Repository: TA-Lib/ta-lib-python Branch: master Commit: 2384b722d617 Files: 62 Total size: 5.6 MB Directory structure: gitextract_70ipxapd/ ├── AUTHORS ├── CHANGELOG ├── CITATION.cff ├── COPYRIGHT ├── DEVELOPMENT ├── Dockerfile ├── LICENSE ├── MANIFEST.in ├── Makefile ├── README.md ├── docs/ │ ├── abstract.md │ ├── doc_index.md │ ├── func.md │ ├── func_groups/ │ │ ├── cycle_indicators.md │ │ ├── math_operators.md │ │ ├── math_transform.md │ │ ├── momentum_indicators.md │ │ ├── overlap_studies.md │ │ ├── pattern_recognition.md │ │ ├── price_transform.md │ │ ├── statistic_functions.md │ │ ├── volatility_indicators.md │ │ └── volume_indicators.md │ ├── funcs.md │ ├── generate_html_pages.py │ ├── index.md │ └── install.md ├── pyproject.toml ├── requirements.txt ├── requirements_dev.txt ├── requirements_test.txt ├── setup.py ├── talib/ │ ├── __init__.py │ ├── _abstract.pxi │ ├── _common.pxi │ ├── _func.pxi │ ├── _stream.pxi │ ├── _ta_lib.c │ ├── _ta_lib.pxd │ ├── _ta_lib.pyi │ ├── _ta_lib.pyx │ ├── abstract.py │ ├── abstract.pyi │ ├── common.pxd │ ├── deprecated.py │ ├── py.typed │ └── stream.py ├── tests/ │ ├── conftest.py │ ├── test_abstract.py │ ├── test_func.py │ ├── test_pandas.py │ ├── test_polars.py │ └── test_stream.py └── tools/ ├── build_talib_linux.sh ├── build_talib_macos.sh ├── build_talib_windows.cmd ├── example.py ├── generate_abstract_stub.py ├── generate_func.py ├── generate_stream.py ├── perf_talib.py └── threads_talib.py ================================================ FILE CONTENTS ================================================ ================================================ FILE: AUTHORS ================================================ Project Founder and Lead Developer: John Benediktsson (https://github.com/mrjbq7) Abstract Interface Author and Maintainer: Brian Cappello (https://github.com/briancappello) ================================================ FILE: CHANGELOG ================================================ 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 - [NEW]: Adding an ``abstract.pyi`` for typing 0.6.8 ===== - [FIX]: Remove accidental cython dependency. - [NEW]: Upgrade to Cython 3.1.5 - [NEW]: Release binaries for Python 3.14 0.6.7 ===== - [NEW]: Upgrade to Cython 3.1.3 - [FIX]: Include .pxd files in the source .tar.gz - [FIX]: Don't require pip, it's not needed - [FIX]: Add back some import compat for backtrader 0.6.6 ===== - [FIX]: Silence project.license warnings when building. - [FIX]: Fix regression in abstract function parameters not coercing integers 0.6.5 ===== - [FIX]: Support PEP-517 style installation - [NEW]: Upgrade to Cython 3.1.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 ====== - [FIX]: Fix build issue with numpy2 released by requiring numpy<2.0.0 for now 0.4.30 ====== - [FIX]: Fix the C library imports to work again on Windows, oops. 0.4.29 ====== - [NEW]: Upgrade to Cython 3.0.10 - [FIX]: Make TA_INCLUDE_PATH and TA_LIBRARY_PATH override default search list - [FIX]: Silent some compiler warnings about const pointers 0.4.28 ====== - [NEW]: Upgrade to Cython 3.0.0 - [FIX]: Use embedsignature to enable code completions? 0.4.27 ====== - [NEW]: Upgrade to Cython 0.29.36 - [FIX]: Fix abstract info to keep values doubles when they are (e.g., nbdevup, nvdevdn) - [FIX]: Don't throw exceptions when inputs are all NaN 0.4.26 ====== - [NEW]: Upgrade to Cython 0.29.34 - [NEW]: Moved to https://github.com/ta-lib/ta-lib-python - [FIX]: Fix deprecation warning for polars.DataFrame(columns=[...]) 0.4.25 ====== - [NEW]: Upgrade to Cython 0.29.32 - [FIX]: Allow Abstract API to be safely used with multithreading 0.4.24 ====== - [FIX]: runtime_lib_dirs preventing install on Windows 0.4.23 ====== - [NEW]: Upgrade to Cython 0.29.25 - [NEW]: Allow TA_INCLUDE_PATH and TA_LIBRARY_PATH to work on Windows. - [FIX]: Remove pyproject.toml which was preventing some installs. 0.4.22 ====== - [NEW]: Upgrade to Cython 0.29.24 - [NEW]: Support polars.Series in Function API - [NEW]: Support polars.Series in Streaming API - [NEW]: Support polars.DataFrame in Abstract API - [NEW]: Switch tests to pytest from nose (no longer supported). 0.4.21 ====== - [FIX]: Fixed {MIN/MAX/MINMAX}INDEX functions to return correct indices. 0.4.20 ====== - [NEW]: Upgrade to Cython 0.29.23 - [FIX]: Fix Homebrew directory on Apple M1 devices 0.4.19 ====== - [NEW]: Upgrade to Cython 0.29.20 - [NEW]: from talib import * (imports all func and stream) - [FIX]: missing method signatures in PyCharm 0.4.18 ====== - [NEW]: Upgrade to Cython 0.29.17 - [NEW]: Support TA_SetCompatibility - [NEW]: Reduce size of generated C file and memory requirements to compile it. - [FIX]: Fixed caching input price series in Abstract API - [NEW]: Support pandas.Series in Streaming API 0.4.17 ====== - [NEW]: Support pandas.Series in Function API 0.4.16 ====== - [FIX]: Fix incorrect C header include on Windows. 0.4.15 ====== - [FIX]: Import TA_FUNC_FLAGS, TA_INPUT_FLAGS, TA_OUTPUT_FLAGS into talib.abstract to support backwards compatibility for backtrader 0.4.14 ====== - [NEW]: Upgrade to Cython 0.27.3 - [NEW]: Add support for set/restore candle settings - [DOC]: Note Function API only supports numpy.ndarray (not pandas.Series) - [NEW]: Continuous integration using Travis on Python 2.7, 3.4, 3.5, 3.6 - [NEW]: Merge common, func, abstract, stream as pxi to _ta_lib.pyx - [DOC]: Update documentation to warn about unstable functions 0.4.10 ====== - [NEW]: Upgrade to Cython 0.23.4. - [NEW]: Adding an experimental Streaming API (talib.stream). - [NEW]: Support for "sunos" - [FIX]: Fix issue initializing library for use with candlestick functions. - [NEW]: Support for TA_SetUnstablePeriod and TA_GetUnstablePeriod 0.4.9 ===== - [NEW]: Support for python 2.6 and earlier for ordereddict. - [FIX]: Add lib64 paths to setup.py. - [NEW]: Upgrade to Cython 0.22. - [FIX]: Allow running setup.py without numpy or cython - [NEW]: Allow TA_LIBRARY_PATH and TA_INCLUDE_PATH environment variables. 0.4.8 ===== - [NEW]: Support pandas.Series and pandas.Dataframe inputs. - [FIX]: Simple check to warn if ta-lib library is not installed - [FIX]: Fix missing key error when inputs are not default names. - [NEW]: Upgrade to Cython 0.20. - [FIX]: Check all input array lengths are same. - [FIX]: Check all input arrays for NaN elements. 0.4.7 ===== - [NEW]: Upgrade to Cython 0.19.1. - [FIX]: Fix "periods" input arrays in abstract interface. - [FIX]: Only require necessary input arrays in abstract interface. 0.4.6 ===== - [NEW]: Support for function_flags and output_flags properties in Functions 0.4.5 ===== - [NEW]: Better test coverage of abstract interface. - [NEW]: Support for Python 3. 0.4.4 ===== - [FIX]: Make installation on Windows easier. 0.4.3 ===== - [NEW]: Upgrade to Cython 0.18. - [FIX]: Improve docstrings for indicators in talib.func. - [FIX]: Initialize and shutdown underlying TA-Lib only once each process. This should give slight speedups when using many indicators (<5%). - [DEPRECATED]: The old moving average types that were in talib.func are now deprecated. See the next bullet item for the replacement, or you can continue using them with "from talib import deprecated" for the time being. - [NEW]: The new moving average types are in talib.MA_Type. It's a class with SMA, EMA, DEMA, etc attribute variables you should now use. Human-readable lookups are also possible by using MA_Type as a dict e.g.: MA_Type[MA_Type.SMA] # returns "Simple Moving Average" - [NEW]: In addition to the existing func interface, we now provide an enhanced abstract interface too. Functions in "import talib" use the original interface, or you can use "from talib import abstract" for the full abstract interface. See the README, tools/example.py and tests/abstract_test.py for more information. The full (commented) source code is mostly located in talib/abstract.pyx. The basic usage is very similar: input_arrays = { 'open': np.random.random(100), 'high': np.random.random(100), 'low': np.random.random(100), 'close': np.random.random(100), 'volume': np.random.random(100) } ema_20 = abstract.Function('ema', input_arrays, 20).outputs # function names not case-sensitive slowd, slowk = abstract.Function('STOCH')(input_arrays, 15, 3, 0, 3, 0) upper, middle, lower = abstract.Function('bbands')(input_arrays, timeperiod=20) 0.4.2 ===== - Move the functions into ``talib.func``, to prepare for ``talib.abstract`` in a future release. 0.4.1 ===== - Support for MacPorts. - Fix for FreeBSD. 0.4.0 ===== First version. ================================================ FILE: CITATION.cff ================================================ cff-version: 1.2.0 message: "If you use this software, please cite it as below." title: ta-lib-python version: 0.6.5 date-released: 2025-08-07 url: "https://github.com/ta-lib/ta-lib-python" type: software authors: - given-names: John family-names: Benediktsson email: mrjbq7@gmail.com ================================================ FILE: COPYRIGHT ================================================ Copyright (C) 2012-2013 Silfur Capital, LLC. All Rights Reserved. The contents of talib/abstract.pyx are Copyright (c) 2013 Brian A Cappello. All Rights Reserved. ================================================ FILE: DEVELOPMENT ================================================ To get started developing on talib, clone the latest code from git and install: ``` $ 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): make build # builds and places libs in the project directory; required for testing make clean # cleans the local build files make install # installs talib system-wide make generate: # generates a fresh _func.pxi, _stream.pxi file. Requires talib and TA-Lib to both be installed make perf # run performance profiling make test # run tests The source code is comprised of one python package, located in the talib directory, which itself has one Cython module (_ta_lib) which consists of four parts: _common, _func, _abstract and _stream. talib/_common.pxi An internal-use file for functionality shared between func and abstract. talib/_func.pxi This file is generated automatically by tools/generate_func.py and any changes made to it directly will get overwritten! talib/_abstract.pxi This file contains the code for interfacing with the TA-Lib abstract interface and wrapping it into a pythonic Function class. talib/_ta_lib.pyx This "Cython header file" defines the C-level functions, variables and types we need to use in the above pyx files. talib/_stream.pxi This file contains code for interfacing a "streaming" interface to TA-Lib. tools/generate_func.py,generate_stream.py Scripts that generate and print _func.pxi or _stream.pxi to stdout. Gets information 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 git. ================================================ FILE: Dockerfile ================================================ # Dockerfile for TA-Lib. To build: # # docker build --rm -t talib . # # To run: # # docker run --rm -it talib bash # ARG PYTHON_VERSION="3.7" FROM python:$PYTHON_VERSION as builder ENV TA_PREFIX="/opt/ta-lib-core" ENV TA_LIBRARY_PATH="$TA_PREFIX/lib" \ TA_INCLUDE_PATH="$TA_PREFIX/include" WORKDIR /src/ta-lib-core RUN apt-get update && apt-get install -y \ gfortran \ libfreetype6-dev \ libhdf5-dev \ liblapack-dev \ libopenblas-dev \ libpng-dev \ && rm -rf /var/lib/apt/lists/* \ && curl -fsSL http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz \ | tar xvz --strip-components 1 \ && ./configure --prefix="$TA_PREFIX" \ && make \ && make install WORKDIR /src/ta-lib-python COPY . . RUN python -m pip install -e . \ && python -c 'import numpy, talib; close = numpy.random.random(100); output = talib.SMA(close); print(output)' \ && python -m pip wheel --wheel-dir wheels . ARG RUN_TESTS="1" RUN if [ "$RUN_TESTS" -ne "0" ]; then \ python -m pip install -r requirements_test.txt \ && pytest . ; \ else \ echo "Skipping tests\n" ; \ fi # Build final image. FROM python:$PYTHON_VERSION-slim COPY --from=builder /src/ta-lib-python/wheels /opt/ta-lib-python/wheels COPY --from=builder /opt/ta-lib-core /opt/ta-lib-core RUN python -m pip install --no-cache-dir /opt/ta-lib-python/wheels/*.whl \ && python -c 'import numpy, talib; close = numpy.random.random(100); output = talib.SMA(close); print(output)' ================================================ FILE: LICENSE ================================================ # 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: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 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. ================================================ FILE: MANIFEST.in ================================================ include LICENSE include COPYRIGHT include README.md include talib/*.c include talib/*.pyx include talib/*.pxd include talib/*.pxi include tests/*.py ================================================ FILE: Makefile ================================================ .PHONY: build build: python3 -m pip install --use-pep517 -e . install: python3 -m pip install --use-pep517 . talib/_func.pxi: tools/generate_func.py python3 tools/generate_func.py > talib/_func.pxi talib/_stream.pxi: tools/generate_stream.py python3 tools/generate_stream.py > talib/_stream.pxi generate: talib/_func.pxi talib/_stream.pxi cython: cython talib/_ta_lib.pyx annotate: cython -a talib/_ta_lib.pyx clean: rm -rf build talib/_ta_lib.so talib/*.pyc perf: python3 tools/perf_talib.py test: build pytest tests/ sdist: python3 -m build --sdist ================================================ FILE: README.md ================================================ # 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: > TA-Lib is widely used by trading software developers requiring to perform > technical analysis of financial market data. > > * Includes 150+ indicators such as ADX, MACD, RSI, Stochastic, Bollinger > Bands, etc. > * Candlestick pattern recognition > * Open-source API for C/C++, Java, Perl, Python and 100% Managed .NET 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 SWIG interface. In addition, this project also supports the use of the [Polars](https://www.pola.rs) and [Pandas](https://pandas.pydata.org) libraries. ## Versions 🗂️ 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: ```shell python -m pip install TA-Lib ``` Or checkout the sources and run `setup.py` yourself: ```shell python setup.py install ``` It also appears possible to install via [Conda Forge](https://anaconda.org/conda-forge/ta-lib): ```shell conda install -c conda-forge ta-lib ``` ### Dependencies 🧩 To use TA-Lib for python, you need to have the [TA-Lib](http://ta-lib.org) already installed. You should probably follow their [installation 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 > library using [the libta-lib package](https://anaconda.org/conda-forge/libta-lib): > > ``$ conda install -c conda-forge libta-lib`` #### Mac OS X You can simply install using Homebrew: ```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: ```shell arch -arm64 brew install ta-lib ``` And perhaps you can set these before installing with `pip`: ```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: ```shell your-arm64-python -m pip install --no-cache-dir ta-lib ``` #### Windows For 64-bit Windows, the easiest way is to get the *executable installer*: 1. Download [ta-lib-0.6.4-windows-x86_64.msi](https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib-0.6.4-windows-x86_64.msi). 2. Run the Installer or run `msiexec` [from the command-line](https://learn.microsoft.com/en-us/windows/win32/msi/standard-installer-command-line-options). Alternatively, if you prefer to get the libraries without installing, or would like to use the 32-bit version: * Intel/AMD 64-bit [ta-lib-0.6.4-windows-x86_64.zip](https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib-0.6.4-windows-x86_64.zip) * Intel/AMD 32-bit [ta-lib-0.6.4-windows-x86_32.zip](https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib-0.6.4-windows-x86_32.zip) #### Linux Download [ta-lib-0.6.4-src.tar.gz](https://github.com/ta-lib/ta-lib/releases/download/v0.6.4/ta-lib-0.6.4-src.tar.gz) and: ```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! > 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. ### 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` 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 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: ```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" | ^~~~~~~~~~~~~~~~~~ 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 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 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, 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" ^ compilation terminated. 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: ```shell sudo apt-get install python3-dev ``` --- 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 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`: ```shell /usr/include/limits.h:26:10: fatal error: bits/libc-header-start.h: No such file or directory #include ^~~~~~~~~~~~~~~~~~~~~~~~~~ ``` This is likely an issue with trying to compile for 32-bit platform but without the appropriate headers. You might find some success looking at the first answer to [this question](https://stackoverflow.com/questions/54082459/fatal-error-bits-libc-header-start-h-no-such-file-or-directory-while-compili). --- 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) ``` You might look at [this question](https://stackoverflow.com/questions/69610572/how-can-i-solve-the-below-error-while-importing-nltk-package) 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`: ```python >>> import talib >>> import numpy as np >>> c = np.random.randn(100) # this is the library function >>> k, d = talib.STOCHRSI(c) # this produces the same result, calling STOCHF >>> rsi = talib.RSI(c) >>> k, d = talib.STOCHF(rsi, rsi, rsi) # you might want this instead, calling STOCH >>> rsi = talib.RSI(c) >>> k, d = talib.STOCH(rsi, rsi, rsi) ``` --- 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 ``` --- 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" ^ compilation terminated 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: ```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 underlying TA-Lib C library sources: ```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' ``` 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 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`. 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: ```python import numpy as np import talib close = np.random.random(100) ``` Calculate a simple moving average of the close prices: ```python output = talib.SMA(close) ``` Calculating bollinger bands, with triple exponential moving average: ```python from talib import MA_Type upper, middle, lower = talib.BBANDS(close, matype=MA_Type.T3) ``` Calculating momentum of the close prices, with a time period of 5: ```python output = talib.MOM(close, timeperiod=5) ``` ### 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: ```python >>> c = np.array([1.0, 2.0, 3.0, np.nan, 4.0, 5.0, 6.0]) >>> talib.SMA(c, 3) array([nan, nan, 2., nan, nan, nan, nan]) ``` You can compare that to a Pandas rolling mean, where their approach is to output NaN until enough "lookback" values are observed to generate new outputs: ```python >>> c = pandas.Series([1.0, 2.0, 3.0, np.nan, 4.0, 5.0, 6.0]) >>> c.rolling(3).mean() 0 NaN 1 NaN 2 2.0 3 NaN 4 NaN 5 NaN 6 5.0 dtype: float64 ``` ## Abstract API If you're already familiar with using the function API, you should feel right at home using the Abstract API. Every function takes a collection of named inputs, either a ``dict`` of ``numpy.ndarray`` or ``pandas.Series`` or ``polars.Series``, or a ``pandas.DataFrame`` or ``polars.DataFrame``. If a ``pandas.DataFrame`` or ``polars.DataFrame`` is provided, the output is returned as the same type with named output columns. For example, inputs could be provided for the typical "OHLCV" data: ```python import numpy as np # note that all ndarrays must be the same length! inputs = { 'open': np.random.random(100), 'high': np.random.random(100), 'low': np.random.random(100), 'close': np.random.random(100), 'volume': np.random.random(100) } ``` Functions can either be imported directly or instantiated by name: ```python from talib import abstract # directly SMA = abstract.SMA # or by name SMA = abstract.Function('sma') ``` From there, calling functions is basically the same as the function API: ```python from talib.abstract import * # uses close prices (default) output = SMA(inputs, timeperiod=25) # uses open prices output = SMA(inputs, timeperiod=25, price='open') # uses close prices (default) upper, middle, lower = BBANDS(inputs, 20, 2.0, 2.0) # uses high, low, close (default) slowk, slowd = STOCH(inputs, 5, 3, 0, 3, 0) # uses high, low, close by default # uses high, low, open instead slowk, slowd = STOCH(inputs, 5, 3, 0, 3, 0, prices=['high', 'low', 'open']) ``` ## Streaming API An experimental Streaming API was added that allows users to compute the latest value of an indicator. This can be faster than using the Function API, for example in an application that receives streaming data, and wants to know just the most recent updated indicator value. ```python import talib from talib import stream close = np.random.random(100) # the Function API output = talib.SMA(close) # the Streaming API latest = stream.SMA(close) # the latest value is the same as the last output value assert (output[-1] - latest) < 0.00001 ``` ## 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", etc): ```python import talib # list of functions for name in talib.get_functions(): print(name) # dict of functions by group for group, names in talib.get_function_groups().items(): print(group) for name in names: print(f" {name}") ``` ### Indicator Groups 🏷️ * Overlap Studies * Momentum Indicators * Volume Indicators * Volatility Indicators * Price Transform * Cycle Indicators * Pattern Recognition #### Overlap Studies ```text BBANDS Bollinger Bands DEMA Double Exponential Moving Average EMA Exponential Moving Average HT_TRENDLINE Hilbert Transform - Instantaneous Trendline KAMA Kaufman Adaptive Moving Average MA Moving average MAMA MESA Adaptive Moving Average MAVP Moving average with variable period MIDPOINT MidPoint over period MIDPRICE Midpoint Price over period SAR Parabolic SAR SAREXT Parabolic SAR - Extended SMA Simple Moving Average T3 Triple Exponential Moving Average (T3) TEMA Triple Exponential Moving Average TRIMA Triangular Moving Average WMA Weighted Moving Average ``` #### Momentum Indicators ```text ADX Average Directional Movement Index ADXR Average Directional Movement Index Rating APO Absolute Price Oscillator AROON Aroon AROONOSC Aroon Oscillator BOP Balance Of Power CCI Commodity Channel Index CMO Chande Momentum Oscillator DX Directional Movement Index MACD Moving Average Convergence/Divergence MACDEXT MACD with controllable MA type MACDFIX Moving Average Convergence/Divergence Fix 12/26 MFI Money Flow Index MINUS_DI Minus Directional Indicator MINUS_DM Minus Directional Movement MOM Momentum PLUS_DI Plus Directional Indicator PLUS_DM Plus Directional Movement PPO Percentage Price Oscillator ROC Rate of change : ((price/prevPrice)-1)*100 ROCP Rate of change Percentage: (price-prevPrice)/prevPrice ROCR Rate of change ratio: (price/prevPrice) ROCR100 Rate of change ratio 100 scale: (price/prevPrice)*100 RSI Relative Strength Index STOCH Stochastic STOCHF Stochastic Fast STOCHRSI Stochastic Relative Strength Index TRIX 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA ULTOSC Ultimate Oscillator WILLR Williams' %R ``` #### Volume Indicators ```text AD Chaikin A/D Line ADOSC Chaikin A/D Oscillator OBV On Balance Volume ``` #### Cycle Indicators ```text HT_DCPERIOD Hilbert Transform - Dominant Cycle Period HT_DCPHASE Hilbert Transform - Dominant Cycle Phase HT_PHASOR Hilbert Transform - Phasor Components HT_SINE Hilbert Transform - SineWave HT_TRENDMODE Hilbert Transform - Trend vs Cycle Mode ``` #### Price Transform ```text AVGPRICE Average Price MEDPRICE Median Price TYPPRICE Typical Price WCLPRICE Weighted Close Price ``` #### Volatility Indicators ```text ATR Average True Range NATR Normalized Average True Range TRANGE True Range ``` #### Pattern Recognition ```text CDL2CROWS Two Crows CDL3BLACKCROWS Three Black Crows CDL3INSIDE Three Inside Up/Down CDL3LINESTRIKE Three-Line Strike CDL3OUTSIDE Three Outside Up/Down CDL3STARSINSOUTH Three Stars In The South CDL3WHITESOLDIERS Three Advancing White Soldiers CDLABANDONEDBABY Abandoned Baby CDLADVANCEBLOCK Advance Block CDLBELTHOLD Belt-hold CDLBREAKAWAY Breakaway CDLCLOSINGMARUBOZU Closing Marubozu CDLCONCEALBABYSWALL Concealing Baby Swallow CDLCOUNTERATTACK Counterattack CDLDARKCLOUDCOVER Dark Cloud Cover CDLDOJI Doji CDLDOJISTAR Doji Star CDLDRAGONFLYDOJI Dragonfly Doji CDLENGULFING Engulfing Pattern CDLEVENINGDOJISTAR Evening Doji Star CDLEVENINGSTAR Evening Star CDLGAPSIDESIDEWHITE Up/Down-gap side-by-side white lines CDLGRAVESTONEDOJI Gravestone Doji CDLHAMMER Hammer CDLHANGINGMAN Hanging Man CDLHARAMI Harami Pattern CDLHARAMICROSS Harami Cross Pattern CDLHIGHWAVE High-Wave Candle CDLHIKKAKE Hikkake Pattern CDLHIKKAKEMOD Modified Hikkake Pattern CDLHOMINGPIGEON Homing Pigeon CDLIDENTICAL3CROWS Identical Three Crows CDLINNECK In-Neck Pattern CDLINVERTEDHAMMER Inverted Hammer CDLKICKING Kicking CDLKICKINGBYLENGTH Kicking - bull/bear determined by the longer marubozu CDLLADDERBOTTOM Ladder Bottom CDLLONGLEGGEDDOJI Long Legged Doji CDLLONGLINE Long Line Candle CDLMARUBOZU Marubozu CDLMATCHINGLOW Matching Low CDLMATHOLD Mat Hold CDLMORNINGDOJISTAR Morning Doji Star CDLMORNINGSTAR Morning Star CDLONNECK On-Neck Pattern CDLPIERCING Piercing Pattern CDLRICKSHAWMAN Rickshaw Man CDLRISEFALL3METHODS Rising/Falling Three Methods CDLSEPARATINGLINES Separating Lines CDLSHOOTINGSTAR Shooting Star CDLSHORTLINE Short Line Candle CDLSPINNINGTOP Spinning Top CDLSTALLEDPATTERN Stalled Pattern CDLSTICKSANDWICH Stick Sandwich CDLTAKURI Takuri (Dragonfly Doji with very long lower shadow) CDLTASUKIGAP Tasuki Gap CDLTHRUSTING Thrusting Pattern CDLTRISTAR Tristar Pattern CDLUNIQUE3RIVER Unique 3 River CDLUPSIDEGAP2CROWS Upside Gap Two Crows CDLXSIDEGAP3METHODS Upside/Downside Gap Three Methods ``` #### Statistic Functions ```text BETA Beta CORREL Pearson's Correlation Coefficient (r) LINEARREG Linear Regression LINEARREG_ANGLE Linear Regression Angle LINEARREG_INTERCEPT Linear Regression Intercept LINEARREG_SLOPE Linear Regression Slope STDDEV Standard Deviation TSF Time Series Forecast VAR Variance ``` ================================================ FILE: docs/abstract.md ================================================ # Abstract API Quick Start If you're already familiar with using the function API, you should feel right at home using the abstract API. Every function takes the same input, passed as a dictionary of Numpy arrays: ```python import numpy as np # note that all ndarrays must be the same length! inputs = { 'open': np.random.random(100), 'high': np.random.random(100), 'low': np.random.random(100), 'close': np.random.random(100), 'volume': np.random.random(100) } ``` Functions can either be imported directly or instantiated by name: ```python from talib import abstract sma = abstract.SMA sma = abstract.Function('sma') ``` From there, calling functions is basically the same as the function API: ```python from talib.abstract import * output = SMA(inputs, timeperiod=25) # calculate on close prices by default output = SMA(inputs, timeperiod=25, price='open') # calculate on opens upper, middle, lower = BBANDS(inputs, 20, 2, 2) slowk, slowd = STOCH(inputs, 5, 3, 0, 3, 0) # uses high, low, close by default slowk, slowd = STOCH(inputs, 5, 3, 0, 3, 0, prices=['high', 'low', 'open']) ``` ## Advanced Usage For more advanced use cases of TA-Lib, the Abstract API also offers much more flexibility. You can even subclass ``abstract.Function`` and override ``set_input_arrays`` to customize the type of input data Function accepts (e.g. a pandas DataFrame). Details about every function can be accessed via the info property: ```python print Function('stoch').info { 'name': 'STOCH', 'display_name': 'Stochastic', 'group': 'Momentum Indicators', 'input_names': OrderedDict([ ('prices', ['high', 'low', 'close']), ]), 'parameters': OrderedDict([ ('fastk_period', 5), ('slowk_period', 3), ('slowk_matype', 0), ('slowd_period', 3), ('slowd_matype', 0), ]), 'output_names': ['slowk', 'slowd'], } ``` Or in human-readable format: ```python help(STOCH) str(STOCH) ``` Other useful properties of ``Function``: ```python Function('x').function_flags Function('x').input_names Function('x').input_arrays Function('x').parameters Function('x').lookback Function('x').output_names Function('x').output_flags Function('x').outputs ``` Aside from calling the function directly, Functions maintain state and will remember their parameters/input_arrays after they've been set. You can set parameters and recalculate with new input data using run(): ```python SMA.parameters = {'timeperiod': 15} result1 = SMA.run(input_arrays1) result2 = SMA.run(input_arrays2) # Or set input_arrays and change the parameters: SMA.input_arrays = input_arrays1 ma10 = SMA(timeperiod=10) ma20 = SMA(20) ``` For more details, take a look at the [code](https://github.com/ta-lib/ta-lib-python/blob/master/talib/abstract.pyx#L46). [Documentation Index](doc_index.md) ================================================ FILE: docs/doc_index.md ================================================ # Documentation * [Installation and Troubleshooting](install.md) * [Using the Function API](func.md) * [Using the Abstract API](abstract.md) * [All Functions](funcs.md) * [Overlap Studies](func_groups/overlap_studies.md) * [Momentum Indicators](func_groups/momentum_indicators.md) * [Volume Indicators](func_groups/volume_indicators.md) * [Volatility Indicators](func_groups/volatility_indicators.md) * [Price Transform](func_groups/price_transform.md) * [Cycle Indicators](func_groups/cycle_indicators.md) * [Pattern Recognition](func_groups/pattern_recognition.md) * [Statistic Functions](func_groups/statistic_functions.md) * [Math Transform](func_groups/math_transform.md) * [Math Operators](func_groups/math_operators.md) ================================================ FILE: docs/func.md ================================================ # Function API Examples Similar to TA-Lib, the function interface provides a lightweight wrapper of the 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``. All of the following examples use the function API: ```python import numpy import talib close = numpy.random.random(100) ``` Calculate a simple moving average of the close prices: ```python output = talib.SMA(close) ``` Calculating bollinger bands, with triple exponential moving average: ```python from talib import MA_Type upper, middle, lower = talib.BBANDS(close, matype=MA_Type.T3) ``` Calculating momentum of the close prices, with a time period of 5: ```python output = talib.MOM(close, timeperiod=5) ``` Documentation for all functions: * [Overlap Studies](func_groups/overlap_studies.md) * [Momentum Indicators](func_groups/momentum_indicators.md) * [Volume Indicators](func_groups/volume_indicators.md) * [Volatility Indicators](func_groups/volatility_indicators.md) * [Pattern Recognition](func_groups/pattern_recognition.md) * [Cycle Indicators](func_groups/cycle_indicators.md) * [Statistic Functions](func_groups/statistic_functions.md) * [Price Transform](func_groups/price_transform.md) * [Math Transform](func_groups/math_transform.md) * [Math Operators](func_groups/math_operators.md) [Documentation Index](doc_index.md) [FLOAT_RIGHTNext: Using the Abstract API](abstract.md) ================================================ FILE: docs/func_groups/cycle_indicators.md ================================================ # Cycle Indicator Functions ### HT_DCPERIOD - Hilbert Transform - Dominant Cycle Period NOTE: The ``HT_DCPERIOD`` function has an unstable period. ```python real = HT_DCPERIOD(real) ``` ### HT_DCPHASE - Hilbert Transform - Dominant Cycle Phase NOTE: The ``HT_DCPHASE`` function has an unstable period. ```python real = HT_DCPHASE(real) ``` ### HT_PHASOR - Hilbert Transform - Phasor Components NOTE: The ``HT_PHASOR`` function has an unstable period. ```python inphase, quadrature = HT_PHASOR(real) ``` ### HT_SINE - Hilbert Transform - SineWave NOTE: The ``HT_SINE`` function has an unstable period. ```python 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(real) ``` [Documentation Index](../doc_index.md) [FLOAT_RIGHTAll Function Groups](../funcs.md) ================================================ FILE: docs/func_groups/math_operators.md ================================================ # Math Operator Functions ### ADD - Vector Arithmetic Add ```python real = ADD(real0, real1) ``` ### DIV - Vector Arithmetic Div ```python real = DIV(real0, real1) ``` ### MAX - Highest value over a specified period ```python real = MAX(real, timeperiod=30) ``` ### MAXINDEX - Index of highest value over a specified period ```python integer = MAXINDEX(real, timeperiod=30) ``` ### MIN - Lowest value over a specified period ```python real = MIN(real, timeperiod=30) ``` ### MININDEX - Index of lowest value over a specified period ```python integer = MININDEX(real, timeperiod=30) ``` ### MINMAX - Lowest and highest values over a specified period ```python min, max = MINMAX(real, timeperiod=30) ``` ### MINMAXINDEX - Indexes of lowest and highest values over a specified period ```python minidx, maxidx = MINMAXINDEX(real, timeperiod=30) ``` ### MULT - Vector Arithmetic Mult ```python real = MULT(real0, real1) ``` ### SUB - Vector Arithmetic Subtraction ```python real = SUB(real0, real1) ``` ### SUM - Summation ```python real = SUM(real, timeperiod=30) ``` [Documentation Index](../doc_index.md) [FLOAT_RIGHTAll Function Groups](../funcs.md) ================================================ FILE: docs/func_groups/math_transform.md ================================================ # Math Transform Functions ### ACOS - Vector Trigonometric ACos ```python real = ACOS(real) ``` ### ASIN - Vector Trigonometric ASin ```python real = ASIN(real) ``` ### ATAN - Vector Trigonometric ATan ```python real = ATAN(real) ``` ### CEIL - Vector Ceil ```python real = CEIL(real) ``` ### COS - Vector Trigonometric Cos ```python real = COS(real) ``` ### COSH - Vector Trigonometric Cosh ```python real = COSH(real) ``` ### EXP - Vector Arithmetic Exp ```python real = EXP(real) ``` ### FLOOR - Vector Floor ```python real = FLOOR(real) ``` ### LN - Vector Log Natural ```python real = LN(real) ``` ### LOG10 - Vector Log10 ```python real = LOG10(real) ``` ### SIN - Vector Trigonometric Sin ```python real = SIN(real) ``` ### SINH - Vector Trigonometric Sinh ```python real = SINH(real) ``` ### SQRT - Vector Square Root ```python real = SQRT(real) ``` ### TAN - Vector Trigonometric Tan ```python real = TAN(real) ``` ### TANH - Vector Trigonometric Tanh ```python real = TANH(real) ``` [Documentation Index](../doc_index.md) [FLOAT_RIGHTAll Function Groups](../funcs.md) ================================================ FILE: docs/func_groups/momentum_indicators.md ================================================ # Momentum Indicator Functions ### ADX - Average Directional Movement Index NOTE: The ``ADX`` function has an unstable period. ```python real = ADX(high, low, close, timeperiod=14) ``` ### ADXR - Average Directional Movement Index Rating NOTE: The ``ADXR`` function has an unstable period. ```python real = ADXR(high, low, close, timeperiod=14) ``` ### APO - Absolute Price Oscillator ```python real = APO(real, fastperiod=12, slowperiod=26, matype=0) ``` ### AROON - Aroon ```python aroondown, aroonup = AROON(high, low, timeperiod=14) ``` ### AROONOSC - Aroon Oscillator ```python real = AROONOSC(high, low, timeperiod=14) ``` ### BOP - Balance Of Power ```python real = BOP(open, high, low, close) ``` ### CCI - Commodity Channel Index ```python real = CCI(high, low, close, timeperiod=14) ``` ### CMO - Chande Momentum Oscillator NOTE: The ``CMO`` function has an unstable period. ```python real = CMO(real, timeperiod=14) ``` ### DX - Directional Movement Index NOTE: The ``DX`` function has an unstable period. ```python real = DX(high, low, close, timeperiod=14) ``` ### IMI - Intraday Momentum Index NOTE: The ``IMI`` function has an unstable period. ```python real = IMI(open, close, timeperiod=14) ``` ### MACD - Moving Average Convergence/Divergence ```python macd, macdsignal, macdhist = MACD(real, fastperiod=12, slowperiod=26, signalperiod=9) ``` ### MACDEXT - MACD with controllable MA type ```python 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(real, signalperiod=9) ``` ### MFI - Money Flow Index NOTE: The ``MFI`` function has an unstable period. ```python real = MFI(high, low, close, volume, timeperiod=14) ``` ### MINUS_DI - Minus Directional Indicator NOTE: The ``MINUS_DI`` function has an unstable period. ```python real = MINUS_DI(high, low, close, timeperiod=14) ``` ### MINUS_DM - Minus Directional Movement NOTE: The ``MINUS_DM`` function has an unstable period. ```python real = MINUS_DM(high, low, timeperiod=14) ``` ### MOM - Momentum ```python real = MOM(real, timeperiod=10) ``` ### PLUS_DI - Plus Directional Indicator NOTE: The ``PLUS_DI`` function has an unstable period. ```python real = PLUS_DI(high, low, close, timeperiod=14) ``` ### PLUS_DM - Plus Directional Movement NOTE: The ``PLUS_DM`` function has an unstable period. ```python real = PLUS_DM(high, low, timeperiod=14) ``` ### PPO - Percentage Price Oscillator ```python real = PPO(real, fastperiod=12, slowperiod=26, matype=0) ``` ### ROC - Rate of change : ((price/prevPrice)-1)*100 ```python real = ROC(real, timeperiod=10) ``` ### ROCP - Rate of change Percentage: (price-prevPrice)/prevPrice ```python real = ROCP(real, timeperiod=10) ``` ### ROCR - Rate of change ratio: (price/prevPrice) ```python real = ROCR(real, timeperiod=10) ``` ### ROCR100 - Rate of change ratio 100 scale: (price/prevPrice)*100 ```python real = ROCR100(real, timeperiod=10) ``` ### RSI - Relative Strength Index NOTE: The ``RSI`` function has an unstable period. ```python real = RSI(real, timeperiod=14) ``` ### STOCH - Stochastic ```python slowk, slowd = STOCH(high, low, close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0) ``` ### STOCHF - Stochastic Fast ```python fastk, fastd = STOCHF(high, low, close, fastk_period=5, fastd_period=3, fastd_matype=0) ``` ### STOCHRSI - Stochastic Relative Strength Index NOTE: The ``STOCHRSI`` function has an unstable period. ```python 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(real, timeperiod=30) ``` ### ULTOSC - Ultimate Oscillator ```python real = ULTOSC(high, low, close, timeperiod1=7, timeperiod2=14, timeperiod3=28) ``` ### WILLR - Williams' %R ```python real = WILLR(high, low, close, timeperiod=14) ``` [Documentation Index](../doc_index.md) [FLOAT_RIGHTAll Function Groups](../funcs.md) ================================================ FILE: docs/func_groups/overlap_studies.md ================================================ # Overlap Studies Functions ### ACCBANDS - Acceleration Bands ```python upperband, middleband, lowerband = ACCBANDS(high, low, close, timeperiod=20) ``` ### BBANDS - Bollinger Bands ```python upperband, middleband, lowerband = BBANDS(real, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0) ``` ### DEMA - Double Exponential Moving Average ```python real = DEMA(real, timeperiod=30) ``` ### EMA - Exponential Moving Average NOTE: The ``EMA`` function has an unstable period. ```python real = EMA(real, timeperiod=30) ``` ### HT_TRENDLINE - Hilbert Transform - Instantaneous Trendline NOTE: The ``HT_TRENDLINE`` function has an unstable period. ```python real = HT_TRENDLINE(real) ``` ### KAMA - Kaufman Adaptive Moving Average NOTE: The ``KAMA`` function has an unstable period. ```python real = KAMA(real, timeperiod=30) ``` ### MA - Moving average ```python real = MA(real, timeperiod=30, matype=0) ``` ### MAMA - MESA Adaptive Moving Average NOTE: The ``MAMA`` function has an unstable period. ```python mama, fama = MAMA(real, fastlimit=0, slowlimit=0) ``` ### MAVP - Moving average with variable period ```python real = MAVP(real, periods, minperiod=2, maxperiod=30, matype=0) ``` ### MIDPOINT - MidPoint over period ```python real = MIDPOINT(real, timeperiod=14) ``` ### MIDPRICE - Midpoint Price over period ```python real = MIDPRICE(high, low, timeperiod=14) ``` ### SAR - Parabolic SAR ```python real = SAR(high, low, acceleration=0, maximum=0) ``` ### SAREXT - Parabolic SAR - Extended ```python real = SAREXT(high, low, startvalue=0, offsetonreverse=0, accelerationinitlong=0, accelerationlong=0, accelerationmaxlong=0, accelerationinitshort=0, accelerationshort=0, accelerationmaxshort=0) ``` ### SMA - Simple Moving Average ```python real = SMA(real, timeperiod=30) ``` ### T3 - Triple Exponential Moving Average (T3) NOTE: The ``T3`` function has an unstable period. ```python real = T3(real, timeperiod=5, vfactor=0) ``` ### TEMA - Triple Exponential Moving Average ```python real = TEMA(real, timeperiod=30) ``` ### TRIMA - Triangular Moving Average ```python real = TRIMA(real, timeperiod=30) ``` ### WMA - Weighted Moving Average ```python real = WMA(real, timeperiod=30) ``` [Documentation Index](../doc_index.md) [FLOAT_RIGHTAll Function Groups](../funcs.md) ================================================ FILE: docs/func_groups/pattern_recognition.md ================================================ # Pattern Recognition Functions ### CDL2CROWS - Two Crows ```python integer = CDL2CROWS(open, high, low, close) ``` ### CDL3BLACKCROWS - Three Black Crows ```python integer = CDL3BLACKCROWS(open, high, low, close) ``` ### CDL3INSIDE - Three Inside Up/Down ```python integer = CDL3INSIDE(open, high, low, close) ``` ### CDL3LINESTRIKE - Three-Line Strike ```python integer = CDL3LINESTRIKE(open, high, low, close) ``` ### CDL3OUTSIDE - Three Outside Up/Down ```python integer = CDL3OUTSIDE(open, high, low, close) ``` ### CDL3STARSINSOUTH - Three Stars In The South ```python integer = CDL3STARSINSOUTH(open, high, low, close) ``` ### CDL3WHITESOLDIERS - Three Advancing White Soldiers ```python integer = CDL3WHITESOLDIERS(open, high, low, close) ``` ### CDLABANDONEDBABY - Abandoned Baby ```python integer = CDLABANDONEDBABY(open, high, low, close, penetration=0) ``` ### CDLADVANCEBLOCK - Advance Block ```python integer = CDLADVANCEBLOCK(open, high, low, close) ``` ### CDLBELTHOLD - Belt-hold ```python integer = CDLBELTHOLD(open, high, low, close) ``` ### CDLBREAKAWAY - Breakaway ```python integer = CDLBREAKAWAY(open, high, low, close) ``` ### CDLCLOSINGMARUBOZU - Closing Marubozu ```python integer = CDLCLOSINGMARUBOZU(open, high, low, close) ``` ### CDLCONCEALBABYSWALL - Concealing Baby Swallow ```python integer = CDLCONCEALBABYSWALL(open, high, low, close) ``` ### CDLCOUNTERATTACK - Counterattack ```python integer = CDLCOUNTERATTACK(open, high, low, close) ``` ### CDLDARKCLOUDCOVER - Dark Cloud Cover ```python integer = CDLDARKCLOUDCOVER(open, high, low, close, penetration=0) ``` ### CDLDOJI - Doji ```python integer = CDLDOJI(open, high, low, close) ``` ### CDLDOJISTAR - Doji Star ```python integer = CDLDOJISTAR(open, high, low, close) ``` ### CDLDRAGONFLYDOJI - Dragonfly Doji ```python integer = CDLDRAGONFLYDOJI(open, high, low, close) ``` ### CDLENGULFING - Engulfing Pattern ```python integer = CDLENGULFING(open, high, low, close) ``` ### CDLEVENINGDOJISTAR - Evening Doji Star ```python integer = CDLEVENINGDOJISTAR(open, high, low, close, penetration=0) ``` ### CDLEVENINGSTAR - Evening Star ```python integer = CDLEVENINGSTAR(open, high, low, close, penetration=0) ``` ### CDLGAPSIDESIDEWHITE - Up/Down-gap side-by-side white lines ```python integer = CDLGAPSIDESIDEWHITE(open, high, low, close) ``` ### CDLGRAVESTONEDOJI - Gravestone Doji ```python integer = CDLGRAVESTONEDOJI(open, high, low, close) ``` ### CDLHAMMER - Hammer ```python integer = CDLHAMMER(open, high, low, close) ``` ### CDLHANGINGMAN - Hanging Man ```python integer = CDLHANGINGMAN(open, high, low, close) ``` ### CDLHARAMI - Harami Pattern ```python integer = CDLHARAMI(open, high, low, close) ``` ### CDLHARAMICROSS - Harami Cross Pattern ```python integer = CDLHARAMICROSS(open, high, low, close) ``` ### CDLHIGHWAVE - High-Wave Candle ```python integer = CDLHIGHWAVE(open, high, low, close) ``` ### CDLHIKKAKE - Hikkake Pattern ```python integer = CDLHIKKAKE(open, high, low, close) ``` ### CDLHIKKAKEMOD - Modified Hikkake Pattern ```python integer = CDLHIKKAKEMOD(open, high, low, close) ``` ### CDLHOMINGPIGEON - Homing Pigeon ```python integer = CDLHOMINGPIGEON(open, high, low, close) ``` ### CDLIDENTICAL3CROWS - Identical Three Crows ```python integer = CDLIDENTICAL3CROWS(open, high, low, close) ``` ### CDLINNECK - In-Neck Pattern ```python integer = CDLINNECK(open, high, low, close) ``` ### CDLINVERTEDHAMMER - Inverted Hammer ```python integer = CDLINVERTEDHAMMER(open, high, low, close) ``` ### CDLKICKING - Kicking ```python integer = CDLKICKING(open, high, low, close) ``` ### CDLKICKINGBYLENGTH - Kicking - bull/bear determined by the longer marubozu ```python integer = CDLKICKINGBYLENGTH(open, high, low, close) ``` ### CDLLADDERBOTTOM - Ladder Bottom ```python integer = CDLLADDERBOTTOM(open, high, low, close) ``` ### CDLLONGLEGGEDDOJI - Long Legged Doji ```python integer = CDLLONGLEGGEDDOJI(open, high, low, close) ``` ### CDLLONGLINE - Long Line Candle ```python integer = CDLLONGLINE(open, high, low, close) ``` ### CDLMARUBOZU - Marubozu ```python integer = CDLMARUBOZU(open, high, low, close) ``` ### CDLMATCHINGLOW - Matching Low ```python integer = CDLMATCHINGLOW(open, high, low, close) ``` ### CDLMATHOLD - Mat Hold ```python integer = CDLMATHOLD(open, high, low, close, penetration=0) ``` ### CDLMORNINGDOJISTAR - Morning Doji Star ```python integer = CDLMORNINGDOJISTAR(open, high, low, close, penetration=0) ``` ### CDLMORNINGSTAR - Morning Star ```python integer = CDLMORNINGSTAR(open, high, low, close, penetration=0) ``` ### CDLONNECK - On-Neck Pattern ```python integer = CDLONNECK(open, high, low, close) ``` ### CDLPIERCING - Piercing Pattern ```python integer = CDLPIERCING(open, high, low, close) ``` ### CDLRICKSHAWMAN - Rickshaw Man ```python integer = CDLRICKSHAWMAN(open, high, low, close) ``` ### CDLRISEFALL3METHODS - Rising/Falling Three Methods ```python integer = CDLRISEFALL3METHODS(open, high, low, close) ``` ### CDLSEPARATINGLINES - Separating Lines ```python integer = CDLSEPARATINGLINES(open, high, low, close) ``` ### CDLSHOOTINGSTAR - Shooting Star ```python integer = CDLSHOOTINGSTAR(open, high, low, close) ``` ### CDLSHORTLINE - Short Line Candle ```python integer = CDLSHORTLINE(open, high, low, close) ``` ### CDLSPINNINGTOP - Spinning Top ```python integer = CDLSPINNINGTOP(open, high, low, close) ``` ### CDLSTALLEDPATTERN - Stalled Pattern ```python integer = CDLSTALLEDPATTERN(open, high, low, close) ``` ### CDLSTICKSANDWICH - Stick Sandwich ```python integer = CDLSTICKSANDWICH(open, high, low, close) ``` ### CDLTAKURI - Takuri (Dragonfly Doji with very long lower shadow) ```python integer = CDLTAKURI(open, high, low, close) ``` ### CDLTASUKIGAP - Tasuki Gap ```python integer = CDLTASUKIGAP(open, high, low, close) ``` ### CDLTHRUSTING - Thrusting Pattern ```python integer = CDLTHRUSTING(open, high, low, close) ``` ### CDLTRISTAR - Tristar Pattern ```python integer = CDLTRISTAR(open, high, low, close) ``` ### CDLUNIQUE3RIVER - Unique 3 River ```python integer = CDLUNIQUE3RIVER(open, high, low, close) ``` ### CDLUPSIDEGAP2CROWS - Upside Gap Two Crows ```python integer = CDLUPSIDEGAP2CROWS(open, high, low, close) ``` ### CDLXSIDEGAP3METHODS - Upside/Downside Gap Three Methods ```python integer = CDLXSIDEGAP3METHODS(open, high, low, close) ``` [Documentation Index](../doc_index.md) [FLOAT_RIGHTAll Function Groups](../funcs.md) ================================================ FILE: docs/func_groups/price_transform.md ================================================ # Price Transform Functions ### AVGDEV - Average Deviation ```python real = AVGDEV(real, timeperiod=14) ``` ### AVGPRICE - Average Price ```python real = AVGPRICE(open, high, low, close) ``` ### MEDPRICE - Median Price ```python real = MEDPRICE(high, low) ``` ### TYPPRICE - Typical Price ```python real = TYPPRICE(high, low, close) ``` ### WCLPRICE - Weighted Close Price ```python real = WCLPRICE(high, low, close) ``` [Documentation Index](../doc_index.md) [FLOAT_RIGHTAll Function Groups](../funcs.md) ================================================ FILE: docs/func_groups/statistic_functions.md ================================================ # Statistic Functions ### BETA - Beta ```python real = BETA(real0, real1, timeperiod=5) ``` ### CORREL - Pearson's Correlation Coefficient (r) ```python real = CORREL(real0, real1, timeperiod=30) ``` ### LINEARREG - Linear Regression ```python real = LINEARREG(real, timeperiod=14) ``` ### LINEARREG_ANGLE - Linear Regression Angle ```python real = LINEARREG_ANGLE(real, timeperiod=14) ``` ### LINEARREG_INTERCEPT - Linear Regression Intercept ```python real = LINEARREG_INTERCEPT(real, timeperiod=14) ``` ### LINEARREG_SLOPE - Linear Regression Slope ```python real = LINEARREG_SLOPE(real, timeperiod=14) ``` ### STDDEV - Standard Deviation ```python real = STDDEV(real, timeperiod=5, nbdev=1) ``` ### TSF - Time Series Forecast ```python real = TSF(real, timeperiod=14) ``` ### VAR - Variance ```python real = VAR(real, timeperiod=5, nbdev=1) ``` [Documentation Index](../doc_index.md) [FLOAT_RIGHTAll Function Groups](../funcs.md) ================================================ FILE: docs/func_groups/volatility_indicators.md ================================================ # Volatility Indicator Functions ### ATR - Average True Range NOTE: The ``ATR`` function has an unstable period. ```python real = ATR(high, low, close, timeperiod=14) ``` ### NATR - Normalized Average True Range NOTE: The ``NATR`` function has an unstable period. ```python real = NATR(high, low, close, timeperiod=14) ``` ### TRANGE - True Range ```python real = TRANGE(high, low, close) ``` [Documentation Index](../doc_index.md) [FLOAT_RIGHTAll Function Groups](../funcs.md) ================================================ FILE: docs/func_groups/volume_indicators.md ================================================ # Volume Indicator Functions ### AD - Chaikin A/D Line ```python real = AD(high, low, close, volume) ``` ### ADOSC - Chaikin A/D Oscillator ```python real = ADOSC(high, low, close, volume, fastperiod=3, slowperiod=10) ``` ### OBV - On Balance Volume ```python real = OBV(close, volume) ``` [Documentation Index](../doc_index.md) [FLOAT_RIGHTAll Function Groups](../funcs.md) ================================================ FILE: docs/funcs.md ================================================ # All Supported Indicators and Functions * [Overlap Studies](func_groups/overlap_studies.md) * [Momentum Indicators](func_groups/momentum_indicators.md) * [Volume Indicators](func_groups/volume_indicators.md) * [Volatility Indicators](func_groups/volatility_indicators.md) * [Price Transform](func_groups/price_transform.md) * [Cycle Indicators](func_groups/cycle_indicators.md) * [Pattern Recognition](func_groups/pattern_recognition.md) * [Statistic Functions](func_groups/statistic_functions.md) * [Math Transform](func_groups/math_transform.md) * [Math Operators](func_groups/math_operators.md) #### [Overlap Studies](func_groups/overlap_studies.md) ``` BBANDS Bollinger Bands DEMA Double Exponential Moving Average EMA Exponential Moving Average HT_TRENDLINE Hilbert Transform - Instantaneous Trendline KAMA Kaufman Adaptive Moving Average MA Moving average MAMA MESA Adaptive Moving Average MAVP Moving average with variable period MIDPOINT MidPoint over period MIDPRICE Midpoint Price over period SAR Parabolic SAR SAREXT Parabolic SAR - Extended SMA Simple Moving Average T3 Triple Exponential Moving Average (T3) TEMA Triple Exponential Moving Average TRIMA Triangular Moving Average WMA Weighted Moving Average ``` #### [Momentum Indicators](func_groups/momentum_indicators.md) ``` ADX Average Directional Movement Index ADXR Average Directional Movement Index Rating APO Absolute Price Oscillator AROON Aroon AROONOSC Aroon Oscillator BOP Balance Of Power CCI Commodity Channel Index CMO Chande Momentum Oscillator DX Directional Movement Index MACD Moving Average Convergence/Divergence MACDEXT MACD with controllable MA type MACDFIX Moving Average Convergence/Divergence Fix 12/26 MFI Money Flow Index MINUS_DI Minus Directional Indicator MINUS_DM Minus Directional Movement MOM Momentum PLUS_DI Plus Directional Indicator PLUS_DM Plus Directional Movement PPO Percentage Price Oscillator ROC Rate of change : ((price/prevPrice)-1)*100 ROCP Rate of change Percentage: (price-prevPrice)/prevPrice ROCR Rate of change ratio: (price/prevPrice) ROCR100 Rate of change ratio 100 scale: (price/prevPrice)*100 RSI Relative Strength Index STOCH Stochastic STOCHF Stochastic Fast STOCHRSI Stochastic Relative Strength Index TRIX 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA ULTOSC Ultimate Oscillator WILLR Williams' %R ``` #### [Volume Indicators](func_groups/volume_indicators.md) ``` AD Chaikin A/D Line ADOSC Chaikin A/D Oscillator OBV On Balance Volume ``` #### [Cycle Indicators](func_groups/cycle_indicators.md) ``` HT_DCPERIOD Hilbert Transform - Dominant Cycle Period HT_DCPHASE Hilbert Transform - Dominant Cycle Phase HT_PHASOR Hilbert Transform - Phasor Components HT_SINE Hilbert Transform - SineWave HT_TRENDMODE Hilbert Transform - Trend vs Cycle Mode ``` #### [Price Transform](func_groups/price_transform.md) ``` AVGPRICE Average Price MEDPRICE Median Price TYPPRICE Typical Price WCLPRICE Weighted Close Price ``` #### [Volatility Indicators](func_groups/volatility_indicators.md) ``` ATR Average True Range NATR Normalized Average True Range TRANGE True Range ``` #### [Pattern Recognition](func_groups/pattern_recognition.md) ``` CDL2CROWS Two Crows CDL3BLACKCROWS Three Black Crows CDL3INSIDE Three Inside Up/Down CDL3LINESTRIKE Three-Line Strike CDL3OUTSIDE Three Outside Up/Down CDL3STARSINSOUTH Three Stars In The South CDL3WHITESOLDIERS Three Advancing White Soldiers CDLABANDONEDBABY Abandoned Baby CDLADVANCEBLOCK Advance Block CDLBELTHOLD Belt-hold CDLBREAKAWAY Breakaway CDLCLOSINGMARUBOZU Closing Marubozu CDLCONCEALBABYSWALL Concealing Baby Swallow CDLCOUNTERATTACK Counterattack CDLDARKCLOUDCOVER Dark Cloud Cover CDLDOJI Doji CDLDOJISTAR Doji Star CDLDRAGONFLYDOJI Dragonfly Doji CDLENGULFING Engulfing Pattern CDLEVENINGDOJISTAR Evening Doji Star CDLEVENINGSTAR Evening Star CDLGAPSIDESIDEWHITE Up/Down-gap side-by-side white lines CDLGRAVESTONEDOJI Gravestone Doji CDLHAMMER Hammer CDLHANGINGMAN Hanging Man CDLHARAMI Harami Pattern CDLHARAMICROSS Harami Cross Pattern CDLHIGHWAVE High-Wave Candle CDLHIKKAKE Hikkake Pattern CDLHIKKAKEMOD Modified Hikkake Pattern CDLHOMINGPIGEON Homing Pigeon CDLIDENTICAL3CROWS Identical Three Crows CDLINNECK In-Neck Pattern CDLINVERTEDHAMMER Inverted Hammer CDLKICKING Kicking CDLKICKINGBYLENGTH Kicking - bull/bear determined by the longer marubozu CDLLADDERBOTTOM Ladder Bottom CDLLONGLEGGEDDOJI Long Legged Doji CDLLONGLINE Long Line Candle CDLMARUBOZU Marubozu CDLMATCHINGLOW Matching Low CDLMATHOLD Mat Hold CDLMORNINGDOJISTAR Morning Doji Star CDLMORNINGSTAR Morning Star CDLONNECK On-Neck Pattern CDLPIERCING Piercing Pattern CDLRICKSHAWMAN Rickshaw Man CDLRISEFALL3METHODS Rising/Falling Three Methods CDLSEPARATINGLINES Separating Lines CDLSHOOTINGSTAR Shooting Star CDLSHORTLINE Short Line Candle CDLSPINNINGTOP Spinning Top CDLSTALLEDPATTERN Stalled Pattern CDLSTICKSANDWICH Stick Sandwich CDLTAKURI Takuri (Dragonfly Doji with very long lower shadow) CDLTASUKIGAP Tasuki Gap CDLTHRUSTING Thrusting Pattern CDLTRISTAR Tristar Pattern CDLUNIQUE3RIVER Unique 3 River CDLUPSIDEGAP2CROWS Upside Gap Two Crows CDLXSIDEGAP3METHODS Upside/Downside Gap Three Methods ``` #### [Statistic Functions](func_groups/statistic_functions.md) ``` BETA Beta CORREL Pearson's Correlation Coefficient (r) LINEARREG Linear Regression LINEARREG_ANGLE Linear Regression Angle LINEARREG_INTERCEPT Linear Regression Intercept LINEARREG_SLOPE Linear Regression Slope STDDEV Standard Deviation TSF Time Series Forecast VAR Variance ``` #### [Math Transform](func_groups/math_transform.md) ``` ACOS Vector Trigonometric ACos ASIN Vector Trigonometric ASin ATAN Vector Trigonometric ATan CEIL Vector Ceil COS Vector Trigonometric Cos COSH Vector Trigonometric Cosh EXP Vector Arithmetic Exp FLOOR Vector Floor LN Vector Log Natural LOG10 Vector Log10 SIN Vector Trigonometric Sin SINH Vector Trigonometric Sinh SQRT Vector Square Root TAN Vector Trigonometric Tan TANH Vector Trigonometric Tanh ``` #### [Math Operators](func_groups/math_operators.md) ``` ADD Vector Arithmetic Add DIV Vector Arithmetic Div MAX Highest value over a specified period MAXINDEX Index of highest value over a specified period MIN Lowest value over a specified period MININDEX Index of lowest value over a specified period MINMAX Lowest and highest values over a specified period MINMAXINDEX Indexes of lowest and highest values over a specified period MULT Vector Arithmetic Mult SUB Vector Arithmetic Subtraction SUM Summation ``` [Documentation Index](doc_index.md) ================================================ FILE: docs/generate_html_pages.py ================================================ """ USAGE: To convert markdown docs into html docs: $ python generate_html_pages.py /path/to/gh-pages/dir To generate pygments code highlighting stylesheet: $ pygmentize -f html -S [STYLE_NAME] -a .highlight > /path/to/gh-pages/stylesheets/dir/pygments_style.css To list available style names (at python prompt) >>> from pygments import styles >>> sorted(styles.get_all_styles()) # default, lovelace and xcode are "normal" styles """ import os import sys import talib import mistune from pygments import highlight from pygments.lexers import get_lexer_by_name from pygments.formatters.html import HtmlFormatter from bs4 import BeautifulSoup from talib.abstract import Function INPUT_DIR = os.path.dirname(os.path.realpath(__file__)) FUNCTION_GROUPS_DIR = os.path.join(INPUT_DIR, 'func_groups') OUTPUT_DIR = os.path.join(INPUT_DIR, 'html') HEADER = '''\ TA-Lib
''' FOOTER = '''\
''' def slugify(string): return string.lower().replace(' ', '_') def get_doc_links(): """Returns a dictionary of function names -> upstream documentation link""" tadoc_homepage = 'https://www.tadoc.org/' html_file_path = os.path.join(INPUT_DIR, '.tadoc.org.html') if os.path.exists(html_file_path): with open(html_file_path, 'r') as f: html = f.read() else: from urllib.request import urlopen html = urlopen(tadoc_homepage).read() with open(html_file_path, 'wb') as f: f.write(html) # find every link that's for an indicator and convert to absolute urls soup = BeautifulSoup(html, 'html.parser') 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']]) func = url[url.rfind('/')+1:url.rfind('.')] ret[func] = url return ret def generate_groups_markdown(): """Generate and save markdown files for function group documentation""" for group, group_docs in get_groups_markdown().items(): file_path = os.path.join(FUNCTION_GROUPS_DIR, '%s.md' % group) with open(file_path, 'w') as f: f.write(group_docs) def get_groups_markdown(): """Generate markdown for function groups using the Abstract API Returns a dictionary of group_name -> documentation for group functions """ def unpluralize(noun): if noun.endswith('s'): if len(noun) > 2 and noun[-2] not in ["'", 'e']: return noun[:-1] return noun doc_links = get_doc_links() ret = {} for group, funcs in talib.get_function_groups().items(): h1 = '# %s' % unpluralize(group) h1 = h1 + ' Functions' if 'Function' not in h1 else h1 + 's' group_docs = [h1] for func in funcs: # figure out this function's options f = Function(func) inputs = f.info['input_names'] if 'price' in inputs and 'prices' in inputs: names = [inputs['price']] names.extend(inputs['prices']) input_names = ', '.join(names) elif 'prices' in inputs: input_names = ', '.join(inputs['prices']) else: input_names = ', '.join([x for x in inputs.values() if x]) params = ', '.join( ['%s=%i' % (param, default) for param, default in f.info['parameters'].items()]) outputs = ', '.join(f.info['output_names']) # print the header group_docs.append('### %s - %s' % (func, f.info['display_name'])) if f.function_flags and 'Function has an unstable period' in f.function_flags: group_docs.append('NOTE: The ``%s`` function has an unstable period. ' % func) # print the code definition block group_docs.append("```python") if params: group_docs.append('%s = %s(%s, %s)' % ( outputs, func.upper(), input_names, params)) else: group_docs.append('%s = %s(%s)' % ( outputs, func.upper(), input_names)) group_docs.append("```\n") # print extra info if we can if func in doc_links: group_docs.append('Learn more about the %s at [tadoc.org](%s). ' % ( f.info['display_name'], doc_links[func])) group_docs.append('\n[Documentation Index](../doc_index.md)') group_docs.append('[FLOAT_RIGHTAll Function Groups](../funcs.md)') ret[slugify(group)] = '\n'.join(group_docs) + '\n' return ret def get_markdown_file_paths(): file_names = [ 'index.md', 'doc_index.md', 'install.md', 'func.md', 'funcs.md', 'abstract.md', ] file_names.extend( ['func_groups/%s' % x for x in os.listdir(FUNCTION_GROUPS_DIR) if x.endswith('.md')] ) return [os.path.join(INPUT_DIR, fn) for fn in file_names] def _get_markdown_renderer(): """Returns a function to convert a Markdown string into pygments-highlighted HTML""" class PygmentsHighlighter(mistune.HTMLRenderer): def block_code(self, code, info=None): if not info: return '\n
%s
\n' % mistune.escape(code) lexer = get_lexer_by_name(info, stripall=True) formatter = HtmlFormatter(classprefix='highlight ') return highlight(code, lexer, formatter) return mistune.Markdown(renderer=PygmentsHighlighter()) def run_convert_to_html(output_dir): """Converts markdown files into their respective html files""" markdown_to_html = _get_markdown_renderer() for md_file_path in get_markdown_file_paths(): with open(md_file_path, 'r') as f: html = markdown_to_html(f.read()) html = html.replace('.md">', '.html">') head = HEADER if 'func_groups' in md_file_path: head = head.replace('"index.html"', '"../index.html"') head = head.replace('"doc_index.html"', '"../doc_index.html"') head = head.replace('"stylesheets/', '"../stylesheets/') lines = html.split('\n') for i, line in enumerate(lines): if 'FLOAT_RIGHT' in line: line = line.replace('FLOAT_RIGHT', '') lines[i] = line.replace(' TA-Lib is widely used by trading software developers requiring to perform > technical analysis of financial market data. > * Includes 150+ indicators such as ADX, MACD, RSI, Stochastic, Bollinger > Bands, etc. > * Candlestick pattern recognition > * Open-source API for C/C++, Java, Perl, Python and 100% Managed .NET The original Python bindings use [SWIG](https://swig.org) which unfortunately are difficult to install and aren't as efficient as they could be. Therefore this project uses Cython and Numpy to efficiently and cleanly bind to TA-Lib -- producing results 2-4 times faster than the SWIG interface. #### [Install TA-Lib](install.md) or [Read the Docs](doc_index.md) ## Examples Similar to TA-Lib, the function interface provides a lightweight wrapper of the 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``. All of the following examples use the function API: ```python import numpy import talib close = numpy.random.random(100) ``` Calculate a simple moving average of the close prices: ```python output = talib.SMA(close) ``` Calculating bollinger bands, with triple exponential moving average: ```python from talib import MA_Type upper, middle, lower = talib.BBANDS(close, matype=MA_Type.T3) ``` Calculating momentum of the close prices, with a time period of 5: ```python output = talib.MOM(close, timeperiod=5) ``` ## Abstract API Quick Start If you're already familiar with using the function API, you should feel right at home using the abstract API. Every function takes the same input, passed as a dictionary of Numpy arrays: ```python import numpy as np # note that all ndarrays must be the same length! inputs = { 'open': np.random.random(100), 'high': np.random.random(100), 'low': np.random.random(100), 'close': np.random.random(100), 'volume': np.random.random(100) } ``` Functions can either be imported directly or instantiated by name: ```python from talib import abstract sma = abstract.SMA sma = abstract.Function('sma') ``` From there, calling functions is basically the same as the function API: ```python from talib.abstract import * output = SMA(input_arrays, timeperiod=25) # calculate on close prices by default output = SMA(input_arrays, timeperiod=25, price='open') # calculate on opens upper, middle, lower = BBANDS(input_arrays, 20, 2, 2) slowk, slowd = STOCH(input_arrays, 5, 3, 0, 3, 0) # uses high, low, close by default slowk, slowd = STOCH(input_arrays, 5, 3, 0, 3, 0, prices=['high', 'low', 'open']) ``` Learn about more advanced usage of TA-Lib [here](abstract.md). ## Supported 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 import talib print talib.get_functions() print talib.get_function_groups() ``` ### Function Groups * [Overlap Studies](func_groups/overlap_studies.md) * [Momentum Indicators](func_groups/momentum_indicators.md) * [Volume Indicators](func_groups/volume_indicators.md) * [Volatility Indicators](func_groups/volatility_indicators.md) * [Price Transform](func_groups/price_transform.md) * [Cycle Indicators](func_groups/cycle_indicators.md) * [Pattern Recognition](func_groups/pattern_recognition.md) * [Statistic Functions](func_groups/statistic_functions.md) * [Math Transform](func_groups/math_transform.md) * [Math Operators](func_groups/math_operators.md) #### [Overlap Studies](func_groups/overlap_studies.md) ``` BBANDS Bollinger Bands DEMA Double Exponential Moving Average EMA Exponential Moving Average HT_TRENDLINE Hilbert Transform - Instantaneous Trendline KAMA Kaufman Adaptive Moving Average MA Moving average MAMA MESA Adaptive Moving Average MAVP Moving average with variable period MIDPOINT MidPoint over period MIDPRICE Midpoint Price over period SAR Parabolic SAR SAREXT Parabolic SAR - Extended SMA Simple Moving Average T3 Triple Exponential Moving Average (T3) TEMA Triple Exponential Moving Average TRIMA Triangular Moving Average WMA Weighted Moving Average ``` #### [Momentum Indicators](func_groups/momentum_indicators.md) ``` ADX Average Directional Movement Index ADXR Average Directional Movement Index Rating APO Absolute Price Oscillator AROON Aroon AROONOSC Aroon Oscillator BOP Balance Of Power CCI Commodity Channel Index CMO Chande Momentum Oscillator DX Directional Movement Index MACD Moving Average Convergence/Divergence MACDEXT MACD with controllable MA type MACDFIX Moving Average Convergence/Divergence Fix 12/26 MFI Money Flow Index MINUS_DI Minus Directional Indicator MINUS_DM Minus Directional Movement MOM Momentum PLUS_DI Plus Directional Indicator PLUS_DM Plus Directional Movement PPO Percentage Price Oscillator ROC Rate of change : ((price/prevPrice)-1)*100 ROCP Rate of change Percentage: (price-prevPrice)/prevPrice ROCR Rate of change ratio: (price/prevPrice) ROCR100 Rate of change ratio 100 scale: (price/prevPrice)*100 RSI Relative Strength Index STOCH Stochastic STOCHF Stochastic Fast STOCHRSI Stochastic Relative Strength Index TRIX 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA ULTOSC Ultimate Oscillator WILLR Williams' %R ``` #### [Volume Indicators](func_groups/volume_indicators.md) ``` AD Chaikin A/D Line ADOSC Chaikin A/D Oscillator OBV On Balance Volume ``` #### [Volatility Indicators](func_groups/volatility_indicators.md) ``` ATR Average True Range NATR Normalized Average True Range TRANGE True Range ``` #### [Price Transform](func_groups/price_transform.md) ``` AVGPRICE Average Price MEDPRICE Median Price TYPPRICE Typical Price WCLPRICE Weighted Close Price ``` #### [Cycle Indicators](func_groups/cycle_indicators.md) ``` HT_DCPERIOD Hilbert Transform - Dominant Cycle Period HT_DCPHASE Hilbert Transform - Dominant Cycle Phase HT_PHASOR Hilbert Transform - Phasor Components HT_SINE Hilbert Transform - SineWave HT_TRENDMODE Hilbert Transform - Trend vs Cycle Mode ``` #### [Pattern Recognition](func_groups/pattern_recognition.md) ``` CDL2CROWS Two Crows CDL3BLACKCROWS Three Black Crows CDL3INSIDE Three Inside Up/Down CDL3LINESTRIKE Three-Line Strike CDL3OUTSIDE Three Outside Up/Down CDL3STARSINSOUTH Three Stars In The South CDL3WHITESOLDIERS Three Advancing White Soldiers CDLABANDONEDBABY Abandoned Baby CDLADVANCEBLOCK Advance Block CDLBELTHOLD Belt-hold CDLBREAKAWAY Breakaway CDLCLOSINGMARUBOZU Closing Marubozu CDLCONCEALBABYSWALL Concealing Baby Swallow CDLCOUNTERATTACK Counterattack CDLDARKCLOUDCOVER Dark Cloud Cover CDLDOJI Doji CDLDOJISTAR Doji Star CDLDRAGONFLYDOJI Dragonfly Doji CDLENGULFING Engulfing Pattern CDLEVENINGDOJISTAR Evening Doji Star CDLEVENINGSTAR Evening Star CDLGAPSIDESIDEWHITE Up/Down-gap side-by-side white lines CDLGRAVESTONEDOJI Gravestone Doji CDLHAMMER Hammer CDLHANGINGMAN Hanging Man CDLHARAMI Harami Pattern CDLHARAMICROSS Harami Cross Pattern CDLHIGHWAVE High-Wave Candle CDLHIKKAKE Hikkake Pattern CDLHIKKAKEMOD Modified Hikkake Pattern CDLHOMINGPIGEON Homing Pigeon CDLIDENTICAL3CROWS Identical Three Crows CDLINNECK In-Neck Pattern CDLINVERTEDHAMMER Inverted Hammer CDLKICKING Kicking CDLKICKINGBYLENGTH Kicking - bull/bear determined by the longer marubozu CDLLADDERBOTTOM Ladder Bottom CDLLONGLEGGEDDOJI Long Legged Doji CDLLONGLINE Long Line Candle CDLMARUBOZU Marubozu CDLMATCHINGLOW Matching Low CDLMATHOLD Mat Hold CDLMORNINGDOJISTAR Morning Doji Star CDLMORNINGSTAR Morning Star CDLONNECK On-Neck Pattern CDLPIERCING Piercing Pattern CDLRICKSHAWMAN Rickshaw Man CDLRISEFALL3METHODS Rising/Falling Three Methods CDLSEPARATINGLINES Separating Lines CDLSHOOTINGSTAR Shooting Star CDLSHORTLINE Short Line Candle CDLSPINNINGTOP Spinning Top CDLSTALLEDPATTERN Stalled Pattern CDLSTICKSANDWICH Stick Sandwich CDLTAKURI Takuri (Dragonfly Doji with very long lower shadow) CDLTASUKIGAP Tasuki Gap CDLTHRUSTING Thrusting Pattern CDLTRISTAR Tristar Pattern CDLUNIQUE3RIVER Unique 3 River CDLUPSIDEGAP2CROWS Upside Gap Two Crows CDLXSIDEGAP3METHODS Upside/Downside Gap Three Methods ``` #### [Statistic Functions](func_groups/statistic_functions.md) ``` BETA Beta CORREL Pearson's Correlation Coefficient (r) LINEARREG Linear Regression LINEARREG_ANGLE Linear Regression Angle LINEARREG_INTERCEPT Linear Regression Intercept LINEARREG_SLOPE Linear Regression Slope STDDEV Standard Deviation TSF Time Series Forecast VAR Variance ``` ================================================ FILE: docs/install.md ================================================ # Installation You can install from PyPI: ``` $ pip install TA-Lib ``` Or checkout the sources and run ``setup.py`` yourself: ``` $ python setup.py install ``` ### Troubleshooting Install Errors ``` func.c:256:28: fatal error: ta-lib/ta_libc.h: No such file or directory compilation terminated. ``` If you get build errors like this, it typically means that it can't find the underlying ``TA-Lib`` library and needs to be installed: # Dependencies To use TA-Lib for python, you need to have the [TA-Lib](https://ta-lib.org/hdr_dw.html) already installed: #### Mac OS X ``` $ brew install ta-lib ``` #### Windows Download [ta-lib-0.4.0-msvc.zip](https://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-msvc.zip) and unzip to ``C:\ta-lib`` #### Linux Download [ta-lib-0.4.0-src.tar.gz](https://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz) and: ``` $ tar zxvf ta-lib-0.4.0-src.tar.gz $ cd ta-lib $ ./configure --prefix=/usr $ make $ sudo make install ``` > If you build ``TA-Lib`` using ``make -jX`` it will fail but that's OK! > Simply rerun ``make -jX`` followed by ``[sudo] make install``. [Documentation Index](doc_index.md) [FLOAT_RIGHTNext: Using the Function API](func.md) ================================================ FILE: pyproject.toml ================================================ [build-system] 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", "abstract.pyi"]} ================================================ FILE: requirements.txt ================================================ numpy Cython ================================================ FILE: requirements_dev.txt ================================================ -r requirements.txt beautifulsoup4 mistune Pygments build cython ================================================ FILE: requirements_test.txt ================================================ -r requirements.txt pandas pytest polars ================================================ FILE: setup.py ================================================ #!/usr/bin/env python import sys import os import os.path import warnings from setuptools import setup, Extension 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 = [ '/usr/include', '/usr/local/include', '/opt/include', '/opt/local/include', '/opt/homebrew/include', '/opt/homebrew/opt/ta-lib/include', ] library_dirs = [ '/usr/lib', '/usr/local/lib', '/usr/lib64', '/usr/local/lib64', '/opt/lib', '/opt/local/lib', '/opt/homebrew/lib', '/opt/homebrew/opt/ta-lib/lib', ] elif sys.platform == "win32": platform_supported = True 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) if 'TA_LIBRARY_PATH' in os.environ: library_dirs = os.environ['TA_LIBRARY_PATH'].split(os.pathsep) if not platform_supported: raise NotImplementedError(sys.platform) for path in library_dirs: try: files = os.listdir(path) if any(lib_talib_name in f for f in files): break except OSError: pass 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 NumpyBuildExt(build_ext): """ Custom build_ext command that adds numpy's include_dir to extensions. """ 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) super().build_extensions() cmdclass = {'build_ext': NumpyBuildExt} ext_modules = [ Extension( 'talib._ta_lib', ['talib/_ta_lib.pyx' if has_cython else 'talib/_ta_lib.c'], include_dirs=include_dirs, library_dirs=library_dirs, libraries=[lib_talib_name], runtime_library_dirs=[] if sys.platform == 'win32' else library_dirs) ] setup( ext_modules=ext_modules, cmdclass=cmdclass, ) ================================================ FILE: talib/__init__.py ================================================ import atexit from itertools import chain from functools import wraps # If polars is available, wrap talib functions so that they support # polars.Series input try: from polars import Series as _pl_Series 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 # If pandas is available, wrap talib functions so that they support # pandas.Series input try: from pandas import Series as _pd_Series 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 if _pl_Series is not None or _pd_Series is not None: def _wrapper(func): @wraps(func) def wrapper(*args, **kwds): if _pl_Series is not None: use_pl = any(isinstance(arg, _pl_Series) for arg in args) or \ any(isinstance(v, _pl_Series) for v in kwds.values()) else: use_pl = False if _pd_Series is not None: use_pd = any(isinstance(arg, _pd_Series) for arg in args) or \ any(isinstance(v, _pd_Series) for v in kwds.values()) else: use_pd = False if use_pl and use_pd: raise Exception("Cannot mix polars and pandas") # Use float64 values if polars or pandas, else use values as passed if use_pl: _args = [arg.to_numpy().astype(float) if isinstance(arg, _pl_Series) else arg for arg in args] _kwds = {k: v.to_numpy().astype(float) if isinstance(v, _pl_Series) else v for k, v in kwds.items()} elif use_pd: index = next(arg.index for arg in chain(args, kwds.values()) if isinstance(arg, _pd_Series)) _args = [arg.to_numpy().astype(float) if isinstance(arg, _pd_Series) else arg for arg in args] _kwds = {k: v.to_numpy().astype(float) if isinstance(v, _pd_Series) else v for k, v in kwds.items()} else: _args = args _kwds = kwds result = func(*_args, **_kwds) # check to see if we got a streaming result first_result = result[0] if isinstance(result, tuple) else result is_streaming_fn_result = not hasattr(first_result, '__len__') if is_streaming_fn_result: return result # Series was passed in, Series gets out if use_pl: if isinstance(result, tuple): return tuple(_pl_Series(arr) for arr in result) else: return _pl_Series(result) elif use_pd: if isinstance(result, tuple): return tuple(_pd_Series(arr, index=index) for arr in result) else: return _pd_Series(result, index=index) else: return result return wrapper else: _wrapper = lambda x: x from ._ta_lib import ( _ta_initialize, _ta_shutdown, MA_Type, __ta_version__, _ta_set_unstable_period as set_unstable_period, _ta_get_unstable_period as get_unstable_period, _ta_set_compatibility as set_compatibility, _ta_get_compatibility as get_compatibility, __TA_FUNCTION_NAMES__ ) # import all the func and stream functions from ._ta_lib import * # wrap them for polars or pandas support func = __import__("_ta_lib", globals(), locals(), __TA_FUNCTION_NAMES__, level=1) for func_name in __TA_FUNCTION_NAMES__: wrapped_func = _wrapper(getattr(func, func_name)) setattr(func, func_name, wrapped_func) globals()[func_name] = wrapped_func stream_func_names = ['stream_%s' % fname for fname in __TA_FUNCTION_NAMES__] stream = __import__("stream", globals(), locals(), stream_func_names, level=1) for func_name, stream_func_name in zip(__TA_FUNCTION_NAMES__, stream_func_names): wrapped_func = _wrapper(getattr(stream, func_name)) setattr(stream, func_name, wrapped_func) globals()[stream_func_name] = wrapped_func __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 # or talib.abstract. Here, we handle initializing and shutting down the # underlying TA-Lib. Initialization happens on import, before any other TA-Lib # functions are called. Finally, when the python process exits, we shutdown # the underlying TA-Lib. _ta_initialize() atexit.register(_ta_shutdown) __function_groups__ = { 'Cycle Indicators': [ 'HT_DCPERIOD', 'HT_DCPHASE', 'HT_PHASOR', 'HT_SINE', 'HT_TRENDMODE', ], 'Math Operators': [ 'ADD', 'DIV', 'MAX', 'MAXINDEX', 'MIN', 'MININDEX', 'MINMAX', 'MINMAXINDEX', 'MULT', 'SUB', 'SUM', ], 'Math Transform': [ 'ACOS', 'ASIN', 'ATAN', 'CEIL', 'COS', 'COSH', 'EXP', 'FLOOR', 'LN', 'LOG10', 'SIN', 'SINH', 'SQRT', 'TAN', 'TANH', ], 'Momentum Indicators': [ 'ADX', 'ADXR', 'APO', 'AROON', 'AROONOSC', 'BOP', 'CCI', 'CMO', 'DX', 'IMI', 'MACD', 'MACDEXT', 'MACDFIX', 'MFI', 'MINUS_DI', 'MINUS_DM', 'MOM', 'PLUS_DI', 'PLUS_DM', 'PPO', 'ROC', 'ROCP', 'ROCR', 'ROCR100', 'RSI', 'STOCH', 'STOCHF', 'STOCHRSI', 'TRIX', 'ULTOSC', 'WILLR', ], 'Overlap Studies': [ 'ACCBANDS', 'BBANDS', 'DEMA', 'EMA', 'HT_TRENDLINE', 'KAMA', 'MA', 'MAMA', 'MAVP', 'MIDPOINT', 'MIDPRICE', 'SAR', 'SAREXT', 'SMA', 'T3', 'TEMA', 'TRIMA', 'WMA', ], 'Pattern Recognition': [ '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', ], 'Price Transform': [ 'AVGDEV', 'AVGPRICE', 'MEDPRICE', 'TYPPRICE', 'WCLPRICE', ], 'Statistic Functions': [ 'BETA', 'CORREL', 'LINEARREG', 'LINEARREG_ANGLE', 'LINEARREG_INTERCEPT', 'LINEARREG_SLOPE', 'STDDEV', 'TSF', 'VAR', ], 'Volatility Indicators': [ 'ATR', 'NATR', 'TRANGE', ], 'Volume Indicators': [ 'AD', 'ADOSC', 'OBV' ], } def get_functions(): """ Returns a list of all the functions supported by TALIB """ ret = [] for group in __function_groups__: ret.extend(__function_groups__[group]) return ret def get_function_groups(): """ Returns a dict with keys of function-group names and values of lists of function names ie {'group_names': ['function_names']} """ return __function_groups__.copy() __all__ = ['get_functions', 'get_function_groups'] + __TA_FUNCTION_NAMES__ + ["stream_%s" % name for name in __TA_FUNCTION_NAMES__] ================================================ FILE: talib/_abstract.pxi ================================================ ''' This file Copyright (c) 2013 Brian A Cappello ''' import math import threading try: from collections import OrderedDict except ImportError: # handle python 2.6 and earlier from ordereddict import OrderedDict from cython.operator cimport dereference as deref import numpy import sys 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', 'price0': 'high', 'price1': 'low', 'periods': 'periods', # only used by MAVP; not a price series! } __INPUT_ARRAYS_TYPES = [dict] __ARRAY_TYPES = [np.ndarray] # allow use of pandas.DataFrame for input arrays try: import pandas __INPUT_ARRAYS_TYPES.append(pandas.DataFrame) __ARRAY_TYPES.append(pandas.Series) __PANDAS_DATAFRAME = pandas.DataFrame __PANDAS_SERIES = pandas.Series 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 # allow use of polars.DataFrame for input arrays try: import polars __INPUT_ARRAYS_TYPES.append(polars.DataFrame) __ARRAY_TYPES.append(polars.Series) __POLARS_DATAFRAME = polars.DataFrame __POLARS_SERIES = polars.Series 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 __INPUT_ARRAYS_TYPES = tuple(__INPUT_ARRAYS_TYPES) __ARRAY_TYPES = tuple(__ARRAY_TYPES) if sys.version >= '3': def str2bytes(s): return bytes(s, 'ascii') def bytes2str(b): return b.decode('ascii') else: def str2bytes(s): return s def bytes2str(b): return b class Function(object): """ This is a pythonic wrapper around TALIB's abstract interface. It is intended to simplify using individual TALIB functions by providing a unified interface for setting/controlling input data, setting function parameters and retrieving results. Input data consists of a ``dict`` of ``numpy`` arrays (or a ``pandas.DataFrame`` or ``polars.DataFrame``), one array for each of open, high, low, close and volume. This can be set with the set_input_arrays() method. Which keyed array(s) are used as inputs when calling the function is controlled using the input_names property. This class gets initialized with a TALIB function name and optionally an input_arrays object. It provides the following primary functions for setting inputs and retrieving results: ---- input_array/TA-function-parameter set-only functions ----- - set_input_arrays(input_arrays) - set_function_args([input_arrays,] [param_args_andor_kwargs]) Documentation for param_args_andor_kwargs can be seen by printing the Function instance or programmatically via the info, input_names and parameters properties. ----- result-returning functions ----- - the outputs property wraps a method which ensures results are always valid - run([input_arrays]) # calls set_input_arrays and returns self.outputs - FunctionInstance([input_arrays,] [param_args_andor_kwargs]) # calls set_function_args and returns self.outputs """ def __init__(self, function_name, func_object, *args, **kwargs): # make sure the function_name is valid and define all of our variables self.__name = function_name.upper() self.__namestr = self.__name self.__name = str2bytes(self.__name) # thread-local storage self.__localdata = threading.local() # finish initializing: query the TALIB abstract interface and set arguments self.set_function_args(*args, **kwargs) self.func_object = func_object @property def __local(self): local = self.__localdata if not hasattr(local, 'info'): local.info = None local.input_arrays = {} # dictionaries of function args. keys are input/opt_input/output parameter names local.input_names = OrderedDict() local.opt_inputs = OrderedDict() local.outputs = OrderedDict() local.outputs_valid = False # function info local.info = _ta_getFuncInfo(self.__name) # inputs (price series names) for i in xrange(local.info.pop('num_inputs')): info = _ta_getInputParameterInfo(self.__name, i) input_name = info['name'] if info['price_series'] is None: info['price_series'] = __INPUT_PRICE_SERIES_DEFAULTS[input_name] local.input_names[input_name] = info local.info['input_names'] = self.input_names # optional inputs (function parameters) for i in xrange(local.info.pop('num_opt_inputs')): info = _ta_getOptInputParameterInfo(self.__name, i) param_name = info['name'] local.opt_inputs[param_name] = info local.info['parameters'] = self.parameters # outputs local.info['output_flags'] = OrderedDict() for i in xrange(local.info.pop('num_outputs')): info = _ta_getOutputParameterInfo(self.__name, i) output_name = info['name'] local.info['output_flags'][output_name] = info['flags'] local.outputs[output_name] = None local.info['output_names'] = self.output_names return local @property def info(self): """ Returns a copy of the function's info dict. """ return self.__local.info.copy() @property def function_flags(self): """ Returns any function flags defined for this indicator function. """ return self.__local.info['function_flags'] @property def output_flags(self): """ Returns the flags for each output for this indicator function. """ return self.__local.info['output_flags'].copy() def get_input_names(self): """ Returns the dict of input price series names that specifies which of the ndarrays in input_arrays will be used to calculate the function. """ local = self.__local ret = OrderedDict() for input_name in local.input_names: ret[input_name] = local.input_names[input_name]['price_series'] return ret def set_input_names(self, input_names): """ Sets the input price series names to use. """ local = self.__local for input_name, price_series in input_names.items(): local.input_names[input_name]['price_series'] = price_series local.info['input_names'][input_name] = price_series local.outputs_valid = False input_names = property(get_input_names, set_input_names) def get_input_arrays(self): """ Returns a copy of the dict of input arrays in use. """ local = self.__local if __POLARS_DATAFRAME is not None \ and isinstance(local.input_arrays, __POLARS_DATAFRAME): return local.input_arrays.clone() else: return local.input_arrays.copy() def set_input_arrays(self, input_arrays): """ Sets the dict of input_arrays to use. Returns True/False for subclasses: If input_arrays is a dict with the keys open, high, low, close and volume, it is assigned as the input_array to use and this function returns True, returning False otherwise. If you implement your own data type and wish to subclass Function, you should wrap this function with an if-statement: class CustomFunction(Function): def __init__(self, function_name): Function.__init__(self, function_name) def set_input_arrays(self, input_data): if Function.set_input_arrays(self, input_data): return True elif isinstance(input_data, some_module.CustomDataType): input_arrays = Function.get_input_arrays(self) # convert input_data to input_arrays and then call the super Function.set_input_arrays(self, input_arrays) return True return False """ local = self.__local if isinstance(input_arrays, __INPUT_ARRAYS_TYPES): missing_keys = [] for key in self.__input_price_series_names(): if __POLARS_DATAFRAME is not None \ and isinstance(input_arrays, __POLARS_DATAFRAME): missing = key not in input_arrays.columns else: missing = key not in input_arrays if missing: missing_keys.append(key) if len(missing_keys) == 0: local.input_arrays = input_arrays local.outputs_valid = False return True else: raise Exception('input_arrays parameter missing required data '\ 'key%s: %s' % ('s' if len(missing_keys) > 1 \ else '', ', '.join(missing_keys))) return False input_arrays = property(get_input_arrays, set_input_arrays) def get_parameters(self): """ Returns the function's optional parameters and their default values. """ local = self.__local ret = OrderedDict() for opt_input in local.opt_inputs: ret[opt_input] = self.__get_opt_input_value(opt_input) return ret def set_parameters(self, parameters=None, **kwargs): """ Sets the function parameter values. """ local = self.__local parameters = parameters or {} parameters.update(kwargs) for param, value in parameters.items(): if self.__check_opt_input_value(param, value): local.opt_inputs[param]['value'] = value local.outputs_valid = False local.info['parameters'] = self.parameters parameters = property(get_parameters, set_parameters) def set_function_args(self, *args, **kwargs): """ optional args:[input_arrays,] [parameter_args,] [input_price_series_kwargs,] [parameter_kwargs] """ local = self.__local update_info = False for key in kwargs: if key in local.opt_inputs: value = kwargs[key] if self.__check_opt_input_value(key, value): local.opt_inputs[key]['value'] = kwargs[key] update_info = True elif key in local.input_names: local.input_names[key]['price_series'] = kwargs[key] local.info['input_names'][key] = kwargs[key] if args: skip_first = 0 if self.set_input_arrays(args[0]): skip_first = 1 if len(args) > skip_first: for i, param_name in enumerate(local.opt_inputs): i += skip_first if i < len(args): value = args[i] if self.__check_opt_input_value(param_name, value): local.opt_inputs[param_name]['value'] = value update_info = True if args or kwargs: if update_info: local.info['parameters'] = self.parameters local.outputs_valid = False @property def lookback(self): """ Returns the lookback window size for the function with the parameter values that are currently set. """ local = self.__local cdef lib.TA_ParamHolder *holder holder = __ta_paramHolderAlloc(self.__name) for i, opt_input in enumerate(local.opt_inputs): value = self.__get_opt_input_value(opt_input) type_ = local.opt_inputs[opt_input]['type'] if type_ == lib.TA_OptInput_RealRange or type_ == lib.TA_OptInput_RealList: __ta_setOptInputParamReal(holder, i, value) elif type_ == lib.TA_OptInput_IntegerRange or type_ == lib.TA_OptInput_IntegerList: __ta_setOptInputParamInteger(holder, i, value) lookback = __ta_getLookback(holder) __ta_paramHolderFree(holder) return lookback @property def output_names(self): """ Returns a list of the output names returned by this function. """ ret = self.__local.outputs.keys() if not isinstance(ret, list): ret = list(ret) return ret @property def outputs(self): """ Returns the TA function values for the currently set input_arrays and parameters. Returned values are a ndarray if there is only one output or a list of ndarrays for more than one output. """ local = self.__local if not local.outputs_valid: self.__call_function() ret = local.outputs.values() if not isinstance(ret, list): ret = list(ret) if __PANDAS_DATAFRAME is not None and \ isinstance(local.input_arrays, __PANDAS_DATAFRAME): index = local.input_arrays.index if len(ret) == 1: return __PANDAS_SERIES(ret[0], index=index) else: return __PANDAS_DATAFRAME(numpy.column_stack(ret), index=index, columns=self.output_names) elif __POLARS_DATAFRAME is not None and \ isinstance(local.input_arrays, __POLARS_DATAFRAME): if len(ret) == 1: return __POLARS_SERIES(ret[0]) else: return __POLARS_DATAFRAME(numpy.column_stack(ret), schema=self.output_names) else: return ret[0] if len(ret) == 1 else ret def run(self, input_arrays=None): """ run([input_arrays=None]) This is a shortcut to the outputs property that also allows setting the input_arrays dict. """ if input_arrays: self.set_input_arrays(input_arrays) self.__call_function() return self.outputs def __call__(self, *args, **kwargs): """ func_instance([input_arrays,] [parameter_args,] [input_price_series_kwargs,] [parameter_kwargs]) This is a shortcut to the outputs property that also allows setting the input_arrays dict and function parameters. """ local = self.__local # do not cache ta-func parameters passed to __call__ opt_input_values = [(param_name, local.opt_inputs[param_name]['value']) for param_name in local.opt_inputs.keys()] price_series_name_values = [(n, local.input_names[n]['price_series']) for n in local.input_names] # allow calling with same signature as talib.func module functions args = list(args) input_arrays = {} input_price_series_names = self.__input_price_series_names() if args and not isinstance(args[0], __INPUT_ARRAYS_TYPES): for i, arg in enumerate(args): if not isinstance(arg, __ARRAY_TYPES): break try: input_arrays[input_price_series_names[i]] = arg except IndexError: msg = 'Too many price arguments: expected %d (%s)' % ( len(input_price_series_names), ', '.join(input_price_series_names)) raise TypeError(msg) if __PANDAS_DATAFRAME is not None \ and isinstance(local.input_arrays, __PANDAS_DATAFRAME): no_existing_input_arrays = local.input_arrays.empty elif __POLARS_DATAFRAME is not None \ and isinstance(local.input_arrays, __POLARS_DATAFRAME): no_existing_input_arrays = local.input_arrays.is_empty() else: no_existing_input_arrays = not bool(local.input_arrays) if len(input_arrays) == len(input_price_series_names): self.set_input_arrays(input_arrays) args = args[len(input_arrays):] elif len(input_arrays) or (no_existing_input_arrays and ( not len(args) or not isinstance(args[0], __INPUT_ARRAYS_TYPES))): msg = 'Not enough price arguments: expected %d (%s)' % ( len(input_price_series_names), ', '.join(input_price_series_names)) raise TypeError(msg) self.set_function_args(*args, **kwargs) self.__call_function() # restore opt_input values to as they were before this call for param_name, value in opt_input_values: local.opt_inputs[param_name]['value'] = value local.info['parameters'] = self.parameters # restore input names values to as they were before this call for input_name, value in price_series_name_values: local.input_names[input_name]['price_series'] = value local.info['input_names'][input_name] = value return self.outputs # figure out which price series names we're using for inputs def __input_price_series_names(self): local = self.__local input_price_series_names = [] for input_name in local.input_names: price_series = local.input_names[input_name]['price_series'] if isinstance(price_series, list): # TALIB-supplied input names for name in price_series: input_price_series_names.append(name) else: # name came from __INPUT_PRICE_SERIES_DEFAULTS input_price_series_names.append(price_series) return input_price_series_names def __call_function(self): local = self.__local input_price_series_names = self.__input_price_series_names() # populate the ordered args we'll call the function with args = [] for price_series in input_price_series_names: series = local.input_arrays[price_series] if __PANDAS_SERIES is not None and \ isinstance(series, __PANDAS_SERIES): series = series.values.astype(float) elif __POLARS_SERIES is not None and \ isinstance(series, __POLARS_SERIES): series = series.to_numpy().astype(float) args.append(series) for opt_input in local.opt_inputs: value = self.__get_opt_input_value(opt_input) args.append(value) # Use the func module to actually call the function. results = self.func_object(*args) if isinstance(results, np.ndarray): keys = local.outputs.keys() if not isinstance(keys, list): keys = list(keys) local.outputs[keys[0]] = results else: for i, output in enumerate(local.outputs): local.outputs[output] = results[i] local.outputs_valid = True def __check_opt_input_value(self, input_name, value): type_ = self.__local.opt_inputs[input_name]['type'] if type_ in {lib.TA_OptInput_IntegerList, lib.TA_OptInput_IntegerRange}: type_ = int elif type_ in {lib.TA_OptInput_RealList, lib.TA_OptInput_RealRange}: type_ = float if isinstance(value, type_): return True elif value is not None: raise TypeError( 'Invalid parameter value for %s (expected %s, got %s)' % ( input_name, type_.__name__, type(value).__name__)) return False def __get_opt_input_value(self, input_name): """ Returns the user-set value if there is one, otherwise the default. """ local = self.__local value = local.opt_inputs[input_name]['value'] if value is None: value = local.opt_inputs[input_name]['default_value'] return value def __repr__(self): return '%s' % self.info def __unicode__(self): return unicode(self.__str__()) def __str__(self): return _get_defaults_and_docs(self.info)[1] # docstring includes defaults ###################### INTERNAL python-level functions ####################### # These map 1-1 with native C TALIB abstract interface calls. Their names # are the same except for having the leading 4 characters lowercased (and # the Alloc/Free function pairs which have been combined into single get # functions) # # These are TA function information-discovery calls. The Function class # encapsulates these functions into an easy-to-use, pythonic interface. It's # therefore recommended over using these functions directly. def _ta_getGroupTable(): """ Returns the list of available TALIB function group names. *slow* """ cdef lib.TA_StringTable *table _ta_check_success('TA_GroupTableAlloc', lib.TA_GroupTableAlloc(&table)) groups = [] for i in xrange(table.size): groups.append(deref(&table.string[i])) _ta_check_success('TA_GroupTableFree', lib.TA_GroupTableFree(table)) return groups def _ta_getFuncTable(char *group): """ Returns a list of the functions for the specified group name. *slow* """ cdef lib.TA_StringTable *table _ta_check_success('TA_FuncTableAlloc', lib.TA_FuncTableAlloc(group, &table)) functions = [] for i in xrange(table.size): functions.append(deref(&table.string[i])) _ta_check_success('TA_FuncTableFree', lib.TA_FuncTableFree(table)) return functions def __get_flags(int flag, dict flags_lookup_dict): """ TA-LIB provides hints for multiple flags as a bitwise-ORed int. This function returns the flags from flag found in the provided flags_lookup_dict. """ value_range = flags_lookup_dict.keys() if not isinstance(value_range, list): value_range = list(value_range) min_int = int(math.log(min(value_range), 2)) max_int = int(math.log(max(value_range), 2)) # if the flag we got is out-of-range, it just means no extra info provided if flag < 1 or flag > 2**max_int: return None # In this loop, i is essentially the bit-position, which represents an # input from flags_lookup_dict. We loop through as many flags_lookup_dict # bit-positions as we need to check, bitwise-ANDing each with flag for a hit. ret = [] for i in xrange(min_int, max_int+1): if 2**i & flag: ret.append(flags_lookup_dict[2**i]) return ret TA_FUNC_FLAGS = { 16777216: 'Output scale same as input', 67108864: 'Output is over volume', 134217728: 'Function has an unstable period', 268435456: 'Output is a candlestick' } # when flag is 0, the function (should) work on any reasonable input ndarray TA_INPUT_FLAGS = { 1: 'open', 2: 'high', 4: 'low', 8: 'close', 16: 'volume', 32: 'openInterest', 64: 'timeStamp' } TA_OUTPUT_FLAGS = { 1: 'Line', 2: 'Dotted Line', 4: 'Dashed Line', 8: 'Dot', 16: 'Histogram', 32: 'Pattern (Bool)', 64: 'Bull/Bear Pattern (Bearish < 0, Neutral = 0, Bullish > 0)', 128: 'Strength Pattern ([-200..-100] = Bearish, [-100..0] = Getting Bearish, 0 = Neutral, [0..100] = Getting Bullish, [100-200] = Bullish)', 256: 'Output can be positive', 512: 'Output can be negative', 1024: 'Output can be zero', 2048: 'Values represent an upper limit', 4096: 'Values represent a lower limit' } def _ta_getFuncInfo(char *function_name): """ Returns the info dict for the function. It has the following keys: name, group, help, flags, num_inputs, num_opt_inputs and num_outputs. """ cdef const lib.TA_FuncInfo *info retCode = lib.TA_GetFuncInfo(__ta_getFuncHandle(function_name), &info) _ta_check_success('TA_GetFuncInfo', retCode) return { 'name': bytes2str(info.name), 'group': bytes2str(info.group), 'display_name': bytes2str(info.hint), 'function_flags': __get_flags(info.flags, TA_FUNC_FLAGS), 'num_inputs': int(info.nbInput), 'num_opt_inputs': int(info.nbOptInput), 'num_outputs': int(info.nbOutput) } def _ta_getInputParameterInfo(char *function_name, int idx): """ Returns the function's input info dict for the given index. It has two keys: name and flags. """ cdef const lib.TA_InputParameterInfo *info retCode = lib.TA_GetInputParameterInfo(__ta_getFuncHandle(function_name), idx, &info) _ta_check_success('TA_GetInputParameterInfo', retCode) name = bytes2str(info.paramName) name = name[len('in'):].lower() if 'real' in name: name = name.replace('real', 'price') elif 'price' in name: name = 'prices' return { 'name': name, 'price_series': __get_flags(info.flags, TA_INPUT_FLAGS) } def _ta_getOptInputParameterInfo(char *function_name, int idx): """ Returns the function's opt_input info dict for the given index. It has the following keys: name, display_name, type, help, default_value and value. """ cdef const lib.TA_OptInputParameterInfo *info retCode = lib.TA_GetOptInputParameterInfo(__ta_getFuncHandle(function_name), idx, &info) _ta_check_success('TA_GetOptInputParameterInfo', retCode) name = bytes2str(info.paramName) name = name[len('optIn'):].lower() default_value = int(info.defaultValue) if info.type > 1 else info.defaultValue return { 'name': name, 'display_name': bytes2str(info.displayName), 'type': info.type, 'help': bytes2str(info.hint), 'default_value': default_value, 'value': None } def _ta_getOutputParameterInfo(char *function_name, int idx): """ Returns the function's output info dict for the given index. It has two keys: name and flags. """ cdef const lib.TA_OutputParameterInfo *info retCode = lib.TA_GetOutputParameterInfo(__ta_getFuncHandle(function_name), idx, &info) _ta_check_success('TA_GetOutputParameterInfo', retCode) name = bytes2str(info.paramName) name = name[len('out'):].lower() # chop off leading 'real' if a descriptive name follows if 'real' in name and name not in ['real', 'real0', 'real1']: name = name[len('real'):] return { 'name': name, 'flags': __get_flags(info.flags, TA_OUTPUT_FLAGS) } def _get_defaults_and_docs(func_info): """ Returns a tuple with two outputs: defaults, a dict of parameter defaults, and documentation, a formatted docstring for the function. .. Note: func_info should come from Function.info, *not* _ta_getFuncInfo. """ defaults = {} func_line = [func_info['name'], '('] func_args = ['[input_arrays]'] docs = [] docs.append('%(display_name)s (%(group)s)\n' % func_info) input_names = func_info['input_names'] docs.append('Inputs:') for input_name in input_names: value = input_names[input_name] if not isinstance(value, list): value = '(any ndarray)' docs.append(' %s: %s' % (input_name, value)) params = func_info['parameters'] if params: docs.append('Parameters:') for param in params: docs.append(' %s: %s' % (param, params[param])) func_args.append('[%s=%s]' % (param, params[param])) defaults[param] = params[param] if param == 'matype': docs[-1] = ' '.join([docs[-1], '(%s)' % MA_Type[params[param]]]) outputs = func_info['output_names'] docs.append('Outputs:') for output in outputs: if output == 'integer': output = 'integer (values are -100, 0 or 100)' docs.append(' %s' % output) func_line.append(', '.join(func_args)) func_line.append(')\n') docs.insert(0, ''.join(func_line)) documentation = '\n'.join(docs) return defaults, documentation ############### PRIVATE C-level-only functions ########################### # These map 1-1 with native C TALIB abstract interface calls. Their names are the # same except for having the leading 4 characters lowercased. # These functions are for: # - Getting TALIB handle and paramholder pointers # - Setting TALIB paramholder optInput values and calling the lookback function cdef const lib.TA_FuncHandle* __ta_getFuncHandle(char *function_name): """ Returns a pointer to a function handle for the given function name """ cdef const lib.TA_FuncHandle *handle _ta_check_success('TA_GetFuncHandle', lib.TA_GetFuncHandle(function_name, &handle)) return handle cdef lib.TA_ParamHolder* __ta_paramHolderAlloc(char *function_name): """ Returns a pointer to a parameter holder for the given function name """ cdef lib.TA_ParamHolder *holder retCode = lib.TA_ParamHolderAlloc(__ta_getFuncHandle(function_name), &holder) _ta_check_success('TA_ParamHolderAlloc', retCode) return holder cdef int __ta_paramHolderFree(lib.TA_ParamHolder *params): """ Frees the memory allocated by __ta_paramHolderAlloc (call when done with the parameter holder) WARNING: Not properly calling this function will cause memory leaks! """ _ta_check_success('TA_ParamHolderFree', lib.TA_ParamHolderFree(params)) cdef int __ta_setOptInputParamInteger(lib.TA_ParamHolder *holder, int idx, int value): retCode = lib.TA_SetOptInputParamInteger(holder, idx, value) _ta_check_success('TA_SetOptInputParamInteger', retCode) cdef int __ta_setOptInputParamReal(lib.TA_ParamHolder *holder, int idx, double value): retCode = lib.TA_SetOptInputParamReal(holder, idx, value) _ta_check_success('TA_SetOptInputParamReal', retCode) cdef int __ta_getLookback(lib.TA_ParamHolder *holder): cdef int lookback retCode = lib.TA_GetLookback(holder, &lookback) _ta_check_success('TA_GetLookback', retCode) return lookback ================================================ FILE: talib/_common.pxi ================================================ cimport _ta_lib as lib from _ta_lib cimport TA_RetCode, TA_FuncUnstId __ta_version__ = lib.TA_GetVersionString() cpdef _ta_check_success(str function_name, TA_RetCode ret_code): if ret_code == 0: return True elif ret_code == 1: description = 'Library Not Initialized (TA_LIB_NOT_INITIALIZE)' elif ret_code == 2: description = 'Bad Parameter (TA_BAD_PARAM)' elif ret_code == 3: description = 'Allocation Error (TA_ALLOC_ERR)' elif ret_code == 4: description = 'Group Not Found (TA_GROUP_NOT_FOUND)' elif ret_code == 5: description = 'Function Not Found (TA_FUNC_NOT_FOUND)' elif ret_code == 6: description = 'Invalid Handle (TA_INVALID_HANDLE)' elif ret_code == 7: description = 'Invalid Parameter Holder (TA_INVALID_PARAM_HOLDER)' elif ret_code == 8: description = 'Invalid Parameter Holder Type (TA_INVALID_PARAM_HOLDER_TYPE)' elif ret_code == 9: description = 'Invalid Parameter Function (TA_INVALID_PARAM_FUNCTION)' elif ret_code == 10: description = 'Input Not All Initialized (TA_INPUT_NOT_ALL_INITIALIZE)' elif ret_code == 11: description = 'Output Not All Initialized (TA_OUTPUT_NOT_ALL_INITIALIZE)' elif ret_code == 12: description = 'Out-of-Range Start Index (TA_OUT_OF_RANGE_START_INDEX)' elif ret_code == 13: description = 'Out-of-Range End Index (TA_OUT_OF_RANGE_END_INDEX)' elif ret_code == 14: description = 'Invalid List Type (TA_INVALID_LIST_TYPE)' elif ret_code == 15: description = 'Bad Object (TA_BAD_OBJECT)' elif ret_code == 16: description = 'Not Supported (TA_NOT_SUPPORTED)' elif ret_code == 5000: description = 'Internal Error (TA_INTERNAL_ERROR)' elif ret_code == 65535: description = 'Unknown Error (TA_UNKNOWN_ERR)' else: description = 'Unknown Error' raise Exception('%s function failed with error code %s: %s' % ( function_name, ret_code, description)) def _ta_initialize(): cdef TA_RetCode ret_code ret_code = lib.TA_Initialize() _ta_check_success('TA_Initialize', ret_code) def _ta_shutdown(): cdef TA_RetCode ret_code ret_code = lib.TA_Shutdown() _ta_check_success('TA_Shutdown', ret_code) class MA_Type(object): SMA, EMA, WMA, DEMA, TEMA, TRIMA, KAMA, MAMA, T3 = range(9) def __init__(self): self._lookup = { MA_Type.SMA: 'Simple Moving Average', MA_Type.EMA: 'Exponential Moving Average', MA_Type.WMA: 'Weighted Moving Average', MA_Type.DEMA: 'Double Exponential Moving Average', MA_Type.TEMA: 'Triple Exponential Moving Average', MA_Type.TRIMA: 'Triangular Moving Average', MA_Type.KAMA: 'Kaufman Adaptive Moving Average', MA_Type.MAMA: 'MESA Adaptive Moving Average', MA_Type.T3: 'Triple Generalized Double Exponential Moving Average', } def __getitem__(self, type_): return self._lookup[type_] MA_Type = MA_Type() _ta_func_unst_ids = {'NONE': -1} for i, name in enumerate([ 'ADX', 'ADXR', 'ATR', 'CMO', 'DX', 'EMA', 'HT_DCPERIOD', 'HT_DCPHASE', 'HT_PHASOR', 'HT_SINE', 'HT_TRENDLINE', 'HT_TRENDMODE', 'KAMA', 'MAMA', 'MFI', 'MINUS_DI', 'MINUS_DM', 'NATR', 'PLUS_DI', 'PLUS_DM', 'RSI', 'STOCHRSI', 'T3', 'ALL' ]): _ta_func_unst_ids[name] = i def _ta_set_unstable_period(name, period): cdef TA_RetCode ret_code cdef TA_FuncUnstId id = _ta_func_unst_ids[name] ret_code = lib.TA_SetUnstablePeriod(id, period) _ta_check_success('TA_SetUnstablePeriod', ret_code) def _ta_get_unstable_period(name): cdef unsigned int period cdef TA_FuncUnstId id = _ta_func_unst_ids[name] period = lib.TA_GetUnstablePeriod(id) return period def _ta_set_compatibility(value): cdef TA_RetCode ret_code ret_code = lib.TA_SetCompatibility(value) _ta_check_success('TA_SetCompatibility', ret_code) def _ta_get_compatibility(): cdef int value value = lib.TA_GetCompatibility() return value class CandleSettingType(object): BodyLong, BodyVeryLong, BodyShort, BodyDoji, ShadowLong, ShadowVeryLong, \ ShadowShort, ShadowVeryShort, Near, Far, Equal, AllCandleSettings = \ range(12) CandleSettingType = CandleSettingType() class RangeType(object): RealBody, HighLow, Shadows = range(3) RangeType = RangeType() def _ta_set_candle_settings(settingtype, rangetype, avgperiod, factor): cdef TA_RetCode ret_code ret_code = lib.TA_SetCandleSettings(settingtype, rangetype, avgperiod, factor) _ta_check_success('TA_SetCandleSettings', ret_code) def _ta_restore_candle_default_settings(settingtype): cdef TA_RetCode ret_code ret_code = lib.TA_RestoreCandleDefaultSettings(settingtype) _ta_check_success('TA_RestoreCandleDefaultSettings', ret_code) ================================================ FILE: talib/_func.pxi ================================================ cimport numpy as np from numpy import nan from cython import boundscheck, wraparound # _ta_check_success: defined in _common.pxi cdef double NaN = nan cdef extern from "numpy/arrayobject.h": int PyArray_TYPE(np.ndarray) np.ndarray PyArray_EMPTY(int, np.npy_intp*, int, int) int PyArray_FLAGS(np.ndarray) np.ndarray PyArray_GETCONTIGUOUS(np.ndarray) np.import_array() # Initialize the NumPy C API cimport _ta_lib as lib from _ta_lib cimport TA_RetCode cdef np.ndarray check_array(np.ndarray real): if PyArray_TYPE(real) != np.NPY_DOUBLE: 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_ARRAY_C_CONTIGUOUS): real = PyArray_GETCONTIGUOUS(real) return real cdef np.npy_intp check_length2(np.ndarray a1, np.ndarray a2) except -1: cdef: np.npy_intp length length = a1.shape[0] if length != a2.shape[0]: raise Exception("input array lengths are different") return length cdef np.npy_intp check_length3(np.ndarray a1, np.ndarray a2, np.ndarray a3) except -1: cdef: np.npy_intp length length = a1.shape[0] if length != a2.shape[0]: raise Exception("input array lengths are different") if length != a3.shape[0]: raise Exception("input array lengths are different") return length cdef np.npy_intp check_length4(np.ndarray a1, np.ndarray a2, np.ndarray a3, np.ndarray a4) except -1: cdef: np.npy_intp length length = a1.shape[0] if length != a2.shape[0]: raise Exception("input array lengths are different") if length != a3.shape[0]: raise Exception("input array lengths are different") if length != a4.shape[0]: raise Exception("input array lengths are different") return length cdef np.npy_int check_begidx1(np.npy_intp length, double* a1): cdef: double val for i from 0 <= i < length: val = a1[i] if val != val: continue return i else: return length - 1 cdef np.npy_int check_begidx2(np.npy_intp length, double* a1, double* a2): cdef: double val for i from 0 <= i < length: val = a1[i] if val != val: continue val = a2[i] if val != val: continue return i else: return length - 1 cdef np.npy_int check_begidx3(np.npy_intp length, double* a1, double* a2, double* a3): cdef: double val for i from 0 <= i < length: val = a1[i] if val != val: continue val = a2[i] if val != val: continue val = a3[i] if val != val: continue return i else: return length - 1 cdef np.npy_int check_begidx4(np.npy_intp length, double* a1, double* a2, double* a3, double* a4): cdef: double val for i from 0 <= i < length: val = a1[i] if val != val: continue val = a2[i] if val != val: continue val = a3[i] if val != val: continue val = a4[i] if val != val: continue return i else: return length - 1 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_ARRAY_DEFAULT) outreal_data = outreal.data for i from 0 <= i < min(lookback, length): outreal_data[i] = NaN return outreal 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_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 ): """ ACOS(real) Vector Trigonometric ACos (Math Transform) Inputs: real: (any ndarray) 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_ACOS_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_ACOS( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_ACOS", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def AD( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , np.ndarray volume not None ): """ AD(high, low, close, volume) Chaikin A/D Line (Volume Indicators) Inputs: prices: ['high', 'low', 'close', 'volume'] Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal high = check_array(high) low = check_array(low) close = check_array(close) volume = check_array(volume) length = check_length4(high, low, close, volume) begidx = check_begidx4(length, (high.data), (low.data), (close.data), (volume.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_AD_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_AD( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , (volume.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_AD", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ADD( np.ndarray real0 not None , np.ndarray real1 not None ): """ ADD(real0, real1) Vector Arithmetic Add (Math Operators) Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal real0 = check_array(real0) real1 = check_array(real1) length = check_length2(real0, real1) begidx = check_begidx2(length, (real0.data), (real1.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_ADD_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_ADD( 0 , endidx , (real0.data)+begidx , (real1.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_ADD", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ADOSC( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , np.ndarray volume not None , int fastperiod=-2**31 , int slowperiod=-2**31 ): """ ADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?]) Chaikin A/D Oscillator (Volume Indicators) Inputs: prices: ['high', 'low', 'close', 'volume'] Parameters: fastperiod: 3 slowperiod: 10 Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal high = check_array(high) low = check_array(low) close = check_array(close) volume = check_array(volume) length = check_length4(high, low, close, volume) begidx = check_begidx4(length, (high.data), (low.data), (close.data), (volume.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_ADOSC_Lookback( fastperiod , slowperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_ADOSC( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , (volume.data)+begidx , fastperiod , slowperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_ADOSC", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ADX( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ ADX(high, low, close[, timeperiod=?]) Average Directional Movement Index (Momentum Indicators) Inputs: prices: ['high', 'low', '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 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_ADX_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_ADX( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_ADX", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ADXR( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ ADXR(high, low, close[, timeperiod=?]) Average Directional Movement Index Rating (Momentum Indicators) Inputs: prices: ['high', 'low', '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 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_ADXR_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_ADXR( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_ADXR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def APO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int matype=0 ): """ APO(real[, fastperiod=?, slowperiod=?, matype=?]) Absolute Price Oscillator (Momentum Indicators) Inputs: real: (any ndarray) Parameters: fastperiod: 12 slowperiod: 26 matype: 0 (Simple Moving Average) Outputs: real """ 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_APO_Lookback( fastperiod , slowperiod , matype ) outreal = make_double_array(length, lookback) retCode = lib.TA_APO( 0 , endidx , (real.data)+begidx , fastperiod , slowperiod , matype , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_APO", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def AROON( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 ): """ AROON(high, low[, timeperiod=?]) Aroon (Momentum Indicators) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: aroondown aroonup """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outaroondown np.ndarray outaroonup high = check_array(high) low = check_array(low) length = check_length2(high, low) begidx = check_begidx2(length, (high.data), (low.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_AROON_Lookback( timeperiod ) outaroondown = make_double_array(length, lookback) outaroonup = make_double_array(length, lookback) retCode = lib.TA_AROON( 0 , endidx , (high.data)+begidx , (low.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outaroondown.data)+lookback , (outaroonup.data)+lookback ) _ta_check_success("TA_AROON", retCode) return outaroondown , outaroonup @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def AROONOSC( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 ): """ AROONOSC(high, low[, timeperiod=?]) Aroon Oscillator (Momentum Indicators) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal high = check_array(high) low = check_array(low) length = check_length2(high, low) begidx = check_begidx2(length, (high.data), (low.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_AROONOSC_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_AROONOSC( 0 , endidx , (high.data)+begidx , (low.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_AROONOSC", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ASIN( np.ndarray real not None ): """ ASIN(real) Vector Trigonometric ASin (Math Transform) Inputs: real: (any ndarray) 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_ASIN_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_ASIN( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_ASIN", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ATAN( np.ndarray real not None ): """ ATAN(real) Vector Trigonometric ATan (Math Transform) Inputs: real: (any ndarray) 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_ATAN_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_ATAN( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_ATAN", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ATR( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ ATR(high, low, close[, timeperiod=?]) Average True Range (Volatility Indicators) Inputs: prices: ['high', 'low', '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 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_ATR_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_ATR( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_ATR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def AVGPRICE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ AVGPRICE(open, high, low, close) Average Price (Price Transform) Inputs: prices: ['open', 'high', 'low', 'close'] 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) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_AVGPRICE_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_AVGPRICE( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _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 ): """ BBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?]) Bollinger Bands (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 5 nbdevup: 2.0 nbdevdn: 2.0 matype: 0 (Simple Moving Average) Outputs: upperband middleband lowerband """ 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 real = check_array(real) length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_BBANDS_Lookback( timeperiod , nbdevup , nbdevdn , matype ) outrealupperband = make_double_array(length, lookback) outrealmiddleband = make_double_array(length, lookback) outreallowerband = make_double_array(length, lookback) retCode = lib.TA_BBANDS( 0 , endidx , (real.data)+begidx , timeperiod , nbdevup , nbdevdn , matype , &outbegidx , &outnbelement , (outrealupperband.data)+lookback , (outrealmiddleband.data)+lookback , (outreallowerband.data)+lookback ) _ta_check_success("TA_BBANDS", 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 BETA( np.ndarray real0 not None , np.ndarray real1 not None , int timeperiod=-2**31 ): """ BETA(real0, real1[, timeperiod=?]) Beta (Statistic Functions) Inputs: real0: (any ndarray) real1: (any ndarray) Parameters: timeperiod: 5 Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal real0 = check_array(real0) real1 = check_array(real1) length = check_length2(real0, real1) begidx = check_begidx2(length, (real0.data), (real1.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_BETA_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_BETA( 0 , endidx , (real0.data)+begidx , (real1.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_BETA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def BOP( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ BOP(open, high, low, close) Balance Of Power (Momentum Indicators) Inputs: prices: ['open', 'high', 'low', 'close'] 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) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_BOP_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_BOP( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_BOP", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CCI( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ CCI(high, low, close[, timeperiod=?]) Commodity Channel Index (Momentum Indicators) Inputs: prices: ['high', 'low', '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 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_CCI_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_CCI( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_CCI", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDL2CROWS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL2CROWS(open, high, low, close) Two Crows (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDL2CROWS_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDL2CROWS( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDL2CROWS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDL3BLACKCROWS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL3BLACKCROWS(open, high, low, close) Three Black Crows (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDL3BLACKCROWS_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDL3BLACKCROWS( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDL3BLACKCROWS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDL3INSIDE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL3INSIDE(open, high, low, close) Three Inside Up/Down (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDL3INSIDE_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDL3INSIDE( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDL3INSIDE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDL3LINESTRIKE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL3LINESTRIKE(open, high, low, close) Three-Line Strike (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDL3LINESTRIKE_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDL3LINESTRIKE( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDL3LINESTRIKE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDL3OUTSIDE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL3OUTSIDE(open, high, low, close) Three Outside Up/Down (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDL3OUTSIDE_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDL3OUTSIDE( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDL3OUTSIDE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDL3STARSINSOUTH( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL3STARSINSOUTH(open, high, low, close) Three Stars In The South (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDL3STARSINSOUTH_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDL3STARSINSOUTH( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDL3STARSINSOUTH", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDL3WHITESOLDIERS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL3WHITESOLDIERS(open, high, low, close) Three Advancing White Soldiers (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDL3WHITESOLDIERS_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDL3WHITESOLDIERS( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDL3WHITESOLDIERS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLABANDONEDBABY( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , double penetration=0.3 ): """ CDLABANDONEDBABY(open, high, low, close[, penetration=?]) Abandoned Baby (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLABANDONEDBABY_Lookback( penetration ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLABANDONEDBABY( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , penetration , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLABANDONEDBABY", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLADVANCEBLOCK( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLADVANCEBLOCK(open, high, low, close) Advance Block (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLADVANCEBLOCK_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLADVANCEBLOCK( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLADVANCEBLOCK", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLBELTHOLD( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLBELTHOLD(open, high, low, close) Belt-hold (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLBELTHOLD_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLBELTHOLD( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLBELTHOLD", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLBREAKAWAY( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLBREAKAWAY(open, high, low, close) Breakaway (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLBREAKAWAY_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLBREAKAWAY( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLBREAKAWAY", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLCLOSINGMARUBOZU( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLCLOSINGMARUBOZU(open, high, low, close) Closing Marubozu (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLCLOSINGMARUBOZU_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLCLOSINGMARUBOZU( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLCLOSINGMARUBOZU", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLCONCEALBABYSWALL( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLCONCEALBABYSWALL(open, high, low, close) Concealing Baby Swallow (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLCONCEALBABYSWALL_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLCONCEALBABYSWALL( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLCONCEALBABYSWALL", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLCOUNTERATTACK( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLCOUNTERATTACK(open, high, low, close) Counterattack (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLCOUNTERATTACK_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLCOUNTERATTACK( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLCOUNTERATTACK", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLDARKCLOUDCOVER( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , double penetration=0.5 ): """ CDLDARKCLOUDCOVER(open, high, low, close[, penetration=?]) Dark Cloud Cover (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.5 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLDARKCLOUDCOVER_Lookback( penetration ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLDARKCLOUDCOVER( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , penetration , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLDARKCLOUDCOVER", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLDOJI( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLDOJI(open, high, low, close) Doji (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLDOJI_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLDOJI( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLDOJI", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLDOJISTAR( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLDOJISTAR(open, high, low, close) Doji Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLDOJISTAR_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLDOJISTAR( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLDOJISTAR", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLDRAGONFLYDOJI( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLDRAGONFLYDOJI(open, high, low, close) Dragonfly Doji (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLDRAGONFLYDOJI_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLDRAGONFLYDOJI( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLDRAGONFLYDOJI", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLENGULFING( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLENGULFING(open, high, low, close) Engulfing Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLENGULFING_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLENGULFING( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLENGULFING", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLEVENINGDOJISTAR( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , double penetration=0.3 ): """ CDLEVENINGDOJISTAR(open, high, low, close[, penetration=?]) Evening Doji Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLEVENINGDOJISTAR_Lookback( penetration ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLEVENINGDOJISTAR( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , penetration , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLEVENINGDOJISTAR", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLEVENINGSTAR( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , double penetration=0.3 ): """ CDLEVENINGSTAR(open, high, low, close[, penetration=?]) Evening Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLEVENINGSTAR_Lookback( penetration ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLEVENINGSTAR( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , penetration , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLEVENINGSTAR", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLGAPSIDESIDEWHITE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLGAPSIDESIDEWHITE(open, high, low, close) Up/Down-gap side-by-side white lines (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLGAPSIDESIDEWHITE_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLGAPSIDESIDEWHITE( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLGAPSIDESIDEWHITE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLGRAVESTONEDOJI( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLGRAVESTONEDOJI(open, high, low, close) Gravestone Doji (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLGRAVESTONEDOJI_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLGRAVESTONEDOJI( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLGRAVESTONEDOJI", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLHAMMER( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHAMMER(open, high, low, close) Hammer (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLHAMMER_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLHAMMER( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLHAMMER", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLHANGINGMAN( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHANGINGMAN(open, high, low, close) Hanging Man (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLHANGINGMAN_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLHANGINGMAN( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLHANGINGMAN", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLHARAMI( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHARAMI(open, high, low, close) Harami Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLHARAMI_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLHARAMI( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLHARAMI", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLHARAMICROSS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHARAMICROSS(open, high, low, close) Harami Cross Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLHARAMICROSS_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLHARAMICROSS( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLHARAMICROSS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLHIGHWAVE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHIGHWAVE(open, high, low, close) High-Wave Candle (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLHIGHWAVE_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLHIGHWAVE( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLHIGHWAVE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLHIKKAKE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHIKKAKE(open, high, low, close) Hikkake Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLHIKKAKE_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLHIKKAKE( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLHIKKAKE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLHIKKAKEMOD( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHIKKAKEMOD(open, high, low, close) Modified Hikkake Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLHIKKAKEMOD_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLHIKKAKEMOD( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLHIKKAKEMOD", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLHOMINGPIGEON( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHOMINGPIGEON(open, high, low, close) Homing Pigeon (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLHOMINGPIGEON_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLHOMINGPIGEON( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLHOMINGPIGEON", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLIDENTICAL3CROWS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLIDENTICAL3CROWS(open, high, low, close) Identical Three Crows (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLIDENTICAL3CROWS_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLIDENTICAL3CROWS( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLIDENTICAL3CROWS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLINNECK( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLINNECK(open, high, low, close) In-Neck Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLINNECK_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLINNECK( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLINNECK", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLINVERTEDHAMMER( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLINVERTEDHAMMER(open, high, low, close) Inverted Hammer (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLINVERTEDHAMMER_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLINVERTEDHAMMER( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLINVERTEDHAMMER", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLKICKING( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLKICKING(open, high, low, close) Kicking (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLKICKING_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLKICKING( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLKICKING", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLKICKINGBYLENGTH( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLKICKINGBYLENGTH(open, high, low, close) Kicking - bull/bear determined by the longer marubozu (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLKICKINGBYLENGTH_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLKICKINGBYLENGTH( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLKICKINGBYLENGTH", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLLADDERBOTTOM( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLLADDERBOTTOM(open, high, low, close) Ladder Bottom (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLLADDERBOTTOM_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLLADDERBOTTOM( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLLADDERBOTTOM", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLLONGLEGGEDDOJI( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLLONGLEGGEDDOJI(open, high, low, close) Long Legged Doji (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLLONGLEGGEDDOJI_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLLONGLEGGEDDOJI( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLLONGLEGGEDDOJI", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLLONGLINE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLLONGLINE(open, high, low, close) Long Line Candle (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLLONGLINE_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLLONGLINE( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLLONGLINE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLMARUBOZU( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLMARUBOZU(open, high, low, close) Marubozu (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLMARUBOZU_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLMARUBOZU( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLMARUBOZU", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLMATCHINGLOW( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLMATCHINGLOW(open, high, low, close) Matching Low (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLMATCHINGLOW_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLMATCHINGLOW( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLMATCHINGLOW", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLMATHOLD( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , double penetration=0.5 ): """ CDLMATHOLD(open, high, low, close[, penetration=?]) Mat Hold (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.5 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLMATHOLD_Lookback( penetration ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLMATHOLD( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , penetration , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLMATHOLD", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLMORNINGDOJISTAR( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , double penetration=0.3 ): """ CDLMORNINGDOJISTAR(open, high, low, close[, penetration=?]) Morning Doji Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLMORNINGDOJISTAR_Lookback( penetration ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLMORNINGDOJISTAR( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , penetration , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLMORNINGDOJISTAR", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLMORNINGSTAR( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , double penetration=0.3 ): """ CDLMORNINGSTAR(open, high, low, close[, penetration=?]) Morning Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLMORNINGSTAR_Lookback( penetration ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLMORNINGSTAR( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , penetration , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLMORNINGSTAR", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLONNECK( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLONNECK(open, high, low, close) On-Neck Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLONNECK_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLONNECK( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLONNECK", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLPIERCING( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLPIERCING(open, high, low, close) Piercing Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLPIERCING_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLPIERCING( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLPIERCING", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLRICKSHAWMAN( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLRICKSHAWMAN(open, high, low, close) Rickshaw Man (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLRICKSHAWMAN_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLRICKSHAWMAN( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLRICKSHAWMAN", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLRISEFALL3METHODS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLRISEFALL3METHODS(open, high, low, close) Rising/Falling Three Methods (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLRISEFALL3METHODS_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLRISEFALL3METHODS( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLRISEFALL3METHODS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLSEPARATINGLINES( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLSEPARATINGLINES(open, high, low, close) Separating Lines (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLSEPARATINGLINES_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLSEPARATINGLINES( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLSEPARATINGLINES", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLSHOOTINGSTAR( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLSHOOTINGSTAR(open, high, low, close) Shooting Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLSHOOTINGSTAR_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLSHOOTINGSTAR( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLSHOOTINGSTAR", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLSHORTLINE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLSHORTLINE(open, high, low, close) Short Line Candle (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLSHORTLINE_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLSHORTLINE( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLSHORTLINE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLSPINNINGTOP( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLSPINNINGTOP(open, high, low, close) Spinning Top (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLSPINNINGTOP_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLSPINNINGTOP( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLSPINNINGTOP", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLSTALLEDPATTERN( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLSTALLEDPATTERN(open, high, low, close) Stalled Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLSTALLEDPATTERN_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLSTALLEDPATTERN( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLSTALLEDPATTERN", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLSTICKSANDWICH( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLSTICKSANDWICH(open, high, low, close) Stick Sandwich (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLSTICKSANDWICH_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLSTICKSANDWICH( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLSTICKSANDWICH", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLTAKURI( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLTAKURI(open, high, low, close) Takuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLTAKURI_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLTAKURI( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLTAKURI", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLTASUKIGAP( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLTASUKIGAP(open, high, low, close) Tasuki Gap (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLTASUKIGAP_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLTASUKIGAP( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLTASUKIGAP", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLTHRUSTING( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLTHRUSTING(open, high, low, close) Thrusting Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLTHRUSTING_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLTHRUSTING( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLTHRUSTING", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLTRISTAR( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLTRISTAR(open, high, low, close) Tristar Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLTRISTAR_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLTRISTAR( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLTRISTAR", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLUNIQUE3RIVER( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLUNIQUE3RIVER(open, high, low, close) Unique 3 River (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLUNIQUE3RIVER_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLUNIQUE3RIVER( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLUNIQUE3RIVER", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLUPSIDEGAP2CROWS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLUPSIDEGAP2CROWS(open, high, low, close) Upside Gap Two Crows (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLUPSIDEGAP2CROWS_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLUPSIDEGAP2CROWS( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLUPSIDEGAP2CROWS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CDLXSIDEGAP3METHODS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLXSIDEGAP3METHODS(open, high, low, close) Upside/Downside Gap Three Methods (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger open = check_array(open) high = check_array(high) low = check_array(low) close = check_array(close) length = check_length4(open, high, low, close) begidx = check_begidx4(length, (open.data), (high.data), (low.data), (close.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CDLXSIDEGAP3METHODS_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_CDLXSIDEGAP3METHODS( 0 , endidx , (open.data)+begidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_CDLXSIDEGAP3METHODS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CEIL( np.ndarray real not None ): """ CEIL(real) Vector Ceil (Math Transform) Inputs: real: (any ndarray) 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_CEIL_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_CEIL( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_CEIL", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CMO( np.ndarray real not None , int timeperiod=-2**31 ): """ CMO(real[, timeperiod=?]) Chande Momentum Oscillator (Momentum Indicators) 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_CMO_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_CMO( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_CMO", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def CORREL( np.ndarray real0 not None , np.ndarray real1 not None , int timeperiod=-2**31 ): """ CORREL(real0, real1[, timeperiod=?]) Pearson's Correlation Coefficient (r) (Statistic Functions) Inputs: real0: (any ndarray) real1: (any ndarray) Parameters: timeperiod: 30 Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal real0 = check_array(real0) real1 = check_array(real1) length = check_length2(real0, real1) begidx = check_begidx2(length, (real0.data), (real1.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_CORREL_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_CORREL( 0 , endidx , (real0.data)+begidx , (real1.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_CORREL", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def COS( np.ndarray real not None ): """ COS(real) Vector Trigonometric Cos (Math Transform) Inputs: real: (any ndarray) 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_COS_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_COS( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_COS", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def COSH( np.ndarray real not None ): """ COSH(real) Vector Trigonometric Cosh (Math Transform) Inputs: real: (any ndarray) 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_COSH_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_COSH( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_COSH", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def DEMA( np.ndarray real not None , int timeperiod=-2**31 ): """ DEMA(real[, timeperiod=?]) Double Exponential Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_DEMA_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_DEMA( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_DEMA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def DIV( np.ndarray real0 not None , np.ndarray real1 not None ): """ DIV(real0, real1) Vector Arithmetic Div (Math Operators) Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal real0 = check_array(real0) real1 = check_array(real1) length = check_length2(real0, real1) begidx = check_begidx2(length, (real0.data), (real1.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_DIV_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_DIV( 0 , endidx , (real0.data)+begidx , (real1.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_DIV", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def DX( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ DX(high, low, close[, timeperiod=?]) Directional Movement Index (Momentum Indicators) Inputs: prices: ['high', 'low', '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 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_DX_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_DX( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_DX", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def EMA( np.ndarray real not None , int timeperiod=-2**31 ): """ EMA(real[, timeperiod=?]) Exponential Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_EMA_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_EMA( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_EMA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def EXP( np.ndarray real not None ): """ EXP(real) Vector Arithmetic Exp (Math Transform) Inputs: real: (any ndarray) 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_EXP_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_EXP( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_EXP", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def FLOOR( np.ndarray real not None ): """ FLOOR(real) Vector Floor (Math Transform) Inputs: real: (any ndarray) 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_FLOOR_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_FLOOR( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_FLOOR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def HT_DCPERIOD( np.ndarray real not None ): """ HT_DCPERIOD(real) Hilbert Transform - Dominant Cycle Period (Cycle Indicators) Inputs: real: (any ndarray) 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_HT_DCPERIOD_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_HT_DCPERIOD( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_HT_DCPERIOD", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def HT_DCPHASE( np.ndarray real not None ): """ HT_DCPHASE(real) Hilbert Transform - Dominant Cycle Phase (Cycle Indicators) Inputs: real: (any ndarray) 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_HT_DCPHASE_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_HT_DCPHASE( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_HT_DCPHASE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def HT_PHASOR( np.ndarray real not None ): """ HT_PHASOR(real) Hilbert Transform - Phasor Components (Cycle Indicators) Inputs: real: (any ndarray) Outputs: inphase quadrature """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinphase np.ndarray outquadrature real = check_array(real) length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_HT_PHASOR_Lookback( ) outinphase = make_double_array(length, lookback) outquadrature = make_double_array(length, lookback) retCode = lib.TA_HT_PHASOR( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outinphase.data)+lookback , (outquadrature.data)+lookback ) _ta_check_success("TA_HT_PHASOR", retCode) return outinphase , outquadrature @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def HT_SINE( np.ndarray real not None ): """ HT_SINE(real) Hilbert Transform - SineWave (Cycle Indicators) Inputs: real: (any ndarray) Outputs: sine leadsine """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outsine np.ndarray outleadsine real = check_array(real) length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_HT_SINE_Lookback( ) outsine = make_double_array(length, lookback) outleadsine = make_double_array(length, lookback) retCode = lib.TA_HT_SINE( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outsine.data)+lookback , (outleadsine.data)+lookback ) _ta_check_success("TA_HT_SINE", retCode) return outsine , outleadsine @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def HT_TRENDLINE( np.ndarray real not None ): """ HT_TRENDLINE(real) Hilbert Transform - Instantaneous Trendline (Overlap Studies) Inputs: real: (any ndarray) 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_HT_TRENDLINE_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_HT_TRENDLINE( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_HT_TRENDLINE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def HT_TRENDMODE( np.ndarray real not None ): """ HT_TRENDMODE(real) Hilbert Transform - Trend vs Cycle Mode (Cycle Indicators) Inputs: real: (any ndarray) Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger real = check_array(real) length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_HT_TRENDMODE_Lookback( ) outinteger = make_int_array(length, lookback) retCode = lib.TA_HT_TRENDMODE( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _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 ): """ KAMA(real[, timeperiod=?]) Kaufman Adaptive Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_KAMA_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_KAMA( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_KAMA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def LINEARREG( np.ndarray real not None , int timeperiod=-2**31 ): """ LINEARREG(real[, timeperiod=?]) Linear Regression (Statistic Functions) 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_LINEARREG_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_LINEARREG( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_LINEARREG", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def LINEARREG_ANGLE( np.ndarray real not None , int timeperiod=-2**31 ): """ LINEARREG_ANGLE(real[, timeperiod=?]) Linear Regression Angle (Statistic Functions) 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_LINEARREG_ANGLE_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_LINEARREG_ANGLE( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_LINEARREG_ANGLE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def LINEARREG_INTERCEPT( np.ndarray real not None , int timeperiod=-2**31 ): """ LINEARREG_INTERCEPT(real[, timeperiod=?]) Linear Regression Intercept (Statistic Functions) 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_LINEARREG_INTERCEPT_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_LINEARREG_INTERCEPT( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_LINEARREG_INTERCEPT", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def LINEARREG_SLOPE( np.ndarray real not None , int timeperiod=-2**31 ): """ LINEARREG_SLOPE(real[, timeperiod=?]) Linear Regression Slope (Statistic Functions) 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_LINEARREG_SLOPE_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_LINEARREG_SLOPE( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_LINEARREG_SLOPE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def LN( np.ndarray real not None ): """ LN(real) Vector Log Natural (Math Transform) Inputs: real: (any ndarray) 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_LN_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_LN( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_LN", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def LOG10( np.ndarray real not None ): """ LOG10(real) Vector Log10 (Math Transform) Inputs: real: (any ndarray) 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_LOG10_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_LOG10( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_LOG10", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MA( np.ndarray real not None , int timeperiod=-2**31 , int matype=0 ): """ MA(real[, timeperiod=?, matype=?]) Moving average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 matype: 0 (Simple Moving Average) 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_MA_Lookback( timeperiod , matype ) outreal = make_double_array(length, lookback) retCode = lib.TA_MA( 0 , endidx , (real.data)+begidx , timeperiod , matype , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_MA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MACD( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int signalperiod=-2**31 ): """ MACD(real[, fastperiod=?, slowperiod=?, signalperiod=?]) Moving Average Convergence/Divergence (Momentum Indicators) Inputs: real: (any ndarray) Parameters: fastperiod: 12 slowperiod: 26 signalperiod: 9 Outputs: macd macdsignal macdhist """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outmacd np.ndarray outmacdsignal np.ndarray outmacdhist real = check_array(real) length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_MACD_Lookback( fastperiod , slowperiod , signalperiod ) outmacd = make_double_array(length, lookback) outmacdsignal = make_double_array(length, lookback) outmacdhist = make_double_array(length, lookback) retCode = lib.TA_MACD( 0 , endidx , (real.data)+begidx , fastperiod , slowperiod , signalperiod , &outbegidx , &outnbelement , (outmacd.data)+lookback , (outmacdsignal.data)+lookback , (outmacdhist.data)+lookback ) _ta_check_success("TA_MACD", retCode) return outmacd , outmacdsignal , outmacdhist @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MACDEXT( np.ndarray real not None , int fastperiod=-2**31 , int fastmatype=0 , int slowperiod=-2**31 , int slowmatype=0 , int signalperiod=-2**31 , int signalmatype=0 ): """ MACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?]) MACD with controllable MA type (Momentum Indicators) Inputs: real: (any ndarray) Parameters: fastperiod: 12 fastmatype: 0 slowperiod: 26 slowmatype: 0 signalperiod: 9 signalmatype: 0 Outputs: macd macdsignal macdhist """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outmacd np.ndarray outmacdsignal np.ndarray outmacdhist real = check_array(real) length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_MACDEXT_Lookback( fastperiod , fastmatype , slowperiod , slowmatype , signalperiod , signalmatype ) outmacd = make_double_array(length, lookback) outmacdsignal = make_double_array(length, lookback) outmacdhist = make_double_array(length, lookback) retCode = lib.TA_MACDEXT( 0 , endidx , (real.data)+begidx , fastperiod , fastmatype , slowperiod , slowmatype , signalperiod , signalmatype , &outbegidx , &outnbelement , (outmacd.data)+lookback , (outmacdsignal.data)+lookback , (outmacdhist.data)+lookback ) _ta_check_success("TA_MACDEXT", retCode) return outmacd , outmacdsignal , outmacdhist @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MACDFIX( np.ndarray real not None , int signalperiod=-2**31 ): """ MACDFIX(real[, signalperiod=?]) Moving Average Convergence/Divergence Fix 12/26 (Momentum Indicators) Inputs: real: (any ndarray) Parameters: signalperiod: 9 Outputs: macd macdsignal macdhist """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outmacd np.ndarray outmacdsignal np.ndarray outmacdhist real = check_array(real) length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_MACDFIX_Lookback( signalperiod ) outmacd = make_double_array(length, lookback) outmacdsignal = make_double_array(length, lookback) outmacdhist = make_double_array(length, lookback) retCode = lib.TA_MACDFIX( 0 , endidx , (real.data)+begidx , signalperiod , &outbegidx , &outnbelement , (outmacd.data)+lookback , (outmacdsignal.data)+lookback , (outmacdhist.data)+lookback ) _ta_check_success("TA_MACDFIX", retCode) return outmacd , outmacdsignal , outmacdhist @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MAMA( np.ndarray real not None , double fastlimit=-4e37 , double slowlimit=-4e37 ): """ MAMA(real[, fastlimit=?, slowlimit=?]) MESA Adaptive Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: fastlimit: 0.5 slowlimit: 0.05 Outputs: mama fama """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outmama np.ndarray outfama real = check_array(real) length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_MAMA_Lookback( fastlimit , slowlimit ) outmama = make_double_array(length, lookback) outfama = make_double_array(length, lookback) retCode = lib.TA_MAMA( 0 , endidx , (real.data)+begidx , fastlimit , slowlimit , &outbegidx , &outnbelement , (outmama.data)+lookback , (outfama.data)+lookback ) _ta_check_success("TA_MAMA", retCode) return outmama , outfama @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MAVP( np.ndarray real not None , np.ndarray periods not None , int minperiod=-2**31 , int maxperiod=-2**31 , int matype=0 ): """ MAVP(real, periods[, minperiod=?, maxperiod=?, matype=?]) Moving average with variable period (Overlap Studies) Inputs: real: (any ndarray) periods: (any ndarray) Parameters: minperiod: 2 maxperiod: 30 matype: 0 (Simple Moving Average) Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal real = check_array(real) periods = check_array(periods) length = check_length2(real, periods) begidx = check_begidx2(length, (real.data), (periods.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_MAVP_Lookback( minperiod , maxperiod , matype ) outreal = make_double_array(length, lookback) retCode = lib.TA_MAVP( 0 , endidx , (real.data)+begidx , (periods.data)+begidx , minperiod , maxperiod , matype , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_MAVP", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MAX( np.ndarray real not None , int timeperiod=-2**31 ): """ MAX(real[, timeperiod=?]) Highest value over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_MAX_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_MAX( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_MAX", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MAXINDEX( np.ndarray real not None , int timeperiod=-2**31 ): """ MAXINDEX(real[, timeperiod=?]) Index of highest value over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger real = check_array(real) length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_MAXINDEX_Lookback( timeperiod ) outinteger = make_int_array(length, lookback) retCode = lib.TA_MAXINDEX( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_MAXINDEX", retCode) outinteger_data = outinteger.data for i from lookback <= i < length: outinteger_data[i] += begidx return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MEDPRICE( np.ndarray high not None , np.ndarray low not None ): """ MEDPRICE(high, low) Median Price (Price Transform) Inputs: prices: ['high', 'low'] Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal high = check_array(high) low = check_array(low) length = check_length2(high, low) begidx = check_begidx2(length, (high.data), (low.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_MEDPRICE_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_MEDPRICE( 0 , endidx , (high.data)+begidx , (low.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_MEDPRICE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MFI( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , np.ndarray volume not None , int timeperiod=-2**31 ): """ MFI(high, low, close, volume[, timeperiod=?]) Money Flow Index (Momentum Indicators) Inputs: prices: ['high', 'low', 'close', 'volume'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal high = check_array(high) low = check_array(low) close = check_array(close) volume = check_array(volume) length = check_length4(high, low, close, volume) begidx = check_begidx4(length, (high.data), (low.data), (close.data), (volume.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_MFI_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_MFI( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , (volume.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_MFI", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MIDPOINT( np.ndarray real not None , int timeperiod=-2**31 ): """ MIDPOINT(real[, timeperiod=?]) MidPoint over period (Overlap Studies) 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_MIDPOINT_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_MIDPOINT( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_MIDPOINT", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MIDPRICE( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 ): """ MIDPRICE(high, low[, timeperiod=?]) Midpoint Price over period (Overlap Studies) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal high = check_array(high) low = check_array(low) length = check_length2(high, low) begidx = check_begidx2(length, (high.data), (low.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_MIDPRICE_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_MIDPRICE( 0 , endidx , (high.data)+begidx , (low.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_MIDPRICE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MIN( np.ndarray real not None , int timeperiod=-2**31 ): """ MIN(real[, timeperiod=?]) Lowest value over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_MIN_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_MIN( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_MIN", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MININDEX( np.ndarray real not None , int timeperiod=-2**31 ): """ MININDEX(real[, timeperiod=?]) Index of lowest value over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outinteger real = check_array(real) length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_MININDEX_Lookback( timeperiod ) outinteger = make_int_array(length, lookback) retCode = lib.TA_MININDEX( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outinteger.data)+lookback ) _ta_check_success("TA_MININDEX", retCode) outinteger_data = outinteger.data for i from lookback <= i < length: outinteger_data[i] += begidx return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MINMAX( np.ndarray real not None , int timeperiod=-2**31 ): """ MINMAX(real[, timeperiod=?]) Lowest and highest values over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: min max """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outmin np.ndarray outmax real = check_array(real) length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_MINMAX_Lookback( timeperiod ) outmin = make_double_array(length, lookback) outmax = make_double_array(length, lookback) retCode = lib.TA_MINMAX( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outmin.data)+lookback , (outmax.data)+lookback ) _ta_check_success("TA_MINMAX", retCode) return outmin , outmax @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MINMAXINDEX( np.ndarray real not None , int timeperiod=-2**31 ): """ MINMAXINDEX(real[, timeperiod=?]) Indexes of lowest and highest values over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: minidx maxidx """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outminidx np.ndarray outmaxidx real = check_array(real) length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_MINMAXINDEX_Lookback( timeperiod ) outminidx = make_int_array(length, lookback) outmaxidx = make_int_array(length, lookback) retCode = lib.TA_MINMAXINDEX( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outminidx.data)+lookback , (outmaxidx.data)+lookback ) _ta_check_success("TA_MINMAXINDEX", retCode) outminidx_data = outminidx.data for i from lookback <= i < length: outminidx_data[i] += begidx outmaxidx_data = outmaxidx.data for i from lookback <= i < length: outmaxidx_data[i] += begidx return outminidx , outmaxidx @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MINUS_DI( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ MINUS_DI(high, low, close[, timeperiod=?]) Minus Directional Indicator (Momentum Indicators) Inputs: prices: ['high', 'low', '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 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_MINUS_DI_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_MINUS_DI( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_MINUS_DI", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MINUS_DM( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 ): """ MINUS_DM(high, low[, timeperiod=?]) Minus Directional Movement (Momentum Indicators) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal high = check_array(high) low = check_array(low) length = check_length2(high, low) begidx = check_begidx2(length, (high.data), (low.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_MINUS_DM_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_MINUS_DM( 0 , endidx , (high.data)+begidx , (low.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_MINUS_DM", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MOM( np.ndarray real not None , int timeperiod=-2**31 ): """ MOM(real[, timeperiod=?]) Momentum (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 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_MOM_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_MOM( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_MOM", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def MULT( np.ndarray real0 not None , np.ndarray real1 not None ): """ MULT(real0, real1) Vector Arithmetic Mult (Math Operators) Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal real0 = check_array(real0) real1 = check_array(real1) length = check_length2(real0, real1) begidx = check_begidx2(length, (real0.data), (real1.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_MULT_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_MULT( 0 , endidx , (real0.data)+begidx , (real1.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_MULT", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def NATR( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ NATR(high, low, close[, timeperiod=?]) Normalized Average True Range (Volatility Indicators) Inputs: prices: ['high', 'low', '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 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_NATR_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_NATR( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_NATR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def OBV( np.ndarray real not None , np.ndarray volume not None ): """ OBV(real, volume) On Balance Volume (Volume Indicators) Inputs: real: (any ndarray) prices: ['volume'] 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) volume = check_array(volume) length = check_length2(real, volume) begidx = check_begidx2(length, (real.data), (volume.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_OBV_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_OBV( 0 , endidx , (real.data)+begidx , (volume.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_OBV", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def PLUS_DI( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ PLUS_DI(high, low, close[, timeperiod=?]) Plus Directional Indicator (Momentum Indicators) Inputs: prices: ['high', 'low', '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 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_PLUS_DI_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_PLUS_DI( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_PLUS_DI", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def PLUS_DM( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 ): """ PLUS_DM(high, low[, timeperiod=?]) Plus Directional Movement (Momentum Indicators) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal high = check_array(high) low = check_array(low) length = check_length2(high, low) begidx = check_begidx2(length, (high.data), (low.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_PLUS_DM_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_PLUS_DM( 0 , endidx , (high.data)+begidx , (low.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_PLUS_DM", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def PPO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int matype=0 ): """ PPO(real[, fastperiod=?, slowperiod=?, matype=?]) Percentage Price Oscillator (Momentum Indicators) Inputs: real: (any ndarray) Parameters: fastperiod: 12 slowperiod: 26 matype: 0 (Simple Moving Average) Outputs: real """ 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_PPO_Lookback( fastperiod , slowperiod , matype ) outreal = make_double_array(length, lookback) retCode = lib.TA_PPO( 0 , endidx , (real.data)+begidx , fastperiod , slowperiod , matype , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_PPO", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ROC( np.ndarray real not None , int timeperiod=-2**31 ): """ ROC(real[, timeperiod=?]) Rate of change : ((real/prevPrice)-1)*100 (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 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_ROC_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_ROC( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_ROC", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ROCP( np.ndarray real not None , int timeperiod=-2**31 ): """ ROCP(real[, timeperiod=?]) Rate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 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_ROCP_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_ROCP( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_ROCP", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ROCR( np.ndarray real not None , int timeperiod=-2**31 ): """ ROCR(real[, timeperiod=?]) Rate of change ratio: (real/prevPrice) (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 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_ROCR_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_ROCR( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_ROCR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ROCR100( np.ndarray real not None , int timeperiod=-2**31 ): """ ROCR100(real[, timeperiod=?]) Rate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 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_ROCR100_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_ROCR100( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_ROCR100", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def RSI( np.ndarray real not None , int timeperiod=-2**31 ): """ RSI(real[, timeperiod=?]) Relative Strength Index (Momentum Indicators) 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_RSI_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_RSI( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_RSI", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def SAR( np.ndarray high not None , np.ndarray low not None , double acceleration=0.02 , double maximum=0.2 ): """ SAR(high, low[, acceleration=?, maximum=?]) Parabolic SAR (Overlap Studies) Inputs: prices: ['high', 'low'] Parameters: acceleration: 0.02 maximum: 0.2 Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal high = check_array(high) low = check_array(low) length = check_length2(high, low) begidx = check_begidx2(length, (high.data), (low.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_SAR_Lookback( acceleration , maximum ) outreal = make_double_array(length, lookback) retCode = lib.TA_SAR( 0 , endidx , (high.data)+begidx , (low.data)+begidx , acceleration , maximum , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_SAR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def SAREXT( np.ndarray high not None , np.ndarray low not None , double startvalue=-4e37 , double offsetonreverse=-4e37 , double accelerationinitlong=-4e37 , double accelerationlong=-4e37 , double accelerationmaxlong=-4e37 , double accelerationinitshort=-4e37 , double accelerationshort=-4e37 , double accelerationmaxshort=-4e37 ): """ SAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?]) Parabolic SAR - Extended (Overlap Studies) Inputs: prices: ['high', 'low'] Parameters: startvalue: 0.0 offsetonreverse: 0.0 accelerationinitlong: 0.02 accelerationlong: 0.02 accelerationmaxlong: 0.2 accelerationinitshort: 0.02 accelerationshort: 0.02 accelerationmaxshort: 0.2 Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal high = check_array(high) low = check_array(low) length = check_length2(high, low) begidx = check_begidx2(length, (high.data), (low.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_SAREXT_Lookback( startvalue , offsetonreverse , accelerationinitlong , accelerationlong , accelerationmaxlong , accelerationinitshort , accelerationshort , accelerationmaxshort ) outreal = make_double_array(length, lookback) retCode = lib.TA_SAREXT( 0 , endidx , (high.data)+begidx , (low.data)+begidx , startvalue , offsetonreverse , accelerationinitlong , accelerationlong , accelerationmaxlong , accelerationinitshort , accelerationshort , accelerationmaxshort , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_SAREXT", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def SIN( np.ndarray real not None ): """ SIN(real) Vector Trigonometric Sin (Math Transform) Inputs: real: (any ndarray) 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_SIN_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_SIN( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_SIN", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def SINH( np.ndarray real not None ): """ SINH(real) Vector Trigonometric Sinh (Math Transform) Inputs: real: (any ndarray) 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_SINH_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_SINH( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_SINH", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def SMA( np.ndarray real not None , int timeperiod=-2**31 ): """ SMA(real[, timeperiod=?]) Simple Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_SMA_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_SMA( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_SMA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def SQRT( np.ndarray real not None ): """ SQRT(real) Vector Square Root (Math Transform) Inputs: real: (any ndarray) 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_SQRT_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_SQRT( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_SQRT", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def STDDEV( np.ndarray real not None , int timeperiod=-2**31 , double nbdev=-4e37 ): """ STDDEV(real[, timeperiod=?, nbdev=?]) Standard Deviation (Statistic Functions) Inputs: real: (any ndarray) Parameters: timeperiod: 5 nbdev: 1.0 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_STDDEV_Lookback( timeperiod , nbdev ) outreal = make_double_array(length, lookback) retCode = lib.TA_STDDEV( 0 , endidx , (real.data)+begidx , timeperiod , nbdev , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_STDDEV", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def STOCH( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int fastk_period=-2**31 , int slowk_period=-2**31 , int slowk_matype=0 , int slowd_period=-2**31 , int slowd_matype=0 ): """ STOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?]) Stochastic (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: fastk_period: 5 slowk_period: 3 slowk_matype: 0 slowd_period: 3 slowd_matype: 0 Outputs: slowk slowd """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outslowk np.ndarray outslowd 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_STOCH_Lookback( fastk_period , slowk_period , slowk_matype , slowd_period , slowd_matype ) outslowk = make_double_array(length, lookback) outslowd = make_double_array(length, lookback) retCode = lib.TA_STOCH( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , fastk_period , slowk_period , slowk_matype , slowd_period , slowd_matype , &outbegidx , &outnbelement , (outslowk.data)+lookback , (outslowd.data)+lookback ) _ta_check_success("TA_STOCH", retCode) return outslowk , outslowd @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def STOCHF( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int fastk_period=-2**31 , int fastd_period=-2**31 , int fastd_matype=0 ): """ STOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?]) Stochastic Fast (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: fastk_period: 5 fastd_period: 3 fastd_matype: 0 Outputs: fastk fastd """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outfastk np.ndarray outfastd 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_STOCHF_Lookback( fastk_period , fastd_period , fastd_matype ) outfastk = make_double_array(length, lookback) outfastd = make_double_array(length, lookback) retCode = lib.TA_STOCHF( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , fastk_period , fastd_period , fastd_matype , &outbegidx , &outnbelement , (outfastk.data)+lookback , (outfastd.data)+lookback ) _ta_check_success("TA_STOCHF", retCode) return outfastk , outfastd @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def STOCHRSI( np.ndarray real not None , int timeperiod=-2**31 , int fastk_period=-2**31 , int fastd_period=-2**31 , int fastd_matype=0 ): """ STOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?]) Stochastic Relative Strength Index (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 14 fastk_period: 5 fastd_period: 3 fastd_matype: 0 Outputs: fastk fastd """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outfastk np.ndarray outfastd real = check_array(real) length = real.shape[0] begidx = check_begidx1(length, (real.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_STOCHRSI_Lookback( timeperiod , fastk_period , fastd_period , fastd_matype ) outfastk = make_double_array(length, lookback) outfastd = make_double_array(length, lookback) retCode = lib.TA_STOCHRSI( 0 , endidx , (real.data)+begidx , timeperiod , fastk_period , fastd_period , fastd_matype , &outbegidx , &outnbelement , (outfastk.data)+lookback , (outfastd.data)+lookback ) _ta_check_success("TA_STOCHRSI", retCode) return outfastk , outfastd @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def SUB( np.ndarray real0 not None , np.ndarray real1 not None ): """ SUB(real0, real1) Vector Arithmetic Subtraction (Math Operators) Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal real0 = check_array(real0) real1 = check_array(real1) length = check_length2(real0, real1) begidx = check_begidx2(length, (real0.data), (real1.data)) endidx = length - begidx - 1 lookback = begidx + lib.TA_SUB_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_SUB( 0 , endidx , (real0.data)+begidx , (real1.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_SUB", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def SUM( np.ndarray real not None , int timeperiod=-2**31 ): """ SUM(real[, timeperiod=?]) Summation (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_SUM_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_SUM( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_SUM", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def T3( np.ndarray real not None , int timeperiod=-2**31 , double vfactor=-4e37 ): """ T3(real[, timeperiod=?, vfactor=?]) Triple Exponential Moving Average (T3) (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 5 vfactor: 0.7 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_T3_Lookback( timeperiod , vfactor ) outreal = make_double_array(length, lookback) retCode = lib.TA_T3( 0 , endidx , (real.data)+begidx , timeperiod , vfactor , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_T3", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def TAN( np.ndarray real not None ): """ TAN(real) Vector Trigonometric Tan (Math Transform) Inputs: real: (any ndarray) 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_TAN_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_TAN( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_TAN", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def TANH( np.ndarray real not None ): """ TANH(real) Vector Trigonometric Tanh (Math Transform) Inputs: real: (any ndarray) 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_TANH_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_TANH( 0 , endidx , (real.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_TANH", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def TEMA( np.ndarray real not None , int timeperiod=-2**31 ): """ TEMA(real[, timeperiod=?]) Triple Exponential Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_TEMA_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_TEMA( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_TEMA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def TRANGE( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ TRANGE(high, low, close) True Range (Volatility Indicators) Inputs: prices: ['high', 'low', 'close'] Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal 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_TRANGE_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_TRANGE( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_TRANGE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def TRIMA( np.ndarray real not None , int timeperiod=-2**31 ): """ TRIMA(real[, timeperiod=?]) Triangular Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_TRIMA_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_TRIMA( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_TRIMA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def TRIX( np.ndarray real not None , int timeperiod=-2**31 ): """ TRIX(real[, timeperiod=?]) 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real """ 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_TRIX_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_TRIX( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_TRIX", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def TSF( np.ndarray real not None , int timeperiod=-2**31 ): """ TSF(real[, timeperiod=?]) Time Series Forecast (Statistic Functions) 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_TSF_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_TSF( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_TSF", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def TYPPRICE( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ TYPPRICE(high, low, close) Typical Price (Price Transform) Inputs: prices: ['high', 'low', 'close'] Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal 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_TYPPRICE_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_TYPPRICE( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_TYPPRICE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def ULTOSC( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod1=-2**31 , int timeperiod2=-2**31 , int timeperiod3=-2**31 ): """ ULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?]) Ultimate Oscillator (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod1: 7 timeperiod2: 14 timeperiod3: 28 Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal 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_ULTOSC_Lookback( timeperiod1 , timeperiod2 , timeperiod3 ) outreal = make_double_array(length, lookback) retCode = lib.TA_ULTOSC( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod1 , timeperiod2 , timeperiod3 , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_ULTOSC", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def VAR( np.ndarray real not None , int timeperiod=-2**31 , double nbdev=-4e37 ): """ VAR(real[, timeperiod=?, nbdev=?]) Variance (Statistic Functions) Inputs: real: (any ndarray) Parameters: timeperiod: 5 nbdev: 1.0 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_VAR_Lookback( timeperiod , nbdev ) outreal = make_double_array(length, lookback) retCode = lib.TA_VAR( 0 , endidx , (real.data)+begidx , timeperiod , nbdev , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_VAR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def WCLPRICE( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ WCLPRICE(high, low, close) Weighted Close Price (Price Transform) Inputs: prices: ['high', 'low', 'close'] Outputs: real """ cdef: np.npy_intp length int begidx, endidx, lookback TA_RetCode retCode int outbegidx int outnbelement np.ndarray outreal 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_WCLPRICE_Lookback( ) outreal = make_double_array(length, lookback) retCode = lib.TA_WCLPRICE( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_WCLPRICE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def WILLR( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ WILLR(high, low, close[, timeperiod=?]) Williams' %R (Momentum Indicators) Inputs: prices: ['high', 'low', '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 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_WILLR_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_WILLR( 0 , endidx , (high.data)+begidx , (low.data)+begidx , (close.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_WILLR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def WMA( np.ndarray real not None , int timeperiod=-2**31 ): """ WMA(real[, timeperiod=?]) Weighted Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_WMA_Lookback( timeperiod ) outreal = make_double_array(length, lookback) retCode = lib.TA_WMA( 0 , endidx , (real.data)+begidx , timeperiod , &outbegidx , &outnbelement , (outreal.data)+lookback ) _ta_check_success("TA_WMA", retCode) return outreal __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"] ================================================ FILE: talib/_stream.pxi ================================================ cimport numpy as np 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 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 def stream_ACOS( np.ndarray real not None ): """ ACOS(real) Vector Trigonometric ACos (Math Transform) Inputs: real: (any ndarray) 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_ACOS( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_ACOS", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_AD( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , np.ndarray volume not None ): """ AD(high, low, close, volume) Chaikin A/D Line (Volume Indicators) Inputs: prices: ['high', 'low', 'close', 'volume'] Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data double* volume_data int outbegidx int outnbelement double outreal high = check_array(high) high_data = high.data low = check_array(low) low_data = low.data close = check_array(close) close_data = close.data volume = check_array(volume) volume_data = volume.data length = check_length4(high, low, close, volume) outreal = NaN retCode = lib.TA_AD( (length) - 1 , (length) - 1 , high_data , low_data , close_data , volume_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_AD", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ADD( np.ndarray real0 not None , np.ndarray real1 not None ): """ ADD(real0, real1) Vector Arithmetic Add (Math Operators) Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* real0_data double* real1_data int outbegidx int outnbelement double outreal real0 = check_array(real0) real0_data = real0.data real1 = check_array(real1) real1_data = real1.data length = check_length2(real0, real1) outreal = NaN retCode = lib.TA_ADD( (length) - 1 , (length) - 1 , real0_data , real1_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_ADD", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ADOSC( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , np.ndarray volume not None , int fastperiod=-2**31 , int slowperiod=-2**31 ): """ ADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?]) Chaikin A/D Oscillator (Volume Indicators) Inputs: prices: ['high', 'low', 'close', 'volume'] Parameters: fastperiod: 3 slowperiod: 10 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data double* volume_data int outbegidx int outnbelement double outreal high = check_array(high) high_data = high.data low = check_array(low) low_data = low.data close = check_array(close) close_data = close.data volume = check_array(volume) volume_data = volume.data length = check_length4(high, low, close, volume) outreal = NaN retCode = lib.TA_ADOSC( (length) - 1 , (length) - 1 , high_data , low_data , close_data , volume_data , fastperiod , slowperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_ADOSC", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ADX( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ ADX(high, low, close[, timeperiod=?]) Average Directional Movement Index (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal 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) outreal = NaN retCode = lib.TA_ADX( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_ADX", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ADXR( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ ADXR(high, low, close[, timeperiod=?]) Average Directional Movement Index Rating (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal 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) outreal = NaN retCode = lib.TA_ADXR( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_ADXR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_APO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int matype=0 ): """ APO(real[, fastperiod=?, slowperiod=?, matype=?]) Absolute Price Oscillator (Momentum Indicators) Inputs: real: (any ndarray) Parameters: fastperiod: 12 slowperiod: 26 matype: 0 (Simple Moving Average) Outputs: real """ 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_APO( (length) - 1 , (length) - 1 , real_data , fastperiod , slowperiod , matype , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_APO", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_AROON( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 ): """ AROON(high, low[, timeperiod=?]) Aroon (Momentum Indicators) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: aroondown aroonup """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data int outbegidx int outnbelement double outaroondown double outaroonup high = check_array(high) high_data = high.data low = check_array(low) low_data = low.data length = check_length2(high, low) outaroondown = NaN outaroonup = NaN retCode = lib.TA_AROON( (length) - 1 , (length) - 1 , high_data , low_data , timeperiod , &outbegidx , &outnbelement , &outaroondown , &outaroonup ) _ta_check_success("TA_AROON", retCode) return outaroondown , outaroonup @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_AROONOSC( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 ): """ AROONOSC(high, low[, timeperiod=?]) Aroon Oscillator (Momentum Indicators) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data int outbegidx int outnbelement double outreal high = check_array(high) high_data = high.data low = check_array(low) low_data = low.data length = check_length2(high, low) outreal = NaN retCode = lib.TA_AROONOSC( (length) - 1 , (length) - 1 , high_data , low_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_AROONOSC", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ASIN( np.ndarray real not None ): """ ASIN(real) Vector Trigonometric ASin (Math Transform) Inputs: real: (any ndarray) 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_ASIN( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_ASIN", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ATAN( np.ndarray real not None ): """ ATAN(real) Vector Trigonometric ATan (Math Transform) Inputs: real: (any ndarray) 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_ATAN( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_ATAN", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ATR( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ ATR(high, low, close[, timeperiod=?]) Average True Range (Volatility Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal 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) outreal = NaN retCode = lib.TA_ATR( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_ATR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_AVGPRICE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ AVGPRICE(open, high, low, close) Average Price (Price Transform) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outreal = NaN retCode = lib.TA_AVGPRICE( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outreal ) _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 ): """ BBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?]) Bollinger Bands (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 5 nbdevup: 2.0 nbdevdn: 2.0 matype: 0 (Simple Moving Average) Outputs: upperband middleband lowerband """ cdef: np.npy_intp length TA_RetCode retCode double* real_data int outbegidx int outnbelement double outrealupperband double outrealmiddleband double outreallowerband real = check_array(real) real_data = real.data length = real.shape[0] outrealupperband = NaN outrealmiddleband = NaN outreallowerband = NaN retCode = lib.TA_BBANDS( (length) - 1 , (length) - 1 , real_data , timeperiod , nbdevup , nbdevdn , matype , &outbegidx , &outnbelement , &outrealupperband , &outrealmiddleband , &outreallowerband ) _ta_check_success("TA_BBANDS", 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 stream_BETA( np.ndarray real0 not None , np.ndarray real1 not None , int timeperiod=-2**31 ): """ BETA(real0, real1[, timeperiod=?]) Beta (Statistic Functions) Inputs: real0: (any ndarray) real1: (any ndarray) Parameters: timeperiod: 5 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* real0_data double* real1_data int outbegidx int outnbelement double outreal real0 = check_array(real0) real0_data = real0.data real1 = check_array(real1) real1_data = real1.data length = check_length2(real0, real1) outreal = NaN retCode = lib.TA_BETA( (length) - 1 , (length) - 1 , real0_data , real1_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_BETA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_BOP( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ BOP(open, high, low, close) Balance Of Power (Momentum Indicators) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outreal = NaN retCode = lib.TA_BOP( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_BOP", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CCI( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ CCI(high, low, close[, timeperiod=?]) Commodity Channel Index (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal 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) outreal = NaN retCode = lib.TA_CCI( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_CCI", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDL2CROWS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL2CROWS(open, high, low, close) Two Crows (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDL2CROWS( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDL2CROWS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDL3BLACKCROWS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL3BLACKCROWS(open, high, low, close) Three Black Crows (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDL3BLACKCROWS( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDL3BLACKCROWS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDL3INSIDE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL3INSIDE(open, high, low, close) Three Inside Up/Down (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDL3INSIDE( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDL3INSIDE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDL3LINESTRIKE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL3LINESTRIKE(open, high, low, close) Three-Line Strike (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDL3LINESTRIKE( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDL3LINESTRIKE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDL3OUTSIDE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL3OUTSIDE(open, high, low, close) Three Outside Up/Down (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDL3OUTSIDE( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDL3OUTSIDE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDL3STARSINSOUTH( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL3STARSINSOUTH(open, high, low, close) Three Stars In The South (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDL3STARSINSOUTH( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDL3STARSINSOUTH", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDL3WHITESOLDIERS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDL3WHITESOLDIERS(open, high, low, close) Three Advancing White Soldiers (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDL3WHITESOLDIERS( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDL3WHITESOLDIERS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLABANDONEDBABY( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , double penetration=0.3 ): """ CDLABANDONEDBABY(open, high, low, close[, penetration=?]) Abandoned Baby (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLABANDONEDBABY( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , penetration , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLABANDONEDBABY", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLADVANCEBLOCK( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLADVANCEBLOCK(open, high, low, close) Advance Block (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLADVANCEBLOCK( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLADVANCEBLOCK", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLBELTHOLD( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLBELTHOLD(open, high, low, close) Belt-hold (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLBELTHOLD( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLBELTHOLD", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLBREAKAWAY( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLBREAKAWAY(open, high, low, close) Breakaway (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLBREAKAWAY( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLBREAKAWAY", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLCLOSINGMARUBOZU( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLCLOSINGMARUBOZU(open, high, low, close) Closing Marubozu (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLCLOSINGMARUBOZU( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLCLOSINGMARUBOZU", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLCONCEALBABYSWALL( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLCONCEALBABYSWALL(open, high, low, close) Concealing Baby Swallow (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLCONCEALBABYSWALL( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLCONCEALBABYSWALL", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLCOUNTERATTACK( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLCOUNTERATTACK(open, high, low, close) Counterattack (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLCOUNTERATTACK( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLCOUNTERATTACK", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLDARKCLOUDCOVER( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , double penetration=0.5 ): """ CDLDARKCLOUDCOVER(open, high, low, close[, penetration=?]) Dark Cloud Cover (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.5 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLDARKCLOUDCOVER( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , penetration , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLDARKCLOUDCOVER", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLDOJI( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLDOJI(open, high, low, close) Doji (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLDOJI( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLDOJI", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLDOJISTAR( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLDOJISTAR(open, high, low, close) Doji Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLDOJISTAR( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLDOJISTAR", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLDRAGONFLYDOJI( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLDRAGONFLYDOJI(open, high, low, close) Dragonfly Doji (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLDRAGONFLYDOJI( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLDRAGONFLYDOJI", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLENGULFING( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLENGULFING(open, high, low, close) Engulfing Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLENGULFING( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLENGULFING", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLEVENINGDOJISTAR( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , double penetration=0.3 ): """ CDLEVENINGDOJISTAR(open, high, low, close[, penetration=?]) Evening Doji Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLEVENINGDOJISTAR( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , penetration , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLEVENINGDOJISTAR", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLEVENINGSTAR( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , double penetration=0.3 ): """ CDLEVENINGSTAR(open, high, low, close[, penetration=?]) Evening Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLEVENINGSTAR( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , penetration , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLEVENINGSTAR", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLGAPSIDESIDEWHITE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLGAPSIDESIDEWHITE(open, high, low, close) Up/Down-gap side-by-side white lines (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLGAPSIDESIDEWHITE( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLGAPSIDESIDEWHITE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLGRAVESTONEDOJI( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLGRAVESTONEDOJI(open, high, low, close) Gravestone Doji (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLGRAVESTONEDOJI( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLGRAVESTONEDOJI", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLHAMMER( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHAMMER(open, high, low, close) Hammer (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLHAMMER( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLHAMMER", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLHANGINGMAN( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHANGINGMAN(open, high, low, close) Hanging Man (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLHANGINGMAN( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLHANGINGMAN", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLHARAMI( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHARAMI(open, high, low, close) Harami Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLHARAMI( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLHARAMI", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLHARAMICROSS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHARAMICROSS(open, high, low, close) Harami Cross Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLHARAMICROSS( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLHARAMICROSS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLHIGHWAVE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHIGHWAVE(open, high, low, close) High-Wave Candle (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLHIGHWAVE( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLHIGHWAVE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLHIKKAKE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHIKKAKE(open, high, low, close) Hikkake Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLHIKKAKE( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLHIKKAKE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLHIKKAKEMOD( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHIKKAKEMOD(open, high, low, close) Modified Hikkake Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLHIKKAKEMOD( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLHIKKAKEMOD", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLHOMINGPIGEON( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLHOMINGPIGEON(open, high, low, close) Homing Pigeon (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLHOMINGPIGEON( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLHOMINGPIGEON", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLIDENTICAL3CROWS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLIDENTICAL3CROWS(open, high, low, close) Identical Three Crows (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLIDENTICAL3CROWS( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLIDENTICAL3CROWS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLINNECK( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLINNECK(open, high, low, close) In-Neck Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLINNECK( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLINNECK", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLINVERTEDHAMMER( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLINVERTEDHAMMER(open, high, low, close) Inverted Hammer (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLINVERTEDHAMMER( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLINVERTEDHAMMER", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLKICKING( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLKICKING(open, high, low, close) Kicking (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLKICKING( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLKICKING", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLKICKINGBYLENGTH( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLKICKINGBYLENGTH(open, high, low, close) Kicking - bull/bear determined by the longer marubozu (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLKICKINGBYLENGTH( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLKICKINGBYLENGTH", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLLADDERBOTTOM( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLLADDERBOTTOM(open, high, low, close) Ladder Bottom (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLLADDERBOTTOM( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLLADDERBOTTOM", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLLONGLEGGEDDOJI( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLLONGLEGGEDDOJI(open, high, low, close) Long Legged Doji (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLLONGLEGGEDDOJI( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLLONGLEGGEDDOJI", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLLONGLINE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLLONGLINE(open, high, low, close) Long Line Candle (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLLONGLINE( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLLONGLINE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLMARUBOZU( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLMARUBOZU(open, high, low, close) Marubozu (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLMARUBOZU( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLMARUBOZU", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLMATCHINGLOW( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLMATCHINGLOW(open, high, low, close) Matching Low (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLMATCHINGLOW( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLMATCHINGLOW", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLMATHOLD( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , double penetration=0.5 ): """ CDLMATHOLD(open, high, low, close[, penetration=?]) Mat Hold (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.5 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLMATHOLD( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , penetration , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLMATHOLD", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLMORNINGDOJISTAR( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , double penetration=0.3 ): """ CDLMORNINGDOJISTAR(open, high, low, close[, penetration=?]) Morning Doji Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLMORNINGDOJISTAR( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , penetration , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLMORNINGDOJISTAR", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLMORNINGSTAR( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , double penetration=0.3 ): """ CDLMORNINGSTAR(open, high, low, close[, penetration=?]) Morning Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLMORNINGSTAR( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , penetration , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLMORNINGSTAR", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLONNECK( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLONNECK(open, high, low, close) On-Neck Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLONNECK( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLONNECK", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLPIERCING( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLPIERCING(open, high, low, close) Piercing Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLPIERCING( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLPIERCING", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLRICKSHAWMAN( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLRICKSHAWMAN(open, high, low, close) Rickshaw Man (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLRICKSHAWMAN( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLRICKSHAWMAN", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLRISEFALL3METHODS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLRISEFALL3METHODS(open, high, low, close) Rising/Falling Three Methods (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLRISEFALL3METHODS( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLRISEFALL3METHODS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLSEPARATINGLINES( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLSEPARATINGLINES(open, high, low, close) Separating Lines (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLSEPARATINGLINES( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLSEPARATINGLINES", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLSHOOTINGSTAR( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLSHOOTINGSTAR(open, high, low, close) Shooting Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLSHOOTINGSTAR( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLSHOOTINGSTAR", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLSHORTLINE( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLSHORTLINE(open, high, low, close) Short Line Candle (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLSHORTLINE( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLSHORTLINE", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLSPINNINGTOP( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLSPINNINGTOP(open, high, low, close) Spinning Top (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLSPINNINGTOP( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLSPINNINGTOP", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLSTALLEDPATTERN( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLSTALLEDPATTERN(open, high, low, close) Stalled Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLSTALLEDPATTERN( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLSTALLEDPATTERN", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLSTICKSANDWICH( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLSTICKSANDWICH(open, high, low, close) Stick Sandwich (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLSTICKSANDWICH( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLSTICKSANDWICH", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLTAKURI( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLTAKURI(open, high, low, close) Takuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLTAKURI( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLTAKURI", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLTASUKIGAP( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLTASUKIGAP(open, high, low, close) Tasuki Gap (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLTASUKIGAP( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLTASUKIGAP", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLTHRUSTING( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLTHRUSTING(open, high, low, close) Thrusting Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLTHRUSTING( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLTHRUSTING", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLTRISTAR( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLTRISTAR(open, high, low, close) Tristar Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLTRISTAR( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLTRISTAR", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLUNIQUE3RIVER( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLUNIQUE3RIVER(open, high, low, close) Unique 3 River (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLUNIQUE3RIVER( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLUNIQUE3RIVER", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLUPSIDEGAP2CROWS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLUPSIDEGAP2CROWS(open, high, low, close) Upside Gap Two Crows (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLUPSIDEGAP2CROWS( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLUPSIDEGAP2CROWS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CDLXSIDEGAP3METHODS( np.ndarray open not None , np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ CDLXSIDEGAP3METHODS(open, high, low, close) Upside/Downside Gap Three Methods (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* open_data double* high_data double* low_data double* close_data int outbegidx int outnbelement int outinteger open = check_array(open) open_data = open.data 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_length4(open, high, low, close) outinteger = 0 retCode = lib.TA_CDLXSIDEGAP3METHODS( (length) - 1 , (length) - 1 , open_data , high_data , low_data , close_data , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_CDLXSIDEGAP3METHODS", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CEIL( np.ndarray real not None ): """ CEIL(real) Vector Ceil (Math Transform) Inputs: real: (any ndarray) 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_CEIL( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_CEIL", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CMO( np.ndarray real not None , int timeperiod=-2**31 ): """ CMO(real[, timeperiod=?]) Chande Momentum Oscillator (Momentum Indicators) 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_CMO( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_CMO", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_CORREL( np.ndarray real0 not None , np.ndarray real1 not None , int timeperiod=-2**31 ): """ CORREL(real0, real1[, timeperiod=?]) Pearson's Correlation Coefficient (r) (Statistic Functions) Inputs: real0: (any ndarray) real1: (any ndarray) Parameters: timeperiod: 30 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* real0_data double* real1_data int outbegidx int outnbelement double outreal real0 = check_array(real0) real0_data = real0.data real1 = check_array(real1) real1_data = real1.data length = check_length2(real0, real1) outreal = NaN retCode = lib.TA_CORREL( (length) - 1 , (length) - 1 , real0_data , real1_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_CORREL", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_COS( np.ndarray real not None ): """ COS(real) Vector Trigonometric Cos (Math Transform) Inputs: real: (any ndarray) 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_COS( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_COS", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_COSH( np.ndarray real not None ): """ COSH(real) Vector Trigonometric Cosh (Math Transform) Inputs: real: (any ndarray) 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_COSH( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_COSH", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_DEMA( np.ndarray real not None , int timeperiod=-2**31 ): """ DEMA(real[, timeperiod=?]) Double Exponential Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_DEMA( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_DEMA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_DIV( np.ndarray real0 not None , np.ndarray real1 not None ): """ DIV(real0, real1) Vector Arithmetic Div (Math Operators) Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* real0_data double* real1_data int outbegidx int outnbelement double outreal real0 = check_array(real0) real0_data = real0.data real1 = check_array(real1) real1_data = real1.data length = check_length2(real0, real1) outreal = NaN retCode = lib.TA_DIV( (length) - 1 , (length) - 1 , real0_data , real1_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_DIV", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_DX( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ DX(high, low, close[, timeperiod=?]) Directional Movement Index (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal 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) outreal = NaN retCode = lib.TA_DX( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_DX", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_EMA( np.ndarray real not None , int timeperiod=-2**31 ): """ EMA(real[, timeperiod=?]) Exponential Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_EMA( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_EMA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_EXP( np.ndarray real not None ): """ EXP(real) Vector Arithmetic Exp (Math Transform) Inputs: real: (any ndarray) 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_EXP( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_EXP", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_FLOOR( np.ndarray real not None ): """ FLOOR(real) Vector Floor (Math Transform) Inputs: real: (any ndarray) 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_FLOOR( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_FLOOR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_HT_DCPERIOD( np.ndarray real not None ): """ HT_DCPERIOD(real) Hilbert Transform - Dominant Cycle Period (Cycle Indicators) Inputs: real: (any ndarray) 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_HT_DCPERIOD( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_HT_DCPERIOD", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_HT_DCPHASE( np.ndarray real not None ): """ HT_DCPHASE(real) Hilbert Transform - Dominant Cycle Phase (Cycle Indicators) Inputs: real: (any ndarray) 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_HT_DCPHASE( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_HT_DCPHASE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_HT_PHASOR( np.ndarray real not None ): """ HT_PHASOR(real) Hilbert Transform - Phasor Components (Cycle Indicators) Inputs: real: (any ndarray) Outputs: inphase quadrature """ cdef: np.npy_intp length TA_RetCode retCode double* real_data int outbegidx int outnbelement double outinphase double outquadrature real = check_array(real) real_data = real.data length = real.shape[0] outinphase = NaN outquadrature = NaN retCode = lib.TA_HT_PHASOR( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outinphase , &outquadrature ) _ta_check_success("TA_HT_PHASOR", retCode) return outinphase , outquadrature @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_HT_SINE( np.ndarray real not None ): """ HT_SINE(real) Hilbert Transform - SineWave (Cycle Indicators) Inputs: real: (any ndarray) Outputs: sine leadsine """ cdef: np.npy_intp length TA_RetCode retCode double* real_data int outbegidx int outnbelement double outsine double outleadsine real = check_array(real) real_data = real.data length = real.shape[0] outsine = NaN outleadsine = NaN retCode = lib.TA_HT_SINE( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outsine , &outleadsine ) _ta_check_success("TA_HT_SINE", retCode) return outsine , outleadsine @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_HT_TRENDLINE( np.ndarray real not None ): """ HT_TRENDLINE(real) Hilbert Transform - Instantaneous Trendline (Overlap Studies) Inputs: real: (any ndarray) 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_HT_TRENDLINE( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_HT_TRENDLINE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_HT_TRENDMODE( np.ndarray real not None ): """ HT_TRENDMODE(real) Hilbert Transform - Trend vs Cycle Mode (Cycle Indicators) Inputs: real: (any ndarray) Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* real_data int outbegidx int outnbelement int outinteger real = check_array(real) real_data = real.data length = real.shape[0] outinteger = 0 retCode = lib.TA_HT_TRENDMODE( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outinteger ) _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 ): """ KAMA(real[, timeperiod=?]) Kaufman Adaptive Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_KAMA( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_KAMA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_LINEARREG( np.ndarray real not None , int timeperiod=-2**31 ): """ LINEARREG(real[, timeperiod=?]) Linear Regression (Statistic Functions) 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_LINEARREG( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_LINEARREG", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_LINEARREG_ANGLE( np.ndarray real not None , int timeperiod=-2**31 ): """ LINEARREG_ANGLE(real[, timeperiod=?]) Linear Regression Angle (Statistic Functions) 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_LINEARREG_ANGLE( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_LINEARREG_ANGLE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_LINEARREG_INTERCEPT( np.ndarray real not None , int timeperiod=-2**31 ): """ LINEARREG_INTERCEPT(real[, timeperiod=?]) Linear Regression Intercept (Statistic Functions) 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_LINEARREG_INTERCEPT( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_LINEARREG_INTERCEPT", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_LINEARREG_SLOPE( np.ndarray real not None , int timeperiod=-2**31 ): """ LINEARREG_SLOPE(real[, timeperiod=?]) Linear Regression Slope (Statistic Functions) 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_LINEARREG_SLOPE( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_LINEARREG_SLOPE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_LN( np.ndarray real not None ): """ LN(real) Vector Log Natural (Math Transform) Inputs: real: (any ndarray) 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_LN( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_LN", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_LOG10( np.ndarray real not None ): """ LOG10(real) Vector Log10 (Math Transform) Inputs: real: (any ndarray) 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_LOG10( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_LOG10", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MA( np.ndarray real not None , int timeperiod=-2**31 , int matype=0 ): """ MA(real[, timeperiod=?, matype=?]) Moving average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 matype: 0 (Simple Moving Average) 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_MA( (length) - 1 , (length) - 1 , real_data , timeperiod , matype , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_MA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MACD( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int signalperiod=-2**31 ): """ MACD(real[, fastperiod=?, slowperiod=?, signalperiod=?]) Moving Average Convergence/Divergence (Momentum Indicators) Inputs: real: (any ndarray) Parameters: fastperiod: 12 slowperiod: 26 signalperiod: 9 Outputs: macd macdsignal macdhist """ cdef: np.npy_intp length TA_RetCode retCode double* real_data int outbegidx int outnbelement double outmacd double outmacdsignal double outmacdhist real = check_array(real) real_data = real.data length = real.shape[0] outmacd = NaN outmacdsignal = NaN outmacdhist = NaN retCode = lib.TA_MACD( (length) - 1 , (length) - 1 , real_data , fastperiod , slowperiod , signalperiod , &outbegidx , &outnbelement , &outmacd , &outmacdsignal , &outmacdhist ) _ta_check_success("TA_MACD", retCode) return outmacd , outmacdsignal , outmacdhist @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MACDEXT( np.ndarray real not None , int fastperiod=-2**31 , int fastmatype=0 , int slowperiod=-2**31 , int slowmatype=0 , int signalperiod=-2**31 , int signalmatype=0 ): """ MACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?]) MACD with controllable MA type (Momentum Indicators) Inputs: real: (any ndarray) Parameters: fastperiod: 12 fastmatype: 0 slowperiod: 26 slowmatype: 0 signalperiod: 9 signalmatype: 0 Outputs: macd macdsignal macdhist """ cdef: np.npy_intp length TA_RetCode retCode double* real_data int outbegidx int outnbelement double outmacd double outmacdsignal double outmacdhist real = check_array(real) real_data = real.data length = real.shape[0] outmacd = NaN outmacdsignal = NaN outmacdhist = NaN retCode = lib.TA_MACDEXT( (length) - 1 , (length) - 1 , real_data , fastperiod , fastmatype , slowperiod , slowmatype , signalperiod , signalmatype , &outbegidx , &outnbelement , &outmacd , &outmacdsignal , &outmacdhist ) _ta_check_success("TA_MACDEXT", retCode) return outmacd , outmacdsignal , outmacdhist @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MACDFIX( np.ndarray real not None , int signalperiod=-2**31 ): """ MACDFIX(real[, signalperiod=?]) Moving Average Convergence/Divergence Fix 12/26 (Momentum Indicators) Inputs: real: (any ndarray) Parameters: signalperiod: 9 Outputs: macd macdsignal macdhist """ cdef: np.npy_intp length TA_RetCode retCode double* real_data int outbegidx int outnbelement double outmacd double outmacdsignal double outmacdhist real = check_array(real) real_data = real.data length = real.shape[0] outmacd = NaN outmacdsignal = NaN outmacdhist = NaN retCode = lib.TA_MACDFIX( (length) - 1 , (length) - 1 , real_data , signalperiod , &outbegidx , &outnbelement , &outmacd , &outmacdsignal , &outmacdhist ) _ta_check_success("TA_MACDFIX", retCode) return outmacd , outmacdsignal , outmacdhist @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MAMA( np.ndarray real not None , double fastlimit=-4e37 , double slowlimit=-4e37 ): """ MAMA(real[, fastlimit=?, slowlimit=?]) MESA Adaptive Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: fastlimit: 0.5 slowlimit: 0.05 Outputs: mama fama """ cdef: np.npy_intp length TA_RetCode retCode double* real_data int outbegidx int outnbelement double outmama double outfama real = check_array(real) real_data = real.data length = real.shape[0] outmama = NaN outfama = NaN retCode = lib.TA_MAMA( (length) - 1 , (length) - 1 , real_data , fastlimit , slowlimit , &outbegidx , &outnbelement , &outmama , &outfama ) _ta_check_success("TA_MAMA", retCode) return outmama , outfama @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MAVP( np.ndarray real not None , np.ndarray periods not None , int minperiod=-2**31 , int maxperiod=-2**31 , int matype=0 ): """ MAVP(real, periods[, minperiod=?, maxperiod=?, matype=?]) Moving average with variable period (Overlap Studies) Inputs: real: (any ndarray) periods: (any ndarray) Parameters: minperiod: 2 maxperiod: 30 matype: 0 (Simple Moving Average) Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* real_data double* periods_data int outbegidx int outnbelement double outreal real = check_array(real) real_data = real.data periods = check_array(periods) periods_data = periods.data length = check_length2(real, periods) outreal = NaN retCode = lib.TA_MAVP( (length) - 1 , (length) - 1 , real_data , periods_data , minperiod , maxperiod , matype , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_MAVP", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MAX( np.ndarray real not None , int timeperiod=-2**31 ): """ MAX(real[, timeperiod=?]) Highest value over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_MAX( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_MAX", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MAXINDEX( np.ndarray real not None , int timeperiod=-2**31 ): """ MAXINDEX(real[, timeperiod=?]) Index of highest value over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* real_data int outbegidx int outnbelement int outinteger real = check_array(real) real_data = real.data length = real.shape[0] outinteger = 0 retCode = lib.TA_MAXINDEX( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_MAXINDEX", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MEDPRICE( np.ndarray high not None , np.ndarray low not None ): """ MEDPRICE(high, low) Median Price (Price Transform) Inputs: prices: ['high', 'low'] Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data int outbegidx int outnbelement double outreal high = check_array(high) high_data = high.data low = check_array(low) low_data = low.data length = check_length2(high, low) outreal = NaN retCode = lib.TA_MEDPRICE( (length) - 1 , (length) - 1 , high_data , low_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_MEDPRICE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MFI( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , np.ndarray volume not None , int timeperiod=-2**31 ): """ MFI(high, low, close, volume[, timeperiod=?]) Money Flow Index (Momentum Indicators) Inputs: prices: ['high', 'low', 'close', 'volume'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data double* volume_data int outbegidx int outnbelement double outreal high = check_array(high) high_data = high.data low = check_array(low) low_data = low.data close = check_array(close) close_data = close.data volume = check_array(volume) volume_data = volume.data length = check_length4(high, low, close, volume) outreal = NaN retCode = lib.TA_MFI( (length) - 1 , (length) - 1 , high_data , low_data , close_data , volume_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_MFI", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MIDPOINT( np.ndarray real not None , int timeperiod=-2**31 ): """ MIDPOINT(real[, timeperiod=?]) MidPoint over period (Overlap Studies) 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_MIDPOINT( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_MIDPOINT", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MIDPRICE( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 ): """ MIDPRICE(high, low[, timeperiod=?]) Midpoint Price over period (Overlap Studies) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data int outbegidx int outnbelement double outreal high = check_array(high) high_data = high.data low = check_array(low) low_data = low.data length = check_length2(high, low) outreal = NaN retCode = lib.TA_MIDPRICE( (length) - 1 , (length) - 1 , high_data , low_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_MIDPRICE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MIN( np.ndarray real not None , int timeperiod=-2**31 ): """ MIN(real[, timeperiod=?]) Lowest value over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_MIN( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_MIN", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MININDEX( np.ndarray real not None , int timeperiod=-2**31 ): """ MININDEX(real[, timeperiod=?]) Index of lowest value over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: integer (values are -100, 0 or 100) """ cdef: np.npy_intp length TA_RetCode retCode double* real_data int outbegidx int outnbelement int outinteger real = check_array(real) real_data = real.data length = real.shape[0] outinteger = 0 retCode = lib.TA_MININDEX( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outinteger ) _ta_check_success("TA_MININDEX", retCode) return outinteger @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MINMAX( np.ndarray real not None , int timeperiod=-2**31 ): """ MINMAX(real[, timeperiod=?]) Lowest and highest values over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: min max """ cdef: np.npy_intp length TA_RetCode retCode double* real_data int outbegidx int outnbelement double outmin double outmax real = check_array(real) real_data = real.data length = real.shape[0] outmin = NaN outmax = NaN retCode = lib.TA_MINMAX( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outmin , &outmax ) _ta_check_success("TA_MINMAX", retCode) return outmin , outmax @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MINMAXINDEX( np.ndarray real not None , int timeperiod=-2**31 ): """ MINMAXINDEX(real[, timeperiod=?]) Indexes of lowest and highest values over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: minidx maxidx """ cdef: np.npy_intp length TA_RetCode retCode double* real_data int outbegidx int outnbelement int outminidx int outmaxidx real = check_array(real) real_data = real.data length = real.shape[0] outminidx = 0 outmaxidx = 0 retCode = lib.TA_MINMAXINDEX( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outminidx , &outmaxidx ) _ta_check_success("TA_MINMAXINDEX", retCode) return outminidx , outmaxidx @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MINUS_DI( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ MINUS_DI(high, low, close[, timeperiod=?]) Minus Directional Indicator (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal 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) outreal = NaN retCode = lib.TA_MINUS_DI( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_MINUS_DI", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MINUS_DM( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 ): """ MINUS_DM(high, low[, timeperiod=?]) Minus Directional Movement (Momentum Indicators) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data int outbegidx int outnbelement double outreal high = check_array(high) high_data = high.data low = check_array(low) low_data = low.data length = check_length2(high, low) outreal = NaN retCode = lib.TA_MINUS_DM( (length) - 1 , (length) - 1 , high_data , low_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_MINUS_DM", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MOM( np.ndarray real not None , int timeperiod=-2**31 ): """ MOM(real[, timeperiod=?]) Momentum (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 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_MOM( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_MOM", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_MULT( np.ndarray real0 not None , np.ndarray real1 not None ): """ MULT(real0, real1) Vector Arithmetic Mult (Math Operators) Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* real0_data double* real1_data int outbegidx int outnbelement double outreal real0 = check_array(real0) real0_data = real0.data real1 = check_array(real1) real1_data = real1.data length = check_length2(real0, real1) outreal = NaN retCode = lib.TA_MULT( (length) - 1 , (length) - 1 , real0_data , real1_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_MULT", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_NATR( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ NATR(high, low, close[, timeperiod=?]) Normalized Average True Range (Volatility Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal 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) outreal = NaN retCode = lib.TA_NATR( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_NATR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_OBV( np.ndarray real not None , np.ndarray volume not None ): """ OBV(real, volume) On Balance Volume (Volume Indicators) Inputs: real: (any ndarray) prices: ['volume'] Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* real_data double* volume_data int outbegidx int outnbelement double outreal real = check_array(real) real_data = real.data volume = check_array(volume) volume_data = volume.data length = check_length2(real, volume) outreal = NaN retCode = lib.TA_OBV( (length) - 1 , (length) - 1 , real_data , volume_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_OBV", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_PLUS_DI( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ PLUS_DI(high, low, close[, timeperiod=?]) Plus Directional Indicator (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal 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) outreal = NaN retCode = lib.TA_PLUS_DI( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_PLUS_DI", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_PLUS_DM( np.ndarray high not None , np.ndarray low not None , int timeperiod=-2**31 ): """ PLUS_DM(high, low[, timeperiod=?]) Plus Directional Movement (Momentum Indicators) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data int outbegidx int outnbelement double outreal high = check_array(high) high_data = high.data low = check_array(low) low_data = low.data length = check_length2(high, low) outreal = NaN retCode = lib.TA_PLUS_DM( (length) - 1 , (length) - 1 , high_data , low_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_PLUS_DM", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_PPO( np.ndarray real not None , int fastperiod=-2**31 , int slowperiod=-2**31 , int matype=0 ): """ PPO(real[, fastperiod=?, slowperiod=?, matype=?]) Percentage Price Oscillator (Momentum Indicators) Inputs: real: (any ndarray) Parameters: fastperiod: 12 slowperiod: 26 matype: 0 (Simple Moving Average) Outputs: real """ 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_PPO( (length) - 1 , (length) - 1 , real_data , fastperiod , slowperiod , matype , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_PPO", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ROC( np.ndarray real not None , int timeperiod=-2**31 ): """ ROC(real[, timeperiod=?]) Rate of change : ((real/prevPrice)-1)*100 (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 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_ROC( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_ROC", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ROCP( np.ndarray real not None , int timeperiod=-2**31 ): """ ROCP(real[, timeperiod=?]) Rate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 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_ROCP( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_ROCP", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ROCR( np.ndarray real not None , int timeperiod=-2**31 ): """ ROCR(real[, timeperiod=?]) Rate of change ratio: (real/prevPrice) (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 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_ROCR( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_ROCR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ROCR100( np.ndarray real not None , int timeperiod=-2**31 ): """ ROCR100(real[, timeperiod=?]) Rate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 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_ROCR100( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_ROCR100", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_RSI( np.ndarray real not None , int timeperiod=-2**31 ): """ RSI(real[, timeperiod=?]) Relative Strength Index (Momentum Indicators) 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_RSI( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_RSI", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_SAR( np.ndarray high not None , np.ndarray low not None , double acceleration=0.02 , double maximum=0.2 ): """ SAR(high, low[, acceleration=?, maximum=?]) Parabolic SAR (Overlap Studies) Inputs: prices: ['high', 'low'] Parameters: acceleration: 0.02 maximum: 0.2 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data int outbegidx int outnbelement double outreal high = check_array(high) high_data = high.data low = check_array(low) low_data = low.data length = check_length2(high, low) outreal = NaN retCode = lib.TA_SAR( (length) - 1 , (length) - 1 , high_data , low_data , acceleration , maximum , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_SAR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_SAREXT( np.ndarray high not None , np.ndarray low not None , double startvalue=-4e37 , double offsetonreverse=-4e37 , double accelerationinitlong=-4e37 , double accelerationlong=-4e37 , double accelerationmaxlong=-4e37 , double accelerationinitshort=-4e37 , double accelerationshort=-4e37 , double accelerationmaxshort=-4e37 ): """ SAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?]) Parabolic SAR - Extended (Overlap Studies) Inputs: prices: ['high', 'low'] Parameters: startvalue: 0.0 offsetonreverse: 0.0 accelerationinitlong: 0.02 accelerationlong: 0.02 accelerationmaxlong: 0.2 accelerationinitshort: 0.02 accelerationshort: 0.02 accelerationmaxshort: 0.2 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data int outbegidx int outnbelement double outreal high = check_array(high) high_data = high.data low = check_array(low) low_data = low.data length = check_length2(high, low) outreal = NaN retCode = lib.TA_SAREXT( (length) - 1 , (length) - 1 , high_data , low_data , startvalue , offsetonreverse , accelerationinitlong , accelerationlong , accelerationmaxlong , accelerationinitshort , accelerationshort , accelerationmaxshort , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_SAREXT", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_SIN( np.ndarray real not None ): """ SIN(real) Vector Trigonometric Sin (Math Transform) Inputs: real: (any ndarray) 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_SIN( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_SIN", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_SINH( np.ndarray real not None ): """ SINH(real) Vector Trigonometric Sinh (Math Transform) Inputs: real: (any ndarray) 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_SINH( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_SINH", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_SMA( np.ndarray real not None , int timeperiod=-2**31 ): """ SMA(real[, timeperiod=?]) Simple Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_SMA( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_SMA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_SQRT( np.ndarray real not None ): """ SQRT(real) Vector Square Root (Math Transform) Inputs: real: (any ndarray) 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_SQRT( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_SQRT", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_STDDEV( np.ndarray real not None , int timeperiod=-2**31 , double nbdev=-4e37 ): """ STDDEV(real[, timeperiod=?, nbdev=?]) Standard Deviation (Statistic Functions) Inputs: real: (any ndarray) Parameters: timeperiod: 5 nbdev: 1.0 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_STDDEV( (length) - 1 , (length) - 1 , real_data , timeperiod , nbdev , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_STDDEV", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_STOCH( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int fastk_period=-2**31 , int slowk_period=-2**31 , int slowk_matype=0 , int slowd_period=-2**31 , int slowd_matype=0 ): """ STOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?]) Stochastic (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: fastk_period: 5 slowk_period: 3 slowk_matype: 0 slowd_period: 3 slowd_matype: 0 Outputs: slowk slowd """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outslowk double outslowd 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) outslowk = NaN outslowd = NaN retCode = lib.TA_STOCH( (length) - 1 , (length) - 1 , high_data , low_data , close_data , fastk_period , slowk_period , slowk_matype , slowd_period , slowd_matype , &outbegidx , &outnbelement , &outslowk , &outslowd ) _ta_check_success("TA_STOCH", retCode) return outslowk , outslowd @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_STOCHF( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int fastk_period=-2**31 , int fastd_period=-2**31 , int fastd_matype=0 ): """ STOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?]) Stochastic Fast (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: fastk_period: 5 fastd_period: 3 fastd_matype: 0 Outputs: fastk fastd """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outfastk double outfastd 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) outfastk = NaN outfastd = NaN retCode = lib.TA_STOCHF( (length) - 1 , (length) - 1 , high_data , low_data , close_data , fastk_period , fastd_period , fastd_matype , &outbegidx , &outnbelement , &outfastk , &outfastd ) _ta_check_success("TA_STOCHF", retCode) return outfastk , outfastd @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_STOCHRSI( np.ndarray real not None , int timeperiod=-2**31 , int fastk_period=-2**31 , int fastd_period=-2**31 , int fastd_matype=0 ): """ STOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?]) Stochastic Relative Strength Index (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 14 fastk_period: 5 fastd_period: 3 fastd_matype: 0 Outputs: fastk fastd """ cdef: np.npy_intp length TA_RetCode retCode double* real_data int outbegidx int outnbelement double outfastk double outfastd real = check_array(real) real_data = real.data length = real.shape[0] outfastk = NaN outfastd = NaN retCode = lib.TA_STOCHRSI( (length) - 1 , (length) - 1 , real_data , timeperiod , fastk_period , fastd_period , fastd_matype , &outbegidx , &outnbelement , &outfastk , &outfastd ) _ta_check_success("TA_STOCHRSI", retCode) return outfastk , outfastd @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_SUB( np.ndarray real0 not None , np.ndarray real1 not None ): """ SUB(real0, real1) Vector Arithmetic Subtraction (Math Operators) Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* real0_data double* real1_data int outbegidx int outnbelement double outreal real0 = check_array(real0) real0_data = real0.data real1 = check_array(real1) real1_data = real1.data length = check_length2(real0, real1) outreal = NaN retCode = lib.TA_SUB( (length) - 1 , (length) - 1 , real0_data , real1_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_SUB", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_SUM( np.ndarray real not None , int timeperiod=-2**31 ): """ SUM(real[, timeperiod=?]) Summation (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_SUM( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_SUM", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_T3( np.ndarray real not None , int timeperiod=-2**31 , double vfactor=-4e37 ): """ T3(real[, timeperiod=?, vfactor=?]) Triple Exponential Moving Average (T3) (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 5 vfactor: 0.7 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_T3( (length) - 1 , (length) - 1 , real_data , timeperiod , vfactor , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_T3", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_TAN( np.ndarray real not None ): """ TAN(real) Vector Trigonometric Tan (Math Transform) Inputs: real: (any ndarray) 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_TAN( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_TAN", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_TANH( np.ndarray real not None ): """ TANH(real) Vector Trigonometric Tanh (Math Transform) Inputs: real: (any ndarray) 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_TANH( (length) - 1 , (length) - 1 , real_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_TANH", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_TEMA( np.ndarray real not None , int timeperiod=-2**31 ): """ TEMA(real[, timeperiod=?]) Triple Exponential Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_TEMA( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_TEMA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_TRANGE( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ TRANGE(high, low, close) True Range (Volatility Indicators) Inputs: prices: ['high', 'low', 'close'] Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal 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) outreal = NaN retCode = lib.TA_TRANGE( (length) - 1 , (length) - 1 , high_data , low_data , close_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_TRANGE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_TRIMA( np.ndarray real not None , int timeperiod=-2**31 ): """ TRIMA(real[, timeperiod=?]) Triangular Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_TRIMA( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_TRIMA", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_TRIX( np.ndarray real not None , int timeperiod=-2**31 ): """ TRIX(real[, timeperiod=?]) 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real """ 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_TRIX( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_TRIX", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_TSF( np.ndarray real not None , int timeperiod=-2**31 ): """ TSF(real[, timeperiod=?]) Time Series Forecast (Statistic Functions) 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_TSF( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_TSF", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_TYPPRICE( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ TYPPRICE(high, low, close) Typical Price (Price Transform) Inputs: prices: ['high', 'low', 'close'] Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal 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) outreal = NaN retCode = lib.TA_TYPPRICE( (length) - 1 , (length) - 1 , high_data , low_data , close_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_TYPPRICE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_ULTOSC( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod1=-2**31 , int timeperiod2=-2**31 , int timeperiod3=-2**31 ): """ ULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?]) Ultimate Oscillator (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod1: 7 timeperiod2: 14 timeperiod3: 28 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal 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) outreal = NaN retCode = lib.TA_ULTOSC( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod1 , timeperiod2 , timeperiod3 , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_ULTOSC", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_VAR( np.ndarray real not None , int timeperiod=-2**31 , double nbdev=-4e37 ): """ VAR(real[, timeperiod=?, nbdev=?]) Variance (Statistic Functions) Inputs: real: (any ndarray) Parameters: timeperiod: 5 nbdev: 1.0 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_VAR( (length) - 1 , (length) - 1 , real_data , timeperiod , nbdev , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_VAR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_WCLPRICE( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None ): """ WCLPRICE(high, low, close) Weighted Close Price (Price Transform) Inputs: prices: ['high', 'low', 'close'] Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal 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) outreal = NaN retCode = lib.TA_WCLPRICE( (length) - 1 , (length) - 1 , high_data , low_data , close_data , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_WCLPRICE", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_WILLR( np.ndarray high not None , np.ndarray low not None , np.ndarray close not None , int timeperiod=-2**31 ): """ WILLR(high, low, close[, timeperiod=?]) Williams' %R (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real """ cdef: np.npy_intp length TA_RetCode retCode double* high_data double* low_data double* close_data int outbegidx int outnbelement double outreal 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) outreal = NaN retCode = lib.TA_WILLR( (length) - 1 , (length) - 1 , high_data , low_data , close_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_WILLR", retCode) return outreal @wraparound(False) # turn off relative indexing from end of lists @boundscheck(False) # turn off bounds-checking for entire function def stream_WMA( np.ndarray real not None , int timeperiod=-2**31 ): """ WMA(real[, timeperiod=?]) Weighted Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 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_WMA( (length) - 1 , (length) - 1 , real_data , timeperiod , &outbegidx , &outnbelement , &outreal ) _ta_check_success("TA_WMA", retCode) return outreal ================================================ FILE: talib/_ta_lib.c ================================================ /* Generated by Cython 3.2.4 */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ /* 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 < 0x03080000 #error Cython requires Python 3.8+. #else #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 ) #endif #if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX #if defined(GRAALVM_PYTHON) /* For very preliminary testing purposes. Most variables are set the same as PyPy. The existence of this section does not imply that anything works or is even tested */ #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 1 #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 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #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 #define CYTHON_FAST_THREAD_STATE 0 #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 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 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_CPYTHON_FREETHREADING 0 #undef CYTHON_USE_TYPE_SLOTS #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 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #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 #define CYTHON_FAST_THREAD_STATE 0 #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 #if PY_VERSION_HEX < 0x03090000 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif #undef CYTHON_USE_MODULE_STATE #define CYTHON_USE_MODULE_STATE 0 #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 (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 #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API #endif #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #define CYTHON_COMPILING_IN_LIMITED_API 1 #define CYTHON_COMPILING_IN_GRAAL 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_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #endif #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #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 #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_GIL #define CYTHON_FAST_GIL 0 #undef CYTHON_METH_FASTCALL #define CYTHON_METH_FASTCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #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 #undef CYTHON_USE_SYS_MONITORING #define CYTHON_USE_SYS_MONITORING 0 #ifndef CYTHON_USE_TP_FINALIZE #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 0 #endif #ifndef CYTHON_USE_FREELISTS #define CYTHON_USE_FREELISTS 1 #endif #undef CYTHON_IMMORTAL_CONSTANTS #define CYTHON_IMMORTAL_CONSTANTS 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #define CYTHON_COMPILING_IN_LIMITED_API 0 #define CYTHON_COMPILING_IN_GRAAL 0 #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 #define CYTHON_USE_TYPE_SPECS 0 #endif #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #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 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) #define CYTHON_USE_UNICODE_WRITER 1 #endif #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 #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 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP487_INIT_SUBCLASS #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif #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 #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 #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 && !CYTHON_USE_MODULE_STATE) #endif #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 (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) #endif #if defined(CYTHON_IMMORTAL_CONSTANTS) && PY_VERSION_HEX < 0x030C0000 #undef CYTHON_IMMORTAL_CONSTANTS #define CYTHON_IMMORTAL_CONSTANTS 0 // definitely won't work #elif !defined(CYTHON_IMMORTAL_CONSTANTS) #define CYTHON_IMMORTAL_CONSTANTS (PY_VERSION_HEX >= 0x030C0000 && !CYTHON_USE_MODULE_STATE && CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) #endif #endif #ifndef CYTHON_COMPRESS_STRINGS #define CYTHON_COMPRESS_STRINGS 1 #endif #ifndef CYTHON_FAST_PYCCALL #define CYTHON_FAST_PYCCALL CYTHON_FAST_PYCALL #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 #endif #if CYTHON_USE_PYLONG_INTERNALS #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED #if defined(__cplusplus) /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 * but leads to warnings with -pedantic, since it is a C++17 feature */ #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) #if __has_cpp_attribute(maybe_unused) #define CYTHON_UNUSED [[maybe_unused]] #endif #endif #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_UNUSED_VAR( const T& ) { } # else # define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #ifndef CYTHON_USE_CPP_STD_MOVE #if defined(__cplusplus) && (\ __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) #define CYTHON_USE_CPP_STD_MOVE 1 #else #define CYTHON_USE_CPP_STD_MOVE 0 #endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #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 * but leads to warnings with -pedantic, since it is a C++17 feature */ #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #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);}; #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) #else #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) #endif #if CYTHON_COMPILING_IN_PYPY == 1 #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX < 0x030A0000) #else #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__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif /* PythonCompatibility */ #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type #if CYTHON_COMPILING_IN_LIMITED_API #ifndef CO_OPTIMIZED static int CO_OPTIMIZED; #endif #ifndef CO_NEWLOCALS static int CO_NEWLOCALS; #endif #ifndef CO_VARARGS static int CO_VARARGS; #endif #ifndef CO_VARKEYWORDS static int CO_VARKEYWORDS; #endif #ifndef CO_ASYNC_GENERATOR static int CO_ASYNC_GENERATOR; #endif #ifndef CO_GENERATOR static int CO_GENERATOR; #endif #ifndef CO_COROUTINE static int CO_COROUTINE; #endif #else #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 #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) #define __Pyx_Py_Is(x, y) Py_Is(x, y) #else #define __Pyx_Py_Is(x, y) ((x) == (y)) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) #else #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) #else #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) #endif #if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) #else #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) #endif #define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) #if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) #else #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef Py_TPFLAGS_SEQUENCE #define Py_TPFLAGS_SEQUENCE 0 #endif #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 #ifndef METH_FASTCALL #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #if PY_VERSION_HEX >= 0x030d00A4 # define __Pyx_PyCFunctionFast PyCFunctionFast # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords #else # define __Pyx_PyCFunctionFast _PyCFunctionFast # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #endif #if CYTHON_METH_FASTCALL #define __Pyx_METH_FASTCALL METH_FASTCALL #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords #else #define __Pyx_METH_FASTCALL METH_VARARGS #define __Pyx_PyCFunction_FastCall PyCFunction #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords #endif #if CYTHON_VECTORCALL #define __pyx_vectorcallfunc vectorcallfunc #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) #else #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) #endif #if PY_VERSION_HEX >= 0x030900B1 #define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) #else #define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) #endif #define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) #elif !CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) #endif #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) 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)(void)) { #if CYTHON_COMPILING_IN_LIMITED_API return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; #else return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; #endif } #define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) #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 #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) #define __Pyx_PyCMethod PyCMethod #endif #ifndef METH_METHOD #define METH_METHOD 0x200 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyFrame_SetLineNumber(frame, lineno) #elif CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000 #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) GraalPyFrame_SetLineNumber((frame), (lineno)) #elif CYTHON_COMPILING_IN_GRAAL #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) _PyFrame_SetLineNumber((frame), (lineno)) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyThreadState_Current PyThreadState_Get() #elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x030d00A1 #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #else #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #endif #if CYTHON_USE_MODULE_STATE static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op) { void *result; result = PyModule_GetState(op); if (!result) Py_FatalError("Couldn't find the module state"); return result; } #define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o) #else #define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global) #endif #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 #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 !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 #define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError #define __Pyx_PyDict_GetItemStr PyDict_GetItem #else static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { #if CYTHON_COMPILING_IN_PYPY return PyDict_GetItem(dict, name); #else PyDictEntry *ep; PyDictObject *mp = (PyDictObject*) dict; long hash = ((PyStringObject *) name)->ob_shash; assert(hash != -1); ep = (mp->ma_lookup)(mp, name, hash); if (ep == NULL) { return NULL; } return ep->me_value; #endif } #define __Pyx_PyDict_GetItemStr PyDict_GetItem #endif #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) #else #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) #endif #define __Pyx_PyObject_GetIterNextFunc(iterator) __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc) #if CYTHON_USE_TYPE_SPECS #define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ PyTypeObject *type = Py_TYPE((PyObject*)obj);\ assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ PyObject_GC_Del(obj);\ Py_DECREF(type);\ } #else #define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #endif #if CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_PyUnicode_READY(op) (0) #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)) #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_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)) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) #if PY_VERSION_HEX >= 0x030C0000 #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #else #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #endif #endif #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY #if !defined(PyUnicode_DecodeUnicodeEscape) #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) #endif #if !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #endif #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if CYTHON_COMPILING_IN_CPYTHON && 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 #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) #else #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_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 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 typedef enum { PYGEN_RETURN = 0, PYGEN_ERROR = -1, PYGEN_NEXT = 1, } __Pyx_PySendResult; #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_HAS_PY_AM_SEND 2 // our own backported implementation #endif #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) #ifndef _USE_MATH_DEFINES #define _USE_MATH_DEFINES #endif #endif #include #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #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; } #ifdef CYTHON_EXTERN_C #undef __PYX_EXTERN_C #define __PYX_EXTERN_C CYTHON_EXTERN_C #elif defined(__PYX_EXTERN_C) #ifdef _MSC_VER #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") #else #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. #endif #else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__talib___ta_lib #define __PYX_HAVE_API__talib___ta_lib /* Early includes */ #if defined(WIN32) || defined(MS_WINDOWS) #include "ta_libc.h" #else #include "ta-lib/ta_defs.h" #include "ta-lib/ta_common.h" #include "ta-lib/ta_abstract.h" #include "ta-lib/ta_func.h" #endif #include #include /* Using NumPy API declarations from "numpy/__init__.cython-30.pxd" */ #include "numpy/arrayobject.h" #include "numpy/ndarrayobject.h" #include "numpy/ndarraytypes.h" #include "numpy/arrayscalars.h" #include "numpy/ufuncobject.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif #ifdef CYTHON_FREETHREADING_COMPATIBLE #if CYTHON_FREETHREADING_COMPATIBLE #define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_NOT_USED #else #define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_USED #endif #else #define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_USED #endif #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #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)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #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_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) #define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode 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_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_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_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x) #else #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)) #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #if CYTHON_USE_PYLONG_INTERNALS #if PY_VERSION_HEX >= 0x030C00A7 #ifndef _PyLong_SIGN_MASK #define _PyLong_SIGN_MASK 3 #endif #ifndef _PyLong_NON_SIZE_BITS #define _PyLong_NON_SIZE_BITS 3 #endif #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) #define __Pyx_PyLong_SignedDigitCount(x)\ ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) #else #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) #endif typedef Py_ssize_t __Pyx_compact_pylong; typedef size_t __Pyx_compact_upylong; #else #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) #define __Pyx_PyLong_CompactValue(x)\ ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) typedef sdigit __Pyx_compact_pylong; typedef digit __Pyx_compact_upylong; #endif #if PY_VERSION_HEX >= 0x030C00A5 #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) #else #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) #endif #endif #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) #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #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 * const __pyx_cfilenm = __FILE__; static const char *__pyx_filename; /* Header.proto */ #if !defined(CYTHON_CCOMPLEX) #if defined(__cplusplus) #define CYTHON_CCOMPLEX 1 #elif (defined(_Complex_I) && !defined(_MSC_VER)) || ((defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_COMPLEX__) && !defined(_MSC_VER)) #define CYTHON_CCOMPLEX 1 #else #define CYTHON_CCOMPLEX 0 #endif #endif #if CYTHON_CCOMPLEX #ifdef __cplusplus #include #else #include #endif #endif #if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) #undef _Complex_I #define _Complex_I 1.0fj #endif /* #### Code section: filename_table ### */ static const char* const __pyx_f[] = { "talib/_ta_lib.pyx", "talib/_common.pxi", "talib/_abstract.pxi", ".venv/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd", "talib/_func.pxi", "talib/_stream.pxi", ".venv/lib/python3.12/site-packages/Cython/Includes/cpython/type.pxd", }; /* #### Code section: utility_code_proto_before_types ### */ /* 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; typedef npy_int16 __pyx_t_5numpy_int16_t; typedef npy_int32 __pyx_t_5numpy_int32_t; typedef npy_int64 __pyx_t_5numpy_int64_t; typedef npy_uint8 __pyx_t_5numpy_uint8_t; typedef npy_uint16 __pyx_t_5numpy_uint16_t; typedef npy_uint32 __pyx_t_5numpy_uint32_t; typedef npy_uint64 __pyx_t_5numpy_uint64_t; typedef npy_float32 __pyx_t_5numpy_float32_t; typedef npy_float64 __pyx_t_5numpy_float64_t; typedef npy_longlong __pyx_t_5numpy_longlong_t; typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; typedef npy_intp __pyx_t_5numpy_intp_t; typedef npy_uintp __pyx_t_5numpy_uintp_t; typedef npy_double __pyx_t_5numpy_float_t; typedef npy_double __pyx_t_5numpy_double_t; typedef npy_longdouble __pyx_t_5numpy_longdouble_t; /* #### Code section: complex_type_declarations ### */ /* Declarations.proto */ #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) #ifdef __cplusplus typedef ::std::complex< float > __pyx_t_float_complex; #else typedef float _Complex __pyx_t_float_complex; #endif #else typedef struct { float real, imag; } __pyx_t_float_complex; #endif static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); /* Declarations.proto */ #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) #ifdef __cplusplus typedef ::std::complex< double > __pyx_t_double_complex; #else typedef double _Complex __pyx_t_double_complex; #endif #else typedef struct { double real, imag; } __pyx_t_double_complex; #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 int (*__pyx_t_5numpy_NpyIter_IterNextFunc)(NpyIter *); typedef void (*__pyx_t_5numpy_NpyIter_GetMultiIndexFunc)(NpyIter *, npy_intp *); /* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, Py_ssize_t); void (*DECREF)(void*, PyObject*, Py_ssize_t); void (*GOTREF)(void*, PyObject*, Py_ssize_t); void (*GIVEREF)(void*, PyObject*, Py_ssize_t); void* (*SetupContext)(const char*, Py_ssize_t, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ } #define __Pyx_RefNannyFinishContextNogil() {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __Pyx_RefNannyFinishContext();\ PyGILState_Release(__pyx_gilstate_save);\ } #define __Pyx_RefNannyFinishContextNogil() {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __Pyx_RefNannyFinishContext();\ PyGILState_Release(__pyx_gilstate_save);\ } #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_Py_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; Py_XDECREF(tmp);\ } while (0) #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #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 (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); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* 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; #if PY_VERSION_HEX >= 0x030C00A6 #define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) #define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) #else #define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) #define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) #endif #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) #define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() #endif /* 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) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* 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 (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 (used by SaveResetException) */ #if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* 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 /* 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 * const*args, size_t nargs, PyObject *kwargs); /* 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 /* 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 /* BytesEquals.proto (used by UnicodeEquals) */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); /* 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_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i) #elif CYTHON_ASSUME_SAFE_MACROS #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i)) #else #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_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 || 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 #else #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 #endif #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 /* 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); /* 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 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)) /* 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) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ 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_XNewRef(__pyx_dict_cached_value);\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #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_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) #define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } while(0) static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) 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) __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, 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, 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, has_gil, unsafe_shared)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __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, 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, 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 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 unsafe_shared); /* ObjectGetItem.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key); #else #define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) #endif /* 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 >= 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 !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name)\ (likely(PyDict_CheckExact(obj)) ?\ __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) #else #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* IterFinish.proto */ static CYTHON_INLINE int __Pyx_IterFinish(void); /* UnpackItemEndCheck.proto */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /* PySequenceContains.proto */ static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { int result = PySequence_Contains(seq, item); return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } /* ListAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 L->ob_item[len] = x; #else PyList_SET_ITEM(list, len, x); #endif __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif /* PyObjectCallNoArg.proto (used by PyObjectCallMethod0) */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); /* PyObjectGetMethod.proto (used by PyObjectCallMethod0) */ #if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); #endif /* PyObjectCallMethod0.proto (used by dict_iter) */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); /* RaiseNoneIterError.proto (used by UnpackTupleError) */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* UnpackTupleError.proto (used by UnpackTuple2) */ static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /* 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( PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); /* dict_iter.proto */ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_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); /* PyLongBinop.proto */ #if !CYTHON_COMPILING_IN_PYPY static CYTHON_INLINE PyObject* __Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); #else #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) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len)) { Py_INCREF(x); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 L->ob_item[len] = x; #else PyList_SET_ITEM(list, len, x); #endif __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else #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); static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop); #else #define __Pyx_PyList_GetSlice(seq, start, stop) PySequence_GetSlice(seq, start, stop) #define __Pyx_PyTuple_GetSlice(seq, start, stop) PySequence_GetSlice(seq, start, stop) #endif /* PyObjectFormatAndDecref.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); /* PyObject_Unicode.proto */ #define __Pyx_PyObject_Unicode(obj)\ (likely(PyUnicode_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj)) /* py_dict_keys.proto */ static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d); /* 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( 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); /* SetItemInt.proto */ #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, 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 unsafe_shared); /* TypeImport.proto */ #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_2_4(s) alignof(s) #else #define __PYX_GET_STRUCT_ALIGNMENT_3_2_4(s) sizeof(void*) #endif 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_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 /* dict_setdefault.proto (used by FetchCommonType) */ static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value); /* LimitedApiGetTypeDict.proto (used by SetItemOnTypeDict) */ #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp); #endif /* SetItemOnTypeDict.proto (used by FixUpExtensionType) */ static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v); #define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v) /* FixUpExtensionType.proto (used by FetchCommonType) */ static CYTHON_INLINE int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); /* AddModuleRef.proto (used by FetchSharedCythonModule) */ #if ((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING ) ||\ __PYX_LIMITED_VERSION_HEX < 0x030d0000) static PyObject *__Pyx_PyImport_AddModuleRef(const char *name); #else #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) #endif /* FetchSharedCythonModule.proto (used by FetchCommonType) */ static PyObject *__Pyx_FetchSharedCythonABIModule(void); /* 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 static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); #endif /* 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 (used by CythonFunction) */ #define __Pyx_CyFunction_USED #define __Pyx_CYFUNCTION_STATICMETHOD 0x01 #define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 #define __Pyx_CYFUNCTION_CCLASS 0x04 #define __Pyx_CYFUNCTION_COROUTINE 0x08 #define __Pyx_CyFunction_GetClosure(f)\ (((__pyx_CyFunctionObject *) (f))->func_closure) #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyFunction_GetClassObj(f)\ (((__pyx_CyFunctionObject *) (f))->func_classobj) #else #define __Pyx_CyFunction_GetClassObj(f)\ ((PyObject*) ((PyCMethodObject *) (f))->mm_class) #endif #define __Pyx_CyFunction_SetClassObj(f, classobj)\ __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) #define __Pyx_CyFunction_Defaults(type, f)\ ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) #define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) typedef struct { #if CYTHON_COMPILING_IN_LIMITED_API PyObject_HEAD PyObject *func; #elif PY_VERSION_HEX < 0x030900B1 PyCFunctionObject func; #else PyCMethodObject func; #endif #if CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL __pyx_vectorcallfunc func_vectorcall; #endif #if CYTHON_COMPILING_IN_LIMITED_API PyObject *func_weakreflist; #endif #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API PyObject *func_dict; #endif PyObject *func_name; PyObject *func_qualname; PyObject *func_doc; PyObject *func_globals; PyObject *func_code; PyObject *func_closure; #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API PyObject *func_classobj; #endif PyObject *defaults; int flags; PyObject *defaults_tuple; PyObject *defaults_kwdict; PyObject *(*defaults_getter)(PyObject *); PyObject *func_annotations; PyObject *func_is_coroutine; } __pyx_CyFunctionObject; #undef __Pyx_CyOrPyCFunction_Check #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, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject* code); static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); 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, PyObject *dict); static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, PyObject *dict); static int __pyx_CyFunction_init(PyObject *module); #if CYTHON_METH_FASTCALL static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); 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_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) #endif #endif /* CythonFunction.proto */ static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject *globals, PyObject* code); /* Py3UpdateBases.proto */ static PyObject* __Pyx_PEP560_update_bases(PyObject *bases); /* CalculateMetaclass.proto */ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); /* SetNameInClass.proto */ #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 #define __Pyx_SetNameInClass(ns, name, value)\ (likely(PyDict_CheckExact(ns)) ? PyDict_SetItem(ns, name, value) : PyObject_SetItem(ns, name, value)) #else #define __Pyx_SetNameInClass(ns, name, value) PyObject_SetItem(ns, name, value) #endif /* 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) static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error); #else #define __Pyx_PyObject_LookupSpecialNoError(o,n) __Pyx_PyObject_GetAttrStrNoError(o,n) #define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n) #endif /* Py3ClassCreate.proto */ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc); 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 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); /* 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); /* 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 (used by AddTraceback) */ #if CYTHON_COMPILING_IN_LIMITED_API typedef PyObject __Pyx_CachedCodeObjectType; #else typedef PyCodeObject __Pyx_CachedCodeObjectType; #endif typedef struct { __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 int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); 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); /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus #define __Pyx_CREAL(z) ((z).real()) #define __Pyx_CIMAG(z) ((z).imag()) #else #define __Pyx_CREAL(z) (__real__(z)) #define __Pyx_CIMAG(z) (__imag__(z)) #endif #else #define __Pyx_CREAL(z) ((z).real) #define __Pyx_CIMAG(z) ((z).imag) #endif #if defined(__cplusplus) && CYTHON_CCOMPLEX\ && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) #define __Pyx_SET_CREAL(z,x) ((z).real(x)) #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) #else #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) #define __Pyx_c_eq_float(a, b) ((a)==(b)) #define __Pyx_c_sum_float(a, b) ((a)+(b)) #define __Pyx_c_diff_float(a, b) ((a)-(b)) #define __Pyx_c_prod_float(a, b) ((a)*(b)) #define __Pyx_c_quot_float(a, b) ((a)/(b)) #define __Pyx_c_neg_float(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_float(z) ((z)==(float)0) #define __Pyx_c_conj_float(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_float(z) (::std::abs(z)) #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_float(z) ((z)==0) #define __Pyx_c_conj_float(z) (conjf(z)) #if 1 #define __Pyx_c_abs_float(z) (cabsf(z)) #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); #endif #endif /* Arithmetic.proto */ #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) #define __Pyx_c_eq_double(a, b) ((a)==(b)) #define __Pyx_c_sum_double(a, b) ((a)+(b)) #define __Pyx_c_diff_double(a, b) ((a)-(b)) #define __Pyx_c_prod_double(a, b) ((a)*(b)) #define __Pyx_c_quot_double(a, b) ((a)/(b)) #define __Pyx_c_neg_double(a) (-(a)) #ifdef __cplusplus #define __Pyx_c_is_zero_double(z) ((z)==(double)0) #define __Pyx_c_conj_double(z) (::std::conj(z)) #if 1 #define __Pyx_c_abs_double(z) (::std::abs(z)) #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) #endif #else #define __Pyx_c_is_zero_double(z) ((z)==0) #define __Pyx_c_conj_double(z) (conj(z)) #if 1 #define __Pyx_c_abs_double(z) (cabs(z)) #define __Pyx_c_pow_double(a, b) (cpow(a, b)) #endif #endif #else static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); #endif #endif /* 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 TA_RetCode __Pyx_PyLong_As_TA_RetCode(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value); /* CIntFromPy.proto */ static CYTHON_INLINE TA_FuncUnstId __Pyx_PyLong_As_TA_FuncUnstId(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_unsigned_int(unsigned int value); /* CIntFromPy.proto */ static CYTHON_INLINE TA_Compatibility __Pyx_PyLong_As_TA_Compatibility(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE TA_CandleSettingType __Pyx_PyLong_As_TA_CandleSettingType(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE TA_RangeType __Pyx_PyLong_As_TA_RangeType(PyObject *); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_OptInputParameterType(TA_OptInputParameterType value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_FuncFlags(TA_FuncFlags value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_TA_InputFlags(TA_InputFlags value); /* CIntToPy.proto */ 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" #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_GetFullyQualifiedName(tp) ((tp)->tp_name) #define __Pyx_DECREF_TypeName(obj) #endif /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) #define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #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) 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 /* GetRuntimeVersion.proto */ #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 static unsigned long __Pyx_cached_runtime_version = 0; static void __Pyx_init_runtime_version(void); #else #define __Pyx_init_runtime_version() #endif static unsigned long __Pyx_get_runtime_version(void); /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* DecompressString.proto */ static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo); /* MultiPhaseInitModuleState.proto */ #if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE static PyObject *__Pyx_State_FindModule(void*); 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*/ static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self); /* proto*/ static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self); /* proto*/ /* Module declarations from "libc.string" */ /* Module declarations from "libc.stdio" */ /* Module declarations from "__builtin__" */ /* Module declarations from "cpython.type" */ /* Module declarations from "cpython" */ /* Module declarations from "cpython.object" */ /* Module declarations from "cpython.ref" */ /* Module declarations from "numpy" */ /* Module declarations from "numpy" */ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void); /*proto*/ /* Module declarations from "talib._ta_lib" */ static double __pyx_v_5talib_7_ta_lib_NaN; static PyObject *__pyx_f_5talib_7_ta_lib__ta_check_success(PyObject *, TA_RetCode, int __pyx_skip_dispatch); /*proto*/ static PyArrayObject *__pyx_f_5talib_7_ta_lib_check_array(PyArrayObject *); /*proto*/ static npy_intp __pyx_f_5talib_7_ta_lib_check_length2(PyArrayObject *, PyArrayObject *); /*proto*/ static npy_intp __pyx_f_5talib_7_ta_lib_check_length3(PyArrayObject *, PyArrayObject *, PyArrayObject *); /*proto*/ static npy_intp __pyx_f_5talib_7_ta_lib_check_length4(PyArrayObject *, PyArrayObject *, PyArrayObject *, PyArrayObject *); /*proto*/ static npy_int __pyx_f_5talib_7_ta_lib_check_begidx1(npy_intp, double *); /*proto*/ static npy_int __pyx_f_5talib_7_ta_lib_check_begidx2(npy_intp, double *, double *); /*proto*/ static npy_int __pyx_f_5talib_7_ta_lib_check_begidx3(npy_intp, double *, double *, double *); /*proto*/ static npy_int __pyx_f_5talib_7_ta_lib_check_begidx4(npy_intp, double *, double *, double *, double *); /*proto*/ static PyArrayObject *__pyx_f_5talib_7_ta_lib_make_double_array(npy_intp, int); /*proto*/ static PyArrayObject *__pyx_f_5talib_7_ta_lib_make_int_array(npy_intp, int); /*proto*/ static TA_FuncHandle const *__pyx_f_5talib_7_ta_lib___ta_getFuncHandle(char *); /*proto*/ static TA_ParamHolder *__pyx_f_5talib_7_ta_lib___ta_paramHolderAlloc(char *); /*proto*/ static int __pyx_f_5talib_7_ta_lib___ta_paramHolderFree(TA_ParamHolder *); /*proto*/ static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamInteger(TA_ParamHolder *, int, int); /*proto*/ static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamReal(TA_ParamHolder *, int, double); /*proto*/ static int __pyx_f_5talib_7_ta_lib___ta_getLookback(TA_ParamHolder *); /*proto*/ /* #### Code section: typeinfo ### */ /* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "talib._ta_lib" extern int __pyx_module_is_main_talib___ta_lib; 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_enumerate; static PyObject *__pyx_builtin_property; static PyObject *__pyx_builtin_min; static PyObject *__pyx_builtin_max; /* #### Code section: string_decls ### */ /* #### 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 */ static PyObject *__pyx_pf_5talib_7_ta_lib_4_ta_shutdown(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type_2__getitem__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_type_); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_6_ta_set_unstable_period(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name, PyObject *__pyx_v_period); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8_ta_get_unstable_period(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_10_ta_set_compatibility(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_value); /* proto */ 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_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 */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_6function_flags(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_8output_flags(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_10get_input_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_names); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_arrays); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_18get_parameters(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_parameters, PyObject *__pyx_v_kwargs); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_24lookback(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_26output_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_30run(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_arrays); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_38__check_opt_input_value(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_name, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_40__get_opt_input_value(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_name); /* proto */ 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_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; PyObject *__pyx_cython_runtime; PyObject *__pyx_empty_tuple; PyObject *__pyx_empty_bytes; PyObject *__pyx_empty_unicode; PyTypeObject *__pyx_ptype_7cpython_4type_type; PyTypeObject *__pyx_ptype_5numpy_dtype; PyTypeObject *__pyx_ptype_5numpy_flatiter; PyTypeObject *__pyx_ptype_5numpy_broadcast; PyTypeObject *__pyx_ptype_5numpy_ndarray; PyTypeObject *__pyx_ptype_5numpy_generic; PyTypeObject *__pyx_ptype_5numpy_number; PyTypeObject *__pyx_ptype_5numpy_integer; PyTypeObject *__pyx_ptype_5numpy_signedinteger; PyTypeObject *__pyx_ptype_5numpy_unsignedinteger; PyTypeObject *__pyx_ptype_5numpy_inexact; PyTypeObject *__pyx_ptype_5numpy_floating; PyTypeObject *__pyx_ptype_5numpy_complexfloating; PyTypeObject *__pyx_ptype_5numpy_flexible; PyTypeObject *__pyx_ptype_5numpy_character; PyTypeObject *__pyx_ptype_5numpy_ufunc; __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; } /* anonymous namespace */ #else static struct PyModuleDef __pyx_moduledef; #endif #define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef))) #define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef)) #else static __pyx_mstatetype __pyx_mstate_global_static = #ifdef __cplusplus {}; #else {0}; #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 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); Py_CLEAR(clear_module_state->__pyx_cython_runtime); Py_CLEAR(clear_module_state->__pyx_empty_tuple); Py_CLEAR(clear_module_state->__pyx_empty_bytes); Py_CLEAR(clear_module_state->__pyx_empty_unicode); #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); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_flatiter); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_broadcast); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ndarray); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_generic); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_number); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_integer); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_signedinteger); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_unsignedinteger); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_inexact); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_floating); Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_complexfloating); 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); 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 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); __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); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_broadcast); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ndarray); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_generic); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_number); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_integer); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_signedinteger); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_unsignedinteger); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_inexact); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_floating); Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_complexfloating); 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); 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_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; __pyx_r = PyArray_BASE(__pyx_v_self); goto __pyx_L0; /* function exit code */ __pyx_L0:; return __pyx_r; } static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArrayObject *__pyx_v_self) { PyArray_Descr *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyArray_Descr *__pyx_t_1; __Pyx_RefNannySetupContext("descr", 0); __Pyx_XDECREF((PyObject *)__pyx_r); __pyx_t_1 = PyArray_DESCR(__pyx_v_self); __Pyx_INCREF((PyObject *)((PyArray_Descr *)__pyx_t_1)); __pyx_r = ((PyArray_Descr *)__pyx_t_1); goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static CYTHON_INLINE int __pyx_f_5numpy_7ndarray_4ndim_ndim(PyArrayObject *__pyx_v_self) { int __pyx_r; __pyx_r = PyArray_NDIM(__pyx_v_self); goto __pyx_L0; /* function exit code */ __pyx_L0:; return __pyx_r; } static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObject *__pyx_v_self) { npy_intp *__pyx_r; __pyx_r = PyArray_DIMS(__pyx_v_self); goto __pyx_L0; /* function exit code */ __pyx_L0:; return __pyx_r; } static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self) { npy_intp *__pyx_r; __pyx_r = PyArray_STRIDES(__pyx_v_self); goto __pyx_L0; /* function exit code */ __pyx_L0:; return __pyx_r; } static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self) { npy_intp __pyx_r; __pyx_r = PyArray_SIZE(__pyx_v_self); goto __pyx_L0; /* function exit code */ __pyx_L0:; return __pyx_r; } static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self) { char *__pyx_r; __pyx_r = PyArray_BYTES(__pyx_v_self); goto __pyx_L0; /* function exit code */ __pyx_L0:; return __pyx_r; } static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { 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("PyArray_MultiIterNew1", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 824, __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("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { 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("PyArray_MultiIterNew2", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 827, __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("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { 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("PyArray_MultiIterNew3", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 830, __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("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { 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("PyArray_MultiIterNew4", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 833, __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("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { 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("PyArray_MultiIterNew5", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 836, __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("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_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_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_mstate_global->__pyx_empty_tuple); __pyx_r = __pyx_mstate_global->__pyx_empty_tuple; goto __pyx_L0; } /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; Py_INCREF(__pyx_v_base); __pyx_t_1 = PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(3, 1028, __pyx_L1_error) /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("numpy.set_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; } static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); __pyx_v_base = PyArray_BASE(__pyx_v_arr); __pyx_t_1 = (__pyx_v_base == NULL); if (__pyx_t_1) { __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_base)); __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; 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", 0); { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { __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; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(3, 1041, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); __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(3, 1042, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __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_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; 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", 0); { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { __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; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(3, 1047, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); __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(3, 1048, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __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_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; 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", 0); { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { __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; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L8_try_end; __pyx_L3_error:; __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(3, 1053, __pyx_L5_except_error) __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); __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(3, 1054, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L8_try_end:; } /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __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_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { int __pyx_r; __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); goto __pyx_L0; /* function exit code */ __pyx_L0:; return __pyx_r; } static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { int __pyx_r; __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); goto __pyx_L0; /* function exit code */ __pyx_L0:; return __pyx_r; } static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { npy_datetime __pyx_r; __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; /* function exit code */ __pyx_L0:; return __pyx_r; } static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { npy_timedelta __pyx_r; __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; /* function exit code */ __pyx_L0:; return __pyx_r; } static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { NPY_DATETIMEUNIT __pyx_r; __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); goto __pyx_L0; /* function exit code */ __pyx_L0:; return __pyx_r; } 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ static PyObject *__pyx_f_5talib_7_ta_lib__ta_check_success(PyObject *__pyx_v_function_name, TA_RetCode __pyx_v_ret_code, CYTHON_UNUSED int __pyx_skip_dispatch) { PyObject *__pyx_v_description = NULL; PyObject *__pyx_r = NULL; __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", 0); switch (__pyx_v_ret_code) { case 0: __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_True); __pyx_r = Py_True; goto __pyx_L0; break; case 1: __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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_mstate_global->__pyx_kp_u_Unknown_Error); __pyx_v_description = __pyx_mstate_global->__pyx_kp_u_Unknown_Error; break; } __pyx_t_2 = NULL; __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_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:; __Pyx_XDECREF(__pyx_v_description); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_function_name = 0; TA_RetCode __pyx_v_ret_code; #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("_ta_check_success (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_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_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_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; } const Py_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_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_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(1, 6, __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._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), (&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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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) { 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("_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, 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; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib._ta_check_success", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_5talib_7_ta_lib_3_ta_initialize(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ 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; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_initialize (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_5talib_7_ta_lib_2_ta_initialize(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_2_ta_initialize(CYTHON_UNUSED PyObject *__pyx_self) { TA_RetCode __pyx_v_ret_code; 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("_ta_initialize", 0); __pyx_v_ret_code = TA_Initialize(); __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; /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib._ta_initialize", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_5talib_7_ta_lib_5_ta_shutdown(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ 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; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_shutdown (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_5talib_7_ta_lib_4_ta_shutdown(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_4_ta_shutdown(CYTHON_UNUSED PyObject *__pyx_self) { TA_RetCode __pyx_v_ret_code; 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("_ta_shutdown", 0); __pyx_v_ret_code = TA_Shutdown(); __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; /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib._ta_shutdown", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("__init__ (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_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_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; } const Py_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_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(1, 63, __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_Type.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_7MA_Type___init__(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = 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("__init__", 0); __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_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_mstate_global->__pyx_n_u_SMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Simple_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 66, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_EMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 66, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Exponential_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 67, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_WMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 67, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Weighted_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DEMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Double_Exponential_Moving_Averag) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 69, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_TEMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 69, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Triple_Exponential_Moving_Averag) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 70, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_TRIMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 70, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_Triangular_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_KAMA); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Kaufman_Adaptive_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 72, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MAMA); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 72, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_t_1, __pyx_t_2, __pyx_mstate_global->__pyx_kp_u_MESA_Adaptive_Moving_Average) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_T3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_t_1, __pyx_t_3, __pyx_mstate_global->__pyx_kp_u_Triple_Generalized_Double_Expone) < (0)) __PYX_ERR(1, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_lookup, __pyx_t_1) < (0)) __PYX_ERR(1, 64, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("talib._ta_lib.MA_Type.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_type_ = 0; #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("__getitem__ (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_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_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_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; } const Py_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_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(1, 76, __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_Type.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_7MA_Type_2__getitem__(__pyx_self, __pyx_v_self, __pyx_v_type_); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_7MA_Type_2__getitem__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_type_) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getitem__", 0); __Pyx_XDECREF(__pyx_r); __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(1, 77, __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; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("talib._ta_lib.MA_Type.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_name = 0; PyObject *__pyx_v_period = 0; #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("_ta_set_unstable_period (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_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_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_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; } const Py_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_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(1, 90, __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._ta_set_unstable_period", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_6_ta_set_unstable_period(__pyx_self, __pyx_v_name, __pyx_v_period); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_6_ta_set_unstable_period(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name, PyObject *__pyx_v_period) { TA_RetCode __pyx_v_ret_code; TA_FuncUnstId __pyx_v_id; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; TA_FuncUnstId __pyx_t_3; unsigned int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_ta_set_unstable_period", 0); __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(1, 92, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __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_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_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; /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("talib._ta_lib._ta_set_unstable_period", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_name = 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("_ta_get_unstable_period (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_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_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; } const Py_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_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(1, 96, __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._ta_get_unstable_period", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8_ta_get_unstable_period(__pyx_self, __pyx_v_name); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8_ta_get_unstable_period(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_name) { unsigned int __pyx_v_period; TA_FuncUnstId __pyx_v_id; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; TA_FuncUnstId __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_ta_get_unstable_period", 0); __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(1, 98, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __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_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; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("talib._ta_lib._ta_get_unstable_period", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_value = 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("_ta_set_compatibility (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_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_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; } const Py_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_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(1, 102, __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._ta_set_compatibility", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_10_ta_set_compatibility(__pyx_self, __pyx_v_value); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_10_ta_set_compatibility(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_value) { TA_RetCode __pyx_v_ret_code; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations TA_Compatibility __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_ta_set_compatibility", 0); __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_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; /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("talib._ta_lib._ta_set_compatibility", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_5talib_7_ta_lib_13_ta_get_compatibility(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ 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; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_ta_get_compatibility (wrapper)", 0); __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_5talib_7_ta_lib_12_ta_get_compatibility(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_12_ta_get_compatibility(CYTHON_UNUSED PyObject *__pyx_self) { int __pyx_v_value; 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("_ta_get_compatibility", 0); __pyx_v_value = TA_GetCompatibility(); __Pyx_XDECREF(__pyx_r); __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; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib._ta_get_compatibility", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_settingtype = 0; PyObject *__pyx_v_rangetype = 0; PyObject *__pyx_v_avgperiod = 0; PyObject *__pyx_v_factor = 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("_ta_set_candle_settings (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_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_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_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_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_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; } const Py_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_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]; __pyx_v_avgperiod = values[2]; __pyx_v_factor = values[3]; } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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(); return NULL; __pyx_L4_argument_unpacking_done:; __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 */ for (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_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) { TA_RetCode __pyx_v_ret_code; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations TA_CandleSettingType __pyx_t_1; TA_RangeType __pyx_t_2; int __pyx_t_3; double __pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_ta_set_candle_settings", 0); __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_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; /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("talib._ta_lib._ta_set_candle_settings", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_settingtype = 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("_ta_restore_candle_default_settings (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_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_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; } const Py_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_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(1, 129, __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._ta_restore_candle_default_settings", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_16_ta_restore_candle_default_settings(__pyx_self, __pyx_v_settingtype); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_16_ta_restore_candle_default_settings(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_settingtype) { TA_RetCode __pyx_v_ret_code; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations TA_CandleSettingType __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_ta_restore_candle_default_settings", 0); __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_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; /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("talib._ta_lib._ta_restore_candle_default_settings", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyArrayObject *__pyx_f_5talib_7_ta_lib_check_array(PyArrayObject *__pyx_v_real) { PyArrayObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations 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_array", 0); __Pyx_INCREF((PyObject *)__pyx_v_real); __pyx_t_1 = (PyArray_TYPE(__pyx_v_real) != NPY_DOUBLE); if (unlikely(__pyx_t_1)) { __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(4, 22, __pyx_L1_error) } __pyx_t_1 = (__pyx_f_5numpy_7ndarray_4ndim_ndim(__pyx_v_real) != 1); if (unlikely(__pyx_t_1)) { __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(4, 24, __pyx_L1_error) } __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(4, 26, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF_SET(__pyx_v_real, ((PyArrayObject *)__pyx_t_2)); __pyx_t_2 = 0; } __Pyx_XDECREF((PyObject *)__pyx_r); __Pyx_INCREF((PyObject *)__pyx_v_real); __pyx_r = __pyx_v_real; goto __pyx_L0; /* 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:; __Pyx_XDECREF((PyObject *)__pyx_v_real); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static npy_intp __pyx_f_5talib_7_ta_lib_check_length2(PyArrayObject *__pyx_v_a1, PyArrayObject *__pyx_v_a2) { npy_intp __pyx_v_length; npy_intp __pyx_r; __Pyx_RefNannyDeclarations 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", 0); __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a1)[0]); __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a2)[0])); if (unlikely(__pyx_t_1)) { __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) } __pyx_r = __pyx_v_length; goto __pyx_L0; /* 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 = -1L; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static npy_intp __pyx_f_5talib_7_ta_lib_check_length3(PyArrayObject *__pyx_v_a1, PyArrayObject *__pyx_v_a2, PyArrayObject *__pyx_v_a3) { npy_intp __pyx_v_length; npy_intp __pyx_r; __Pyx_RefNannyDeclarations 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", 0); __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a1)[0]); __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a2)[0])); if (unlikely(__pyx_t_1)) { __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_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a3)[0])); if (unlikely(__pyx_t_1)) { __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) } __pyx_r = __pyx_v_length; goto __pyx_L0; /* 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 = -1L; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static npy_intp __pyx_f_5talib_7_ta_lib_check_length4(PyArrayObject *__pyx_v_a1, PyArrayObject *__pyx_v_a2, PyArrayObject *__pyx_v_a3, PyArrayObject *__pyx_v_a4) { npy_intp __pyx_v_length; npy_intp __pyx_r; __Pyx_RefNannyDeclarations 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", 0); __pyx_v_length = (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a1)[0]); __pyx_t_1 = (__pyx_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a2)[0])); if (unlikely(__pyx_t_1)) { __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_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a3)[0])); if (unlikely(__pyx_t_1)) { __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_v_length != (__pyx_f_5numpy_7ndarray_5shape_shape(__pyx_v_a4)[0])); if (unlikely(__pyx_t_1)) { __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) } __pyx_r = __pyx_v_length; goto __pyx_L0; /* 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 = -1L; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static npy_int __pyx_f_5talib_7_ta_lib_check_begidx1(npy_intp __pyx_v_length, double *__pyx_v_a1) { double __pyx_v_val; long __pyx_v_i; npy_int __pyx_r; npy_intp __pyx_t_1; int __pyx_t_2; __pyx_t_1 = __pyx_v_length; for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) { __pyx_v_val = (__pyx_v_a1[__pyx_v_i]); __pyx_t_2 = (__pyx_v_val != __pyx_v_val); if (__pyx_t_2) { goto __pyx_L3_continue; } __pyx_r = __pyx_v_i; goto __pyx_L0; __pyx_L3_continue:; } /*else*/ { __pyx_r = (__pyx_v_length - 1); goto __pyx_L0; } /* function exit code */ __pyx_L0:; return __pyx_r; } static npy_int __pyx_f_5talib_7_ta_lib_check_begidx2(npy_intp __pyx_v_length, double *__pyx_v_a1, double *__pyx_v_a2) { double __pyx_v_val; long __pyx_v_i; npy_int __pyx_r; npy_intp __pyx_t_1; int __pyx_t_2; __pyx_t_1 = __pyx_v_length; for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) { __pyx_v_val = (__pyx_v_a1[__pyx_v_i]); __pyx_t_2 = (__pyx_v_val != __pyx_v_val); if (__pyx_t_2) { goto __pyx_L3_continue; } __pyx_v_val = (__pyx_v_a2[__pyx_v_i]); __pyx_t_2 = (__pyx_v_val != __pyx_v_val); if (__pyx_t_2) { goto __pyx_L3_continue; } __pyx_r = __pyx_v_i; goto __pyx_L0; __pyx_L3_continue:; } /*else*/ { __pyx_r = (__pyx_v_length - 1); goto __pyx_L0; } /* function exit code */ __pyx_L0:; return __pyx_r; } static npy_int __pyx_f_5talib_7_ta_lib_check_begidx3(npy_intp __pyx_v_length, double *__pyx_v_a1, double *__pyx_v_a2, double *__pyx_v_a3) { double __pyx_v_val; long __pyx_v_i; npy_int __pyx_r; npy_intp __pyx_t_1; int __pyx_t_2; __pyx_t_1 = __pyx_v_length; for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) { __pyx_v_val = (__pyx_v_a1[__pyx_v_i]); __pyx_t_2 = (__pyx_v_val != __pyx_v_val); if (__pyx_t_2) { goto __pyx_L3_continue; } __pyx_v_val = (__pyx_v_a2[__pyx_v_i]); __pyx_t_2 = (__pyx_v_val != __pyx_v_val); if (__pyx_t_2) { goto __pyx_L3_continue; } __pyx_v_val = (__pyx_v_a3[__pyx_v_i]); __pyx_t_2 = (__pyx_v_val != __pyx_v_val); if (__pyx_t_2) { goto __pyx_L3_continue; } __pyx_r = __pyx_v_i; goto __pyx_L0; __pyx_L3_continue:; } /*else*/ { __pyx_r = (__pyx_v_length - 1); goto __pyx_L0; } /* function exit code */ __pyx_L0:; return __pyx_r; } static npy_int __pyx_f_5talib_7_ta_lib_check_begidx4(npy_intp __pyx_v_length, double *__pyx_v_a1, double *__pyx_v_a2, double *__pyx_v_a3, double *__pyx_v_a4) { double __pyx_v_val; long __pyx_v_i; npy_int __pyx_r; npy_intp __pyx_t_1; int __pyx_t_2; __pyx_t_1 = __pyx_v_length; for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) { __pyx_v_val = (__pyx_v_a1[__pyx_v_i]); __pyx_t_2 = (__pyx_v_val != __pyx_v_val); if (__pyx_t_2) { goto __pyx_L3_continue; } __pyx_v_val = (__pyx_v_a2[__pyx_v_i]); __pyx_t_2 = (__pyx_v_val != __pyx_v_val); if (__pyx_t_2) { goto __pyx_L3_continue; } __pyx_v_val = (__pyx_v_a3[__pyx_v_i]); __pyx_t_2 = (__pyx_v_val != __pyx_v_val); if (__pyx_t_2) { goto __pyx_L3_continue; } __pyx_v_val = (__pyx_v_a4[__pyx_v_i]); __pyx_t_2 = (__pyx_v_val != __pyx_v_val); if (__pyx_t_2) { goto __pyx_L3_continue; } __pyx_r = __pyx_v_i; goto __pyx_L0; __pyx_L3_continue:; } /*else*/ { __pyx_r = (__pyx_v_length - 1); goto __pyx_L0; } /* function exit code */ __pyx_L0:; return __pyx_r; } static PyArrayObject *__pyx_f_5talib_7_ta_lib_make_double_array(npy_intp __pyx_v_length, int __pyx_v_lookback) { PyArrayObject *__pyx_v_outreal = 0; double *__pyx_v_outreal_data; long __pyx_v_i; PyArrayObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; 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", 0); __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_v_outreal_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outreal)); __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_4 = __pyx_t_3; } __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; } __Pyx_XDECREF((PyObject *)__pyx_r); __Pyx_INCREF((PyObject *)__pyx_v_outreal); __pyx_r = __pyx_v_outreal; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib.make_double_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyArrayObject *__pyx_f_5talib_7_ta_lib_make_int_array(npy_intp __pyx_v_length, int __pyx_v_lookback) { PyArrayObject *__pyx_v_outinteger = 0; int *__pyx_v_outinteger_data; long __pyx_v_i; PyArrayObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; 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", 0); __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_v_outinteger_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)); __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_4 = __pyx_t_3; } __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; } __Pyx_XDECREF((PyObject *)__pyx_r); __Pyx_INCREF((PyObject *)__pyx_v_outinteger); __pyx_r = __pyx_v_outinteger; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib.make_int_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outinteger); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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("ACOS (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,0}; 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_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; } const Py_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_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(4, 181, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 200, __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, 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(4, 205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.ACOS", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; PyArrayObject *__pyx_v_volume = 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("AD (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_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_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_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_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_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; } const Py_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_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]); __pyx_v_close = ((PyArrayObject *)values[2]); __pyx_v_volume = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("AD", 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, 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(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(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(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)-1L))) __PYX_ERR(4, 233, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 234, __pyx_L1_error) __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(4, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.AD", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real0 = 0; PyArrayObject *__pyx_v_real1 = 0; #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("ADD (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_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_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_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; } const Py_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_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(4, 242, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("ADD", 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, 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(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)-1L))) __PYX_ERR(4, 264, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 265, __pyx_L1_error) __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(4, 268, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.ADD", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XDECREF((PyObject *)__pyx_v_real0); __Pyx_XDECREF((PyObject *)__pyx_v_real1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; PyArrayObject *__pyx_v_volume = 0; int __pyx_v_fastperiod; int __pyx_v_slowperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[6] = {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("ADOSC (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_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_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_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_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_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_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_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; } const Py_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_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_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_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; } } __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_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_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(4, 273, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("ADOSC", 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, 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(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(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(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)-1L))) __PYX_ERR(4, 299, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 300, __pyx_L1_error) __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(4, 303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.ADOSC", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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; } /* Python wrapper */ 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_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 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("ADX (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, 308, __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, 308, __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, 308, __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, 308, __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, 308, __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, "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_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_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; } } __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, 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(4, 308, __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.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(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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("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(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(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(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)-1L))) __PYX_ERR(4, 332, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 333, __pyx_L1_error) __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(4, 336, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.ADX", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 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("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(4, 341, __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, 341, __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, 341, __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, 341, __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, 341, __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, "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_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_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; } } __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, 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(4, 341, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("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, 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(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(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)-1L))) __PYX_ERR(4, 365, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 366, __pyx_L1_error) __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(4, 369, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.ADXR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_fastperiod; int __pyx_v_slowperiod; 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("APO (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_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_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_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_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_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; } const Py_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_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_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_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_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_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_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_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(4, 374, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 397, __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, 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(4, 402, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.APO", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("AROON (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_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_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_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_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; } const Py_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((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, 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(4, 407, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; int __pyx_v_lookback; TA_RetCode __pyx_v_retCode; int __pyx_v_outbegidx; int __pyx_v_outnbelement; PyArrayObject *__pyx_v_outaroondown = 0; PyArrayObject *__pyx_v_outaroonup = 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("AROON", 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, 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(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)-1L))) __PYX_ERR(4, 432, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 433, __pyx_L1_error) __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(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(4, 437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outaroonup = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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(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)) != (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)) != (0)) __PYX_ERR(4, 440, __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.AROON", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outaroondown); __Pyx_XDECREF((PyObject *)__pyx_v_outaroonup); __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("AROONOSC (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_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_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_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_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; } const Py_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((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, 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(4, 442, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("AROONOSC", 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, 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(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)-1L))) __PYX_ERR(4, 465, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 466, __pyx_L1_error) __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(4, 469, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.AROONOSC", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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("ASIN (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,0}; 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_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; } const Py_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_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(4, 474, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 493, __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, 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(4, 498, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.ASIN", __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_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_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 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("ATAN (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,0}; 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_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; } const Py_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_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(4, 503, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 522, __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, 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(4, 527, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.ATAN", __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_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_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 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("ATR (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, 532, __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, 532, __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, 532, __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, 532, __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, 532, __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, "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_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_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; } } __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, 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(4, 532, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("ATR", 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, 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(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(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)-1L))) __PYX_ERR(4, 556, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 557, __pyx_L1_error) __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(4, 560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.ATR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 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("AVGPRICE (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, 565, __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, 565, __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, 565, __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, 565, __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, 565, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("AVGPRICE", 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, 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(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(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(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)-1L))) __PYX_ERR(4, 588, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 589, __pyx_L1_error) __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(4, 592, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.AVGPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 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("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(4, 628, __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(4, 628, __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(4, 628, __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, 628, __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, 628, __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, 628, __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, "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_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_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_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_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_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_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(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(4, 630, __pyx_L3_error) } else { __pyx_v_nbdevdn = ((double)((double)-4e37)); } if (values[4]) { __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(4, 628, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_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(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_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, 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(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(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(4, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreallowerband = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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(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)) != (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)) != (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)) != (0)) __PYX_ERR(4, 666, __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.BBANDS", __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_real); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("BETA (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_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_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_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_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; } const Py_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_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_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; } } __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(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(4, 668, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("BETA", 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, 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(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)-1L))) __PYX_ERR(4, 692, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 693, __pyx_L1_error) __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(4, 696, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.BETA", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XDECREF((PyObject *)__pyx_v_real0); __Pyx_XDECREF((PyObject *)__pyx_v_real1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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("BOP (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, 701, __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, 701, __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, 701, __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, 701, __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, 701, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("BOP", 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, 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(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(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(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)-1L))) __PYX_ERR(4, 724, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 725, __pyx_L1_error) __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(4, 728, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.BOP", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 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("CCI (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, 733, __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, 733, __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, 733, __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, 733, __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, 733, __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, "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_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_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; } } __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, 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(4, 733, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("CCI", 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, 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(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(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)-1L))) __PYX_ERR(4, 757, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 758, __pyx_L1_error) __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(4, 761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CCI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 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("CDL2CROWS (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, 766, __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, 766, __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, 766, __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, 766, __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, 766, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("CDL2CROWS", 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, 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(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(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(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)-1L))) __PYX_ERR(4, 789, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 790, __pyx_L1_error) __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(4, 793, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDL2CROWS", __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_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_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 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("CDL3BLACKCROWS (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, 798, __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, 798, __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, 798, __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, 798, __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, 798, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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(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(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(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(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)-1L))) __PYX_ERR(4, 821, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 822, __pyx_L1_error) __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(4, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDL3BLACKCROWS", __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_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_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 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("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(4, 830, __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, 830, __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, 830, __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, 830, __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, 830, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 853, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 854, __pyx_L1_error) __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(4, 857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDL3INSIDE", __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_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_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 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("CDL3LINESTRIKE (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, 862, __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, 862, __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, 862, __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, 862, __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, 862, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 885, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 886, __pyx_L1_error) __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(4, 889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDL3LINESTRIKE", __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_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_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 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("CDL3OUTSIDE (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, 894, __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, 894, __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, 894, __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, 894, __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, 894, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 917, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 918, __pyx_L1_error) __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(4, 921, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDL3OUTSIDE", __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_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_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 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("CDL3STARSINSOUTH (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, 926, __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, 926, __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, 926, __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, 926, __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, 926, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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(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(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(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(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)-1L))) __PYX_ERR(4, 949, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 950, __pyx_L1_error) __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(4, 953, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDL3STARSINSOUTH", __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_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_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 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("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(4, 958, __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, 958, __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, 958, __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, 958, __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, 958, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 981, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 982, __pyx_L1_error) __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(4, 985, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDL3WHITESOLDIERS", __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_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_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 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; 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLABANDONEDBABY (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,&__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_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_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_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_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_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; } const Py_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_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_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; } } __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, 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(4, 990, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1015, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1016, __pyx_L1_error) __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(4, 1019, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLABANDONEDBABY", __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_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_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 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("CDLADVANCEBLOCK (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, 1024, __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, 1024, __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, 1024, __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, 1024, __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, 1024, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1047, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1048, __pyx_L1_error) __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(4, 1051, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLADVANCEBLOCK", __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_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_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 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("CDLBELTHOLD (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, 1056, __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, 1056, __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, 1056, __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, 1056, __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, 1056, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1079, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1080, __pyx_L1_error) __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(4, 1083, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLBELTHOLD", __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_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_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 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("CDLBREAKAWAY (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, 1088, __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, 1088, __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, 1088, __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, 1088, __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, 1088, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1111, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1112, __pyx_L1_error) __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(4, 1115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLBREAKAWAY", __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_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_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 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("CDLCLOSINGMARUBOZU (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, 1120, __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, 1120, __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, 1120, __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, 1120, __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, 1120, __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, "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 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 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: 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 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; } const Py_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_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]); __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(4, 1152, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1175, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1176, __pyx_L1_error) __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(4, 1179, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLCONCEALBABYSWALL", __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_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_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 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("CDLCOUNTERATTACK (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, 1184, __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, 1184, __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, 1184, __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, 1184, __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, 1184, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1207, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1208, __pyx_L1_error) __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(4, 1211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLCOUNTERATTACK", __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_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_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 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; 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLDARKCLOUDCOVER (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,&__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_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_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_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_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_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; } const Py_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_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_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; } } __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, 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(4, 1216, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1241, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1242, __pyx_L1_error) __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(4, 1245, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLDARKCLOUDCOVER", __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_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_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 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("CDLDOJI (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, 1250, __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, 1250, __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, 1250, __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, 1250, __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, 1250, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1273, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1274, __pyx_L1_error) __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(4, 1277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLDOJI", __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_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_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 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("CDLDOJISTAR (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, 1282, __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, 1282, __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, 1282, __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, 1282, __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, 1282, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1305, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1306, __pyx_L1_error) __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(4, 1309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLDOJISTAR", __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_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_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 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("CDLDRAGONFLYDOJI (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, 1314, __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, 1314, __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, 1314, __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, 1314, __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, 1314, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1337, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1338, __pyx_L1_error) __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(4, 1341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLDRAGONFLYDOJI", __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_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_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 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("CDLENGULFING (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, 1346, __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, 1346, __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, 1346, __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, 1346, __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, 1346, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1369, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1370, __pyx_L1_error) __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(4, 1373, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLENGULFING", __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_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_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 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; 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLEVENINGDOJISTAR (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,&__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_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_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_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_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_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; } const Py_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_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_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; } } __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, 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(4, 1378, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1403, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1404, __pyx_L1_error) __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(4, 1407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLEVENINGDOJISTAR", __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_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_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 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; 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLEVENINGSTAR (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,&__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_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_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_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_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_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; } const Py_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_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_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; } } __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, 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(4, 1412, __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.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_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); { 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_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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1469, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1470, __pyx_L1_error) __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(4, 1473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLGAPSIDESIDEWHITE", __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_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_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 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("CDLGRAVESTONEDOJI (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, 1478, __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, 1478, __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, 1478, __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, 1478, __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, 1478, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1501, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1502, __pyx_L1_error) __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(4, 1505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLGRAVESTONEDOJI", __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_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_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 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("CDLHAMMER (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, 1510, __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, 1510, __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, 1510, __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, 1510, __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, 1510, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1533, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1534, __pyx_L1_error) __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(4, 1537, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLHAMMER", __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_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_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 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("CDLHANGINGMAN (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, 1542, __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, 1542, __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, 1542, __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, 1542, __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, 1542, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1565, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1566, __pyx_L1_error) __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(4, 1569, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLHANGINGMAN", __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_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_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 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("CDLHARAMI (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, 1574, __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, 1574, __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, 1574, __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, 1574, __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, 1574, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1597, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1598, __pyx_L1_error) __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(4, 1601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLHARAMI", __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_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_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 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("CDLHARAMICROSS (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, 1606, __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, 1606, __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, 1606, __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, 1606, __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, 1606, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1629, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1630, __pyx_L1_error) __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(4, 1633, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLHARAMICROSS", __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_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_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 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("CDLHIGHWAVE (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, 1638, __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, 1638, __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, 1638, __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, 1638, __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, 1638, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1661, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1662, __pyx_L1_error) __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(4, 1665, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLHIGHWAVE", __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_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_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 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("CDLHIKKAKE (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, 1670, __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, 1670, __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, 1670, __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, 1670, __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, 1670, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1693, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1694, __pyx_L1_error) __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(4, 1697, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLHIKKAKE", __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_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_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 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("CDLHIKKAKEMOD (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, 1702, __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, 1702, __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, 1702, __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, 1702, __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, 1702, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1725, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1726, __pyx_L1_error) __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(4, 1729, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLHIKKAKEMOD", __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_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_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 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("CDLHOMINGPIGEON (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, 1734, __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, 1734, __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, 1734, __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, 1734, __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, 1734, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1757, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1758, __pyx_L1_error) __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(4, 1761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLHOMINGPIGEON", __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_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_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 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("CDLIDENTICAL3CROWS (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, 1766, __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, 1766, __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, 1766, __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, 1766, __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, 1766, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1789, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1790, __pyx_L1_error) __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(4, 1793, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLIDENTICAL3CROWS", __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_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_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 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("CDLINNECK (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, 1798, __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, 1798, __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, 1798, __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, 1798, __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, 1798, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1821, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1822, __pyx_L1_error) __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(4, 1825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLINNECK", __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_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_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 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("CDLINVERTEDHAMMER (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, 1830, __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, 1830, __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, 1830, __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, 1830, __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, 1830, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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(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(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(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(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)-1L))) __PYX_ERR(4, 1853, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1854, __pyx_L1_error) __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(4, 1857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLINVERTEDHAMMER", __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_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_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 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("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(4, 1862, __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, 1862, __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, 1862, __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, 1862, __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, 1862, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1885, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1886, __pyx_L1_error) __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(4, 1889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLKICKING", __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_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_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 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("CDLKICKINGBYLENGTH (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, 1894, __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, 1894, __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, 1894, __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, 1894, __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, 1894, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1917, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1918, __pyx_L1_error) __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(4, 1921, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLKICKINGBYLENGTH", __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_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_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 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("CDLLADDERBOTTOM (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, 1926, __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, 1926, __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, 1926, __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, 1926, __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, 1926, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1949, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1950, __pyx_L1_error) __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(4, 1953, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLLADDERBOTTOM", __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_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_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 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("CDLLONGLEGGEDDOJI (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, 1958, __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, 1958, __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, 1958, __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, 1958, __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, 1958, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 1981, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 1982, __pyx_L1_error) __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(4, 1985, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLLONGLEGGEDDOJI", __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_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_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 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("CDLLONGLINE (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, 1990, __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, 1990, __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, 1990, __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, 1990, __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, 1990, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2013, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2014, __pyx_L1_error) __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(4, 2017, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLLONGLINE", __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_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_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 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("CDLMARUBOZU (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, 2022, __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, 2022, __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, 2022, __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, 2022, __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, 2022, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2045, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2046, __pyx_L1_error) __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(4, 2049, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLMARUBOZU", __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_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_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 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("CDLMATCHINGLOW (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, 2054, __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, 2054, __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, 2054, __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, 2054, __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, 2054, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2077, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2078, __pyx_L1_error) __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(4, 2081, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLMATCHINGLOW", __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_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_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 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; 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLMATHOLD (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,&__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_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_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_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_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_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; } const Py_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_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_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; } } __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, 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(4, 2086, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2111, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2112, __pyx_L1_error) __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(4, 2115, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLMATHOLD", __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_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_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 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; 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLMORNINGDOJISTAR (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,&__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_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_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_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_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_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; } const Py_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_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_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; } } __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, 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(4, 2120, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2145, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2146, __pyx_L1_error) __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(4, 2149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLMORNINGDOJISTAR", __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_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_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 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; 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CDLMORNINGSTAR (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,&__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_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_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_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_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_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; } const Py_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_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_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; } } __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, 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(4, 2154, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2179, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2180, __pyx_L1_error) __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(4, 2183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLMORNINGSTAR", __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_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_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 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("CDLONNECK (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, 2188, __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, 2188, __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, 2188, __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, 2188, __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, 2188, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2211, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2212, __pyx_L1_error) __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(4, 2215, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLONNECK", __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_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_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 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("CDLPIERCING (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, 2220, __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, 2220, __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, 2220, __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, 2220, __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, 2220, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2243, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2244, __pyx_L1_error) __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(4, 2247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLPIERCING", __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_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_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 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("CDLRICKSHAWMAN (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, 2252, __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, 2252, __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, 2252, __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, 2252, __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, 2252, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2275, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2276, __pyx_L1_error) __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(4, 2279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLRICKSHAWMAN", __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_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_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 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("CDLRISEFALL3METHODS (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, 2284, __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, 2284, __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, 2284, __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, 2284, __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, 2284, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2307, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2308, __pyx_L1_error) __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(4, 2311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLRISEFALL3METHODS", __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_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_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 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("CDLSEPARATINGLINES (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, 2316, __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, 2316, __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, 2316, __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, 2316, __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, 2316, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2339, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2340, __pyx_L1_error) __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(4, 2343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLSEPARATINGLINES", __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_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_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 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("CDLSHOOTINGSTAR (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, 2348, __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, 2348, __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, 2348, __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, 2348, __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, 2348, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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(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(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(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(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)-1L))) __PYX_ERR(4, 2371, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2372, __pyx_L1_error) __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(4, 2375, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLSHOOTINGSTAR", __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_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_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 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("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(4, 2380, __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, 2380, __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, 2380, __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, 2380, __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, 2380, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2403, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2404, __pyx_L1_error) __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(4, 2407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLSHORTLINE", __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_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_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 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("CDLSPINNINGTOP (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, 2412, __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, 2412, __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, 2412, __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, 2412, __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, 2412, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2435, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2436, __pyx_L1_error) __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(4, 2439, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLSPINNINGTOP", __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_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_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 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("CDLSTALLEDPATTERN (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, 2444, __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, 2444, __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, 2444, __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, 2444, __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, 2444, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2467, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2468, __pyx_L1_error) __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(4, 2471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLSTALLEDPATTERN", __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_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_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 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("CDLSTICKSANDWICH (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, 2476, __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, 2476, __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, 2476, __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, 2476, __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, 2476, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2499, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2500, __pyx_L1_error) __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(4, 2503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLSTICKSANDWICH", __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_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_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 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("CDLTAKURI (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, 2508, __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, 2508, __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, 2508, __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, 2508, __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, 2508, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2531, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2532, __pyx_L1_error) __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(4, 2535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLTAKURI", __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_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_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 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("CDLTASUKIGAP (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, 2540, __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, 2540, __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, 2540, __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, 2540, __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, 2540, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2563, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2564, __pyx_L1_error) __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(4, 2567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLTASUKIGAP", __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_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_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 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("CDLTHRUSTING (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, 2572, __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, 2572, __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, 2572, __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, 2572, __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, 2572, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2595, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2596, __pyx_L1_error) __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(4, 2599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLTHRUSTING", __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_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_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 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("CDLTRISTAR (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, 2604, __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, 2604, __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, 2604, __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, 2604, __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, 2604, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2627, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2628, __pyx_L1_error) __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(4, 2631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLTRISTAR", __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_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_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 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("CDLUNIQUE3RIVER (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, 2636, __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, 2636, __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, 2636, __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, 2636, __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, 2636, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2659, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2660, __pyx_L1_error) __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(4, 2663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLUNIQUE3RIVER", __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_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_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 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("CDLUPSIDEGAP2CROWS (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, 2668, __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, 2668, __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, 2668, __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, 2668, __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, 2668, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2691, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2692, __pyx_L1_error) __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(4, 2695, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLUPSIDEGAP2CROWS", __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_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_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 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("CDLXSIDEGAP3METHODS (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, 2700, __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, 2700, __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, 2700, __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, 2700, __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, 2700, __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, "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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 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(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(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(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)-1L))) __PYX_ERR(4, 2723, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2724, __pyx_L1_error) __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(4, 2727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CDLXSIDEGAP3METHODS", __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_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_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 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("CEIL (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,0}; 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_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; } const Py_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_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(4, 2732, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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(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_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, 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(4, 2756, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CEIL", __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_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_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 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("CMO (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, 2761, __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, 2761, __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, 2761, __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, "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_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_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_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(4, 2761, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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(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_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, 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(4, 2787, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CMO", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("CORREL (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_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_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_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_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; } const Py_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_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_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; } } __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(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(4, 2792, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("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_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(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)-1L))) __PYX_ERR(4, 2816, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2817, __pyx_L1_error) __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(4, 2820, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.CORREL", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XDECREF((PyObject *)__pyx_v_real0); __Pyx_XDECREF((PyObject *)__pyx_v_real1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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("COS (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,0}; 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_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; } const Py_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_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(4, 2825, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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(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_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, 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(4, 2849, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.COS", __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_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_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 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("COSH (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,0}; 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_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; } const Py_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_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(4, 2854, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 2873, __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, 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(4, 2878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.COSH", __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_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_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 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("DEMA (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, 2883, __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, 2883, __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, 2883, __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, "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_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_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_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(4, 2883, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 2904, __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, 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(4, 2909, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.DEMA", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real0 = 0; PyArrayObject *__pyx_v_real1 = 0; #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("DIV (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_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_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_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; } const Py_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_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(4, 2914, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("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, 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(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)-1L))) __PYX_ERR(4, 2936, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2937, __pyx_L1_error) __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(4, 2940, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.DIV", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XDECREF((PyObject *)__pyx_v_real0); __Pyx_XDECREF((PyObject *)__pyx_v_real1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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("DX (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, 2945, __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, 2945, __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, 2945, __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, 2945, __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, 2945, __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, "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_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_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; } } __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, 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(4, 2945, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("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, 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(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(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)-1L))) __PYX_ERR(4, 2969, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 2970, __pyx_L1_error) __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(4, 2973, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.DX", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 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("EMA (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, 2978, __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, 2978, __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, 2978, __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, "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_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_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_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(4, 2978, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 2999, __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, 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(4, 3004, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.EMA", __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_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_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 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("EXP (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,0}; 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_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; } const Py_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_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(4, 3009, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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(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_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, 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(4, 3033, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.EXP", __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_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_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 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("FLOOR (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,0}; 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_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; } const Py_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_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(4, 3038, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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(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_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, 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(4, 3062, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.FLOOR", __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_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_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 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("HT_DCPERIOD (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,0}; 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_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; } const Py_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_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(4, 3067, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_DCPERIOD(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { 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("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, 3086, __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, 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(4, 3091, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.HT_DCPERIOD", __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_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_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 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("HT_DCPHASE (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,0}; 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_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; } const Py_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_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(4, 3096, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_DCPHASE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { 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("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, 3115, __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, 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(4, 3120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.HT_DCPHASE", __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_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_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 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("HT_PHASOR (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,0}; 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_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; } const Py_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_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(4, 3125, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_PHASOR(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { 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_outinphase = 0; PyArrayObject *__pyx_v_outquadrature = 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("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, 3146, __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, 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(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(4, 3152, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outquadrature = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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(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)) != (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)) != (0)) __PYX_ERR(4, 3155, __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.HT_PHASOR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outinphase); __Pyx_XDECREF((PyObject *)__pyx_v_outquadrature); __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_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_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 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("HT_SINE (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,0}; 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_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; } const Py_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_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(4, 3157, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_SINE(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_real) { 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_outsine = 0; PyArrayObject *__pyx_v_outleadsine = 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("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, 3178, __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, 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(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(4, 3184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outleadsine = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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(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)) != (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)) != (0)) __PYX_ERR(4, 3187, __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.HT_SINE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outsine); __Pyx_XDECREF((PyObject *)__pyx_v_outleadsine); __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_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_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 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("HT_TRENDLINE (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,0}; 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_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; } const Py_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_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(4, 3189, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 3208, __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, 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(4, 3213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.HT_TRENDLINE", __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_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_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 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("HT_TRENDMODE (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,0}; 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_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; } const Py_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_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(4, 3218, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_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(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_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, 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(4, 3242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.HT_TRENDMODE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outinteger); __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_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_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_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[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("IMI (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_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 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 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; } const Py_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 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 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_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("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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 3268, __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_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_5talib_7_ta_lib_check_length2(__pyx_v_open, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(4, 3270, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_open)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3271, __pyx_L1_error) __pyx_v_begidx = __pyx_t_3; __pyx_v_endidx = ((((int)__pyx_v_length) - __pyx_v_begidx) - 1); __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(4, 3274, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.IMI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XDECREF((PyObject *)__pyx_v_open); __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_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_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 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("KAMA (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, 3279, __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, 3279, __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, 3279, __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, "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_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_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_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("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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 3300, __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, 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_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(4, 3305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.KAMA", __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_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_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 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("LINEARREG (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, 3310, __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, 3310, __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, 3310, __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, "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_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_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_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", 0, 1, 2, __pyx_nargs); __PYX_ERR(4, 3310, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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(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("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, 3331, __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, 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_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, 3336, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.LINEARREG", __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_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_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 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("LINEARREG_ANGLE (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, 3341, __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, 3341, __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, 3341, __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, "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_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_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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 3362, __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, 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_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(4, 3367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.LINEARREG_ANGLE", __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_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_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 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("LINEARREG_INTERCEPT (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, 3372, __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, 3372, __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, 3372, __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, "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_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_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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 3393, __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, 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_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(4, 3398, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.LINEARREG_INTERCEPT", __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_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_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 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("LINEARREG_SLOPE (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, 3403, __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, 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; } const Py_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 { 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("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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 3424, __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, 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_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(4, 3429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.LINEARREG_SLOPE", __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_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_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 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("LN (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,0}; 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_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; } const Py_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_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("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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 3453, __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, 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_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(4, 3458, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.LN", __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_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_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 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("LOG10 (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,0}; 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 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; } const Py_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 { 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]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 3482, __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, 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_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(4, 3487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.LOG10", __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_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_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 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MA (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_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 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: 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; } const Py_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 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: 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: 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_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; } const Py_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_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: 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_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_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_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_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(4, 3524, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; int __pyx_v_lookback; TA_RetCode __pyx_v_retCode; int __pyx_v_outbegidx; int __pyx_v_outnbelement; PyArrayObject *__pyx_v_outmacd = 0; PyArrayObject *__pyx_v_outmacdsignal = 0; PyArrayObject *__pyx_v_outmacdhist = 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("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, 3551, __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, 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(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(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(4, 3558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmacdhist = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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(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)) != (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)) != (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)) != (0)) __PYX_ERR(4, 3561, __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.MACD", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outmacd); __Pyx_XDECREF((PyObject *)__pyx_v_outmacdsignal); __Pyx_XDECREF((PyObject *)__pyx_v_outmacdhist); __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_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_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 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; #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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MACDEXT (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_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_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_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_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_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_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_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_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; } const Py_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_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_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_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_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_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_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_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_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_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_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_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_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_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(4, 3563, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; int __pyx_v_lookback; TA_RetCode __pyx_v_retCode; int __pyx_v_outbegidx; int __pyx_v_outnbelement; PyArrayObject *__pyx_v_outmacd = 0; PyArrayObject *__pyx_v_outmacdsignal = 0; PyArrayObject *__pyx_v_outmacdhist = 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("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, 3593, __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, 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(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(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(4, 3600, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmacdhist = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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(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)) != (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)) != (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)) != (0)) __PYX_ERR(4, 3603, __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.MACDEXT", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outmacd); __Pyx_XDECREF((PyObject *)__pyx_v_outmacdsignal); __Pyx_XDECREF((PyObject *)__pyx_v_outmacdhist); __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_signalperiod; #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("MACDFIX (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_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_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_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; } const Py_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_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_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_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(4, 3605, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; int __pyx_v_lookback; TA_RetCode __pyx_v_retCode; int __pyx_v_outbegidx; int __pyx_v_outnbelement; PyArrayObject *__pyx_v_outmacd = 0; PyArrayObject *__pyx_v_outmacdsignal = 0; PyArrayObject *__pyx_v_outmacdhist = 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("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, 3630, __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, 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(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(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(4, 3637, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmacdhist = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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(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)) != (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)) != (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)) != (0)) __PYX_ERR(4, 3640, __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.MACDFIX", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outmacd); __Pyx_XDECREF((PyObject *)__pyx_v_outmacdsignal); __Pyx_XDECREF((PyObject *)__pyx_v_outmacdhist); __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; 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[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("MAMA (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_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_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_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_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; } const Py_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_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_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_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(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(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(4, 3642, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; int __pyx_v_lookback; TA_RetCode __pyx_v_retCode; int __pyx_v_outbegidx; int __pyx_v_outnbelement; PyArrayObject *__pyx_v_outmama = 0; PyArrayObject *__pyx_v_outfama = 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("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, 3666, __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, 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(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(4, 3672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outfama = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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(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)) != (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)) != (0)) __PYX_ERR(4, 3675, __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.MAMA", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outmama); __Pyx_XDECREF((PyObject *)__pyx_v_outfama); __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_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_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 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; #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("MAVP (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_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_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_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_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_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_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; } const Py_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_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_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_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_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; } } __pyx_v_real = ((PyArrayObject *)values[0]); __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(4, 3679, __pyx_L3_error) } else { __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(4, 3679, __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(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(4, 3677, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("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, 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(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)-1L))) __PYX_ERR(4, 3703, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_periods))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3704, __pyx_L1_error) __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(4, 3707, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.MAVP", __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_periods); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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("MAX (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, 3712, __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, 3712, __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, 3712, __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, "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_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_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_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(4, 3712, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 3733, __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, 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(4, 3738, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.MAX", __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_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_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 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("MAXINDEX (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, 3743, __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, 3743, __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, 3743, __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, "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_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_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_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(4, 3743, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; int __pyx_v_lookback; TA_RetCode __pyx_v_retCode; int __pyx_v_outbegidx; int __pyx_v_outnbelement; PyArrayObject *__pyx_v_outinteger = 0; int *__pyx_v_outinteger_data; int __pyx_v_i; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; 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(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_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, 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(4, 3769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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_v_outinteger_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)); __pyx_t_3 = __pyx_v_length; for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_3; __pyx_v_i++) { __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); __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.MAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outinteger); __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; #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("MEDPRICE (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,0}; 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_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_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; } const Py_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_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(4, 3777, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("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, 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(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)-1L))) __PYX_ERR(4, 3798, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3799, __pyx_L1_error) __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(4, 3802, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MFI (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_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_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_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_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_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_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; } const Py_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_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_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; } } __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(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(4, 3807, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("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_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(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(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(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)-1L))) __PYX_ERR(4, 3832, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx4(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3833, __pyx_L1_error) __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(4, 3836, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.MFI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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; } /* Python wrapper */ 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_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 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("MIDPOINT (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, 3841, __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, 3841, __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, 3841, __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, "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_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_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_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(4, 3841, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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(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_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, 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(4, 3867, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.MIDPOINT", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MIDPRICE (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_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_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_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_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; } const Py_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((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, 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(4, 3872, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("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, 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(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)-1L))) __PYX_ERR(4, 3895, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 3896, __pyx_L1_error) __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(4, 3899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.MIDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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("MIN (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, 3904, __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, 3904, __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, 3904, __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, "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_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_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_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(4, 3904, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 3925, __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, 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(4, 3930, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.MIN", __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_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_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 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("MININDEX (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, 3935, __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, 3935, __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, 3935, __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, "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_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_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_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(4, 3935, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; int __pyx_v_lookback; TA_RetCode __pyx_v_retCode; int __pyx_v_outbegidx; int __pyx_v_outnbelement; PyArrayObject *__pyx_v_outinteger = 0; int *__pyx_v_outinteger_data; int __pyx_v_i; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; 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(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_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, 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(4, 3961, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outinteger = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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_v_outinteger_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outinteger)); __pyx_t_3 = __pyx_v_length; for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_3; __pyx_v_i++) { __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); __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.MININDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outinteger); __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_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_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 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("MINMAX (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, 3969, __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, 3969, __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, 3969, __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, "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_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_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_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(4, 3969, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; int __pyx_v_lookback; TA_RetCode __pyx_v_retCode; int __pyx_v_outbegidx; int __pyx_v_outnbelement; PyArrayObject *__pyx_v_outmin = 0; PyArrayObject *__pyx_v_outmax = 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("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, 3992, __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, 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(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(4, 3998, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmax = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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(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)) != (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)) != (0)) __PYX_ERR(4, 4001, __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.MINMAX", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outmin); __Pyx_XDECREF((PyObject *)__pyx_v_outmax); __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_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_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 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("MINMAXINDEX (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, 4003, __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, 4003, __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, 4003, __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, "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_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_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_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(4, 4003, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; int __pyx_v_lookback; TA_RetCode __pyx_v_retCode; int __pyx_v_outbegidx; int __pyx_v_outnbelement; PyArrayObject *__pyx_v_outminidx = 0; PyArrayObject *__pyx_v_outmaxidx = 0; int *__pyx_v_outminidx_data; int __pyx_v_i; int *__pyx_v_outmaxidx_data; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; 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(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_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, 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(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(4, 4032, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outmaxidx = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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_v_outminidx_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outminidx)); __pyx_t_3 = __pyx_v_length; for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_3; __pyx_v_i++) { __pyx_t_4 = __pyx_v_i; (__pyx_v_outminidx_data[__pyx_t_4]) = ((__pyx_v_outminidx_data[__pyx_t_4]) + __pyx_v_begidx); } __pyx_v_outmaxidx_data = ((int *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_outmaxidx)); __pyx_t_3 = __pyx_v_length; for (__pyx_v_i = __pyx_v_lookback; __pyx_v_i < __pyx_t_3; __pyx_v_i++) { __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(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)) != (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)) != (0)) __PYX_ERR(4, 4041, __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.MINMAXINDEX", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outminidx); __Pyx_XDECREF((PyObject *)__pyx_v_outmaxidx); __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_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_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 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("MINUS_DI (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, 4043, __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, 4043, __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, 4043, __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, 4043, __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, 4043, __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, "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_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_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; } } __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, 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(4, 4043, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MINUS_DI", 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, 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(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(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)-1L))) __PYX_ERR(4, 4067, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4068, __pyx_L1_error) __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(4, 4071, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.MINUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("MINUS_DM (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_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_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_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_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; } const Py_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((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, 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(4, 4076, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MINUS_DM", 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, 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(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)-1L))) __PYX_ERR(4, 4099, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4100, __pyx_L1_error) __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(4, 4103, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.MINUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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("MOM (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, 4108, __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, 4108, __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, 4108, __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, "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_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_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_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(4, 4108, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4129, __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, 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(4, 4134, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.MOM", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real0 = 0; PyArrayObject *__pyx_v_real1 = 0; #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("MULT (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_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_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_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; } const Py_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_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(4, 4139, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("MULT", 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, 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(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)-1L))) __PYX_ERR(4, 4161, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4162, __pyx_L1_error) __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(4, 4165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.MULT", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XDECREF((PyObject *)__pyx_v_real0); __Pyx_XDECREF((PyObject *)__pyx_v_real1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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("NATR (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, 4170, __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, 4170, __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, 4170, __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, 4170, __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, 4170, __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, "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_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_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; } } __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, 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(4, 4170, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("NATR", 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, 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(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(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)-1L))) __PYX_ERR(4, 4194, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4195, __pyx_L1_error) __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(4, 4198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.NATR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; PyArrayObject *__pyx_v_volume = 0; #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("OBV (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_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_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_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; } const Py_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_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(4, 4203, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("OBV", 0); __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, 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(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)-1L))) __PYX_ERR(4, 4225, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4226, __pyx_L1_error) __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(4, 4229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.OBV", __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_volume); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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("PLUS_DI (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, 4234, __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, 4234, __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, 4234, __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, 4234, __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, 4234, __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, "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_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_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; } } __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, 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(4, 4234, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PLUS_DI", 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, 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(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(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)-1L))) __PYX_ERR(4, 4258, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4259, __pyx_L1_error) __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(4, 4262, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.PLUS_DI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("PLUS_DM (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_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_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_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_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; } const Py_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((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, 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(4, 4267, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PLUS_DM", 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, 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(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)-1L))) __PYX_ERR(4, 4290, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4291, __pyx_L1_error) __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(4, 4294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.PLUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_fastperiod; int __pyx_v_slowperiod; 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("PPO (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_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_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_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_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_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; } const Py_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_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_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_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_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_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_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_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(4, 4299, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4322, __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, 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(4, 4327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.PPO", __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_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_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 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("ROC (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, 4332, __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, 4332, __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, 4332, __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, "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_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_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_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(4, 4332, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4353, __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, 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(4, 4358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.ROC", __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_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_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 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("ROCP (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, 4363, __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, 4363, __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, 4363, __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, "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_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_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_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(4, 4363, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4384, __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, 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(4, 4389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.ROCP", __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_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_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 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("ROCR (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, 4394, __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, 4394, __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, 4394, __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, "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_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_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_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(4, 4394, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4415, __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, 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(4, 4420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.ROCR", __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_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_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 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("ROCR100 (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, 4425, __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, 4425, __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, 4425, __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, "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_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_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_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(4, 4425, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4446, __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, 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(4, 4451, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.ROCR100", __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_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_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 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("RSI (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, 4456, __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, 4456, __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, 4456, __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, "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_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_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_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(4, 4456, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4477, __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, 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(4, 4482, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.RSI", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; double __pyx_v_acceleration; double __pyx_v_maximum; #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("SAR (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_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_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_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_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_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; } const Py_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_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_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_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; } } __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, 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(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(4, 4487, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("SAR", 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, 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(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)-1L))) __PYX_ERR(4, 4511, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4512, __pyx_L1_error) __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(4, 4515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.SAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; 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; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[10] = {0,0,0,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("SAREXT (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_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_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_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_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_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_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_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_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_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_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_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; } const Py_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_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_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_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_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_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_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_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_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_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; } } __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, 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(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(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(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(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(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(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(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(4, 4520, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("SAREXT", 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, 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(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)-1L))) __PYX_ERR(4, 4550, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4551, __pyx_L1_error) __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(4, 4554, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.SAREXT", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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("SIN (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,0}; 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_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; } const Py_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_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(4, 4559, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4578, __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, 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(4, 4583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.SIN", __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_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_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 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("SINH (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,0}; 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_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; } const Py_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_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(4, 4588, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4607, __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, 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(4, 4612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.SINH", __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_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_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 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("SMA (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, 4617, __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, 4617, __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, 4617, __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, "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_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_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_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(4, 4617, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4638, __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, 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(4, 4643, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.SMA", __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_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_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 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("SQRT (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,0}; 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_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; } const Py_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_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(4, 4648, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4667, __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, 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(4, 4672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.SQRT", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_timeperiod; double __pyx_v_nbdev; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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("STDDEV (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_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_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_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_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; } const Py_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_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_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_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_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(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(4, 4677, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4699, __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, 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(4, 4704, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.STDDEV", __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_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_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 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_fastk_period; int __pyx_v_slowk_period; int __pyx_v_slowk_matype; int __pyx_v_slowd_period; int __pyx_v_slowd_matype; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[8] = {0,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("STOCH (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_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_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_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_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_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_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_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_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_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; } const Py_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_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_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_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_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { __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_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_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_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_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(4, 4709, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; int __pyx_v_lookback; TA_RetCode __pyx_v_retCode; int __pyx_v_outbegidx; int __pyx_v_outnbelement; PyArrayObject *__pyx_v_outslowk = 0; PyArrayObject *__pyx_v_outslowd = 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("STOCH", 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, 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(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(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)-1L))) __PYX_ERR(4, 4739, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4740, __pyx_L1_error) __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(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(4, 4744, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outslowd = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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(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)) != (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)) != (0)) __PYX_ERR(4, 4747, __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.STOCH", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outslowk); __Pyx_XDECREF((PyObject *)__pyx_v_outslowd); __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_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_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 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_fastk_period; int __pyx_v_fastd_period; int __pyx_v_fastd_matype; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[6] = {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("STOCHF (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_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_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_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_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_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_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_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; } const Py_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_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_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { __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_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_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(4, 4749, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; int __pyx_v_lookback; TA_RetCode __pyx_v_retCode; int __pyx_v_outbegidx; int __pyx_v_outnbelement; PyArrayObject *__pyx_v_outfastk = 0; PyArrayObject *__pyx_v_outfastd = 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("STOCHF", 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, 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(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(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)-1L))) __PYX_ERR(4, 4777, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4778, __pyx_L1_error) __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(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(4, 4782, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outfastd = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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(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)) != (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)) != (0)) __PYX_ERR(4, 4785, __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.STOCHF", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outfastk); __Pyx_XDECREF((PyObject *)__pyx_v_outfastd); __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_timeperiod; int __pyx_v_fastk_period; int __pyx_v_fastd_period; int __pyx_v_fastd_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("STOCHRSI (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_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_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_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_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_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_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; } const Py_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_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_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_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_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_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_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_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_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_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(4, 4787, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; int __pyx_v_lookback; TA_RetCode __pyx_v_retCode; int __pyx_v_outbegidx; int __pyx_v_outnbelement; PyArrayObject *__pyx_v_outfastk = 0; PyArrayObject *__pyx_v_outfastd = 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("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, 4813, __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, 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(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(4, 4819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outfastd = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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(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)) != (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)) != (0)) __PYX_ERR(4, 4822, __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.STOCHRSI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outfastk); __Pyx_XDECREF((PyObject *)__pyx_v_outfastd); __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real0 = 0; PyArrayObject *__pyx_v_real1 = 0; #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("SUB (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_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_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_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; } const Py_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_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(4, 4824, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("SUB", 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, 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(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)-1L))) __PYX_ERR(4, 4846, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx2(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real0)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 4847, __pyx_L1_error) __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(4, 4850, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.SUB", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __Pyx_XDECREF((PyObject *)__pyx_v_real0); __Pyx_XDECREF((PyObject *)__pyx_v_real1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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("SUM (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, 4855, __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, 4855, __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, 4855, __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, "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_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_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_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(4, 4855, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4876, __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, 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(4, 4881, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.SUM", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_timeperiod; double __pyx_v_vfactor; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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("T3 (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_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_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_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_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; } const Py_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_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_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_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_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(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(4, 4886, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4908, __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, 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(4, 4913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.T3", __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_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_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 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("TAN (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,0}; 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_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; } const Py_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_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(4, 4918, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4937, __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, 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(4, 4942, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.TAN", __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_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_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 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("TANH (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,0}; 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_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; } const Py_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_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(4, 4947, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4966, __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, 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(4, 4971, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.TANH", __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_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_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 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("TEMA (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, 4976, __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, 4976, __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, 4976, __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, "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_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_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_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(4, 4976, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 4997, __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, 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(4, 5002, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.TEMA", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { 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[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("TRANGE (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,0}; 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_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_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_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; } const Py_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_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]); __pyx_v_close = ((PyArrayObject *)values[2]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("TRANGE", 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, 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(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(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)-1L))) __PYX_ERR(4, 5029, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5030, __pyx_L1_error) __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(4, 5033, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.TRANGE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 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("TRIMA (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, 5038, __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, 5038, __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, 5038, __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, "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_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_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_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(4, 5038, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 5059, __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, 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(4, 5064, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.TRIMA", __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_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_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 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("TRIX (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, 5069, __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, 5069, __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, 5069, __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, "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_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_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_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(4, 5069, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 5090, __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, 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(4, 5095, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.TRIX", __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_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_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 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("TSF (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, 5100, __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, 5100, __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, 5100, __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, "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_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_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_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(4, 5100, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 5121, __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, 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(4, 5126, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.TSF", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { 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[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("TYPPRICE (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,0}; 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_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_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_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; } const Py_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_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]); __pyx_v_close = ((PyArrayObject *)values[2]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("TYPPRICE", 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, 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(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(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)-1L))) __PYX_ERR(4, 5153, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5154, __pyx_L1_error) __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(4, 5157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.TYPPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 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_timeperiod1; int __pyx_v_timeperiod2; int __pyx_v_timeperiod3; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[6] = {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("ULTOSC (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_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_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_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_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_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_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_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; } const Py_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_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_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { __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_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_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(4, 5162, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("ULTOSC", 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, 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(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(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)-1L))) __PYX_ERR(4, 5188, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5189, __pyx_L1_error) __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(4, 5192, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.ULTOSC", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_timeperiod; double __pyx_v_nbdev; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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("VAR (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_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_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_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_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; } const Py_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_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_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_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_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(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(4, 5197, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 5219, __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, 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(4, 5224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.VAR", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { 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[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("WCLPRICE (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,0}; 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_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_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_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; } const Py_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_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]); __pyx_v_close = ((PyArrayObject *)values[2]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("WCLPRICE", 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, 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(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(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)-1L))) __PYX_ERR(4, 5251, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5252, __pyx_L1_error) __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(4, 5255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.WCLPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 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("WILLR (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, 5260, __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, 5260, __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, 5260, __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, 5260, __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, 5260, __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, "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_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_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; } } __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, 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(4, 5260, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_intp __pyx_t_2; npy_int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("WILLR", 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, 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(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(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)-1L))) __PYX_ERR(4, 5284, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_t_3 = __pyx_f_5talib_7_ta_lib_check_begidx3(__pyx_v_length, ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_high)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_low)), ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close))); if (unlikely(__pyx_t_3 == ((npy_int)-1) && PyErr_Occurred())) __PYX_ERR(4, 5285, __pyx_L1_error) __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(4, 5288, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.WILLR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_outreal); __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_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_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 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("WMA (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, 5293, __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, 5293, __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, 5293, __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, "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_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_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_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(4, 5293, __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.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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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("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, 5314, __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, 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(4, 5319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_outreal = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; __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_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; __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.WMA", __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_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*/ 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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_s = 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("str2bytes (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_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_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; } const Py_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_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(2, 74, __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.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_340str2bytes(__pyx_self, __pyx_v_s); /* 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_RefNannyFinishContext(); return __pyx_r; } 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", 0); __Pyx_XDECREF(__pyx_r); __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; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("talib._ta_lib.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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*/ 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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_b = 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("bytes2str (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_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_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; } const Py_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_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(2, 77, __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.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_342bytes2str(__pyx_self, __pyx_v_b); /* 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_RefNannyFinishContext(); return __pyx_r; } 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; size_t __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("bytes2str", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __pyx_v_b; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { 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_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("talib._ta_lib.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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*/ 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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_s = 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("str2bytes (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_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_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; } const Py_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_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(2, 82, __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.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_344str2bytes(__pyx_self, __pyx_v_s); /* 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_RefNannyFinishContext(); return __pyx_r; } 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", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_s); __pyx_r = __pyx_v_s; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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*/ 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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_b = 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("bytes2str (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_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_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; } const Py_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_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(2, 85, __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.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_346bytes2str(__pyx_self, __pyx_v_b); /* 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_RefNannyFinishContext(); return __pyx_r; } 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", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_b); __pyx_r = __pyx_v_b; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_function_name = 0; PyObject *__pyx_v_func_object = 0; PyObject *__pyx_v_args = 0; PyObject *__pyx_v_kwargs = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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("__init__ (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); __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; __Pyx_GOTREF(__pyx_v_kwargs); __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 3, __pyx_nargs); if (unlikely(!__pyx_v_args)) { __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; __Pyx_RefNannyFinishContext(); return NULL; } __Pyx_GOTREF(__pyx_v_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_ArgRef_FASTCALL(__pyx_args, 2); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(2, 117, __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(2, 117, __pyx_L3_error) CYTHON_FALLTHROUGH; case 1: values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(2, 117, __pyx_L3_error) CYTHON_FALLTHROUGH; case 0: break; } 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_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]; __pyx_v_func_object = values[2]; } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (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; __Pyx_AddTraceback("talib._ta_lib.Function.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __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); __Pyx_RefNannyFinishContext(); return __pyx_r; } 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) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; 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__", 0); __pyx_t_2 = __pyx_v_function_name; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { 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); } if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name, __pyx_t_1) < (0)) __PYX_ERR(2, 119, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__namestr, __pyx_t_1) < (0)) __PYX_ERR(2, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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_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_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); } if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name, __pyx_t_1) < (0)) __PYX_ERR(2, 121, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = NULL; __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_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_3 = 1; #if CYTHON_UNPACK_METHODS 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_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); } if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__localdata, __pyx_t_1) < (0)) __PYX_ERR(2, 124, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_set_function_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_func_object, __pyx_v_func_object) < (0)) __PYX_ERR(2, 128, __pyx_L1_error) /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __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; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("__local (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_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_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; } const Py_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_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(2, 130, __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.Function.__local", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_2__local(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_2__local(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_v_local = NULL; PyObject *__pyx_v_i = NULL; PyObject *__pyx_v_info = NULL; PyObject *__pyx_v_input_name = NULL; PyObject *__pyx_v_param_name = NULL; PyObject *__pyx_v_output_name = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; size_t __pyx_t_6; 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("__local", 0); __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_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_mstate_global->__pyx_n_u_info, Py_None) < (0)) __PYX_ERR(2, 134, __pyx_L1_error) __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_arrays, __pyx_t_1) < (0)) __PYX_ERR(2, 135, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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_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_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); } if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names, __pyx_t_1) < (0)) __PYX_ERR(2, 138, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_5 = NULL; __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); 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((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_opt_inputs, __pyx_t_1) < (0)) __PYX_ERR(2, 139, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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_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_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); } if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs, __pyx_t_1) < (0)) __PYX_ERR(2, 140, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 141, __pyx_L1_error) __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_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_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_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_mstate_global->__pyx_n_u_info, __pyx_t_1) < (0)) __PYX_ERR(2, 144, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = NULL; __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 147, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_5 = __pyx_t_8; __Pyx_INCREF(__pyx_t_5); __pyx_t_6 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_num_inputs}; __pyx_t_7 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_pop, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 147, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); } __pyx_t_6 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_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, 147, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 147, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 147, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { { __pyx_t_1 = __pyx_t_9(__pyx_t_7); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 147, __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_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_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_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_1); __pyx_t_1 = 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_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_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_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 152, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (unlikely((PyObject_SetItem(__pyx_t_8, __pyx_v_input_name, __pyx_v_info) < 0))) __PYX_ERR(2, 152, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 153, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_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_8 = NULL; __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __pyx_t_4; __Pyx_INCREF(__pyx_t_5); __pyx_t_6 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_num_opt_inputs}; __pyx_t_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_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_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 (;;) { { __pyx_t_7 = __pyx_t_9(__pyx_t_1); if (unlikely(!__pyx_t_7)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 156, __pyx_L1_error) PyErr_Clear(); } break; } } __Pyx_GOTREF(__pyx_t_7); __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_7); __pyx_t_7 = 0; __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_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_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_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_7); __pyx_t_7 = 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_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_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_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_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_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_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_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_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; { PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_num_outputs}; __pyx_t_7 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_pop, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 164, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); } __pyx_t_6 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_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_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 (;;) { { __pyx_t_1 = __pyx_t_9(__pyx_t_7); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 164, __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_t_4 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_ta_getOutputParameterInfo); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = 1; #if CYTHON_UNPACK_METHODS if (unlikely(PyMethod_Check(__pyx_t_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_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_1); __pyx_t_1 = 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_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_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely((PyObject_SetItem(__pyx_t_5, __pyx_v_output_name, __pyx_t_1) < 0))) __PYX_ERR(2, 167, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __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_7); __pyx_t_7 = 0; __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); 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; } __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_local); __pyx_r = __pyx_v_local; 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_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("talib._ta_lib.Function.__local", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_local); __Pyx_XDECREF(__pyx_v_i); __Pyx_XDECREF(__pyx_v_info); __Pyx_XDECREF(__pyx_v_input_name); __Pyx_XDECREF(__pyx_v_param_name); __Pyx_XDECREF(__pyx_v_output_name); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("info (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_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_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; } const Py_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_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(2, 172, __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.Function.info", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_4info(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_4info(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; 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", 0); __Pyx_XDECREF(__pyx_r); __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_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_2 = __pyx_t_4; __Pyx_INCREF(__pyx_t_2); __pyx_t_5 = 0; { 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_r = __pyx_t_1; __pyx_t_1 = 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_AddTraceback("talib._ta_lib.Function.info", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("function_flags (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_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_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; } const Py_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_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(2, 179, __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.Function.function_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_6function_flags(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_6function_flags(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("function_flags", 0); __Pyx_XDECREF(__pyx_r); __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_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_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; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("talib._ta_lib.Function.function_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("output_flags (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_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_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; } const Py_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_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(2, 186, __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.Function.output_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_8output_flags(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_8output_flags(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; 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", 0); __Pyx_XDECREF(__pyx_r); __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_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_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_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_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 191, __pyx_L1_error) __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_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:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_10get_input_names, "Function.get_input_names(self)\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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("get_input_names (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_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_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; } const Py_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_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(2, 193, __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.Function.get_input_names", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_10get_input_names(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_10get_input_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_v_local = NULL; PyObject *__pyx_v_ret = NULL; PyObject *__pyx_v_input_name = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; 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", 0); __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_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_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_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_v_ret = __pyx_t_1; __pyx_t_1 = 0; __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_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; __pyx_t_6 = NULL; } else { __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_3))) { { 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; } __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_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 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5)); #else __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_3); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 200, __pyx_L1_error) PyErr_Clear(); } break; } } __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_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_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_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_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_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_ret); __pyx_r = __pyx_v_ret; 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_AddTraceback("talib._ta_lib.Function.get_input_names", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_local); __Pyx_XDECREF(__pyx_v_ret); __Pyx_XDECREF(__pyx_v_input_name); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_12set_input_names, "Function.set_input_names(self, input_names)\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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_input_names = 0; #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("set_input_names (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_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_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_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; } const Py_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_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(2, 204, __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.Function.set_input_names", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(__pyx_self, __pyx_v_self, __pyx_v_input_names); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_12set_input_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_names) { PyObject *__pyx_v_local = NULL; PyObject *__pyx_v_input_name = NULL; PyObject *__pyx_v_price_series = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; 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", 0); __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_v_input_names; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { 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); } 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_4 = 0; __pyx_t_5 = NULL; } else { __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_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_5)) { if (likely(PyList_CheckExact(__pyx_t_2))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 209, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_2, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_4; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 209, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __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); #endif ++__pyx_t_4; } if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 209, __pyx_L1_error) } else { __pyx_t_1 = __pyx_t_5(__pyx_t_2); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 209, __pyx_L1_error) PyErr_Clear(); } break; } } __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(2, 209, __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_INCREF(__pyx_t_6); __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_7); } else { __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); } #else __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(2, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __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(2, 209, __pyx_L1_error) __pyx_t_9 = NULL; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L6_unpacking_done; __pyx_L5_unpacking_failed:; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_9 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(2, 209, __pyx_L1_error) __pyx_L6_unpacking_done:; } __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_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(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_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_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_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(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_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 212, __pyx_L1_error) /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __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); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_local); __Pyx_XDECREF(__pyx_v_input_name); __Pyx_XDECREF(__pyx_v_price_series); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_14get_input_arrays, "Function.get_input_arrays(self)\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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("get_input_arrays (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_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_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; } const Py_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_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(2, 216, __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.Function.get_input_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_14get_input_arrays(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_v_local = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; size_t __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_input_arrays", 0); __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_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; if (__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __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_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(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; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { __Pyx_XDECREF(__pyx_r); __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_t_1 = __pyx_t_5; __Pyx_INCREF(__pyx_t_1); __pyx_t_6 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_clone, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; } /*else*/ { __Pyx_XDECREF(__pyx_r); __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_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); __pyx_t_6 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __pyx_r = __pyx_t_4; __pyx_t_4 = 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.Function.get_input_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_local); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_16set_input_arrays, "Function.set_input_arrays(self, input_arrays)\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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_input_arrays = 0; #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("set_input_arrays (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_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_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_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; } const Py_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_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(2, 227, __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.Function.set_input_arrays", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(__pyx_self, __pyx_v_self, __pyx_v_input_arrays); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_16set_input_arrays(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_arrays) { PyObject *__pyx_v_local = NULL; PyObject *__pyx_v_missing_keys = NULL; PyObject *__pyx_v_key = NULL; PyObject *__pyx_v_missing = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; size_t __pyx_t_4; Py_ssize_t __pyx_t_5; PyObject *(*__pyx_t_6)(PyObject *); int __pyx_t_7; int __pyx_t_8; 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", 0); __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_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(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(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_v_self; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; { 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); } 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; } else { __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_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_6)) { if (likely(PyList_CheckExact(__pyx_t_3))) { { 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, 255, __pyx_L1_error) #endif if (__pyx_t_5 >= __pyx_temp) break; } __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_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 255, __pyx_L1_error) #endif if (__pyx_t_5 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __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_5); #endif ++__pyx_t_5; } if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 255, __pyx_L1_error) } else { __pyx_t_1 = __pyx_t_6(__pyx_t_3); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 255, __pyx_L1_error) PyErr_Clear(); } break; } } __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_1); __pyx_t_1 = 0; __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_7 = (__pyx_t_1 != Py_None); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_7) { } else { __pyx_t_2 = __pyx_t_7; goto __pyx_L7_bool_binop_done; } __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_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_7; __pyx_L7_bool_binop_done:; if (__pyx_t_2) { __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(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(2, 258, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_missing, __pyx_t_1); __pyx_t_1 = 0; goto __pyx_L6; } /*else*/ { __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(2, 261, __pyx_L1_error) if (__pyx_t_2) { __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_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_mstate_global->__pyx_n_u_input_arrays, __pyx_v_input_arrays) < (0)) __PYX_ERR(2, 264, __pyx_L1_error) if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 265, __pyx_L1_error) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_True); __pyx_r = Py_True; goto __pyx_L0; } /*else*/ { __pyx_t_1 = NULL; __pyx_t_5 = __Pyx_PyList_GET_SIZE(__pyx_v_missing_keys); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(2, 269, __pyx_L1_error) __pyx_t_2 = (__pyx_t_5 > 1); if (__pyx_t_2) { __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_s); __pyx_t_9 = __pyx_mstate_global->__pyx_n_u_s; } else { __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_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) } } __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_False); __pyx_r = Py_False; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __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:; __Pyx_XDECREF(__pyx_v_local); __Pyx_XDECREF(__pyx_v_missing_keys); __Pyx_XDECREF(__pyx_v_key); __Pyx_XDECREF(__pyx_v_missing); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("get_parameters (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_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_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; } const Py_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_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(2, 276, __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.Function.get_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_18get_parameters(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_18get_parameters(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_v_local = NULL; PyObject *__pyx_v_ret = NULL; PyObject *__pyx_v_opt_input = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; 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_parameters", 0); __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_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_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_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_v_ret = __pyx_t_1; __pyx_t_1 = 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, 282, __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; } else { __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_3))) { { 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; } __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_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 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5)); #else __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_3); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 282, __pyx_L1_error) PyErr_Clear(); } break; } } __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_opt_input, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __pyx_v_self; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0; { 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); } 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_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_ret); __pyx_r = __pyx_v_ret; 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_AddTraceback("talib._ta_lib.Function.get_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_local); __Pyx_XDECREF(__pyx_v_ret); __Pyx_XDECREF(__pyx_v_opt_input); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_20set_parameters, "Function.set_parameters(self, parameters=None, **kwargs)\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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_parameters = 0; PyObject *__pyx_v_kwargs = 0; #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("set_parameters (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); __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; __Pyx_GOTREF(__pyx_v_kwargs); { 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_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_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; } 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_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_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(2, 286, __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_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; __Pyx_AddTraceback("talib._ta_lib.Function.set_parameters", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __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 */ for (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; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_20set_parameters(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_parameters, PyObject *__pyx_v_kwargs) { PyObject *__pyx_v_local = NULL; PyObject *__pyx_v_param = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; 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 *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_parameters", 0); __Pyx_INCREF(__pyx_v_parameters); __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(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(2, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = __pyx_t_3; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_L3_bool_binop_done:; __Pyx_DECREF_SET(__pyx_v_parameters, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __pyx_v_parameters; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; { 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_1); __pyx_t_1 = 0; __pyx_t_3 = __pyx_v_parameters; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; { 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); } 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; } else { __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_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_6)) { if (likely(PyList_CheckExact(__pyx_t_3))) { { 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, 293, __pyx_L1_error) #endif if (__pyx_t_5 >= __pyx_temp) break; } __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_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 293, __pyx_L1_error) #endif if (__pyx_t_5 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __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_5); #endif ++__pyx_t_5; } if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 293, __pyx_L1_error) } else { __pyx_t_1 = __pyx_t_6(__pyx_t_3); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 293, __pyx_L1_error) PyErr_Clear(); } break; } } __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(2, 293, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); __Pyx_INCREF(__pyx_t_7); __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_8); } else { __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); } #else __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(2, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __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(2, 293, __pyx_L1_error) __pyx_t_10 = NULL; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L8_unpacking_done; __pyx_L7_unpacking_failed:; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_10 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(2, 293, __pyx_L1_error) __pyx_L8_unpacking_done:; } __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_v_self; __Pyx_INCREF(__pyx_t_8); __pyx_t_4 = 0; { 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_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_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(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_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; } } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 296, __pyx_L1_error) __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_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_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; /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __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); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_local); __Pyx_XDECREF(__pyx_v_param); __Pyx_XDECREF(__pyx_v_value); __Pyx_XDECREF(__pyx_v_parameters); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_22set_function_args, "Function.set_function_args(self, *args, **kwargs)\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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_args = 0; PyObject *__pyx_v_kwargs = 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("set_function_args (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); __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; __Pyx_GOTREF(__pyx_v_kwargs); __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs); if (unlikely(!__pyx_v_args)) { __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; __Pyx_RefNannyFinishContext(); return NULL; } __Pyx_GOTREF(__pyx_v_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_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; } 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_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(2, 301, __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_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; __Pyx_AddTraceback("talib._ta_lib.Function.set_function_args", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __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); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_22set_function_args(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { PyObject *__pyx_v_local = NULL; int __pyx_v_update_info; PyObject *__pyx_v_key = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_v_skip_first = NULL; PyObject *__pyx_v_i = NULL; PyObject *__pyx_v_param_name = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; int __pyx_t_7; PyObject *__pyx_t_8 = 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", 0); __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; __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(2, 308, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = __pyx_t_5; __pyx_t_5 = 0; 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(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_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(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(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_v_self; __Pyx_INCREF(__pyx_t_8); __pyx_t_9 = 0; { 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_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(2, 312, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __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_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_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; } goto __pyx_L5; } __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(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(2, 315, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __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_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(2, 316, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __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_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_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; } __pyx_L5:; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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_mstate_global->__pyx_int_0); __pyx_v_skip_first = __pyx_mstate_global->__pyx_int_0; __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_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_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_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(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_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_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_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_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); __pyx_t_3 = 0; __pyx_t_11 = NULL; } else { __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_11)) { if (likely(PyList_CheckExact(__pyx_t_5))) { { 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; } __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_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 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_3)); #else __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_11(__pyx_t_5); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 323, __pyx_L1_error) PyErr_Clear(); } break; } } __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_param_name, __pyx_t_1); __pyx_t_1 = 0; __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_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(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(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(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(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(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_v_self; __Pyx_INCREF(__pyx_t_1); __pyx_t_9 = 0; { 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_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_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(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_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; } } } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 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(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_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); 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_mstate_global->__pyx_n_u_outputs_valid, Py_False) < (0)) __PYX_ERR(2, 334, __pyx_L1_error) } /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_8); __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:; __Pyx_XDECREF(__pyx_v_local); __Pyx_XDECREF(__pyx_v_key); __Pyx_XDECREF(__pyx_v_value); __Pyx_XDECREF(__pyx_v_skip_first); __Pyx_XDECREF(__pyx_v_i); __Pyx_XDECREF(__pyx_v_param_name); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("lookback (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_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_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; } const Py_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_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(2, 336, __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.Function.lookback", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_24lookback(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_24lookback(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_v_local = NULL; TA_ParamHolder *__pyx_v_holder; PyObject *__pyx_v_i = NULL; PyObject *__pyx_v_opt_input = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_v_type_ = NULL; int __pyx_v_lookback; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; char *__pyx_t_2; TA_ParamHolder *__pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; PyObject *(*__pyx_t_7)(PyObject *); PyObject *__pyx_t_8 = NULL; size_t __pyx_t_9; int __pyx_t_10; int __pyx_t_11; int __pyx_t_12; double __pyx_t_13; int __pyx_t_14; int __pyx_t_15; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("lookback", 0); __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_mstate_global->__pyx_n_u_Function__name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_AsWritableString(__pyx_t_1); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(2, 344, __pyx_L1_error) __pyx_t_3 = __pyx_f_5talib_7_ta_lib___ta_paramHolderAlloc(__pyx_t_2); if (unlikely(__pyx_t_3 == ((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_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(2, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __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 (;;) { if (likely(!__pyx_t_7)) { if (likely(PyList_CheckExact(__pyx_t_5))) { { 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, 345, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } __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_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 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_6)); #else __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 (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 345, __pyx_L1_error) PyErr_Clear(); } break; } } __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_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_v_self; __Pyx_INCREF(__pyx_t_8); __pyx_t_9 = 0; { 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_XDECREF_SET(__pyx_v_value, __pyx_t_4); __pyx_t_4 = 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, 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(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_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_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(2, 348, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __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_11) { } else { __pyx_t_10 = __pyx_t_11; goto __pyx_L6_bool_binop_done; } __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(2, 348, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __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_10 = __pyx_t_11; __pyx_L6_bool_binop_done:; if (__pyx_t_10) { __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_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(2, 350, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __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_11) { } else { __pyx_t_10 = __pyx_t_11; goto __pyx_L8_bool_binop_done; } __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(2, 350, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __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_10 = __pyx_t_11; __pyx_L8_bool_binop_done:; if (__pyx_t_10) { __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:; } __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(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(2, 354, __pyx_L1_error) __Pyx_XDECREF(__pyx_r); __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; 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_8); __Pyx_AddTraceback("talib._ta_lib.Function.lookback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_local); __Pyx_XDECREF(__pyx_v_i); __Pyx_XDECREF(__pyx_v_opt_input); __Pyx_XDECREF(__pyx_v_value); __Pyx_XDECREF(__pyx_v_type_); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("output_names (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_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_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; } const Py_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_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(2, 357, __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.Function.output_names", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_26output_names(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_26output_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_v_ret = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; 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", 0); __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_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_2 = __pyx_t_4; __Pyx_INCREF(__pyx_t_2); __pyx_t_5 = 0; { 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_v_ret = __pyx_t_1; __pyx_t_1 = 0; __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(2, 364, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_ret, __pyx_t_1); __pyx_t_1 = 0; } __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_ret); __pyx_r = __pyx_v_ret; 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_AddTraceback("talib._ta_lib.Function.output_names", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_ret); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("outputs (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_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_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; } const Py_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_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(2, 367, __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.Function.outputs", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_28outputs(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_28outputs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_v_local = NULL; PyObject *__pyx_v_ret = NULL; PyObject *__pyx_v_index = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; 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", 0); __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_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(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_v_self; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; { 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_1); __pyx_t_1 = 0; } __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_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_values, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 377, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_ret = __pyx_t_1; __pyx_t_1 = 0; __pyx_t_3 = PyList_Check(__pyx_v_ret); __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(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_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; if (__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L6_bool_binop_done; } __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_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_6); __pyx_t_6 = 0; __pyx_t_2 = __pyx_t_3; __pyx_L6_bool_binop_done:; if (__pyx_t_2) { __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_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(2, 383, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 == 1); if (__pyx_t_2) { __Pyx_XDECREF(__pyx_r); __pyx_t_6 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 384, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 384, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_5 = 1; #if CYTHON_UNPACK_METHODS 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_t_4 = NULL; __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_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_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_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_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_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(2, 391, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 == 1); if (__pyx_t_2) { __Pyx_XDECREF(__pyx_r); __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_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_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_9; __pyx_t_9 = 0; goto __pyx_L0; } /*else*/ { __Pyx_XDECREF(__pyx_r); __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_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_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_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; } } /*else*/ { __Pyx_XDECREF(__pyx_r); __pyx_t_7 = PyObject_Length(__pyx_v_ret); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 397, __pyx_L1_error) __pyx_t_2 = (__pyx_t_7 == 1); if (__pyx_t_2) { __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_ret, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 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_9 = __pyx_v_ret; } __pyx_r = __pyx_t_9; __pyx_t_9 = 0; goto __pyx_L0; } /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __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:; __Pyx_XDECREF(__pyx_v_local); __Pyx_XDECREF(__pyx_v_ret); __Pyx_XDECREF(__pyx_v_index); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_input_arrays = 0; #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("run (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_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_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_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; } const Py_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_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_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(2, 399, __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.Function.run", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_30run(__pyx_self, __pyx_v_self, __pyx_v_input_arrays); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_30run(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_arrays) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations 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("run", 0); __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_v_self; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; { 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_2); __pyx_t_2 = 0; } __pyx_t_3 = __pyx_v_self; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; { 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_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_r); __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; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("talib._ta_lib.Function.run", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_args = 0; PyObject *__pyx_v_kwargs = 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("__call__ (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); __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; __Pyx_GOTREF(__pyx_v_kwargs); __pyx_v_args = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs); if (unlikely(!__pyx_v_args)) { __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; __Pyx_RefNannyFinishContext(); return NULL; } __Pyx_GOTREF(__pyx_v_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_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; } 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_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(2, 411, __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_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; __Pyx_AddTraceback("talib._ta_lib.Function.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __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); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_32__call__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) { PyObject *__pyx_v_local = NULL; PyObject *__pyx_v_opt_input_values = NULL; PyObject *__pyx_v_price_series_name_values = NULL; PyObject *__pyx_v_input_arrays = NULL; PyObject *__pyx_v_input_price_series_names = NULL; PyObject *__pyx_v_i = NULL; PyObject *__pyx_v_arg = NULL; PyObject *__pyx_v_msg = NULL; PyObject *__pyx_v_no_existing_input_arrays = NULL; PyObject *__pyx_v_param_name = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_v_input_name = NULL; PyObject *__pyx_v_n = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; size_t __pyx_t_5; Py_ssize_t __pyx_t_6; PyObject *(*__pyx_t_7)(PyObject *); int __pyx_t_8; int __pyx_t_9; int __pyx_t_10; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = 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[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_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(2, 420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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_t_3 = __pyx_t_4; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_keys, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 421, __pyx_L1_error) __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(2, 421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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 (;;) { if (likely(!__pyx_t_7)) { if (likely(PyList_CheckExact(__pyx_t_4))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 421, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } __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_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 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_6)); #else __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 (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 421, __pyx_L1_error) PyErr_Clear(); } break; } } __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_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(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_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(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) != (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) != (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(2, 420, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __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(2, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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(2, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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 (;;) { if (likely(!__pyx_t_7)) { if (likely(PyList_CheckExact(__pyx_t_3))) { { 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, 423, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } __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_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 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_6)); #else __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 (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 423, __pyx_L1_error) PyErr_Clear(); } break; } } __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_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(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_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(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) != (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) != (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(2, 422, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __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(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(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_v_self; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0; { 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_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(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_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); __pyx_t_8 = __pyx_t_10; __pyx_L10_bool_binop_done:; if (__pyx_t_8) { __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(2, 430, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 430, __pyx_L1_error) #endif if (__pyx_t_6 >= __pyx_temp) break; } __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_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 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_6)); #else __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 (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 430, __pyx_L1_error) PyErr_Clear(); } break; } } __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_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_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(2, 431, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_10 = (!__pyx_t_8); if (__pyx_t_10) { goto __pyx_L13_break; } { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); __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(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(2, 435, __pyx_L15_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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; goto __pyx_L22_try_end; __pyx_L15_error:; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_IndexError)))); if (__pyx_t_14) { __Pyx_AddTraceback("talib._ta_lib.Function.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_4, &__pyx_t_15) < 0) __PYX_ERR(2, 436, __pyx_L17_except_error) __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_15); __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 = 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_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_20); __pyx_t_20 = 0; __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; __pyx_L17_except_error:; __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); goto __pyx_L1_error; __pyx_L22_try_end:; } } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L25_for_end; __pyx_L13_break:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L25_for_end; __pyx_L25_for_end:; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __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; if (__pyx_t_8) { } else { __pyx_t_10 = __pyx_t_8; goto __pyx_L27_bool_binop_done; } __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_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(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; __pyx_L27_bool_binop_done:; if (__pyx_t_10) { __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_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; __pyx_t_3 = 0; goto __pyx_L26; } __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; if (__pyx_t_8) { } else { __pyx_t_10 = __pyx_t_8; goto __pyx_L29_bool_binop_done; } __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_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(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; __pyx_L29_bool_binop_done:; if (__pyx_t_10) { __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; { PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_is_empty, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_v_no_existing_input_arrays = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L26; } /*else*/ { __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(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(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(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_15 = __pyx_v_self; __Pyx_INCREF(__pyx_t_15); __pyx_t_5 = 0; { 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_1); __pyx_t_1 = 0; __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; goto __pyx_L31; } __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(2, 454, __pyx_L1_error) if (__pyx_t_8) { } else { __pyx_t_10 = __pyx_t_8; goto __pyx_L32_bool_binop_done; } __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_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 455, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 455, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __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_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_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 = 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_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_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 = 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_ERR(2, 459, __pyx_L1_error) } __pyx_L31:; __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_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_3); __pyx_t_3 = 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_15 = __pyx_v_self; __Pyx_INCREF(__pyx_t_15); __pyx_t_5 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_15, NULL}; __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_Function__call_function, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __pyx_v_opt_input_values; __Pyx_INCREF(__pyx_t_4); __pyx_t_16 = 0; for (;;) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 465, __pyx_L1_error) #endif if (__pyx_t_16 >= __pyx_temp) break; } __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(2, 465, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); __Pyx_INCREF(__pyx_t_1); __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_3); } else { __pyx_t_1 = __Pyx_PyList_GetItemRefFast(sequence, 0, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 465, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyList_GetItemRefFast(sequence, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 465, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_3); } #else __pyx_t_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_15); __pyx_t_15 = 0; } else { Py_ssize_t index = -1; __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_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); 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_21 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(2, 465, __pyx_L1_error) __pyx_L39_unpacking_done:; } __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_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_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_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_16 = 0; for (;;) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 470, __pyx_L1_error) #endif if (__pyx_t_16 >= __pyx_temp) break; } __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(2, 470, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_15 = PyTuple_GET_ITEM(sequence, 0); __Pyx_INCREF(__pyx_t_15); __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); __Pyx_INCREF(__pyx_t_1); } else { __pyx_t_15 = __Pyx_PyList_GetItemRefFast(sequence, 0, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 470, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_15); __pyx_t_1 = __Pyx_PyList_GetItemRefFast(sequence, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 470, __pyx_L1_error) __Pyx_XGOTREF(__pyx_t_1); } #else __pyx_t_15 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __pyx_t_1 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { Py_ssize_t index = -1; __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_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_21 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(2, 470, __pyx_L1_error) __pyx_L44_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_input_name, __pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_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_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_info); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_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_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; 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_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:; __Pyx_XDECREF(__pyx_v_args); __Pyx_XDECREF(__pyx_v_local); __Pyx_XDECREF(__pyx_v_opt_input_values); __Pyx_XDECREF(__pyx_v_price_series_name_values); __Pyx_XDECREF(__pyx_v_input_arrays); __Pyx_XDECREF(__pyx_v_input_price_series_names); __Pyx_XDECREF(__pyx_v_i); __Pyx_XDECREF(__pyx_v_arg); __Pyx_XDECREF(__pyx_v_msg); __Pyx_XDECREF(__pyx_v_no_existing_input_arrays); __Pyx_XDECREF(__pyx_v_param_name); __Pyx_XDECREF(__pyx_v_value); __Pyx_XDECREF(__pyx_v_input_name); __Pyx_XDECREF(__pyx_v_n); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("__input_price_series_names (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_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_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; } const Py_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_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(2, 477, __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.Function.__input_price_series_names", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_34__input_price_series_names(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_v_local = NULL; PyObject *__pyx_v_input_price_series_names = NULL; PyObject *__pyx_v_input_name = NULL; PyObject *__pyx_v_price_series = NULL; PyObject *__pyx_v_name = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; Py_ssize_t __pyx_t_3; PyObject *(*__pyx_t_4)(PyObject *); PyObject *__pyx_t_5 = NULL; int __pyx_t_6; Py_ssize_t __pyx_t_7; PyObject *(*__pyx_t_8)(PyObject *); int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__input_price_series_names", 0); __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(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_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(2, 480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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 (;;) { if (likely(!__pyx_t_4)) { if (likely(PyList_CheckExact(__pyx_t_2))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 480, __pyx_L1_error) #endif if (__pyx_t_3 >= __pyx_temp) break; } __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_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 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3)); #else __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 (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 480, __pyx_L1_error) PyErr_Clear(); } break; } } __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_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(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_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); __pyx_t_1 = 0; __pyx_t_6 = PyList_Check(__pyx_v_price_series); if (__pyx_t_6) { if (likely(PyList_CheckExact(__pyx_v_price_series)) || PyTuple_CheckExact(__pyx_v_price_series)) { __pyx_t_1 = __pyx_v_price_series; __Pyx_INCREF(__pyx_t_1); __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(2, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 483, __pyx_L1_error) #endif if (__pyx_t_7 >= __pyx_temp) break; } __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_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 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7)); #else __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 (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 483, __pyx_L1_error) PyErr_Clear(); } break; } } __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(2, 484, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L5; } /*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(2, 486, __pyx_L1_error) } __pyx_L5:; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_input_price_series_names); __pyx_r = __pyx_v_input_price_series_names; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("talib._ta_lib.Function.__input_price_series_names", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_local); __Pyx_XDECREF(__pyx_v_input_price_series_names); __Pyx_XDECREF(__pyx_v_input_name); __Pyx_XDECREF(__pyx_v_price_series); __Pyx_XDECREF(__pyx_v_name); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("__call_function (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_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_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; } const Py_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_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(2, 489, __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.Function.__call_function", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_36__call_function(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_36__call_function(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_v_local = NULL; PyObject *__pyx_v_input_price_series_names = NULL; PyObject *__pyx_v_args = NULL; PyObject *__pyx_v_price_series = NULL; PyObject *__pyx_v_series = NULL; PyObject *__pyx_v_opt_input = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_v_results = NULL; PyObject *__pyx_v_keys = NULL; PyObject *__pyx_v_i = NULL; PyObject *__pyx_v_output = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; 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; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__call_function", 0); __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_v_self; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { 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_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(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_4 = 0; __pyx_t_5 = NULL; } else { __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_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_5)) { if (likely(PyList_CheckExact(__pyx_t_1))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 495, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } __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_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 495, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __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_4); #endif ++__pyx_t_4; } if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 495, __pyx_L1_error) } else { __pyx_t_2 = __pyx_t_5(__pyx_t_1); if (unlikely(!__pyx_t_2)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { 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_XDECREF_SET(__pyx_v_price_series, __pyx_t_2); __pyx_t_2 = 0; __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_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_6); __pyx_t_6 = 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_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_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_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_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 499, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); } __Pyx_DECREF_SET(__pyx_v_series, __pyx_t_6); __pyx_t_6 = 0; goto __pyx_L5; } __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_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_10 = __pyx_v_series; __Pyx_INCREF(__pyx_t_10); __pyx_t_3 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL}; __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_to_numpy, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } __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_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_3, (2-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 502, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); } __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(2, 503, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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, 504, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_6 = __pyx_t_1; __Pyx_INCREF(__pyx_t_6); __pyx_t_4 = 0; __pyx_t_5 = NULL; } else { __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_5)) { if (likely(PyList_CheckExact(__pyx_t_6))) { { 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_4 >= __pyx_temp) break; } __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_6); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 504, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_4)); #else __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_5(__pyx_t_6); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 504, __pyx_L1_error) PyErr_Clear(); } break; } } __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_opt_input, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __pyx_v_self; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { 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_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(2, 506, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __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_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_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_mstate_global->__pyx_ptype_5numpy_ndarray); if (__pyx_t_7) { __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_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_keys, __pyx_callargs+__pyx_t_3, (1-__pyx_t_3) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 511, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } __pyx_v_keys = __pyx_t_2; __pyx_t_2 = 0; __pyx_t_7 = PyList_Check(__pyx_v_keys); __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(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_mstate_global->__pyx_n_u_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_keys, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 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_6); __pyx_t_6 = 0; goto __pyx_L14; } /*else*/ { __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_4 = 0; __pyx_t_5 = NULL; } else { __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_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_5)) { if (likely(PyList_CheckExact(__pyx_t_1))) { { Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 516, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } __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_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 516, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __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_4); #endif ++__pyx_t_4; } if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 516, __pyx_L1_error) } else { __pyx_t_2 = __pyx_t_5(__pyx_t_1); if (unlikely(!__pyx_t_2)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { 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_XDECREF_SET(__pyx_v_output, __pyx_t_2); __pyx_t_2 = 0; __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_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(2, 517, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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(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_6); __pyx_t_6 = 0; } __pyx_L14:; if (__Pyx_PyObject_SetAttrStr(__pyx_v_local, __pyx_mstate_global->__pyx_n_u_outputs_valid, Py_True) < (0)) __PYX_ERR(2, 518, __pyx_L1_error) /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __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); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_local); __Pyx_XDECREF(__pyx_v_input_price_series_names); __Pyx_XDECREF(__pyx_v_args); __Pyx_XDECREF(__pyx_v_price_series); __Pyx_XDECREF(__pyx_v_series); __Pyx_XDECREF(__pyx_v_opt_input); __Pyx_XDECREF(__pyx_v_value); __Pyx_XDECREF(__pyx_v_results); __Pyx_XDECREF(__pyx_v_keys); __Pyx_XDECREF(__pyx_v_i); __Pyx_XDECREF(__pyx_v_output); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_input_name = 0; PyObject *__pyx_v_value = 0; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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("__check_opt_input_value (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_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_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_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_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; } const Py_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_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]; __pyx_v_value = values[2]; } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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(); return NULL; __pyx_L4_argument_unpacking_done:; __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 */ for (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_8Function_38__check_opt_input_value(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_name, PyObject *__pyx_v_value) { PyObject *__pyx_v_type_ = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; 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", 0); __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_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(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_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; __pyx_t_2 = 0; __Pyx_INCREF(__pyx_v_type_); __pyx_t_2 = __pyx_v_type_; __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(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(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_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(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(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:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = __pyx_t_3; if (__pyx_t_5) { __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_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(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(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_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(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(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:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = __pyx_t_5; if (__pyx_t_3) { __Pyx_INCREF((PyObject *)(&PyFloat_Type)); __Pyx_DECREF_SET(__pyx_v_type_, ((PyObject *)(&PyFloat_Type))); } __pyx_L3:; __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); __Pyx_INCREF(Py_True); __pyx_r = Py_True; goto __pyx_L0; } __pyx_t_3 = (__pyx_v_value != Py_None); if (unlikely(__pyx_t_3)) { __pyx_t_1 = NULL; __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_input_name), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 532, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_type_, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 532, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_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_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) } __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_False); __pyx_r = Py_False; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __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:; __Pyx_XDECREF(__pyx_v_type_); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_8Function_40__get_opt_input_value, "Function.__get_opt_input_value(self, input_name)\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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_input_name = 0; #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("__get_opt_input_value (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_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_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_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; } const Py_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_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(2, 535, __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.Function.__get_opt_input_value", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __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 */ for (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_8Function_40__get_opt_input_value(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_input_name) { PyObject *__pyx_v_local = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get_opt_input_value", 0); __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_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(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_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; __pyx_t_1 = 0; __pyx_t_3 = (__pyx_v_value == Py_None); if (__pyx_t_3) { __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(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_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); __pyx_t_1 = 0; } __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_value); __pyx_r = __pyx_v_value; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("talib._ta_lib.Function.__get_opt_input_value", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_local); __Pyx_XDECREF(__pyx_v_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("__repr__ (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_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_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; } const Py_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_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(2, 545, __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.Function.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_42__repr__(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_42__repr__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); __Pyx_XDECREF(__pyx_r); __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_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; __pyx_t_2 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("talib._ta_lib.Function.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("__unicode__ (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_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_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; } const Py_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_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(2, 548, __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.Function.__unicode__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_44__unicode__(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_44__unicode__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { 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("__unicode__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __pyx_v_self; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; { 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_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; __pyx_t_2 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("talib._ta_lib.Function.__unicode__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ); /*proto*/ 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 #else PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_self = 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("__str__ (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_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_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; } const Py_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_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(2, 551, __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.Function.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_5talib_7_ta_lib_8Function_46__str__(__pyx_self, __pyx_v_self); /* 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_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_5talib_7_ta_lib_8Function_46__str__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; 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("__str__", 0); __Pyx_XDECREF(__pyx_r); __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 = __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_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_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(2, 552, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 552, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 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_AddTraceback("talib._ta_lib.Function.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_5talib_7_ta_lib_349_ta_getGroupTable(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ PyDoc_STRVAR(__pyx_doc_5talib_7_ta_lib_348_ta_getGroupTable, "_ta_getGroupTable()\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_348_ta_getGroupTable(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; unsigned int __pyx_t_2; unsigned int __pyx_t_3; unsigned int __pyx_t_4; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_ta_getGroupTable", 0); __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(2, 571, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_groups = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __pyx_v_table->size; __pyx_t_3 = __pyx_t_2; 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(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(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_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; __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_groups); __pyx_r = __pyx_v_groups; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib._ta_getGroupTable", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_groups); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { char *__pyx_v_group; #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("_ta_getFuncTable (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_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_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; } const Py_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_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(2, 577, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_350_ta_getFuncTable(__pyx_self, __pyx_v_group); /* 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_RefNannyFinishContext(); return __pyx_r; } 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; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; unsigned int __pyx_t_2; unsigned int __pyx_t_3; unsigned int __pyx_t_4; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_ta_getFuncTable", 0); __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(2, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_functions = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __pyx_v_table->size; __pyx_t_3 = __pyx_t_2; 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(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(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_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; __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_functions); __pyx_r = __pyx_v_functions; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib._ta_getFuncTable", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_functions); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { int __pyx_v_flag; PyObject *__pyx_v_flags_lookup_dict = 0; #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("__get_flags (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_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_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_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; } const Py_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_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_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(2, 589, __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.__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(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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; PyObject *__pyx_v_ret = NULL; PyObject *__pyx_v_i = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; size_t __pyx_t_8; 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", 0); if (unlikely(__pyx_v_flags_lookup_dict == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); __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(2, 595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_value_range = __pyx_t_1; __pyx_t_1 = 0; __pyx_t_2 = PyList_Check(__pyx_v_value_range); __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(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_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_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_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_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_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 = ((PyObject*)__pyx_t_6); __pyx_t_6 = 0; __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_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_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_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_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 599, __pyx_L1_error) __Pyx_GOTREF(__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); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L5_bool_binop_done; } __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_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_3 = __pyx_t_2; __pyx_L5_bool_binop_done:; if (__pyx_t_3) { __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __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_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 (;;) { { __pyx_t_5 = __pyx_t_9(__pyx_t_4); if (unlikely(!__pyx_t_5)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 609, __pyx_L1_error) PyErr_Clear(); } break; } } __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_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_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(2, 611, __pyx_L1_error) } __pyx_t_1 = PyNumber_Power(__pyx_mstate_global->__pyx_int_2, __pyx_v_i, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 611, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_flags_lookup_dict, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 611, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_ret, __pyx_t_6); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(2, 611, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_ret); __pyx_r = __pyx_v_ret; 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_XDECREF(__pyx_t_7); __Pyx_AddTraceback("talib._ta_lib.__get_flags", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_value_range); __Pyx_XDECREF(__pyx_v_min_int); __Pyx_XDECREF(__pyx_v_max_int); __Pyx_XDECREF(__pyx_v_ret); __Pyx_XDECREF(__pyx_v_i); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { char *__pyx_v_function_name; #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("_ta_getFuncInfo (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_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_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; } const Py_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_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(2, 648, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_354_ta_getFuncInfo(__pyx_self, __pyx_v_function_name); /* 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_RefNannyFinishContext(); return __pyx_r; } 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; __Pyx_RefNannyDeclarations TA_FuncHandle const *__pyx_t_1; 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; 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", 0); __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(2, 654, __pyx_L1_error) __pyx_v_retCode = TA_GetFuncInfo(__pyx_t_1, (&__pyx_v_info)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetFuncInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 655, __pyx_L1_error) __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(2, 658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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 = __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_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_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(2, 658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __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_7 = 1; #if CYTHON_UNPACK_METHODS 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_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_mstate_global->__pyx_n_u_group, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = NULL; __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(2, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = 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_7 = 0; } #endif { PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); } if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_display_name, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __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_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_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_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_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; __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); } if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_function_flags, __pyx_t_3) < (0)) __PYX_ERR(2, 658, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = NULL; __pyx_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; __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_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; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* function exit code */ __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_AddTraceback("talib._ta_lib._ta_getFuncInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { char *__pyx_v_function_name; int __pyx_v_idx; #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("_ta_getInputParameterInfo (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_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_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_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; } const Py_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_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(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(2, 667, __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._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_356_ta_getInputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx); /* 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_RefNannyFinishContext(); return __pyx_r; } 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; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations TA_FuncHandle const *__pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; size_t __pyx_t_6; Py_ssize_t __pyx_t_7; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_ta_getInputParameterInfo", 0); __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(2, 673, __pyx_L1_error) __pyx_v_retCode = TA_GetInputParameterInfo(__pyx_t_1, __pyx_v_idx, (&__pyx_v_info)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetInputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 674, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 676, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 676, __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_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_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(2, 676, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } __pyx_v_name = __pyx_t_2; __pyx_t_2 = 0; __pyx_t_7 = __Pyx_PyUnicode_GET_LENGTH(__pyx_mstate_global->__pyx_n_u_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; { 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_SET(__pyx_v_name, __pyx_t_2); __pyx_t_2 = 0; __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_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_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_5); __pyx_t_5 = 0; goto __pyx_L3; } __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_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_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_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_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_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_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_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; __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_5, __pyx_mstate_global->__pyx_n_u_price_series, __pyx_t_2) < (0)) __PYX_ERR(2, 684, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* function exit code */ __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_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("talib._ta_lib._ta_getInputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { char *__pyx_v_function_name; int __pyx_v_idx; #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("_ta_getOptInputParameterInfo (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_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_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_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; } const Py_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_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(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(2, 688, __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._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_358_ta_getOptInputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx); /* 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_RefNannyFinishContext(); return __pyx_r; } 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; PyObject *__pyx_v_default_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations TA_FuncHandle const *__pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; size_t __pyx_t_6; Py_ssize_t __pyx_t_7; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_ta_getOptInputParameterInfo", 0); __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(2, 694, __pyx_L1_error) __pyx_v_retCode = TA_GetOptInputParameterInfo(__pyx_t_1, __pyx_v_idx, (&__pyx_v_info)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetOptInputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 695, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 697, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 697, __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_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_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(2, 697, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } __pyx_v_name = __pyx_t_2; __pyx_t_2 = 0; __pyx_t_7 = __Pyx_PyUnicode_GET_LENGTH(__pyx_mstate_global->__pyx_n_u_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; { 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_SET(__pyx_v_name, __pyx_t_2); __pyx_t_2 = 0; __pyx_t_8 = (__pyx_v_info->type > 1); if (__pyx_t_8) { __pyx_t_5 = PyLong_FromDouble(__pyx_v_info->defaultValue); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 699, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_2 = __pyx_t_5; __pyx_t_5 = 0; } else { __pyx_t_5 = PyFloat_FromDouble(__pyx_v_info->defaultValue); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 699, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_2 = __pyx_t_5; __pyx_t_5 = 0; } __pyx_v_default_value = __pyx_t_2; __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 702, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name, __pyx_v_name) < (0)) __PYX_ERR(2, 702, __pyx_L1_error) __pyx_t_4 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 703, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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_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_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_mstate_global->__pyx_n_u_display_name, __pyx_t_5) < (0)) __PYX_ERR(2, 702, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyLong_From_TA_OptInputParameterType(__pyx_v_info->type); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 704, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_type_2, __pyx_t_5) < (0)) __PYX_ERR(2, 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_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_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_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_mstate_global->__pyx_n_u_default_value, __pyx_v_default_value) < (0)) __PYX_ERR(2, 702, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_value, Py_None) < (0)) __PYX_ERR(2, 702, __pyx_L1_error) __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* function exit code */ __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_9); __Pyx_AddTraceback("talib._ta_lib._ta_getOptInputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_default_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { char *__pyx_v_function_name; int __pyx_v_idx; #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("_ta_getOutputParameterInfo (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_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_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_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; } const Py_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_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(2, 710, __pyx_L3_error) __pyx_v_idx = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 710, __pyx_L3_error) } goto __pyx_L6_skip; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_ta_getOutputParameterInfo", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 710, __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._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_360_ta_getOutputParameterInfo(__pyx_self, __pyx_v_function_name, __pyx_v_idx); /* 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_RefNannyFinishContext(); return __pyx_r; } 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; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations TA_FuncHandle const *__pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; size_t __pyx_t_6; Py_ssize_t __pyx_t_7; int __pyx_t_8; int __pyx_t_9; int __pyx_t_10; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_ta_getOutputParameterInfo", 0); __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(2, 716, __pyx_L1_error) __pyx_v_retCode = TA_GetOutputParameterInfo(__pyx_t_1, __pyx_v_idx, (&__pyx_v_info)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetOutputParameterInfo, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 717, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_bytes2str); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 719, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_info->paramName); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 719, __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_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_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(2, 719, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } __pyx_v_name = __pyx_t_2; __pyx_t_2 = 0; __pyx_t_7 = __Pyx_PyUnicode_GET_LENGTH(__pyx_mstate_global->__pyx_n_u_out); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 720, __pyx_L1_error) __pyx_t_5 = __Pyx_PyObject_GetSlice(__pyx_v_name, __pyx_t_7, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 720, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __pyx_t_5; __Pyx_INCREF(__pyx_t_4); __pyx_t_6 = 0; { PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; __pyx_t_2 = __Pyx_PyObject_FastCallMethod((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_SET(__pyx_v_name, __pyx_t_2); __pyx_t_2 = 0; __pyx_t_9 = (__Pyx_PySequence_ContainsTF(__pyx_mstate_global->__pyx_n_u_real, __pyx_v_name, Py_EQ)); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(2, 722, __pyx_L1_error) if (__pyx_t_9) { } else { __pyx_t_8 = __pyx_t_9; goto __pyx_L4_bool_binop_done; } __Pyx_INCREF(__pyx_v_name); __pyx_t_2 = __pyx_v_name; __pyx_t_10 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_real, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(2, 722, __pyx_L1_error) if (__pyx_t_10) { } else { __pyx_t_9 = __pyx_t_10; goto __pyx_L6_bool_binop_done; } __pyx_t_10 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_real0, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(2, 722, __pyx_L1_error) if (__pyx_t_10) { } else { __pyx_t_9 = __pyx_t_10; goto __pyx_L6_bool_binop_done; } __pyx_t_10 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_real1, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(2, 722, __pyx_L1_error) __pyx_t_9 = __pyx_t_10; __pyx_L6_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_10 = __pyx_t_9; __pyx_t_8 = __pyx_t_10; __pyx_L4_bool_binop_done:; if (__pyx_t_8) { __pyx_t_7 = __Pyx_PyUnicode_GET_LENGTH(__pyx_mstate_global->__pyx_n_u_real); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(2, 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; } __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 726, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name, __pyx_v_name) < (0)) __PYX_ERR(2, 726, __pyx_L1_error) __pyx_t_4 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_get_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_11 = __Pyx_PyLong_From_TA_OutputFlags(__pyx_v_info->flags); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_TA_OUTPUT_FLAGS); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 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_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_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; __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_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; /* function exit code */ __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_11); __Pyx_XDECREF(__pyx_t_12); __Pyx_AddTraceback("talib._ta_lib._ta_getOutputParameterInfo", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyObject *__pyx_v_func_info = 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("_get_defaults_and_docs (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_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_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; } const Py_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_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(2, 730, __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._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_362_get_defaults_and_docs(__pyx_self, __pyx_v_func_info); /* 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_RefNannyFinishContext(); return __pyx_r; } 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; PyObject *__pyx_v_docs = NULL; PyObject *__pyx_v_input_names = NULL; PyObject *__pyx_v_input_name = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_v_params = NULL; PyObject *__pyx_v_param = NULL; PyObject *__pyx_v_outputs = NULL; PyObject *__pyx_v_output = NULL; PyObject *__pyx_v_documentation = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; Py_ssize_t __pyx_t_4; PyObject *(*__pyx_t_5)(PyObject *); int __pyx_t_6; int __pyx_t_7; PyObject *__pyx_t_8 = 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", 0); __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_defaults = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(2, 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(2, 738, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_mstate_global->__pyx_kp_u_input_arrays_2); __Pyx_GIVEREF(__pyx_mstate_global->__pyx_kp_u_input_arrays_2); if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_mstate_global->__pyx_kp_u_input_arrays_2) != (0)) __PYX_ERR(2, 738, __pyx_L1_error); __pyx_v_func_args = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 739, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_docs = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_mstate_global->__pyx_kp_u_display_name_s_group_s, __pyx_v_func_info); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 740, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Dict_GetItem(__pyx_v_func_info, __pyx_mstate_global->__pyx_n_u_input_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_input_names = __pyx_t_2; __pyx_t_2 = 0; __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_mstate_global->__pyx_kp_u_Inputs); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 743, __pyx_L1_error) if (likely(PyList_CheckExact(__pyx_v_input_names)) || PyTuple_CheckExact(__pyx_v_input_names)) { __pyx_t_2 = __pyx_v_input_names; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0; __pyx_t_5 = NULL; } else { __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_input_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 744, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 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_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 744, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } __pyx_t_1 = __Pyx_PyList_GetItemRefFast(__pyx_t_2, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_4; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 744, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __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); #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 (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 744, __pyx_L1_error) PyErr_Clear(); } break; } } __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(2, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_6 = PyList_Check(__pyx_v_value); __pyx_t_7 = (!__pyx_t_6); if (__pyx_t_7) { __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 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_input_name), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_value), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 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_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_mstate_global->__pyx_n_u_parameters); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 750, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_params = __pyx_t_2; __pyx_t_2 = 0; __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_params); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 751, __pyx_L1_error) if (__pyx_t_7) { __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_mstate_global->__pyx_kp_u_Parameters); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 752, __pyx_L1_error) } if (likely(PyList_CheckExact(__pyx_v_params)) || PyTuple_CheckExact(__pyx_v_params)) { __pyx_t_2 = __pyx_v_params; __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_params); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 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_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 753, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } __pyx_t_10 = __Pyx_PyList_GetItemRefFast(__pyx_t_2, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_4; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 753, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_10 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4)); #else __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_10 = __pyx_t_5(__pyx_t_2); if (unlikely(!__pyx_t_10)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 753, __pyx_L1_error) PyErr_Clear(); } break; } } __Pyx_GOTREF(__pyx_t_10); __Pyx_XDECREF_SET(__pyx_v_param, __pyx_t_10); __pyx_t_10 = 0; __pyx_t_10 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_param), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 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 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_8), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_9[0] = __pyx_mstate_global->__pyx_kp_u__7; __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(2, 754, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_v_param), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_10 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Str(__pyx_t_1), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_11[0] = __pyx_mstate_global->__pyx_kp_u__8; __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_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_PyUnicode_Equals(__pyx_v_param, __pyx_mstate_global->__pyx_n_u_matype, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 757, __pyx_L1_error) if (__pyx_t_7) { __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_docs, -1L, long, 1, __Pyx_PyLong_From_long, 1, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_mstate_global->__pyx_n_u_MA_Type); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_params, __pyx_v_param); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 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_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_12, 1, __pyx_t_8) != (0)) __PYX_ERR(2, 758, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_8 = 0; __pyx_t_8 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__11, __pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 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_mstate_global->__pyx_n_u_output_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 760, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_outputs = __pyx_t_2; __pyx_t_2 = 0; __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_docs, __pyx_mstate_global->__pyx_kp_u_Outputs); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 761, __pyx_L1_error) if (likely(PyList_CheckExact(__pyx_v_outputs)) || PyTuple_CheckExact(__pyx_v_outputs)) { __pyx_t_2 = __pyx_v_outputs; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0; __pyx_t_5 = NULL; } else { __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_outputs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 762, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 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_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 762, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } __pyx_t_8 = __Pyx_PyList_GetItemRefFast(__pyx_t_2, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); ++__pyx_t_4; } else { { Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); #if !CYTHON_ASSUME_SAFE_SIZE if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 762, __pyx_L1_error) #endif if (__pyx_t_4 >= __pyx_temp) break; } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_8 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4)); #else __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_8 = __pyx_t_5(__pyx_t_2); if (unlikely(!__pyx_t_8)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(2, 762, __pyx_L1_error) PyErr_Clear(); } break; } } __Pyx_GOTREF(__pyx_t_8); __Pyx_XDECREF_SET(__pyx_v_output, __pyx_t_8); __pyx_t_8 = 0; __pyx_t_7 = (__Pyx_PyUnicode_Equals(__pyx_v_output, __pyx_mstate_global->__pyx_n_u_integer, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(2, 763, __pyx_L1_error) if (__pyx_t_7) { __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_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 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__3, __pyx_v_func_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 767, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_func_line, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 767, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_func_line, __pyx_mstate_global->__pyx_kp_u__12); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 768, __pyx_L1_error) __pyx_t_2 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__2, __pyx_v_func_line); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyList_Insert(__pyx_v_docs, 0, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 769, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyUnicode_Join(__pyx_mstate_global->__pyx_kp_u__13, __pyx_v_docs); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 770, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_documentation = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_r); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 771, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_defaults); __Pyx_GIVEREF(__pyx_v_defaults); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_defaults) != (0)) __PYX_ERR(2, 771, __pyx_L1_error); __Pyx_INCREF(__pyx_v_documentation); __Pyx_GIVEREF(__pyx_v_documentation); if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_documentation) != (0)) __PYX_ERR(2, 771, __pyx_L1_error); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_8); __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:; __Pyx_XDECREF(__pyx_v_defaults); __Pyx_XDECREF(__pyx_v_func_line); __Pyx_XDECREF(__pyx_v_func_args); __Pyx_XDECREF(__pyx_v_docs); __Pyx_XDECREF(__pyx_v_input_names); __Pyx_XDECREF(__pyx_v_input_name); __Pyx_XDECREF(__pyx_v_value); __Pyx_XDECREF(__pyx_v_params); __Pyx_XDECREF(__pyx_v_param); __Pyx_XDECREF(__pyx_v_outputs); __Pyx_XDECREF(__pyx_v_output); __Pyx_XDECREF(__pyx_v_documentation); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static TA_FuncHandle const *__pyx_f_5talib_7_ta_lib___ta_getFuncHandle(char *__pyx_v_function_name) { TA_FuncHandle const *__pyx_v_handle; TA_FuncHandle const *__pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__ta_getFuncHandle", 0); __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_GetFuncHandle, TA_GetFuncHandle(__pyx_v_function_name, (&__pyx_v_handle)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 787, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_v_handle; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib.__ta_getFuncHandle", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static TA_ParamHolder *__pyx_f_5talib_7_ta_lib___ta_paramHolderAlloc(char *__pyx_v_function_name) { TA_ParamHolder *__pyx_v_holder; TA_RetCode __pyx_v_retCode; TA_ParamHolder *__pyx_r; __Pyx_RefNannyDeclarations TA_FuncHandle const *__pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__ta_paramHolderAlloc", 0); __pyx_t_1 = __pyx_f_5talib_7_ta_lib___ta_getFuncHandle(__pyx_v_function_name); if (unlikely(__pyx_t_1 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(2, 795, __pyx_L1_error) __pyx_v_retCode = TA_ParamHolderAlloc(__pyx_t_1, (&__pyx_v_holder)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ParamHolderAlloc, __pyx_v_retCode, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_v_holder; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("talib._ta_lib.__ta_paramHolderAlloc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_f_5talib_7_ta_lib___ta_paramHolderFree(TA_ParamHolder *__pyx_v_params) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__ta_paramHolderFree", 0); __pyx_t_1 = __pyx_f_5talib_7_ta_lib__ta_check_success(__pyx_mstate_global->__pyx_n_u_TA_ParamHolderFree, TA_ParamHolderFree(__pyx_v_params), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 804, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib.__ta_paramHolderFree", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamInteger(TA_ParamHolder *__pyx_v_holder, int __pyx_v_idx, int __pyx_v_value) { TA_RetCode __pyx_v_retCode; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_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; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib.__ta_setOptInputParamInteger", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_f_5talib_7_ta_lib___ta_setOptInputParamReal(TA_ParamHolder *__pyx_v_holder, int __pyx_v_idx, double __pyx_v_value) { TA_RetCode __pyx_v_retCode; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_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; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib.__ta_setOptInputParamReal", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_f_5talib_7_ta_lib___ta_getLookback(TA_ParamHolder *__pyx_v_holder) { int __pyx_v_lookback; TA_RetCode __pyx_v_retCode; int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_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; __pyx_r = __pyx_v_lookback; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib.__ta_getLookback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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_ACOS (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,0}; 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_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; } const Py_ssize_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_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(5, 50, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 75, __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_ACOS", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; PyArrayObject *__pyx_v_volume = 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_AD (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_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_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_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_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_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; } const Py_ssize_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_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]); __pyx_v_close = ((PyArrayObject *)values[2]); __pyx_v_volume = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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; npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_AD", 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(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_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, 101, __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, 103, __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_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_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, 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_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(5, 111, __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_AD", __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; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real0 = 0; PyArrayObject *__pyx_v_real1 = 0; #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_ADD (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_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_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_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; } const Py_ssize_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_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(5, 113, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; double *__pyx_v_real1_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_ADD", 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(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_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(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_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-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_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(5, 142, __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_ADD", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real0); __Pyx_XDECREF((PyObject *)__pyx_v_real1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; PyArrayObject *__pyx_v_close = 0; PyArrayObject *__pyx_v_volume = 0; int __pyx_v_fastperiod; int __pyx_v_slowperiod; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[6] = {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_ADOSC (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_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_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_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_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_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_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_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; } const Py_ssize_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_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_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_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; } } __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_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_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(5, 144, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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; npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_ADOSC", 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(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_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, 171, __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, 173, __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_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_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, 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_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(5, 181, __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_ADOSC", __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; } /* Python wrapper */ 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_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 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_ADX (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, 183, __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, 183, __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, 183, __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, 183, __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, 183, __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_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 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_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: 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 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; } const Py_ssize_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_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) 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; } } __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, 220, __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(5, 218, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; npy_intp __pyx_t_2; 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(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_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, 243, __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, 245, __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, 247, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __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_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(5, 251, __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_fastperiod; int __pyx_v_slowperiod; 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_APO (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_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_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_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_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_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; } const Py_ssize_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_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_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_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_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_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_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_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(5, 253, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 282, __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_APO", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_AROON (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_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_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_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_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; } const Py_ssize_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((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, 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(5, 284, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; double *__pyx_v_low_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; double __pyx_v_outaroondown; double __pyx_v_outaroonup; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_AROON", 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(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_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, 310, __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_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; __pyx_v_outaroonup = __pyx_v_5talib_7_ta_lib_NaN; __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_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(5, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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_GIVEREF(__pyx_t_1); 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; 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_AddTraceback("talib._ta_lib.stream_AROON", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_AROONOSC (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_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_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_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_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; } const Py_ssize_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((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, 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(5, 319, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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; npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_AROONOSC", 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(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_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, 343, __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_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_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(5, 349, __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_AROONOSC", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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_ASIN (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,0}; 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_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; } const Py_ssize_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_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(5, 351, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 376, __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_ASIN", __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_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_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 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_ATAN (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,0}; 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_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; } const Py_ssize_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_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(5, 378, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 403, __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_ATAN", __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_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_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 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_ATR (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, 405, __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, 405, __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, 405, __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, 405, __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, 405, __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_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_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_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; } } __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, 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(5, 405, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_ATR", 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, 428, __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, 430, __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, 432, __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, 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_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(5, 438, __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_ATR", __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_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_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 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_AVGPRICE (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, 440, __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, 440, __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, 440, __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, 440, __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, 440, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_AVGPRICE", 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, 462, __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, 464, __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, 466, __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, 468, __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, 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_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(5, 474, __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_AVGPRICE", __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_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_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 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_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(5, 476, __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(5, 476, __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, 476, __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_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 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_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 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_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_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; } const Py_ssize_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_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_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_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_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) 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, 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(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(5, 507, __pyx_L3_error) } else { __pyx_v_nbdevdn = ((double)((double)-4e37)); } if (values[4]) { __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(5, 505, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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; 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_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(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_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_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_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_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(5, 541, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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_GIVEREF(__pyx_t_1); 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; 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_AddTraceback("talib._ta_lib.stream_BBANDS", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_BETA (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_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_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_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_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; } const Py_ssize_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_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_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; } } __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, 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(5, 543, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; double *__pyx_v_real1_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_BETA", 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(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_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(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_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-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_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(5, 574, __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_BETA", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real0); __Pyx_XDECREF((PyObject *)__pyx_v_real1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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_BOP (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, 576, __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, 576, __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, 576, __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, 576, __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, 576, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_BOP", 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, 598, __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, 600, __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, 602, __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, 604, __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, 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_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(5, 610, __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_BOP", __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_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_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 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_CCI (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, 612, __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, 612, __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, 612, __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, 612, __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, 612, __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_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_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_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; } } __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, 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(5, 612, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_CCI", 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, 635, __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, 637, __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, 639, __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, 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_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(5, 645, __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_CCI", __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_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_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 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_CDL2CROWS (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, 647, __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, 647, __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, 647, __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, 647, __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, 647, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_CDL2CROWS", 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, 669, __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, 671, __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, 673, __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, 675, __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, 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_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_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; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("talib._ta_lib.stream_CDL2CROWS", __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_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_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 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_CDL3BLACKCROWS (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, 683, __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, 683, __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, 683, __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, 683, __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, 683, __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_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 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 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: 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 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; } const Py_ssize_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 743, __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, 745, __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, 747, __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, 749, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDL3LINESTRIKE (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, 755, __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, 755, __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, 755, __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, 755, __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, 755, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 779, __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, 781, __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, 783, __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, 785, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDL3OUTSIDE (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, 791, __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, 791, __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, 791, __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, 791, __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, 791, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 815, __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, 817, __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, 819, __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, 821, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDL3STARSINSOUTH (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, 827, __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, 827, __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, 827, __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, 827, __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, 827, __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_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 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 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: 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 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; } const Py_ssize_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 887, __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, 889, __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, 891, __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, 893, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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; 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}; 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); #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,&__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 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 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 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 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; } const Py_ssize_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 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 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; } } __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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 925, __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, 927, __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, 929, __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, 931, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLADVANCEBLOCK (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, 937, __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, 937, __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, 937, __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, 937, __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, 937, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 961, __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, 963, __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, 965, __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, 967, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLBELTHOLD (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, 973, __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, 973, __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, 973, __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, 973, __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, 973, __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_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 { 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]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 997, __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, 999, __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, 1001, __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, 1003, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLBREAKAWAY (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, 1009, __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, 1009, __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, 1009, __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, 1009, __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, 1009, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1033, __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, 1035, __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, 1037, __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, 1039, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLCLOSINGMARUBOZU (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, 1045, __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, 1045, __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, 1045, __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, 1045, __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, 1045, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1069, __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, 1071, __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, 1073, __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, 1075, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_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(5, 1081, __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, 1081, __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, 1081, __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, 1081, __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, 1081, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1105, __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, 1107, __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, 1109, __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, 1111, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLCOUNTERATTACK (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, 1117, __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, 1117, __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, 1117, __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, 1117, __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, 1117, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1141, __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, 1143, __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, 1145, __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, 1147, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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; 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}; 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); #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,&__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 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 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 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_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; } const Py_ssize_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 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 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; } } __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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1179, __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, 1181, __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, 1183, __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, 1185, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLDOJI (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, 1191, __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, 1191, __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, 1191, __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, 1191, __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, 1191, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1215, __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, 1217, __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, 1219, __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, 1221, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLDOJISTAR (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, 1227, __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, 1227, __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, 1227, __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, 1227, __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, 1227, __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_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 { 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]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1251, __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, 1253, __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, 1255, __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, 1257, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLDRAGONFLYDOJI (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, 1263, __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, 1263, __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, 1263, __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, 1263, __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, 1263, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1287, __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, 1289, __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, 1291, __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, 1293, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLENGULFING (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, 1299, __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, 1299, __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, 1299, __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, 1299, __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, 1299, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1323, __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, 1325, __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, 1327, __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, 1329, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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; 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}; 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); #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,&__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 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_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_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_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; } const Py_ssize_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 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) 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; } } __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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1361, __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, 1363, __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, 1365, __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, 1367, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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; 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}; 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); #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,&__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 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_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_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_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; } const Py_ssize_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 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) 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; } } __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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1399, __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, 1401, __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, 1403, __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, 1405, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_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); { 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 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_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_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_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; } const Py_ssize_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 { 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]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1435, __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, 1437, __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, 1439, __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, 1441, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLGRAVESTONEDOJI (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, 1447, __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, 1447, __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, 1447, __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, 1447, __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, 1447, __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_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 { 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]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1471, __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, 1473, __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, 1475, __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, 1477, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLHAMMER (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, 1483, __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, 1483, __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, 1483, __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, 1483, __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, 1483, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1507, __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, 1509, __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, 1511, __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, 1513, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLHANGINGMAN (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, 1519, __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, 1519, __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, 1519, __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, 1519, __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, 1519, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1543, __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, 1545, __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, 1547, __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, 1549, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLHARAMI (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, 1555, __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, 1555, __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, 1555, __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, 1555, __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, 1555, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1579, __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, 1581, __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, 1583, __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, 1585, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLHARAMICROSS (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, 1591, __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, 1591, __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, 1591, __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, 1591, __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, 1591, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1615, __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, 1617, __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, 1619, __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, 1621, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLHIGHWAVE (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, 1627, __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, 1627, __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, 1627, __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, 1627, __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, 1627, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1651, __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, 1653, __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, 1655, __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, 1657, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLHIKKAKE (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, 1663, __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, 1663, __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, 1663, __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, 1663, __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, 1663, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1687, __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, 1689, __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, 1691, __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, 1693, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLHIKKAKEMOD (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, 1699, __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, 1699, __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, 1699, __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, 1699, __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, 1699, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1723, __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, 1725, __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, 1727, __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, 1729, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLHOMINGPIGEON (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, 1735, __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, 1735, __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, 1735, __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, 1735, __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, 1735, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1759, __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, 1761, __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, 1763, __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, 1765, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLIDENTICAL3CROWS (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, 1771, __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, 1771, __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, 1771, __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, 1771, __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, 1771, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1795, __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, 1797, __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, 1799, __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, 1801, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLINNECK (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, 1807, __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, 1807, __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, 1807, __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, 1807, __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, 1807, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1831, __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, 1833, __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, 1835, __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, 1837, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLINVERTEDHAMMER (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, 1843, __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, 1843, __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, 1843, __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, 1843, __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, 1843, __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_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 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 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: 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 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; } const Py_ssize_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1903, __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, 1905, __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, 1907, __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, 1909, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLKICKINGBYLENGTH (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, 1915, __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, 1915, __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, 1915, __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, 1915, __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, 1915, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1939, __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, 1941, __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, 1943, __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, 1945, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLLADDERBOTTOM (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, 1951, __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, 1951, __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, 1951, __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, 1951, __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, 1951, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 1975, __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, 1977, __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, 1979, __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, 1981, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLLONGLEGGEDDOJI (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, 1987, __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, 1987, __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, 1987, __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, 1987, __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, 1987, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2011, __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, 2013, __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, 2015, __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, 2017, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLLONGLINE (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, 2023, __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, 2023, __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, 2023, __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, 2023, __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, 2023, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2047, __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, 2049, __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, 2051, __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, 2053, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLMARUBOZU (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, 2059, __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, 2059, __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, 2059, __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, 2059, __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, 2059, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2083, __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, 2085, __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, 2087, __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, 2089, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLMATCHINGLOW (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, 2095, __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, 2095, __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, 2095, __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, 2095, __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, 2095, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2119, __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, 2121, __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, 2123, __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, 2125, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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; 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}; 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); #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,&__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 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 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 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 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; } const Py_ssize_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 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 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; } } __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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2157, __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, 2159, __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, 2161, __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, 2163, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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; 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}; 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); #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,&__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 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 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 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 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; } const Py_ssize_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 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 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; } } __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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2195, __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, 2197, __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, 2199, __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, 2201, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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; 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}; 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); #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,&__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 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 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_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_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; } const Py_ssize_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 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 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; } } __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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2233, __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, 2235, __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, 2237, __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, 2239, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLONNECK (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, 2245, __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, 2245, __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, 2245, __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, 2245, __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, 2245, __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_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 { 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]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2269, __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, 2271, __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, 2273, __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, 2275, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLPIERCING (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, 2281, __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, 2281, __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, 2281, __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, 2281, __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, 2281, __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_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 { 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]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2305, __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, 2307, __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, 2309, __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, 2311, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLRICKSHAWMAN (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, 2317, __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, 2317, __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, 2317, __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, 2317, __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, 2317, __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_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 { 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]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2341, __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, 2343, __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, 2345, __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, 2347, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLRISEFALL3METHODS (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, 2353, __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, 2353, __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, 2353, __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, 2353, __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, 2353, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2377, __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, 2379, __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, 2381, __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, 2383, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLSEPARATINGLINES (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, 2389, __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, 2389, __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, 2389, __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, 2389, __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, 2389, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2413, __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, 2415, __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, 2417, __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, 2419, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLSHOOTINGSTAR (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, 2425, __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, 2425, __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, 2425, __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, 2425, __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, 2425, __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_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 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 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: 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 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; } const Py_ssize_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2485, __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, 2487, __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, 2489, __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, 2491, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLSPINNINGTOP (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, 2497, __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, 2497, __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, 2497, __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, 2497, __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, 2497, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2521, __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, 2523, __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, 2525, __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, 2527, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLSTALLEDPATTERN (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, 2533, __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, 2533, __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, 2533, __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, 2533, __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, 2533, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2557, __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, 2559, __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, 2561, __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, 2563, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLSTICKSANDWICH (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, 2569, __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, 2569, __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, 2569, __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, 2569, __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, 2569, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2593, __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, 2595, __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, 2597, __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, 2599, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLTAKURI (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, 2605, __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, 2605, __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, 2605, __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, 2605, __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, 2605, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2629, __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, 2631, __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, 2633, __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, 2635, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLTASUKIGAP (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, 2641, __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, 2641, __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, 2641, __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, 2641, __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, 2641, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2665, __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, 2667, __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, 2669, __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, 2671, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLTHRUSTING (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, 2677, __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, 2677, __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, 2677, __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, 2677, __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, 2677, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2701, __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, 2703, __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, 2705, __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, 2707, __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLTRISTAR (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, 2713, __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, 2713, __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, 2713, __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, 2713, __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, 2713, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2737, __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, 2739, __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, 2741, __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, 2743, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLUNIQUE3RIVER (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, 2749, __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, 2749, __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, 2749, __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, 2749, __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, 2749, __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_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_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]); __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(5, 2749, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2773, __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, 2775, __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, 2777, __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, 2779, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLUPSIDEGAP2CROWS (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, 2785, __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, 2785, __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, 2785, __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, 2785, __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, 2785, __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_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_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]); __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(5, 2785, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 2809, __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, 2811, __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, 2813, __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, 2815, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; __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_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_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; goto __pyx_L0; /* 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_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_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_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 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_CDLXSIDEGAP3METHODS (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, 2821, __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, 2821, __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, 2821, __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, 2821, __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, 2821, __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_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_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]); __pyx_v_low = ((PyArrayObject *)values[2]); __pyx_v_close = ((PyArrayObject *)values[3]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_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(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_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, 2845, __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, 2847, __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, 2849, __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, 2851, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outinteger = 0; __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_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_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; goto __pyx_L0; /* 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_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_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_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_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_CEIL (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,0}; 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 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; } const Py_ssize_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 != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2857, __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(5, 2857, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_CEIL(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2876, __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_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_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 = 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; goto __pyx_L0; /* 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_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_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_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_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_CMO (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(5, 2884, __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(5, 2884, __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, 2884, __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_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 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_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; } } __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 { __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(5, 2884, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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_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_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(5, 2905, __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_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_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 = 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; goto __pyx_L0; /* 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_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_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_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_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}; 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); #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_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 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_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_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; } const Py_ssize_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 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_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; } } __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 { __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(5, 2913, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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_real0_data; double *__pyx_v_real1_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_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_real0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 2936, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real0, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; __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(5, 2938, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_real1, ((PyArrayObject *)__pyx_t_1)); __pyx_t_1 = 0; __pyx_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 2940, __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_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 = 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; goto __pyx_L0; /* 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_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real0); __Pyx_XDECREF((PyObject *)__pyx_v_real1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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_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_COS (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,0}; 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 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; } const Py_ssize_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 != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 2946, __pyx_L3_error) } __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(5, 2946, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_COS(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; 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_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_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_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_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 = 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; 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; } /* Python wrapper */ 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_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 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_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,0}; 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_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; } const Py_ssize_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_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_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:; for (Py_ssize_t __pyx_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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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(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_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_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_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(5, 2998, __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_COSH", __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_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_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 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_DEMA (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(5, 3000, __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(5, 3000, __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, 3000, __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_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_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_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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 3027, __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_DEMA", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real0 = 0; PyArrayObject *__pyx_v_real1 = 0; #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_DIV (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_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 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_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; } const Py_ssize_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 { 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]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; double *__pyx_v_real1_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_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(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_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(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_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-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_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_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(5, 3058, __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_DIV", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real0); __Pyx_XDECREF((PyObject *)__pyx_v_real1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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_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_DX (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, 3060, __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, 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; } const Py_ssize_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) } } } 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; } } __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 { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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_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_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(5, 3083, __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, 3085, __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, 3087, __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, 3089, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __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_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(5, 3093, __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_DX", __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_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_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 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_EMA (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(5, 3095, __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(5, 3095, __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, 3095, __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_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_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_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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 3122, __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_EMA", __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_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_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_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_EXP (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,0}; 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 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; } const Py_ssize_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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3124, __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(5, 3124, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_EXP(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3143, __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_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_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(5, 3149, __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_EXP", __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_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_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_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_FLOOR (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,0}; 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 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; } const Py_ssize_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) } } } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(5, 3151, __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(5, 3151, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_FLOOR(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_real)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3170, __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_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_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(5, 3176, __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_FLOOR", __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_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_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 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_HT_DCPERIOD (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,0}; 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 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; } const Py_ssize_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 { 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]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 3203, __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_HT_DCPERIOD", __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_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_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 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_HT_DCPHASE (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,0}; 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_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; } const Py_ssize_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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 3230, __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_HT_DCPHASE", __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_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_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 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_HT_PHASOR (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,0}; 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_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; } const Py_ssize_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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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_outinphase; double __pyx_v_outquadrature; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = 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_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(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_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_outinphase = __pyx_v_5talib_7_ta_lib_NaN; __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_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_outinphase); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3260, __pyx_L1_error) __Pyx_GOTREF(__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_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); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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_HT_SINE (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,0}; 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_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; } const Py_ssize_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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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_outsine; double __pyx_v_outleadsine; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = 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_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(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_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_outsine = __pyx_v_5talib_7_ta_lib_NaN; __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_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_outsine); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3290, __pyx_L1_error) __Pyx_GOTREF(__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_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); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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_HT_TRENDLINE (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,0}; 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_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; } const Py_ssize_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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 3317, __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_HT_TRENDLINE", __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_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_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 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_HT_TRENDMODE (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,0}; 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_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; } const Py_ssize_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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; int __pyx_v_outinteger; 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_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(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_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_outinteger = 0; __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_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 = __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_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_HT_TRENDMODE", __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_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_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_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[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_IMI (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_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 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; } const Py_ssize_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) } } } 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; } } __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 { __pyx_v_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_IMI", __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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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_open_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_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_open)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3368, __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_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_close_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_close)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_open, __pyx_v_close); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 3372, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __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_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_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3376, __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_IMI", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_open); __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_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_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 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_KAMA (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(5, 3378, __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(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; } const Py_ssize_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 { 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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 3405, __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_KAMA", __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_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_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 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_LINEARREG (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(5, 3407, __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(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; } const Py_ssize_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) } } } else { 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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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 = 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; goto __pyx_L0; /* 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_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_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_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 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_LINEARREG_ANGLE (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(5, 3436, __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(5, 3436, __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, 3436, __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_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_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_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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 3463, __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_LINEARREG_ANGLE", __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_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_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 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_LINEARREG_INTERCEPT (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(5, 3465, __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(5, 3465, __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, 3465, __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_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_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_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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 3492, __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_LINEARREG_INTERCEPT", __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_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_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 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_LINEARREG_SLOPE (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(5, 3494, __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(5, 3494, __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, 3494, __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_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_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_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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 3521, __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_LINEARREG_SLOPE", __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_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_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 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_LN (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,0}; 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 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; } const Py_ssize_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 { 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]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 3548, __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_LN", __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_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_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 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_LOG10 (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,0}; 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 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; } const Py_ssize_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 { 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]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 3575, __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_LOG10", __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_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_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 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}; 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); #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_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 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; } const Py_ssize_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 { 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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 3605, __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_MA", __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_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_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 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("stream_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(5, 3607, __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, 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; } const Py_ssize_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) } } } 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, 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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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_outmacd; double __pyx_v_outmacdsignal; double __pyx_v_outmacdhist; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; 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_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(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_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_outmacd = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_outmacdsignal = __pyx_v_5talib_7_ta_lib_NaN; __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_outmacd); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3642, __pyx_L1_error) __Pyx_GOTREF(__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_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); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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; #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}; 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); #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_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 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 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_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; } const Py_ssize_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 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 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_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_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_fastperiod = ((int)((int)-2147483648)); } if (values[2]) { __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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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_outmacd; double __pyx_v_outmacdsignal; double __pyx_v_outmacdhist; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; 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_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(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_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_outmacd = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_outmacdsignal = __pyx_v_5talib_7_ta_lib_NaN; __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_outmacd); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3682, __pyx_L1_error) __Pyx_GOTREF(__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_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); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_signalperiod; #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_MACDFIX (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_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 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_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; } const Py_ssize_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 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_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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; int __pyx_v_outbegidx; int __pyx_v_outnbelement; double __pyx_v_outmacd; double __pyx_v_outmacdsignal; double __pyx_v_outmacdhist; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; 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_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(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_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_outmacd = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_outmacdsignal = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_outmacdhist = __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_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(5, 3717, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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_GIVEREF(__pyx_t_1); 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; 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_AddTraceback("talib._ta_lib.stream_MACDFIX", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; 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[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_MAMA (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_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 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_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_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; } const Py_ssize_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 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_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_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_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_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(5, 3721, __pyx_L3_error) } else { __pyx_v_slowlimit = ((double)((double)-4e37)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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_outmama; double __pyx_v_outfama; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = 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_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(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_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_outmama = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_outfama = __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_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_outmama); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3750, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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_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_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_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); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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; #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_MAVP (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_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 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 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: 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; } const Py_ssize_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 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 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]); __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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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_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_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(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_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(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_periods_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_periods)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_periods); if (unlikely(__pyx_t_2 == ((npy_intp)-1L))) __PYX_ERR(5, 3781, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outreal = __pyx_v_5talib_7_ta_lib_NaN; __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_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_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3785, __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_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; } /* Python wrapper */ 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_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 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_MAX (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(5, 3787, __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(5, 3787, __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, 3787, __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_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 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_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_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_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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_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_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(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_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_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_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_outreal); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3814, __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_MAX", __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_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_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 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_MAXINDEX (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(5, 3816, __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(5, 3816, __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, 3816, __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_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 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_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]); 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_timeperiod = ((int)((int)-2147483648)); } } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; int __pyx_v_outbegidx; int __pyx_v_outnbelement; int __pyx_v_outinteger; 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_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(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_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_outinteger = 0; __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_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 = __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; goto __pyx_L0; /* 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_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_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_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_high = 0; PyArrayObject *__pyx_v_low = 0; #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_MEDPRICE (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,0}; 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_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_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; } const Py_ssize_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) } } } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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_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; npy_intp __pyx_t_2; 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(5, 3865, __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, 3867, __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_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_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_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(5, 3873, __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_MEDPRICE", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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_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}; 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); #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_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 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 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 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: 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; } const Py_ssize_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 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 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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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_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; npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_high)); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 3899, __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, 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_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, 3903, __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_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 = 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; goto __pyx_L0; /* 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_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; } /* Python wrapper */ 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_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_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_MIDPOINT (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(5, 3913, __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(5, 3913, __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, 3913, __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_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 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_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; } } __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 { __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(5, 3913, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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_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_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(5, 3934, __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_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_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(5, 3940, __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_MIDPOINT", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 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}; 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); #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_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 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_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_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; } const Py_ssize_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 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_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]); 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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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, 3966, __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_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_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_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(5, 3972, __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_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_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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_MIN (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(5, 3974, __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(5, 3974, __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, 3974, __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_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_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_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_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_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:; for (Py_ssize_t __pyx_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_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, 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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4001, __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_MIN", __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_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_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_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_MININDEX (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(5, 4003, __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(5, 4003, __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, 4003, __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_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 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_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_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_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:; for (Py_ssize_t __pyx_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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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(5, 4024, __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_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_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 = __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; 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_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_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 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_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(5, 4032, __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(5, 4032, __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, 4032, __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_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_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_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_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_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:; for (Py_ssize_t __pyx_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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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_outmin); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 4062, __pyx_L1_error) __Pyx_GOTREF(__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_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); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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_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(5, 4064, __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(5, 4064, __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, 4064, __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_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) } } } else { switch (__pyx_nargs) { 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: 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_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(5, 4064, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; int __pyx_v_outbegidx; int __pyx_v_outnbelement; int __pyx_v_outminidx; int __pyx_v_outmaxidx; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = 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(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_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_outminidx = 0; __pyx_v_outmaxidx = 0; __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_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_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_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_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_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_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("talib._ta_lib.stream_MINMAXINDEX", __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_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_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 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_MINUS_DI (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, 4096, __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, 4096, __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, 4096, __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, 4096, __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, 4096, __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_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_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_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; } } __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, 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(5, 4096, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_MINUS_DI", 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, 4119, __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, 4121, __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, 4123, __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, 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_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(5, 4129, __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_MINUS_DI", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_MINUS_DM (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_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_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_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_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; } const Py_ssize_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((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, 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(5, 4131, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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; npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_MINUS_DM", 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(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_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, 4155, __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_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_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(5, 4161, __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_MINUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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_MOM (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(5, 4163, __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(5, 4163, __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, 4163, __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_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_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_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_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(5, 4163, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4190, __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_MOM", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real0 = 0; PyArrayObject *__pyx_v_real1 = 0; #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_MULT (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_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_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_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; } const Py_ssize_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_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(5, 4192, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; double *__pyx_v_real1_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_MULT", 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(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_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(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_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-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_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(5, 4221, __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_MULT", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real0); __Pyx_XDECREF((PyObject *)__pyx_v_real1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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_NATR (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, 4223, __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, 4223, __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, 4223, __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, 4223, __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, 4223, __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_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_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_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; } } __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, 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(5, 4223, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_NATR", 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, 4246, __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, 4248, __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, 4250, __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, 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_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(5, 4256, __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_NATR", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; PyArrayObject *__pyx_v_volume = 0; #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_OBV (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_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_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_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; } const Py_ssize_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_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(5, 4258, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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; npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_OBV", 0); __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(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_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(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_v_volume_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_volume)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real, __pyx_v_volume); if (unlikely(__pyx_t_2 == ((npy_intp)-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_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(5, 4287, __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_OBV", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real); __Pyx_XDECREF((PyObject *)__pyx_v_volume); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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_PLUS_DI (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, 4289, __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, 4289, __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, 4289, __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, 4289, __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, 4289, __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_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_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_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; } } __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, 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(5, 4289, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_PLUS_DI", 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, 4312, __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, 4314, __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, 4316, __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, 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_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(5, 4322, __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_PLUS_DI", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_PLUS_DM (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_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_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_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_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; } const Py_ssize_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((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, 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(5, 4324, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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; npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_PLUS_DM", 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(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_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, 4348, __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_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_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(5, 4354, __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_PLUS_DM", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_fastperiod; int __pyx_v_slowperiod; 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}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("stream_PPO (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_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_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_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_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_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; } const Py_ssize_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_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_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_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_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_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_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_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(5, 4356, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4385, __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_PPO", __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_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_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 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_ROC (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(5, 4387, __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(5, 4387, __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, 4387, __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_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_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_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_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(5, 4387, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4414, __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_ROC", __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_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_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 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_ROCP (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(5, 4416, __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(5, 4416, __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, 4416, __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_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_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_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_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(5, 4416, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4443, __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_ROCP", __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_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_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 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_ROCR (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(5, 4445, __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(5, 4445, __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, 4445, __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_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_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_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_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(5, 4445, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4472, __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_ROCR", __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_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_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 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_ROCR100 (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(5, 4474, __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(5, 4474, __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, 4474, __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_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_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_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_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(5, 4474, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4501, __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_ROCR100", __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_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_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 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_RSI (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(5, 4503, __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(5, 4503, __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, 4503, __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_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_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_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_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(5, 4503, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4530, __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_RSI", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; double __pyx_v_acceleration; double __pyx_v_maximum; #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_SAR (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_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_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_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_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_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; } const Py_ssize_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_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_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_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; } } __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(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(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(5, 4532, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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; npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_SAR", 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(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_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, 4557, __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_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_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(5, 4563, __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_SAR", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_high = 0; PyArrayObject *__pyx_v_low = 0; 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; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[10] = {0,0,0,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_SAREXT (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_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_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_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_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_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_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_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_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_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_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_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; } const Py_ssize_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_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_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_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_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_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_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_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_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_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; } } __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(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(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(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(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(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(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(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(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(5, 4565, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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; npy_intp __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_SAREXT", 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(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_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, 4596, __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_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_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(5, 4602, __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_SAREXT", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_high); __Pyx_XDECREF((PyObject *)__pyx_v_low); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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_SIN (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,0}; 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_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; } const Py_ssize_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_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(5, 4604, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4629, __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_SIN", __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_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_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 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_SINH (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,0}; 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_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; } const Py_ssize_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_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(5, 4631, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4656, __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_SINH", __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_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_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 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_SMA (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(5, 4658, __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(5, 4658, __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, 4658, __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_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_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_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_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(5, 4658, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4685, __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_SMA", __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_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_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 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_SQRT (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,0}; 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_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; } const Py_ssize_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_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(5, 4687, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4712, __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_SQRT", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_timeperiod; double __pyx_v_nbdev; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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_STDDEV (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_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_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_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_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; } const Py_ssize_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_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_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_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_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(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(5, 4714, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4742, __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_STDDEV", __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_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_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 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_fastk_period; int __pyx_v_slowk_period; int __pyx_v_slowk_matype; int __pyx_v_slowd_period; int __pyx_v_slowd_matype; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[8] = {0,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_STOCH (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_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_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_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_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_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_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_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_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_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; } const Py_ssize_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_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_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_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_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { __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_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_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_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_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(5, 4744, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; double *__pyx_v_low_data; double *__pyx_v_close_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; double __pyx_v_outslowk; double __pyx_v_outslowd; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_STOCH", 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, 4773, __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, 4775, __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, 4777, __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, 4779, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outslowk = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_outslowd = __pyx_v_5talib_7_ta_lib_NaN; __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_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(5, 4784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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_GIVEREF(__pyx_t_1); 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; 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_AddTraceback("talib._ta_lib.stream_STOCH", __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_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_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 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_fastk_period; int __pyx_v_fastd_period; int __pyx_v_fastd_matype; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[6] = {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_STOCHF (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_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_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_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_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_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_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_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; } const Py_ssize_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_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_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { __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_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_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(5, 4786, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; double *__pyx_v_low_data; double *__pyx_v_close_data; int __pyx_v_outbegidx; int __pyx_v_outnbelement; double __pyx_v_outfastk; double __pyx_v_outfastd; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("stream_STOCHF", 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, 4813, __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, 4815, __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, 4817, __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, 4819, __pyx_L1_error) __pyx_v_length = __pyx_t_2; __pyx_v_outfastk = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_outfastd = __pyx_v_5talib_7_ta_lib_NaN; __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_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(5, 4824, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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_GIVEREF(__pyx_t_1); 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; 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_AddTraceback("talib._ta_lib.stream_STOCHF", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_timeperiod; int __pyx_v_fastk_period; int __pyx_v_fastd_period; int __pyx_v_fastd_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_STOCHRSI (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_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_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_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_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_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_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; } const Py_ssize_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_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_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_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_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_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_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_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_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_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(5, 4826, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; int __pyx_v_outbegidx; int __pyx_v_outnbelement; double __pyx_v_outfastk; double __pyx_v_outfastd; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = 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(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_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_outfastk = __pyx_v_5talib_7_ta_lib_NaN; __pyx_v_outfastd = __pyx_v_5talib_7_ta_lib_NaN; __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_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(5, 4859, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __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_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_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_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("talib._ta_lib.stream_STOCHRSI", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real0 = 0; PyArrayObject *__pyx_v_real1 = 0; #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_SUB (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_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_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_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; } const Py_ssize_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_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(5, 4861, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; double *__pyx_v_real1_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_SUB", 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(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_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(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_v_real1_data = ((double *)__pyx_f_5numpy_7ndarray_4data_data(__pyx_v_real1)); __pyx_t_2 = __pyx_f_5talib_7_ta_lib_check_length2(__pyx_v_real0, __pyx_v_real1); if (unlikely(__pyx_t_2 == ((npy_intp)-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_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(5, 4890, __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_SUB", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_real0); __Pyx_XDECREF((PyObject *)__pyx_v_real1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ 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_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 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_SUM (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(5, 4892, __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(5, 4892, __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, 4892, __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_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_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_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_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(5, 4892, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4919, __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_SUM", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_timeperiod; double __pyx_v_vfactor; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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_T3 (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_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_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_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_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; } const Py_ssize_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_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_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_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_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(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(5, 4921, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4949, __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_T3", __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_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_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 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_TAN (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,0}; 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_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; } const Py_ssize_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_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(5, 4951, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 4976, __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_TAN", __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_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_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 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_TANH (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,0}; 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_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; } const Py_ssize_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_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(5, 4978, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 5003, __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_TANH", __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_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_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 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_TEMA (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(5, 5005, __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(5, 5005, __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, 5005, __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_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_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_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_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(5, 5005, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 5032, __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_TEMA", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { 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[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_TRANGE (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,0}; 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_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_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_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; } const Py_ssize_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_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]); __pyx_v_close = ((PyArrayObject *)values[2]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_TRANGE", 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, 5055, __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, 5057, __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, 5059, __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, 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_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(5, 5065, __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_TRANGE", __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_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_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 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_TRIMA (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(5, 5067, __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(5, 5067, __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, 5067, __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_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_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_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_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(5, 5067, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 5094, __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_TRIMA", __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_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_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 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_TRIX (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(5, 5096, __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(5, 5096, __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, 5096, __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_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_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_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_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(5, 5096, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 5123, __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_TRIX", __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_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_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 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_TSF (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(5, 5125, __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(5, 5125, __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, 5125, __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_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_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_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_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(5, 5125, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__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_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; 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_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(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_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_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_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(5, 5152, __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_TSF", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { 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[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_TYPPRICE (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,0}; 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_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_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_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; } const Py_ssize_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_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]); __pyx_v_close = ((PyArrayObject *)values[2]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_TYPPRICE", 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, 5175, __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, 5177, __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, 5179, __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, 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_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(5, 5185, __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_TYPPRICE", __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_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_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 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_timeperiod1; int __pyx_v_timeperiod2; int __pyx_v_timeperiod3; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject* values[6] = {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_ULTOSC (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_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_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_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_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_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_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_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; } const Py_ssize_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_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_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_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_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; } } __pyx_v_high = ((PyArrayObject *)values[0]); __pyx_v_low = ((PyArrayObject *)values[1]); __pyx_v_close = ((PyArrayObject *)values[2]); if (values[3]) { __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_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_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(5, 5187, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_ULTOSC", 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, 5212, __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, 5214, __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, 5216, __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, 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_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(5, 5222, __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_ULTOSC", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { PyArrayObject *__pyx_v_real = 0; int __pyx_v_timeperiod; double __pyx_v_nbdev; #if !CYTHON_METH_FASTCALL CYTHON_UNUSED Py_ssize_t __pyx_nargs; #endif CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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_VAR (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_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_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_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_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; } const Py_ssize_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_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_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_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_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(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(5, 5224, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_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(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_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_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_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(5, 5252, __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_VAR", __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_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_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 PyObject *__pyx_args, PyObject *__pyx_kwds #endif ) { 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[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_WCLPRICE (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,0}; 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_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_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_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; } const Py_ssize_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_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]); __pyx_v_close = ((PyArrayObject *)values[2]); } goto __pyx_L6_skip; __pyx_L5_argtuple_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:; for (Py_ssize_t __pyx_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_WCLPRICE", 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, 5275, __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, 5277, __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, 5279, __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, 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_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(5, 5285, __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_WCLPRICE", __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_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_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 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_WILLR (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, 5287, __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, 5287, __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, 5287, __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, 5287, __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, 5287, __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_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_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_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; } } __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, 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(5, 5287, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_WILLR", 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, 5310, __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, 5312, __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, 5314, __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, 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_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(5, 5320, __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_WILLR", __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_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_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 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_WMA (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(5, 5322, __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(5, 5322, __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, 5322, __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_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_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_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_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(5, 5322, __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_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_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:; for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { Py_XDECREF(values[__pyx_temp]); } __pyx_L7_cleaned_up:; __Pyx_RefNannyFinishContext(); return __pyx_r; } 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; 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_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(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_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_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_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(5, 5349, __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_WMA", __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; } /* #### Code section: module_exttypes ### */ static PyMethodDef __pyx_methods[] = { {0, 0, 0, 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 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(__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(__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(__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(__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; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_mstate->__pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_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_2_4(PyTypeObject), #elif CYTHON_COMPILING_IN_LIMITED_API 0, 0, #else sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_4(PyHeapTypeObject), #endif __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(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; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } 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(__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 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 #ifdef __cplusplus namespace { struct PyModuleDef __pyx_moduledef = #else static struct PyModuleDef __pyx_moduledef = #endif { PyModuleDef_HEAD_INIT, "_ta_lib", 0, /* m_doc */ #if CYTHON_USE_MODULE_STATE sizeof(__pyx_mstatetype), /* m_size */ #else (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif #if CYTHON_USE_MODULE_STATE __pyx_m_traverse, /* m_traverse */ __pyx_m_clear, /* m_clear */ NULL /* m_free */ #else NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ #endif }; #ifdef __cplusplus } /* anonymous namespace */ #endif /* PyModInitFuncType */ #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #else #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else #define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif __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) { 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 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."); return -1; } return 0; } #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) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } 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"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; 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; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec__ta_lib(PyObject *__pyx_pyinit_module) #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; size_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = 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; PyObject *__pyx_t_21 = NULL; double __pyx_t_22; int __pyx_t_23; PyObject *__pyx_t_24 = NULL; 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; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module '_ta_lib' has already been imported. Re-initialisation is not supported."); return -1; } #else if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_t_1 = __pyx_pyinit_module; Py_INCREF(__pyx_t_1); #else __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 = __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(0, 1, __pyx_L1_error) pystate_addmodule_run = 1; } #else __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_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("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 ---*/ /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) stringtab_initialized = 1; if (__Pyx_InitGlobals() < (0)) __PYX_ERR(0, 1, __pyx_L1_error) if (__pyx_module_is_main_talib___ta_lib) { if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name_2, __pyx_mstate_global->__pyx_n_u_main) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) } { 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(0, 1, __pyx_L1_error) } } /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_CreateCodeObjects(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) /*--- Global type/function init 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 ---*/ __pyx_t_2 = __Pyx_PyBytes_FromString(TA_GetVersionString()); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_version, __pyx_t_2) < (0)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_1_ta_check_success, 0, __pyx_mstate_global->__pyx_n_u_ta_check_success, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_check_success, __pyx_t_2) < (0)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_3_ta_initialize, 0, __pyx_mstate_global->__pyx_n_u_ta_initialize, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_initialize, __pyx_t_2) < (0)) __PYX_ERR(1, 50, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_5_ta_shutdown, 0, __pyx_mstate_global->__pyx_n_u_ta_shutdown, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 55, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_shutdown, __pyx_t_2) < (0)) __PYX_ERR(1, 55, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[2]); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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_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_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_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_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_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_16); for (index=0; index < 9; index++) { 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_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_16); __pyx_t_16 = 0; __pyx_t_17 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(1, 61, __pyx_L1_error) __pyx_L3_unpacking_done:; } if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_SMA, __pyx_t_6) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_EMA, __pyx_t_8) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_WMA, __pyx_t_9) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DEMA, __pyx_t_10) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TEMA, __pyx_t_11) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_TRIMA, __pyx_t_12) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_KAMA, __pyx_t_13) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_MAMA, __pyx_t_14) < (0)) __PYX_ERR(1, 61, __pyx_L1_error) __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_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 CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); #endif if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_5) < (0)) __PYX_ERR(1, 63, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_7MA_Type_3__getitem__, 0, __pyx_mstate_global->__pyx_n_u_MA_Type___getitem, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); #endif if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_getitem, __pyx_t_5) < (0)) __PYX_ERR(1, 76, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_Py3ClassCreate(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_MA_Type, __pyx_t_2, __pyx_t_4, NULL, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 60, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #if 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_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; __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_NONE, __pyx_mstate_global->__pyx_int_neg_1) < (0)) __PYX_ERR(1, 81, __pyx_L1_error) if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_func_unst_ids, __pyx_t_2) < (0)) __PYX_ERR(1, 81, __pyx_L1_error) __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_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_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_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_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_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_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_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_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_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_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); 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_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_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_17(__pyx_t_21); if (unlikely(!item)) goto __pyx_L7_unpacking_failed; __Pyx_GOTREF(item); *(temps[index]) = item; } 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_21); __pyx_t_21 = 0; __pyx_t_17 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(1, 113, __pyx_L1_error) __pyx_L8_unpacking_done:; } if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyLong, __pyx_t_5) < (0)) __PYX_ERR(1, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyVeryLong, __pyx_t_14) < (0)) __PYX_ERR(1, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyShort, __pyx_t_13) < (0)) __PYX_ERR(1, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_BodyDoji, __pyx_t_12) < (0)) __PYX_ERR(1, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowLong, __pyx_t_11) < (0)) __PYX_ERR(1, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowVeryLong, __pyx_t_10) < (0)) __PYX_ERR(1, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowShort, __pyx_t_9) < (0)) __PYX_ERR(1, 114, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_ShadowVeryShort, __pyx_t_8) < (0)) __PYX_ERR(1, 114, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_Near, __pyx_t_6) < (0)) __PYX_ERR(1, 114, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (__Pyx_SetNameInClass(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_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_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_t_3 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_CandleSettingType); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_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_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_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); 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_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); } { Py_ssize_t index = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_15); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_17 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_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 = 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_17 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(1, 120, __pyx_L1_error) __pyx_L10_unpacking_done:; } if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_RealBody, __pyx_t_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_3, __pyx_mstate_global->__pyx_n_u_Shadows, __pyx_t_16) < (0)) __PYX_ERR(1, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_15 = __Pyx_Py3ClassCreate(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_RangeType, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); #if 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_t_4 = NULL; __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_RangeType); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 122, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_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_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_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; { 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_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_23 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(4, 15, __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_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_DECREF(__pyx_t_2); __pyx_t_2 = 0; __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_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 = __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); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_AD, __pyx_t_2) < (0)) __PYX_ERR(4, 210, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_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 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_Pack(2, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_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_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 308, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_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_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_4 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_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_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_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_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_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_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_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_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_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_15 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 532, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_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_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; __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_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 670, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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); #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_53BOP, 0, __pyx_mstate_global->__pyx_n_u_BOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[28])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 701, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_BOP, __pyx_t_3) < (0)) __PYX_ERR(4, 701, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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); #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_57CDL2CROWS, 0, __pyx_mstate_global->__pyx_n_u_CDL2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[30])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 766, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL2CROWS, __pyx_t_3) < (0)) __PYX_ERR(4, 766, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_59CDL3BLACKCROWS, 0, __pyx_mstate_global->__pyx_n_u_CDL3BLACKCROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[31])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 798, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3BLACKCROWS, __pyx_t_3) < (0)) __PYX_ERR(4, 798, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_61CDL3INSIDE, 0, __pyx_mstate_global->__pyx_n_u_CDL3INSIDE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[32])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3INSIDE, __pyx_t_3) < (0)) __PYX_ERR(4, 830, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_63CDL3LINESTRIKE, 0, __pyx_mstate_global->__pyx_n_u_CDL3LINESTRIKE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[33])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 862, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3LINESTRIKE, __pyx_t_3) < (0)) __PYX_ERR(4, 862, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_65CDL3OUTSIDE, 0, __pyx_mstate_global->__pyx_n_u_CDL3OUTSIDE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[34])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3OUTSIDE, __pyx_t_3) < (0)) __PYX_ERR(4, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_67CDL3STARSINSOUTH, 0, __pyx_mstate_global->__pyx_n_u_CDL3STARSINSOUTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[35])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 926, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3STARSINSOUTH, __pyx_t_3) < (0)) __PYX_ERR(4, 926, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_69CDL3WHITESOLDIERS, 0, __pyx_mstate_global->__pyx_n_u_CDL3WHITESOLDIERS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[36])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 958, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDL3WHITESOLDIERS, __pyx_t_3) < (0)) __PYX_ERR(4, 958, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_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_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 990, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_71CDLABANDONEDBABY, 0, __pyx_mstate_global->__pyx_n_u_CDLABANDONEDBABY, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[37])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 990, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLABANDONEDBABY, __pyx_t_3) < (0)) __PYX_ERR(4, 990, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_73CDLADVANCEBLOCK, 0, __pyx_mstate_global->__pyx_n_u_CDLADVANCEBLOCK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[38])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1024, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLADVANCEBLOCK, __pyx_t_3) < (0)) __PYX_ERR(4, 1024, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_75CDLBELTHOLD, 0, __pyx_mstate_global->__pyx_n_u_CDLBELTHOLD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[39])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1056, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLBELTHOLD, __pyx_t_3) < (0)) __PYX_ERR(4, 1056, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_77CDLBREAKAWAY, 0, __pyx_mstate_global->__pyx_n_u_CDLBREAKAWAY, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[40])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1088, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLBREAKAWAY, __pyx_t_3) < (0)) __PYX_ERR(4, 1088, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_79CDLCLOSINGMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_CDLCLOSINGMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[41])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLCLOSINGMARUBOZU, __pyx_t_3) < (0)) __PYX_ERR(4, 1120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_81CDLCONCEALBABYSWALL, 0, __pyx_mstate_global->__pyx_n_u_CDLCONCEALBABYSWALL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[42])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1152, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLCONCEALBABYSWALL, __pyx_t_3) < (0)) __PYX_ERR(4, 1152, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_83CDLCOUNTERATTACK, 0, __pyx_mstate_global->__pyx_n_u_CDLCOUNTERATTACK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[43])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLCOUNTERATTACK, __pyx_t_3) < (0)) __PYX_ERR(4, 1184, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_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_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 1216, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_85CDLDARKCLOUDCOVER, 0, __pyx_mstate_global->__pyx_n_u_CDLDARKCLOUDCOVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[44])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1216, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDARKCLOUDCOVER, __pyx_t_3) < (0)) __PYX_ERR(4, 1216, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_87CDLDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[45])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDOJI, __pyx_t_3) < (0)) __PYX_ERR(4, 1250, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_89CDLDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[46])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDOJISTAR, __pyx_t_3) < (0)) __PYX_ERR(4, 1282, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_91CDLDRAGONFLYDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLDRAGONFLYDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[47])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLDRAGONFLYDOJI, __pyx_t_3) < (0)) __PYX_ERR(4, 1314, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_93CDLENGULFING, 0, __pyx_mstate_global->__pyx_n_u_CDLENGULFING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[48])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLENGULFING, __pyx_t_3) < (0)) __PYX_ERR(4, 1346, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1380, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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); #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(4, 1414, __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, 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); #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_99CDLGAPSIDESIDEWHITE, 0, __pyx_mstate_global->__pyx_n_u_CDLGAPSIDESIDEWHITE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[51])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1446, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLGAPSIDESIDEWHITE, __pyx_t_3) < (0)) __PYX_ERR(4, 1446, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_101CDLGRAVESTONEDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLGRAVESTONEDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[52])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLGRAVESTONEDOJI, __pyx_t_3) < (0)) __PYX_ERR(4, 1478, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_103CDLHAMMER, 0, __pyx_mstate_global->__pyx_n_u_CDLHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[53])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1510, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHAMMER, __pyx_t_3) < (0)) __PYX_ERR(4, 1510, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_105CDLHANGINGMAN, 0, __pyx_mstate_global->__pyx_n_u_CDLHANGINGMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[54])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1542, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHANGINGMAN, __pyx_t_3) < (0)) __PYX_ERR(4, 1542, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_107CDLHARAMI, 0, __pyx_mstate_global->__pyx_n_u_CDLHARAMI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[55])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHARAMI, __pyx_t_3) < (0)) __PYX_ERR(4, 1574, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_109CDLHARAMICROSS, 0, __pyx_mstate_global->__pyx_n_u_CDLHARAMICROSS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[56])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1606, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHARAMICROSS, __pyx_t_3) < (0)) __PYX_ERR(4, 1606, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_111CDLHIGHWAVE, 0, __pyx_mstate_global->__pyx_n_u_CDLHIGHWAVE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[57])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1638, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHIGHWAVE, __pyx_t_3) < (0)) __PYX_ERR(4, 1638, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_113CDLHIKKAKE, 0, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[58])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1670, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKE, __pyx_t_3) < (0)) __PYX_ERR(4, 1670, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_115CDLHIKKAKEMOD, 0, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKEMOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[59])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1702, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKEMOD, __pyx_t_3) < (0)) __PYX_ERR(4, 1702, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_117CDLHOMINGPIGEON, 0, __pyx_mstate_global->__pyx_n_u_CDLHOMINGPIGEON, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[60])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1734, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLHOMINGPIGEON, __pyx_t_3) < (0)) __PYX_ERR(4, 1734, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_119CDLIDENTICAL3CROWS, 0, __pyx_mstate_global->__pyx_n_u_CDLIDENTICAL3CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[61])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1766, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLIDENTICAL3CROWS, __pyx_t_3) < (0)) __PYX_ERR(4, 1766, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_121CDLINNECK, 0, __pyx_mstate_global->__pyx_n_u_CDLINNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[62])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1798, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLINNECK, __pyx_t_3) < (0)) __PYX_ERR(4, 1798, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_123CDLINVERTEDHAMMER, 0, __pyx_mstate_global->__pyx_n_u_CDLINVERTEDHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[63])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLINVERTEDHAMMER, __pyx_t_3) < (0)) __PYX_ERR(4, 1830, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_125CDLKICKING, 0, __pyx_mstate_global->__pyx_n_u_CDLKICKING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[64])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1862, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLKICKING, __pyx_t_3) < (0)) __PYX_ERR(4, 1862, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_127CDLKICKINGBYLENGTH, 0, __pyx_mstate_global->__pyx_n_u_CDLKICKINGBYLENGTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[65])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLKICKINGBYLENGTH, __pyx_t_3) < (0)) __PYX_ERR(4, 1894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_129CDLLADDERBOTTOM, 0, __pyx_mstate_global->__pyx_n_u_CDLLADDERBOTTOM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[66])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1926, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLLADDERBOTTOM, __pyx_t_3) < (0)) __PYX_ERR(4, 1926, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_131CDLLONGLEGGEDDOJI, 0, __pyx_mstate_global->__pyx_n_u_CDLLONGLEGGEDDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[67])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1958, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLLONGLEGGEDDOJI, __pyx_t_3) < (0)) __PYX_ERR(4, 1958, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_133CDLLONGLINE, 0, __pyx_mstate_global->__pyx_n_u_CDLLONGLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[68])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 1990, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLLONGLINE, __pyx_t_3) < (0)) __PYX_ERR(4, 1990, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_135CDLMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_CDLMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[69])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2022, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMARUBOZU, __pyx_t_3) < (0)) __PYX_ERR(4, 2022, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_137CDLMATCHINGLOW, 0, __pyx_mstate_global->__pyx_n_u_CDLMATCHINGLOW, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[70])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2054, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMATCHINGLOW, __pyx_t_3) < (0)) __PYX_ERR(4, 2054, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2088, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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); #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(4, 2122, __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, 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); #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(4, 2156, __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, 2154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_143CDLMORNINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLMORNINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[73])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLMORNINGSTAR, __pyx_t_3) < (0)) __PYX_ERR(4, 2154, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_145CDLONNECK, 0, __pyx_mstate_global->__pyx_n_u_CDLONNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[74])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLONNECK, __pyx_t_3) < (0)) __PYX_ERR(4, 2188, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_147CDLPIERCING, 0, __pyx_mstate_global->__pyx_n_u_CDLPIERCING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[75])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLPIERCING, __pyx_t_3) < (0)) __PYX_ERR(4, 2220, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_149CDLRICKSHAWMAN, 0, __pyx_mstate_global->__pyx_n_u_CDLRICKSHAWMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[76])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLRICKSHAWMAN, __pyx_t_3) < (0)) __PYX_ERR(4, 2252, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_151CDLRISEFALL3METHODS, 0, __pyx_mstate_global->__pyx_n_u_CDLRISEFALL3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[77])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLRISEFALL3METHODS, __pyx_t_3) < (0)) __PYX_ERR(4, 2284, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_153CDLSEPARATINGLINES, 0, __pyx_mstate_global->__pyx_n_u_CDLSEPARATINGLINES, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[78])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2316, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSEPARATINGLINES, __pyx_t_3) < (0)) __PYX_ERR(4, 2316, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_155CDLSHOOTINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLSHOOTINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[79])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSHOOTINGSTAR, __pyx_t_3) < (0)) __PYX_ERR(4, 2348, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_157CDLSHORTLINE, 0, __pyx_mstate_global->__pyx_n_u_CDLSHORTLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[80])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2380, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSHORTLINE, __pyx_t_3) < (0)) __PYX_ERR(4, 2380, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_159CDLSPINNINGTOP, 0, __pyx_mstate_global->__pyx_n_u_CDLSPINNINGTOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[81])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2412, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSPINNINGTOP, __pyx_t_3) < (0)) __PYX_ERR(4, 2412, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_161CDLSTALLEDPATTERN, 0, __pyx_mstate_global->__pyx_n_u_CDLSTALLEDPATTERN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[82])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2444, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSTALLEDPATTERN, __pyx_t_3) < (0)) __PYX_ERR(4, 2444, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_163CDLSTICKSANDWICH, 0, __pyx_mstate_global->__pyx_n_u_CDLSTICKSANDWICH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[83])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLSTICKSANDWICH, __pyx_t_3) < (0)) __PYX_ERR(4, 2476, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_165CDLTAKURI, 0, __pyx_mstate_global->__pyx_n_u_CDLTAKURI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[84])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2508, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTAKURI, __pyx_t_3) < (0)) __PYX_ERR(4, 2508, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_167CDLTASUKIGAP, 0, __pyx_mstate_global->__pyx_n_u_CDLTASUKIGAP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[85])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2540, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTASUKIGAP, __pyx_t_3) < (0)) __PYX_ERR(4, 2540, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_169CDLTHRUSTING, 0, __pyx_mstate_global->__pyx_n_u_CDLTHRUSTING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[86])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTHRUSTING, __pyx_t_3) < (0)) __PYX_ERR(4, 2572, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_171CDLTRISTAR, 0, __pyx_mstate_global->__pyx_n_u_CDLTRISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[87])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2604, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLTRISTAR, __pyx_t_3) < (0)) __PYX_ERR(4, 2604, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_173CDLUNIQUE3RIVER, 0, __pyx_mstate_global->__pyx_n_u_CDLUNIQUE3RIVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[88])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2636, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLUNIQUE3RIVER, __pyx_t_3) < (0)) __PYX_ERR(4, 2636, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_175CDLUPSIDEGAP2CROWS, 0, __pyx_mstate_global->__pyx_n_u_CDLUPSIDEGAP2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[89])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLUPSIDEGAP2CROWS, __pyx_t_3) < (0)) __PYX_ERR(4, 2668, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_177CDLXSIDEGAP3METHODS, 0, __pyx_mstate_global->__pyx_n_u_CDLXSIDEGAP3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[90])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2700, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CDLXSIDEGAP3METHODS, __pyx_t_3) < (0)) __PYX_ERR(4, 2700, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_179CEIL, 0, __pyx_mstate_global->__pyx_n_u_CEIL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[91])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2732, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CEIL, __pyx_t_3) < (0)) __PYX_ERR(4, 2732, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2763, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_181CMO, 0, __pyx_mstate_global->__pyx_n_u_CMO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[92])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_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_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2794, __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, 2792, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_183CORREL, 0, __pyx_mstate_global->__pyx_n_u_CORREL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[93])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2792, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_CORREL, __pyx_t_3) < (0)) __PYX_ERR(4, 2792, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_185COS, 0, __pyx_mstate_global->__pyx_n_u_COS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[94])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_COS, __pyx_t_3) < (0)) __PYX_ERR(4, 2825, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_187COSH, 0, __pyx_mstate_global->__pyx_n_u_COSH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[95])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2854, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_COSH, __pyx_t_3) < (0)) __PYX_ERR(4, 2854, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2885, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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); #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_191DIV, 0, __pyx_mstate_global->__pyx_n_u_DIV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[97])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2914, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DIV, __pyx_t_3) < (0)) __PYX_ERR(4, 2914, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2947, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 2945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_193DX, 0, __pyx_mstate_global->__pyx_n_u_DX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[98])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_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_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2980, __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, 2978, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_195EMA, 0, __pyx_mstate_global->__pyx_n_u_EMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[99])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 2978, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_EMA, __pyx_t_3) < (0)) __PYX_ERR(4, 2978, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_197EXP, 0, __pyx_mstate_global->__pyx_n_u_EXP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[100])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3009, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_EXP, __pyx_t_3) < (0)) __PYX_ERR(4, 3009, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_199FLOOR, 0, __pyx_mstate_global->__pyx_n_u_FLOOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[101])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3038, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_FLOOR, __pyx_t_3) < (0)) __PYX_ERR(4, 3038, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_201HT_DCPERIOD, 0, __pyx_mstate_global->__pyx_n_u_HT_DCPERIOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[102])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3067, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_DCPERIOD, __pyx_t_3) < (0)) __PYX_ERR(4, 3067, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_203HT_DCPHASE, 0, __pyx_mstate_global->__pyx_n_u_HT_DCPHASE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[103])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3096, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_DCPHASE, __pyx_t_3) < (0)) __PYX_ERR(4, 3096, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_205HT_PHASOR, 0, __pyx_mstate_global->__pyx_n_u_HT_PHASOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[104])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_PHASOR, __pyx_t_3) < (0)) __PYX_ERR(4, 3125, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_207HT_SINE, 0, __pyx_mstate_global->__pyx_n_u_HT_SINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[105])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_SINE, __pyx_t_3) < (0)) __PYX_ERR(4, 3157, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_209HT_TRENDLINE, 0, __pyx_mstate_global->__pyx_n_u_HT_TRENDLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[106])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_TRENDLINE, __pyx_t_3) < (0)) __PYX_ERR(4, 3189, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_211HT_TRENDMODE, 0, __pyx_mstate_global->__pyx_n_u_HT_TRENDMODE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[107])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3218, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_HT_TRENDMODE, __pyx_t_3) < (0)) __PYX_ERR(4, 3218, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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); #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_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3281, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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); #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_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3312, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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); #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_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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); #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_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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); #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_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 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_225LN, 0, __pyx_mstate_global->__pyx_n_u_LN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[114])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LN, __pyx_t_3) < (0)) __PYX_ERR(4, 3434, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_227LOG10, 0, __pyx_mstate_global->__pyx_n_u_LOG10, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[115])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3463, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_LOG10, __pyx_t_3) < (0)) __PYX_ERR(4, 3463, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_16 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __pyx_t_4 = PyTuple_Pack(2, __pyx_t_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_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); #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_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 3565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_15 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 3565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 3565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_16 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_16)) __PYX_ERR(4, 3565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __pyx_t_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_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); #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; __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_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); #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 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3644, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __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_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_20 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_20)) __PYX_ERR(4, 3679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_20); __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 3679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_19 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyTuple_Pack(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_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3714, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_245MEDPRICE, 0, __pyx_mstate_global->__pyx_n_u_MEDPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[124])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3777, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MEDPRICE, __pyx_t_19) < (0)) __PYX_ERR(4, 3777, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3809, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3874, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3906, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3937, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 3971, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4005, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4045, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4078, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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); #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; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_267MULT, 0, __pyx_mstate_global->__pyx_n_u_MULT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[135])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_MULT, __pyx_t_19) < (0)) __PYX_ERR(4, 4139, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_16 = PyTuple_Pack(1, __pyx_t_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); #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; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_271OBV, 0, __pyx_mstate_global->__pyx_n_u_OBV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[137])); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_OBV, __pyx_t_19) < (0)) __PYX_ERR(4, 4203, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_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_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); #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; __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_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); #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; __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_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_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_4 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_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); #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_293SIN, 0, __pyx_mstate_global->__pyx_n_u_SIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[148])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4559, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SIN, __pyx_t_6) < (0)) __PYX_ERR(4, 4559, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __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 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_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4619, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 4617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_297SMA, 0, __pyx_mstate_global->__pyx_n_u_SMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[150])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SMA, __pyx_t_6) < (0)) __PYX_ERR(4, 4617, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_299SQRT, 0, __pyx_mstate_global->__pyx_n_u_SQRT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[151])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4648, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SQRT, __pyx_t_6) < (0)) __PYX_ERR(4, 4648, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 4679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_3 = PyTuple_Pack(2, __pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4677, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_301STDDEV, 0, __pyx_mstate_global->__pyx_n_u_STDDEV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[152])); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 4677, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_8); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_8, __pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STDDEV, __pyx_t_8) < (0)) __PYX_ERR(4, 4677, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_8)) __PYX_ERR(4, 4711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4711, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_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_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_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_Pack(3, __pyx_t_4, __pyx_t_19, __pyx_t_15); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_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_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STOCHF, __pyx_t_15) < (0)) __PYX_ERR(4, 4749, __pyx_L1_error) __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_15 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_15)) __PYX_ERR(4, 4789, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 4789, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4789, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_4 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4789, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyTuple_Pack(4, __pyx_t_15, __pyx_t_6, __pyx_t_19, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4787, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_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_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_STOCHRSI, __pyx_t_4) < (0)) __PYX_ERR(4, 4787, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_309SUB, 0, __pyx_mstate_global->__pyx_n_u_SUB, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[156])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4824, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SUB, __pyx_t_4) < (0)) __PYX_ERR(4, 4824, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_311SUM, 0, __pyx_mstate_global->__pyx_n_u_SUM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[157])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_SUM, __pyx_t_4) < (0)) __PYX_ERR(4, 4855, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 4888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); #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_315TAN, 0, __pyx_mstate_global->__pyx_n_u_TAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[159])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4918, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TAN, __pyx_t_3) < (0)) __PYX_ERR(4, 4918, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_317TANH, 0, __pyx_mstate_global->__pyx_n_u_TANH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[160])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4947, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TANH, __pyx_t_3) < (0)) __PYX_ERR(4, 4947, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_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_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 4976, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_319TEMA, 0, __pyx_mstate_global->__pyx_n_u_TEMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[161])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 4976, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TEMA, __pyx_t_3) < (0)) __PYX_ERR(4, 4976, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_321TRANGE, 0, __pyx_mstate_global->__pyx_n_u_TRANGE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[162])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5007, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TRANGE, __pyx_t_3) < (0)) __PYX_ERR(4, 5007, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_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_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 5038, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_323TRIMA, 0, __pyx_mstate_global->__pyx_n_u_TRIMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[163])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5038, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TRIMA, __pyx_t_3) < (0)) __PYX_ERR(4, 5038, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_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_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 5069, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_325TRIX, 0, __pyx_mstate_global->__pyx_n_u_TRIX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[164])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5069, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TRIX, __pyx_t_3) < (0)) __PYX_ERR(4, 5069, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_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_19 = PyTuple_Pack(1, __pyx_t_3); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 5100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_327TSF, 0, __pyx_mstate_global->__pyx_n_u_TSF, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[165])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_19); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TSF, __pyx_t_3) < (0)) __PYX_ERR(4, 5100, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_329TYPPRICE, 0, __pyx_mstate_global->__pyx_n_u_TYPPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[166])); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TYPPRICE, __pyx_t_3) < (0)) __PYX_ERR(4, 5131, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(4, 5164, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 5164, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 5164, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = PyTuple_Pack(3, __pyx_t_3, __pyx_t_19, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_331ULTOSC, 0, __pyx_mstate_global->__pyx_n_u_ULTOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[167])); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 5162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ULTOSC, __pyx_t_4) < (0)) __PYX_ERR(4, 5162, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(4, 5199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __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); #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_335WCLPRICE, 0, __pyx_mstate_global->__pyx_n_u_WCLPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[169])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_WCLPRICE, __pyx_t_6) < (0)) __PYX_ERR(4, 5229, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_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_19 = PyTuple_Pack(1, __pyx_t_6); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 5260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_337WILLR, 0, __pyx_mstate_global->__pyx_n_u_WILLR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[170])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_19); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_WILLR, __pyx_t_6) < (0)) __PYX_ERR(4, 5260, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_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_19 = PyTuple_Pack(1, __pyx_t_6); if (unlikely(!__pyx_t_19)) __PYX_ERR(4, 5293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_339WMA, 0, __pyx_mstate_global->__pyx_n_u_WMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[171])); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_19); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_WMA, __pyx_t_6) < (0)) __PYX_ERR(4, 5293, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyList_Pack(161, __pyx_mstate_global->__pyx_n_u_ACCBANDS, __pyx_mstate_global->__pyx_n_u_ACOS, __pyx_mstate_global->__pyx_n_u_AD, __pyx_mstate_global->__pyx_n_u_ADD, __pyx_mstate_global->__pyx_n_u_ADOSC, __pyx_mstate_global->__pyx_n_u_ADX, __pyx_mstate_global->__pyx_n_u_ADXR, __pyx_mstate_global->__pyx_n_u_APO, __pyx_mstate_global->__pyx_n_u_AROON, __pyx_mstate_global->__pyx_n_u_AROONOSC, __pyx_mstate_global->__pyx_n_u_ASIN, __pyx_mstate_global->__pyx_n_u_ATAN, __pyx_mstate_global->__pyx_n_u_ATR, __pyx_mstate_global->__pyx_n_u_AVGPRICE, __pyx_mstate_global->__pyx_n_u_AVGDEV, __pyx_mstate_global->__pyx_n_u_BBANDS, __pyx_mstate_global->__pyx_n_u_BETA, __pyx_mstate_global->__pyx_n_u_BOP, __pyx_mstate_global->__pyx_n_u_CCI, __pyx_mstate_global->__pyx_n_u_CDL2CROWS, __pyx_mstate_global->__pyx_n_u_CDL3BLACKCROWS, __pyx_mstate_global->__pyx_n_u_CDL3INSIDE, __pyx_mstate_global->__pyx_n_u_CDL3LINESTRIKE, __pyx_mstate_global->__pyx_n_u_CDL3OUTSIDE, __pyx_mstate_global->__pyx_n_u_CDL3STARSINSOUTH, __pyx_mstate_global->__pyx_n_u_CDL3WHITESOLDIERS, __pyx_mstate_global->__pyx_n_u_CDLABANDONEDBABY, __pyx_mstate_global->__pyx_n_u_CDLADVANCEBLOCK, __pyx_mstate_global->__pyx_n_u_CDLBELTHOLD, __pyx_mstate_global->__pyx_n_u_CDLBREAKAWAY, __pyx_mstate_global->__pyx_n_u_CDLCLOSINGMARUBOZU, __pyx_mstate_global->__pyx_n_u_CDLCONCEALBABYSWALL, __pyx_mstate_global->__pyx_n_u_CDLCOUNTERATTACK, __pyx_mstate_global->__pyx_n_u_CDLDARKCLOUDCOVER, __pyx_mstate_global->__pyx_n_u_CDLDOJI, __pyx_mstate_global->__pyx_n_u_CDLDOJISTAR, __pyx_mstate_global->__pyx_n_u_CDLDRAGONFLYDOJI, __pyx_mstate_global->__pyx_n_u_CDLENGULFING, __pyx_mstate_global->__pyx_n_u_CDLEVENINGDOJISTAR, __pyx_mstate_global->__pyx_n_u_CDLEVENINGSTAR, __pyx_mstate_global->__pyx_n_u_CDLGAPSIDESIDEWHITE, __pyx_mstate_global->__pyx_n_u_CDLGRAVESTONEDOJI, __pyx_mstate_global->__pyx_n_u_CDLHAMMER, __pyx_mstate_global->__pyx_n_u_CDLHANGINGMAN, __pyx_mstate_global->__pyx_n_u_CDLHARAMI, __pyx_mstate_global->__pyx_n_u_CDLHARAMICROSS, __pyx_mstate_global->__pyx_n_u_CDLHIGHWAVE, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKE, __pyx_mstate_global->__pyx_n_u_CDLHIKKAKEMOD, __pyx_mstate_global->__pyx_n_u_CDLHOMINGPIGEON, __pyx_mstate_global->__pyx_n_u_CDLIDENTICAL3CROWS, __pyx_mstate_global->__pyx_n_u_CDLINNECK, __pyx_mstate_global->__pyx_n_u_CDLINVERTEDHAMMER, __pyx_mstate_global->__pyx_n_u_CDLKICKING, __pyx_mstate_global->__pyx_n_u_CDLKICKINGBYLENGTH, __pyx_mstate_global->__pyx_n_u_CDLLADDERBOTTOM, __pyx_mstate_global->__pyx_n_u_CDLLONGLEGGEDDOJI, __pyx_mstate_global->__pyx_n_u_CDLLONGLINE, __pyx_mstate_global->__pyx_n_u_CDLMARUBOZU, __pyx_mstate_global->__pyx_n_u_CDLMATCHINGLOW, __pyx_mstate_global->__pyx_n_u_CDLMATHOLD, __pyx_mstate_global->__pyx_n_u_CDLMORNINGDOJISTAR, __pyx_mstate_global->__pyx_n_u_CDLMORNINGSTAR, __pyx_mstate_global->__pyx_n_u_CDLONNECK, __pyx_mstate_global->__pyx_n_u_CDLPIERCING, __pyx_mstate_global->__pyx_n_u_CDLRICKSHAWMAN, __pyx_mstate_global->__pyx_n_u_CDLRISEFALL3METHODS, __pyx_mstate_global->__pyx_n_u_CDLSEPARATINGLINES, __pyx_mstate_global->__pyx_n_u_CDLSHOOTINGSTAR, __pyx_mstate_global->__pyx_n_u_CDLSHORTLINE, __pyx_mstate_global->__pyx_n_u_CDLSPINNINGTOP, __pyx_mstate_global->__pyx_n_u_CDLSTALLEDPATTERN, __pyx_mstate_global->__pyx_n_u_CDLSTICKSANDWICH, __pyx_mstate_global->__pyx_n_u_CDLTAKURI, __pyx_mstate_global->__pyx_n_u_CDLTASUKIGAP, __pyx_mstate_global->__pyx_n_u_CDLTHRUSTING, __pyx_mstate_global->__pyx_n_u_CDLTRISTAR, __pyx_mstate_global->__pyx_n_u_CDLUNIQUE3RIVER, __pyx_mstate_global->__pyx_n_u_CDLUPSIDEGAP2CROWS, __pyx_mstate_global->__pyx_n_u_CDLXSIDEGAP3METHODS, __pyx_mstate_global->__pyx_n_u_CEIL, __pyx_mstate_global->__pyx_n_u_CMO, __pyx_mstate_global->__pyx_n_u_CORREL, __pyx_mstate_global->__pyx_n_u_COS, __pyx_mstate_global->__pyx_n_u_COSH, __pyx_mstate_global->__pyx_n_u_DEMA, __pyx_mstate_global->__pyx_n_u_DIV, __pyx_mstate_global->__pyx_n_u_DX, __pyx_mstate_global->__pyx_n_u_EMA, __pyx_mstate_global->__pyx_n_u_EXP, __pyx_mstate_global->__pyx_n_u_FLOOR, __pyx_mstate_global->__pyx_n_u_HT_DCPERIOD, __pyx_mstate_global->__pyx_n_u_HT_DCPHASE, __pyx_mstate_global->__pyx_n_u_HT_PHASOR, __pyx_mstate_global->__pyx_n_u_HT_SINE, __pyx_mstate_global->__pyx_n_u_HT_TRENDLINE, __pyx_mstate_global->__pyx_n_u_HT_TRENDMODE, __pyx_mstate_global->__pyx_n_u_IMI, __pyx_mstate_global->__pyx_n_u_KAMA, __pyx_mstate_global->__pyx_n_u_LINEARREG, __pyx_mstate_global->__pyx_n_u_LINEARREG_ANGLE, __pyx_mstate_global->__pyx_n_u_LINEARREG_INTERCEPT, __pyx_mstate_global->__pyx_n_u_LINEARREG_SLOPE, __pyx_mstate_global->__pyx_n_u_LN, __pyx_mstate_global->__pyx_n_u_LOG10, __pyx_mstate_global->__pyx_n_u_MA, __pyx_mstate_global->__pyx_n_u_MACD, __pyx_mstate_global->__pyx_n_u_MACDEXT, __pyx_mstate_global->__pyx_n_u_MACDFIX, __pyx_mstate_global->__pyx_n_u_MAMA, __pyx_mstate_global->__pyx_n_u_MAVP, __pyx_mstate_global->__pyx_n_u_MAX, __pyx_mstate_global->__pyx_n_u_MAXINDEX, __pyx_mstate_global->__pyx_n_u_MEDPRICE, __pyx_mstate_global->__pyx_n_u_MFI, __pyx_mstate_global->__pyx_n_u_MIDPOINT, __pyx_mstate_global->__pyx_n_u_MIDPRICE, __pyx_mstate_global->__pyx_n_u_MIN, __pyx_mstate_global->__pyx_n_u_MININDEX, __pyx_mstate_global->__pyx_n_u_MINMAX, __pyx_mstate_global->__pyx_n_u_MINMAXINDEX, __pyx_mstate_global->__pyx_n_u_MINUS_DI, __pyx_mstate_global->__pyx_n_u_MINUS_DM, __pyx_mstate_global->__pyx_n_u_MOM, __pyx_mstate_global->__pyx_n_u_MULT, __pyx_mstate_global->__pyx_n_u_NATR, __pyx_mstate_global->__pyx_n_u_OBV, __pyx_mstate_global->__pyx_n_u_PLUS_DI, __pyx_mstate_global->__pyx_n_u_PLUS_DM, __pyx_mstate_global->__pyx_n_u_PPO, __pyx_mstate_global->__pyx_n_u_ROC, __pyx_mstate_global->__pyx_n_u_ROCP, __pyx_mstate_global->__pyx_n_u_ROCR, __pyx_mstate_global->__pyx_n_u_ROCR100, __pyx_mstate_global->__pyx_n_u_RSI, __pyx_mstate_global->__pyx_n_u_SAR, __pyx_mstate_global->__pyx_n_u_SAREXT, __pyx_mstate_global->__pyx_n_u_SIN, __pyx_mstate_global->__pyx_n_u_SINH, __pyx_mstate_global->__pyx_n_u_SMA, __pyx_mstate_global->__pyx_n_u_SQRT, __pyx_mstate_global->__pyx_n_u_STDDEV, __pyx_mstate_global->__pyx_n_u_STOCH, __pyx_mstate_global->__pyx_n_u_STOCHF, __pyx_mstate_global->__pyx_n_u_STOCHRSI, __pyx_mstate_global->__pyx_n_u_SUB, __pyx_mstate_global->__pyx_n_u_SUM, __pyx_mstate_global->__pyx_n_u_T3, __pyx_mstate_global->__pyx_n_u_TAN, __pyx_mstate_global->__pyx_n_u_TANH, __pyx_mstate_global->__pyx_n_u_TEMA, __pyx_mstate_global->__pyx_n_u_TRANGE, __pyx_mstate_global->__pyx_n_u_TRIMA, __pyx_mstate_global->__pyx_n_u_TRIX, __pyx_mstate_global->__pyx_n_u_TSF, __pyx_mstate_global->__pyx_n_u_TYPPRICE, __pyx_mstate_global->__pyx_n_u_ULTOSC, __pyx_mstate_global->__pyx_n_u_VAR, __pyx_mstate_global->__pyx_n_u_WCLPRICE, __pyx_mstate_global->__pyx_n_u_WILLR, __pyx_mstate_global->__pyx_n_u_WMA); if (unlikely(!__pyx_t_6)) __PYX_ERR(4, 5324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_FUNCTION_NAMES, __pyx_t_6) < (0)) __PYX_ERR(4, 5324, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_math, 0, 0, __pyx_mstate_global->__pyx_kp_u_talib_math, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error) __pyx_t_6 = __pyx_t_1; __Pyx_GOTREF(__pyx_t_6); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_math, __pyx_t_6) < (0)) __PYX_ERR(2, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_threading, 0, 0, __pyx_mstate_global->__pyx_kp_u_talib_threading, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) __pyx_t_6 = __pyx_t_1; __Pyx_GOTREF(__pyx_t_6); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_threading, __pyx_t_6) < (0)) __PYX_ERR(2, 5, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_24, &__pyx_t_25); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_24); __Pyx_XGOTREF(__pyx_t_25); /*try:*/ { { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_OrderedDict}; __pyx_t_26 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_collections, __pyx_imported_names, 1, __pyx_mstate_global->__pyx_kp_u_talib_collections, -1); if (unlikely(!__pyx_t_26)) __PYX_ERR(2, 7, __pyx_L11_error) } __pyx_t_6 = __pyx_t_26; __Pyx_GOTREF(__pyx_t_6); { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_OrderedDict}; __pyx_t_18 = 0; { __pyx_t_19 = __Pyx_ImportFrom(__pyx_t_6, __pyx_imported_names[__pyx_t_18]); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 7, __pyx_L11_error) __Pyx_GOTREF(__pyx_t_19); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_18], __pyx_t_19) < (0)) __PYX_ERR(2, 7, __pyx_L11_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; } } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __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; __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_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_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __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_19, &__pyx_t_4) < 0) __PYX_ERR(2, 8, __pyx_L13_except_error) __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_19); __Pyx_XGOTREF(__pyx_t_4); { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_OrderedDict}; __pyx_t_26 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_ordereddict, __pyx_imported_names, 1, __pyx_mstate_global->__pyx_kp_u_talib_ordereddict, -1); if (unlikely(!__pyx_t_26)) __PYX_ERR(2, 9, __pyx_L13_except_error) } __pyx_t_3 = __pyx_t_26; __Pyx_GOTREF(__pyx_t_3); { PyObject* const __pyx_imported_names[] = {__pyx_mstate_global->__pyx_n_u_OrderedDict}; __pyx_t_18 = 0; { __pyx_t_15 = __Pyx_ImportFrom(__pyx_t_3, __pyx_imported_names[__pyx_t_18]); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 9, __pyx_L13_except_error) __Pyx_GOTREF(__pyx_t_15); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_imported_names[__pyx_t_18], __pyx_t_15) < (0)) __PYX_ERR(2, 9, __pyx_L13_except_error) __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L12_exception_handled; } goto __pyx_L13_except_error; __pyx_L13_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__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_24); __Pyx_XGIVEREF(__pyx_t_25); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_24, __pyx_t_25); __pyx_L16_try_end:; } __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_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_23 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(2, 18, __pyx_L1_error) __pyx_t_4 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_price, __pyx_mstate_global->__pyx_n_u_close) < (0)) __PYX_ERR(2, 21, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_price0, __pyx_mstate_global->__pyx_n_u_high) < (0)) __PYX_ERR(2, 21, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_price1, __pyx_mstate_global->__pyx_n_u_low) < (0)) __PYX_ERR(2, 21, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_periods, __pyx_mstate_global->__pyx_n_u_periods) < (0)) __PYX_ERR(2, 21, __pyx_L1_error) if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_INPUT_PRICE_SERIES_DEFAULTS, __pyx_t_4) < (0)) __PYX_ERR(2, 21, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyList_Pack(1, ((PyObject *)(&PyDict_Type))); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_INPUT_ARRAYS_TYPES, __pyx_t_4) < (0)) __PYX_ERR(2, 27, __pyx_L1_error) __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_25, &__pyx_t_24, &__pyx_t_1); __Pyx_XGOTREF(__pyx_t_25); __Pyx_XGOTREF(__pyx_t_24); __Pyx_XGOTREF(__pyx_t_1); /*try:*/ { __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_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_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_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_ARRAY_TYPES); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 34, __pyx_L19_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pandas); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 34, __pyx_L19_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_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_19, __pyx_mstate_global->__pyx_n_u_pandas); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 35, __pyx_L19_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_DataFrame); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 35, __pyx_L19_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME, __pyx_t_6) < (0)) __PYX_ERR(2, 35, __pyx_L19_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_pandas); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 36, __pyx_L19_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Series); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 36, __pyx_L19_error) __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES, __pyx_t_19) < (0)) __PYX_ERR(2, 36, __pyx_L19_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; } __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0; __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L24_try_end; __pyx_L19_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_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_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __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_19, &__pyx_t_6, &__pyx_t_4) < 0) __PYX_ERR(2, 37, __pyx_L21_except_error) __Pyx_XGOTREF(__pyx_t_19); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_import_error, __pyx_t_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_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_DATAFRAME, Py_None) < (0)) __PYX_ERR(2, 46, __pyx_L21_except_error) if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_PANDAS_SERIES, Py_None) < (0)) __PYX_ERR(2, 47, __pyx_L21_except_error) __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L20_exception_handled; } goto __pyx_L21_except_error; __pyx_L21_except_error:; __Pyx_XGIVEREF(__pyx_t_25); __Pyx_XGIVEREF(__pyx_t_24); __Pyx_XGIVEREF(__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_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_24, &__pyx_t_25); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_24); __Pyx_XGOTREF(__pyx_t_25); /*try:*/ { __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_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_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_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_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_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_polars); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 54, __pyx_L40_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DataFrame); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 54, __pyx_L40_error) __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME, __pyx_t_19) < (0)) __PYX_ERR(2, 54, __pyx_L40_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_GetModuleGlobalName(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_polars); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 55, __pyx_L40_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_Series); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 55, __pyx_L40_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_SERIES, __pyx_t_6) < (0)) __PYX_ERR(2, 55, __pyx_L40_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0; __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_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_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __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_19, &__pyx_t_4) < 0) __PYX_ERR(2, 56, __pyx_L42_except_error) __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_19); __Pyx_XGOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_import_error, __pyx_t_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_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_DATAFRAME, Py_None) < (0)) __PYX_ERR(2, 65, __pyx_L42_except_error) if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_POLARS_SERIES, Py_None) < (0)) __PYX_ERR(2, 66, __pyx_L42_except_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L41_exception_handled; } goto __pyx_L42_except_error; __pyx_L42_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_24); __Pyx_XGIVEREF(__pyx_t_25); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_24, __pyx_t_25); goto __pyx_L1_error; __pyx_L41_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_24); __Pyx_XGIVEREF(__pyx_t_25); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_24, __pyx_t_25); __pyx_L45_try_end:; } __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_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_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_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_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_L61; } /*else*/ { __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_345str2bytes, 0, __pyx_mstate_global->__pyx_n_u_str2bytes, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[174])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 82, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_str2bytes, __pyx_t_4) < (0)) __PYX_ERR(2, 82, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_347bytes2str, 0, __pyx_mstate_global->__pyx_n_u_bytes2str, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[175])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 85, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_bytes2str, __pyx_t_4) < (0)) __PYX_ERR(2, 85, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __pyx_L61:; __pyx_t_4 = __Pyx_PEP560_update_bases(__pyx_mstate_global->__pyx_tuple[8]); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 88, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_19 = __Pyx_CalculateMetaclass(NULL, __pyx_t_4); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 88, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_6 = __Pyx_Py3MetaclassPrepare(__pyx_t_19, __pyx_t_4, __pyx_mstate_global->__pyx_n_u_Function, __pyx_mstate_global->__pyx_n_u_Function, (PyObject *) NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_kp_u_This_is_a_pythonic_wrapper_arou); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 88, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4 != __pyx_mstate_global->__pyx_tuple[8]) { if (unlikely((PyDict_SetItemString(__pyx_t_6, "__orig_bases__", __pyx_mstate_global->__pyx_tuple[8]) < 0))) __PYX_ERR(2, 88, __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); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_init, __pyx_t_3) < (0)) __PYX_ERR(2, 117, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_15 = NULL; __pyx_t_8 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_3__local, 0, __pyx_mstate_global->__pyx_n_u_Function___local, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[177])); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 130, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_8); #endif __pyx_t_7 = 1; { PyObject *__pyx_callargs[2] = {__pyx_t_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; __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_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; __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_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_15 = NULL; __pyx_t_8 = PyObject_GetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_get_input_names); if (unlikely(!__pyx_t_8)) { PyErr_Clear(); __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_get_input_names); } if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 214, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_2 = PyObject_GetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_set_input_names); if (unlikely(!__pyx_t_2)) { PyErr_Clear(); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_set_input_names); } 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_mstate_global->__pyx_n_u_Function_get_input_arrays, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[183])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 216, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_get_input_arrays, __pyx_t_3) < (0)) __PYX_ERR(2, 216, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_17set_input_arrays, 0, __pyx_mstate_global->__pyx_n_u_Function_set_input_arrays, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[184])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_set_input_arrays, __pyx_t_3) < (0)) __PYX_ERR(2, 227, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_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_8, __pyx_mstate_global->__pyx_n_u_get_input_arrays); } 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_15, __pyx_mstate_global->__pyx_n_u_set_input_arrays); } 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_8, __pyx_mstate_global->__pyx_n_u_get_parameters); } if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_2 = PyObject_GetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_set_parameters); if (unlikely(!__pyx_t_2)) { PyErr_Clear(); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_set_parameters); } 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; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_23set_function_args, 0, __pyx_mstate_global->__pyx_n_u_Function_set_function_args, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[187])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_set_function_args, __pyx_t_3) < (0)) __PYX_ERR(2, 301, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_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; __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_mstate_global->__pyx_n_u_Function_run, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[191])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_mstate_global->__pyx_tuple[9]); if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_run, __pyx_t_3) < (0)) __PYX_ERR(2, 399, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_33__call__, 0, __pyx_mstate_global->__pyx_n_u_Function___call, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[192])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 411, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_call, __pyx_t_3) < (0)) __PYX_ERR(2, 411, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_35__input_price_series_names, 0, __pyx_mstate_global->__pyx_n_u_Function___input_price_series_na, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[193])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Function__input_price_series_na, __pyx_t_3) < (0)) __PYX_ERR(2, 477, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_37__call_function, 0, __pyx_mstate_global->__pyx_n_u_Function___call_function, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[194])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 489, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Function__call_function, __pyx_t_3) < (0)) __PYX_ERR(2, 489, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_39__check_opt_input_value, 0, __pyx_mstate_global->__pyx_n_u_Function___check_opt_input_value, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[195])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 520, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Function__check_opt_input_value, __pyx_t_3) < (0)) __PYX_ERR(2, 520, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_41__get_opt_input_value, 0, __pyx_mstate_global->__pyx_n_u_Function___get_opt_input_value, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[196])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_Function__get_opt_input_value, __pyx_t_3) < (0)) __PYX_ERR(2, 535, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_43__repr__, 0, __pyx_mstate_global->__pyx_n_u_Function___repr, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[197])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 545, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_repr, __pyx_t_3) < (0)) __PYX_ERR(2, 545, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_45__unicode__, 0, __pyx_mstate_global->__pyx_n_u_Function___unicode, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[198])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 548, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_unicode, __pyx_t_3) < (0)) __PYX_ERR(2, 548, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_8Function_47__str__, 0, __pyx_mstate_global->__pyx_n_u_Function___str, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[199])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 551, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (__Pyx_SetNameInClass(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_str, __pyx_t_3) < (0)) __PYX_ERR(2, 551, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_Py3ClassCreate(__pyx_t_19, __pyx_mstate_global->__pyx_n_u_Function, __pyx_t_4, __pyx_t_6, NULL, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 88, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_3); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_Function, __pyx_t_3) < (0)) __PYX_ERR(2, 88, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_349_ta_getGroupTable, 0, __pyx_mstate_global->__pyx_n_u_ta_getGroupTable, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[200])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getGroupTable, __pyx_t_4) < (0)) __PYX_ERR(2, 565, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_351_ta_getFuncTable, 0, __pyx_mstate_global->__pyx_n_u_ta_getFuncTable, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[201])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getFuncTable, __pyx_t_4) < (0)) __PYX_ERR(2, 577, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_353__get_flags, 0, __pyx_mstate_global->__pyx_n_u_get_flags, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[202])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 589, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_get_flags, __pyx_t_4) < (0)) __PYX_ERR(2, 589, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 615, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_16777216, __pyx_mstate_global->__pyx_kp_u_Output_scale_same_as_input) < (0)) __PYX_ERR(2, 615, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_67108864, __pyx_mstate_global->__pyx_kp_u_Output_is_over_volume) < (0)) __PYX_ERR(2, 615, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_134217728, __pyx_mstate_global->__pyx_kp_u_Function_has_an_unstable_period) < (0)) __PYX_ERR(2, 615, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_268435456, __pyx_mstate_global->__pyx_kp_u_Output_is_a_candlestick) < (0)) __PYX_ERR(2, 615, __pyx_L1_error) if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_FUNC_FLAGS, __pyx_t_4) < (0)) __PYX_ERR(2, 614, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 623, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_n_u_open) < (0)) __PYX_ERR(2, 623, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_2, __pyx_mstate_global->__pyx_n_u_high) < (0)) __PYX_ERR(2, 623, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_4, __pyx_mstate_global->__pyx_n_u_low) < (0)) __PYX_ERR(2, 623, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_8, __pyx_mstate_global->__pyx_n_u_close) < (0)) __PYX_ERR(2, 623, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_16, __pyx_mstate_global->__pyx_n_u_volume) < (0)) __PYX_ERR(2, 623, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_32, __pyx_mstate_global->__pyx_n_u_openInterest) < (0)) __PYX_ERR(2, 623, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_64, __pyx_mstate_global->__pyx_n_u_timeStamp) < (0)) __PYX_ERR(2, 623, __pyx_L1_error) if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_INPUT_FLAGS, __pyx_t_4) < (0)) __PYX_ERR(2, 622, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(13); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 633, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_n_u_Line) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_2, __pyx_mstate_global->__pyx_kp_u_Dotted_Line) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_4, __pyx_mstate_global->__pyx_kp_u_Dashed_Line) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_8, __pyx_mstate_global->__pyx_n_u_Dot) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_16, __pyx_mstate_global->__pyx_n_u_Histogram) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_32, __pyx_mstate_global->__pyx_kp_u_Pattern_Bool) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_64, __pyx_mstate_global->__pyx_kp_u_Bull_Bear_Pattern_Bearish_0_Neut) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_128, __pyx_mstate_global->__pyx_kp_u_Strength_Pattern_200_100_Bearish) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_256, __pyx_mstate_global->__pyx_kp_u_Output_can_be_positive) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_512, __pyx_mstate_global->__pyx_kp_u_Output_can_be_negative) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_1024, __pyx_mstate_global->__pyx_kp_u_Output_can_be_zero) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_2048, __pyx_mstate_global->__pyx_kp_u_Values_represent_an_upper_limit) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_int_4096, __pyx_mstate_global->__pyx_kp_u_Values_represent_a_lower_limit) < (0)) __PYX_ERR(2, 633, __pyx_L1_error) if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_TA_OUTPUT_FLAGS, __pyx_t_4) < (0)) __PYX_ERR(2, 632, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_355_ta_getFuncInfo, 0, __pyx_mstate_global->__pyx_n_u_ta_getFuncInfo, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[203])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 648, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getFuncInfo, __pyx_t_4) < (0)) __PYX_ERR(2, 648, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_357_ta_getInputParameterInfo, 0, __pyx_mstate_global->__pyx_n_u_ta_getInputParameterInfo, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[204])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 667, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getInputParameterInfo, __pyx_t_4) < (0)) __PYX_ERR(2, 667, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_359_ta_getOptInputParameterInfo, 0, __pyx_mstate_global->__pyx_n_u_ta_getOptInputParameterInfo, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[205])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 688, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ta_getOptInputParameterInfo, __pyx_t_4) < (0)) __PYX_ERR(2, 688, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_361_ta_getOutputParameterInfo, 0, __pyx_mstate_global->__pyx_n_u_ta_getOutputParameterInfo, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[206])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 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_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_23 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_23 == ((int)-1))) __PYX_ERR(5, 7, __pyx_L1_error) __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_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_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_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_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_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_6 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_375stream_ADX, 0, __pyx_mstate_global->__pyx_n_u_stream_ADX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[213])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 183, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ADX, __pyx_t_19) < (0)) __PYX_ERR(5, 183, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_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_6 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 218, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_377stream_ADXR, 0, __pyx_mstate_global->__pyx_n_u_stream_ADXR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[214])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 218, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ADXR, __pyx_t_19) < (0)) __PYX_ERR(5, 218, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyTuple_Pack(3, __pyx_t_19, __pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_379stream_APO, 0, __pyx_mstate_global->__pyx_n_u_stream_APO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[215])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_APO, __pyx_t_4) < (0)) __PYX_ERR(5, 253, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_381stream_AROON, 0, __pyx_mstate_global->__pyx_n_u_stream_AROON, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[216])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AROON, __pyx_t_4) < (0)) __PYX_ERR(5, 284, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 321, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_383stream_AROONOSC, 0, __pyx_mstate_global->__pyx_n_u_stream_AROONOSC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[217])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AROONOSC, __pyx_t_4) < (0)) __PYX_ERR(5, 319, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_385stream_ASIN, 0, __pyx_mstate_global->__pyx_n_u_stream_ASIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[218])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ASIN, __pyx_t_4) < (0)) __PYX_ERR(5, 351, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_387stream_ATAN, 0, __pyx_mstate_global->__pyx_n_u_stream_ATAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[219])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ATAN, __pyx_t_4) < (0)) __PYX_ERR(5, 378, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_389stream_ATR, 0, __pyx_mstate_global->__pyx_n_u_stream_ATR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[220])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ATR, __pyx_t_4) < (0)) __PYX_ERR(5, 405, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_391stream_AVGPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_AVGPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[221])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 440, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AVGPRICE, __pyx_t_4) < (0)) __PYX_ERR(5, 440, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_393stream_AVGDEV, 0, __pyx_mstate_global->__pyx_n_u_stream_AVGDEV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[222])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_AVGDEV, __pyx_t_4) < (0)) __PYX_ERR(5, 476, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_19 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(4, __pyx_t_4, __pyx_t_3, __pyx_t_6, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_461stream_CDLHIKKAKEMOD, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHIKKAKEMOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[256])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1699, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHIKKAKEMOD, __pyx_t_19) < (0)) __PYX_ERR(5, 1699, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_463stream_CDLHOMINGPIGEON, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLHOMINGPIGEON, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[257])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLHOMINGPIGEON, __pyx_t_19) < (0)) __PYX_ERR(5, 1735, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_465stream_CDLIDENTICAL3CROWS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLIDENTICAL3CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[258])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1771, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLIDENTICAL3CROWS, __pyx_t_19) < (0)) __PYX_ERR(5, 1771, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_467stream_CDLINNECK, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLINNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[259])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1807, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLINNECK, __pyx_t_19) < (0)) __PYX_ERR(5, 1807, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_469stream_CDLINVERTEDHAMMER, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLINVERTEDHAMMER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[260])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1843, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLINVERTEDHAMMER, __pyx_t_19) < (0)) __PYX_ERR(5, 1843, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_471stream_CDLKICKING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[261])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1879, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKING, __pyx_t_19) < (0)) __PYX_ERR(5, 1879, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_473stream_CDLKICKINGBYLENGTH, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKINGBYLENGTH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[262])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1915, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLKICKINGBYLENGTH, __pyx_t_19) < (0)) __PYX_ERR(5, 1915, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_475stream_CDLLADDERBOTTOM, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLLADDERBOTTOM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[263])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1951, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLLADDERBOTTOM, __pyx_t_19) < (0)) __PYX_ERR(5, 1951, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_477stream_CDLLONGLEGGEDDOJI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLEGGEDDOJI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[264])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 1987, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLEGGEDDOJI, __pyx_t_19) < (0)) __PYX_ERR(5, 1987, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_479stream_CDLLONGLINE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[265])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2023, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLLONGLINE, __pyx_t_19) < (0)) __PYX_ERR(5, 2023, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_481stream_CDLMARUBOZU, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMARUBOZU, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[266])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2059, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMARUBOZU, __pyx_t_19) < (0)) __PYX_ERR(5, 2059, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_483stream_CDLMATCHINGLOW, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMATCHINGLOW, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[267])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2095, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMATCHINGLOW, __pyx_t_19) < (0)) __PYX_ERR(5, 2095, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = PyFloat_FromDouble(((double)0.5)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2133, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 2131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_485stream_CDLMATHOLD, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMATHOLD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[268])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMATHOLD, __pyx_t_19) < (0)) __PYX_ERR(5, 2131, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2171, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 2169, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_487stream_CDLMORNINGDOJISTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGDOJISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[269])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2169, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGDOJISTAR, __pyx_t_19) < (0)) __PYX_ERR(5, 2169, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = PyFloat_FromDouble(((double)0.3)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 2207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_489stream_CDLMORNINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[270])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLMORNINGSTAR, __pyx_t_19) < (0)) __PYX_ERR(5, 2207, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_491stream_CDLONNECK, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLONNECK, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[271])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2245, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLONNECK, __pyx_t_19) < (0)) __PYX_ERR(5, 2245, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_493stream_CDLPIERCING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLPIERCING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[272])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2281, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLPIERCING, __pyx_t_19) < (0)) __PYX_ERR(5, 2281, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_495stream_CDLRICKSHAWMAN, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLRICKSHAWMAN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[273])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLRICKSHAWMAN, __pyx_t_19) < (0)) __PYX_ERR(5, 2317, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_497stream_CDLRISEFALL3METHODS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLRISEFALL3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[274])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLRISEFALL3METHODS, __pyx_t_19) < (0)) __PYX_ERR(5, 2353, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_499stream_CDLSEPARATINGLINES, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSEPARATINGLINES, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[275])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSEPARATINGLINES, __pyx_t_19) < (0)) __PYX_ERR(5, 2389, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_501stream_CDLSHOOTINGSTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSHOOTINGSTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[276])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSHOOTINGSTAR, __pyx_t_19) < (0)) __PYX_ERR(5, 2425, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_503stream_CDLSHORTLINE, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSHORTLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[277])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2461, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSHORTLINE, __pyx_t_19) < (0)) __PYX_ERR(5, 2461, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_505stream_CDLSPINNINGTOP, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSPINNINGTOP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[278])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2497, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSPINNINGTOP, __pyx_t_19) < (0)) __PYX_ERR(5, 2497, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_507stream_CDLSTALLEDPATTERN, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSTALLEDPATTERN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[279])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2533, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSTALLEDPATTERN, __pyx_t_19) < (0)) __PYX_ERR(5, 2533, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_509stream_CDLSTICKSANDWICH, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLSTICKSANDWICH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[280])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2569, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLSTICKSANDWICH, __pyx_t_19) < (0)) __PYX_ERR(5, 2569, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_511stream_CDLTAKURI, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTAKURI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[281])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTAKURI, __pyx_t_19) < (0)) __PYX_ERR(5, 2605, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_513stream_CDLTASUKIGAP, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTASUKIGAP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[282])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTASUKIGAP, __pyx_t_19) < (0)) __PYX_ERR(5, 2641, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_515stream_CDLTHRUSTING, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTHRUSTING, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[283])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2677, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTHRUSTING, __pyx_t_19) < (0)) __PYX_ERR(5, 2677, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_517stream_CDLTRISTAR, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLTRISTAR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[284])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2713, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLTRISTAR, __pyx_t_19) < (0)) __PYX_ERR(5, 2713, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_519stream_CDLUNIQUE3RIVER, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLUNIQUE3RIVER, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[285])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLUNIQUE3RIVER, __pyx_t_19) < (0)) __PYX_ERR(5, 2749, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_521stream_CDLUPSIDEGAP2CROWS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLUPSIDEGAP2CROWS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[286])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2785, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLUPSIDEGAP2CROWS, __pyx_t_19) < (0)) __PYX_ERR(5, 2785, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_523stream_CDLXSIDEGAP3METHODS, 0, __pyx_mstate_global->__pyx_n_u_stream_CDLXSIDEGAP3METHODS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[287])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2821, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CDLXSIDEGAP3METHODS, __pyx_t_19) < (0)) __PYX_ERR(5, 2821, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_525stream_CEIL, 0, __pyx_mstate_global->__pyx_n_u_stream_CEIL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[288])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CEIL, __pyx_t_19) < (0)) __PYX_ERR(5, 2857, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2886, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 2884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_527stream_CMO, 0, __pyx_mstate_global->__pyx_n_u_stream_CMO, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[289])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CMO, __pyx_t_19) < (0)) __PYX_ERR(5, 2884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2915, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 2913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_529stream_CORREL, 0, __pyx_mstate_global->__pyx_n_u_stream_CORREL, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[290])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_CORREL, __pyx_t_19) < (0)) __PYX_ERR(5, 2913, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_531stream_COS, 0, __pyx_mstate_global->__pyx_n_u_stream_COS, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[291])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2946, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_COS, __pyx_t_19) < (0)) __PYX_ERR(5, 2946, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_533stream_COSH, 0, __pyx_mstate_global->__pyx_n_u_stream_COSH, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[292])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 2973, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_COSH, __pyx_t_19) < (0)) __PYX_ERR(5, 2973, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3002, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3000, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_535stream_DEMA, 0, __pyx_mstate_global->__pyx_n_u_stream_DEMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[293])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3000, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_DEMA, __pyx_t_19) < (0)) __PYX_ERR(5, 3000, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_537stream_DIV, 0, __pyx_mstate_global->__pyx_n_u_stream_DIV, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[294])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3029, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_DIV, __pyx_t_19) < (0)) __PYX_ERR(5, 3029, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3062, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3060, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_539stream_DX, 0, __pyx_mstate_global->__pyx_n_u_stream_DX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[295])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3060, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_DX, __pyx_t_19) < (0)) __PYX_ERR(5, 3060, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3097, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3095, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_541stream_EMA, 0, __pyx_mstate_global->__pyx_n_u_stream_EMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[296])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3095, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_EMA, __pyx_t_19) < (0)) __PYX_ERR(5, 3095, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_543stream_EXP, 0, __pyx_mstate_global->__pyx_n_u_stream_EXP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[297])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_EXP, __pyx_t_19) < (0)) __PYX_ERR(5, 3124, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_545stream_FLOOR, 0, __pyx_mstate_global->__pyx_n_u_stream_FLOOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[298])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3151, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_FLOOR, __pyx_t_19) < (0)) __PYX_ERR(5, 3151, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_547stream_HT_DCPERIOD, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPERIOD, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[299])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3178, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPERIOD, __pyx_t_19) < (0)) __PYX_ERR(5, 3178, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_549stream_HT_DCPHASE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPHASE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[300])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_DCPHASE, __pyx_t_19) < (0)) __PYX_ERR(5, 3205, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_551stream_HT_PHASOR, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_PHASOR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[301])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_PHASOR, __pyx_t_19) < (0)) __PYX_ERR(5, 3232, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_553stream_HT_SINE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_SINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[302])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3262, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_SINE, __pyx_t_19) < (0)) __PYX_ERR(5, 3262, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_555stream_HT_TRENDLINE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDLINE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[303])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDLINE, __pyx_t_19) < (0)) __PYX_ERR(5, 3292, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_557stream_HT_TRENDMODE, 0, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDMODE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[304])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3319, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_HT_TRENDMODE, __pyx_t_19) < (0)) __PYX_ERR(5, 3319, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_559stream_IMI, 0, __pyx_mstate_global->__pyx_n_u_stream_IMI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[305])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_IMI, __pyx_t_19) < (0)) __PYX_ERR(5, 3346, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3380, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_561stream_KAMA, 0, __pyx_mstate_global->__pyx_n_u_stream_KAMA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[306])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3378, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_KAMA, __pyx_t_19) < (0)) __PYX_ERR(5, 3378, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_563stream_LINEARREG, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[307])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG, __pyx_t_19) < (0)) __PYX_ERR(5, 3407, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3438, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3436, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_565stream_LINEARREG_ANGLE, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_ANGLE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[308])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3436, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_ANGLE, __pyx_t_19) < (0)) __PYX_ERR(5, 3436, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3465, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_567stream_LINEARREG_INTERCEPT, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_INTERCEPT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[309])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3465, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_INTERCEPT, __pyx_t_19) < (0)) __PYX_ERR(5, 3465, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3496, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = PyTuple_Pack(1, __pyx_t_19); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_569stream_LINEARREG_SLOPE, 0, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_SLOPE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[310])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_19, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LINEARREG_SLOPE, __pyx_t_19) < (0)) __PYX_ERR(5, 3494, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_571stream_LN, 0, __pyx_mstate_global->__pyx_n_u_stream_LN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[311])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3523, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LN, __pyx_t_19) < (0)) __PYX_ERR(5, 3523, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_573stream_LOG10, 0, __pyx_mstate_global->__pyx_n_u_stream_LOG10, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[312])); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3550, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_19); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_LOG10, __pyx_t_19) < (0)) __PYX_ERR(5, 3550, __pyx_L1_error) __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_8 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_6 = PyTuple_Pack(2, __pyx_t_19, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_575stream_MA, 0, __pyx_mstate_global->__pyx_n_u_stream_MA, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[313])); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_8); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_8, __pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MA, __pyx_t_8) < (0)) __PYX_ERR(5, 3577, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_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_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_19 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 3646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __pyx_t_3 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 3646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 3646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_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; __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_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_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_2 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3721, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 3721, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __pyx_t_4 = PyTuple_Pack(2, __pyx_t_2, __pyx_t_15); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 3719, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_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_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_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_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); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MAVP, __pyx_t_2) < (0)) __PYX_ERR(5, 3752, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_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_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_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_589stream_MAXINDEX, 0, __pyx_mstate_global->__pyx_n_u_stream_MAXINDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[320])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MAXINDEX, __pyx_t_2) < (0)) __PYX_ERR(5, 3816, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_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_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3877, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_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_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3915, __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, 3913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_595stream_MIDPOINT, 0, __pyx_mstate_global->__pyx_n_u_stream_MIDPOINT, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[323])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MIDPOINT, __pyx_t_2) < (0)) __PYX_ERR(5, 3913, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_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_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3942, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_597stream_MIDPRICE, 0, __pyx_mstate_global->__pyx_n_u_stream_MIDPRICE, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[324])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3942, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MIDPRICE, __pyx_t_2) < (0)) __PYX_ERR(5, 3942, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_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_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 3974, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_599stream_MIN, 0, __pyx_mstate_global->__pyx_n_u_stream_MIN, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[325])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 3974, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MIN, __pyx_t_2) < (0)) __PYX_ERR(5, 3974, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_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_8 = PyTuple_Pack(1, __pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4003, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_601stream_MININDEX, 0, __pyx_mstate_global->__pyx_n_u_stream_MININDEX, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[326])); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4003, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_MININDEX, __pyx_t_2) < (0)) __PYX_ERR(5, 4003, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_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 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_8 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_4 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_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); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_PPO, __pyx_t_4) < (0)) __PYX_ERR(5, 4356, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4387, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_625stream_ROC, 0, __pyx_mstate_global->__pyx_n_u_stream_ROC, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[338])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4387, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #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 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_627stream_ROCP, 0, __pyx_mstate_global->__pyx_n_u_stream_ROCP, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[339])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ROCP, __pyx_t_4) < (0)) __PYX_ERR(5, 4416, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_629stream_ROCR, 0, __pyx_mstate_global->__pyx_n_u_stream_ROCR, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[340])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_ROCR, __pyx_t_4) < (0)) __PYX_ERR(5, 4445, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_15 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_631stream_ROCR100, 0, __pyx_mstate_global->__pyx_n_u_stream_ROCR100, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[341])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #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 = PyTuple_Pack(1, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_633stream_RSI, 0, __pyx_mstate_global->__pyx_n_u_stream_RSI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[342])); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_RSI, __pyx_t_4) < (0)) __PYX_ERR(5, 4503, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyFloat_FromDouble(((double)0.02)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4534, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_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_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); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_15); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_15, __pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SAR, __pyx_t_15) < (0)) __PYX_ERR(5, 4532, __pyx_L1_error) __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_15 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_15)) __PYX_ERR(5, 4567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __pyx_t_8 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_8)) __PYX_ERR(5, 4567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_4 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 4567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_3 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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; __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_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_6 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = PyTuple_Pack(5, __pyx_t_20, __pyx_t_19, __pyx_t_16, __pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4744, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_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); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_STOCH, __pyx_t_6) < (0)) __PYX_ERR(5, 4744, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4788, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = __Pyx_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 4788, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyLong_From_int(((int)0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 4788, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_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; __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_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_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_653stream_STOCHRSI, 0, __pyx_mstate_global->__pyx_n_u_stream_STOCHRSI, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[352])); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4826, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_19); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_STOCHRSI, __pyx_t_6) < (0)) __PYX_ERR(5, 4826, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_655stream_SUB, 0, __pyx_mstate_global->__pyx_n_u_stream_SUB, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[353])); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4861, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); #endif if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SUB, __pyx_t_6) < (0)) __PYX_ERR(5, 4861, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_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_19 = PyTuple_Pack(1, __pyx_t_6); if (unlikely(!__pyx_t_19)) __PYX_ERR(5, 4892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_CyFunction_New(&__pyx_mdef_5talib_7_ta_lib_657stream_SUM, 0, __pyx_mstate_global->__pyx_n_u_stream_SUM, NULL, __pyx_mstate_global->__pyx_n_u_talib__ta_lib, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[354])); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 4892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 PyUnstable_Object_EnableDeferredRefcount(__pyx_t_6); #endif __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_6, __pyx_t_19); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_stream_SUM, __pyx_t_6) < (0)) __PYX_ERR(5, 4892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_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_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_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_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_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_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_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 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_PyLong_From_int(((int)-2147483648)); if (unlikely(!__pyx_t_6)) __PYX_ERR(5, 5226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_16 = PyFloat_FromDouble(((double)-4e37)); if (unlikely(!__pyx_t_16)) __PYX_ERR(5, 5226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __pyx_t_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_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_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_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_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_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 ### */ 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) /* CommonTypesMetaclass.init */ if (likely(__pyx_CommonTypesMetaclass_init(__pyx_m) == 0)); else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) /* CachedMethodType.init */ #if CYTHON_COMPILING_IN_LIMITED_API { PyObject *typesModule=NULL; typesModule = PyImport_ImportModule("types"); if (typesModule) { __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType"); Py_DECREF(typesModule); } } // error handling follows #endif if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) /* CythonFunctionShared.init */ if (likely(__pyx_CyFunction_init(__pyx_m) == 0)); else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } /* #### Code section: cleanup_globals ### */ /* #### Code section: cleanup_module ### */ /* #### Code section: main_method ### */ /* #### Code section: utility_code_pragmas ### */ #ifdef _MSC_VER #pragma warning( push ) /* Warning 4127: conditional expression is constant * Cython uses constant conditional expressions to allow in inline functions to be optimized at * compile-time, so this warning is not useful */ #pragma warning( disable : 4127 ) #endif /* #### Code section: utility_code_def ### */ /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* 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); for (i=0; i= 0x030C00A6 PyObject *current_exception = tstate->current_exception; if (unlikely(!current_exception)) return 0; exc_type = (PyObject*) Py_TYPE(current_exception); if (exc_type == err) return 1; #else exc_type = tstate->curexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; #endif #if CYTHON_AVOID_BORROWED_REFS Py_INCREF(exc_type); #endif if (unlikely(PyTuple_Check(err))) { result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); } else { result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(exc_type); #endif return result; } #endif /* PyErrFetchRestore (used by PyObjectGetAttrStrNoError) */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { #if PY_VERSION_HEX >= 0x030C00A6 PyObject *tmp_value; assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); if (value) { #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) #endif PyException_SetTraceback(value, tb); } tmp_value = tstate->current_exception; tstate->current_exception = value; Py_XDECREF(tmp_value); Py_XDECREF(type); Py_XDECREF(tb); #else PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #endif } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if PY_VERSION_HEX >= 0x030C00A6 PyObject* exc_value; exc_value = tstate->current_exception; tstate->current_exception = 0; *value = exc_value; *type = NULL; *tb = NULL; if (exc_value) { *type = (PyObject*) Py_TYPE(exc_value); Py_INCREF(*type); #if CYTHON_COMPILING_IN_CPYTHON *tb = ((PyBaseExceptionObject*) exc_value)->traceback; Py_XINCREF(*tb); #else *tb = PyException_GetTraceback(exc_value); #endif } #else *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #endif } #endif /* 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); return PyObject_GetAttr(obj, attr_name); } #endif /* PyObjectGetAttrStrNoError (used by GetBuiltinName) */ #if __PYX_LIMITED_VERSION_HEX < 0x030d0000 static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) __Pyx_PyErr_Clear(); } #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { PyObject *result; #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 PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); } #endif result = __Pyx_PyObject_GetAttrStr(obj, attr_name); if (unlikely(!result)) { __Pyx_PyObject_GetAttrStr_ClearAttributeError(); } return result; #endif } /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_b, name); if (unlikely(!result) && !PyErr_Occurred()) { PyErr_Format(PyExc_NameError, "name '%U' is not defined", name); } return result; } /* GetTopmostException (used by SaveResetException) */ #if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); PyObject *exc_value = exc_info->exc_value; if (exc_value == NULL || exc_value == Py_None) { *value = NULL; *type = NULL; *tb = NULL; } else { *value = exc_value; Py_INCREF(*value); *type = (PyObject*) Py_TYPE(exc_value); Py_INCREF(*type); *tb = PyException_GetTraceback(exc_value); } #elif CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); #endif } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 _PyErr_StackItem *exc_info = tstate->exc_info; PyObject *tmp_value = exc_info->exc_value; exc_info->exc_value = value; Py_XDECREF(tmp_value); Py_XDECREF(type); Py_XDECREF(tb); #else PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #endif } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { 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 >= 0x030C0000 local_value = tstate->current_exception; tstate->current_exception = 0; #else local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; 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 if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif // __PYX_LIMITED_VERSION_HEX > 0x030C0000 Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; #if PY_VERSION_HEX >= 0x030B00a4 tmp_value = exc_info->exc_value; exc_info->exc_value = local_value; tmp_type = NULL; tmp_tb = NULL; Py_XDECREF(local_type); Py_XDECREF(local_tb); #else tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; #endif } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif 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; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; #endif } /* 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 (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* 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); } #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 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); } 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 } /* RaiseException */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if PY_VERSION_HEX >= 0x030C00A6 PyException_SetTraceback(value, tb); #elif CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #else PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #endif } bad: Py_XDECREF(owned_instance); return; } /* 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; void *udata; uval = PyUnicode_New(ulength, 127); if (unlikely(!uval)) return NULL; udata = PyUnicode_DATA(uval); if (uoffset > 0) { i = 0; if (prepend_sign) { __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); i++; } for (; i < uoffset; i++) { __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); } } for (i=0; i < clength; i++) { __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); } #else { PyObject *sign = NULL, *padding = NULL; uval = NULL; if (uoffset > 0) { prepend_sign = !!prepend_sign; if (uoffset > prepend_sign) { padding = PyUnicode_FromOrdinal(padding_char); if (likely(padding) && uoffset > prepend_sign + 1) { PyObject *tmp = PySequence_Repeat(padding, uoffset - prepend_sign); Py_DECREF(padding); padding = tmp; } if (unlikely(!padding)) goto done_or_error; } if (prepend_sign) { sign = PyUnicode_FromOrdinal('-'); if (unlikely(!sign)) goto done_or_error; } } uval = PyUnicode_DecodeASCII(chars, clength, NULL); if (likely(uval) && padding) { PyObject *tmp = PyUnicode_Concat(padding, uval); Py_DECREF(uval); uval = tmp; } if (likely(uval) && sign) { PyObject *tmp = PyUnicode_Concat(sign, uval); Py_DECREF(uval); uval = tmp; } done_or_error: Py_XDECREF(padding); Py_XDECREF(sign); } #endif return uval; } /* COrdinalToPyUnicode (used by CIntToPyUnicode) */ static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value) { return value <= 1114111; } static PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t ulength, char padding_char) { Py_ssize_t padding_length = ulength - 1; if (likely((padding_length <= 250) && (value < 0xD800 || value > 0xDFFF))) { char chars[256]; if (value <= 255) { memset(chars, padding_char, (size_t) padding_length); chars[ulength-1] = (char) value; return PyUnicode_DecodeLatin1(chars, ulength, NULL); } char *cpos = chars + sizeof(chars); if (value < 0x800) { *--cpos = (char) (0x80 | (value & 0x3f)); value >>= 6; *--cpos = (char) (0xc0 | (value & 0x1f)); } else if (value < 0x10000) { *--cpos = (char) (0x80 | (value & 0x3f)); value >>= 6; *--cpos = (char) (0x80 | (value & 0x3f)); value >>= 6; *--cpos = (char) (0xe0 | (value & 0x0f)); } else { *--cpos = (char) (0x80 | (value & 0x3f)); value >>= 6; *--cpos = (char) (0x80 | (value & 0x3f)); value >>= 6; *--cpos = (char) (0x80 | (value & 0x3f)); value >>= 6; *--cpos = (char) (0xf0 | (value & 0x07)); } cpos -= padding_length; memset(cpos, padding_char, (size_t) padding_length); return PyUnicode_DecodeUTF8(cpos, chars + sizeof(chars) - cpos, NULL); } if (value <= 127 && CYTHON_USE_UNICODE_INTERNALS) { const char chars[1] = {(char) value}; return __Pyx_PyUnicode_BuildFromAscii(ulength, chars, 1, 0, padding_char); } { PyObject *uchar, *padding_uchar, *padding, *result; padding_uchar = PyUnicode_FromOrdinal(padding_char); if (unlikely(!padding_uchar)) return NULL; padding = PySequence_Repeat(padding_uchar, padding_length); Py_DECREF(padding_uchar); if (unlikely(!padding)) return NULL; uchar = PyUnicode_FromOrdinal(value); if (unlikely(!uchar)) { Py_DECREF(padding); return NULL; } result = PyUnicode_Concat(padding, uchar); Py_DECREF(padding); Py_DECREF(uchar); return result; } } /* CIntToPyUnicode */ static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_TA_RetCode(TA_RetCode value, Py_ssize_t width, char padding_char) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const TA_RetCode neg_one = (TA_RetCode) -1, const_zero = (TA_RetCode) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (unlikely(!(is_unsigned || value == 0 || value > 0) || !(sizeof(value) <= 2 || value & ~ (TA_RetCode) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); return NULL; } if (width <= 1) { return PyUnicode_FromOrdinal((int) value); } return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); } static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_TA_RetCode(TA_RetCode value, Py_ssize_t width, char padding_char, char format_char) { char digits[sizeof(TA_RetCode)*3+2]; char *dpos, *end = digits + sizeof(TA_RetCode)*3+2; const char *hex_digits = DIGITS_HEX; Py_ssize_t length, ulength; int prepend_sign, last_one_off; TA_RetCode remaining; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const TA_RetCode neg_one = (TA_RetCode) -1, const_zero = (TA_RetCode) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (format_char == 'X') { hex_digits += 16; format_char = 'x'; } remaining = value; last_one_off = 0; dpos = end; do { int digit_pos; switch (format_char) { case 'o': digit_pos = abs((int)(remaining % (8*8))); remaining = (TA_RetCode) (remaining / (8*8)); dpos -= 2; memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); last_one_off = (digit_pos < 8); break; case 'd': digit_pos = abs((int)(remaining % (10*10))); remaining = (TA_RetCode) (remaining / (10*10)); dpos -= 2; memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); last_one_off = (digit_pos < 10); break; case 'x': *(--dpos) = hex_digits[abs((int)(remaining % 16))]; remaining = (TA_RetCode) (remaining / 16); break; default: assert(0); break; } } while (unlikely(remaining != 0)); assert(!last_one_off || *dpos == '0'); dpos += last_one_off; length = end - dpos; ulength = length; prepend_sign = 0; if (!is_unsigned && value <= neg_one) { if (padding_char == ' ' || width <= length + 1) { *(--dpos) = '-'; ++length; } else { prepend_sign = 1; } ++ulength; } if (width > ulength) { ulength = width; } if (ulength == 1) { return PyUnicode_FromOrdinal(*dpos); } return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); } /* JoinPyUnicode */ 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 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; } 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 } /* 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; } #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; for (i = 0; i < length; i++) { v = dest[i] = src[i]; Py_INCREF(v); } } static CYTHON_INLINE PyObject * __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) { PyObject *res; if (n <= 0) { return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); } res = PyTuple_New(n); if (unlikely(res == NULL)) return NULL; __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); return res; } static CYTHON_INLINE PyObject * __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) { PyObject *res; if (n <= 0) { return PyList_New(0); } res = PyList_New(n); if (unlikely(res == NULL)) return NULL; __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); return res; } #endif /* BytesEquals (used by UnicodeEquals) */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL ||\ !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { return (equals == Py_EQ); } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) return (equals == Py_NE); ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); if (ps1[0] != ps2[0]) { return (equals == Py_NE); } else if (length == 1) { return (equals == Py_EQ); } else { int result; #if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) Py_hash_t hash1, hash2; hash1 = ((PyBytesObject*)s1)->ob_shash; hash2 = ((PyBytesObject*)s2)->ob_shash; if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { return (equals == Py_NE); } #endif result = memcmp(ps1, ps2, (size_t)length); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { return (equals == Py_NE); } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { return (equals == Py_NE); } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } #endif } /* UnicodeEquals (used by fastcall) */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL return PyObject_RichCompareBool(s1, s2, equals); #else 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 (s1_is_unicode & s2_is_unicode) { 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 !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; hash1 = ((PyASCIIObject*)s1)->hash; hash2 = ((PyASCIIObject*)s2)->hash; if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { goto return_ne; } } #endif kind = __Pyx_PyUnicode_KIND(s1); if (kind != __Pyx_PyUnicode_KIND(s2)) { goto return_ne; } data1 = __Pyx_PyUnicode_DATA(s1); data2 = __Pyx_PyUnicode_DATA(s2); if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { goto return_ne; } else if (length == 1) { goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { goto return_ne; } else if ((s2 == Py_None) & s1_is_unicode) { goto return_ne; } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } return_eq: return (equals == Py_EQ); return_ne: return (equals == Py_NE); #endif } /* fastcall */ #if CYTHON_METH_FASTCALL static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) { 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++) { 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++) { 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]; } } return NULL; } #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; 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 { assert(pvalue); *pvalue = next; } return 1; bad: Py_XDECREF(next); #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 PyErr_FormatUnraisable("Exception ignored in __Pyx_PyDict_NextRef"); #else PyErr_WriteUnraisable(__pyx_mstate_global->__pyx_n_u_Pyx_PyDict_NextRef); #endif if (pkey) *pkey = NULL; if (pvalue) *pvalue = NULL; return 0; } #else // !CYTHON_AVOID_BORROWED_REFS static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue) { int result = PyDict_Next(p, ppos, pkey, pvalue); if (likely(result == 1)) { if (pkey) Py_INCREF(*pkey); if (pvalue) Py_INCREF(*pvalue); } return result; } #endif /* RaiseDoubleKeywords (used by ParseKeywordsImpl) */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, "%s() got multiple values for keyword argument '%U'", func_name, kw_name); } /* CallUnboundCMethod2 */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { 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 #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; } 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 argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { 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; } #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; } #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; } #endif 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 key = __Pyx_PySequence_ITEM(kwds, pos); #else key = __Pyx_PyTuple_GET_ITEM(kwds, pos); #endif #if !CYTHON_ASSUME_SAFE_MACROS if (unlikely(!key)) goto bad; #endif 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; } } } #if CYTHON_AVOID_BORROWED_REFS Py_DECREF(key); key = NULL; #endif } return 0; invalid_keyword: PyErr_Format(PyExc_TypeError, "%s() got an unexpected keyword argument '%U'", function_name, key); goto bad; bad: #if CYTHON_AVOID_BORROWED_REFS Py_XDECREF(key); #endif return -1; } /* 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 (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_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 ")" #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 (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; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #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; } 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 result; } #else 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); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* PyObjectSetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_setattro)) return tp->tp_setattro(obj, attr_name, value); return PyObject_SetAttr(obj, attr_name, value); } #endif /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (unlikely(!j)) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, 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)))) { return __Pyx_NewRef(PyList_GET_ITEM(o, wrapped_i)); } return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); #else (void)wraparound; (void)boundscheck; return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, 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)))) { return __Pyx_NewRef(PyTuple_GET_ITEM(o, wrapped_i)); } return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); #else (void)wraparound; (void)boundscheck; return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, 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 ((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 !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)))) { return __Pyx_NewRef(PyTuple_GET_ITEM(o, n)); } } 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 (!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 (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)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return sm->sq_item(o, i); } } #else if (is_list || !PyMapping_Check(o)) { return PySequence_GetItem(o, i); } #endif (void)wraparound; (void)boundscheck; return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); } /* ObjectGetItem */ #if CYTHON_USE_TYPE_SLOTS static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { PyObject *runerr = NULL; 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, 1); } if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { __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); __Pyx_DECREF_TypeName(index_type_name); } return NULL; } 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_mstate_global->__pyx_n_u_class_getitem); if (!meth) { PyErr_Clear(); } else { PyObject *result = __Pyx_PyObject_CallOneArg(meth, key); Py_DECREF(meth); return result; } } 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); return NULL; } static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) { PyTypeObject *tp = Py_TYPE(obj); PyMappingMethods *mm = tp->tp_as_mapping; PySequenceMethods *sm = tp->tp_as_sequence; if (likely(mm && mm->mp_subscript)) { return mm->mp_subscript(obj, key); } if (likely(sm && sm->sq_item)) { return __Pyx_PyObject_GetIndex(obj, key); } return __Pyx_PyObject_GetItem_Slow(obj, key); } #endif /* 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 < 0x030d0000 static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; if (unlikely(!PyUnicode_Check(n))) { PyErr_SetString(PyExc_TypeError, "hasattr(): attribute name must be string"); return -1; } r = __Pyx_PyObject_GetAttrStrNoError(o, n); if (!r) { return (unlikely(PyErr_Occurred())) ? -1 : 0; } else { Py_DECREF(r); return 1; } } #endif /* DictGetItem */ #if !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; 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 value; } #endif /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* IterFinish */ static CYTHON_INLINE int __Pyx_IterFinish(void) { PyObject* exc_type; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign exc_type = __Pyx_PyErr_CurrentExceptionType(); if (unlikely(exc_type)) { if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) return -1; __Pyx_PyErr_Clear(); return 0; } return 0; } /* UnpackItemEndCheck */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } return __Pyx_IterFinish(); } /* 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 (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 __Pyx_TypeName type_name; PyTypeObject *tp = Py_TYPE(obj); PyObject *descr; descrgetfunc f = NULL; PyObject **dictptr, *dict; int meth_found = 0; assert (*method == NULL); if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; } if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { return 0; } descr = _PyType_Lookup(tp, name); if (likely(descr != NULL)) { Py_INCREF(descr); #if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) #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 #endif { meth_found = 1; } else { f = Py_TYPE(descr)->tp_descr_get; if (f != NULL && PyDescr_IsData(descr)) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } } } dictptr = _PyObject_GetDictPtr(obj); if (dictptr != NULL && (dict = *dictptr) != NULL) { Py_INCREF(dict); attr = __Pyx_PyDict_GetItemStr(dict, name); if (attr != NULL) { Py_INCREF(attr); Py_DECREF(dict); Py_XDECREF(descr); goto try_unpack; } Py_DECREF(dict); } if (meth_found) { *method = descr; return 1; } if (f != NULL) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } if (likely(descr != NULL)) { *method = descr; return 0; } type_name = __Pyx_PyType_GetFullyQualifiedName(tp); PyErr_Format(PyExc_AttributeError, "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", type_name, name); __Pyx_DECREF_TypeName(type_name); return 0; #else attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; #endif try_unpack: #if CYTHON_UNPACK_METHODS if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { PyObject *function = PyMethod_GET_FUNCTION(attr); Py_INCREF(function); Py_DECREF(attr); *method = function; return 1; } #endif *method = attr; return 0; } #endif /* 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)) { result = __Pyx_PyObject_CallOneArg(method, obj); Py_DECREF(method); return result; } if (unlikely(!method)) goto bad; result = __Pyx_PyObject_CallNoArg(method); Py_DECREF(method); bad: return result; #endif } /* RaiseNoneIterError (used by UnpackTupleError) */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* UnpackTupleError (used by UnpackTuple2) */ static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { if (t == Py_None) { __Pyx_RaiseNoneNotIterableError(); } else { 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 (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_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); #endif if (decref_tuple) { Py_DECREF(tuple); } *pvalue1 = value1; *pvalue2 = value2; return 0; #if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS bad: Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; #endif } static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int has_known_size, int decref_tuple) { Py_ssize_t index; PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; iternextfunc iternext; iter = PyObject_GetIter(tuple); if (unlikely(!iter)) goto bad; if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } iternext = __Pyx_PyObject_GetIterNextFunc(iter); value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; Py_DECREF(iter); *pvalue1 = value1; *pvalue2 = value2; return 0; unpacking_failed: if (!has_known_size && __Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); bad: Py_XDECREF(iter); Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; } /* dict_iter */ #if CYTHON_COMPILING_IN_PYPY #include #endif static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_source_is_dict) { is_dict = is_dict || likely(PyDict_CheckExact(iterable)); *p_source_is_dict = is_dict; if (is_dict) { #if !CYTHON_COMPILING_IN_PYPY *p_orig_length = PyDict_Size(iterable); Py_INCREF(iterable); return iterable; #else static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; PyObject **pp = NULL; if (method_name) { const char *name = PyUnicode_AsUTF8(method_name); if (strcmp(name, "iteritems") == 0) pp = &py_items; else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; else if (strcmp(name, "itervalues") == 0) pp = &py_values; if (pp) { if (!*pp) { *pp = PyUnicode_FromString(name + 4); if (!*pp) return NULL; } method_name = *pp; } } #endif } *p_orig_length = 0; if (method_name) { PyObject* iter; iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); if (!iterable) return NULL; #if !CYTHON_COMPILING_IN_PYPY if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) return iterable; #endif iter = PyObject_GetIter(iterable); Py_DECREF(iterable); return iter; } return PyObject_GetIter(iterable); } #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) { 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; } 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 (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); *pvalue = value; } } 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; 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; 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 = __Pyx_PyList_GetItemRef(iter_obj, pos); if (unlikely(!next_item)) return -1; } else #endif { next_item = PyIter_Next(iter_obj); if (unlikely(!next_item)) { return __Pyx_IterFinish(); } } if (pitem) { *pitem = next_item; } else if (pkey && pvalue) { if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) return -1; } else if (pkey) { *pkey = next_item; } else { *pvalue = next_item; } return 1; } /* PyLongBinop */ #if !CYTHON_COMPILING_IN_PYPY 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); 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; } return PyLong_Type.tp_as_number->nb_add(op1, op2); } calculate_long: { long x; x = a + b; return PyLong_FromLong(x); } 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)) { 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 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; } 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 static CYTHON_INLINE void __Pyx_crop_slice(Py_ssize_t* _start, Py_ssize_t* _stop, Py_ssize_t* _length) { Py_ssize_t start = *_start, stop = *_stop, length = *_length; if (start < 0) { start += length; if (start < 0) start = 0; } if (stop < 0) stop += length; else if (stop > length) stop = length; *_length = stop - start; *_start = start; *_stop = stop; } 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); if (length <= 0) { return PyList_New(0); } return __Pyx_PyList_FromArray(((PyListObject*)src)->ob_item + start, length); } static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice( PyObject* src, Py_ssize_t start, Py_ssize_t stop) { PyObject *result; __Pyx_BEGIN_CRITICAL_SECTION(src); result = __Pyx_PyList_GetSlice_locked(src, start, stop); __Pyx_END_CRITICAL_SECTION(); return result; } #endif // CYTHON_COMPILING_IN_CPYTHON /* 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) { return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_keys, d); } /* 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 { PyErr_Format(PyExc_TypeError, "Expected %.200s, got " __Pyx_FMT_TYPENAME, type_name, obj_type_name ); } __Pyx_DECREF_TypeName(obj_type_name); } /* pyint_simplify */ static CYTHON_INLINE int __Pyx_PyInt_FromNumber(PyObject **number_var, const char *argname, int accept_none) { PyObject *number = *number_var; if (likely((accept_none && number == Py_None) || PyLong_CheckExact(number))) { return 0; } PyObject *int_object; if (likely(PyNumber_Check(number))) { int_object = PyNumber_Long(number); if (unlikely(!int_object)) goto bad; } else { __Pyx_PyBuiltin_Invalid(number, "int", argname); goto bad; } *number_var = int_object; Py_DECREF(number); return 0; bad: *number_var = NULL; Py_DECREF(number); return -1; } /* SliceObject */ 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, CYTHON_UNUSED int wraparound) { __Pyx_TypeName obj_type_name; #if CYTHON_USE_TYPE_SLOTS PyMappingMethods* mp = Py_TYPE(obj)->tp_as_mapping; if (likely(mp && mp->mp_subscript)) #endif { PyObject* result; PyObject *py_slice, *py_start, *py_stop; if (_py_slice) { py_slice = *_py_slice; } else { PyObject* owned_start = NULL; PyObject* owned_stop = NULL; if (_py_start) { py_start = *_py_start; } else { if (has_cstart) { owned_start = py_start = PyLong_FromSsize_t(cstart); if (unlikely(!py_start)) goto bad; } else py_start = Py_None; } if (_py_stop) { py_stop = *_py_stop; } else { if (has_cstop) { owned_stop = py_stop = PyLong_FromSsize_t(cstop); if (unlikely(!py_stop)) { Py_XDECREF(owned_start); goto bad; } } else py_stop = Py_None; } py_slice = PySlice_New(py_start, py_stop, Py_None); Py_XDECREF(owned_start); Py_XDECREF(owned_stop); if (unlikely(!py_slice)) goto bad; } #if CYTHON_USE_TYPE_SLOTS result = mp->mp_subscript(obj, py_slice); #else result = PyObject_GetItem(obj, py_slice); #endif if (!_py_slice) { Py_DECREF(py_slice); } return result; } 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); bad: return NULL; } /* SetItemInt */ static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { int r; if (unlikely(!j)) return -1; r = PyObject_SetItem(o, j, v); Py_DECREF(j); return r; } static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, 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 ((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 0; } } 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 (!is_list && mm && mm->mp_ass_subscript) { int r; 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 (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)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return -1; PyErr_Clear(); } } return sm->sq_ass_item(o, i, v); } } #else if (is_list || !PyMapping_Check(o)) { return PySequence_SetItem(o, i, v); } #endif (void)wraparound; (void)boundscheck; return __Pyx_SetItemInt_Generic(o, PyLong_FromSsize_t(i), v); } /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType_3_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; Py_ssize_t basicsize; Py_ssize_t itemsize; #if defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API) PyObject *py_basicsize; PyObject *py_itemsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #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; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); if (!py_itemsize) goto bad; itemsize = PyLong_AsSsize_t(py_itemsize); Py_DECREF(py_itemsize); py_itemsize = 0; if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if (itemsize) { if (size % alignment) { alignment = size % alignment; } if (itemsize < (Py_ssize_t)alignment) itemsize = (Py_ssize_t)alignment; } if ((size_t)(basicsize + itemsize) < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize+itemsize); goto bad; } 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. " "Expected %zd from C header, got %zd-%zd from PyObject", module_name, class_name, size, basicsize, basicsize+itemsize); 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: Py_XDECREF(result); return NULL; } #endif /* 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 __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) { #if !CYTHON_COMPILING_IN_CPYTHON const #endif // !CYTHON_COMPILING_IN_CPYTHON) PyMemberDef *memb = (PyMemberDef*) slot->pfunc; while (memb && memb->name) { if (memb->name[0] == '_' && memb->name[1] == '_') { if (strcmp(memb->name, "__weaklistoffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); type->tp_weaklistoffset = memb->offset; changed = 1; } else if (strcmp(memb->name, "__dictoffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); type->tp_dictoffset = memb->offset; changed = 1; } #if CYTHON_METH_FASTCALL else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { assert(memb->type == T_PYSSIZET); assert(memb->flags == READONLY); type->tp_vectorcall_offset = memb->offset; changed = 1; } #endif // CYTHON_METH_FASTCALL #if !CYTHON_COMPILING_IN_PYPY else if (strcmp(memb->name, "__module__") == 0) { PyObject *descr; assert(memb->type == T_OBJECT); assert(memb->flags == 0 || memb->flags == READONLY); descr = PyDescr_NewMember(type, memb); if (unlikely(!descr)) return -1; int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); Py_DECREF(descr); if (unlikely(set_item_result < 0)) { return -1; } changed = 1; } #endif // !CYTHON_COMPILING_IN_PYPY } memb++; } } #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 (used by FetchCommonType) */ static PyObject *__Pyx_FetchSharedCythonABIModule(void) { return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME); } /* 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 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", name); return -1; } return 0; } 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) 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, spec->basicsize) < 0) { goto bad; } goto done; } else if (unlikely(get_item_ref_result == -1)) { goto bad; } cached_type = __Pyx_PyType_FromMetaclass( metaclass, CYTHON_USE_MODULE_STATE ? module : abi_module, spec, bases); if (unlikely(!cached_type)) goto bad; if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type); 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_XDECREF(abi_module); Py_DECREF(py_object_name); assert(cached_type == NULL || PyType_Check(cached_type)); return (PyTypeObject *) cached_type; bad: Py_XDECREF(cached_type); 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; } /* 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; #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(); return NULL; } for (j = 0; j < nargs; j++) newargs[j] = args[j]; kwnames = PyTuple_New(nkw); if (unlikely(kwnames == NULL)) { PyMem_Free(newargs); return NULL; } kwvalues = newargs + nargs; pos = 0; i = 0; keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; 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++; } if (unlikely(!keys_are_strings)) { PyErr_SetString(PyExc_TypeError, "keywords must be strings"); goto cleanup; } 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]); PyMem_Free(newargs); return res; } static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { 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 (used by CythonFunction) */ #if CYTHON_COMPILING_IN_LIMITED_API static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { if (__Pyx_CyFunction_Check(func)) { return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; } else if (PyCFunction_Check(func)) { return PyCFunction_GetFunction(func) == (PyCFunction) 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)(void)) { if (PyMethod_Check(func)) { func = PyMethod_GET_FUNCTION(func); } return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; } #endif static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API __Pyx_Py_XDECREF_SET( __Pyx_CyFunction_GetClassObj(f), ((classobj) ? __Pyx_NewRef(classobj) : NULL)); #else __Pyx_Py_XDECREF_SET( ((PyCMethodObject *) (f))->mm_class, (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); #endif } static PyObject * __Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op) { 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) { op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); if (unlikely(op->func_doc == NULL)) return NULL; } else { Py_INCREF(Py_None); return Py_None; } #endif } 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) { CYTHON_UNUSED_VAR(context); if (value == NULL) { 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_locked(__pyx_CyFunctionObject *op) { if (unlikely(op->func_name == NULL)) { #if CYTHON_COMPILING_IN_LIMITED_API op->func_name = PyObject_GetAttrString(op->func, "__name__"); #else op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); #endif if (unlikely(op->func_name == NULL)) return NULL; } 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 (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); 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 (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) { CYTHON_UNUSED_VAR(context); if (unlikely(op->func_dict == NULL)) { op->func_dict = PyDict_New(); if (unlikely(op->func_dict == NULL)) return NULL; } Py_INCREF(op->func_dict); return op->func_dict; } #endif static PyObject * __Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); Py_INCREF(op->func_globals); return op->func_globals; } static PyObject * __Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(op); CYTHON_UNUSED_VAR(context); Py_INCREF(Py_None); return Py_None; } static PyObject * __Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) { PyObject* result = (op->func_code) ? op->func_code : Py_None; CYTHON_UNUSED_VAR(context); Py_INCREF(result); return result; } static int __Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { int result = 0; PyObject *res = op->defaults_getter((PyObject *) op); if (unlikely(!res)) return -1; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS op->defaults_tuple = PyTuple_GET_ITEM(res, 0); Py_INCREF(op->defaults_tuple); op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); Py_INCREF(op->defaults_kwdict); #else op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); if (unlikely(!op->defaults_tuple)) result = -1; else { op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); if (unlikely(!op->defaults_kwdict)) result = -1; } #endif Py_DECREF(res); return result; } static int __Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); if (!value) { value = Py_None; } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { PyErr_SetString(PyExc_TypeError, "__defaults__ must be set to a tuple object"); return -1; } 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_locked(__pyx_CyFunctionObject *op) { PyObject* result = op->defaults_tuple; if (unlikely(!result)) { if (op->defaults_getter) { if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; result = op->defaults_tuple; } else { result = Py_None; } } 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); if (!value) { value = Py_None; } else if (unlikely(value != Py_None && !PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "__kwdefaults__ must be set to a dict object"); return -1; } 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_locked(__pyx_CyFunctionObject *op) { PyObject* result = op->defaults_kwdict; if (unlikely(!result)) { if (op->defaults_getter) { if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; result = op->defaults_kwdict; } else { result = Py_None; } } 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); if (!value || value == Py_None) { value = NULL; } else if (unlikely(!PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "__annotations__ must be set to a dict object"); 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_locked(__pyx_CyFunctionObject *op) { PyObject* result = op->func_annotations; if (unlikely(!result)) { result = PyDict_New(); if (unlikely(!result)) return NULL; op->func_annotations = result; } Py_INCREF(result); return result; } static PyObject * __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { PyObject *result; CYTHON_UNUSED_VAR(context); __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 *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); #if CYTHON_ASSUME_SAFE_MACROS PyList_SET_ITEM(fromlist, 0, marker); #else if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { Py_DECREF(marker); Py_DECREF(fromlist); return NULL; } #endif module = PyImport_ImportModuleLevelObject(__pyx_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0); Py_DECREF(fromlist); if (unlikely(!module)) goto ignore; is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker); Py_DECREF(module); 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 } #if CYTHON_COMPILING_IN_LIMITED_API static PyObject * __Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { CYTHON_UNUSED_VAR(context); return PyObject_GetAttrString(op->func, "__module__"); } static int __Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { CYTHON_UNUSED_VAR(context); return PyObject_SetAttrString(op->func, "__module__", value); } #endif static PyGetSetDef __pyx_CyFunction_getsets[] = { {"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 {0, 0, 0, 0, 0} }; static PyMemberDef __pyx_CyFunction_members[] = { #if !CYTHON_COMPILING_IN_LIMITED_API {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, #endif #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, #endif #if CYTHON_METH_FASTCALL #if CYTHON_COMPILING_IN_LIMITED_API {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, #else {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, #endif #if CYTHON_COMPILING_IN_LIMITED_API {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, #else {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, #endif #endif {0, 0, 0, 0, 0} }; static PyObject * __Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) { PyObject *result = NULL; CYTHON_UNUSED_VAR(args); __Pyx_BEGIN_CRITICAL_SECTION(m); Py_INCREF(m->func_qualname); 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 CYTHON_COMPILING_IN_LIMITED_API #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) #else #define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) #endif static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { #if !CYTHON_COMPILING_IN_LIMITED_API PyCFunctionObject *cf = (PyCFunctionObject*) op; #endif if (unlikely(op == NULL)) return NULL; #if CYTHON_COMPILING_IN_LIMITED_API op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); if (unlikely(!op->func)) return NULL; #endif op->flags = flags; __Pyx_CyFunction_weakreflist(op) = NULL; #if !CYTHON_COMPILING_IN_LIMITED_API cf->m_ml = ml; cf->m_self = (PyObject *) op; #endif Py_XINCREF(closure); op->func_closure = closure; #if !CYTHON_COMPILING_IN_LIMITED_API 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; op->func_doc = NULL; #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API op->func_classobj = NULL; #else ((PyCMethodObject*)op)->mm_class = NULL; #endif op->func_globals = globals; Py_INCREF(op->func_globals); Py_XINCREF(code); op->func_code = code; op->defaults = NULL; op->defaults_tuple = NULL; op->defaults_kwdict = NULL; op->defaults_getter = NULL; op->func_annotations = NULL; op->func_is_coroutine = NULL; #if CYTHON_METH_FASTCALL switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { case METH_NOARGS: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; break; case METH_O: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; break; case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; break; case METH_FASTCALL | METH_KEYWORDS: __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; break; case METH_VARARGS | METH_KEYWORDS: __Pyx_CyFunction_func_vectorcall(op) = NULL; break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); Py_DECREF(op); return NULL; } #endif return (PyObject *) op; } static int __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) { Py_CLEAR(m->func_closure); #if CYTHON_COMPILING_IN_LIMITED_API Py_CLEAR(m->func); #else Py_CLEAR(((PyCFunctionObject*)m)->m_module); #endif #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API Py_CLEAR(m->func_dict); #elif PY_VERSION_HEX < 0x030d0000 _PyObject_ClearManagedDict((PyObject*)m); #else PyObject_ClearManagedDict((PyObject*)m); #endif Py_CLEAR(m->func_name); Py_CLEAR(m->func_qualname); Py_CLEAR(m->func_doc); Py_CLEAR(m->func_globals); Py_CLEAR(m->func_code); #if !CYTHON_COMPILING_IN_LIMITED_API #if PY_VERSION_HEX < 0x030900B1 Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); #else { PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; ((PyCMethodObject *) (m))->mm_class = NULL; Py_XDECREF(cls); } #endif #endif Py_CLEAR(m->defaults_tuple); Py_CLEAR(m->defaults_kwdict); Py_CLEAR(m->func_annotations); Py_CLEAR(m->func_is_coroutine); Py_CLEAR(m->defaults); return 0; } static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) { if (__Pyx_CyFunction_weakreflist(m) != NULL) PyObject_ClearWeakRefs((PyObject *) m); __Pyx_CyFunction_clear(m); __Pyx_PyHeapTypeObject_GC_Del(m); } static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) { PyObject_GC_UnTrack(m); __Pyx__CyFunction_dealloc(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); #else { int e = #if PY_VERSION_HEX < 0x030d0000 _PyObject_VisitManagedDict #else PyObject_VisitManagedDict #endif ((PyObject*)m, visit, arg); if (e != 0) return e; } #endif __Pyx_VISIT_CONST(m->func_name); __Pyx_VISIT_CONST(m->func_qualname); Py_VISIT(m->func_doc); Py_VISIT(m->func_globals); __Pyx_VISIT_CONST(m->func_code); #if !CYTHON_COMPILING_IN_LIMITED_API Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); #endif Py_VISIT(m->defaults_tuple); Py_VISIT(m->defaults_kwdict); Py_VISIT(m->func_is_coroutine); Py_VISIT(m->defaults); return 0; } static PyObject* __Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) { PyObject *repr; __Pyx_BEGIN_CRITICAL_SECTION(op); repr = PyUnicode_FromFormat("", op->func_qualname, (void *)op); __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; PyCFunction meth; int flags; meth = PyCFunction_GetFunction(f); if (unlikely(!meth)) return NULL; flags = PyCFunction_GetFlags(f); if (unlikely(flags < 0)) return NULL; #else PyCFunctionObject* f = (PyCFunctionObject*)func; PyCFunction meth = f->m_ml->ml_meth; int flags = f->m_ml->ml_flags; #endif Py_ssize_t size; switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { case METH_VARARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) return (*meth)(self, arg); break; case METH_VARARGS | METH_KEYWORDS: return (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, arg, kw); case METH_NOARGS: if (likely(kw == NULL || PyDict_Size(kw) == 0)) { #if CYTHON_ASSUME_SAFE_SIZE size = PyTuple_GET_SIZE(arg); #else size = PyTuple_Size(arg); if (unlikely(size < 0)) return NULL; #endif if (likely(size == 0)) return (*meth)(self, NULL); __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_SIZE size = PyTuple_GET_SIZE(arg); #else size = PyTuple_Size(arg); if (unlikely(size < 0)) return NULL; #endif if (likely(size == 1)) { PyObject *result, *arg0; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS arg0 = PyTuple_GET_ITEM(arg, 0); #else arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; #endif result = (*meth)(self, arg0); #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) Py_DECREF(arg0); #endif return result; } __Pyx_CyFunction_raise_argument_count_error( (__pyx_CyFunctionObject*)func, "takes exactly one argument", size); return NULL; } break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); return NULL; } __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) { PyObject *self, *result; #if CYTHON_COMPILING_IN_LIMITED_API self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); if (unlikely(!self) && PyErr_Occurred()) return NULL; #else self = ((PyCFunctionObject*)func)->m_self; #endif result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); return result; } static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { PyObject *result; __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; #if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); if (vc) { #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; return PyVectorcall_Call(func, args, kw); #endif } #endif if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { Py_ssize_t argc; PyObject *new_args; PyObject *self; #if CYTHON_ASSUME_SAFE_SIZE argc = PyTuple_GET_SIZE(args); #else argc = PyTuple_Size(args); if (unlikely(argc < 0)) return NULL; #endif new_args = PyTuple_GetSlice(args, 1, argc); if (unlikely(!new_args)) return NULL; self = PyTuple_GetItem(args, 0); if (unlikely(!self)) { Py_DECREF(new_args); PyErr_Format(PyExc_TypeError, "unbound method %.200S() needs an argument", cyfunc->func_qualname); return NULL; } result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); Py_DECREF(new_args); } else { result = __Pyx_CyFunction_Call(func, args, kw); } return result; } #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)) { __Pyx_CyFunction_raise_type_error( cyfunc, "needs an argument"); return -1; } ret = 1; } if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) { __Pyx_CyFunction_raise_type_error( cyfunc, "takes no keyword arguments"); return -1; } return ret; } static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) { __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); 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]; args += 1; 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)) { __Pyx_CyFunction_raise_argument_count_error( cyfunc, "takes no arguments", nargs); return 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; Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); 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]; args += 1; 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)) { __Pyx_CyFunction_raise_argument_count_error( cyfunc, "takes exactly one argument", nargs); return NULL; } 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; Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); 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]; args += 1; 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))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; PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); 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]; args += 1; 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 PY_VERSION_HEX < 0x030e00A6 size_t nargs_value = (size_t) nargs; #else Py_ssize_t nargs_value = nargs; #endif return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, nargs_value, kwnames); } #endif static PyType_Slot __pyx_CyFunctionType_slots[] = { {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, {Py_tp_methods, (void *)__pyx_CyFunction_methods}, {Py_tp_members, (void *)__pyx_CyFunction_members}, {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, {0, 0}, }; static PyType_Spec __pyx_CyFunctionType_spec = { __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", sizeof(__pyx_CyFunctionObject), 0, #ifdef Py_TPFLAGS_METHOD_DESCRIPTOR Py_TPFLAGS_METHOD_DESCRIPTOR | #endif #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 #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, __pyx_CyFunctionType_slots }; static int __pyx_CyFunction_init(PyObject *module) { __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 PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type); if (unlikely(!m->defaults)) return NULL; return m->defaults; } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults_tuple = tuple; Py_INCREF(tuple); } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults_kwdict = dict; Py_INCREF(dict); } static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->func_annotations = dict; Py_INCREF(dict); } /* CythonFunction */ 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_mstate_global->__pyx_CyFunctionType), ml, flags, qualname, closure, module, globals, code ); if (likely(op)) { PyObject_GC_Track(op); } return op; } /* Py3UpdateBases */ static PyObject* __Pyx_PEP560_update_bases(PyObject *bases) { Py_ssize_t i, j, size_bases; 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++) { #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) { goto error; } } continue; } meth = __Pyx_PyObject_GetAttrStrNoError(base, __pyx_mstate_global->__pyx_n_u_mro_entries); if (!meth && PyErr_Occurred()) { goto error; } if (!meth) { if (new_bases) { if (PyList_Append(new_bases, base) < 0) { goto error; } } continue; } new_base = __Pyx_PyObject_CallOneArg(meth, bases); Py_DECREF(meth); if (!new_base) { goto error; } if (!PyTuple_Check(new_base)) { PyErr_SetString(PyExc_TypeError, "__mro_entries__ must return a tuple"); Py_DECREF(new_base); goto error; } if (!new_bases) { if (!(new_bases = PyList_New(i))) { goto error; } for (j = 0; j < i; j++) { 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; } Py_DECREF(new_base); } if (!new_bases) { Py_INCREF(bases); return 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_SIZE nbases = PyTuple_GET_SIZE(bases); #else nbases = PyTuple_Size(bases); if (nbases < 0) return NULL; #endif for (i=0; i < nbases; i++) { PyTypeObject *tmptype; #if CYTHON_ASSUME_SAFE_MACROS PyObject *tmp = PyTuple_GET_ITEM(bases, i); #else PyObject *tmp = PyTuple_GetItem(bases, i); if (!tmp) return NULL; #endif tmptype = Py_TYPE(tmp); if (!metaclass) { metaclass = tmptype; continue; } if (PyType_IsSubtype(metaclass, tmptype)) continue; if (PyType_IsSubtype(tmptype, metaclass)) { metaclass = tmptype; continue; } PyErr_SetString(PyExc_TypeError, "metaclass conflict: " "the metaclass of a derived class " "must be a (non-strict) subclass " "of the metaclasses of all its bases"); return NULL; } if (!metaclass) { metaclass = &PyType_Type; } Py_INCREF((PyObject*) metaclass); return (PyObject*) metaclass; } /* 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); res = _PyType_Lookup(tp, attr_name); if (likely(res)) { descrgetfunc f = Py_TYPE(res)->tp_descr_get; if (!f) { Py_INCREF(res); } else { res = f(res, obj, (PyObject *)tp); } } else if (with_error) { PyErr_SetObject(PyExc_AttributeError, attr_name); } return res; } #endif /* Py3ClassCreate */ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { PyObject *ns; if (metaclass) { 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); Py_DECREF(prep); } else { if (unlikely(PyErr_Occurred())) return NULL; ns = PyDict_New(); } } else { ns = PyDict_New(); } if (unlikely(!ns)) return NULL; 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; } static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass) { PyObject *result; PyObject *owned_metaclass = NULL; PyObject *margs[4] = {NULL, name, bases, dict}; if (allow_py2_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))) { PyErr_Clear(); } else { return NULL; } } if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); Py_XDECREF(owned_metaclass); if (unlikely(!metaclass)) return NULL; owned_metaclass = metaclass; } result = __Pyx_PyObject_FastCallDict(metaclass, margs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw); Py_XDECREF(owned_metaclass); 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__pyx_d, level); } /* ImportFrom */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { const char* module_name_str = 0; PyObject* module_name = 0; PyObject* module_dot = 0; PyObject* full_name = 0; PyErr_Clear(); module_name_str = PyModule_GetName(module); 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_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 (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) ||\ CYTHON_COMPILING_IN_GRAAL { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) goto modbad; value = PyObject_GetItem(modules, full_name); } #else value = PyImport_GetModule(full_name); #endif modbad: Py_XDECREF(full_name); Py_XDECREF(module_dot); Py_XDECREF(module_name); } if (unlikely(!value)) { PyErr_Format(PyExc_ImportError, "cannot import name %S", name); } return value; } /* 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_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 *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 } /* append */ 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_mstate_global->__pyx_n_u_append, x); if (unlikely(!retval)) return -1; Py_DECREF(retval); } return 0; } /* 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 = NULL; PyObject *ptype, *pvalue, *ptraceback; PyObject *cython_runtime_dict; CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_mstate_global->__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); 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_SetDefault(cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False)) } 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 (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) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } 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(!code_cache->entries)) { return NULL; } 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 = code_cache->entries[pos].code_object; Py_INCREF(code_object); return 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 = code_cache->entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { 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(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 (code_cache->count == code_cache->max_count) { int new_max = code_cache->max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( code_cache->entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } code_cache->entries = entries; code_cache->max_count = new_max; } 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; 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 && !defined(PYPY_VERSION) #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif #if CYTHON_COMPILING_IN_LIMITED_API static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, PyObject *firstlineno, PyObject *name) { PyObject *replace = NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; replace = PyObject_GetAttrString(code, "replace"); if (likely(replace)) { PyObject *result = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict); Py_DECREF(replace); return result; } PyErr_Clear(); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; PyObject *replace = NULL, *getframe = NULL, *frame = NULL; PyObject *exc_type, *exc_value, *exc_traceback; int success = 0; if (c_line) { c_line = __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); } PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); code_object = __pyx_find_code_object(c_line ? -c_line : py_line); 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(); } getframe = PySys_GetObject("_getframe"); if (unlikely(!getframe)) goto bad; if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; frame = PyEval_EvalCode(code_object, dict, dict); if (unlikely(!frame) || frame == Py_None) goto bad; success = 1; bad: PyErr_Restore(exc_type, exc_value, exc_traceback); Py_XDECREF(code_object); Py_XDECREF(py_py_line); Py_XDECREF(py_funcname); Py_XDECREF(dict); Py_XDECREF(replace); if (success) { PyTraceBack_Here( (struct _frame*)frame); } Py_XDECREF(frame); } #else static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = NULL; PyObject *py_funcname = NULL; if (c_line) { 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; } py_code = PyCode_NewEmpty(filename, funcname, py_line); Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject *ptype, *pvalue, *ptraceback; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) { /* If the code object creation fails, then we should clear the fetched exception references and propagate the new exception */ Py_XDECREF(ptype); Py_XDECREF(pvalue); Py_XDECREF(ptraceback); goto bad; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_mstate_global->__pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } #endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* Declarations */ #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) #ifdef __cplusplus static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return ::std::complex< float >(x, y); } #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { return x + y*(__pyx_t_float_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { __pyx_t_float_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_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_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_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabsf(b.real) >= fabsf(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { float r = b.imag / b.real; float s = (float)(1.0) / (b.real + b.imag * r); return __pyx_t_float_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { float r = b.real / b.imag; float s = (float)(1.0) / (b.imag + b.real * r); return __pyx_t_float_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { if (b.imag == 0) { return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); } else { float denom = b.real * b.real + b.imag * b.imag; return __pyx_t_float_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_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { __pyx_t_float_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrtf(z.real*z.real + z.imag*z.imag); #else return hypotf(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { __pyx_t_float_complex z; float r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { float 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_float(a, a); case 3: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, a); case 4: z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if ((b.imag == 0) && (a.real >= 0)) { z.real = powf(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2f(0.0, -1.0); } } else { r = __Pyx_c_abs_float(a); theta = atan2f(a.imag, a.real); } lnr = logf(r); z_r = expf(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cosf(z_theta); z.imag = z_r * sinf(z_theta); return z; } #endif #endif /* Declarations */ #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) #ifdef __cplusplus static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return ::std::complex< double >(x, y); } #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { return x + y*(__pyx_t_double_complex)_Complex_I; } #endif #else static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { __pyx_t_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_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { return (a.real == b.real) && (a.imag == b.imag); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real + b.real; z.imag = a.imag + b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; z.real = a.real - b.real; z.imag = a.imag - b.imag; return z; } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_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_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else if (fabs(b.real) >= fabs(b.imag)) { if (b.real == 0 && b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); } else { double r = b.imag / b.real; double s = (double)(1.0) / (b.real + b.imag * r); return __pyx_t_double_complex_from_parts( (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); } } else { double r = b.real / b.imag; double s = (double)(1.0) / (b.imag + b.real * r); return __pyx_t_double_complex_from_parts( (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); } } #else static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { if (b.imag == 0) { return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); } else { double denom = b.real * b.real + b.imag * b.imag; return __pyx_t_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_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = -a.real; z.imag = -a.imag; return z; } static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { return (a.real == 0) && (a.imag == 0); } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { __pyx_t_double_complex z; z.real = a.real; z.imag = -a.imag; return z; } #if 1 static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { #if !defined(HAVE_HYPOT) || defined(_MSC_VER) return sqrt(z.real*z.real + z.imag*z.imag); #else return hypot(z.real, z.imag); #endif } static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { __pyx_t_double_complex z; double r, lnr, theta, z_r, z_theta; if (b.imag == 0 && b.real == (int)b.real) { if (b.real < 0) { 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_double(a, a); case 3: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, a); case 4: z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(z, z); } } if (a.imag == 0) { if (a.real == 0) { return a; } else if ((b.imag == 0) && (a.real >= 0)) { z.real = pow(a.real, b.real); z.imag = 0; return z; } else if (a.real > 0) { r = a.real; theta = 0; } else { r = -a.real; theta = atan2(0.0, -1.0); } } else { r = __Pyx_c_abs_double(a); theta = atan2(a.imag, a.real); } lnr = log(r); z_r = exp(lnr * b.real - theta * b.imag); z_theta = theta * b.real + lnr * b.imag; z.real = z_r * cos(z_theta); z.imag = z_r * sin(z_theta); return z; } #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_PyLong_As_TA_RetCode(PyObject *x) { #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(!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])); } } 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; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 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)) } 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]))); } } 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) > 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) > 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; } } #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)); } { int result = PyObject_RichCompareBool(v, Py_False, Py_LT); if (unlikely(result < 0)) { Py_DECREF(v); 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; } 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: PyErr_SetString(PyExc_OverflowError, "value too large to convert to TA_RetCode"); return (TA_RetCode) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to TA_RetCode"); return (TA_RetCode) -1; } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; 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])); } } 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; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 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)) } 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]))); } } 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) > 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) > 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; } } #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 result = PyObject_RichCompareBool(v, Py_False, Py_LT); if (unlikely(result < 0)) { Py_DECREF(v); 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; } 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: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const int neg_one = (int) -1, const_zero = (int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #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 PyLong_FromLong((long) value); } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); } } { unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 if (is_unsigned) { return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); } else { return PyLong_FromNativeBytes(bytes, sizeof(value), -1); } #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 int one = 1; int little = (int)*(unsigned char *)&one; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); #else int one = 1; int little = (int)*(unsigned char *)&one; PyObject *from_bytes, *result = NULL, *kwds = NULL; PyObject *py_bytes = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; { PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; if (!is_unsigned) { kwds = __Pyx_MakeVectorcallBuilderKwds(1); if (!kwds) goto limited_bad; if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; } result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); } limited_bad: Py_XDECREF(kwds); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntFromPy */ static CYTHON_INLINE TA_FuncUnstId __Pyx_PyLong_As_TA_FuncUnstId(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const TA_FuncUnstId neg_one = (TA_FuncUnstId) -1, const_zero = (TA_FuncUnstId) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; 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])); } } 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; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 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)) } 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]))); } } 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) > 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) > 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; } } #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)); } { int result = PyObject_RichCompareBool(v, Py_False, Py_LT); if (unlikely(result < 0)) { Py_DECREF(v); 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; } 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: PyErr_SetString(PyExc_OverflowError, "value too large to convert to TA_FuncUnstId"); return (TA_FuncUnstId) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to TA_FuncUnstId"); return (TA_FuncUnstId) -1; } /* CIntFromPy */ 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" #endif const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; 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])); } } 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; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 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)) } 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]))); } } 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) > 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) > 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; } } #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)); } { int result = PyObject_RichCompareBool(v, Py_False, Py_LT); if (unlikely(result < 0)) { Py_DECREF(v); 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; } 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: PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned int"); return (unsigned int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned int"); return (unsigned int) -1; } /* CIntToPy */ 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" #endif const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(unsigned int) < sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(unsigned int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #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 PyLong_FromLong((long) value); } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); } } { unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 if (is_unsigned) { return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); } else { return PyLong_FromNativeBytes(bytes, sizeof(value), -1); } #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 int one = 1; int little = (int)*(unsigned char *)&one; return _PyLong_FromByteArray(bytes, sizeof(unsigned int), little, !is_unsigned); #else int one = 1; int little = (int)*(unsigned char *)&one; PyObject *from_bytes, *result = NULL, *kwds = NULL; PyObject *py_bytes = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned int)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; { PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; if (!is_unsigned) { kwds = __Pyx_MakeVectorcallBuilderKwds(1); if (!kwds) goto limited_bad; if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; } result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); } limited_bad: Py_XDECREF(kwds); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntFromPy */ static CYTHON_INLINE TA_Compatibility __Pyx_PyLong_As_TA_Compatibility(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const TA_Compatibility neg_one = (TA_Compatibility) -1, const_zero = (TA_Compatibility) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; 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])); } } 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; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 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)) } 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]))); } } 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) > 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) > 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; } } #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)); } { int result = PyObject_RichCompareBool(v, Py_False, Py_LT); if (unlikely(result < 0)) { Py_DECREF(v); 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; } 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: PyErr_SetString(PyExc_OverflowError, "value too large to convert to TA_Compatibility"); return (TA_Compatibility) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to TA_Compatibility"); return (TA_Compatibility) -1; } /* CIntFromPy */ 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" #endif const TA_CandleSettingType neg_one = (TA_CandleSettingType) -1, const_zero = (TA_CandleSettingType) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; 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])); } } 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; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 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)) } 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]))); } } 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) > 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) > 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; } } #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)); } { int result = PyObject_RichCompareBool(v, Py_False, Py_LT); if (unlikely(result < 0)) { Py_DECREF(v); 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; } 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: PyErr_SetString(PyExc_OverflowError, "value too large to convert to TA_CandleSettingType"); return (TA_CandleSettingType) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to TA_CandleSettingType"); return (TA_CandleSettingType) -1; } /* CIntFromPy */ 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" #endif const TA_RangeType neg_one = (TA_RangeType) -1, const_zero = (TA_RangeType) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; 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])); } } 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; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 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)) } 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]))); } } 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) > 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) > 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; } } #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)); } { int result = PyObject_RichCompareBool(v, Py_False, Py_LT); if (unlikely(result < 0)) { Py_DECREF(v); 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; } 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: PyErr_SetString(PyExc_OverflowError, "value too large to convert to TA_RangeType"); return (TA_RangeType) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to TA_RangeType"); return (TA_RangeType) -1; } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #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 PyLong_FromLong((long) value); } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); } } { unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 if (is_unsigned) { return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); } else { return PyLong_FromNativeBytes(bytes, sizeof(value), -1); } #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 int one = 1; int little = (int)*(unsigned char *)&one; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); #else int one = 1; int little = (int)*(unsigned char *)&one; PyObject *from_bytes, *result = NULL, *kwds = NULL; PyObject *py_bytes = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; { PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; if (!is_unsigned) { kwds = __Pyx_MakeVectorcallBuilderKwds(1); if (!kwds) goto limited_bad; if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; } result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); } limited_bad: Py_XDECREF(kwds); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntToPy */ 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" #endif const TA_OptInputParameterType neg_one = (TA_OptInputParameterType) -1, const_zero = (TA_OptInputParameterType) 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_OptInputParameterType) < sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(TA_OptInputParameterType) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #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 PyLong_FromLong((long) value); } else if (sizeof(TA_OptInputParameterType) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); } } { unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 if (is_unsigned) { return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); } else { return PyLong_FromNativeBytes(bytes, sizeof(value), -1); } #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 int one = 1; int little = (int)*(unsigned char *)&one; return _PyLong_FromByteArray(bytes, sizeof(TA_OptInputParameterType), little, !is_unsigned); #else int one = 1; int little = (int)*(unsigned char *)&one; PyObject *from_bytes, *result = NULL, *kwds = NULL; PyObject *py_bytes = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(TA_OptInputParameterType)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; { PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; if (!is_unsigned) { kwds = __Pyx_MakeVectorcallBuilderKwds(1); if (!kwds) goto limited_bad; if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; } result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); } limited_bad: Py_XDECREF(kwds); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntToPy */ 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" #endif const TA_FuncFlags neg_one = (TA_FuncFlags) -1, const_zero = (TA_FuncFlags) 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_FuncFlags) < sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(TA_FuncFlags) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #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 PyLong_FromLong((long) value); } else if (sizeof(TA_FuncFlags) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); } } { unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 if (is_unsigned) { return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); } else { return PyLong_FromNativeBytes(bytes, sizeof(value), -1); } #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 int one = 1; int little = (int)*(unsigned char *)&one; return _PyLong_FromByteArray(bytes, sizeof(TA_FuncFlags), little, !is_unsigned); #else int one = 1; int little = (int)*(unsigned char *)&one; PyObject *from_bytes, *result = NULL, *kwds = NULL; PyObject *py_bytes = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(TA_FuncFlags)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; { PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; if (!is_unsigned) { kwds = __Pyx_MakeVectorcallBuilderKwds(1); if (!kwds) goto limited_bad; if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; } result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); } limited_bad: Py_XDECREF(kwds); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntToPy */ 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" #endif const TA_InputFlags neg_one = (TA_InputFlags) -1, const_zero = (TA_InputFlags) 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_InputFlags) < sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(TA_InputFlags) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #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 PyLong_FromLong((long) value); } else if (sizeof(TA_InputFlags) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); } } { unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 if (is_unsigned) { return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); } else { return PyLong_FromNativeBytes(bytes, sizeof(value), -1); } #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 int one = 1; int little = (int)*(unsigned char *)&one; return _PyLong_FromByteArray(bytes, sizeof(TA_InputFlags), little, !is_unsigned); #else int one = 1; int little = (int)*(unsigned char *)&one; PyObject *from_bytes, *result = NULL, *kwds = NULL; PyObject *py_bytes = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(TA_InputFlags)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; { PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; if (!is_unsigned) { kwds = __Pyx_MakeVectorcallBuilderKwds(1); if (!kwds) goto limited_bad; if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; } result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); } limited_bad: Py_XDECREF(kwds); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* CIntToPy */ 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" #endif const TA_OutputFlags neg_one = (TA_OutputFlags) -1, const_zero = (TA_OutputFlags) 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_OutputFlags) < sizeof(long)) { return PyLong_FromLong((long) value); } else if (sizeof(TA_OutputFlags) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #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 PyLong_FromLong((long) value); } else if (sizeof(TA_OutputFlags) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); } } { unsigned char *bytes = (unsigned char *)&value; #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 if (is_unsigned) { return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); } else { return PyLong_FromNativeBytes(bytes, sizeof(value), -1); } #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 int one = 1; int little = (int)*(unsigned char *)&one; return _PyLong_FromByteArray(bytes, sizeof(TA_OutputFlags), little, !is_unsigned); #else int one = 1; int little = (int)*(unsigned char *)&one; PyObject *from_bytes, *result = NULL, *kwds = NULL; PyObject *py_bytes = NULL, *order_str = NULL; from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); if (!from_bytes) return NULL; py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(TA_OutputFlags)); if (!py_bytes) goto limited_bad; order_str = PyUnicode_FromString(little ? "little" : "big"); if (!order_str) goto limited_bad; { PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; if (!is_unsigned) { kwds = __Pyx_MakeVectorcallBuilderKwds(1); if (!kwds) goto limited_bad; if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; } result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); } limited_bad: Py_XDECREF(kwds); Py_XDECREF(order_str); Py_XDECREF(py_bytes); Py_XDECREF(from_bytes); return result; #endif } } /* FormatTypeName */ #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) { 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); } goto done; } #endif /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) { #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const long neg_one = (long) -1, const_zero = (long) 0; #ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; 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])); } } 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; } } #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 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)) } 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]))); } } 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) > 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) > 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; } } #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)); } { int result = PyObject_RichCompareBool(v, Py_False, Py_LT); if (unlikely(result < 0)) { Py_DECREF(v); 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; } 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: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (cls == a || cls == b) return 1; mro = cls->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { PyObject *base = PyTuple_GET_ITEM(mro, i); if (base == (PyObject *)a || base == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); } 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); } else { return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } } 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); for (i=0; i>= 8; ++i; } __Pyx_cached_runtime_version = version; } } #endif static unsigned long __Pyx_get_runtime_version(void) { #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 return Py_Version & ~0xFFUL; #else return __Pyx_cached_runtime_version; #endif } /* 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)) return 0; if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) return 1; { char message[200]; PyOS_snprintf(message, sizeof(message), "compile time Python version %d.%d " "of module '%.100s' " "%s " "runtime version %d.%d", (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), __Pyx_MODULE_NAME, (allow_newer) ? "was newer than" : "does not match", (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) ); return PyErr_WarnEx(NULL, message, 1); } } /* 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 { 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); } end: Py_XDECREF(code_type); Py_XDECREF(exception_table); Py_XDECREF(types_module); if (type) { PyErr_Restore(type, value, traceback); } return result; } #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 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 defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wcast-qual" #elif !defined(__INTEL_COMPILER) && defined(__GNUC__) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wcast-qual" #endif char *memview_bytes = (char*) s; #if defined(__clang__) #pragma clang diagnostic pop #elif !defined(__INTEL_COMPILER) && defined(__GNUC__) #pragma GCC diagnostic pop #endif #endif #if CYTHON_COMPILING_IN_LIMITED_API && !defined(PyBUF_READ) int memview_flags = 0x100; #else int memview_flags = PyBUF_READ; #endif compressed_bytes = PyMemoryView_FromMemory(memview_bytes, length, memview_flags); } 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 static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { size_t len = strlen(s); if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { PyErr_SetString(PyExc_OverflowError, "byte string is too long"); return -1; } return (Py_ssize_t) len; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { Py_ssize_t len = __Pyx_ssize_strlen(c_str); if (unlikely(len < 0)) return NULL; return __Pyx_PyUnicode_FromStringAndSize(c_str, len); } static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { Py_ssize_t len = __Pyx_ssize_strlen(c_str); if (unlikely(len < 0)) return NULL; return PyByteArray_FromStringAndSize(c_str, len); } 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_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 { 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; } #else #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #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_UTF8 if (PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif 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 *length = PyByteArray_Size(o); if (*length == -1) return NULL; return PyByteArray_AsString(o); #endif } else { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } 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 "). " "The ability to return an instance of a strict subclass of int is deprecated, " "and may be removed in a future version of Python.", result_type_name)) { __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } __Pyx_DECREF_TypeName(result_type_name); return result; } PyErr_Format(PyExc_TypeError, "__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_Long(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif PyObject *res = NULL; if (likely(PyLong_Check(x))) return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; if (likely(m && m->nb_int)) { res = m->nb_int(x); } #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Long(x); } #endif if (likely(res)) { if (unlikely(!PyLong_CheckExact(res))) { return __Pyx_PyNumber_LongWrongResultType(res); } } else if (!PyErr_Occurred()) { 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 (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS if (likely(__Pyx_PyLong_IsCompact(b))) { return __Pyx_PyLong_CompactValue(b); } else { const digit* digits = __Pyx_PyLong_Digits(b); const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; 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); } else { Py_ssize_t ival; PyObject *x; x = PyNumber_Index(o); if (!x) return -1; 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 __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 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 #pragma warning( pop ) #endif /* #### Code section: end ### */ #endif /* Py_PYTHON_H */ ================================================ FILE: talib/_ta_lib.pxd ================================================ #cython: language_level=2 cdef extern from "ta-lib/ta_defs.h": ctypedef int TA_RetCode 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 const TA_Compatibility TA_COMPATIBILITY_DEFAULT = 0 const TA_Compatibility TA_COMPATIBILITY_METASTOCK = 1 ctypedef int TA_MAType 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 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 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 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() const char *TA_GetVersionMajor() const char *TA_GetVersionMinor() const char *TA_GetVersionBuild() const char *TA_GetVersionDate() const char *TA_GetVersionTime() ctypedef double TA_Real ctypedef int TA_Integer ctypedef struct TA_StringTable: unsigned int size const char **string void *hiddenData ctypedef struct TA_RetCodeInfo: const char* enumStr const char* infoStr void TA_SetRetCodeInfo(TA_RetCode theRetCode, TA_RetCodeInfo *retCodeInfo) TA_RetCode TA_Initialize() TA_RetCode TA_Shutdown() cdef extern from "ta-lib/ta_abstract.h": TA_RetCode TA_GroupTableAlloc(TA_StringTable **table) TA_RetCode TA_GroupTableFree(TA_StringTable *table) TA_RetCode TA_FuncTableAlloc(const char *group, TA_StringTable **table) TA_RetCode TA_FuncTableFree(TA_StringTable *table) ctypedef unsigned int TA_FuncHandle TA_RetCode TA_GetFuncHandle(const char *name, const TA_FuncHandle **handle) ctypedef int TA_FuncFlags ctypedef struct TA_FuncInfo: const char *name const char *group const char *hint const char *camelCaseName TA_FuncFlags flags unsigned int nbInput unsigned int nbOptInput unsigned int nbOutput const TA_FuncHandle *handle TA_RetCode TA_GetFuncInfo(const TA_FuncHandle *handle, const TA_FuncInfo **funcInfo) ctypedef int TA_InputParameterType 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 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 const TA_OutputParameterType TA_Output_Real = 0 const TA_OutputParameterType TA_Output_Integer = 1 ctypedef int TA_InputFlags ctypedef int TA_OptInputFlags ctypedef int TA_OutputFlags ctypedef struct TA_InputParameterInfo: TA_InputParameterType type const char *paramName TA_InputFlags flags ctypedef struct TA_OptInputParameterInfo: TA_OptInputParameterType type const char *paramName TA_OptInputFlags flags const char *displayName const void *dataSet TA_Real defaultValue const char *hint const char *helpFile ctypedef struct TA_OutputParameterInfo: TA_OutputParameterType type const char *paramName TA_OutputFlags flags TA_RetCode TA_GetInputParameterInfo(const TA_FuncHandle *handle, unsigned int paramIndex, const TA_InputParameterInfo **info) TA_RetCode TA_GetOptInputParameterInfo(const TA_FuncHandle *handle, unsigned int paramIndex, const TA_OptInputParameterInfo **info) TA_RetCode TA_GetOutputParameterInfo(const TA_FuncHandle *handle, unsigned int paramIndex, const TA_OutputParameterInfo **info) ctypedef struct TA_ParamHolder: void *hiddenData TA_RetCode TA_ParamHolderAlloc(const TA_FuncHandle *handle, TA_ParamHolder **allocatedParams) # get_lookback() TA_RetCode TA_ParamHolderFree(TA_ParamHolder *params) TA_RetCode TA_SetOptInputParamInteger(TA_ParamHolder *params, unsigned int paramIndex, TA_Integer optInValue) TA_RetCode TA_SetOptInputParamReal(TA_ParamHolder *params, unsigned int paramIndex, TA_Real optInValue) TA_RetCode TA_GetLookback(const TA_ParamHolder *params, TA_Integer *lookback) TA_RetCode TA_CallFunc(const TA_ParamHolder *params, TA_Integer startIdx, TA_Integer endIdx, TA_Integer *outBegIdx, TA_Integer *outNbElement) 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[]) int TA_AD_Lookback() TA_RetCode TA_ADD(int startIdx, int endIdx, const double inReal0[], const double inReal1[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_ADD_Lookback() TA_RetCode TA_ADOSC(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], const double inVolume[], int optInFastPeriod, int optInSlowPeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_ADOSC_Lookback(int optInFastPeriod, int optInSlowPeriod) TA_RetCode TA_ADX(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_ADX_Lookback(int optInTimePeriod) TA_RetCode TA_ADXR(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_ADXR_Lookback(int optInTimePeriod) TA_RetCode TA_APO(int startIdx, int endIdx, const double inReal[], int optInFastPeriod, int optInSlowPeriod, TA_MAType optInMAType, int *outBegIdx, int *outNBElement, double outReal[]) int TA_APO_Lookback(int optInFastPeriod, int optInSlowPeriod, TA_MAType optInMAType) TA_RetCode TA_AROON(int startIdx, int endIdx, const double inHigh[], const double inLow[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outAroonDown[], double outAroonUp[]) int TA_AROON_Lookback(int optInTimePeriod) TA_RetCode TA_AROONOSC(int startIdx, int endIdx, const double inHigh[], const double inLow[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_AROONOSC_Lookback(int optInTimePeriod) TA_RetCode TA_ASIN(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_ASIN_Lookback() TA_RetCode TA_ATAN(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_ATAN_Lookback() TA_RetCode TA_ATR(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) 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[]) int TA_BETA_Lookback(int optInTimePeriod) TA_RetCode TA_BOP(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_BOP_Lookback() TA_RetCode TA_CCI(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_CCI_Lookback(int optInTimePeriod) TA_RetCode TA_CDL2CROWS(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDL2CROWS_Lookback() TA_RetCode TA_CDL3BLACKCROWS(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDL3BLACKCROWS_Lookback() TA_RetCode TA_CDL3INSIDE(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDL3INSIDE_Lookback() TA_RetCode TA_CDL3LINESTRIKE(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDL3LINESTRIKE_Lookback() TA_RetCode TA_CDL3OUTSIDE(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDL3OUTSIDE_Lookback() TA_RetCode TA_CDL3STARSINSOUTH(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDL3STARSINSOUTH_Lookback() TA_RetCode TA_CDL3WHITESOLDIERS(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDL3WHITESOLDIERS_Lookback() TA_RetCode TA_CDLABANDONEDBABY(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], double optInPenetration, int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLABANDONEDBABY_Lookback(double optInPenetration) TA_RetCode TA_CDLADVANCEBLOCK(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLADVANCEBLOCK_Lookback() TA_RetCode TA_CDLBELTHOLD(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLBELTHOLD_Lookback() TA_RetCode TA_CDLBREAKAWAY(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLBREAKAWAY_Lookback() TA_RetCode TA_CDLCLOSINGMARUBOZU(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLCLOSINGMARUBOZU_Lookback() TA_RetCode TA_CDLCONCEALBABYSWALL(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLCONCEALBABYSWALL_Lookback() TA_RetCode TA_CDLCOUNTERATTACK(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLCOUNTERATTACK_Lookback() TA_RetCode TA_CDLDARKCLOUDCOVER(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], double optInPenetration, int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLDARKCLOUDCOVER_Lookback(double optInPenetration) TA_RetCode TA_CDLDOJI(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLDOJI_Lookback() TA_RetCode TA_CDLDOJISTAR(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLDOJISTAR_Lookback() TA_RetCode TA_CDLDRAGONFLYDOJI(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLDRAGONFLYDOJI_Lookback() TA_RetCode TA_CDLENGULFING(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLENGULFING_Lookback() TA_RetCode TA_CDLEVENINGDOJISTAR(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], double optInPenetration, int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLEVENINGDOJISTAR_Lookback(double optInPenetration) TA_RetCode TA_CDLEVENINGSTAR(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], double optInPenetration, int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLEVENINGSTAR_Lookback(double optInPenetration) TA_RetCode TA_CDLGAPSIDESIDEWHITE(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLGAPSIDESIDEWHITE_Lookback() TA_RetCode TA_CDLGRAVESTONEDOJI(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLGRAVESTONEDOJI_Lookback() TA_RetCode TA_CDLHAMMER(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLHAMMER_Lookback() TA_RetCode TA_CDLHANGINGMAN(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLHANGINGMAN_Lookback() TA_RetCode TA_CDLHARAMI(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLHARAMI_Lookback() TA_RetCode TA_CDLHARAMICROSS(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLHARAMICROSS_Lookback() TA_RetCode TA_CDLHIGHWAVE(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLHIGHWAVE_Lookback() TA_RetCode TA_CDLHIKKAKE(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLHIKKAKE_Lookback() TA_RetCode TA_CDLHIKKAKEMOD(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLHIKKAKEMOD_Lookback() TA_RetCode TA_CDLHOMINGPIGEON(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLHOMINGPIGEON_Lookback() TA_RetCode TA_CDLIDENTICAL3CROWS(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLIDENTICAL3CROWS_Lookback() TA_RetCode TA_CDLINNECK(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLINNECK_Lookback() TA_RetCode TA_CDLINVERTEDHAMMER(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLINVERTEDHAMMER_Lookback() TA_RetCode TA_CDLKICKING(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLKICKING_Lookback() TA_RetCode TA_CDLKICKINGBYLENGTH(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLKICKINGBYLENGTH_Lookback() TA_RetCode TA_CDLLADDERBOTTOM(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLLADDERBOTTOM_Lookback() TA_RetCode TA_CDLLONGLEGGEDDOJI(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLLONGLEGGEDDOJI_Lookback() TA_RetCode TA_CDLLONGLINE(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLLONGLINE_Lookback() TA_RetCode TA_CDLMARUBOZU(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLMARUBOZU_Lookback() TA_RetCode TA_CDLMATCHINGLOW(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLMATCHINGLOW_Lookback() TA_RetCode TA_CDLMATHOLD(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], double optInPenetration, int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLMATHOLD_Lookback(double optInPenetration) TA_RetCode TA_CDLMORNINGDOJISTAR(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], double optInPenetration, int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLMORNINGDOJISTAR_Lookback(double optInPenetration) TA_RetCode TA_CDLMORNINGSTAR(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], double optInPenetration, int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLMORNINGSTAR_Lookback(double optInPenetration) TA_RetCode TA_CDLONNECK(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLONNECK_Lookback() TA_RetCode TA_CDLPIERCING(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLPIERCING_Lookback() TA_RetCode TA_CDLRICKSHAWMAN(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLRICKSHAWMAN_Lookback() TA_RetCode TA_CDLRISEFALL3METHODS(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLRISEFALL3METHODS_Lookback() TA_RetCode TA_CDLSEPARATINGLINES(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLSEPARATINGLINES_Lookback() TA_RetCode TA_CDLSHOOTINGSTAR(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLSHOOTINGSTAR_Lookback() TA_RetCode TA_CDLSHORTLINE(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLSHORTLINE_Lookback() TA_RetCode TA_CDLSPINNINGTOP(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLSPINNINGTOP_Lookback() TA_RetCode TA_CDLSTALLEDPATTERN(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLSTALLEDPATTERN_Lookback() TA_RetCode TA_CDLSTICKSANDWICH(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLSTICKSANDWICH_Lookback() TA_RetCode TA_CDLTAKURI(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLTAKURI_Lookback() TA_RetCode TA_CDLTASUKIGAP(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLTASUKIGAP_Lookback() TA_RetCode TA_CDLTHRUSTING(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLTHRUSTING_Lookback() TA_RetCode TA_CDLTRISTAR(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLTRISTAR_Lookback() TA_RetCode TA_CDLUNIQUE3RIVER(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLUNIQUE3RIVER_Lookback() TA_RetCode TA_CDLUPSIDEGAP2CROWS(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLUPSIDEGAP2CROWS_Lookback() TA_RetCode TA_CDLXSIDEGAP3METHODS(int startIdx, int endIdx, const double inOpen[], const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, int outInteger[]) int TA_CDLXSIDEGAP3METHODS_Lookback() TA_RetCode TA_CEIL(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_CEIL_Lookback() TA_RetCode TA_CMO(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_CMO_Lookback(int optInTimePeriod) TA_RetCode TA_CORREL(int startIdx, int endIdx, const double inReal0[], const double inReal1[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_CORREL_Lookback(int optInTimePeriod) TA_RetCode TA_COS(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_COS_Lookback() TA_RetCode TA_COSH(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_COSH_Lookback() TA_RetCode TA_DEMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_DEMA_Lookback(int optInTimePeriod) TA_RetCode TA_DIV(int startIdx, int endIdx, const double inReal0[], const double inReal1[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_DIV_Lookback() TA_RetCode TA_DX(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_DX_Lookback(int optInTimePeriod) TA_RetCode TA_EMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_EMA_Lookback(int optInTimePeriod) TA_RetCode TA_EXP(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_EXP_Lookback() TA_RetCode TA_FLOOR(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_FLOOR_Lookback() TA_RetCode TA_HT_DCPERIOD(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_HT_DCPERIOD_Lookback() TA_RetCode TA_HT_DCPHASE(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_HT_DCPHASE_Lookback() TA_RetCode TA_HT_PHASOR(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outInPhase[], double outQuadrature[]) int TA_HT_PHASOR_Lookback() TA_RetCode TA_HT_SINE(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outSine[], double outLeadSine[]) int TA_HT_SINE_Lookback() TA_RetCode TA_HT_TRENDLINE(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) 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[]) int TA_LINEARREG_Lookback(int optInTimePeriod) TA_RetCode TA_LINEARREG_ANGLE(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_LINEARREG_ANGLE_Lookback(int optInTimePeriod) TA_RetCode TA_LINEARREG_INTERCEPT(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_LINEARREG_INTERCEPT_Lookback(int optInTimePeriod) TA_RetCode TA_LINEARREG_SLOPE(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_LINEARREG_SLOPE_Lookback(int optInTimePeriod) TA_RetCode TA_LN(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_LN_Lookback() TA_RetCode TA_LOG10(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_LOG10_Lookback() TA_RetCode TA_MA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, TA_MAType optInMAType, int *outBegIdx, int *outNBElement, double outReal[]) int TA_MA_Lookback(int optInTimePeriod, TA_MAType optInMAType) TA_RetCode TA_MACD(int startIdx, int endIdx, const double inReal[], int optInFastPeriod, int optInSlowPeriod, int optInSignalPeriod, int *outBegIdx, int *outNBElement, double outMACD[], double outMACDSignal[], double outMACDHist[]) int TA_MACD_Lookback(int optInFastPeriod, int optInSlowPeriod, int optInSignalPeriod) TA_RetCode TA_MACDEXT(int startIdx, int endIdx, const double inReal[], int optInFastPeriod, TA_MAType optInFastMAType, int optInSlowPeriod, TA_MAType optInSlowMAType, int optInSignalPeriod, TA_MAType optInSignalMAType, int *outBegIdx, int *outNBElement, double outMACD[], double outMACDSignal[], double outMACDHist[]) int TA_MACDEXT_Lookback(int optInFastPeriod, TA_MAType optInFastMAType, int optInSlowPeriod, TA_MAType optInSlowMAType, int optInSignalPeriod, TA_MAType optInSignalMAType) TA_RetCode TA_MACDFIX(int startIdx, int endIdx, const double inReal[], int optInSignalPeriod, int *outBegIdx, int *outNBElement, double outMACD[], double outMACDSignal[], double outMACDHist[]) int TA_MACDFIX_Lookback(int optInSignalPeriod) TA_RetCode TA_MAMA(int startIdx, int endIdx, const double inReal[], double optInFastLimit, double optInSlowLimit, int *outBegIdx, int *outNBElement, double outMAMA[], double outFAMA[]) int TA_MAMA_Lookback(double optInFastLimit, double optInSlowLimit) TA_RetCode TA_MAVP(int startIdx, int endIdx, const double inReal[], const double inPeriods[], int optInMinPeriod, int optInMaxPeriod, TA_MAType optInMAType, int *outBegIdx, int *outNBElement, double outReal[]) int TA_MAVP_Lookback(int optInMinPeriod, int optInMaxPeriod, TA_MAType optInMAType) TA_RetCode TA_MAX(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_MAX_Lookback(int optInTimePeriod) TA_RetCode TA_MAXINDEX(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, int outInteger[]) int TA_MAXINDEX_Lookback(int optInTimePeriod) TA_RetCode TA_MEDPRICE(int startIdx, int endIdx, const double inHigh[], const double inLow[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_MEDPRICE_Lookback() TA_RetCode TA_MFI(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], const double inVolume[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_MFI_Lookback(int optInTimePeriod) TA_RetCode TA_MIDPOINT(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_MIDPOINT_Lookback(int optInTimePeriod) TA_RetCode TA_MIDPRICE(int startIdx, int endIdx, const double inHigh[], const double inLow[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_MIDPRICE_Lookback(int optInTimePeriod) TA_RetCode TA_MIN(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_MIN_Lookback(int optInTimePeriod) TA_RetCode TA_MININDEX(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, int outInteger[]) int TA_MININDEX_Lookback(int optInTimePeriod) TA_RetCode TA_MINMAX(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outMin[], double outMax[]) int TA_MINMAX_Lookback(int optInTimePeriod) TA_RetCode TA_MINMAXINDEX(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, int outMinIdx[], int outMaxIdx[]) int TA_MINMAXINDEX_Lookback(int optInTimePeriod) TA_RetCode TA_MINUS_DI(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_MINUS_DI_Lookback(int optInTimePeriod) TA_RetCode TA_MINUS_DM(int startIdx, int endIdx, const double inHigh[], const double inLow[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_MINUS_DM_Lookback(int optInTimePeriod) TA_RetCode TA_MOM(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_MOM_Lookback(int optInTimePeriod) TA_RetCode TA_MULT(int startIdx, int endIdx, const double inReal0[], const double inReal1[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_MULT_Lookback() TA_RetCode TA_NATR(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_NATR_Lookback(int optInTimePeriod) TA_RetCode TA_OBV(int startIdx, int endIdx, const double inReal[], const double inVolume[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_OBV_Lookback() TA_RetCode TA_PLUS_DI(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_PLUS_DI_Lookback(int optInTimePeriod) TA_RetCode TA_PLUS_DM(int startIdx, int endIdx, const double inHigh[], const double inLow[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_PLUS_DM_Lookback(int optInTimePeriod) TA_RetCode TA_PPO(int startIdx, int endIdx, const double inReal[], int optInFastPeriod, int optInSlowPeriod, TA_MAType optInMAType, int *outBegIdx, int *outNBElement, double outReal[]) int TA_PPO_Lookback(int optInFastPeriod, int optInSlowPeriod, TA_MAType optInMAType) TA_RetCode TA_ROC(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_ROC_Lookback(int optInTimePeriod) TA_RetCode TA_ROCP(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_ROCP_Lookback(int optInTimePeriod) TA_RetCode TA_ROCR(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_ROCR_Lookback(int optInTimePeriod) TA_RetCode TA_ROCR100(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_ROCR100_Lookback(int optInTimePeriod) TA_RetCode TA_RSI(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) nogil int TA_RSI_Lookback(int optInTimePeriod) nogil TA_RetCode TA_SAR(int startIdx, int endIdx, const double inHigh[], const double inLow[], double optInAcceleration, double optInMaximum, int *outBegIdx, int *outNBElement, double outReal[]) int TA_SAR_Lookback(double optInAcceleration, double optInMaximum) TA_RetCode TA_SAREXT(int startIdx, int endIdx, const double inHigh[], const double inLow[], double optInStartValue, double optInOffsetOnReverse, double optInAccelerationInitLong, double optInAccelerationLong, double optInAccelerationMaxLong, double optInAccelerationInitShort, double optInAccelerationShort, double optInAccelerationMaxShort, int *outBegIdx, int *outNBElement, double outReal[]) int TA_SAREXT_Lookback(double optInStartValue, double optInOffsetOnReverse, double optInAccelerationInitLong, double optInAccelerationLong, double optInAccelerationMaxLong, double optInAccelerationInitShort, double optInAccelerationShort, double optInAccelerationMaxShort) TA_RetCode TA_SIN(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_SIN_Lookback() TA_RetCode TA_SINH(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_SINH_Lookback() TA_RetCode TA_SMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_SMA_Lookback(int optInTimePeriod) TA_RetCode TA_SQRT(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_SQRT_Lookback() TA_RetCode TA_STDDEV(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, double optInNbDev, int *outBegIdx, int *outNBElement, double outReal[]) int TA_STDDEV_Lookback(int optInTimePeriod, double optInNbDev) TA_RetCode TA_STOCH(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInFastK_Period, int optInSlowK_Period, TA_MAType optInSlowK_MAType, int optInSlowD_Period, TA_MAType optInSlowD_MAType, int *outBegIdx, int *outNBElement, double outSlowK[], double outSlowD[]) int TA_STOCH_Lookback(int optInFastK_Period, int optInSlowK_Period, TA_MAType optInSlowK_MAType, int optInSlowD_Period, TA_MAType optInSlowD_MAType) TA_RetCode TA_STOCHF(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInFastK_Period, int optInFastD_Period, TA_MAType optInFastD_MAType, int *outBegIdx, int *outNBElement, double outFastK[], double outFastD[]) int TA_STOCHF_Lookback(int optInFastK_Period, int optInFastD_Period, TA_MAType optInFastD_MAType) TA_RetCode TA_STOCHRSI(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int optInFastK_Period, int optInFastD_Period, TA_MAType optInFastD_MAType, int *outBegIdx, int *outNBElement, double outFastK[], double outFastD[]) int TA_STOCHRSI_Lookback(int optInTimePeriod, int optInFastK_Period, int optInFastD_Period, TA_MAType optInFastD_MAType) TA_RetCode TA_SUB(int startIdx, int endIdx, const double inReal0[], const double inReal1[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_SUB_Lookback() TA_RetCode TA_SUM(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_SUM_Lookback(int optInTimePeriod) TA_RetCode TA_T3(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, double optInVFactor, int *outBegIdx, int *outNBElement, double outReal[]) int TA_T3_Lookback(int optInTimePeriod, double optInVFactor) TA_RetCode TA_TAN(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_TAN_Lookback() TA_RetCode TA_TANH(int startIdx, int endIdx, const double inReal[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_TANH_Lookback() TA_RetCode TA_TEMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_TEMA_Lookback(int optInTimePeriod) TA_RetCode TA_TRANGE(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_TRANGE_Lookback() TA_RetCode TA_TRIMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_TRIMA_Lookback(int optInTimePeriod) TA_RetCode TA_TRIX(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_TRIX_Lookback(int optInTimePeriod) TA_RetCode TA_TSF(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_TSF_Lookback(int optInTimePeriod) TA_RetCode TA_TYPPRICE(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_TYPPRICE_Lookback() TA_RetCode TA_ULTOSC(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod1, int optInTimePeriod2, int optInTimePeriod3, int *outBegIdx, int *outNBElement, double outReal[]) int TA_ULTOSC_Lookback(int optInTimePeriod1, int optInTimePeriod2, int optInTimePeriod3) TA_RetCode TA_VAR(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, double optInNbDev, int *outBegIdx, int *outNBElement, double outReal[]) int TA_VAR_Lookback(int optInTimePeriod, double optInNbDev) TA_RetCode TA_WCLPRICE(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int *outBegIdx, int *outNBElement, double outReal[]) int TA_WCLPRICE_Lookback() TA_RetCode TA_WILLR(int startIdx, int endIdx, const double inHigh[], const double inLow[], const double inClose[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_WILLR_Lookback(int optInTimePeriod) TA_RetCode TA_WMA(int startIdx, int endIdx, const double inReal[], int optInTimePeriod, int *outBegIdx, int *outNBElement, double outReal[]) int TA_WMA_Lookback(int optInTimePeriod) # TALIB functions for TA_SetUnstablePeriod TA_RetCode TA_SetUnstablePeriod(TA_FuncUnstId id, unsigned int unstablePeriod) unsigned int TA_GetUnstablePeriod(TA_FuncUnstId id) # TALIB functions for TA_SetCompatibility TA_RetCode TA_SetCompatibility(TA_Compatibility value) TA_Compatibility TA_GetCompatibility() # TALIB functions for TA_SetCandleSettings TA_RetCode TA_SetCandleSettings(TA_CandleSettingType settingType, TA_RangeType rangeType, int avgPeriod, double factor) TA_RetCode TA_RestoreCandleDefaultSettings(TA_CandleSettingType) ================================================ FILE: talib/_ta_lib.pyi ================================================ 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]: ... ================================================ FILE: talib/_ta_lib.pyx ================================================ #cython: embedsignature=True, emit_code_comments=False include "_common.pxi" include "_func.pxi" include "_abstract.pxi" include "_stream.pxi" __all__ = __TA_FUNCTION_NAMES__ + ["stream_%s" % name for name in __TA_FUNCTION_NAMES__] ================================================ FILE: talib/abstract.py ================================================ import talib._ta_lib as _ta_lib from ._ta_lib import Function as _Function, __TA_FUNCTION_NAMES__, _get_defaults_and_docs # add some backwards compat for backtrader from ._ta_lib import TA_FUNC_FLAGS, TA_INPUT_FLAGS, TA_OUTPUT_FLAGS _func_obj_mapping = { func_name: getattr(_ta_lib, func_name) for func_name in __TA_FUNCTION_NAMES__ } def Function(function_name, *args, **kwargs): func_name = function_name.upper() if func_name not in _func_obj_mapping: raise Exception('%s not supported by TA-LIB.' % func_name) return _Function( func_name, _func_obj_mapping[func_name], *args, **kwargs ) for func_name in __TA_FUNCTION_NAMES__: globals()[func_name] = Function(func_name) __all__ = ["Function", "_get_defaults_and_docs"] + __TA_FUNCTION_NAMES__ ================================================ FILE: talib/abstract.pyi ================================================ from typing import overload, Tuple, Union import numpy as np import pandas as pd """HT_DCPERIOD(real) Hilbert Transform - Dominant Cycle Period (Cycle Indicators) Inputs: real: (any ndarray) Outputs: real""" @overload def HT_DCPERIOD(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def HT_DCPERIOD(real: pd.DataFrame) -> pd.Series: ... """HT_DCPHASE(real) Hilbert Transform - Dominant Cycle Phase (Cycle Indicators) Inputs: real: (any ndarray) Outputs: real""" @overload def HT_DCPHASE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def HT_DCPHASE(real: pd.DataFrame) -> pd.Series: ... """HT_PHASOR(real) Hilbert Transform - Phasor Components (Cycle Indicators) Inputs: real: (any ndarray) Outputs: inphase quadrature""" @overload def HT_PHASOR(real: Union[pd.Series, np.ndarray]) -> Tuple[np.ndarray, np.ndarray]: ... @overload def HT_PHASOR(real: pd.DataFrame) -> pd.DataFrame: ... """HT_SINE(real) Hilbert Transform - SineWave (Cycle Indicators) Inputs: real: (any ndarray) Outputs: sine leadsine""" @overload def HT_SINE(real: Union[pd.Series, np.ndarray]) -> Tuple[np.ndarray, np.ndarray]: ... @overload def HT_SINE(real: pd.DataFrame) -> pd.DataFrame: ... """HT_TRENDMODE(real) Hilbert Transform - Trend vs Cycle Mode (Cycle Indicators) Inputs: real: (any ndarray) Outputs: integer (values are -100, 0 or 100)""" @overload def HT_TRENDMODE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def HT_TRENDMODE(real: pd.DataFrame) -> pd.Series: ... """ADD(real0, real1) Vector Arithmetic Add (Math Operators) Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real""" @overload def ADD(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def ADD(real: pd.DataFrame) -> pd.Series: ... """DIV(real0, real1) Vector Arithmetic Div (Math Operators) Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real""" @overload def DIV(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def DIV(real: pd.DataFrame) -> pd.Series: ... """MAX(real[, timeperiod=?]) Highest value over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real""" @overload def MAX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def MAX(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... """MAXINDEX(real[, timeperiod=?]) Index of highest value over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: integer (values are -100, 0 or 100)""" @overload def MAXINDEX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def MAXINDEX(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... """MIN(real[, timeperiod=?]) Lowest value over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real""" @overload def MIN(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def MIN(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... """MININDEX(real[, timeperiod=?]) Index of lowest value over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: integer (values are -100, 0 or 100)""" @overload def MININDEX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def MININDEX(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... """MINMAX(real[, timeperiod=?]) Lowest and highest values over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: min max""" @overload def MINMAX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> Tuple[np.ndarray, np.ndarray]: ... @overload def MINMAX(real: pd.DataFrame, timeperiod=30) -> pd.DataFrame: ... """MINMAXINDEX(real[, timeperiod=?]) Indexes of lowest and highest values over a specified period (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: minidx maxidx""" @overload def MINMAXINDEX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> Tuple[np.ndarray, np.ndarray]: ... @overload def MINMAXINDEX(real: pd.DataFrame, timeperiod=30) -> pd.DataFrame: ... """MULT(real0, real1) Vector Arithmetic Mult (Math Operators) Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real""" @overload def MULT(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def MULT(real: pd.DataFrame) -> pd.Series: ... """SUB(real0, real1) Vector Arithmetic Subtraction (Math Operators) Inputs: real0: (any ndarray) real1: (any ndarray) Outputs: real""" @overload def SUB(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def SUB(real: pd.DataFrame) -> pd.Series: ... """SUM(real[, timeperiod=?]) Summation (Math Operators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real""" @overload def SUM(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def SUM(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... """ACOS(real) Vector Trigonometric ACos (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def ACOS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def ACOS(real: pd.DataFrame) -> pd.Series: ... """ASIN(real) Vector Trigonometric ASin (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def ASIN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def ASIN(real: pd.DataFrame) -> pd.Series: ... """ATAN(real) Vector Trigonometric ATan (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def ATAN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def ATAN(real: pd.DataFrame) -> pd.Series: ... """CEIL(real) Vector Ceil (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def CEIL(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CEIL(real: pd.DataFrame) -> pd.Series: ... """COS(real) Vector Trigonometric Cos (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def COS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def COS(real: pd.DataFrame) -> pd.Series: ... """COSH(real) Vector Trigonometric Cosh (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def COSH(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def COSH(real: pd.DataFrame) -> pd.Series: ... """EXP(real) Vector Arithmetic Exp (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def EXP(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def EXP(real: pd.DataFrame) -> pd.Series: ... """FLOOR(real) Vector Floor (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def FLOOR(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def FLOOR(real: pd.DataFrame) -> pd.Series: ... """LN(real) Vector Log Natural (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def LN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def LN(real: pd.DataFrame) -> pd.Series: ... """LOG10(real) Vector Log10 (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def LOG10(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def LOG10(real: pd.DataFrame) -> pd.Series: ... """SIN(real) Vector Trigonometric Sin (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def SIN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def SIN(real: pd.DataFrame) -> pd.Series: ... """SINH(real) Vector Trigonometric Sinh (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def SINH(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def SINH(real: pd.DataFrame) -> pd.Series: ... """SQRT(real) Vector Square Root (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def SQRT(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def SQRT(real: pd.DataFrame) -> pd.Series: ... """TAN(real) Vector Trigonometric Tan (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def TAN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def TAN(real: pd.DataFrame) -> pd.Series: ... """TANH(real) Vector Trigonometric Tanh (Math Transform) Inputs: real: (any ndarray) Outputs: real""" @overload def TANH(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def TANH(real: pd.DataFrame) -> pd.Series: ... """ADX(high, low, close[, timeperiod=?]) Average Directional Movement Index (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real""" @overload def ADX(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def ADX(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """ADXR(high, low, close[, timeperiod=?]) Average Directional Movement Index Rating (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real""" @overload def ADXR(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def ADXR(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """APO(real[, fastperiod=?, slowperiod=?, matype=?]) Absolute Price Oscillator (Momentum Indicators) Inputs: real: (any ndarray) Parameters: fastperiod: 12 slowperiod: 26 matype: 0 (Simple Moving Average) Outputs: real""" @overload def APO(real: Union[pd.Series, np.ndarray], fastperiod=12, slowperiod=26, matype=0) -> np.ndarray: ... @overload def APO(real: pd.DataFrame, fastperiod=12, slowperiod=26, matype=0) -> pd.Series: ... """AROON(high, low[, timeperiod=?]) Aroon (Momentum Indicators) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: aroondown aroonup""" @overload def AROON(real: Union[pd.Series, np.ndarray], timeperiod=14) -> Tuple[np.ndarray, np.ndarray]: ... @overload def AROON(real: pd.DataFrame, timeperiod=14) -> pd.DataFrame: ... """AROONOSC(high, low[, timeperiod=?]) Aroon Oscillator (Momentum Indicators) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real""" @overload def AROONOSC(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def AROONOSC(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """BOP(open, high, low, close) Balance Of Power (Momentum Indicators) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: real""" @overload def BOP(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def BOP(real: pd.DataFrame) -> pd.Series: ... """CCI(high, low, close[, timeperiod=?]) Commodity Channel Index (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real""" @overload def CCI(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def CCI(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """CMO(real[, timeperiod=?]) Chande Momentum Oscillator (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real""" @overload def CMO(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def CMO(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """DX(high, low, close[, timeperiod=?]) Directional Movement Index (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real""" @overload def DX(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def DX(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """MACD(real[, fastperiod=?, slowperiod=?, signalperiod=?]) Moving Average Convergence/Divergence (Momentum Indicators) Inputs: real: (any ndarray) Parameters: fastperiod: 12 slowperiod: 26 signalperiod: 9 Outputs: macd macdsignal macdhist""" @overload def MACD(real: Union[pd.Series, np.ndarray], fastperiod=12, slowperiod=26, signalperiod=9) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: ... @overload def MACD(real: pd.DataFrame, fastperiod=12, slowperiod=26, signalperiod=9) -> pd.DataFrame: ... """MACDEXT(real[, fastperiod=?, fastmatype=?, slowperiod=?, slowmatype=?, signalperiod=?, signalmatype=?]) MACD with controllable MA type (Momentum Indicators) Inputs: real: (any ndarray) Parameters: fastperiod: 12 fastmatype: 0 slowperiod: 26 slowmatype: 0 signalperiod: 9 signalmatype: 0 Outputs: macd macdsignal macdhist""" @overload def MACDEXT(real: Union[pd.Series, np.ndarray], fastperiod=12, fastmatype=0, slowperiod=26, slowmatype=0, signalperiod=9, signalmatype=0) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: ... @overload def MACDEXT(real: pd.DataFrame, fastperiod=12, fastmatype=0, slowperiod=26, slowmatype=0, signalperiod=9, signalmatype=0) -> pd.DataFrame: ... """MACDFIX(real[, signalperiod=?]) Moving Average Convergence/Divergence Fix 12/26 (Momentum Indicators) Inputs: real: (any ndarray) Parameters: signalperiod: 9 Outputs: macd macdsignal macdhist""" @overload def MACDFIX(real: Union[pd.Series, np.ndarray], signalperiod=9) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: ... @overload def MACDFIX(real: pd.DataFrame, signalperiod=9) -> pd.DataFrame: ... """MFI(high, low, close, volume[, timeperiod=?]) Money Flow Index (Momentum Indicators) Inputs: prices: ['high', 'low', 'close', 'volume'] Parameters: timeperiod: 14 Outputs: real""" @overload def MFI(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def MFI(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """MINUS_DI(high, low, close[, timeperiod=?]) Minus Directional Indicator (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real""" @overload def MINUS_DI(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def MINUS_DI(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """MINUS_DM(high, low[, timeperiod=?]) Minus Directional Movement (Momentum Indicators) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real""" @overload def MINUS_DM(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def MINUS_DM(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """MOM(real[, timeperiod=?]) Momentum (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 Outputs: real""" @overload def MOM(real: Union[pd.Series, np.ndarray], timeperiod=10) -> np.ndarray: ... @overload def MOM(real: pd.DataFrame, timeperiod=10) -> pd.Series: ... """PLUS_DI(high, low, close[, timeperiod=?]) Plus Directional Indicator (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real""" @overload def PLUS_DI(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def PLUS_DI(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """PLUS_DM(high, low[, timeperiod=?]) Plus Directional Movement (Momentum Indicators) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real""" @overload def PLUS_DM(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def PLUS_DM(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """PPO(real[, fastperiod=?, slowperiod=?, matype=?]) Percentage Price Oscillator (Momentum Indicators) Inputs: real: (any ndarray) Parameters: fastperiod: 12 slowperiod: 26 matype: 0 (Simple Moving Average) Outputs: real""" @overload def PPO(real: Union[pd.Series, np.ndarray], fastperiod=12, slowperiod=26, matype=0) -> np.ndarray: ... @overload def PPO(real: pd.DataFrame, fastperiod=12, slowperiod=26, matype=0) -> pd.Series: ... """ROC(real[, timeperiod=?]) Rate of change : ((real/prevPrice)-1)*100 (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 Outputs: real""" @overload def ROC(real: Union[pd.Series, np.ndarray], timeperiod=10) -> np.ndarray: ... @overload def ROC(real: pd.DataFrame, timeperiod=10) -> pd.Series: ... """ROCP(real[, timeperiod=?]) Rate of change Percentage: (real-prevPrice)/prevPrice (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 Outputs: real""" @overload def ROCP(real: Union[pd.Series, np.ndarray], timeperiod=10) -> np.ndarray: ... @overload def ROCP(real: pd.DataFrame, timeperiod=10) -> pd.Series: ... """ROCR(real[, timeperiod=?]) Rate of change ratio: (real/prevPrice) (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 Outputs: real""" @overload def ROCR(real: Union[pd.Series, np.ndarray], timeperiod=10) -> np.ndarray: ... @overload def ROCR(real: pd.DataFrame, timeperiod=10) -> pd.Series: ... """ROCR100(real[, timeperiod=?]) Rate of change ratio 100 scale: (real/prevPrice)*100 (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 10 Outputs: real""" @overload def ROCR100(real: Union[pd.Series, np.ndarray], timeperiod=10) -> np.ndarray: ... @overload def ROCR100(real: pd.DataFrame, timeperiod=10) -> pd.Series: ... """RSI(real[, timeperiod=?]) Relative Strength Index (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real""" @overload def RSI(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def RSI(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """STOCH(high, low, close[, fastk_period=?, slowk_period=?, slowk_matype=?, slowd_period=?, slowd_matype=?]) Stochastic (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: fastk_period: 5 slowk_period: 3 slowk_matype: 0 slowd_period: 3 slowd_matype: 0 Outputs: slowk slowd""" @overload def STOCH(real: Union[pd.Series, np.ndarray], fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0) -> Tuple[np.ndarray, np.ndarray]: ... @overload def STOCH(real: pd.DataFrame, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0) -> pd.DataFrame: ... """STOCHF(high, low, close[, fastk_period=?, fastd_period=?, fastd_matype=?]) Stochastic Fast (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: fastk_period: 5 fastd_period: 3 fastd_matype: 0 Outputs: fastk fastd""" @overload def STOCHF(real: Union[pd.Series, np.ndarray], fastk_period=5, fastd_period=3, fastd_matype=0) -> Tuple[np.ndarray, np.ndarray]: ... @overload def STOCHF(real: pd.DataFrame, fastk_period=5, fastd_period=3, fastd_matype=0) -> pd.DataFrame: ... """STOCHRSI(real[, timeperiod=?, fastk_period=?, fastd_period=?, fastd_matype=?]) Stochastic Relative Strength Index (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 14 fastk_period: 5 fastd_period: 3 fastd_matype: 0 Outputs: fastk fastd""" @overload def STOCHRSI(real: Union[pd.Series, np.ndarray], timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0) -> Tuple[np.ndarray, np.ndarray]: ... @overload def STOCHRSI(real: pd.DataFrame, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0) -> pd.DataFrame: ... """TRIX(real[, timeperiod=?]) 1-day Rate-Of-Change (ROC) of a Triple Smooth EMA (Momentum Indicators) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real""" @overload def TRIX(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def TRIX(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... """ULTOSC(high, low, close[, timeperiod1=?, timeperiod2=?, timeperiod3=?]) Ultimate Oscillator (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod1: 7 timeperiod2: 14 timeperiod3: 28 Outputs: real""" @overload def ULTOSC(real: Union[pd.Series, np.ndarray], timeperiod1=7, timeperiod2=14, timeperiod3=28) -> np.ndarray: ... @overload def ULTOSC(real: pd.DataFrame, timeperiod1=7, timeperiod2=14, timeperiod3=28) -> pd.Series: ... """WILLR(high, low, close[, timeperiod=?]) Williams' %R (Momentum Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real""" @overload def WILLR(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def WILLR(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """BBANDS(real[, timeperiod=?, nbdevup=?, nbdevdn=?, matype=?]) Bollinger Bands (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 5 nbdevup: 2.0 nbdevdn: 2.0 matype: 0 (Simple Moving Average) Outputs: upperband middleband lowerband""" @overload def BBANDS(real: Union[pd.Series, np.ndarray], timeperiod=5, nbdevup=2.0, nbdevdn=2.0, matype=0) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: ... @overload def BBANDS(real: pd.DataFrame, timeperiod=5, nbdevup=2.0, nbdevdn=2.0, matype=0) -> pd.DataFrame: ... """DEMA(real[, timeperiod=?]) Double Exponential Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real""" @overload def DEMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def DEMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... """EMA(real[, timeperiod=?]) Exponential Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real""" @overload def EMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def EMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... """HT_TRENDLINE(real) Hilbert Transform - Instantaneous Trendline (Overlap Studies) Inputs: real: (any ndarray) Outputs: real""" @overload def HT_TRENDLINE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def HT_TRENDLINE(real: pd.DataFrame) -> pd.Series: ... """KAMA(real[, timeperiod=?]) Kaufman Adaptive Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real""" @overload def KAMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def KAMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... """MA(real[, timeperiod=?, matype=?]) Moving average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 matype: 0 (Simple Moving Average) Outputs: real""" @overload def MA(real: Union[pd.Series, np.ndarray], timeperiod=30, matype=0) -> np.ndarray: ... @overload def MA(real: pd.DataFrame, timeperiod=30, matype=0) -> pd.Series: ... """MAMA(real[, fastlimit=?, slowlimit=?]) MESA Adaptive Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: fastlimit: 0.5 slowlimit: 0.05 Outputs: mama fama""" @overload def MAMA(real: Union[pd.Series, np.ndarray], fastlimit=0.5, slowlimit=0.05) -> Tuple[np.ndarray, np.ndarray]: ... @overload def MAMA(real: pd.DataFrame, fastlimit=0.5, slowlimit=0.05) -> pd.DataFrame: ... """MAVP(real, periods[, minperiod=?, maxperiod=?, matype=?]) Moving average with variable period (Overlap Studies) Inputs: real: (any ndarray) periods: (any ndarray) Parameters: minperiod: 2 maxperiod: 30 matype: 0 (Simple Moving Average) Outputs: real""" @overload def MAVP(real: Union[pd.Series, np.ndarray], minperiod=2, maxperiod=30, matype=0) -> np.ndarray: ... @overload def MAVP(real: pd.DataFrame, minperiod=2, maxperiod=30, matype=0) -> pd.Series: ... """MIDPOINT(real[, timeperiod=?]) MidPoint over period (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real""" @overload def MIDPOINT(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def MIDPOINT(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """MIDPRICE(high, low[, timeperiod=?]) Midpoint Price over period (Overlap Studies) Inputs: prices: ['high', 'low'] Parameters: timeperiod: 14 Outputs: real""" @overload def MIDPRICE(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def MIDPRICE(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """SAR(high, low[, acceleration=?, maximum=?]) Parabolic SAR (Overlap Studies) Inputs: prices: ['high', 'low'] Parameters: acceleration: 0.02 maximum: 0.2 Outputs: real""" @overload def SAR(real: Union[pd.Series, np.ndarray], acceleration=0.02, maximum=0.2) -> np.ndarray: ... @overload def SAR(real: pd.DataFrame, acceleration=0.02, maximum=0.2) -> pd.Series: ... """SAREXT(high, low[, startvalue=?, offsetonreverse=?, accelerationinitlong=?, accelerationlong=?, accelerationmaxlong=?, accelerationinitshort=?, accelerationshort=?, accelerationmaxshort=?]) Parabolic SAR - Extended (Overlap Studies) Inputs: prices: ['high', 'low'] Parameters: startvalue: 0.0 offsetonreverse: 0.0 accelerationinitlong: 0.02 accelerationlong: 0.02 accelerationmaxlong: 0.2 accelerationinitshort: 0.02 accelerationshort: 0.02 accelerationmaxshort: 0.2 Outputs: real""" @overload def SAREXT(real: Union[pd.Series, np.ndarray], startvalue=0.0, offsetonreverse=0.0, accelerationinitlong=0.02, accelerationlong=0.02, accelerationmaxlong=0.2, accelerationinitshort=0.02, accelerationshort=0.02, accelerationmaxshort=0.2) -> np.ndarray: ... @overload def SAREXT(real: pd.DataFrame, startvalue=0.0, offsetonreverse=0.0, accelerationinitlong=0.02, accelerationlong=0.02, accelerationmaxlong=0.2, accelerationinitshort=0.02, accelerationshort=0.02, accelerationmaxshort=0.2) -> pd.Series: ... """SMA(real[, timeperiod=?]) Simple Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real""" @overload def SMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def SMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... """T3(real[, timeperiod=?, vfactor=?]) Triple Exponential Moving Average (T3) (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 5 vfactor: 0.7 Outputs: real""" @overload def T3(real: Union[pd.Series, np.ndarray], timeperiod=5, vfactor=0.7) -> np.ndarray: ... @overload def T3(real: pd.DataFrame, timeperiod=5, vfactor=0.7) -> pd.Series: ... """TEMA(real[, timeperiod=?]) Triple Exponential Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real""" @overload def TEMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def TEMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... """TRIMA(real[, timeperiod=?]) Triangular Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real""" @overload def TRIMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def TRIMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... """WMA(real[, timeperiod=?]) Weighted Moving Average (Overlap Studies) Inputs: real: (any ndarray) Parameters: timeperiod: 30 Outputs: real""" @overload def WMA(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def WMA(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... """CDL2CROWS(open, high, low, close) Two Crows (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDL2CROWS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDL2CROWS(real: pd.DataFrame) -> pd.Series: ... """CDL3BLACKCROWS(open, high, low, close) Three Black Crows (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDL3BLACKCROWS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDL3BLACKCROWS(real: pd.DataFrame) -> pd.Series: ... """CDL3INSIDE(open, high, low, close) Three Inside Up/Down (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDL3INSIDE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDL3INSIDE(real: pd.DataFrame) -> pd.Series: ... """CDL3LINESTRIKE(open, high, low, close) Three-Line Strike (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDL3LINESTRIKE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDL3LINESTRIKE(real: pd.DataFrame) -> pd.Series: ... """CDL3OUTSIDE(open, high, low, close) Three Outside Up/Down (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDL3OUTSIDE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDL3OUTSIDE(real: pd.DataFrame) -> pd.Series: ... """CDL3STARSINSOUTH(open, high, low, close) Three Stars In The South (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDL3STARSINSOUTH(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDL3STARSINSOUTH(real: pd.DataFrame) -> pd.Series: ... """CDL3WHITESOLDIERS(open, high, low, close) Three Advancing White Soldiers (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDL3WHITESOLDIERS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDL3WHITESOLDIERS(real: pd.DataFrame) -> pd.Series: ... """CDLABANDONEDBABY(open, high, low, close[, penetration=?]) Abandoned Baby (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100)""" @overload def CDLABANDONEDBABY(real: Union[pd.Series, np.ndarray], penetration=0.3) -> np.ndarray: ... @overload def CDLABANDONEDBABY(real: pd.DataFrame, penetration=0.3) -> pd.Series: ... """CDLADVANCEBLOCK(open, high, low, close) Advance Block (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLADVANCEBLOCK(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLADVANCEBLOCK(real: pd.DataFrame) -> pd.Series: ... """CDLBELTHOLD(open, high, low, close) Belt-hold (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLBELTHOLD(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLBELTHOLD(real: pd.DataFrame) -> pd.Series: ... """CDLBREAKAWAY(open, high, low, close) Breakaway (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLBREAKAWAY(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLBREAKAWAY(real: pd.DataFrame) -> pd.Series: ... """CDLCLOSINGMARUBOZU(open, high, low, close) Closing Marubozu (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLCLOSINGMARUBOZU(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLCLOSINGMARUBOZU(real: pd.DataFrame) -> pd.Series: ... """CDLCONCEALBABYSWALL(open, high, low, close) Concealing Baby Swallow (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLCONCEALBABYSWALL(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLCONCEALBABYSWALL(real: pd.DataFrame) -> pd.Series: ... """CDLCOUNTERATTACK(open, high, low, close) Counterattack (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLCOUNTERATTACK(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLCOUNTERATTACK(real: pd.DataFrame) -> pd.Series: ... """CDLDARKCLOUDCOVER(open, high, low, close[, penetration=?]) Dark Cloud Cover (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.5 Outputs: integer (values are -100, 0 or 100)""" @overload def CDLDARKCLOUDCOVER(real: Union[pd.Series, np.ndarray], penetration=0.5) -> np.ndarray: ... @overload def CDLDARKCLOUDCOVER(real: pd.DataFrame, penetration=0.5) -> pd.Series: ... """CDLDOJI(open, high, low, close) Doji (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLDOJI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLDOJI(real: pd.DataFrame) -> pd.Series: ... """CDLDOJISTAR(open, high, low, close) Doji Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLDOJISTAR(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLDOJISTAR(real: pd.DataFrame) -> pd.Series: ... """CDLDRAGONFLYDOJI(open, high, low, close) Dragonfly Doji (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLDRAGONFLYDOJI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLDRAGONFLYDOJI(real: pd.DataFrame) -> pd.Series: ... """CDLENGULFING(open, high, low, close) Engulfing Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLENGULFING(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLENGULFING(real: pd.DataFrame) -> pd.Series: ... """CDLEVENINGDOJISTAR(open, high, low, close[, penetration=?]) Evening Doji Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100)""" @overload def CDLEVENINGDOJISTAR(real: Union[pd.Series, np.ndarray], penetration=0.3) -> np.ndarray: ... @overload def CDLEVENINGDOJISTAR(real: pd.DataFrame, penetration=0.3) -> pd.Series: ... """CDLEVENINGSTAR(open, high, low, close[, penetration=?]) Evening Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100)""" @overload def CDLEVENINGSTAR(real: Union[pd.Series, np.ndarray], penetration=0.3) -> np.ndarray: ... @overload def CDLEVENINGSTAR(real: pd.DataFrame, penetration=0.3) -> pd.Series: ... """CDLGAPSIDESIDEWHITE(open, high, low, close) Up/Down-gap side-by-side white lines (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLGAPSIDESIDEWHITE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLGAPSIDESIDEWHITE(real: pd.DataFrame) -> pd.Series: ... """CDLGRAVESTONEDOJI(open, high, low, close) Gravestone Doji (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLGRAVESTONEDOJI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLGRAVESTONEDOJI(real: pd.DataFrame) -> pd.Series: ... """CDLHAMMER(open, high, low, close) Hammer (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLHAMMER(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLHAMMER(real: pd.DataFrame) -> pd.Series: ... """CDLHANGINGMAN(open, high, low, close) Hanging Man (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLHANGINGMAN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLHANGINGMAN(real: pd.DataFrame) -> pd.Series: ... """CDLHARAMI(open, high, low, close) Harami Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLHARAMI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLHARAMI(real: pd.DataFrame) -> pd.Series: ... """CDLHARAMICROSS(open, high, low, close) Harami Cross Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLHARAMICROSS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLHARAMICROSS(real: pd.DataFrame) -> pd.Series: ... """CDLHIGHWAVE(open, high, low, close) High-Wave Candle (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLHIGHWAVE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLHIGHWAVE(real: pd.DataFrame) -> pd.Series: ... """CDLHIKKAKE(open, high, low, close) Hikkake Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLHIKKAKE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLHIKKAKE(real: pd.DataFrame) -> pd.Series: ... """CDLHIKKAKEMOD(open, high, low, close) Modified Hikkake Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLHIKKAKEMOD(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLHIKKAKEMOD(real: pd.DataFrame) -> pd.Series: ... """CDLHOMINGPIGEON(open, high, low, close) Homing Pigeon (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLHOMINGPIGEON(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLHOMINGPIGEON(real: pd.DataFrame) -> pd.Series: ... """CDLIDENTICAL3CROWS(open, high, low, close) Identical Three Crows (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLIDENTICAL3CROWS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLIDENTICAL3CROWS(real: pd.DataFrame) -> pd.Series: ... """CDLINNECK(open, high, low, close) In-Neck Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLINNECK(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLINNECK(real: pd.DataFrame) -> pd.Series: ... """CDLINVERTEDHAMMER(open, high, low, close) Inverted Hammer (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLINVERTEDHAMMER(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLINVERTEDHAMMER(real: pd.DataFrame) -> pd.Series: ... """CDLKICKING(open, high, low, close) Kicking (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLKICKING(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLKICKING(real: pd.DataFrame) -> pd.Series: ... """CDLKICKINGBYLENGTH(open, high, low, close) Kicking - bull/bear determined by the longer marubozu (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLKICKINGBYLENGTH(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLKICKINGBYLENGTH(real: pd.DataFrame) -> pd.Series: ... """CDLLADDERBOTTOM(open, high, low, close) Ladder Bottom (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLLADDERBOTTOM(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLLADDERBOTTOM(real: pd.DataFrame) -> pd.Series: ... """CDLLONGLEGGEDDOJI(open, high, low, close) Long Legged Doji (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLLONGLEGGEDDOJI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLLONGLEGGEDDOJI(real: pd.DataFrame) -> pd.Series: ... """CDLLONGLINE(open, high, low, close) Long Line Candle (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLLONGLINE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLLONGLINE(real: pd.DataFrame) -> pd.Series: ... """CDLMARUBOZU(open, high, low, close) Marubozu (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLMARUBOZU(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLMARUBOZU(real: pd.DataFrame) -> pd.Series: ... """CDLMATCHINGLOW(open, high, low, close) Matching Low (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLMATCHINGLOW(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLMATCHINGLOW(real: pd.DataFrame) -> pd.Series: ... """CDLMATHOLD(open, high, low, close[, penetration=?]) Mat Hold (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.5 Outputs: integer (values are -100, 0 or 100)""" @overload def CDLMATHOLD(real: Union[pd.Series, np.ndarray], penetration=0.5) -> np.ndarray: ... @overload def CDLMATHOLD(real: pd.DataFrame, penetration=0.5) -> pd.Series: ... """CDLMORNINGDOJISTAR(open, high, low, close[, penetration=?]) Morning Doji Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100)""" @overload def CDLMORNINGDOJISTAR(real: Union[pd.Series, np.ndarray], penetration=0.3) -> np.ndarray: ... @overload def CDLMORNINGDOJISTAR(real: pd.DataFrame, penetration=0.3) -> pd.Series: ... """CDLMORNINGSTAR(open, high, low, close[, penetration=?]) Morning Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Parameters: penetration: 0.3 Outputs: integer (values are -100, 0 or 100)""" @overload def CDLMORNINGSTAR(real: Union[pd.Series, np.ndarray], penetration=0.3) -> np.ndarray: ... @overload def CDLMORNINGSTAR(real: pd.DataFrame, penetration=0.3) -> pd.Series: ... """CDLONNECK(open, high, low, close) On-Neck Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLONNECK(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLONNECK(real: pd.DataFrame) -> pd.Series: ... """CDLPIERCING(open, high, low, close) Piercing Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLPIERCING(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLPIERCING(real: pd.DataFrame) -> pd.Series: ... """CDLRICKSHAWMAN(open, high, low, close) Rickshaw Man (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLRICKSHAWMAN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLRICKSHAWMAN(real: pd.DataFrame) -> pd.Series: ... """CDLRISEFALL3METHODS(open, high, low, close) Rising/Falling Three Methods (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLRISEFALL3METHODS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLRISEFALL3METHODS(real: pd.DataFrame) -> pd.Series: ... """CDLSEPARATINGLINES(open, high, low, close) Separating Lines (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLSEPARATINGLINES(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLSEPARATINGLINES(real: pd.DataFrame) -> pd.Series: ... """CDLSHOOTINGSTAR(open, high, low, close) Shooting Star (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLSHOOTINGSTAR(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLSHOOTINGSTAR(real: pd.DataFrame) -> pd.Series: ... """CDLSHORTLINE(open, high, low, close) Short Line Candle (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLSHORTLINE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLSHORTLINE(real: pd.DataFrame) -> pd.Series: ... """CDLSPINNINGTOP(open, high, low, close) Spinning Top (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLSPINNINGTOP(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLSPINNINGTOP(real: pd.DataFrame) -> pd.Series: ... """CDLSTALLEDPATTERN(open, high, low, close) Stalled Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLSTALLEDPATTERN(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLSTALLEDPATTERN(real: pd.DataFrame) -> pd.Series: ... """CDLSTICKSANDWICH(open, high, low, close) Stick Sandwich (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLSTICKSANDWICH(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLSTICKSANDWICH(real: pd.DataFrame) -> pd.Series: ... """CDLTAKURI(open, high, low, close) Takuri (Dragonfly Doji with very long lower shadow) (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLTAKURI(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLTAKURI(real: pd.DataFrame) -> pd.Series: ... """CDLTASUKIGAP(open, high, low, close) Tasuki Gap (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLTASUKIGAP(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLTASUKIGAP(real: pd.DataFrame) -> pd.Series: ... """CDLTHRUSTING(open, high, low, close) Thrusting Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLTHRUSTING(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLTHRUSTING(real: pd.DataFrame) -> pd.Series: ... """CDLTRISTAR(open, high, low, close) Tristar Pattern (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLTRISTAR(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLTRISTAR(real: pd.DataFrame) -> pd.Series: ... """CDLUNIQUE3RIVER(open, high, low, close) Unique 3 River (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLUNIQUE3RIVER(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLUNIQUE3RIVER(real: pd.DataFrame) -> pd.Series: ... """CDLUPSIDEGAP2CROWS(open, high, low, close) Upside Gap Two Crows (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLUPSIDEGAP2CROWS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLUPSIDEGAP2CROWS(real: pd.DataFrame) -> pd.Series: ... """CDLXSIDEGAP3METHODS(open, high, low, close) Upside/Downside Gap Three Methods (Pattern Recognition) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: integer (values are -100, 0 or 100)""" @overload def CDLXSIDEGAP3METHODS(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def CDLXSIDEGAP3METHODS(real: pd.DataFrame) -> pd.Series: ... """AVGPRICE(open, high, low, close) Average Price (Price Transform) Inputs: prices: ['open', 'high', 'low', 'close'] Outputs: real""" @overload def AVGPRICE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def AVGPRICE(real: pd.DataFrame) -> pd.Series: ... """MEDPRICE(high, low) Median Price (Price Transform) Inputs: prices: ['high', 'low'] Outputs: real""" @overload def MEDPRICE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def MEDPRICE(real: pd.DataFrame) -> pd.Series: ... """TYPPRICE(high, low, close) Typical Price (Price Transform) Inputs: prices: ['high', 'low', 'close'] Outputs: real""" @overload def TYPPRICE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def TYPPRICE(real: pd.DataFrame) -> pd.Series: ... """WCLPRICE(high, low, close) Weighted Close Price (Price Transform) Inputs: prices: ['high', 'low', 'close'] Outputs: real""" @overload def WCLPRICE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def WCLPRICE(real: pd.DataFrame) -> pd.Series: ... """BETA(real0, real1[, timeperiod=?]) Beta (Statistic Functions) Inputs: real0: (any ndarray) real1: (any ndarray) Parameters: timeperiod: 5 Outputs: real""" @overload def BETA(real: Union[pd.Series, np.ndarray], timeperiod=5) -> np.ndarray: ... @overload def BETA(real: pd.DataFrame, timeperiod=5) -> pd.Series: ... """CORREL(real0, real1[, timeperiod=?]) Pearson's Correlation Coefficient (r) (Statistic Functions) Inputs: real0: (any ndarray) real1: (any ndarray) Parameters: timeperiod: 30 Outputs: real""" @overload def CORREL(real: Union[pd.Series, np.ndarray], timeperiod=30) -> np.ndarray: ... @overload def CORREL(real: pd.DataFrame, timeperiod=30) -> pd.Series: ... """LINEARREG(real[, timeperiod=?]) Linear Regression (Statistic Functions) Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real""" @overload def LINEARREG(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def LINEARREG(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """LINEARREG_ANGLE(real[, timeperiod=?]) Linear Regression Angle (Statistic Functions) Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real""" @overload def LINEARREG_ANGLE(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def LINEARREG_ANGLE(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """LINEARREG_INTERCEPT(real[, timeperiod=?]) Linear Regression Intercept (Statistic Functions) Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real""" @overload def LINEARREG_INTERCEPT(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def LINEARREG_INTERCEPT(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """LINEARREG_SLOPE(real[, timeperiod=?]) Linear Regression Slope (Statistic Functions) Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real""" @overload def LINEARREG_SLOPE(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def LINEARREG_SLOPE(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """STDDEV(real[, timeperiod=?, nbdev=?]) Standard Deviation (Statistic Functions) Inputs: real: (any ndarray) Parameters: timeperiod: 5 nbdev: 1.0 Outputs: real""" @overload def STDDEV(real: Union[pd.Series, np.ndarray], timeperiod=5, nbdev=1.0) -> np.ndarray: ... @overload def STDDEV(real: pd.DataFrame, timeperiod=5, nbdev=1.0) -> pd.Series: ... """TSF(real[, timeperiod=?]) Time Series Forecast (Statistic Functions) Inputs: real: (any ndarray) Parameters: timeperiod: 14 Outputs: real""" @overload def TSF(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def TSF(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """VAR(real[, timeperiod=?, nbdev=?]) Variance (Statistic Functions) Inputs: real: (any ndarray) Parameters: timeperiod: 5 nbdev: 1.0 Outputs: real""" @overload def VAR(real: Union[pd.Series, np.ndarray], timeperiod=5, nbdev=1.0) -> np.ndarray: ... @overload def VAR(real: pd.DataFrame, timeperiod=5, nbdev=1.0) -> pd.Series: ... """ATR(high, low, close[, timeperiod=?]) Average True Range (Volatility Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real""" @overload def ATR(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def ATR(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """NATR(high, low, close[, timeperiod=?]) Normalized Average True Range (Volatility Indicators) Inputs: prices: ['high', 'low', 'close'] Parameters: timeperiod: 14 Outputs: real""" @overload def NATR(real: Union[pd.Series, np.ndarray], timeperiod=14) -> np.ndarray: ... @overload def NATR(real: pd.DataFrame, timeperiod=14) -> pd.Series: ... """TRANGE(high, low, close) True Range (Volatility Indicators) Inputs: prices: ['high', 'low', 'close'] Outputs: real""" @overload def TRANGE(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def TRANGE(real: pd.DataFrame) -> pd.Series: ... """AD(high, low, close, volume) Chaikin A/D Line (Volume Indicators) Inputs: prices: ['high', 'low', 'close', 'volume'] Outputs: real""" @overload def AD(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def AD(real: pd.DataFrame) -> pd.Series: ... """ADOSC(high, low, close, volume[, fastperiod=?, slowperiod=?]) Chaikin A/D Oscillator (Volume Indicators) Inputs: prices: ['high', 'low', 'close', 'volume'] Parameters: fastperiod: 3 slowperiod: 10 Outputs: real""" @overload def ADOSC(real: Union[pd.Series, np.ndarray], fastperiod=3, slowperiod=10) -> np.ndarray: ... @overload def ADOSC(real: pd.DataFrame, fastperiod=3, slowperiod=10) -> pd.Series: ... """OBV(real, volume) On Balance Volume (Volume Indicators) Inputs: real: (any ndarray) prices: ['volume'] Outputs: real""" @overload def OBV(real: Union[pd.Series, np.ndarray]) -> np.ndarray: ... @overload def OBV(real: pd.DataFrame) -> pd.Series: ... ================================================ FILE: talib/common.pxd ================================================ from _ta_lib cimport TA_RetCode cpdef _ta_check_success(str function_name, TA_RetCode ret_code) ================================================ FILE: talib/deprecated.py ================================================ # TA_MAType enums MA_SMA, MA_EMA, MA_WMA, MA_DEMA, MA_TEMA, MA_TRIMA, MA_KAMA, MA_MAMA, MA_T3 = range(9) ================================================ FILE: talib/py.typed ================================================ ================================================ FILE: talib/stream.py ================================================ import talib._ta_lib as _ta_lib from ._ta_lib import __TA_FUNCTION_NAMES__ for func_name in __TA_FUNCTION_NAMES__: globals()[func_name] = getattr(_ta_lib, "stream_%s" % func_name) ================================================ FILE: tests/conftest.py ================================================ import pytest import numpy as np @pytest.fixture(scope='session') def ford_2012_dates(): return np.asarray([ 20120103, 20120104, 20120105, 20120106, 20120109, 20120110, 20120111, 20120112, 20120113, 20120117, 20120118, 20120119, 20120120, 20120123, 20120124, 20120125, 20120126, 20120127, 20120130, 20120131, 20120201, 20120202, 20120203, 20120206, 20120207, 20120208, 20120209, 20120210, 20120213, 20120214, 20120215, 20120216, 20120217, 20120221, 20120222, 20120223, 20120224, 20120227, 20120228, 20120229, 20120301, 20120302, 20120305, 20120306, 20120307, 20120308, 20120309, 20120312, 20120313, 20120314, 20120315, 20120316, 20120319, 20120320, 20120321, 20120322, 20120323, 20120326, 20120327, 20120328, 20120329, 20120330, 20120402, 20120403, 20120404, 20120405, 20120409, 20120410, 20120411, 20120412, 20120413, 20120416, 20120417, 20120418, 20120419, 20120420, 20120423, 20120424, 20120425, 20120426, 20120427, 20120430, 20120501, 20120502, 20120503, 20120504, 20120507, 20120508, 20120509, 20120510, 20120511, 20120514, 20120515, 20120516, 20120517, 20120518, 20120521, 20120522, 20120523, 20120524, 20120525, 20120529, 20120530, 20120531, 20120601, 20120604, 20120605, 20120606, 20120607, 20120608, 20120611, 20120612, 20120613, 20120614, 20120615, 20120618, 20120619, 20120620, 20120621, 20120622, 20120625, 20120626, 20120627, 20120628, 20120629, 20120702, 20120703, 20120705, 20120706, 20120709, 20120710, 20120711, 20120712, 20120713, 20120716, 20120717, 20120718, 20120719, 20120720, 20120723, 20120724, 20120725, 20120726, 20120727, 20120730, 20120731, 20120801, 20120802, 20120803, 20120806, 20120807, 20120808, 20120809, 20120810, 20120813, 20120814, 20120815, 20120816, 20120817, 20120820, 20120821, 20120822, 20120823, 20120824, 20120827, 20120828, 20120829, 20120830, 20120831, 20120904, 20120905, 20120906, 20120907, 20120910, 20120911, 20120912, 20120913, 20120914, 20120917, 20120918, 20120919, 20120920, 20120921, 20120924, 20120925, 20120926, 20120927, 20120928, 20121001, 20121002, 20121003, 20121004, 20121005, 20121008, 20121009, 20121010, 20121011, 20121012, 20121015, 20121016, 20121017, 20121018, 20121019, 20121022, 20121023, 20121024, 20121025, 20121026, 20121031, 20121101, 20121102, 20121105, 20121106, 20121107, 20121108, 20121109, 20121112, 20121113, 20121114, 20121115, 20121116, 20121119, 20121120, 20121121, 20121123, 20121126, 20121127, 20121128, 20121129, 20121130, 20121203, 20121204, 20121205, 20121206, 20121207, 20121210, 20121211, 20121212, 20121213, 20121214, 20121217, 20121218, 20121219, 20121220, 20121221, 20121224, 20121226, 20121227, 20121228, 20121231 ]) @pytest.fixture(scope='session') def ford_2012(): return { 'open': np.asarray([ 11.00, 11.15, 11.33, 11.74, 11.83, 12.00, 11.74, 12.16, 12.01, 12.20, 12.03, 12.48, 12.55, 12.69, 12.56, 12.80, 13.03, 11.96, 12.06, 12.47, 12.73, 12.40, 12.47, 12.85, 12.93, 12.91, 12.89, 12.52, 12.74, 12.46, 12.47, 12.38, 12.84, 12.74, 12.49, 12.27, 12.43, 12.11, 12.34, 12.28, 12.48, 12.74, 12.67, 12.23, 12.21, 12.41, 12.53, 12.57, 12.48, 12.64, 12.90, 12.86, 12.52, 12.48, 12.59, 12.48, 12.31, 12.45, 12.51, 12.35, 12.33, 12.55, 12.50, 12.71, 12.46, 12.38, 12.26, 12.19, 11.99, 11.94, 11.98, 12.01, 11.98, 11.81, 11.81, 11.71, 11.15, 11.61, 11.51, 11.71, 12.03, 11.42, 11.25, 11.16, 11.13, 10.84, 10.53, 10.60, 10.48, 10.83, 10.61, 10.41, 10.34, 10.23, 10.16, 10.08, 10.02, 10.25, 10.32, 10.50, 10.61, 10.69, 10.73, 10.62, 10.33, 10.15, 10.01, 10.29, 10.73, 10.48, 10.77, 10.47, 10.39, 10.27, 10.40, 10.35, 10.37, 10.58, 10.65, 10.35, 10.13, 10.06, 10.05, 9.93, 9.95, 9.50, 9.53, 9.67, 9.47, 9.46, 9.50, 9.33, 9.26, 9.16, 9.22, 9.28, 9.38, 9.45, 9.28, 9.08, 9.17, 9.17, 9.05, 8.99, 9.04, 9.13, 9.29, 8.99, 9.02, 9.13, 9.18, 9.25, 9.31, 9.30, 9.35, 9.45, 9.44, 9.50, 9.65, 9.58, 9.65, 9.50, 9.45, 9.42, 9.51, 9.37, 9.33, 9.30, 9.39, 9.37, 9.45, 9.66, 9.95, 10.08, 10.18, 10.25, 10.20, 10.41, 10.27, 10.30, 10.49, 10.48, 10.53, 10.30, 10.35, 9.98, 10.13, 9.99, 9.89, 10.01, 9.82, 10.06, 10.17, 10.06, 10.21, 10.12, 10.06, 10.14, 10.11, 10.26, 10.31, 10.36, 10.42, 10.14, 10.02, 10.08, 10.42, 10.35, 10.70, 11.19, 11.31, 11.15, 11.33, 11.25, 11.07, 10.76, 11.03, 10.89, 11.02, 10.57, 10.58, 10.65, 10.85, 10.84, 10.98, 11.05, 11.10, 11.05, 11.32, 11.52, 11.56, 11.40, 11.32, 11.26, 11.27, 11.41, 11.51, 11.52, 11.46, 11.27, 11.16, 11.48, 11.79, 11.74, 11.55, 11.67, 12.31, 12.79, 12.55, 12.88 ]), 'high': np.asarray([ 11.25, 11.53, 11.63, 11.80, 11.95, 12.05, 12.18, 12.18, 12.08, 12.26, 12.37, 12.72, 12.64, 12.84, 12.86, 12.98, 13.05, 12.53, 12.44, 12.51, 12.75, 12.43, 12.84, 13.00, 12.97, 12.96, 12.90, 12.66, 12.74, 12.58, 12.57, 12.77, 12.88, 12.76, 12.51, 12.44, 12.46, 12.36, 12.35, 12.55, 12.77, 12.94, 12.68, 12.25, 12.30, 12.55, 12.73, 12.59, 12.72, 12.90, 13.04, 12.90, 12.68, 12.61, 12.67, 12.54, 12.37, 12.50, 12.61, 12.36, 12.52, 12.58, 12.65, 12.95, 12.52, 12.58, 12.29, 12.28, 12.02, 12.13, 12.03, 12.05, 12.00, 11.85, 11.88, 11.72, 11.40, 11.61, 11.75, 11.93, 12.04, 11.47, 11.34, 11.17, 11.15, 10.87, 10.79, 10.64, 10.81, 10.86, 10.83, 10.53, 10.34, 10.43, 10.25, 10.18, 10.23, 10.40, 10.45, 10.62, 10.68, 10.88, 10.75, 10.68, 10.37, 10.18, 10.24, 10.58, 10.78, 10.68, 10.80, 10.55, 10.49, 10.45, 10.42, 10.40, 10.64, 10.74, 10.68, 10.40, 10.18, 10.08, 10.10, 10.09, 9.98, 9.60, 9.79, 9.74, 9.52, 9.47, 9.55, 9.38, 9.28, 9.32, 9.32, 9.35, 9.52, 9.50, 9.35, 9.21, 9.24, 9.20, 9.11, 9.10, 9.18, 9.28, 9.42, 9.03, 9.15, 9.21, 9.39, 9.38, 9.46, 9.36, 9.42, 9.66, 9.54, 9.67, 9.66, 9.64, 9.70, 9.56, 9.54, 9.52, 9.52, 9.44, 9.40, 9.34, 9.43, 9.47, 9.62, 9.96, 10.23, 10.28, 10.25, 10.30, 10.38, 10.57, 10.42, 10.45, 10.66, 10.52, 10.54, 10.40, 10.37, 10.12, 10.18, 10.00, 10.08, 10.05, 10.02, 10.15, 10.28, 10.12, 10.25, 10.12, 10.26, 10.25, 10.25, 10.32, 10.41, 10.57, 10.43, 10.24, 10.11, 10.29, 10.49, 10.42, 11.17, 11.30, 11.38, 11.35, 11.59, 11.34, 11.23, 11.10, 11.16, 11.10, 11.05, 10.80, 10.64, 10.90, 11.02, 11.00, 11.10, 11.14, 11.27, 11.26, 11.53, 11.60, 11.70, 11.44, 11.40, 11.31, 11.50, 11.53, 11.58, 11.56, 11.50, 11.27, 11.41, 11.68, 11.85, 11.80, 11.86, 12.40, 12.79, 12.81, 12.88, 13.08 ]), 'low': np.asarray([ 10.99, 11.07, 11.24, 11.52, 11.70, 11.63, 11.65, 11.89, 11.84, 11.96, 12.00, 12.43, 12.45, 12.55, 12.46, 12.70, 12.66, 11.79, 12.00, 12.20, 12.29, 12.20, 12.39, 12.71, 12.83, 12.80, 12.67, 12.37, 12.51, 12.34, 12.33, 12.38, 12.71, 12.46, 12.22, 12.16, 12.19, 11.99, 12.20, 12.25, 12.45, 12.68, 12.41, 12.00, 12.15, 12.32, 12.48, 12.37, 12.40, 12.63, 12.83, 12.51, 12.48, 12.39, 12.55, 12.24, 12.18, 12.39, 12.30, 12.18, 12.24, 12.40, 12.44, 12.46, 12.32, 12.38, 12.11, 11.65, 11.88, 11.86, 11.84, 11.83, 11.88, 11.72, 11.58, 11.39, 11.15, 11.36, 11.43, 11.67, 11.52, 11.15, 11.11, 11.00, 10.85, 10.63, 10.52, 10.40, 10.41, 10.66, 10.56, 10.30, 10.10, 10.15, 10.01, 9.96, 10.00, 10.15, 10.22, 10.38, 10.51, 10.68, 10.52, 10.40, 10.06, 9.91, 9.97, 10.27, 10.52, 10.38, 10.45, 10.31, 10.22, 10.21, 10.26, 10.26, 10.35, 10.52, 10.25, 10.18, 9.95, 9.96, 9.97, 9.93, 9.46, 9.30, 9.49, 9.53, 9.40, 9.31, 9.28, 9.26, 9.12, 9.14, 9.15, 9.12, 9.34, 9.33, 9.18, 9.05, 8.95, 8.91, 8.83, 8.88, 9.01, 9.12, 8.99, 8.82, 8.96, 9.09, 9.18, 9.24, 9.30, 9.23, 9.25, 9.42, 9.41, 9.49, 9.60, 9.51, 9.52, 9.40, 9.42, 9.41, 9.38, 9.31, 9.29, 9.25, 9.31, 9.35, 9.39, 9.66, 9.93, 10.06, 10.13, 10.17, 10.12, 10.39, 10.26, 10.28, 10.45, 10.35, 10.36, 10.26, 10.06, 9.86, 10.02, 9.81, 9.88, 9.71, 9.76, 9.96, 10.13, 9.99, 10.02, 9.95, 10.05, 10.09, 10.09, 10.22, 10.26, 10.33, 10.13, 10.03, 9.97, 10.01, 10.28, 10.22, 10.60, 10.88, 11.15, 11.13, 11.26, 11.04, 10.89, 10.71, 10.96, 10.86, 10.62, 10.46, 10.38, 10.65, 10.76, 10.80, 10.96, 10.97, 11.10, 10.98, 11.32, 11.33, 11.40, 11.23, 11.18, 11.19, 11.26, 11.41, 11.40, 11.43, 11.21, 11.03, 11.14, 11.40, 11.62, 11.58, 11.47, 11.67, 12.31, 12.36, 12.52, 12.76 ]), 'close': np.asarray([ 11.13, 11.30, 11.59, 11.71, 11.80, 11.80, 12.07, 12.14, 12.04, 12.02, 12.34, 12.61, 12.59, 12.66, 12.82, 12.93, 12.79, 12.21, 12.29, 12.42, 12.33, 12.26, 12.79, 12.96, 12.88, 12.84, 12.69, 12.44, 12.54, 12.48, 12.38, 12.74, 12.75, 12.53, 12.28, 12.40, 12.23, 12.30, 12.25, 12.38, 12.66, 12.72, 12.46, 12.09, 12.24, 12.46, 12.58, 12.43, 12.70, 12.88, 12.90, 12.51, 12.63, 12.54, 12.57, 12.32, 12.32, 12.48, 12.32, 12.32, 12.50, 12.48, 12.62, 12.64, 12.51, 12.47, 12.22, 11.79, 11.91, 12.07, 11.92, 11.88, 11.91, 11.79, 11.66, 11.41, 11.35, 11.39, 11.73, 11.87, 11.60, 11.28, 11.23, 11.10, 10.92, 10.67, 10.66, 10.61, 10.69, 10.71, 10.58, 10.32, 10.15, 10.16, 10.01, 10.01, 10.20, 10.19, 10.41, 10.59, 10.60, 10.84, 10.66, 10.56, 10.12, 10.04, 10.19, 10.57, 10.55, 10.66, 10.45, 10.50, 10.30, 10.41, 10.35, 10.34, 10.56, 10.65, 10.27, 10.19, 10.01, 10.01, 10.02, 10.09, 9.59, 9.39, 9.60, 9.57, 9.50, 9.45, 9.35, 9.33, 9.13, 9.27, 9.26, 9.34, 9.38, 9.35, 9.21, 9.17, 9.06, 8.97, 8.96, 9.00, 9.10, 9.24, 9.04, 8.92, 9.09, 9.15, 9.31, 9.35, 9.34, 9.35, 9.40, 9.44, 9.49, 9.59, 9.63, 9.63, 9.53, 9.49, 9.45, 9.49, 9.39, 9.34, 9.32, 9.31, 9.34, 9.41, 9.57, 9.92, 10.14, 10.11, 10.15, 10.21, 10.34, 10.53, 10.39, 10.42, 10.59, 10.44, 10.40, 10.32, 10.09, 10.01, 10.02, 9.86, 9.93, 9.79, 9.94, 10.11, 10.16, 10.05, 10.10, 9.98, 10.14, 10.12, 10.22, 10.30, 10.41, 10.43, 10.18, 10.17, 10.00, 10.17, 10.39, 10.36, 11.16, 11.25, 11.17, 11.25, 11.42, 11.06, 10.90, 10.93, 10.97, 11.00, 10.67, 10.57, 10.50, 10.83, 10.85, 10.92, 11.10, 11.11, 11.10, 11.25, 11.53, 11.45, 11.41, 11.31, 11.31, 11.24, 11.48, 11.47, 11.49, 11.47, 11.27, 11.10, 11.39, 11.67, 11.73, 11.77, 11.86, 12.40, 12.79, 12.76, 12.87, 12.95 ]), 'volume': np.asarray([ 45709900, 79725200, 67877500, 59840700, 53981500, 121750600, 63806000, 48687700, 46366700, 44398400, 47102700, 70894200, 43705700, 49379700, 45768400, 54021600, 75470700, 142155300, 57752600, 46412100, 71669000, 48347600, 78851200, 46363300, 39413500, 35352500, 52290500, 52505500, 34474400, 39627900, 38174800, 49164400, 30778000, 38409800, 43326000, 36747600, 31399300, 38703400, 30789000, 62093700, 68262000, 49063500, 28433700, 57374500, 28440900, 37099100, 36159300, 30275700, 42783600, 47578500, 55286600, 77119600, 52445700, 40214400, 27521400, 50117100, 44755000, 26692200, 35070700, 41051700, 51039700, 36381000, 43966900, 97034200, 51505000, 37939500, 42515300, 77370300, 34724400, 26988800, 39675000, 31903500, 35981200, 32314000, 48169200, 52631000, 31269200, 38615200, 45185400, 40889300, 83070300, 46156300, 43959200, 48572900, 40238400, 53268400, 33235200, 46174500, 54501200, 42526100, 36561300, 50225200, 41886500, 44321300, 49648900, 50572000, 38134900, 44295700, 75647800, 45334100, 30430800, 43760600, 44592100, 54297000, 68237000, 57305600, 38326200, 50458000, 33846100, 30811600, 35811400, 35130800, 53471900, 37531800, 39442000, 27361000, 37155900, 40810100, 40062800, 56427300, 44297600, 31871900, 33278900, 38648400, 138138600, 63388600, 49629300, 31783900, 30355400, 37441600, 33516600, 32028700, 55111000, 30248300, 28838200, 29510000, 31010000, 33615000, 27968300, 33773800, 53519200, 44338200, 51798900, 67986800, 40958300, 41360900, 65973000, 45326500, 38631400, 23819100, 43574500, 22630300, 30909800, 19618800, 21122000, 21129500, 21308300, 34323700, 34533900, 38923800, 26281100, 26965500, 23537700, 19574600, 22754200, 23084400, 26115700, 16459400, 28029200, 37965000, 40608800, 67996400, 60617000, 43381300, 28165300, 28046500, 50920200, 55934300, 31922200, 34937000, 42403000, 28755100, 35459800, 28557900, 36866300, 44362600, 25740900, 44586300, 33445600, 63630000, 51023800, 46855500, 40693900, 25473900, 38235700, 33951600, 39328700, 24108500, 26466500, 32788400, 29346300, 44041700, 40493000, 39149700, 32476500, 49339800, 59290900, 43485500, 137960900, 88770100, 53399000, 37995000, 51232200, 56674900, 45948800, 40703600, 25723100, 33342900, 45664700, 48879800, 45346200, 39359100, 34739800, 21181700, 16032200, 26831700, 37610000, 38496900, 57289300, 41329600, 47746300, 37760200, 33152400, 31065800, 38404500, 26025200, 36326900, 31099900, 35443200, 36933500, 46983300, 61810400, 54884700, 47750100, 94489300, 91734900, 140331900, 108315100, 95668600, 106908900 ]) } @pytest.fixture(scope='session') def series(): return np.array([ 91.50, 94.81, 94.38, 95.09, 93.78, 94.62, 92.53, 92.75, 90.31, 92.47, 96.12, 97.25, 98.50, 89.88, 91.00, 92.81, 89.16, 89.34, 91.62, 89.88, 88.38, 87.62, 84.78, 83.00, 83.50, 81.38, 84.44, 89.25, 86.38, 86.25, 85.25, 87.12, 85.81, 88.97, 88.47, 86.88, 86.81, 84.88, 84.19, 83.88, 83.38, 85.50, 89.19, 89.44, 91.09, 90.75, 91.44, 89.00, 91.00, 90.50, 89.03, 88.81, 84.28, 83.50, 82.69, 84.75, 85.66, 86.19, 88.94, 89.28, 88.62, 88.50, 91.97, 91.50, 93.25, 93.50, 93.16, 91.72, 90.00, 89.69, 88.88, 85.19, 83.38, 84.88, 85.94, 97.25, 99.88, 104.94, 106.00, 102.50, 102.41, 104.59, 106.12, 106.00, 106.06, 104.62, 108.62, 109.31, 110.50, 112.75, 123.00, 119.62, 118.75, 119.25, 117.94, 116.44, 115.19, 111.88, 110.59, 118.12, 116.00, 116.00, 112.00, 113.75, 112.94, 116.00, 120.50, 116.62, 117.00, 115.25, 114.31, 115.50, 115.87, 120.69, 120.19, 120.75, 124.75, 123.37, 122.94, 122.56, 123.12, 122.56, 124.62, 129.25, 131.00, 132.25, 131.00, 132.81, 134.00, 137.38, 137.81, 137.88, 137.25, 136.31, 136.25, 134.63, 128.25, 129.00, 123.87, 124.81, 123.00, 126.25, 128.38, 125.37, 125.69, 122.25, 119.37, 118.50, 123.19, 123.50, 122.19, 119.31, 123.31, 121.12, 123.37, 127.37, 128.50, 123.87, 122.94, 121.75, 124.44, 122.00, 122.37, 122.94, 124.00, 123.19, 124.56, 127.25, 125.87, 128.86, 132.00, 130.75, 134.75, 135.00, 132.38, 133.31, 131.94, 130.00, 125.37, 130.13, 127.12, 125.19, 122.00, 125.00, 123.00, 123.50, 120.06, 121.00, 117.75, 119.87, 122.00, 119.19, 116.37, 113.50, 114.25, 110.00, 105.06, 107.00, 107.87, 107.00, 107.12, 107.00, 91.00, 93.94, 93.87, 95.50, 93.00, 94.94, 98.25, 96.75, 94.81, 94.37, 91.56, 90.25, 93.94, 93.62, 97.00, 95.00, 95.87, 94.06, 94.62, 93.75, 98.00, 103.94, 107.87, 106.06, 104.50, 105.00, 104.19, 103.06, 103.42, 105.27, 111.87, 116.00, 116.62, 118.28, 113.37, 109.00, 109.70, 109.25, 107.00, 109.19, 110.00, 109.20, 110.12, 108.00, 108.62, 109.75, 109.81, 109.00, 108.75, 107.87 ]) ================================================ FILE: tests/test_abstract.py ================================================ import copy import re import threading import time import numpy as np import pytest from numpy.testing import assert_array_equal, assert_raises try: from collections import OrderedDict except ImportError: # handle python 2.6 and earlier from ordereddict import OrderedDict import talib from talib import abstract, func 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) input_dict = dict((k, pandas.Series(v)) for k, v in ford_2012.items()) expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close']) # 5, 3, 0, 3, 0 output = abstract.Function('stoch', input_df).outputs assert isinstance(output, pandas.DataFrame) assert_array_equal(expected_k, output['slowk']) assert_array_equal(expected_d, output['slowd']) output = abstract.Function('stoch', input_dict).outputs assert isinstance(output, list) assert_array_equal(expected_k, output[0]) assert_array_equal(expected_d, output[1]) expected = func.SMA(ford_2012['close'], 10) output = abstract.Function('sma', input_df, 10).outputs assert isinstance(output, pandas.Series) assert_array_equal(expected, output) output = abstract.Function('sma', input_dict, 10).outputs assert isinstance(output, np.ndarray) assert_array_equal(expected, output) def test_pandas_series(ford_2012): import pandas input_df = pandas.DataFrame(ford_2012) output = talib.SMA(input_df['close'], 10) expected = pandas.Series(func.SMA(ford_2012['close'], 10), index=input_df.index) pandas.testing.assert_series_equal(output, expected) # Test kwargs output = talib.SMA(real=input_df['close'], timeperiod=10) pandas.testing.assert_series_equal(output, expected) # Test talib.func API output = func.SMA(input_df['close'], timeperiod=10) pandas.testing.assert_series_equal(output, expected) # Test multiple outputs such as from BBANDS _, output, _ = talib.BBANDS(input_df['close'], 10) expected = pandas.Series(func.BBANDS(ford_2012['close'], 10)[1], index=input_df.index) pandas.testing.assert_series_equal(output, expected) def test_SMA(ford_2012): expected = func.SMA(ford_2012['close'], 10) assert_array_equal(expected, abstract.Function('sma', ford_2012, 10).outputs) assert_array_equal(expected, abstract.Function('sma')(ford_2012, 10, price='close')) assert_array_equal(expected, abstract.Function('sma')(ford_2012, timeperiod=10)) expected = func.SMA(ford_2012['open'], 10) assert_array_equal(expected, abstract.Function('sma', ford_2012, 10, price='open').outputs) assert_array_equal(expected, abstract.Function('sma', price='low')(ford_2012, 10, price='open')) assert_array_not_equal(expected, abstract.Function('sma', ford_2012, 10, price='open')(timeperiod=20)) assert_array_not_equal(expected, abstract.Function('sma', ford_2012)(10, price='close')) assert_array_not_equal(expected, abstract.Function('sma', 10)(ford_2012, price='high')) assert_array_not_equal(expected, abstract.Function('sma', price='low')(ford_2012, 10)) input_arrays = {'foobarbaz': ford_2012['open']} assert_array_equal(expected, abstract.SMA(input_arrays, 10, price='foobarbaz')) def test_STOCH(ford_2012): # check defaults match expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close']) # 5, 3, 0, 3, 0 got_k, got_d = abstract.Function('stoch', ford_2012).outputs assert_array_equal(expected_k, got_k) assert_array_equal(expected_d, got_d) expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close']) got_k, got_d = abstract.Function('stoch', ford_2012)(5, 3, 0, 3, 0) assert_array_equal(expected_k, got_k) assert_array_equal(expected_d, got_d) expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close'], 15) got_k, got_d = abstract.Function('stoch', ford_2012)(15, 5, 0, 5, 0) assert_array_not_equal(expected_k, got_k) assert_array_not_equal(expected_d, got_d) expected_k, expected_d = func.STOCH(ford_2012['high'], ford_2012['low'], ford_2012['close'], 15, 5, 1, 5, 1) got_k, got_d = abstract.Function('stoch', ford_2012)(15, 5, 1, 5, 1) assert_array_equal(expected_k, got_k) assert_array_equal(expected_d, got_d) def test_doji_candle(ford_2012): expected = func.CDLDOJI(ford_2012['open'], ford_2012['high'], ford_2012['low'], ford_2012['close']) got = abstract.Function('CDLDOJI').run(ford_2012) assert_array_equal(got, expected) def test_MAVP(ford_2012): mavp = abstract.MAVP with pytest.raises(Exception): mavp.set_input_arrays(ford_2012) input_d = {} input_d['close'] = ford_2012['close'] input_d['periods'] = np.arange(30) assert mavp.set_input_arrays(input_d) assert mavp.input_arrays == input_d def test_info(): stochrsi = abstract.Function('STOCHRSI') stochrsi.input_names = {'price': 'open'} stochrsi.parameters = {'fastd_matype': talib.MA_Type.EMA} expected = { 'display_name': 'Stochastic Relative Strength Index', 'function_flags': ['Function has an unstable period'], 'group': 'Momentum Indicators', 'input_names': OrderedDict([('price', 'open')]), 'name': 'STOCHRSI', 'output_flags': OrderedDict([ ('fastk', ['Line']), ('fastd', ['Line']), ]), 'output_names': ['fastk', 'fastd'], 'parameters': OrderedDict([ ('timeperiod', 14), ('fastk_period', 5), ('fastd_period', 3), ('fastd_matype', 1), ]), } assert expected == stochrsi.info expected = { 'display_name': 'Bollinger Bands', 'function_flags': ['Output scale same as input'], 'group': 'Overlap Studies', 'input_names': OrderedDict([('price', 'close')]), 'name': 'BBANDS', 'output_flags': OrderedDict([ ('upperband', ['Values represent an upper limit']), ('middleband', ['Line']), ('lowerband', ['Values represent a lower limit']), ]), 'output_names': ['upperband', 'middleband', 'lowerband'], 'parameters': OrderedDict([ ('timeperiod', 5), ('nbdevup', 2), ('nbdevdn', 2), ('matype', 0), ]), } assert expected == abstract.Function('BBANDS').info def test_input_names(): expected = OrderedDict([('price', 'close')]) assert expected == abstract.Function('MAMA').input_names # test setting input_names obv = abstract.Function('OBV') expected = OrderedDict([ ('price', 'open'), ('prices', ['volume']), ]) obv.input_names = expected assert obv.input_names == expected obv.input_names = { 'price': 'open', 'prices': ['volume'], } assert obv.input_names == expected def test_input_arrays(ford_2012): mama = abstract.Function('MAMA') # test default setting assert mama.get_input_arrays() == {} # test setting/getting input_arrays assert mama.set_input_arrays(ford_2012) assert mama.get_input_arrays() == ford_2012 with pytest.raises(Exception): mama.set_input_arrays({'hello': 'fail', 'world': 'bye'}) # test only required keys are needed willr = abstract.Function('WILLR') reqd = willr.input_names['prices'] input_d = dict([(key, ford_2012[key]) for key in reqd]) assert willr.set_input_arrays(input_d) assert willr.input_arrays == input_d # test extraneous keys are ignored input_d['extra_stuffs'] = 'you should never see me' input_d['date'] = np.random.rand(100) assert willr.set_input_arrays(input_d) # test missing keys get detected input_d['open'] = ford_2012['open'] input_d.pop('close') with pytest.raises(Exception): willr.set_input_arrays(input_d) # test changing input_names on the Function willr.input_names = {'prices': ['high', 'low', 'open']} assert willr.set_input_arrays(input_d) def test_parameters(): stoch = abstract.Function('STOCH') expected = OrderedDict([ ('fastk_period', 5), ('slowk_period', 3), ('slowk_matype', 0), ('slowd_period', 3), ('slowd_matype', 0), ]) assert expected == stoch.parameters stoch.parameters = {'fastk_period': 10} expected['fastk_period'] = 10 assert expected == stoch.parameters stoch.parameters = {'slowk_period': 8, 'slowd_period': 5} expected['slowk_period'] = 8 expected['slowd_period'] = 5 assert expected == stoch.parameters stoch.parameters = {'slowd_matype': talib.MA_Type.T3} expected['slowd_matype'] = 8 assert expected == stoch.parameters stoch.parameters = { 'slowk_matype': talib.MA_Type.WMA, 'slowd_matype': talib.MA_Type.EMA, } expected['slowk_matype'] = 2 expected['slowd_matype'] = 1 assert expected == stoch.parameters def test_lookback(): assert abstract.Function('SMA', 10).lookback == 9 stochrsi = abstract.Function('stochrsi', 20, 5, 3) assert stochrsi.lookback == 26 def test_call_supports_same_signature_as_func_module(ford_2012): adx = abstract.Function('ADX') expected = func.ADX(ford_2012['open'], ford_2012['high'], ford_2012['low']) output = adx(ford_2012['open'], ford_2012['high'], ford_2012['low']) assert_array_equal(expected, output) expected_error = re.escape('Too many price arguments: expected 3 (high, low, close)') with pytest.raises(TypeError, match=expected_error): adx(ford_2012['open'], ford_2012['high'], ford_2012['low'], ford_2012['close']) expected_error = re.escape('Not enough price arguments: expected 3 (high, low, close)') with pytest.raises(TypeError, match=expected_error): adx(ford_2012['open'], ford_2012['high']) def test_parameter_type_checking(ford_2012): sma = abstract.Function('SMA', timeperiod=10) expected_error = re.escape('Invalid parameter value for timeperiod (expected int, got float)') with pytest.raises(TypeError, match=expected_error): sma(ford_2012['close'], 35.5) with pytest.raises(TypeError, match=expected_error): abstract.Function('SMA', timeperiod=35.5) with pytest.raises(TypeError, match=expected_error): sma.parameters = {'timeperiod': 35.5} with pytest.raises(TypeError, match=expected_error): sma.set_parameters(timeperiod=35.5) def test_call_doesnt_cache_parameters(ford_2012): sma = abstract.Function('SMA', timeperiod=10) expected = func.SMA(ford_2012['open'], 20) output = sma(ford_2012, timeperiod=20, price='open') assert_array_equal(expected, output) expected = func.SMA(ford_2012['close'], 20) output = sma(ford_2012, timeperiod=20) assert_array_equal(expected, output) expected = func.SMA(ford_2012['close'], 10) output = sma(ford_2012) assert_array_equal(expected, output) def test_call_without_arguments(): with pytest.raises(TypeError, match='Not enough price arguments'): abstract.Function('SMA')() with pytest.raises(TypeError, match='Not enough price arguments'): abstract.Function('SMA')(10) def test_threading(): import pandas as pd TEST_LEN_SHORT = 999 TEST_LEN_LONG = 4005 LOOPS = 1000 THREADS = 4 data_short = np.random.rand(TEST_LEN_SHORT, 5) data_long = np.random.rand(TEST_LEN_LONG, 5) df_short = pd.DataFrame(data_short, columns=['open', 'high', 'low', 'close', 'volume']) df_long = pd.DataFrame(data_long, columns=['open', 'high', 'low', 'close', 'volume']) total = 0 def loop(i): nonlocal total if i % 2 == 0: df = copy.deepcopy(df_short) else: df = copy.deepcopy(df_long) for _ in range(LOOPS): total += 1 df['RSI'] = abstract.RSI(df) t0 = time.time() threads = [] for i in range(THREADS): t = threading.Thread(target=lambda: loop(i)) threads.append(t) t.start() for t in threads: t.join() t1 = time.time() print('test_len: %d, loops: %d' % (TEST_LEN_LONG, LOOPS)) print('%.6f' % (t1 - t0)) print('%.6f' % ((t1 - t0) / LOOPS)) assert total == THREADS * LOOPS ================================================ FILE: tests/test_func.py ================================================ import numpy as np from numpy.testing import assert_array_equal, assert_array_almost_equal import pytest import talib from talib import func def test_talib_version(): assert talib.__ta_version__[:5] == b'0.6.4' def test_num_functions(): assert len(talib.get_functions()) == 161 def test_input_wrong_type(): a1 = np.arange(10, dtype=int) with pytest.raises(Exception): func.MOM(a1) def test_input_lengths(): a1 = np.arange(10, dtype=float) a2 = np.arange(11, dtype=float) with pytest.raises(Exception): func.BOP(a2, a1, a1, a1) with pytest.raises(Exception): func.BOP(a1, a2, a1, a1) with pytest.raises(Exception): func.BOP(a1, a1, a2, a1) with pytest.raises(Exception): func.BOP(a1, a1, a1, a2) def test_input_allnans(): a = np.arange(20, dtype=float) a[:] = np.nan r = func.RSI(a) assert np.all(np.isnan(r)) def test_input_nans(): a1 = np.arange(10, dtype=float) a2 = np.arange(10, dtype=float) a2[0] = np.nan a2[1] = np.nan r1, r2 = func.AROON(a1, a2, 2) assert_array_equal(r1, [np.nan, np.nan, np.nan, np.nan, 0, 0, 0, 0, 0, 0]) assert_array_equal(r2, [np.nan, np.nan, np.nan, np.nan, 100, 100, 100, 100, 100, 100]) r1, r2 = func.AROON(a2, a1, 2) assert_array_equal(r1, [np.nan, np.nan, np.nan, np.nan, 0, 0, 0, 0, 0, 0]) assert_array_equal(r2, [np.nan, np.nan, np.nan, np.nan, 100, 100, 100, 100, 100, 100]) def test_unstable_period(): a = np.arange(10, dtype=float) r = func.EMA(a, 3) assert_array_equal(r, [np.nan, np.nan, 1, 2, 3, 4, 5, 6, 7, 8]) talib.set_unstable_period('EMA', 5) r = func.EMA(a, 3) assert_array_equal(r, [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, 6, 7, 8]) talib.set_unstable_period('EMA', 0) def test_compatibility(): a = np.arange(10, dtype=float) talib.set_compatibility(0) r = func.EMA(a, 3) assert_array_equal(r, [np.nan, np.nan, 1, 2, 3, 4, 5, 6, 7, 8]) talib.set_compatibility(1) r = func.EMA(a, 3) assert_array_equal(r, [np.nan, np.nan,1.25,2.125,3.0625,4.03125,5.015625,6.0078125,7.00390625,8.001953125]) talib.set_compatibility(0) def test_MIN(series): result = func.MIN(series, timeperiod=4) i = np.where(~np.isnan(result))[0][0] assert len(series) == len(result) assert result[i + 1] == 93.780 assert result[i + 2] == 93.780 assert result[i + 3] == 92.530 assert result[i + 4] == 92.530 values = np.array([np.nan, 5., 4., 3., 5., 7.]) result = func.MIN(values, timeperiod=2) assert_array_equal(result, [np.nan, np.nan, 4, 3, 3, 5]) def test_MAX(series): result = func.MAX(series, timeperiod=4) i = np.where(~np.isnan(result))[0][0] assert len(series) == len(result) assert result[i + 2] == 95.090 assert result[i + 3] == 95.090 assert result[i + 4] == 94.620 assert result[i + 5] == 94.620 def test_MOM(): values = np.array([90.0,88.0,89.0]) result = func.MOM(values, timeperiod=1) assert_array_equal(result, [np.nan, -2, 1]) result = func.MOM(values, timeperiod=2) assert_array_equal(result, [np.nan, np.nan, -1]) result = func.MOM(values, timeperiod=3) assert_array_equal(result, [np.nan, np.nan, np.nan]) result = func.MOM(values, timeperiod=4) assert_array_equal(result, [np.nan, np.nan, np.nan]) def test_BBANDS(series): upper, middle, lower = func.BBANDS( series, timeperiod=20, nbdevup=2.0, nbdevdn=2.0, matype=talib.MA_Type.EMA ) i = np.where(~np.isnan(upper))[0][0] assert len(upper) == len(middle) == len(lower) == len(series) # assert abs(upper[i + 0] - 98.0734) < 1e-3 assert abs(middle[i + 0] - 92.8910) < 1e-3 assert abs(lower[i + 0] - 87.7086) < 1e-3 # assert abs(upper[i + 13] - 93.674) < 1e-3 assert abs(middle[i + 13] - 87.679) < 1e-3 assert abs(lower[i + 13] - 81.685) < 1e-3 def test_DEMA(series): result = func.DEMA(series) i = np.where(~np.isnan(result))[0][0] assert len(series) == len(result) assert abs(result[i + 1] - 86.765) < 1e-3 assert abs(result[i + 2] - 86.942) < 1e-3 assert abs(result[i + 3] - 87.089) < 1e-3 assert abs(result[i + 4] - 87.656) < 1e-3 def test_EMAEMA(series): result = func.EMA(series, timeperiod=2) result = func.EMA(result, timeperiod=2) i = np.where(~np.isnan(result))[0][0] assert len(series) == len(result) assert i == 2 def test_CDL3BLACKCROWS(): o = np.array([39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 40.32, 40.51, 38.09, 35.00, 27.66, 30.80]) h = np.array([40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 41.69, 40.84, 38.12, 35.50, 31.74, 32.51]) l = np.array([35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 39.26, 36.73, 33.37, 30.03, 27.03, 28.31]) c = np.array([40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.46, 37.08, 33.37, 30.03, 31.46, 28.31]) result = func.CDL3BLACKCROWS(o, h, l, c) assert_array_equal(result, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -100, 0, 0]) def test_RSI(): a = np.array([0.00000024, 0.00000024, 0.00000024, 0.00000024, 0.00000024, 0.00000023, 0.00000024, 0.00000024, 0.00000024, 0.00000024, 0.00000023, 0.00000024, 0.00000023, 0.00000024, 0.00000023, 0.00000024, 0.00000024, 0.00000023, 0.00000023, 0.00000023], dtype='float64') result = func.RSI(a, 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]) 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]) def test_MAVP(): a = np.array([1,5,3,4,7,3,8,1,4,6], dtype=float) b = np.array([2,4,2,4,2,4,2,4,2,4], dtype=float) result = func.MAVP(a, b, minperiod=2, maxperiod=4) assert_array_equal(result, [np.nan,np.nan,np.nan,3.25,5.5,4.25,5.5,4.75,2.5,4.75]) sma2 = func.SMA(a, 2) assert_array_equal(result[4::2], sma2[4::2]) sma4 = func.SMA(a, 4) assert_array_equal(result[3::2], sma4[3::2]) result = func.MAVP(a, b, minperiod=2, maxperiod=3) assert_array_equal(result, [np.nan,np.nan,4,4,5.5,4.666666666666667,5.5,4,2.5,3.6666666666666665]) sma3 = func.SMA(a, 3) assert_array_equal(result[2::2], sma2[2::2]) assert_array_equal(result[3::2], sma3[3::2]) def test_MAXINDEX(): import talib as func import numpy as np a = np.array([1., 2, 3, 4, 5, 6, 7, 8, 7, 7, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5, 15]) b = func.MA(a, 10) c = func.MAXINDEX(b, 10) assert_array_equal(c, [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,16,16,21]) d = np.array([1., 2, 3]) e = func.MAXINDEX(d, 10) assert_array_equal(e, [0,0,0]) ================================================ FILE: tests/test_pandas.py ================================================ import numpy as np from numpy.testing import assert_array_equal import pandas as pd import talib def test_MOM(): values = pd.Series([90.0,88.0,89.0], index=[10, 20, 30]) result = talib.MOM(values, timeperiod=1) assert isinstance(result, pd.Series) assert_array_equal(result.values, [np.nan, -2, 1]) assert_array_equal(result.index, [10, 20, 30]) result = talib.MOM(values, timeperiod=2) assert isinstance(result, pd.Series) assert_array_equal(result.values, [np.nan, np.nan, -1]) assert_array_equal(result.index, [10, 20, 30]) result = talib.MOM(values, timeperiod=3) assert isinstance(result, pd.Series) assert_array_equal(result.values, [np.nan, np.nan, np.nan]) assert_array_equal(result.index, [10, 20, 30]) result = talib.MOM(values, timeperiod=4) assert isinstance(result, pd.Series) assert_array_equal(result.values, [np.nan, np.nan, np.nan]) assert_array_equal(result.index, [10, 20, 30]) def test_MAVP(): a = pd.Series([1,5,3,4,7,3,8,1,4,6], index=range(10, 20), dtype=float) b = pd.Series([2,4,2,4,2,4,2,4,2,4], index=range(20, 30), dtype=float) result = talib.MAVP(a, b, minperiod=2, maxperiod=4) assert isinstance(result, pd.Series) assert_array_equal(result.values, [np.nan,np.nan,np.nan,3.25,5.5,4.25,5.5,4.75,2.5,4.75]) assert_array_equal(result.index, range(10, 20)) sma2 = talib.SMA(a, 2) assert isinstance(sma2, pd.Series) assert_array_equal(sma2.index, range(10, 20)) assert_array_equal(result.values[4::2], sma2.values[4::2]) sma4 = talib.SMA(a, 4) assert isinstance(sma4, pd.Series) assert_array_equal(sma4.index, range(10, 20)) assert_array_equal(result.values[3::2], sma4.values[3::2]) result = talib.MAVP(a, b, minperiod=2, maxperiod=3) assert isinstance(result, pd.Series) assert_array_equal(result.values, [np.nan,np.nan,4,4,5.5,4.666666666666667,5.5,4,2.5,3.6666666666666665]) assert_array_equal(result.index, range(10, 20)) sma3 = talib.SMA(a, 3) assert isinstance(sma3, pd.Series) assert_array_equal(sma3.index, range(10, 20)) assert_array_equal(result.values[2::2], sma2.values[2::2]) assert_array_equal(result.values[3::2], sma3.values[3::2]) ================================================ FILE: tests/test_polars.py ================================================ import numpy as np from numpy.testing import assert_array_equal import polars as pl import talib from talib import abstract def test_MOM(): values = pl.Series([90.0,88.0,89.0]) result = talib.MOM(values, timeperiod=1) assert isinstance(result, pl.Series) assert_array_equal(result.to_numpy(), [np.nan, -2, 1]) result = talib.MOM(values, timeperiod=2) assert isinstance(result, pl.Series) assert_array_equal(result.to_numpy(), [np.nan, np.nan, -1]) result = talib.MOM(values, timeperiod=3) assert isinstance(result, pl.Series) assert_array_equal(result.to_numpy(), [np.nan, np.nan, np.nan]) result = talib.MOM(values, timeperiod=4) assert isinstance(result, pl.Series) assert_array_equal(result.to_numpy(), [np.nan, np.nan, np.nan]) def test_MAVP(): a = pl.Series([1,5,3,4,7,3,8,1,4,6], dtype=pl.Float64) b = pl.Series([2,4,2,4,2,4,2,4,2,4], dtype=pl.Float64) result = talib.MAVP(a, b, minperiod=2, maxperiod=4) assert isinstance(result, pl.Series) assert_array_equal(result.to_numpy(), [np.nan,np.nan,np.nan,3.25,5.5,4.25,5.5,4.75,2.5,4.75]) sma2 = talib.SMA(a, 2) assert isinstance(sma2, pl.Series) assert_array_equal(result.to_numpy()[4::2], sma2.to_numpy()[4::2]) sma4 = talib.SMA(a, 4) assert isinstance(sma4, pl.Series) assert_array_equal(result.to_numpy()[3::2], sma4.to_numpy()[3::2]) result = talib.MAVP(a, b, minperiod=2, maxperiod=3) assert isinstance(result, pl.Series) assert_array_equal(result.to_numpy(), [np.nan,np.nan,4,4,5.5,4.666666666666667,5.5,4,2.5,3.6666666666666665]) sma3 = talib.SMA(a, 3) assert isinstance(sma3, pl.Series) assert_array_equal(result.to_numpy()[2::2], sma2.to_numpy()[2::2]) assert_array_equal(result.to_numpy()[3::2], sma3.to_numpy()[3::2]) def test_TEVA(): size = 50 df = pl.DataFrame( { "open": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"), "high": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"), "low": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"), "close": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"), "volume": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32") } ) tema1 = abstract.TEMA(df, timeperiod=9) assert isinstance(tema1, pl.Series) assert len(tema1) == 50 inputs = abstract.TEMA.get_input_arrays() assert inputs.columns == df.columns for column in df.columns: assert_array_equal(inputs[column].to_numpy(), df[column].to_numpy()) tema2 = abstract.TEMA(df, timeperiod=9) assert isinstance(tema2, pl.Series) assert len(tema2) == 50 inputs = abstract.TEMA.get_input_arrays() assert inputs.columns == df.columns for column in df.columns: assert_array_equal(inputs[column].to_numpy(), df[column].to_numpy()) assert_array_equal(tema1.to_numpy(), tema2.to_numpy()) def test_AVR(): size = 50 df = pl.DataFrame( { "open": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"), "high": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"), "low": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"), "close": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32"), "volume": np.random.uniform(low=0.0, high=100.0, size=size).astype("float32") } ) high = df['high'] low = df['low'] close = df['close'] atr = talib.ATR(high, low, close, timeperiod=14) ================================================ FILE: tests/test_stream.py ================================================ import numpy as np import pandas as pd from talib import stream def test_streaming(): a = np.array([1,1,2,3,5,8,13], dtype=float) r = stream.MOM(a, timeperiod=1) assert r == 5 r = stream.MOM(a, timeperiod=2) assert r == 8 r = stream.MOM(a, timeperiod=3) assert r == 10 r = stream.MOM(a, timeperiod=4) assert r == 11 r = stream.MOM(a, timeperiod=5) assert r == 12 r = stream.MOM(a, timeperiod=6) assert r == 12 r = stream.MOM(a, timeperiod=7) assert np.isnan(r) def test_streaming_pandas(): a = pd.Series([1,1,2,3,5,8,13]) r = stream.MOM(a, timeperiod=1) assert r == 5 r = stream.MOM(a, timeperiod=2) assert r == 8 r = stream.MOM(a, timeperiod=3) assert r == 10 r = stream.MOM(a, timeperiod=4) assert r == 11 r = stream.MOM(a, timeperiod=5) assert r == 12 r = stream.MOM(a, timeperiod=6) assert r == 12 r = stream.MOM(a, timeperiod=7) assert np.isnan(r) def test_CDL3BLACKCROWS(): o = np.array([39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 40.32, 40.51, 38.09, 35.00]) h = np.array([40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 41.69, 40.84, 38.12, 35.50]) l = np.array([35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 39.26, 36.73, 33.37, 30.03]) c = np.array([40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.46, 37.08, 33.37, 30.03]) r = stream.CDL3BLACKCROWS(o, h, l, c) assert r == -100 def test_CDL3BLACKCROWS_pandas(): o = pd.Series([39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 39.00, 40.32, 40.51, 38.09, 35.00]) h = pd.Series([40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 40.84, 41.69, 40.84, 38.12, 35.50]) l = pd.Series([35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 35.80, 39.26, 36.73, 33.37, 30.03]) c = pd.Series([40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.29, 40.46, 37.08, 33.37, 30.03]) r = stream.CDL3BLACKCROWS(o, h, l, c) assert r == -100 def test_MAXINDEX(): a = np.array([1., 2, 3, 4, 5, 6, 7, 8, 7, 7, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5, 15]) r = stream.MAXINDEX(a, 10) assert r == 21 ================================================ FILE: tools/build_talib_linux.sh ================================================ #!/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!" ================================================ FILE: tools/build_talib_macos.sh ================================================ #!/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!" ================================================ FILE: tools/build_talib_windows.cmd ================================================ :: 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 ================================================ FILE: tools/example.py ================================================ import sys import numpy as np import pylab import talib from talib.abstract import Function TEST_LEN = int(sys.argv[1]) if len(sys.argv) > 1 else 100 r = np.arange(TEST_LEN) idata = np.random.random(TEST_LEN) def func_example(): odata = talib.MA(idata) upper, middle, lower = talib.BBANDS(idata) kama = talib.KAMA(idata) plot(odata, upper, middle, lower, kama) def abstract_example(): sma = Function('sma') input_arrays = sma.get_input_arrays() for key in input_arrays.keys(): input_arrays[key] = idata sma.set_input_arrays(input_arrays) odata = sma(30) # timePeriod=30, specified as an arg bbands = Function('bbands', input_arrays) bbands.parameters = { 'timeperiod': 20, 'nbdevup': 2, 'nbdevdn': 2 } upper, middle, lower = bbands() # multiple output values unpacked (these will always have the correct order) kama = Function('kama').run(input_arrays) # alternative run() calling method. plot(odata, upper, middle, lower, kama) def plot(odata, upper, middle, lower, kama): pylab.plot(r, idata, 'b-', label="original") pylab.plot(r, odata, 'g-', label="MA") pylab.plot(r, upper, 'r-', label="Upper") pylab.plot(r, middle, 'r-', label="Middle") pylab.plot(r, lower, 'r-', label="Lower") pylab.plot(r, kama, 'g', label="KAMA") pylab.legend() pylab.show() if __name__ == '__main__': print('All functions (sorted by group):') groups = talib.get_function_groups() for group, functions in sorted(groups.items()): print('%s functions: %s' % (group, functions)) if len(sys.argv) == 1 or sys.argv[1] == 'func': print('Using talib.func') func_example() else: print('Using talib.abstract') abstract_example() ================================================ FILE: tools/generate_abstract_stub.py ================================================ import inspect import talib import talib.abstract as abstract HEADER = """ from typing import overload, Tuple, Union import numpy as np import pandas as pd """ NUMPY = "np.ndarray" SERIES = "pd.Series" DATAFRAME = "pd.DataFrame" def parse_signature(name: str) -> str: """ Return a comma-separated function signature for the given TA-Lib abstract function using the latest talib (OrderedDict parameters) """ func = abstract.Function(name) func_info = func.info params = ["real"] # always first for param_name, default_val in func_info["parameters"].items(): if default_val is not None: params.append(f"{param_name}={repr(default_val)}") else: params.append(param_name) return ", ".join(params) def output_type(func): outputs = func.output_names if len(outputs) == 1: return NUMPY, SERIES tuple_np_type = f"Tuple[{', '.join([NUMPY]*len(outputs))}]" return tuple_np_type, DATAFRAME def clean_doc(doc): # Remove redundant first line return "\n".join(doc.splitlines()[1:]).strip() def generate_function(name: str): func = abstract.Function(name) params = parse_signature(name) np_type, pd_type = output_type(func) # get talib module docstring (Python-level) doc = clean_doc(inspect.getdoc(getattr(talib, name))) lines = [] if doc: lines.append(f'"""{doc}"""') # Union overload for Series + ndarray (catches both) union_params = params.replace("real", "real: Union[pd.Series, np.ndarray]") lines.append("@overload") lines.append(f"def {name}({union_params}) -> {np_type}: ...") # DataFrame overload df_params = params.replace("real", "real: pd.DataFrame") lines.append("@overload") lines.append(f"def {name}({df_params}) -> {pd_type}: ...") return "\n".join(lines) def main(): print(HEADER) for name in talib.get_functions(): print(generate_function(name)) print() if __name__ == "__main__": main() ================================================ FILE: tools/generate_func.py ================================================ import os import re import sys from talib import abstract # FIXME: initialize once, then shutdown at the end, rather than each call? # FIXME: should we pass startIdx and endIdx into function? # FIXME: don't return number of elements since it always equals allocation? functions = [] if sys.platform == 'win32': 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_dirs: ta_func_header = os.path.join(path, 'ta-lib', 'ta_func.h') if os.path.exists(ta_func_header): header_found = True break if not header_found: print('Error: ta-lib/ta_func.h not found', file=sys.stderr) sys.exit(1) with open(ta_func_header) as f: tmp = [] for line in f: if line.startswith('TA_LIB_API'): line = line[10:] line = line.strip() if tmp or \ line.startswith('TA_RetCode TA_') or \ line.startswith('int TA_'): line = re.sub(r'/\*[^\*]+\*/', '', line) # strip comments tmp.append(line) if not line: s = ' '.join(tmp) s = re.sub(r'\s+', ' ', s) functions.append(s) tmp = [] # strip "float" functions functions = [s for s in functions if not s.startswith('TA_RetCode TA_S_')] # strip non-indicators functions = [s for s in functions if not s.startswith('TA_RetCode TA_Set')] functions = [s for s in functions if not s.startswith('TA_RetCode TA_Restore')] # print headers print("""\ cimport numpy as np from numpy import nan from cython import boundscheck, wraparound # _ta_check_success: defined in _common.pxi cdef double NaN = nan cdef extern from "numpy/arrayobject.h": int PyArray_TYPE(np.ndarray) np.ndarray PyArray_EMPTY(int, np.npy_intp*, int, int) int PyArray_FLAGS(np.ndarray) np.ndarray PyArray_GETCONTIGUOUS(np.ndarray) np.import_array() # Initialize the NumPy C API cimport _ta_lib as lib from _ta_lib cimport TA_RetCode cdef np.ndarray check_array(np.ndarray real): if PyArray_TYPE(real) != np.NPY_DOUBLE: 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_ARRAY_C_CONTIGUOUS): real = PyArray_GETCONTIGUOUS(real) return real cdef np.npy_intp check_length2(np.ndarray a1, np.ndarray a2) except -1: cdef: np.npy_intp length length = a1.shape[0] if length != a2.shape[0]: raise Exception("input array lengths are different") return length cdef np.npy_intp check_length3(np.ndarray a1, np.ndarray a2, np.ndarray a3) except -1: cdef: np.npy_intp length length = a1.shape[0] if length != a2.shape[0]: raise Exception("input array lengths are different") if length != a3.shape[0]: raise Exception("input array lengths are different") return length cdef np.npy_intp check_length4(np.ndarray a1, np.ndarray a2, np.ndarray a3, np.ndarray a4) except -1: cdef: np.npy_intp length length = a1.shape[0] if length != a2.shape[0]: raise Exception("input array lengths are different") if length != a3.shape[0]: raise Exception("input array lengths are different") if length != a4.shape[0]: raise Exception("input array lengths are different") return length cdef np.npy_int check_begidx1(np.npy_intp length, double* a1): cdef: double val for i from 0 <= i < length: val = a1[i] if val != val: continue return i else: return length - 1 cdef np.npy_int check_begidx2(np.npy_intp length, double* a1, double* a2): cdef: double val for i from 0 <= i < length: val = a1[i] if val != val: continue val = a2[i] if val != val: continue return i else: return length - 1 cdef np.npy_int check_begidx3(np.npy_intp length, double* a1, double* a2, double* a3): cdef: double val for i from 0 <= i < length: val = a1[i] if val != val: continue val = a2[i] if val != val: continue val = a3[i] if val != val: continue return i else: return length - 1 cdef np.npy_int check_begidx4(np.npy_intp length, double* a1, double* a2, double* a3, double* a4): cdef: double val for i from 0 <= i < length: val = a1[i] if val != val: continue val = a2[i] if val != val: continue val = a3[i] if val != val: continue val = a4[i] if val != val: continue return i else: return length - 1 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_ARRAY_DEFAULT) outreal_data = outreal.data for i from 0 <= i < min(lookback, length): outreal_data[i] = NaN return outreal 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_ARRAY_DEFAULT) outinteger_data = outinteger.data for i from 0 <= i < min(lookback, length): outinteger_data[i] = 0 return outinteger """) # cleanup variable names to make them more pythonic def cleanup(name): if name.startswith('in'): return name[2:].lower() elif name.startswith('optIn'): return name[5:].lower() else: return name.lower() # print functions names = [] for f in functions: if 'Lookback' in f: # skip lookback functions continue i = f.index('(') name = f[:i].split()[1] args = f[i:].split(',') args = [re.sub(r'[\(\);]', '', s).strip() for s in args] shortname = name[3:] names.append(shortname) 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') print('def %s(' % shortname, end=' ') docs = [' %s(' % shortname] i = 0 for arg in args: var = arg.split()[-1] if var in ('startIdx', 'endIdx'): continue elif 'out' in var: break if i > 0: print(',', end=' ') i += 1 if var.endswith('[]'): var = cleanup(var[:-2]) assert arg.startswith('const double'), arg print('np.ndarray %s not None' % var, end=' ') docs.append(var) docs.append(', ') elif var.startswith('opt'): var = cleanup(var) default_arg = arg.split()[-1][len('optIn'):] # chop off typedef and 'optIn' default_arg = default_arg[0].lower() + default_arg[1:] # lowercase first letter if arg.startswith('double'): if default_arg in defaults: print('double %s=%s' % (var, defaults[default_arg]), end=' ') else: print('double %s=-4e37' % var, end=' ') # TA_REAL_DEFAULT elif arg.startswith('int'): if default_arg in defaults: print('int %s=%s' % (var, defaults[default_arg]), end=' ') else: print('int %s=-2**31' % var, end=' ') # TA_INTEGER_DEFAULT elif arg.startswith('TA_MAType'): print('int %s=%s' % (var, defaults.get('matype', 0)), end=' ') # TA_MAType_SMA else: assert False, arg if '[, ' not in docs: docs[-1] = ('[, ') docs.append('%s=?' % var) docs.append(', ') docs[-1] = '])' if '[, ' in docs else ')' if documentation: tmp_docs = [] lower_case = False documentation = documentation.split('\n')[2:] # discard abstract calling definition for line in documentation: line = line.replace('Substraction', 'Subtraction') if 'prices' not in line and 'price' in line: line = line.replace('price', 'real') if not line or line.isspace(): tmp_docs.append('') else: tmp_docs.append(' %s' % line) # add an indent of 4 spaces docs.append('\n\n') docs.append('\n'.join(tmp_docs)) docs.append('\n ') print('):') print(' """%s"""' % ''.join(docs)) print(' cdef:') print(' np.npy_intp length') print(' int begidx, endidx, lookback') print(' TA_RetCode retCode') for arg in args: var = arg.split()[-1] if 'out' not in var: continue if var.endswith('[]'): var = cleanup(var[:-2]) print(' np.ndarray %s' % var) elif var.startswith('*'): var = cleanup(var[1:]) print(' int %s' % var) else: assert False, arg for arg in args: var = arg.split()[-1] if 'out' in var: break if var.endswith('[]'): var = cleanup(var[:-2]) if 'double' in arg: cast = '' else: assert False, arg print(' %s = check_array(%s)' % (var, var)) # check all input array lengths are the same inputs = [] for arg in args: var = arg.split()[-1] if 'out' in var: break if var.endswith('[]'): var = cleanup(var[:-2]) inputs.append(var) if len(inputs) == 1: print(' length = %s.shape[0]' % inputs[0]) else: print(' length = check_length%s(%s)' % (len(inputs), ', '.join(inputs))) # check for all input values are non-NaN print(' begidx = check_begidx%s(length, %s)' % (len(inputs), ', '.join('(%s.data)' % s for s in inputs))) print(' endidx = length - begidx - 1') print(' lookback = begidx + lib.%s_Lookback(' % name, end=' ') opts = [arg for arg in args if 'opt' in arg] for i, opt in enumerate(opts): if i > 0: print(',', end=' ') print(cleanup(opt.split()[-1]), end=' ') print(')') for arg in args: var = arg.split()[-1] if 'out' not in var: continue if var.endswith('[]'): var = cleanup(var[:-2]) if 'double' in arg: print(' %s = make_double_array(length, lookback)' % var) elif 'int' in arg: print(' %s = make_int_array(length, lookback)' % var) else: assert False, args print(' retCode = lib.%s(' % name, end=' ') for i, arg in enumerate(args): if i > 0: print(',', end=' ') var = arg.split()[-1] if var.endswith('[]'): var = cleanup(var[:-2]) if 'out' in var: data = '(%s.data)+lookback' % var else: data = '(%s.data)+begidx' % var if 'double' in arg: print('%s' % data, end=' ') elif 'int' in arg: print('%s' % data, end=' ') else: assert False, arg elif var.startswith('*'): var = cleanup(var[1:]) print('&%s' % var, end=' ') else: cleaned = cleanup(var) if var != 'startIdx' else '0' print(cleaned, end=' ') print(')') print(' _ta_check_success("%s", retCode)' % name) if 'INDEX' in f: for arg in args: var = arg.split()[-1] if 'out' not in var: continue if var.endswith('[]'): var = cleanup(var[:-2]) print(' %s_data = %s.data' % (var, var)) print(' for i from lookback <= i < length:') print(' %s_data[i] += begidx' % var) print(' return ', end='') i = 0 for arg in args: var = arg.split()[-1] if var.endswith('[]'): var = var[:-2] elif var.startswith('*'): var = var[1:] if var.startswith('out'): if var not in ("outNBElement", "outBegIdx"): if i > 0: print(',', end=' ') i += 1 print(cleanup(var), end=' ') else: assert re.match('.*(void|startIdx|endIdx|opt|in)/*', arg), arg print('') print('') print('__TA_FUNCTION_NAMES__ = [%s]' % ','.join(['\"%s\"' % name for name in names])) ================================================ FILE: tools/generate_stream.py ================================================ import os import re import sys from talib import abstract # FIXME: initialize once, then shutdown at the end, rather than each call? # FIXME: should we pass startIdx and endIdx into function? # FIXME: don't return number of elements since it always equals allocation? functions = [] if sys.platform == 'win32': 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_dirs: ta_func_header = os.path.join(path, 'ta-lib', 'ta_func.h') if os.path.exists(ta_func_header): header_found = True break if not header_found: print('Error: ta-lib/ta_func.h not found', file=sys.stderr) sys.exit(1) with open(ta_func_header) as f: tmp = [] for line in f: if line.startswith('TA_LIB_API'): line = line[10:] line = line.strip() if tmp or \ line.startswith('TA_RetCode TA_') or \ line.startswith('int TA_'): line = re.sub(r'/\*[^\*]+\*/', '', line) # strip comments tmp.append(line) if not line: s = ' '.join(tmp) s = re.sub(r'\s+', ' ', s) functions.append(s) tmp = [] # strip "float" functions functions = [s for s in functions if not s.startswith('TA_RetCode TA_S_')] # strip non-indicators functions = [s for s in functions if not s.startswith('TA_RetCode TA_Set')] functions = [s for s in functions if not s.startswith('TA_RetCode TA_Restore')] # print headers print("""\ cimport numpy as np 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 np.import_array() # Initialize the NumPy C API """) # cleanup variable names to make them more pythonic def cleanup(name): if name.startswith('in'): return name[2:].lower() elif name.startswith('optIn'): return name[5:].lower() else: return name.lower() # print functions names = [] for f in functions: if 'Lookback' in f: # skip lookback functions continue i = f.index('(') name = f[:i].split()[1] args = f[i:].split(',') args = [re.sub(r'[\(\);]', '', s).strip() for s in args] shortname = name[3:] names.append(shortname) 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') print('def stream_%s(' % shortname, end=' ') docs = [' %s(' % shortname] i = 0 for arg in args: var = arg.split()[-1] if var in ('startIdx', 'endIdx'): continue elif 'out' in var: break if i > 0: print(',', end=' ') i += 1 if var.endswith('[]'): var = cleanup(var[:-2]) assert arg.startswith('const double'), arg print('np.ndarray %s not None' % var, end=' ') docs.append(var) docs.append(', ') elif var.startswith('opt'): var = cleanup(var) default_arg = arg.split()[-1][len('optIn'):] # chop off typedef and 'optIn' default_arg = default_arg[0].lower() + default_arg[1:] # lowercase first letter if arg.startswith('double'): if default_arg in defaults: print('double %s=%s' % (var, defaults[default_arg]), end=' ') else: print('double %s=-4e37' % var, end=' ') # TA_REAL_DEFAULT elif arg.startswith('int'): if default_arg in defaults: print('int %s=%s' % (var, defaults[default_arg]), end=' ') else: print('int %s=-2**31' % var, end=' ') # TA_INTEGER_DEFAULT elif arg.startswith('TA_MAType'): print('int %s=%s' % (var, defaults.get('matype', 0)), end=' ') # TA_MAType_SMA else: assert False, arg if '[, ' not in docs: docs[-1] = ('[, ') docs.append('%s=?' % var) docs.append(', ') docs[-1] = '])' if '[, ' in docs else ')' if documentation: tmp_docs = [] lower_case = False documentation = documentation.split('\n')[2:] # discard abstract calling definition for line in documentation: line = line.replace('Substraction', 'Subtraction') if 'prices' not in line and 'price' in line: line = line.replace('price', 'real') if not line or line.isspace(): tmp_docs.append('') else: tmp_docs.append(' %s' % line) # add an indent of 4 spaces docs.append('\n\n') docs.append('\n'.join(tmp_docs)) docs.append('\n ') print('):') print(' """%s"""' % ''.join(docs)) print(' cdef:') print(' np.npy_intp length') print(' TA_RetCode retCode') for arg in args: var = arg.split()[-1] if 'out' in var: break if var.endswith('[]'): var = cleanup(var[:-2]) if 'double' in arg: print(' double* %s_data' % var) elif 'int' in arg: print(' int* %s_data' % var) else: assert False, args for arg in args: var = arg.split()[-1] if 'out' not in var: continue if var.endswith('[]'): var = cleanup(var[:-2]) if 'double' in arg: print(' double %s' % var) elif 'int' in arg: print(' int %s' % var) else: assert False, args elif var.startswith('*'): var = cleanup(var[1:]) print(' int %s' % var) else: assert False, arg for arg in args: var = arg.split()[-1] if 'out' in var: break if var.endswith('[]'): var = cleanup(var[:-2]) if 'double' in arg: cast = '' else: assert False, arg print(' %s = check_array(%s)' % (var, var)) print(' %s_data = %s%s.data' % (var, cast, var)) # check all input array lengths are the same inputs = [] for arg in args: var = arg.split()[-1] if 'out' in var: break if var.endswith('[]'): var = cleanup(var[:-2]) inputs.append(var) if len(inputs) == 1: print(' length = %s.shape[0]' % inputs[0]) else: print(' length = check_length%s(%s)' % (len(inputs), ', '.join(inputs))) for arg in args: var = arg.split()[-1] if 'out' not in var: continue if var.endswith('[]'): var = cleanup(var[:-2]) if 'double' in arg: print(' %s = NaN' % var) elif 'int' in arg: print(' %s = 0' % var) else: assert False, args print(' retCode = lib.%s(' % name, end=' ') for i, arg in enumerate(args): if i > 0: print(',', end=' ') var = arg.split()[-1] if var.endswith('[]'): var = cleanup(var[:-2]) if 'out' in var: print('&%s' % var, end=' ') else: print('%s_data' % var, end=' ') elif var.startswith('*'): var = cleanup(var[1:]) print('&%s' % var, end=' ') elif var in ('startIdx', 'endIdx'): print('(length) - 1', end= ' ') else: cleaned = cleanup(var) print(cleaned, end=' ') print(')') print(' _ta_check_success("%s", retCode)' % name) print(' return ', end='') i = 0 for arg in args: var = arg.split()[-1] if var.endswith('[]'): var = var[:-2] elif var.startswith('*'): var = var[1:] if var.startswith('out'): if var not in ("outNBElement", "outBegIdx"): if i > 0: print(',', end=' ') i += 1 print(cleanup(var), end=' ') else: assert re.match('.*(void|startIdx|endIdx|opt|in)/*', arg), arg print('') print('') ================================================ FILE: tools/perf_talib.py ================================================ import numpy import talib import time import sys TEST_LEN = int(sys.argv[1]) if len(sys.argv) > 1 else 10000 LOOPS = int(sys.argv[2]) if len(sys.argv) > 2 else 1000 data = numpy.random.random(TEST_LEN) if False: # fill array with nans data[:-1] = numpy.nan t0 = time.time() for _ in range(LOOPS): talib.MA(data) talib.BBANDS(data) talib.KAMA(data) talib.CDLMORNINGDOJISTAR(data, data, data, data) t1 = time.time() print('test_len: %d, loops: %d' % (TEST_LEN, LOOPS)) print('%.6f' % (t1 - t0)) print('%.6f' % ((t1 - t0) / LOOPS)) ================================================ FILE: tools/threads_talib.py ================================================ import time import threading import numpy import copy from talib.abstract import RSI import sys import pandas as pd TEST_LEN_SHORT = int(sys.argv[1]) if len(sys.argv) > 1 else 999 TEST_LEN_LONG = int(sys.argv[1]) if len(sys.argv) > 1 else 4005 LOOPS = int(sys.argv[2]) if len(sys.argv) > 2 else 1000 data_short = numpy.random.rand(TEST_LEN_SHORT, 5) data_long = numpy.random.rand(TEST_LEN_LONG, 5) df_short = pd.DataFrame(data_short, columns={ 'open', 'high', 'low', 'close', 'volume'}) df_long = pd.DataFrame(data_long, columns={ 'open', 'high', 'low', 'close', 'volume'}) total = 0 def loop(): global total if threading.get_native_id() % 2 == 0: df = copy.deepcopy(df_short) else: df = copy.deepcopy(df_long) while total < LOOPS: total += 1 try: df['RSI'] = RSI(df) except ValueError as msg: raise ValueError(msg) t0 = time.time() threads = [] for i in range(4): t = threading.Thread(target=loop) threads.append(t) t.start() for t in threads: t.join() t1 = time.time() print('test_len: %d, loops: %d' % (TEST_LEN_LONG, LOOPS)) print('%.6f' % (t1 - t0)) print('%.6f' % ((t1 - t0) / LOOPS))