pax_global_header00006660000000000000000000000064134640750200014513gustar00rootroot0000000000000052 comment=1c719c6cf2c9da346eeade7f645b9b93da63d6a4 khiva-python-0.2.2/000077500000000000000000000000001346407502000141355ustar00rootroot00000000000000khiva-python-0.2.2/.CI/000077500000000000000000000000001346407502000145065ustar00rootroot00000000000000khiva-python-0.2.2/.CI/travis/000077500000000000000000000000001346407502000160165ustar00rootroot00000000000000khiva-python-0.2.2/.CI/travis/build_and_test.sh000066400000000000000000000007161346407502000213360ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. # Build the project if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then python${PYTHON_VERSION} setup.py install else python setup.py install fi coverage run -m unittest discover tests/unit_tests *_tests.py -f -v khiva-python-0.2.2/.CI/travis/install-arrayfire.sh000066400000000000000000000024111346407502000220000ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install fftw freeimage if [ ! -e "./installers/arrayfire-no-gl.pkg" ]; then wget https://github.com/shapelets/arrayfire/releases/download/v3.6.2/arrayfire-no-gl.pkg -O installers/arrayfire-no-gl.pkg fi # Installs arrayfire sudo installer -pkg ./installers/arrayfire-no-gl.pkg -target / else sudo apt-get update && \ sudo apt-get install -y libboost-all-dev \ libfftw3-dev \ libfontconfig1-dev \ libfreeimage-dev \ liblapack-dev \ liblapacke-dev \ libopenblas-dev if [ ! -e "./installers/arrayfire-no-gl.sh" ]; then wget https://github.com/shapelets/arrayfire/releases/download/v3.6.2/arrayfire-no-gl.sh -O installers/arrayfire-no-gl.sh fi sudo mkdir -p /opt/arrayfire-3 sudo bash installers/arrayfire-no-gl.sh --prefix=/opt/arrayfire-3 --skip-license sudo ln -s /opt/arrayfire-3/lib64 /opt/arrayfire-3/lib echo "/opt/arrayfire-3/lib" | sudo tee /etc/ld.so.conf.d/arrayfire.conf sudo ldconfig fi khiva-python-0.2.2/.CI/travis/install-khiva.sh000066400000000000000000000054461346407502000211310ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. if [[ "$INSTALL_KHIVA_METHOD" == "installer" ]]; then if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then if [ ! -e "./installers/khiva-v0.1.0.pkg" ]; then wget https://github.com/shapelets/khiva/releases/download/v0.1.0/khiva-v0.1.0-OnlyCPU.pkg -O ./installers/khiva-v0.1.0-OnlyCPU.pkg fi # Installs Khiva sudo installer -pkg ./installers/khiva-v0.1.0-OnlyCPU.pkg -target / else if [ ! -e "./installers/khiva-v0.1.0-ci.sh" ]; then wget https://github.com/shapelets/khiva/releases/download/v0.1.0/khiva-v0.1.0-ci.sh -O ./installers/khiva-v0.1.0-ci.sh chmod +x ./installers/khiva-v0.1.0-ci.sh fi sudo ./installers/khiva-v0.1.0-ci.sh --prefix=/usr/local --skip-license sudo ldconfig fi else # GitHub method # Install cmake in Linux, it is already installed in osx if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then # Check if the file already exists if [ ! -e "${TRAVIS_BUILD_DIR}/cmakebin/cmake-3.13.2-Linux-x86_64.sh" ]; then mkdir -p cmakebin wget https://github.com/Kitware/CMake/releases/download/v3.13.2/cmake-3.13.2-Linux-x86_64.sh -O cmakebin/cmake-3.13.2-Linux-x86_64.sh fi # Install cmake sudo bash cmakebin/cmake-3.13.2-Linux-x86_64.sh --prefix=./cmakebin/ --skip-license fi #Installing conan and dependencies if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then pip install conan else pip${PYTHON_VERSION} install conan==1.6.1 fi conan remote add conan-mpusz https://api.bintray.com/conan/mpusz/conan-mpusz if [ $? -ne 0 ]; then conan remote update conan-mpusz https://api.bintray.com/conan/mpusz/conan-mpusz fi # Cloning Github repo into khiva-library folder git clone https://github.com/shapelets/khiva.git khiva-library cd khiva-library mkdir -p build && cd build if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then conan install .. -s compiler=apple-clang -s compiler.version=9.1 -s compiler.libcxx=libc++ --build missing cmake .. -DKHIVA_ONLY_CPU_BACKEND=ON -DKHIVA_BUILD_DOCUMENTATION=OFF -DKHIVA_BUILD_EXAMPLES=OFF -DKHIVA_BUILD_BENCHMARKS=OFF make install -j8 else conan install .. -s compiler.libcxx=libstdc++11 --build missing ../../cmakebin/bin/cmake .. -DKHIVA_ENABLE_COVERAGE=ON -DKHIVA_BUILD_DOCUMENTATION=OFF -DKHIVA_BUILD_EXAMPLES=OFF -DKHIVA_BUILD_BENCHMARKS=OFF sudo make install -j8 sudo ldconfig fi # Switching back to the khiva-python folder cd .. cd .. fi khiva-python-0.2.2/.CI/travis/install.sh000066400000000000000000000016041346407502000200210ustar00rootroot00000000000000#!/bin/bash # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew upgrade pyenv export PATH=$HOME/.pyenv/shims:$HOME/.pyenv/versions/${TRAVIS_PYTHON_VERSION}/bin:$PATH export PYTHON_VERSION=$(echo $TRAVIS_PYTHON_VERSION | awk -F'.' '{print $1 "." $2}') pyenv install ${TRAVIS_PYTHON_VERSION} -s pyenv init - pyenv local ${TRAVIS_PYTHON_VERSION} python${PYTHON_VERSION} --version pip${PYTHON_VERSION} install -r requirements.txt pip${PYTHON_VERSION} install -r test-requirements.txt pip${PYTHON_VERSION} install codecov else pip install -r requirements.txt pip install -r test-requirements.txt pip install codecov fi khiva-python-0.2.2/.appveyor.yml000066400000000000000000000054111346407502000166040ustar00rootroot00000000000000# Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. image: - Visual Studio 2017 environment: GENERATOR: "Visual Studio 15 Win64" BOOST_PATH: C:\Libraries\boost_1_67_0 AF_PATH: C:\Program Files\ArrayFire\v3 KHIVA_PATH: C:\Program Files\Khiva\v0 matrix: - PATH: $(AF_PATH)\lib;$(KHIVA_PATH)\lib;C:\Python36-x64;C:\Python36-x64\Scripts;$(PATH) - PATH: $(AF_PATH)\lib;$(KHIVA_PATH)\lib;C:\Python27-x64;C:\Python27-x64\Scripts;$(PATH) cache: - c:\tools\vcpkg\installed - C:\Program Files\ArrayFire - C:\Program Files\Khiva clone_folder: C:\khiva-python platform: - x64 before_build: - ps: if(!(Test-Path -Path "C:\Program Files\ArrayFire" )){ appveyor DownloadFile "https://www.dropbox.com/s/13wnbd1qynjmw0i/ArrayFire-v3.6.2.zip?dl=1" -FileName ArrayFire-v3.6.2.zip } - ps: if(!(Test-Path -Path "C:\Program Files\ArrayFire" )){ 7z x ArrayFire-v3.6.2.zip -o"C:\Program Files" } - reg add HKCU\Software\Kitware\CMake\Packages\ArrayFire /v ArrayFire_CMake_DIR /d "C:\Program Files\ArrayFire\v3\cmake" /f - vcpkg install --triplet x64-windows gtest eigen3 - ps: if ($env:INSTALL_KHIVA_METHOD -eq "installer"){ if(!(Test-Path -Path "C:\Program Files\Khiva" )){ appveyor DownloadFile "https://github.com/shapelets/khiva/releases/download/v0.2.0/khiva-v0.2.0-unattended.exe" -FileName khiva-v0.2.0-unattended.exe }; if(!(Test-Path -Path "C:\Program Files\Khiva" )){ .\khiva-v0.2.0-unattended.exe /S }; }else{ git clone -q https://github.com/shapelets/khiva.git C:\khiva-library ; cd C:\khiva-library; mkdir build; cd build; cmake .. -DCMAKE_TOOLCHAIN_FILE=c:/tools/vcpkg/scripts/buildsystems/vcpkg.cmake -DBOOST_ROOT="$($env:BOOST_PATH)" -DKHIVA_USE_CONAN=OFF -DKHIVA_BUILD_DOCUMENTATION=OFF -DKHIVA_BUILD_BENCHMARKS=OFF -DKHIVA_ONLY_CPU_BACKEND=ON -G"$env:GENERATOR"; cmake --build . --config Release --target INSTALL -- /m; } - cd C:\khiva-python - pip install -r requirements.txt - pip install -r test-requirements.txt - pip install codecov build_script: - python setup.py install test_script: - coverage run -m unittest discover tests/unit_tests *_tests.py -f -v - python -m xmlrunner discover tests/unit_tests *_tests.py on_finish: - codecov -F Windows -X gcov - ps: | $files = Get-ChildItem -Path . -File -Filter *.xml foreach ($file in $files) { (New-Object System.Net.WebClient).UploadFile("https://ci.appveyor.com/api/testresults/junit/$($env:APPVEYOR_JOB_ID)", $file.FullName) } khiva-python-0.2.2/.github/000077500000000000000000000000001346407502000154755ustar00rootroot00000000000000khiva-python-0.2.2/.github/CODE_OF_CONDUCT.md000066400000000000000000000166031346407502000203020ustar00rootroot00000000000000# Code of Conduct > A code of conduct is a set of rules outlining the social norms and rules and responsibilities of, or proper practices for, an individual, party or organization ## Summary Shapelets is dedicated to providing a harassment-free working environment for all, regardless of gender, sexual orientation, disability, physical appearance, body size, race, or religion. We do not tolerate harassment of any form. All communication should be appropriate for a professional audience including people of many different backgrounds. Sexual language and imagery is not appropriate for any communication and/or talks. Be kind and do not insult or put down others. Behave professionally. Remember that harassment and sexist, racist, or exclusionary jokes are not appropriate for Shapelets. Staff violating these rules should be reported to an appropriate line manager. These are the values to which people in the Shapelets community should aspire: - Be friendly and welcoming - Be patient - Remember that people have varying communication styles and that not everyone is using their native language. (Meaning and tone can be lost in translation.) - Be thoughtful - Productive communication requires effort. Think about how your words will be interpreted. - Remember that sometimes it is best to refrain entirely from commenting. - Be respectful - In particular, respect differences of opinion. - Be charitable - Interpret the arguments of others in good faith, do not seek to disagree. - When we do disagree, try to understand why. - Avoid destructive behavior: - Derailing: stay on topic; if you want to talk about something else, start a new conversation. - Unconstructive criticism: don't merely decry the current state of affairs; offer—or at least solicit—suggestions as to how things may be improved. - Snarking (pithy, unproductive, sniping comments) - Discussing potentially offensive or sensitive issues; this all too often leads to unnecessary conflict. - Microaggressions: brief and commonplace verbal, behavioral and environmental indignities that communicate hostile, derogatory or negative slights and insults to a person or group. People are complicated. You should expect to be misunderstood and to misunderstand others; when this inevitably occurs, resist the urge to be defensive or assign blame. Try not to take offense where no offense was intended. Give people the benefit of the doubt. Even if the intent was to provoke, do not rise to it. It is the responsibility of all parties to de-escalate conflict when it arises. ## Reporting an incident Incidents that violate the Code of Conduct are extremely damaging to Shapelets, and they will not be tolerated. The silver lining is that, in many cases, these incidents present a chance for the offenders, and the teams at large, to grow, learn, and become better. > The following should be handled by a line manager who has been informed of the incident Try to get as much of the incident in written form. The important information to gather include the following: - Name and team of the participant doing the harassing - The location in which the incident occurred - The behavior that was in violation - The approximate time of the behavior - The circumstances surrounding the incident - Other people involved in the incident Depending on the severity/details of the incident, please follow these guidelines: - If there is any general threat to staff or any other doubts, summon security or police - Offer the victim a private place to sit - Ask "is there a friend or trusted person who you would like to be with you?" (if so, arrange for someone to fetch this person) - Ask them "how can I help?" - Provide them with your list of emergency contacts if they need help later - If everyone is presently physically safe, involve the police or security only at a victim's request There are also some guidelines as to what not to do as an initial response: - Do not overtly invite them to withdraw the complaint or mention that withdrawal is OK. This suggests that you want them to do so, and is therefore coercive. "If you're OK with pursuing the complaint" suggests that you are by default pursuing it and is not coercive. - Do not ask for their advice on how to deal with the complaint. This is a staff responsibility. - Do not offer them input into penalties. This is the staff's responsibility. The line manager who is handling the reported offence should find out the following: - What happened? - Are we doing anything about it? - Who is doing those things? - When are they doing them? After the above has been identified and discussed, have an appropriate line manager communicate with the alleged harasser. Make sure to inform them of what has been reported about them. Allow the alleged harasser to give their side of the story. After this point, if the report stands, let the alleged harasser know what actions will be taken against them. Some things for the staff to consider when dealing with Code of Conduct offenders: - Warning the harasser to cease their behaviour and that any further reports will result in sanctions - Requiring that the harasser avoid any interaction with, and physical proximity to, their victim until a resolution or course of action has been decided upon - Requiring that the harasser not volunteer for future events your organisation runs (either indefinitely or for a certain time period) - Depending on the severity/details of the incident, requiring that the harasser immediately be sent home - Depending on the severity/details of the incident, removing a harasser from membership of relevant Shapelets organisations - Depending on the severity/details of the incident, publishing an account of the harassment and calling for the resignation of the harasser from their responsibilities (usually pursued by people without formal authority: may be called for if the harasser is a team leader, or refuses to stand aside from the conflict of interest) Give accused staff members a place to appeal to if there is one, but in the meantime the report stands. Keep in mind that it is not a good idea to encourage an apology from the harasser. It is very important how we deal with the incident publicly. Our policy is to make sure that everyone aware of the initial incident is also made aware that it is not according to policy and that official action has been taken - while still respecting the privacy of individual staff members. When speaking to individuals (those who are aware of the incident, but were not involved with the incident) about the incident it is a good idea to keep the details out. Depending on the incident, the head of responsible department, or designate, may decide to make one or more public announcements. If necessary, this will be done with a short announcement either during the plenary and/or through other channels. No one other than the head of responsible department or someone delegated authority from them should make any announcements. No personal information about either party will be disclosed as part of this process. If some members of staff were angered by the incident, it is best to apologise to them that the incident occurred to begin with. If there are residual hard feelings, suggest to them to write an email to the responsible head of department. It will be dealt with accordingly. ## Attribution This Code of Conduct was adapted from both [Golang](https://golang.org/conduct) an the [Golang UK Conference](http://golanguk.com/conduct/). khiva-python-0.2.2/.github/ISSUE_TEMPLATE/000077500000000000000000000000001346407502000176605ustar00rootroot00000000000000khiva-python-0.2.2/.github/ISSUE_TEMPLATE/bug_report.md000066400000000000000000000012461346407502000223550ustar00rootroot00000000000000--- name: Bug report about: Create a report to help us improve --- **Describe the bug** A clear and concise description of what the bug is. **To Reproduce** Steps to reproduce the behavior, at minimum a code snippet containing the steps which produced the error, and preferably a project with : **Expected behavior** A clear and concise description of what you expected to happen. **Screenshots** If applicable, add screenshots to help explain your problem. **Environment information:** - OS: [e.g. Mac OS] - Version [e.g. 10.13] - Khiva dependencies versions [e.g. numpy==1.14.0 or pandas==0.22.0] **Additional context** Add any other context about the problem here. khiva-python-0.2.2/.github/ISSUE_TEMPLATE/feature_request.md000066400000000000000000000010601346407502000234020ustar00rootroot00000000000000--- name: Feature request about: Suggest an idea for this project --- **Is your feature request related to a problem? Please describe.** A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] **Describe the solution you'd like** A clear and concise description of what you want to happen. **Describe alternatives you've considered** A clear and concise description of any alternative solutions or features you've considered. **Additional context** Add any other context or screenshots about the feature request here. khiva-python-0.2.2/.github/PULL_REQUEST_TEMPLATE.md000066400000000000000000000017431346407502000213030ustar00rootroot00000000000000Make sure you have checked _all_ steps below. ### Description - [ ] Here are some details about my PR, including screenshots of any UI changes: ### Tests - [ ] My PR adds the following unit tests __OR__ does not need testing for this extremely good reason: ### Commits - [ ] My commits have been squashed if they address the same issue. In addition, my commits follow the guidelines from "[How to write a good git commit message](http://chris.beams.io/posts/git-commit/)": 1. Subject is separated from body by a blank line 2. Subject is limited to 50 characters 3. Subject does not end with a period 4. Subject uses the imperative mood ("add", not "adding") 5. Body wraps at 72 characters 6. Body explains "what" and "why", not "how" ## License - [ ] Add a [Mozilla Public License 2.0 license header](http://mozilla.org/MPL/2.0/) to all the new files. ### Documentation - [ ] In case of new functionality, my PR adds documentation that describes how to use it. khiva-python-0.2.2/.gitignore000066400000000000000000000022731346407502000161310ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python env/ build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ *.egg-info/ .installed.cfg *.egg # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover .hypothesis/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder target/ # Jupyter Notebook .ipynb_checkpoints # pyenv .python-version # celery beat schedule file celerybeat-schedule # SageMath parsed files *.sage.py # dotenv .env # virtualenv .venv venv/ ENV/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ #documentation ./docs/build/ #IntelliJ files. .idea khiva-python-0.2.2/.travis.yml000066400000000000000000000040561346407502000162530ustar00rootroot00000000000000# Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. language: python matrix: fast_finish: true include: - os: linux dist: xenial sudo: required python: "3.6" cache: directories: - ${TRAVIS_BUILD_DIR}/installers - ${HOME}/.conan - ${TRAVIS_BUILD_DIR}/cmakebin after_success: - codecov -F Linux -X gcov - os: linux dist: xenial sudo: required python: "3.5" cache: directories: - ${TRAVIS_BUILD_DIR}/installers - ${HOME}/.conan - ${TRAVIS_BUILD_DIR}/cmakebin - os: linux dist: xenial sudo: required python: "2.7" cache: directories: - ${TRAVIS_BUILD_DIR}/installers - ${HOME}/.conan - ${TRAVIS_BUILD_DIR}/cmakebin - os: osx osx_image: xcode9.3 language: generic env: - TRAVIS_PYTHON_VERSION=3.6.5 cache: directories: - ${TRAVIS_BUILD_DIR}/installers - $HOME/.pyenv - $HOME/Library/Caches/Homebrew - ${HOME}/.conan after_success: - codecov -F MacOS -X gcov - os: osx osx_image: xcode9.3 language: generic env: - TRAVIS_PYTHON_VERSION=3.5.5 cache: directories: - ${TRAVIS_BUILD_DIR}/installers - $HOME/.pyenv - $HOME/Library/Caches/Homebrew - ${HOME}/.conan - os: osx osx_image: xcode9.3 language: generic env: - TRAVIS_PYTHON_VERSION=2.7.15 cache: directories: - ${TRAVIS_BUILD_DIR}/installers - $HOME/.pyenv - $HOME/Library/Caches/Homebrew - ${HOME}/.conan install: - source .CI/travis/install.sh - source .CI/travis/install-arrayfire.sh - source .CI/travis/install-khiva.sh script: - source .CI/travis/build_and_test.sh khiva-python-0.2.2/AUTHORS.rst000066400000000000000000000010111346407502000160050ustar00rootroot00000000000000Authors ========== Core Development Team --------------------- - Cuesta Merino, David (`david.cuesta@shapelets.io `_) - Ruíz-Ferrer, Justo (`justo.ruiz@shapelets.io `_) - Torreño Tirado, Óscar (`oscar.torreno@shapelets.io `_) - Vilches Reina, Antonio (`antonio.vilches@shapelets.io `_) Contributions ------------- - Sánchez de Ybargüen, Luis (`luis.sanchez@shapelets.io `_) khiva-python-0.2.2/CHANGES.rst000066400000000000000000000035221346407502000157410ustar00rootroot00000000000000========= Changelog ========= KHIVA uses `Semantic Versioning `_ Version 0.2.2 ============= Added - Join function for KHIVA arrays. Fixed - to_arrayfire and from_arrayfire functions. - KShape for double precision data. Version 0.2.0 ============= Added - KMeans algorithm. - KShape Algorithm. - Added Ljung-Box test. - Installation script for Windows. - SBD distance function. - Header checks in all header files from core library and bindings. Changed - Implementation improvement of stomp function and find motifs and discords functions. - Readme and installation Guide have been improved. Fixed - PAA method. - Crosscorrelation function to work with several time series. - Conan script to work with new conan version. - Documentation generator to work with new PIP version. - Cmake path for windows in installation guide. Version 0.1.0 ============= Added - Binding for Matlab. - Statistics namespace. - Features namespace. - Dimensionality namespace. - Polynomial namespace. - LinAlg namespace. - Normalization namespace. - Regression namespace. - Regularization namespace. - Support for Windows and Linux (Ubuntu 16.04 LTS). - Documentation using breathe. - Async. memory management. - Operators for Khiva Arrays class for all bindings (Java, Python, C++, R) Removed - Simplification namespace. Version 0.0.1 ============= Added - We have set Arrayfire as an abstraction layer to run on top of accelerators that are able to run OpenCL. - Implementation of STOMP method. - (Mueen's Algorithm for Similarity Search) MASS algorithm implementation. - Implementation of Simplification algorithms (Visvalingam and PIP). - Benchmarks Suite (based on Google Benchmark). - Test Suite (Google Test). - New Features Algorithms. - Binding for Python, R, Java. - Matrix namespace. - Distances namespace. - Simplification namespace. khiva-python-0.2.2/CONTRIBUTING.md000066400000000000000000000056551346407502000164010ustar00rootroot00000000000000# Contributing Contributions are welcome and are greatly appreciated! Every little bit helps, and credit will always be given. # Table of Contents * [Formatting Style](#formatting-style) * [Branching model](#branching-model) * [Contribution process](#contribution-process) * [Types of Contributions](#types-of-contributions) - [Report Bugs](#report-bugs) - [Fix Bugs](#fix-bugs) - [Implement Features](#implement-features) - [Improve Documentation](#improve-documentation) - [Submit Feedback](#submit-feedback) * [Documentation](#documentation) * [Development and Testing](#development-and-testing) - [Set up a development env using Docker](#set-up-a-development-env-using-docker) ## Formatting Style In order to have a standardised code base, we only accept code that is formatted according to PEP 8. ## Branching model Our branching model has one permanent branch, **master**. We aim at using `master` as the main branch, where all features are merged. In this sense, we also use the master branch to contain the release versions of the Python Khiva library by means of git tags. ## Contribution process In order to contribute to the code base, we follow the next process : 1. The main branch is `master`, every developer should pull the current status of the branch before starting to develop any new feature. `git pull` 1. Create a new branch with the following pattern "feature/[name_of_the_feature]" `git checkout -b feature/example_feature` 3. Develop the new feature on the the new branch. It includes testing and documentation. `git commit -a -m "Bla, Bla, Bla"; git push` 4. Open a Pull Request to merge the feature branch into `master`. Currently, a pull request has to be reviewed at least by one person. 5. Finally, delete the feature branch. 6. Move back to `master` branch. `git checkout master` 7. Pull the latest changes. `git pull` ## Types of Contributions ### Report Bugs Report bugs through [GitHub issues](https://github.com/shapelets/khiva-python/issues) Please follow the project issue template to exhibit the problem. ### Fix Bugs Look through the GitHub issues for bugs. Anything is open to whoever wants to implement it. ### Implement Features Look through the [GitHub issues](https://github.com/shapelets/khiva-python/issues) for feature requests. Any unassigned "Improvement" issue is open to whoever wants to implement it. ### Improve Documentation Khiva could always use better documentation, whether as part of the official Khiva docs, or even description of the methods in the different namespaces. ### Submit Feedback The best way to send feedback is to open an issue on [GitHub issues](https://github.com/shapelets/khiva-python/issues) If you are proposing a feature, please follow the feature request template. ## Development and Testing ### Set up a development env using Docker Start a new docker container. ``` # Start docker docker run --rm -ti shapelets/khiva-python ``` khiva-python-0.2.2/LICENSE.txt000066400000000000000000000370701346407502000157670ustar00rootroot00000000000000Mozilla Public License, version 2.0 1. Definitions 1.1. "Contributor" means each individual or legal entity that creates, contributes to the creation of, or owns Covered Software. 1.2. "Contributor Version" means the combination of the Contributions of others (if any) used by a Contributor and that particular Contributor's Contribution. 1.3. "Contribution" means Covered Software of a particular Contributor. 1.4. "Covered Software" means Source Code Form to which the initial Contributor has attached the notice in Exhibit A, the Executable Form of such Source Code Form, and Modifications of such Source Code Form, in each case including portions thereof. 1.5. "Incompatible With Secondary Licenses" means a. that the initial Contributor has attached the notice described in Exhibit B to the Covered Software; or b. that the Covered Software was made available under the terms of version 1.1 or earlier of the License, but not also under the terms of a Secondary License. 1.6. "Executable Form" means any form of the work other than Source Code Form. 1.7. "Larger Work" means a work that combines Covered Software with other material, in a separate file or files, that is not Covered Software. 1.8. "License" means this document. 1.9. "Licensable" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently, any and all of the rights conveyed by this License. 1.10. "Modifications" means any of the following: a. any file in Source Code Form that results from an addition to, deletion from, or modification of the contents of Covered Software; or b. any new file in Source Code Form that contains any Covered Software. 1.11. "Patent Claims" of a Contributor means any patent claim(s), including without limitation, method, process, and apparatus claims, in any patent Licensable by such Contributor that would be infringed, but for the grant of the License, by the making, using, selling, offering for sale, having made, import, or transfer of either its Contributions or its Contributor Version. 1.12. "Secondary License" means either the GNU General Public License, Version 2.0, the GNU Lesser General Public License, Version 2.1, the GNU Affero General Public License, Version 3.0, or any later versions of those licenses. 1.13. "Source Code Form" means the form of the work preferred for making modifications. 1.14. "You" (or "Your") means an individual or a legal entity exercising rights under this License. For legal entities, "You" includes any entity that controls, is controlled by, or is under common control with You. For purposes of this definition, "control" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity. 2. License Grants and Conditions 2.1. Grants Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license: a. under intellectual property rights (other than patent or trademark) Licensable by such Contributor to use, reproduce, make available, modify, display, perform, distribute, and otherwise exploit its Contributions, either on an unmodified basis, with Modifications, or as part of a Larger Work; and b. under Patent Claims of such Contributor to make, use, sell, offer for sale, have made, import, and otherwise transfer either its Contributions or its Contributor Version. 2.2. Effective Date The licenses granted in Section 2.1 with respect to any Contribution become effective for each Contribution on the date the Contributor first distributes such Contribution. 2.3. Limitations on Grant Scope The licenses granted in this Section 2 are the only rights granted under this License. No additional rights or licenses will be implied from the distribution or licensing of Covered Software under this License. Notwithstanding Section 2.1(b) above, no patent license is granted by a Contributor: a. for any code that a Contributor has removed from Covered Software; or b. for infringements caused by: (i) Your and any other third party's modifications of Covered Software, or (ii) the combination of its Contributions with other software (except as part of its Contributor Version); or c. under Patent Claims infringed by Covered Software in the absence of its Contributions. This License does not grant any rights in the trademarks, service marks, or logos of any Contributor (except as may be necessary to comply with the notice requirements in Section 3.4). 2.4. Subsequent Licenses No Contributor makes additional grants as a result of Your choice to distribute the Covered Software under a subsequent version of this License (see Section 10.2) or under the terms of a Secondary License (if permitted under the terms of Section 3.3). 2.5. Representation Each Contributor represents that the Contributor believes its Contributions are its original creation(s) or it has sufficient rights to grant the rights to its Contributions conveyed by this License. 2.6. Fair Use This License is not intended to limit any rights You have under applicable copyright doctrines of fair use, fair dealing, or other equivalents. 2.7. Conditions Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in Section 2.1. 3. Responsibilities 3.1. Distribution of Source Form All distribution of Covered Software in Source Code Form, including any Modifications that You create or to which You contribute, must be under the terms of this License. You must inform recipients that the Source Code Form of the Covered Software is governed by the terms of this License, and how they can obtain a copy of this License. You may not attempt to alter or restrict the recipients' rights in the Source Code Form. 3.2. Distribution of Executable Form If You distribute Covered Software in Executable Form then: a. such Covered Software must also be made available in Source Code Form, as described in Section 3.1, and You must inform recipients of the Executable Form how they can obtain a copy of such Source Code Form by reasonable means in a timely manner, at a charge no more than the cost of distribution to the recipient; and b. You may distribute such Executable Form under the terms of this License, or sublicense it under different terms, provided that the license for the Executable Form does not attempt to limit or alter the recipients' rights in the Source Code Form under this License. 3.3. Distribution of a Larger Work You may create and distribute a Larger Work under terms of Your choice, provided that You also comply with the requirements of this License for the Covered Software. If the Larger Work is a combination of Covered Software with a work governed by one or more Secondary Licenses, and the Covered Software is not Incompatible With Secondary Licenses, this License permits You to additionally distribute such Covered Software under the terms of such Secondary License(s), so that the recipient of the Larger Work may, at their option, further distribute the Covered Software under the terms of either this License or such Secondary License(s). 3.4. Notices You may not remove or alter the substance of any license notices (including copyright notices, patent notices, disclaimers of warranty, or limitations of liability) contained within the Source Code Form of the Covered Software, except that You may alter any license notices to the extent required to remedy known factual inaccuracies. 3.5. Application of Additional Terms You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Software. However, You may do so only on Your own behalf, and not on behalf of any Contributor. You must make it absolutely clear that any such warranty, support, indemnity, or liability obligation is offered by You alone, and You hereby agree to indemnify every Contributor for any liability incurred by such Contributor as a result of warranty, support, indemnity or liability terms You offer. You may include additional disclaimers of warranty and limitations of liability specific to any jurisdiction. 4. Inability to Comply Due to Statute or Regulation If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Software due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be placed in a text file included with all distributions of the Covered Software under this License. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it. 5. Termination 5.1. The rights granted under this License will terminate automatically if You fail to comply with any of its terms. However, if You become compliant, then the rights granted under this License from a particular Contributor are reinstated (a) provisionally, unless and until such Contributor explicitly and finally terminates Your grants, and (b) on an ongoing basis, if such Contributor fails to notify You of the non-compliance by some reasonable means prior to 60 days after You have come back into compliance. Moreover, Your grants from a particular Contributor are reinstated on an ongoing basis if such Contributor notifies You of the non-compliance by some reasonable means, this is the first time You have received notice of non-compliance with this License from such Contributor, and You become compliant prior to 30 days after Your receipt of the notice. 5.2. If You initiate litigation against any entity by asserting a patent infringement claim (excluding declaratory judgment actions, counter-claims, and cross-claims) alleging that a Contributor Version directly or indirectly infringes any patent, then the rights granted to You by any and all Contributors for the Covered Software under Section 2.1 of this License shall terminate. 5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or Your distributors under this License prior to termination shall survive termination. 6. Disclaimer of Warranty Covered Software is provided under this License on an "as is" basis, without warranty of any kind, either expressed, implied, or statutory, including, without limitation, warranties that the Covered Software is free of defects, merchantable, fit for a particular purpose or non-infringing. The entire risk as to the quality and performance of the Covered Software is with You. Should any Covered Software prove defective in any respect, You (not any Contributor) assume the cost of any necessary servicing, repair, or correction. This disclaimer of warranty constitutes an essential part of this License. No use of any Covered Software is authorized under this License except under this disclaimer. 7. Limitation of Liability Under no circumstances and under no legal theory, whether tort (including negligence), contract, or otherwise, shall any Contributor, or anyone who distributes Covered Software as permitted above, be liable to You for any direct, indirect, special, incidental, or consequential damages of any character including, without limitation, damages for lost profits, loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses, even if such party shall have been informed of the possibility of such damages. This limitation of liability shall not apply to liability for death or personal injury resulting from such party's negligence to the extent applicable law prohibits such limitation. Some jurisdictions do not allow the exclusion or limitation of incidental or consequential damages, so this exclusion and limitation may not apply to You. 8. Litigation Any litigation relating to this License may be brought only in the courts of a jurisdiction where the defendant maintains its principal place of business and such litigation shall be governed by laws of that jurisdiction, without reference to its conflict-of-law provisions. Nothing in this Section shall prevent a party's ability to bring cross-claims or counter-claims. 9. Miscellaneous This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not be used to construe this License against a Contributor. 10. Versions of the License 10.1. New Versions Mozilla Foundation is the license steward. Except as provided in Section 10.3, no one other than the license steward has the right to modify or publish new versions of this License. Each version will be given a distinguishing version number. 10.2. Effect of New Versions You may distribute the Covered Software under the terms of the version of the License under which You originally received the Covered Software, or under the terms of any subsequent version published by the license steward. 10.3. Modified Versions If you create software not governed by this License, and you want to create a new license for such software, you may create and use a modified version of this License if you rename the license and remove any references to the name of the license steward (except to note that such modified license differs from this License). 10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses If You choose to distribute Source Code Form that is Incompatible With Secondary Licenses under the terms of this version of the License, the notice described in Exhibit B of this License must be attached. Exhibit A - Source Code Form License Notice This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/. If it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice. You may add additional accurate notices of copyright ownership. Exhibit B - "Incompatible With Secondary Licenses" Notice This Source Code Form is "Incompatible With Secondary Licenses", as defined by the Mozilla Public License, v. 2.0. khiva-python-0.2.2/README.md000066400000000000000000000103251346407502000154150ustar00rootroot00000000000000# Khiva-Python [![License: MPL 2.0](https://img.shields.io/badge/License-MPL%202.0-brightgreen.svg)](https://github.com/shapelets/khiva-python/blob/master/LICENSE.txt) [![Gitter chat](https://badges.gitter.im/shapelets-io/Lobby.svg)](https://gitter.im/shapelets-io/khiva-python?utm_source=share-link&utm_medium=link&utm_campaign=share-link) | Build Documentation | Build Linux and Mac OS | Build Windows | Code Coverage | |:-------------------------------------------------------------------------------------------------------------------------------------------------------------:|:----------------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------------------------------------------------------:| | [![Documentation Status](https://readthedocs.org/projects/khiva-python/badge/?version=latest)](https://khiva-python.readthedocs.io/en/master/?badge=master) | [![Build Status](https://travis-ci.org/shapelets/khiva-python.svg?branch=master)](https://travis-ci.org/shapelets/khiva-python/branches) | [![Build status](https://ci.appveyor.com/api/projects/status/7f4n5n0iydicfd9p/branch/master?svg=true)](https://ci.appveyor.com/project/shapelets/khiva-python/branch/master) |[![Coverage Status](https://codecov.io/gh/shapelets/khiva-python/branch/master/graph/badge.svg)](https://codecov.io/gh/shapelets/khiva-python/branch/master) | # README # This is the Khiva Python binding, it allows the usage of Khiva library from Python. ## License This project is licensed under [MPL-v2](https://www.mozilla.org/en-US/MPL/2.0/). ## Quick Summary This Python binding called 'khiva' provides all the functionalities of the KHIVA library for time series analytics. ## Set up In order to use this binding, you need to install Khiva library. ### Prerequisites - [Python 64-bits](https://www.python.org/downloads/) > Note: By now, only 64-bit Python versions are supported. > Note **Windows' users**: Search your 64-bits version [here](https://www.python.org/downloads/windows/) ### Install latest version Install latest stable version of Khiva library. Follow the steps in the "Installation" section of the [Khiva repository](https://github.com/shapelets/khiva) To install the Khiva Python binding, we just need to execute the following command: ```bash python setup.py install ``` ### Install any release Install the prerequisites listed in the "Installation" section of the [Khiva library repository](https://github.com/shapelets/khiva). Download and install your selected Khiva release from [Khiva repository](https://github.com/shapelets/khiva/releases). Install the Khiva python binding compatible with the Khiva library installed previously. Follow the steps to install the Khiva python binding explained in [pypi](https://pypi.org/project/khiva/). ## Executing the tests: All tests can be executed separately, please find them in /tests/unit_tests. ## Documentation This Khiva Python binding follows the standard way of writing documentation of Python by using Sphinx. In order to generate the documentation (in html format), run the following command under the /docs folder: ```bash make html ``` ## Contributing The rules to contribute to this project are described [here](CONTRIBUTING.md) [![Powered by Shapelets](https://img.shields.io/badge/powered%20by-Shapelets-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](https://shapelets.io) khiva-python-0.2.2/README.rst000066400000000000000000000156061346407502000156340ustar00rootroot00000000000000Khiva ====== This is the Khiva binding for connecting the Python programming language and the Khiva C++ library. License ------- This project is licensed under `MPL-v2 `__. Install Khiva --------------- First of all, the Khiva C++ library should be installed: `Khiva documentation `__. Then, install the compiled Khiva package that is hosted on the Python Package Index (PyPI) with pip: .. code:: shell pip install khiva Dive in ------- Dive quickly into Khiva with the following example: First, set the backend and device you want to use. There is a backend and a device set by default: .. code-block:: python from khiva.library import * set_backend(KHIVABackend.KHIVA_BACKEND_OPENCL) set_device(0) Then, you can create an array in the device: .. code-block:: python from khiva.array import * a = Array([1, 2, 3, 4, 5, 6, 7, 8]) a.display() The previous lines print the dimensions and the content of the created array: +-----------+ | [8 1 1 1] | +===========+ |1.0000 | +-----------+ |2.0000 | +-----------+ |3.0000 | +-----------+ |4.0000 | +-----------+ |5.0000 | +-----------+ |6.0000 | +-----------+ |7.0000 | +-----------+ |8.0000 | +-----------+ Once the array is created in device memory, we can concatenate operations with this array in an asynchronous way and receive the data only in the host when `to_list()`, `to_numpy()` or `to_pandas()` (the latter only supports bi-dimensional time series) functions are called. .. code-block:: python a = a.to_pandas() print(a) The result is the next one: +-+-------+ | | 0 | +=+=======+ |1|1.0 | +-+-------+ |2|2.00 | +-+-------+ |3|3.00 | +-+-------+ |4|4.00 | +-+-------+ |5|5.00 | +-+-------+ |6|6.00 | +-+-------+ |7|7.00 | +-+-------+ |8|8.00 | +-+-------+ Now let's dive into the asynchronous usage of the library. Khiva library provides us several time series analysis functionalities which include features extraction, time-series re-dimension, distance calculations, motifs and discords detection, tools for similarity study, statistical parameters extraction or time series normalization. All these functionalities can be concatenated to improve the performance, so you can get the data just in the moment that you do not use the functions of this library: .. code-block:: python from khiva.matrix import * stomp_result = stomp(Array(np.array([11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11])), Array(np.array([9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 9])), 3) find_best_n_discords_result = find_best_n_discords(stomp_result[0], stomp_result[1], 2) a = find_best_n_discords_result[2].to_numpy() print(a) The previous produces the following output: +-------------------------------------+ | [1.73190141 1.73185158] [8 8] [0 9] | +-------------------------------------+ The first numpy array represents the minimum distances between the subsequences of length 3 between the two time-series. The second numpy array represents the location of those subsequences in the first time-series and the third one represents the indices in the second time-series. We want to highlight the possibility of using the library for computing the functions in different backends and with different devices, knowing that the operations should be executed in the same device where the array was created. .. code-block:: python #Adding operations in the different backends and devices. from khiva.features import * set_backend(KHIVABackend.KHIVA_BACKEND_OPENCL) set_device(0) a = Array([1, 2, 3, 4, 5, 6, 7, 8]) b = mean(a) set_device(1) c = Array([1, 2, 3, 4, 5, 6, 7, 8]) d = mean(c) set_backend(KHIVABackend.KHIVA_BACKEND_CPU) set_device(0) e = Array([1, 2, 3, 4, 5, 6, 7, 8]) f = mean(e) #Retrieving the results of the previous operations set_backend(KHIVABackend.KHIVA_BACKEND_OPENCL) set_device(0) print(b.to_numpy()) set_device(1) print(d.to_numpy()) set_backend(KHIVABackend.KHIVA_BACKEND_CPU) set_device(0) print(f.to_numpy()) The output is the next one: +-----+ | 4.5 | +-----+ | 4.5 | +-----+ | 4.5 | +-----+ Note that the data type used by default is floating point of 32 bits in order to avoid problems with the different devices, but it can be changed deliberately. The available data types are the next ones: +-----------+----------------------+ | Data type | Explanation | +===========+======================+ | f32 | 32 bits Float | +-----------+----------------------+ | c32 | 32 bits Complex | +-----------+----------------------+ | f64 | 64 bits Double | +-----------+----------------------+ | c64 | 64 bits Complex | +-----------+----------------------+ | b8 | 8 bits Boolean | +-----------+----------------------+ | s32 | 32 bits Int | +-----------+----------------------+ | 32u | 32 bits Unsigned Int | +-----------+----------------------+ | u8 | 8 bits Unsigned Int | +-----------+----------------------+ | s64 | 64 bits Int | +-----------+----------------------+ | u64 | 64 bits Unsigned Int | +-----------+----------------------+ | s16 | 16 bits Int | +-----------+----------------------+ | u16 | 16 bits Unsigned Int | +-----------+----------------------+ There are functions that do not support 32 bits floating point data type, so it is necessary to indicate the data type. The following is an example function requiring a 32-bit signed integer array: .. code-block:: python cwt_coefficients_result = cwt_coefficients(Array([[0.1, 0.2, 0.3], [0.1, 0.2, 0.3]]), Array(data=[1, 2, 3], khiva_type=dtype.s32), 2, 2).to_numpy() print(cwt_coefficients_result) The output is: +-------------------------+ | [0.26517162 0.26517162] | +-------------------------+ Limitations ----------- This open-source library provides a very good performance, but it has got memory limitations. For cases where you need to apply a time series analysis over a huge amount of data and in short-term fashion, please, `contact us `__. Let's Rock! ----------- Now, you have the basic concepts to start using the library. Please, follow the documentation of each function to know how to use them. Each function has its corresponding tests so you can check how to use each of them. Furthermore, we provide use cases and examples that you can use to learn where and how to apply the library. Documentation ------------- This Python library follows the standard way of writing documentation of Python by using Sphinx. The documentation is located in: `Khiva Python documentation `__. khiva-python-0.2.2/codecov.yml000066400000000000000000000000501346407502000162750ustar00rootroot00000000000000ignore: - "tests/" - ".*(? Modules FAQ Authors License Changelog How to contribute Indices and tables ================== * :ref:`genindex` * :ref:`modindex` * :ref:`search` khiva-python-0.2.2/docs/khiva.rst000066400000000000000000000033151346407502000167230ustar00rootroot00000000000000khiva =========== Submodules ++++++++++ khiva.array --------------------------------- .. automodule:: khiva.array :members: :undoc-members: :show-inheritance: khiva.dimensionality --------------------------------- .. automodule:: khiva.dimensionality :members: :undoc-members: :show-inheritance: khiva.distances --------------------------------- .. automodule:: khiva.distances :members: :undoc-members: :show-inheritance: khiva.features --------------------------------- .. automodule:: khiva.features :members: :undoc-members: :show-inheritance: khiva.library --------------------------------- .. automodule:: khiva.library :members: :undoc-members: :show-inheritance: khiva.linalg --------------------------------- .. automodule:: khiva.linalg :members: :undoc-members: :show-inheritance: khiva.matrix --------------------------------- .. automodule:: khiva.matrix :members: :undoc-members: :show-inheritance: khiva.normalization --------------------------------- .. automodule:: khiva.normalization :members: :undoc-members: :show-inheritance: khiva.polynomial --------------------------------- .. automodule:: khiva.polynomial :members: :undoc-members: :show-inheritance: khiva.regression --------------------------------- .. automodule:: khiva.regression :members: :undoc-members: :show-inheritance: khiva.regularization --------------------------------- .. automodule:: khiva.regularization :members: :undoc-members: :show-inheritance: khiva.statistics --------------------------------- .. automodule:: khiva.statistics :members: :undoc-members: :show-inheritance: khiva-python-0.2.2/docs/license.rst000066400000000000000000000001121346407502000172330ustar00rootroot00000000000000.. _license: ======= License ======= .. literalinclude:: ../LICENSE.txt khiva-python-0.2.2/docs/modules.rst000066400000000000000000000000641346407502000172670ustar00rootroot00000000000000Khiva ===== .. toctree:: :maxdepth: 4 khiva khiva-python-0.2.2/docs/text/000077500000000000000000000000001346407502000160515ustar00rootroot00000000000000khiva-python-0.2.2/docs/text/faq.rst000066400000000000000000000007141346407502000173540ustar00rootroot00000000000000FAQ === 1. **What are the Khiva Array restrictions?** Khiva Arrays can have up to 4 dimensions, each one needs to have the same length and the same type. 2. **Can I use the Khiva package without having a GPU for computation?** Of course. It is right that Khiva algorithms are designed to run on GPU, but a CPU backend could be set. 3. **What OS are supported?** Nowadays, Khiva is supported on Windows, Linux and MacOS. khiva-python-0.2.2/docs/text/how_to_contribute.rst000066400000000000000000000031661346407502000223460ustar00rootroot00000000000000How to contribute ================= We have just started! Our aim is to make the Khiva library the reference library for time series analysis in the fastest fashion. To achieve this target we need your help! All contributions, bug reports, bug fixes, documentation improvements, enhancements and ideas are welcome. If you want to add one or two interesting feature calculators, implement a new feature selection process or just fix 1-2 typos, your help is appreciated. If you want to help, just create a pull request on our github page. Guidelines '''''''''' Branching model ++++++++++++++++ Our branching model has one permanent branch, **master**. We aim at using `master` as the main branch, where all features are merged. In this sense, we also use the master branch to contain the release versions of the Python Khiva library by means of git tags. Contribution process +++++++++++++++++++++ In order to contribute to the code base, we follow the next process: 1. The main branch is `master`, every developer should pull the current status of the branch before stating to develop any new feature. `git pull` 2. Create a new branch with the following pattern "feature/[name_of_the_feature]" `git checkout -b feature/example_feature` 3. Develop the new feature on the the new branch. It includes testing and documentation. `git commit -a -m "Bla, Bla, Bla"` `git push` 4. Open a Pull Request to merge the feature branch in to `master`. Currently, a pull request has to be reviewed at least by one person. 5. Finally, delete the feature branch. 6. Move back to `master` branch. `git checkout master` 7. Pull the latest changes. `git pull` khiva-python-0.2.2/docs/text/quick_start.rst000066400000000000000000000147251346407502000211450ustar00rootroot00000000000000.. _quick-start-label: Quick Start =========== Install Khiva --------------- First of all, the Khiva C++ library should be installed: `Shapelets `__. Then, install the compiled Khiva package that is hosted on the Python Package Index (PyPI) with pip: .. code:: shell pip install khiva Dive in ------- Dive quickly into Khiva with the following example: First, set the backend and device you want to use. There is a backend and a device set by default: .. code-block:: python from khiva.library import * set_backend(KHIVABackend.KHIVA_BACKEND_OPENCL) set_device(0) Then, you can create an array in the device: .. code-block:: python from khiva.array import * a = Array([1, 2, 3, 4, 5, 6, 7, 8]) a.display() The previous lines print the dimensions and the content of the created array: +-----------+ | [8 1 1 1] | +===========+ |1.0000 | +-----------+ |2.0000 | +-----------+ |3.0000 | +-----------+ |4.0000 | +-----------+ |5.0000 | +-----------+ |6.0000 | +-----------+ |7.0000 | +-----------+ |8.0000 | +-----------+ Once the array is created in device memory, we can concatenate operations with this array in an asynchronous way and receive the data only in the host when `to_list()`, `to_numpy()` or `to_pandas()` (the latter only supports bi-dimensional time series) functions are called. .. code-block:: python a = a.to_pandas() print(a) The result is the next one: +-+-------+ | | 0 | +=+=======+ |1|1.0 | +-+-------+ |2|2.00 | +-+-------+ |3|3.00 | +-+-------+ |4|4.00 | +-+-------+ |5|5.00 | +-+-------+ |6|6.00 | +-+-------+ |7|7.00 | +-+-------+ |8|8.00 | +-+-------+ Now, let's dive into the asynchronous usage of the library. Khiva library provides us several time series analysis functionalities which include features extraction, time-series re-dimension, distance calculations, motifs and discords detection, tools for similarity study, statistical parameters extraction or time series normalization. All these functionalities can be concatenated to improve the performance, so you can get the data just in the moment that you do not use the functions of this library: .. code-block:: python from khiva.matrix import * stomp_result = stomp(Array(np.array([11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11])), Array(np.array([9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 9])), 3) find_best_n_discords_result = find_best_n_discords(stomp_result[0], stomp_result[1], 2) a = find_best_n_discords_result[2].to_numpy() print(a) The previous produces the following output: +-------------------------------------+ | [1.73190141 1.73185158] [8 8] [0 9] | +-------------------------------------+ The first numpy array represents the minimum distances between the subsequences of length 3 between the two time-series. The second numpy array represents the location of those subsequences in the first time-series and the third one represents the indices in the second time-series. We want to highlight the possibility of using the library for computing the functions in different backends and with different devices, knowing that the operations should be executed in the same device where the array was created. .. code-block:: python #Adding operations in the different backends and devices. from khiva.features import * set_backend(KHIVABackend.KHIVA_BACKEND_OPENCL) set_device(0) a = Array([1, 2, 3, 4, 5, 6, 7, 8]) b = mean(a) set_device(1) c = Array([1, 2, 3, 4, 5, 6, 7, 8]) d = mean(c) set_backend(KHIVABackend.KHIVA_BACKEND_CPU) set_device(0) e = Array([1, 2, 3, 4, 5, 6, 7, 8]) f = mean(e) #Retrieving the results of the previous operations set_backend(KHIVABackend.KHIVA_BACKEND_OPENCL) set_device(0) print(b.to_numpy()) set_device(1) print(d.to_numpy()) set_backend(KHIVABackend.KHIVA_BACKEND_CPU) set_device(0) print(f.to_numpy()) The output is the next one: +-----+ | 4.5 | +-----+ | 4.5 | +-----+ | 4.5 | +-----+ Note that the data type used by default is floating point of 32 bits in order to avoid problems with the different devices, but it can be changed deliberately. The available data types are the next ones: +-----------+----------------------+ | Data type | Explanation | +===========+======================+ | f32 | 32 bits Float | +-----------+----------------------+ | c32 | 32 bits Complex | +-----------+----------------------+ | f64 | 64 bits Double | +-----------+----------------------+ | c64 | 64 bits Complex | +-----------+----------------------+ | b8 | 8 bits Boolean | +-----------+----------------------+ | s32 | 32 bits Int | +-----------+----------------------+ | 32u | 32 bits Unsigned Int | +-----------+----------------------+ | u8 | 8 bits Unsigned Int | +-----------+----------------------+ | s64 | 64 bits Int | +-----------+----------------------+ | u64 | 64 bits Unsigned Int | +-----------+----------------------+ | s16 | 16 bits Int | +-----------+----------------------+ | u16 | 16 bits Unsigned Int | +-----------+----------------------+ There are functions that do not support 32 bits floating point data type, so it is necessary to indicate the data type. The following is an example function requiring a 32-bit signed integer array: .. code:: python cwt_coefficients_result = cwt_coefficients(Array([[0.1, 0.2, 0.3], [0.1, 0.2, 0.3]]), Array(data=[1, 2, 3], khiva_type=dtype.s32), 2, 2).to_numpy() print(cwt_coefficients_result) The output is: +-------------------------+ | [0.26517162 0.26517162] | +-------------------------+ Limitations ----------- This open-source library provides a very good performance, but it has got memory limitations. For cases where you need to apply a time series analysis over a huge amount of data and in short-term fashion, please, `contact us `_). Let's Rock! ----------- Now, you have the basic concepts to start using the library. Please, follow the documentation of each function to know how to use them. Each function has its corresponding tests so you can check how to use each of them. Furthermore, we provide use cases and examples that you can use to learn where and how to apply the library. khiva-python-0.2.2/khiva/000077500000000000000000000000001346407502000152375ustar00rootroot00000000000000khiva-python-0.2.2/khiva/__init__.py000066400000000000000000000013051346407502000173470ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. from khiva.array import * from khiva.clustering import * from khiva.dimensionality import * from khiva.distances import * from khiva.features import * from khiva.library import * from khiva.linalg import * from khiva.matrix import * from khiva.normalization import * from khiva.normalization import * from khiva.polynomial import * from khiva.regression import * from khiva.regularization import * from khiva.statistics import * khiva-python-0.2.2/khiva/array.py000066400000000000000000000754011346407502000167360ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import ctypes import logging import sys from collections import deque from enum import Enum import numpy as np import pandas as pd from khiva.library import KhivaLibrary ######################################################################################################################## class dtype(Enum): """ KHIVA array available types. """ f32 = 0 """ Float. khiva.dtype """ c32 = 1 """ 32 bits Complex. khiva.dtype """ f64 = 2 """ 64 bits Double. khiva.dtype """ c64 = 3 """ 64 bits Complex. khiva.dtype """ b8 = 4 """ Boolean. khiva.dtype """ s32 = 5 """ 32 bits Int. khiva.dtype """ u32 = 6 """ 32 bits Unsigned Int. khiva.dtype """ u8 = 7 """ 8 bits Unsigned Int. khiva.dtype """ s64 = 8 """ 64 bits Integer. khiva.dtype """ u64 = 9 """ 64 bits Unsigned Int. khiva.dtype """ s16 = 10 """ 16 bits Int. khiva.dtype """ u16 = 11 """ 16 bits Unsigned int. khiva.dtype """ def _get_array_type(khiva_type): """ Transform the KHIVA type to its equivalent in ctypes. :param khiva_type: KHIVA type. :return: The ctypes equivalent. """ return { dtype.f32.value: ctypes.c_float, dtype.c32.value: ctypes.c_float, dtype.f64.value: ctypes.c_double, dtype.c64.value: ctypes.c_double, dtype.b8.value: ctypes.c_bool, dtype.u8.value: ctypes.c_uint8, dtype.s16.value: ctypes.c_int16, dtype.u16.value: ctypes.c_uint16, dtype.s32.value: ctypes.c_int32, dtype.u32.value: ctypes.c_uint32, dtype.s64.value: ctypes.c_int64, dtype.u64.value: ctypes.c_uint64 }[khiva_type] def _get_numpy_type(khiva_type): """ Transform the KHIVA type to its equivalent in Numpy. :param khiva_type: KHIVA type. :return: The Numpy type equivalent. """ return { dtype.f32.value: np.float, dtype.c32.value: np.complex64, dtype.f64.value: np.double, dtype.c64.value: np.complex128, dtype.b8.value: np.bool, dtype.u8.value: np.uint8, dtype.s16.value: np.int8, dtype.u16.value: np.uint16, dtype.s32.value: np.int16, dtype.u32.value: np.uint32, dtype.s64.value: np.int64, dtype.u64.value: np.uint64, }[khiva_type] class Array: __array_priority__ = 50 def __init__(self, data=None, khiva_type=dtype.f32, array_reference=None, arrayfire_reference=False): """ Creates a KHIVA array in one of the following ways: 1) using a previously created array; or 2) with data (in numpy, list, or pandas dataframe format) :param data: Numpy array, List of elements or a Pandas dataframe. :param khiva_type: KHIVA type. :param array_reference: Reference of the array. """ if array_reference is None: self.khiva_type = khiva_type self.arr_reference = self._create_array(data) self.dims = self.get_dims() self.result_l = self._get_result_length() else: self.arr_reference = array_reference self.khiva_type = self.get_type() self.dims = self.get_dims() self.result_l = self._get_result_length() self.arrayfire_reference = arrayfire_reference @classmethod def from_arrayfire(cls, arrayfire): """ Creates a KHIVA array from an array of ArrayFire. :param arrayfire: An ArrayFire array. :return: a KHIVA array. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.from_arrayfire(ctypes.pointer(arrayfire.arr), ctypes.pointer(result)) arrayfire.arr.value = 0 return cls(array_reference=result, arrayfire_reference=False) def _create_array(self, data): """ Creates the KHIVA array in the device. :param data: The data used for creating the khiva array. :return An opaque pointer to the Array. """ if isinstance(data, list): data = np.asarray(data) if isinstance(data, pd.DataFrame): data = data.values shape = np.array(data.shape) shape = shape[shape > 1] shape = deque(shape) shape.rotate(1) c_array_n = (ctypes.c_longlong * len(shape))(*(np.array(shape)).astype(np.longlong)) c_ndims = ctypes.c_uint(len(shape)) c_complex = np.iscomplexobj(data) if c_complex: data = np.array([data.real, data.imag]) c = deque(range(1, len(data.shape))) c.rotate(1) c.append(0) array_joint = np.transpose(data, c).flatten() else: array_joint = data.flatten() c_array_joint = (_get_array_type(self.khiva_type.value) * len(array_joint))( *array_joint) opaque_pointer = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.create_array(ctypes.pointer(c_array_joint), ctypes.pointer(c_ndims), ctypes.pointer(c_array_n), ctypes.pointer(opaque_pointer), ctypes.pointer(ctypes.c_int(self.khiva_type.value))) return opaque_pointer def _get_data(self): """ Retrieves the data from the device to the host. :return A numpy array with the data. """ initialized_result_array = np.zeros(self.result_l).astype(_get_array_type(self.khiva_type.value)) c_result_array = (_get_array_type(self.khiva_type.value) * self.result_l)(*initialized_result_array) KhivaLibrary().c_khiva_library.get_data(ctypes.pointer(self.arr_reference), ctypes.pointer(c_result_array)) dims = self.get_dims() if dims[dims > 1].size > 0: dims = dims[dims > 1] else: dims = np.array([1]) a = np.array(c_result_array) if self._is_complex(): a = np.array(np.split(a, self.result_l / 2)) a = np.apply_along_axis(lambda args: [complex(*args)], 1, a) a = a.reshape(dims) c = deque(range(len(a.shape))) c.rotate(-1) a = np.transpose(a, c) else: dims = deque(dims) dims.rotate(1) a = a.reshape(dims) a = a.astype(_get_numpy_type(self.khiva_type.value)) return a def _get_result_length(self): """ Gets the length of the result. :return: The length of the result, used in order to get the data to the host. """ result = 1 for value in self.dims: result *= value if self._is_complex(): result *= 2 return int(result) def get_dims(self): """ Gets the dimensions of the KHIVA array. :return: The dimensions of the KHIVA array. """ c_array_n = (ctypes.c_longlong * 4)(*(np.zeros(4)).astype(np.longlong)) KhivaLibrary().c_khiva_library.get_dims(ctypes.pointer(self.arr_reference), ctypes.pointer(c_array_n)) return np.array(c_array_n) def get_type(self): """ Gets the type of the KHIVA array. :return: The type of the KHIVA array. """ c_type = ctypes.c_int() KhivaLibrary().c_khiva_library.get_type(ctypes.pointer(self.arr_reference), ctypes.pointer(c_type)) return dtype(c_type.value) def _is_complex(self): """ Returns True if the array contains complex numbers and False otherwise. :return: True if the array contains complex numbers and False otherwise. """ return self.khiva_type.value == dtype.c32.value or self.khiva_type.value == dtype.c64.value def to_arrayfire(self): """ Creates an Arrayfire array from this KHIVA array. This need to be used carefully as the same array reference is oging to be used by both of them. Once the Arrayfire array is created, the destructor of the KHIVA array is not going to free the allocated array. :return: an Arrayfire Array """ try: import arrayfire as af except ModuleNotFoundError: logging.error("In order to use `to_arrayfire()` function, you need to install the Arrayfire Python library") sys.exit(1) result = af.Array() result.arr = self.arr_reference self.arrayfire_reference = True return result def to_list(self): """ Converts the KHIVA array to a list. :return: KHIVA array converted to list. """ return self._get_data().tolist() def to_numpy(self): """ Converts the KHIVA array to a numpy array. :return: KHIVA array converted to numpy.array. """ return self._get_data() def to_pandas(self): """ Converts the KHIVA array to a pandas data frame. :return: KHIVA array converted to a pandas data frame. """ return pd.DataFrame(data=self._get_data()) def display(self): """ Displays the data stored in the KHIVA array. """ KhivaLibrary().c_khiva_library.display(ctypes.pointer(self.arr_reference)) def join(self, dim, other): """ Joins the first and second KHIVA arrays along the specified dimension. :param dim: The dimension along which the join occurs. :param other: The second input array. :return: KHIVA Array with the result of this operation. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.join(ctypes.pointer(ctypes.c_int(dim)), ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __len__(self): """ Return the length. """ if self._is_complex(): return self.result_l / 2 else: return self.result_l def __del__(self): """ Class destructor. """ if not self.arrayfire_reference: KhivaLibrary().c_khiva_library.delete_array(ctypes.pointer(self.arr_reference)) def __add__(self, other): """ Return self + other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_add(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __iadd__(self, other): """ Perform self += other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_add(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __radd__(self, other): """ Return other + self. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_add(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __sub__(self, other): """ Return self - other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_sub(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __isub__(self, other): """ Perform self -= other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_sub(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __rsub__(self, other): """ Return other - self. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_sub(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __mul__(self, other): """ Return self * other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_mul(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __imul__(self, other): """ Perform self *= other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_mul(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __rmul__(self, other): """ Return other * self. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_mul(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __truediv__(self, other): """ Return self / other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_div(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __itruediv__(self, other): """ Perform self /= other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_div(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __rtruediv__(self, other): """ Return other / self. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_div(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __div__(self, other): """ Return self / other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_div(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __idiv__(self, other): """ Perform other / self. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_div(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __rdiv__(self, other): """ Return other / self. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_div(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __mod__(self, other): """ Return self % other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_mod(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __imod__(self, other): """ Perform self %= other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_mod(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __rmod__(self, other): """ Return other % self. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_mod(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __pow__(self, other): """ Return self ** other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_pow(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __ipow__(self, other): """ Perform self **= other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_pow(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __rpow__(self, other): """ Return other ** self. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_pow(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __lt__(self, other): """ Return self < other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_lt(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __gt__(self, other): """ Return self > other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_gt(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __le__(self, other): """ Return self <= other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_le(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __ge__(self, other): """ Return self >= other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_ge(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __eq__(self, other): """ Return self == other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_eq(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __ne__(self, other): """ Return self != other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_ne(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __and__(self, other): """ Return self & other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_bitand(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __iand__(self, other): """ Perform self &= other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_bitand(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __or__(self, other): """ Return self | other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_bitor(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __ior__(self, other): """ Perform self |= other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_bitor(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __xor__(self, other): """ Return self ^ other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_bitxor(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __ixor__(self, other): """ Perform self ^= other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_bitxor(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def __lshift__(self, other): """ Return self << other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_bitshiftl(ctypes.pointer(self.arr_reference), ctypes.pointer(ctypes.c_int32(other)), ctypes.pointer(result)) return Array(array_reference=result) def __ilshift__(self, other): """ Perform self <<= other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_bitshiftl(ctypes.pointer(self.arr_reference), ctypes.pointer(ctypes.c_int32(other)), ctypes.pointer(result)) return Array(array_reference=result) def __rshift__(self, other): """ Return self >> other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_bitshiftr(ctypes.pointer(self.arr_reference), ctypes.pointer(ctypes.c_int32(other)), ctypes.pointer(result)) return Array(array_reference=result) def __irshift__(self, other): """ Perform self >>= other. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_bitshiftr(ctypes.pointer(self.arr_reference), ctypes.pointer(ctypes.c_int32(other)), ctypes.pointer(result)) return Array(array_reference=result) def __neg__(self): """ Return -self """ return Array(np.zeros(self.get_dims())) - self def __pos__(self): """ Return +self """ return self def __invert__(self): """ Return ~self """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_not(ctypes.pointer(self.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def _get_metadata_str(self, dims=True): return 'khiva.Array()\nType: {}\n{}' \ .format(self.khiva_type, 'Dims: {}'.format(str(self.dims)) if dims else '') def __str__(self): """ Converts the khiva array to string showing its meta data and contents. """ return self._get_metadata_str() def __nonzero__(self): """ Returns if the Array is non-zero. """ ne = self != Array(np.zeros(self.get_dims())) ne_host = ne.to_numpy() return int(np.all(ne_host)) def __repr__(self): """ Displays the meta data of the arrayfire array. """ return self._get_metadata_str() def transpose(self, conjugate=False): """ Transpose the KHIVA Array. :param conjugate: Indicates if the transpose is conjugated or not. :return: The transposed KHIVA Array. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_transpose(ctypes.pointer(self.arr_reference), ctypes.pointer(ctypes.c_bool(conjugate)), ctypes.pointer(result)) return Array(array_reference=result) def get_col(self, index): """ Gets a desired column. :param index: Index of the desired column. :return: The desired column. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_col(ctypes.pointer(self.arr_reference), ctypes.pointer(ctypes.c_int32(index)), ctypes.pointer(result)) return Array(array_reference=result) def get_cols(self, first, last): """ Gets a sequence of columns using the first column index and the last column index, both columns included. :param first: First column of the subsequence of columns. :param last: Last column of the subsequence of columns. :return: A subsequence of columns between 'first' and 'last'. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_cols(ctypes.pointer(self.arr_reference), ctypes.pointer(ctypes.c_int32(first)), ctypes.pointer(ctypes.c_int32(last)), ctypes.pointer(result)) return Array(array_reference=result) def get_row(self, index): """ Gets a desired row. :param index: Index of the desired row. :return: The desired row. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_row(ctypes.pointer(self.arr_reference), ctypes.pointer(ctypes.c_int32(index)), ctypes.pointer(result)) return Array(array_reference=result) def get_rows(self, first, last): """ Gets a sequence of rows using the first row index and the last row index, both rows included. :param first: First row of the subsequence of rows. :param last: Last row of the subsequence of rows. :return: A subsequence of rows between 'first' and 'last'. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_rows(ctypes.pointer(self.arr_reference), ctypes.pointer(ctypes.c_int32(first)), ctypes.pointer(ctypes.c_int32(last)), ctypes.pointer(result)) return Array(array_reference=result) def matmul(self, other): """ Matrix multiplication. :param other: KHIVA Array :return: The matrix multiplication between these two KHIVA Arrays. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_matmul(ctypes.pointer(self.arr_reference), ctypes.pointer(other.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def copy(self): """ Performs a deep copy of the array. return: An identical copy of self. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.copy(ctypes.pointer(self.arr_reference), ctypes.pointer(result)) return Array(array_reference=result) def as_type(self, dtype): """ Converts the array to a desired array with a desired type. :param dtype: The desired KHIVA data type. :return: An array with the desired data type. """ result = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.khiva_as(ctypes.pointer(self.arr_reference), ctypes.pointer(ctypes.c_int32(dtype.value)), ctypes.pointer(result)) self.khiva_type = self.get_type() return Array(array_reference=result) khiva-python-0.2.2/khiva/clustering.py000066400000000000000000000067701346407502000200020ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import ctypes from khiva.library import KhivaLibrary from khiva.array import Array ######################################################################################################################## def k_means(tss, k, tolerance=1e-10, max_iterations=100): """ Calculates the K-Means algorithm. [1] S. Lloyd. 1982. Least squares quantization in PCM. IEEE Transactions on Information Theory, 28, 2, Pages 129-137. :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :param k: The number of means to be computed. :param tolerance: The error tolerance to stop the computation of the centroids. :param max_iterations: The maximum number of iterations allowed. :return: Tuple with an array of centroids and array of labels. """ centroids = ctypes.c_void_p(0) labels = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.k_means(ctypes.pointer(tss.arr_reference), ctypes.pointer(ctypes.c_int(k)), ctypes.pointer(centroids), ctypes.pointer(labels), ctypes.pointer(ctypes.c_float(tolerance)), ctypes.pointer(ctypes.c_int(max_iterations)) ) return Array(array_reference=centroids), Array(array_reference=labels) def k_shape(tss, k, tolerance=1e-10, max_iterations=100): """ Calculates the K-Shape algorithm. [1] John Paparrizos and Luis Gravano. 2016. k-Shape: Efficient and Accurate Clustering of Time Series. SIGMOD Rec. 45, 1 (June 2016), 69-76. :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :param k: The number of means to be computed. :param tolerance: The error tolerance to stop the computation of the centroids. :param max_iterations: The maximum number of iterations allowed. :return: Tuple with an array of centroids and array of labels. """ centroids = ctypes.c_void_p(0) labels = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.k_shape(ctypes.pointer(tss.arr_reference), ctypes.pointer(ctypes.c_int(k)), ctypes.pointer(centroids), ctypes.pointer(labels), ctypes.pointer(ctypes.c_float(tolerance)), ctypes.pointer(ctypes.c_int(max_iterations)) ) return Array(array_reference=centroids), Array(array_reference=labels) khiva-python-0.2.2/khiva/dimensionality.py000066400000000000000000000203661346407502000206500ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import ctypes from khiva.library import KhivaLibrary from khiva.array import Array ######################################################################################################################## def paa(a, bins): """ Piecewise Aggregate Approximation (PAA) approximates a time series :math:`X` of length :math:`n` into vector :math:`\\bar{X}=(\\bar{x}_{1},…,\\bar{x}_{M})` of any arbitrary length :math:`M \\leq n` where each of :math:`\\bar{x_{i}}` is calculated as follows: .. math:: \\bar{x}_{i} = \\frac{M}{n} \\sum_{j=n/M(i-1)+1}^{(n/M)i} x_{j}. Which simply means that in order to reduce the dimensionality from :math:`n` to :math:`M`, we first divide the original time series into :math:`M` equally sized frames and secondly compute the mean values for each frame. The sequence assembled from the mean values is the PAA approximation (i.e., transform) of the original time series. :param a: Set of points. :param bins: Sets the total number of divisions. :return: KHIVA array of points with the reduced dimensionality. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.paa(ctypes.pointer(a.arr_reference), ctypes.pointer(ctypes.c_int(bins)), ctypes.pointer(b)) return Array(array_reference=b) def pip(a, number_ips): """ Calculates the number of Perceptually Important Points (PIP) in the time series. [1] Fu TC, Chung FL, Luk R, and Ng CM. Representing financial time series based on data point importance. Engineering Applications of Artificial Intelligence, 21(2):277-300, 2008. :param a: KHIVA array whose dimension zero is the length of the time series. :param number_ips: The number of points to be returned. :return: KHIVA array with the most Perceptually Important number_ips. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.pip(ctypes.pointer(a.arr_reference), ctypes.pointer(ctypes.c_int(number_ips)), ctypes.pointer(b)) return Array(array_reference=b) def pla_bottom_up(ts, max_error): """ Applies the Piecewise Linear Approximation (PLA BottomUP) to the time series. [1] Zhu Y, Wu D, Li Sh (2007). A Piecewise Linear Representation Method of Time Series Based on Feature Points. Knowledge-Based Intelligent Information and Engineering Systems 4693:1066-1072. :param ts: Expects a khiva array containing the set of points to be reduced. The first component of the points in the first column and the second component of the points in the second column. :param max_error: The maximum approximation error allowed. :return: The reduced number of points. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.pla_bottom_up(ctypes.pointer(ts.arr_reference), ctypes.pointer(ctypes.c_float(max_error)), ctypes.pointer(b)) return Array(array_reference=b) def pla_sliding_window(ts, max_error): """ Applies the Piecewise Linear Approximation (PLA Sliding Window) to the time series. [1] Zhu Y, Wu D, Li Sh (2007). A Piecewise Linear Representation Method of Time Series Based on Feature Points. Knowledge-Based Intelligent Information and Engineering Systems 4693:1066-1072. :param ts: Expects a khiva array containing the set of points to be reduced. The first component of the points in the first column and the second component of the points in the second column. :param max_error: The maximum approximation error allowed. :return: The reduced number of points. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.pla_sliding_window(ctypes.pointer(ts.arr_reference), ctypes.pointer(ctypes.c_float(max_error)), ctypes.pointer(b)) return Array(array_reference=b) def ramer_douglas_peucker(a, epsilon): """ The Ramer–Douglas–Peucker algorithm (RDP) is an algorithm for reducing the number of points in a curve that is approximated by a series of points. It reduces a set of points depending on the perpendicular distance of the points and epsilon, the greater epsilon, more points are deleted. [1] Urs Ramer, "An iterative procedure for the polygonal approximation of plane curves", Computer Graphics and Image Processing, 1(3), 244–256 (1972) doi:10.1016/S0146-664X(72)80017-0. [2] David Douglas & Thomas Peucker, "Algorithms for the reduction of the number of points required to represent a digitized line or its caricature", The Canadian Cartographer 10(2), 112–122 (1973) doi:10.3138/FM57-6770-U75U-7727 :param a: KHIVA array with the x-coordinates and y-coordinates of the input points (x in column 0 and y in column 1). :param epsilon: It acts as the threshold value to decide which points should be considered meaningful or not. :return: KHIVA array with the x-coordinates and y-coordinates of the selected points (x in column 0 and y in column 1). """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.ramer_douglas_peucker(ctypes.pointer(a.arr_reference), ctypes.pointer(ctypes.c_double(epsilon)), ctypes.pointer(b)) return Array(array_reference=b) def sax(a, alphabet_size): """ Symbolic Aggregate approXimation (SAX). It transforms a numeric time series into a time series of symbols with the same size. The algorithm was proposed by Lin et al.) and extends the PAA-based approach inheriting the original algorithm simplicity and low computational complexity while providing satisfactory sensitivity and selectivity in range query processing. Moreover, the use of a symbolic representation opened a door to the existing wealth of data-structures and string-manipulation algorithms in computer science such as hashing, regular expression, pattern matching, suffix trees, and grammatical inference. [1] Lin, J., Keogh, E., Lonardi, S. & Chiu, B. (2003) A Symbolic Representation of Time Series, with Implications for Streaming Algorithms. In proceedings of the 8th ACM SIGMOD Workshop on Research Issues in Data Mining and Knowledge Discovery. San Diego, CA. June 13. :param a: KHIVA array with the input time series. :param alphabet_size: Number of element within the alphabet. :return: KHIVA array of points with the reduced dimensionality. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.sax(ctypes.pointer(a.arr_reference), ctypes.pointer(ctypes.c_int(alphabet_size)), ctypes.pointer(b)) return Array(array_reference=b) def visvalingam(a, num_points): """ Reduces a set of points by applying the Visvalingam method (minimun triangle area) until the number of points is reduced to numPoints. [1] M. Visvalingam and J. D. Whyatt, Line generalisation by repeated elimination of points, The Cartographic Journal, 1993. :param a: KHIVA array with the x-coordinates and y-coordinates of the input points (x in column 0 and y in column 1). :param num_points: Sets the number of points returned after the execution of the method. :return: KHIVA array with the x-coordinates and y-coordinates of the selected points (x in column 0 and y in column 1). """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.visvalingam(ctypes.pointer(a.arr_reference), ctypes.pointer(ctypes.c_int(num_points)), ctypes.pointer(b)) return Array(array_reference=b) khiva-python-0.2.2/khiva/distances.py000066400000000000000000000117741346407502000176000ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import ctypes from khiva.library import KhivaLibrary from khiva.array import Array ######################################################################################################################## def euclidean(tss): """ Calculates euclidean distances between time series. :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :return: Array with an upper triangular matrix where each position corresponds to the distance between two time series. Diagonal elements will be zero. For example: Position row 0 column 1 records the distance between time series 0 and time series 1. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.euclidean(ctypes.pointer(tss.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def dtw(tss): """ Calculates the Dynamic Time Warping Distance. :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :return: Array with an upper triangular matrix where each position corresponds to the distance between two time series. Diagonal elements will be zero. For example: Position row 0 column 1 records the distance between time series 0 and time series 1. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.dtw(ctypes.pointer(tss.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def hamming(tss): """ Calculates Hamming distances between time series. :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :return: Array with an upper triangular matrix where each position corresponds to the distance between two time series. Diagonal elements will be zero. For example: Position row 0 column 1 records the distance between time series 0 and time series 1. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.hamming(ctypes.pointer(tss.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def manhattan(tss): """ Calculates Manhattan distances between time series. :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :return: Array with an upper triangular matrix where each position corresponds to the distance between two time series. Diagonal elements will be zero. For example: Position row 0 column 1 records the distance between time series 0 and time series 1. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.manhattan(ctypes.pointer(tss.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def sbd(tss): """ Calculates the Shape-Based distance (SBD). It computes the normalized cross-correlation and it returns the value that maximizes the correlation value between time series. :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :return: Array with an upper triangular matrix where each position corresponds to the distance between two time series. Diagonal elements will be zero. For example: Position row 0 column 1 records the distance between time series 0 and time series 1. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.sbd(ctypes.pointer(tss.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def squared_euclidean(tss): """ Calculates the non squared version of the euclidean distance. :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :return: Array with an upper triangular matrix where each position corresponds to the distance between two time series. Diagonal elements will be zero. For example: Position row 0 column 1 records the distance between time series 0 and time series 1. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.squared_euclidean(ctypes.pointer(tss.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) khiva-python-0.2.2/khiva/features.py000066400000000000000000001367211346407502000174410ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import ctypes from khiva.library import KhivaLibrary from khiva.array import Array ######################################################################################################################## def abs_energy(arr): """ Calculates the sum over the square values of the time series. :param arr: KHIVA array with the time series. :type arr: khiva.array :return: KHIVA array with the absEnergy. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.abs_energy(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def absolute_sum_of_changes(arr): """ Calculates the value of an aggregation function f_agg (e.g. var or mean) of the autocorrelation (Compare to http://en.wikipedia.org/wiki/Autocorrelation#Estimation), taken over different all possible lags (1 to length of x) :param arr: KHIVA array with the time series. :type arr: khiva.array :return: KHIVA array with the absolute sum of changes. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.absolute_sum_of_changes(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def aggregated_autocorrelation(arr, aggregation_function): """ Calculates a linear least-squares regression for values of the time series that were aggregated over chunks versus the sequence from 0 up to the number of chunks minus one. :param arr: A KHIVA array with the time series. :param aggregation_function: Function to be used in the aggregation. It receives an integer which indicates the function to be applied. 0 : mean, 1 : median 2 : min, 3 : max, 4 : stdev, 5 : var, default : mean :return: KHIVA array that contains the aggregated correlation for each time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.aggregated_autocorrelation(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_int(aggregation_function)), ctypes.pointer(b)) return Array(array_reference=b) def aggregated_linear_trend(arr, chunk_size, aggregation_function): """ Calculates a linear least-squares regression for values of the time series that were aggregated over chunks versus the sequence from 0 up to the number of chunks minus one. :param arr: A KHIVA array with the time series. :param chunk_size: The chunk size used to aggregate the data. :param aggregation_function: Function to be used in the aggregation. It receives an integer which indicates the function to be applied: 0 : mean, 1 : median 2 : min, 3 : max, 4 : stdev, default : mean :return: ( pvalue: KHIVA array with the pvalues for all time series. rvalue: KHIVA array with the rvalues for all time series. intercept: KHIVA array with the intercept values for all time series. slope: KHIVA array with the slope for all time series. stdrr: KHIVA array with the stderr values for all time series. ) """ b = ctypes.c_void_p(0) c = ctypes.c_void_p(0) d = ctypes.c_void_p(0) e = ctypes.c_void_p(0) f = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.aggregated_linear_trend(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_long(chunk_size)), ctypes.pointer(ctypes.c_int(aggregation_function)), ctypes.pointer(b), ctypes.pointer(c), ctypes.pointer(d), ctypes.pointer(e), ctypes.pointer(f)) return Array(array_reference=b), Array(array_reference=c, khiva_type=arr.khiva_type), Array( array_reference=d), Array(array_reference=e), Array( array_reference=f) def approximate_entropy(arr, m, r): """ Calculates a vectorized Approximate entropy algorithm. https://en.wikipedia.org/wiki/Approximate_entropy For short time-series this method is highly dependent on the parameters, but should be stable for N > 2000, see: Yentes et al. (2012) - The Appropriate Use of Approximate Entropy and Sample Entropy with Short Data Sets Other shortcomings and alternatives discussed in: Richman & Moorman (2000) - Physiological time-series analysis using approximate entropy and sample entropy :param arr: A KHIVA array with the time series. :param m: Length of compared run of data. :param r: Filtering level, must be positive. :return: KHIVA array with the vectorized approximate entropy for all the input time series in tss. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.approximate_entropy(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_int(m)), ctypes.pointer(ctypes.c_float(r)), ctypes.pointer(b)) return Array(array_reference=b) def cross_covariance(xss, yss, unbiased): """ Calculates the cross-covariance of the given time series. :param xss: A KHIVA array with time series. :param yss: A KHIVA Array with time series. :param unbiased: Determines whether it divides by n - lag (if true) or n (if false). :return: KHIVA array with the cross-covariance value for the given time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.cross_covariance(ctypes.pointer(xss.arr_reference), ctypes.pointer(yss.arr_reference), ctypes.pointer(ctypes.c_bool(unbiased)), ctypes.pointer(b)) return Array(array_reference=b) def auto_covariance(arr, unbiased=False): """ Calculates the auto-covariance the given time series. :param arr: KHIVA array with the time series. :param unbiased: Determines whether it divides by n - lag (if true) or n (if false). :return: KHIVA array with the auto-covariance value for the given time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.auto_covariance(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_bool(unbiased)), ctypes.pointer(b)) return Array(array_reference=b) def cross_correlation(xss, yss, unbiased): """ Calculates the cross-correlation of the given time series. :param xss: KHIVA array with the time series. :param yss: KHIVA array with the time series. :param unbiased: Determines whether it divides by n - lag (if true) or n (if false). :return: KHIVA array with cross-correlation value for the given time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.cross_correlation(ctypes.pointer(xss.arr_reference), ctypes.pointer(yss.arr_reference), ctypes.pointer(ctypes.c_bool(unbiased)), ctypes.pointer(b)) return Array(array_reference=b) def auto_correlation(arr, max_lag, unbiased): """ Calculates the autocorrelation of the specified lag for the given time series. :param arr: KHIVA array with the time series. :param max_lag: The maximum lag to compute. :param unbiased: Determines whether it divides by n - lag (if true) or n (if false). :return: KHIVA array with the autocorrelation value for the given time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.auto_correlation(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_long(max_lag)), ctypes.pointer(ctypes.c_bool(unbiased)), ctypes.pointer(b)) return Array(array_reference=b) def binned_entropy(arr, max_bins): """ Calculates the binned entropy for the given time series and number of bins. :param arr: KHIVA array with the time series. :param max_bins: The number of bins. :return: KHIVA array with the binned entropy value for the given time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.binned_entropy(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_int(max_bins)), ctypes.pointer(b)) return Array(array_reference=b) def c3(arr, lag): """ Calculates the Schreiber, T. and Schmitz, A. (1997) measure of non-linearity for the given time series :param arr: KHIVA array with the time series. :param lag: The lag. :return: KHIVA array with non-linearity value for the given time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.c3(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_long(lag)), ctypes.pointer(b)) return Array(array_reference=b) def cid_ce(arr, z_normalize): """ Calculates an estimate for the time series complexity defined by Batista, Gustavo EAPA, et al (2014). (A more complex time series has more peaks, valleys, etc.) :param arr: KHIVA array with the time series. :param z_normalize: Controls wheter the time series should be z-normalized or not. :return: KHIVA array with the complexity value for the given time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.cid_ce(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_bool(z_normalize)), ctypes.pointer(b)) return Array(array_reference=b) def count_above_mean(arr): """ Calculates the number of values in the time series that are higher than the mean. :param arr: KHIVA array with the time series. :return: KHIVA array with the number of values in the time series that are higher than the mean. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.count_above_mean(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def count_below_mean(arr): """ Calculates the number of values in the time series that are lower than the mean. :param arr: KHIVA array with the time series. :return: KHIVA Array with the number of values in the time series that are lower than the mean. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.count_below_mean(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def cwt_coefficients(tss, widths, coeff, w): """ Calculates a Continuous wavelet transform for the Ricker wavelet, also known as the "Mexican hat wavelet". :param tss: KHIVA array with the time series. :param widths: Widths. It accepts a list of lists or a numpy array with one or several widths. :param coeff: Coefficient of interest. :param w: Width of interest. :return: KHIVA Array with the result of calculated coefficients. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.cwt_coefficients(ctypes.pointer(tss.arr_reference), ctypes.pointer(widths.arr_reference), ctypes.pointer(ctypes.c_int(coeff)), ctypes.pointer(ctypes.c_int(w)), ctypes.pointer(b)) return Array(array_reference=b) def energy_ratio_by_chunks(arr, num_segments, segment_focus): """ Calculates the sum of squares of chunk i out of N chunks expressed as a ratio with the sum of squares over the whole series. segmentFocus should be lower than the number of segments. :param arr: KHIVA array with the time series. :param num_segments: The number of segments to divide the series into. :param segment_focus: The segment number (starting at zero) to return a feature on. :return: KHIVA array with the energy ratio by chunk of the time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.energy_ratio_by_chunks(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_long(num_segments)), ctypes.pointer(ctypes.c_long(segment_focus)), ctypes.pointer(b)) return Array(array_reference=b) def fft_aggregated(arr): """ Calculates the spectral centroid(mean), variance, skew, and kurtosis of the absolute fourier transform spectrum. :param arr: KHIVA array with the time series. :return: KHIVA array with the spectral centroid (mean), variance, skew, and kurtosis of the absolute fourier transform spectrum. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.fft_aggregated(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def fft_coefficient(arr, coefficient): """ Calculates the fourier coefficients of the one-dimensional discrete Fourier Transform for real input by fast fourier transformation algorithm. :param arr: KHIVA array with the time series. :param coefficient: The coefficient to extract from the FFT. :return: Tuple with: real: KHIVA array with the real part of the coefficient. imag: KHIVA array with the imaginary part of the coefficient. abs: KHIVA array with the absolute value of the coefficient. angle: KHIVA array with the angle of the coefficient. """ b = ctypes.c_void_p(0) c = ctypes.c_void_p(0) d = ctypes.c_void_p(0) e = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.fft_coefficient(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_long(coefficient)), ctypes.pointer(b), ctypes.pointer(c), ctypes.pointer(d), ctypes.pointer(e) ) return Array(array_reference=b), Array(array_reference=c, khiva_type=arr.khiva_type), Array( array_reference=d), Array(array_reference=e) def first_location_of_maximum(arr): """ Calculates the first relative location of the maximal value for each time series. :param arr: KHIVA array with the time series. :return: KHIVA array with the first relative location of the maximum value to the length of the time series, for each time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.first_location_of_maximum(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def first_location_of_minimum(arr): """ Calculates the first location of the minimal value of each time series. The position is calculated relatively to the length of the series. :param arr: KHIVA array with the time series. :return: KHIVA array with the first relative location of the minimal value of each series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.first_location_of_minimum(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def friedrich_coefficients(arr, m, r): """ Coefficients of polynomial :math:`h(x)`, which has been fitted to the deterministic dynamics of Langevin model: Largest fixed point of dynamics :math:`argmax_x {h(x)=0}` estimated from polynomial :math:`h(x)`, which has been fitted to the deterministic dynamics of Langevin model: .. math:: \\dot(x)(t) = h(x(t)) + R \\mathcal(N)(0,1) as described by [1]. For short time series this method is highly dependent on the parameters. [1] Friedrich et al. (2000): Physics Letters A 271, p. 217-222 Extracting model equations from experimental data. :param arr: KHIVA array with the time series. :param m: Order of polynom to fit for estimating fixed points of dynamics. :param r: Number of quantiles to use for averaging. :return: KHIVA array with the coefficients for each time seriess. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.friedrich_coefficients(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_int(m)), ctypes.pointer(ctypes.c_float(r)), ctypes.pointer(b)) return Array(array_reference=b) def has_duplicates(arr): """ Calculates if the input time series contain duplicated elements. :param arr: KHIVA array with the time series. :return: KHIVA array containing True if the time series contains duplicated elements and false otherwise. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.has_duplicates(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def has_duplicate_max(arr): """ Calculates if the maximum within input time series is duplicated. :param arr: KHIVA array with the time series. :return: KHIVA array containing True if the maximum value of the time series is duplicated and false otherwise. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.has_duplicate_max(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def has_duplicate_min(arr): """ Calculates if the minimum of the input time series is duplicated. :param arr: KHIVA array with the time series. :return: KHIVA array containing True if the minimum of the time series is duplicated and False otherwise. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.has_duplicate_min(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def index_mass_quantile(arr, q): """ Calculates the index of the mass quantile. :param arr: KHIVA array with the time series. :param q: The quantile. :return: KHIVA array with the index of the mass quantile q. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.index_mass_quantile(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_float(q)), ctypes.pointer(b)) return Array(array_reference=b) def kurtosis(arr): """ Returns the kurtosis of tss (calculated with the adjusted Fisher-Pearson standardized moment coefficient G2). :param arr: KHIVA array with the time series. :return: KHIVA array with the kurtosis of each time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.kurtosis(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def large_standard_deviation(arr, r): """ Checks if the time series within tss have a large standard deviation. :param arr: KHIVA array with the time series. :param r: The threshold. :return: KHIVA array containing True for those time series in tss that have a large standard deviation. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.large_standard_deviation(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_float(r)), ctypes.pointer(b)) return Array(array_reference=b) def last_location_of_maximum(arr): """ Calculates the last location of the maximum value of each time series. The position is calculated relatively to the length of the series. :param arr: KHIVA array with the time series. :return: KHIVA array with the last relative location of the maximum value of each series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.last_location_of_maximum(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def last_location_of_minimum(arr): """ Calculates the last location of the minimum value of each time series. The position is calculated relatively to the length of the series. :param arr: KHIVA array with the time series. :return: KHIVA array the last relative location of the minimum value of each series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.last_location_of_minimum(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def length(arr): """ Returns the length of the input time series. :param arr: KHIVA array with the time series. :return: KHIVA array the length of tss. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.length(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def linear_trend(arr): """ Calculate a linear least-squares regression for the values of the time series versus the sequence from 0 to length of the time series minus one. :param arr: KHIVA array with the time series. :return a tuple with: pvalue: KHIVA array the pvalues for all time series. rvalue: KHIVA array The rvalues for all time series. intercept: KHIVA array the intercept values for all time series. slope: KHIVA array the slope for all time series. stdrr: KHIVA array the stderr values for all time series. """ b = ctypes.c_void_p(0) c = ctypes.c_void_p(0) d = ctypes.c_void_p(0) e = ctypes.c_void_p(0) f = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.linear_trend(ctypes.pointer(arr.arr_reference), ctypes.pointer(b), ctypes.pointer(c), ctypes.pointer(d), ctypes.pointer(e), ctypes.pointer(f) ) return Array(array_reference=b), \ Array(array_reference=c), \ Array(array_reference=d), \ Array(array_reference=e), \ Array(array_reference=f) def local_maximals(arr): """ Calculates all Local Maximals fot the time series in array. :param arr: KHIVA array with the time series. :return: KHIVA array with the calculated local maximals for each time series in arr. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.local_maximals(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def longest_strike_above_mean(arr): """ Calculates the length of the longest consecutive subsequence in tss that is bigger than the mean of tss. :param arr: KHIVA array with the time series. :return: KHIVA array with the length of the longest consecutive subsequence in the input time series that is bigger than the mean. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.longest_strike_above_mean(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def longest_strike_below_mean(arr): """ Calculates the length of the longest consecutive subsequence in tss that is below the mean of tss. :param arr: KHIVA array with the time series. :return: KHIVA array with the length of the longest consecutive subsequence in the input time series that is below the mean. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.longest_strike_below_mean(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def max_langevin_fixed_point(arr, m, r): """ Largest fixed point of dynamics :math:`argmax_x {h(x)=0}` estimated from polynomial :math:`h(x)`, which has been fitted to the deterministic dynamics of Langevin model .. math:: \\dot(x)(t) = h(x(t)) + R \\mathcal(N)(0,1) as described by Friedrich et al. (2000): Physics Letters A 271, p. 217-222 *Extracting model equations from experimental data* :param arr: KHIVA array with the time series. :param m: Order of polynom to fit for estimating fixed points of dynamics. :param r: Number of quantiles to use for averaging. :return: KHIVA array with the largest fixed point of deterministic dynamics. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.max_langevin_fixed_point(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_int(m)), ctypes.pointer(ctypes.c_float(r)), ctypes.pointer(b)) return Array(array_reference=b) def maximum(arr): """ Calculates the maximum value for each time series within tss. :param arr: KHIVA array with the time series. :return: KHIVA array with the maximum value of each time series within tss. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.maximum(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def mean(arr): """ Calculates the mean value for each time series within tss. :param arr: KHIVA array with the time series. :return: KHIVA array with the mean value of each time series within tss. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.mean(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def mean_absolute_change(arr): """ Calculates the mean over the absolute differences between subsequent time series values in tss. :param arr: KHIVA array with the time series. :return: KHIVA array with the mean over the absolute differences between subsequent time series values. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.mean_absolute_change(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def mean_change(arr): """ Calculates the mean over the differences between subsequent time series values in tss. :param arr: KHIVA array with the time series. :return: KHIVA array with the mean over the differences between subsequent time series values. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.mean_change(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def mean_second_derivative_central(arr): """ Calculates mean value of a central approximation of the second derivative for each time series in tss. :param arr: KHIVA array with the time series. :return: KHIVA array with the mean value of a central approximation of the second derivative for each time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.mean_second_derivative_central(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def median(arr): """ Calculates the median value for each time series within tss. :param arr: KHIVA array with the time series. :return: KHIVA array with the median value of each time series within tss. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.median(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def minimum(arr): """ Calculates the minimum value for each time series within tss. :param arr: KHIVA array with the time series. :return: KHIVA array with the minimum value of each time series within tss. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.minimum(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def number_crossing_m(arr, m): """ Calculates the number of m-crossings. A m-crossing is defined as two sequential values where the first value is lower than m and the next is greater, or viceversa. If you set m to zero, you will get the number of zero crossings. :param arr: KHIVA array with the time series. :param m: The m value. :return: KHIVA array with the number of m-crossings of each time series within tss. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.number_crossing_m(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_int(m)), ctypes.pointer(b)) return Array(array_reference=b) def number_cwt_peaks(arr, max_w): """ This feature calculator searches for different peaks. To do so, the time series is smoothed by a ricker wavelet and for widths ranging from 1 to :math:'max_w`. This feature calculator returns the number of peaks that occur at enough width scales and with sufficiently high Signal-to-Noise-Ratio (SNR). :param arr: KHIVA array with the time series. :param max_w: The maximum width to consider. :return: KHIVA array with the number of peaks for each time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.number_cwt_peaks(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_int(max_w)), ctypes.pointer(b)) return Array(array_reference=b) def number_peaks(arr, n): """ Calculates the number of peaks of at least support :math:`n` in the time series :math:`tss`. A peak of support :math:`n` is defined as a subsequence of :math:`tss where a value occurs, which is bigger than its :math:`n` neighbours to the left and to the right. :param arr: KHIVA array with the time series. :param n: The support of the peak. :return: KHIVA array with the number of peaks of at least support :math:`n`. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.number_peaks(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_int(n)), ctypes.pointer(b)) return Array(array_reference=b) def partial_autocorrelation(arr, lags): """ Calculates the value of the partial autocorrelation function at the given lag. The lag :math:`k'` partial autocorrelation of a time series :math:`\\lbrace x_t, t = 1 \\ldots T \\rbrace` equals the partial correlation of :math:`x_t` and :math:`x_{t-k}`, adjusted for the intermediate variables :math:`\\lbrace x_{t-1}, \\ldots, x_{t-k+1}\\rbrace` ([1]). Following [2], it can be defined as: .. math:: \\alpha_k = \\frac{ Cov(x_t, x_{t-k} | x_{t-1}, \\ldots, x_{t-k+1})} {\\sqrt{ Var(x_t | x_{t-1}, \\ldots, x_{t-k+1}) Var(x_{t-k} | x_{t-1}, \\ldots, x_{t-k+1} )}} with (a) :math:`x_t = f(x_{t-1}, \\ldots, x_{t-k+1})` and (b) :math:`x_{t-k} = f(x_{t-1}, \\ldots, x_{t-k+1})` being AR(k-1) models that can be fitted by OLS. Be aware that in (a), the regression is done on past values to predict :math:`x_t` whereas in (b), future values are used to calculate the past value :math:`x_{t-k}`. It is said in [1] that "for an AR(p), the partial autocorrelations :math:`\\alpha_k` will be nonzero for :math:`k<=p` and zero for :math:`k>p`." With this property, it is used to determine the lag of an AR-Process. [1] Box, G. E., Jenkins, G. M., Reinsel, G. C., & Ljung, G. M. (2015). Time series analysis: forecasting and control. John Wiley & Sons. [2] https://onlinecourses.science.psu.edu/stat510/node/62 :param arr: KHIVA array with the time series. :param lags: KHIVA array with the lags to be calculated. :return: KHIVA array with the partial autocorrelation for each time series for the given lag. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.partial_autocorrelation(ctypes.pointer(arr.arr_reference), ctypes.pointer(lags.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def percentage_of_reoccurring_datapoints_to_all_datapoints(arr, is_sorted): """ Calculates the percentage of unique values, that are present in the time series more than once. .. math:: len(different values occurring more than once) / len(different values) This means the percentage is normalized to the number of unique values, in contrast to the percentage_of_reoccurring_values_to_all_values. :param arr: KHIVA array with the time series. :param is_sorted: Indicates if the input time series is sorted or not. Defaults to false. :return: KHIVA array with the percentage of unique values, that are present in the time series more than once. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.percentage_of_reoccurring_datapoints_to_all_datapoints( ctypes.pointer(arr.arr_reference), ctypes.pointer( ctypes.c_bool(is_sorted)), ctypes.pointer( b)) return Array(array_reference=b) def percentage_of_reoccurring_values_to_all_values(arr, is_sorted): """ Calculates the percentage of unique values, that are present in the time series more than once. .. math:: \\frac{\\textit{number of data points occurring more than once}}{\\textit{number of all data points})} This means the percentage is normalized to the number of unique values, in contrast to the percentage_of_reoccurring_datapoints_to_all_datapoints. :param arr: KHIVA array with the time series. :param is_sorted: Indicates if the input time series is sorted or not. Defaults to false. :return: KHIVA array with the percentage of unique values, that are present in the time series more than once. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.percentage_of_reoccurring_values_to_all_values(ctypes.pointer(arr.arr_reference), ctypes.pointer( ctypes.c_bool(is_sorted)), ctypes.pointer(b)) return Array(array_reference=b) def quantile(arr, q, precision=1e8): """ Returns values at the given quantile. :param arr: KHIVA array with the time series. :param q: Khiva array with the percentile(s) at which to extract score(s). One or many. :param precision: Number of decimals expected. :return: Values at the given quantile. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.quantile(ctypes.pointer(arr.arr_reference), ctypes.pointer(q.arr_reference), ctypes.pointer(ctypes.c_float(precision)), ctypes.pointer(b)) return Array(array_reference=b) def range_count(arr, min, max): """ Counts observed values within the interval [min, max). :param arr: KHIVA array with the time series. :param min: Value that sets the lower limit. :param max: Value that sets the upper limit. :return: KHIVA array with the values at the given range. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.range_count(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_int(min)), ctypes.pointer(ctypes.c_float(max)), ctypes.pointer(b)) return Array(array_reference=b) def ratio_beyond_r_sigma(arr, r): """ Calculates the ratio of values that are more than :math:`r*std(x)` (so :math:`r` sigma) away from the mean of :math:`x`. :param arr: KHIVA array with the time series. :param r: Number of times that the values should be away from. :return: KHIVA array with the ratio of values that are more than :math:`r*std(x)` (so :math:`r` sigma) away from the mean of :math:`x`. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.ratio_beyond_r_sigma(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_float(r)), ctypes.pointer(b)) return Array(array_reference=b) def ratio_value_number_to_time_series_length(arr): """ Calculates a factor which is 1 if all values in the time series occur only once, and below one if this is not the case. In principle, it just returns: .. math:: \\frac{\\textit{number unique values}}{\\textit{number values}} :param arr: KHIVA array with the time series. :return: KHIVA array with the ratio of unique values with respect to the total number of values. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.ratio_value_number_to_time_series_length(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def sample_entropy(arr): """ Calculates a vectorized sample entropy algorithm. https://en.wikipedia.org/wiki/Sample_entropy https://www.ncbi.nlm.nih.gov/pubmed/10843903?dopt=Abstract For short time-series this method is highly dependent on the parameters, but should be stable for N > 2000, see: Yentes et al. (2012) - The Appropriate Use of Approximate Entropy and Sample Entropy with Short Data Sets Other shortcomings and alternatives discussed in: Richman & Moorman (2000) - Physiological time-series analysis using approximate entropy and sample entropy. :param arr: KHIVA array with the time series. :return: KHIVA array with the same dimensions as tss, whose values (time series in dimension 0) contains the vectorized sample entropy for all the input time series in tss. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.sample_entropy(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def skewness(arr): """ Calculates the sample skewness of tss (calculated with the adjusted Fisher-Pearson standardized moment coefficient G1). :param arr: KHIVA array with the time series. :return: KHIVA array containing the skewness of each time series in tss. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.skewness(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def spkt_welch_density(arr, coeff): """ Estimates the cross power spectral density of the time series array at different frequencies. To do so, the time series is first shifted from the time domain to the frequency domain. Welch's method computes an estimate of the power spectral density by dividing the data into overlapping segments, computing a modified periodogram for each segment and averaging the periodograms. [1] P. Welch, "The use of the fast Fourier transform for the estimation of power spectra: A method based on time averaging over short, modified periodograms", IEEE Trans. Audio Electroacoust. vol. 15, pp. 70-73, 1967. [2] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra", Biometrika, vol. 37, pp. 1-16, 1950. [3] Rabiner, Lawrence R., and B. Gold. "Theory and Application of Digital Signal Processing" Prentice-Hall, pp. 414-419, 1975. :param arr: KHIVA array with the time series. :param coeff: The coefficient to be returned. :return: KHIVA array containing the power spectrum of the different frequencies for each time series in arr. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.spkt_welch_density(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_int(coeff)), ctypes.pointer(b)) return Array(array_reference=b) def standard_deviation(arr): """ Calculates the standard deviation of each time series within tss. :param arr: KHIVA array with the time series. :return: KHIVA array with the standard deviation of each time series within tss. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.standard_deviation(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def sum_of_reoccurring_datapoints(arr, is_sorted=False): """ Calculates the sum of all data points, that are present in the time series more than once. :param arr: KHIVA array with the time series. :param is_sorted: Indicates if the input time series is sorted or not. Defaults to false. :return: KHIVA array with the sum of all data points, that are present in the time series more than once. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.sum_of_reoccurring_datapoints(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_bool(is_sorted)), ctypes.pointer(b)) return Array(array_reference=b) def sum_of_reoccurring_values(arr, is_sorted=False): """ Calculates the sum of all values, that are present in the time series more than once. :param arr: KHIVA array with the time series. :param is_sorted: Indicates if the input time series is sorted or not. Defaults to false. :return: KHIVA array with the sum of all values, that are present in the time series more than once. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.sum_of_reoccurring_values(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_bool(is_sorted)), ctypes.pointer(b)) return Array(array_reference=b) def sum_values(arr): """ Calculates the sum over the time series arr. :param arr: KHIVA array with the time series. :param is_sorted: Indicates if the input time series is sorted or not. Defaults to false. :return: KHIVA array with the sum of values in each time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.sum_values(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def symmetry_looking(arr, r): """ Calculates if the distribution of tss *looks symmetric*. This is the case if .. math:: | mean(tss)-median(tss)| < r * (max(tss)-min(tss)) :param arr: KHIVA array with the time series. :param r: The percentage of the range to compare with. :return: KHIVA array denoting if the input time series look symmetric. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.symmetry_looking(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_float(r)), ctypes.pointer(b)) return Array(array_reference=b) def time_reversal_asymmetry_statistic(arr, lag): """ This function calculates the value of: .. math:: \\frac{1}{n-2lag} \\sum_{i=0}^{n-2lag} x_{i + 2 \\cdot lag}^2 \\cdot x_{i + lag} - x_{i + lag} \\cdot x_{i}^2 which is .. math:: \\mathbb{E}[L^2(X)^2 \\cdot L(X) - L(X) \\cdot X^2] where :math:`\\mathbb{E}` is the mean and :math:`L` is the lag operator. It was proposed in [1] as a promising feature to extract from time series. :param arr: KHIVA array with the time series. :param lag: The lag to be computed. :return: KHIVA array containing the count of the given value in each time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.time_reversal_asymmetry_statistic(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_int(lag)), ctypes.pointer(b)) return Array(array_reference=b) def value_count(arr, v): """ Counts occurrences of value in the time series tss. :param arr: KHIVA array with the time series. :param v: The value to be counted. :return: KHIVA array containing the count of the given value in each time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.value_count(ctypes.pointer(arr.arr_reference), ctypes.pointer(ctypes.c_float(v)), ctypes.pointer(b)) return Array(array_reference=b) def variance(arr): """ Computes the variance for the time series array. :param arr: KHIVA array with the time series. :return: KHIVA array containing the variance in each time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.variance(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def variance_larger_than_standard_deviation(arr): """ Calculates if the variance of array is greater than the standard deviation. In other words, if the variance of array is larger than 1. :param arr: KHIVA array with the time series. :return: KHIVA array denoting if the variance of array is greater than the standard deviation. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.variance_larger_than_standard_deviation(ctypes.pointer(arr.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) khiva-python-0.2.2/khiva/library.py000066400000000000000000000077731346407502000172730ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## from enum import Enum import ctypes import platform import logging import sys ######################################################################################################################## class KhivaLibrary(object): class __KhivaLibrary: def __init__(self): try: if platform.system() == 'Darwin': self.c_khiva_library = ctypes.CDLL('libkhiva_c.dylib') elif platform.system() == 'Windows': self.c_khiva_library = ctypes.CDLL('C:/Program Files/Khiva/v0/lib/khiva_c.dll') elif platform.system() == 'Linux': self.c_khiva_library = ctypes.CDLL('libkhiva_c.so') except: logging.error( "Khiva C++ library is required in order to use the Python Khiva library") sys.exit(1) instance = None def __new__(cls): if not KhivaLibrary.instance: KhivaLibrary.instance = KhivaLibrary.__KhivaLibrary() return KhivaLibrary.instance def __getattr__(self, name): return getattr(self.instance, name) def __setattr__(self, name): return setattr(self.instance, name) class KHIVABackend(Enum): """ KHIVA Backend. """ KHIVA_BACKEND_DEFAULT = 0 """ Default Backend. """ KHIVA_BACKEND_CPU = 1 """ CPU Backend. """ KHIVA_BACKEND_CUDA = 2 """ CUDA Backend. """ KHIVA_BACKEND_OPENCL = 4 """ OPENCL Backend. """ def get_backend_info(): """ Gets information from the current backend. :return: A string with information from the current backend. """ info_pointer = ctypes.c_char_p((" " * 1000).encode('utf8')) KhivaLibrary().c_khiva_library.backend_info(ctypes.pointer(info_pointer)) return info_pointer.value.decode('utf8') def set_backend(backend): """ Sets the KHIVABackend. :param backend: The desired backend. KHIVABackend type. """ KhivaLibrary().c_khiva_library.set_backend(ctypes.pointer(ctypes.c_int(backend.value))) def get_backend(): """ Gets the active backend. :return: The active backend. KHIVABackend type. """ backend = (ctypes.c_int * 1)(*[0]) KhivaLibrary().c_khiva_library.get_backend(ctypes.pointer(backend)) return KHIVABackend(backend[0]) def get_backends(): """ Gets the available backends. :return: The available backends. """ backends = (ctypes.c_int * 1)(*[0]) KhivaLibrary().c_khiva_library.get_backends(ctypes.pointer(backends)) return backends[0] def set_device(device): """ Sets the device. :param device: The desired device. """ KhivaLibrary().c_khiva_library.set_device(ctypes.pointer(ctypes.c_int(device))) def get_device_id(): """ Gets the active device. :return: The active device. """ device = (ctypes.c_int * 1)(*[0]) KhivaLibrary().c_khiva_library.get_device_id(ctypes.pointer(device)) return device[0] def get_device_count(): """ Gets the devices count. :return: The devices count. """ device_count = (ctypes.c_int * 1)(*[0]) KhivaLibrary().c_khiva_library.get_device_count(ctypes.pointer(device_count)) return device_count[0] def version(): """ Returns a string with the current version of the library. :return: A string with the current version of the library. """ v = ctypes.c_char_p((" " * 40).encode('utf8')) KhivaLibrary().c_khiva_library.version(ctypes.pointer(v)) return v.value.decode('utf8') khiva-python-0.2.2/khiva/linalg.py000066400000000000000000000034041346407502000170600ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import ctypes from khiva.library import KhivaLibrary from khiva.array import Array ######################################################################################################################## def lls(a, b): """ Calculates the minimum norm least squares solution :math:`x` :math:`(||A·x - b||^2)` to :math:`A·x = b`. This function uses the singular value decomposition function of Arrayfire. The actual formula that this function computes is :math:`x = V·D\\dagger·U^T·b`. Where :math:`U` and :math:`V` are orthogonal matrices and :math:`D\\dagger` contains the inverse values of the singular values contained in :math:`D` if they are not zero, and zero otherwise. :param a: KHIVA array with the coefficients of the linear equation problem to solve. It accepts a list of lists or a numpy array with one or several time series. :param b: KHIVA array with the measured values. :return: KHIVA array with the solution to the linear equation problem minimizing the norm 2. """ c = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.lls(ctypes.pointer(a.arr_reference), ctypes.pointer(b.arr_reference), ctypes.pointer(c)) return Array(array_reference=c) khiva-python-0.2.2/khiva/matrix.py000066400000000000000000000146051346407502000171230ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import ctypes from khiva.library import KhivaLibrary from khiva.array import Array ######################################################################################################################## def find_best_n_discords(profile, index, m, n, self_join=False): """ This function extracts the best N motifs from a previously calculated matrix profile. :param profile: KHIVA array with the matrix profile containing the minimum distance of each subsequence. :param index: KHIVA array with the matrix profile index containing where each minimum occurs. :param m: Subsequence length value used to calculate the input matrix profile. :param n: Number of discords to extract. :param self_join: Indicates whether the input profile comes from a self join operation or not. It determines whether the mirror similar region is included in the output or not. :return: KHIVA arrays with the discord distances, the discord indices and the subsequence indices. """ b = ctypes.c_void_p(0) c = ctypes.c_void_p(0) d = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.find_best_n_discords(ctypes.pointer(profile.arr_reference), ctypes.pointer(index.arr_reference), ctypes.pointer(ctypes.c_long(m)), ctypes.pointer(ctypes.c_long(n)), ctypes.pointer(b), ctypes.pointer(c), ctypes.pointer(d), ctypes.pointer(ctypes.c_bool(self_join))) return Array(array_reference=b), Array(array_reference=c), Array( array_reference=d) def find_best_n_motifs(profile, index, m, n, self_join=False): """ This function extracts the best N discords from a previously calculated matrix profile. :param profile: KHIVA array with the matrix profile containing the minimum distance of each subsequence. :param index: KHIVA array with the matrix profile index containing where each minimum occurs. :param m: Subsequence length value used to calculate the input matrix profile. :param n: Number of motifs to extract. :param self_join: Indicates whether the input profile comes from a self join operation or not. It determines whether the mirror similar region is included in the output or not. :return: KHIVA arrays with the motif distances, the motif indices and the subsequence indices. """ b = ctypes.c_void_p(0) c = ctypes.c_void_p(0) d = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.find_best_n_motifs(ctypes.pointer(profile.arr_reference), ctypes.pointer(index.arr_reference), ctypes.pointer(ctypes.c_long(m)), ctypes.pointer(ctypes.c_long(n)), ctypes.pointer(b), ctypes.pointer(c), ctypes.pointer(d), ctypes.pointer(ctypes.c_bool(self_join))) return Array(array_reference=b), Array(array_reference=c), Array( array_reference=d) def stomp(first_time_series, second_time_series, subsequence_length): """ Stomp algorithm to calculate the matrix profile between `ta` and `tb` using a subsequence length of `m`. [1] Yan Zhu, Zachary Zimmerman, Nader Shakibay Senobari, Chin-Chia Michael Yeh, Gareth Funning, Abdullah Mueen, Philip Brisk and Eamonn Keogh (2016). Matrix Profile II: Exploiting a Novel Algorithm and GPUs to break the one Hundred Million Barrier for Time Series Motifs and Joins. IEEE ICDM 2016. :param first_time_series: KHIVA array with the first time series. :param second_time_series: KHIVA array with the second time series. :param subsequence_length: Length of the subsequence. :return: KHIVA arrays with the profile and index. """ b = ctypes.c_void_p(0) c = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.stomp(ctypes.pointer(first_time_series.arr_reference), ctypes.pointer(second_time_series.arr_reference), ctypes.pointer(ctypes.c_long(subsequence_length)), ctypes.pointer(b), ctypes.pointer(c)) return Array(array_reference=b), Array(array_reference=c) def stomp_self_join(time_series, subsequence_length): """ Stomp algorithm to calculate the matrix profile between `t` and itself using a subsequence length of `m`. This method filters the trivial matches. [1] Yan Zhu, Zachary Zimmerman, Nader Shakibay Senobari, Chin-Chia Michael Yeh, Gareth Funning, Abdullah Mueen, Philip Brisk and Eamonn Keogh (2016). Matrix Profile II: Exploiting a Novel Algorithm and GPUs to break the one Hundred Million Barrier for Time Series Motifs and Joins. IEEE ICDM 2016. :param time_series: The query and reference time series in KHIVA array format. :param subsequence_length: Lenght of the subsequence :return: KHIVA arrays with the profile and index. """ b = ctypes.c_void_p(0) c = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.stomp_self_join(ctypes.pointer(time_series.arr_reference), ctypes.pointer(ctypes.c_long(subsequence_length)), ctypes.pointer(b), ctypes.pointer(c)) return Array(array_reference=b), Array(array_reference=c) khiva-python-0.2.2/khiva/normalization.py000066400000000000000000000141061346407502000205010ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import ctypes from khiva.library import KhivaLibrary from khiva.array import Array ######################################################################################################################## def decimal_scaling_norm(tss): """ Normalizes the given time series according to its maximum value and adjusts each value within the range (-1, 1). :param tss: KHIVA array with the time series. :return: KHIVA array with the same dimensions as tss, whose values (time series in dimension 0) have been normalized by dividing each number by :math::`10^j` , where j is the number of integer digits of the max number in the time series.` """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.decimal_scaling_norm(ctypes.pointer(tss.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def decimal_scaling_norm_in_place(tss): """ Same as decimal_scaling_norm, but it performs the operation in place, without allocating further memory. :param tss: KHIVA array with the time series. """ KhivaLibrary().c_khiva_library.decimal_scaling_norm_in_place(ctypes.pointer(tss.arr_reference)) def max_min_norm(tss, high=1.0, low=0.0, epsilon=0.00000001): """ Normalizes the given time series according to its minimum and maximum value and adjusts each value within the range [low, high]. :param tss: KHIVA array with the time series. :param high: Maximum final value (Defaults to 1.0). :param low: Minimum final value (Defaults to 0.0). :param epsilon: Safeguard for constant (or near constant) time series as the operation implies a unit scale operation between min and max values in the tss. :return: KHIVA array with the same dimensions as tss where the time series have been adjusted for zero mean and one as standard deviation. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.max_min_norm(ctypes.pointer(tss.arr_reference), ctypes.pointer(ctypes.c_double(high)), ctypes.pointer(ctypes.c_double(low)), ctypes.pointer(ctypes.c_double(epsilon)), ctypes.pointer(b)) return Array(array_reference=b) def max_min_norm_in_place(tss, high=1.0, low=0.0, epsilon=0.00000001): """ Same as max_min_norm, but it performs the operation in place, without allocating further memory. :param tss: KHIVA array with the time series. :param high: Maximum final value (Defaults to 1.0). :param low: Minimum final value (Defaults to 0.0). :param epsilon: Safeguard for constant (or near constant) time series as the operation implies a unit scale operation between min and max values in the tss. """ KhivaLibrary().c_khiva_library.max_min_norm_in_place(ctypes.pointer(tss.arr_reference), ctypes.pointer(ctypes.c_double(high)), ctypes.pointer(ctypes.c_double(low)), ctypes.pointer(ctypes.c_double(epsilon))) def mean_norm(tss): """ Normalizes the given time series according to its maximum-minimum value and its mean. It follows the following formulae: .. math:: \\acute{x} = frac{x - mean(x)}{max(x) - min(x)}. :param tss: KHIVA array with the time series. :return: An array with the same dimensions as tss, whose values (time series in dimension 0) have been normalized by substracting the mean from each number and dividing each number by :math:`max(x) - min(`x)`, in the time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.mean_norm(ctypes.pointer(tss.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def mean_norm_in_place(tss): """ Normalizes the given time series according to its maximum-minimum value and its mean. It follows the following formulae: .. math: \\acute{x} = frac{x - mean(x)}{max(x) - min(x)}. :param tss: KHIVA array with the time series. """ KhivaLibrary().c_khiva_library.mean_norm_in_place(ctypes.pointer(tss.arr_reference)) def znorm(tss, epsilon=0.00000001): """ Calculates a new set of time series with zero mean and standard deviation one. :param tss: KHIVA array with the time series. :param epsilon: Minimum standard deviation to consider. It acts as a gatekeeper for those time series that may be constant or near constant. :return: KHIVA array with the same dimensions as tss where the time series have been adjusted for zero mean and one as standard deviation. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.znorm(ctypes.pointer(tss.arr_reference), ctypes.pointer(ctypes.c_double(epsilon)), ctypes.pointer(b)) return Array(array_reference=b) def znorm_in_place(tss, epsilon=0.00000001): """ Adjusts the time series in the given input and performs z-norm in place (without allocating further memory). :param tss: KHIVA array with the time series. :param epsilon: epsilon Minimum standard deviation to consider. It acts as a gatekeeper for those time series that may be constant or near constant. """ KhivaLibrary().c_khiva_library.znorm_in_place(ctypes.pointer(tss.arr_reference), ctypes.pointer(ctypes.c_double(epsilon))) khiva-python-0.2.2/khiva/polynomial.py000066400000000000000000000042711346407502000200000ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import ctypes from khiva.library import KhivaLibrary from khiva.array import Array ######################################################################################################################## def polyfit(x, y, deg): """ Least squares polynomial fit. Fit a polynomial :math:`p(x) = p[0] * x^{deg} + ... + p[deg]` of degree :math:`deg` to points :math:`(x, y)`. Returns a vector of coefficients :math:`p` that minimises the squared error. :param x: KHIVA array with the x-coordinates of the M sample points :math:`(x[i], y[i])`. :param y: KHIVA array with the y-coordinates of the sample points. :param deg: Degree of the fitting polynomial :return: KHIVA array with the polynomial coefficients, highest power first. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.polyfit(ctypes.pointer(x.arr_reference), ctypes.pointer(y.arr_reference), ctypes.pointer(ctypes.c_int(deg)), ctypes.pointer(b)) return Array(array_reference=b) def roots(p): """ Calculates the roots of a polynomial with coefficients given in :math:`p`. The values in the rank-1 array :math:`p` are coefficients of a polynomial. If the length of :math:`p` is :math:`n+1` then the polynomial is described by: .. math:: p[0] * x^n + p[1] * x^{n-1} + ... + p[n-1] * x + p[n] :param p: KHIVA array with the polynomial coefficients. :return: KHIVA array with the roots of the polynomial. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.roots(ctypes.pointer(p.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) khiva-python-0.2.2/khiva/regression.py000066400000000000000000000046031346407502000177740ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import ctypes from khiva.library import KhivaLibrary from khiva.array import Array ######################################################################################################################## def linear(xss, yss): """Calculates a linear least-squares regression for two sets of measurements. Both arrays should have the same length. :param xss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :param yss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :return: slope Slope of the regression line. intercept Intercept of the regression line. rvalue Correlation coefficient. pvalue Two-sided p-value for a hypothesis test whose null hypothesis is that the slope is zero, using Wald Test with t-distribution of the test statistic. stderrest Standard error of the estimated gradient. """ b = ctypes.c_void_p(0) c = ctypes.c_void_p(0) d = ctypes.c_void_p(0) e = ctypes.c_void_p(0) f = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.linear(ctypes.pointer(xss.arr_reference), ctypes.pointer(yss.arr_reference), ctypes.pointer(b), ctypes.pointer(c), ctypes.pointer(d), ctypes.pointer(e), ctypes.pointer(f) ) return Array(array_reference=b), Array(array_reference=c), Array(array_reference=d), Array( array_reference=e), Array(array_reference=f) khiva-python-0.2.2/khiva/regularization.py000066400000000000000000000045301346407502000206520ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import ctypes from khiva.library import KhivaLibrary from khiva.array import Array ######################################################################################################################## def group_by(tss, aggregation_function, n_columns_key=1, n_columns_value=1): """ Group by operation in the input array using n_columns_key columns as group keys and n_columns_value columns as values. The data is expected to be sorted. The aggregation function determines the operation to aggregate the values. :param tss: KHIVA array with the time series. :param aggregation_function: Function to be used in the aggregation. It receives an integer which indicates the function to be applied. 0 : mean, 1 : median 2 : min, 3 : max, 4 : stdev, 5 : var, default : mean :param n_columns_key: Number of columns conforming the key. :param n_columns_value: Number of columns conforming the value (they are expected to be consecutive to the column keys). :return: KHIVA array with the values of the group keys aggregated using the aggregation_function. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.group_by(ctypes.pointer(tss.arr_reference), ctypes.pointer(ctypes.c_int(aggregation_function)), ctypes.pointer(ctypes.c_int(n_columns_key)), ctypes.pointer(ctypes.c_int(n_columns_value)), ctypes.pointer(b)) return Array(array_reference=b) khiva-python-0.2.2/khiva/statistics.py000066400000000000000000000172501346407502000200100ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import ctypes from khiva.library import KhivaLibrary from khiva.array import Array ######################################################################################################################## def covariance(tss, unbiased=False): """ Returns the covariance matrix of the time series contained in tss. :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :param unbiased: Determines whether it divides by n - 1 (if false) or n (if true). :return: The covariance matrix of the time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.covariance_statistics(ctypes.pointer(tss.arr_reference), ctypes.pointer(ctypes.c_bool(unbiased)), ctypes.pointer(b)) return Array(array_reference=b) def kurtosis(tss): """ Returns the kurtosis of tss (calculated with the adjusted Fisher-Pearson standardized moment coefficient G2). :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :return: The kurtosis of tss. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.kurtosis_statistics(ctypes.pointer(tss.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def ljung_box(tss, lags): """ The Ljung–Box test checks that data whithin the time series are independently distributed (i.e. the correlations in the population from which the sample is taken are 0, so that any observed correlations in the data result from randomness of the sampling process). Data are no independently distributed, if they exhibit serial correlation. The test statistic is: .. math:: Q = n\\left(n+2\\right)\sum_{k=1}^h\\frac{\hat{\\rho}^2_k}{n-k} where :math:`n` is the sample size, :math:`\hat{\\rho}k` is the sample autocorrelation at lag :math:`k`, and :math:`h` is the number of lags being tested. Under :math:`H_0` the statistic Q follows a :math:`\\chi^2{(h)}`. For significance level :math:`\\alpha`, the :math:`critical region` for rejection of the hypothesis of randomness is: .. math:: Q > \\chi_{1-\\alpha,h}^2 where :math:`\\chi_{1-\\alpha,h}^2` is the :math:`\\alpha`-quantile of the chi-squared distribution with :math:`h` degrees of freedom. [1] G. M. Ljung G. E. P. Box (1978). On a measure of lack of fit in time series models. Biometrika, Volume 65, Issue 2, 1 August 1978, Pages 297–303. :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :param lags: Number of lags being tested. :return: Array containing the Ljung-Box statistic test. """ ljung_box_out = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.ljung_box(ctypes.pointer(tss.arr_reference), ctypes.pointer(ctypes.c_long(lags)), ctypes.pointer(ljung_box_out)) return Array(array_reference=ljung_box_out) def moment(tss, k): """ Returns the kth moment of the given time series. :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :param k: The specific moment to be calculated. :return: The kth moment of the given time series. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.moment_statistics(ctypes.pointer(tss.arr_reference), ctypes.pointer(ctypes.c_int(k)), ctypes.pointer(b)) return Array(array_reference=b) def quantile(tss, q, precision=1e8): """ Returns values at the given quantile. :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. NOTE: the time series should be sorted. :param q: Percentile(s) at which to extract score(s). One or many. :param precision: Number of decimals expected. :return: Values at the given quantile. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.quantile_statistics(ctypes.pointer(tss.arr_reference), ctypes.pointer(q.arr_reference), ctypes.pointer(ctypes.c_float(precision)), ctypes.pointer(b)) return Array(array_reference=b) def quantiles_cut(tss, quantiles, precision=1e-8): """ Discretizes the time series into equal-sized buckets based on sample quantiles. :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. NOTE: the time series should be sorted. :param quantiles: Number of quantiles to extract. From 0 to 1, step 1/quantiles. :param precision: Number of decimals expected. :return: Matrix with the categories, one category per row, the start of the category in the first column and the end in the second category. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.quantiles_cut_statistics(ctypes.pointer(tss.arr_reference), ctypes.pointer(ctypes.c_float(quantiles)), ctypes.pointer(ctypes.c_float(precision)), ctypes.pointer(b)) return Array(array_reference=b) def sample_stdev(tss): """ Estimates standard deviation based on a sample. The standard deviation is calculated using the "n-1" method. :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. :return: The sample standard deviation. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.sample_stdev_statistics(ctypes.pointer(tss.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) def skewness(tss): """ Calculates the sample skewness of tss (calculated with the adjusted Fisher-Pearson standardized moment coefficient G1). :param tss: Expects an input array whose dimension zero is the length of the time series (all the same) and dimension one indicates the number of time series. NOTE: the time series should be sorted. :return: Array containing the skewness of each time series in tss. """ b = ctypes.c_void_p(0) KhivaLibrary().c_khiva_library.skewness_statistics(ctypes.pointer(tss.arr_reference), ctypes.pointer(b)) return Array(array_reference=b) khiva-python-0.2.2/rdocs-requirements.txt000066400000000000000000000000521346407502000205260ustar00rootroot00000000000000Sphinx >= 1.7.0 sphinx_rtd_theme >= 0.2.4 khiva-python-0.2.2/requirements.txt000066400000000000000000000001041346407502000174140ustar00rootroot00000000000000pandas >= 0.22.0 numpy >= 1.14.0 arrayfire >= 3.5.2 enum34 >= 1.1.6 khiva-python-0.2.2/setup.cfg000066400000000000000000000015641346407502000157640ustar00rootroot00000000000000[metadata] name = khiva summary = khiva performs big sequence analytics by using GPU. license = MPL-v2 author = Shapelets.io # Add here all kinds of additional classifiers as defined under # https://pypi.python.org/pypi?%3Aaction=list_classifiers classifier = Programming Language :: Python :: 3.6 Programming Language :: Python :: 3.5 Programming Language :: Python :: 2.7 Operating System :: Unix Operating System :: Microsoft :: Windows Operating System :: MacOS Intended Audience :: Science/Research Topic :: Scientific/Engineering Topic :: Software Development [entry_points] # Add here console scripts like: # console_scripts = # script_name = khiva.module:function [files] # Add here 'data_files', 'packages' or 'namespace_packages'. # Additional data files are defined as key value pairs of source and target: packages = khiva khiva-python-0.2.2/setup.py000066400000000000000000000020251346407502000156460ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## from setuptools import setup, find_packages ######################################################################################################################## with open("README.rst", "r") as handler: LONG_DESC = handler.read() setup( author="Shapelets.io", author_email="dev@shapelets.io", name="khiva", version='0.2.2', long_description = LONG_DESC, description="Python bindings for khiva", license="MPL 2.0", url="http://shapelets.io", packages=find_packages() ) khiva-python-0.2.2/test-requirements.txt000066400000000000000000000001031346407502000203700ustar00rootroot00000000000000pytest >= 3.4.1 unittest-xml-reporting >= 2.2.0 requests >= 2.19.1 khiva-python-0.2.2/tests/000077500000000000000000000000001346407502000152775ustar00rootroot00000000000000khiva-python-0.2.2/tests/__init__.py000066400000000000000000000004271346407502000174130ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. khiva-python-0.2.2/tests/unit_tests/000077500000000000000000000000001346407502000175005ustar00rootroot00000000000000khiva-python-0.2.2/tests/unit_tests/__init__.py000066400000000000000000000004271346407502000216140ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. khiva-python-0.2.2/tests/unit_tests/array_unit_tests.py000066400000000000000000000361201346407502000234530ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import unittest import arrayfire as af import numpy as np import pandas as pd from khiva.array import Array, dtype from khiva.library import set_backend, KHIVABackend ######################################################################################################################## class ArrayTest(unittest.TestCase): DELTA = 1e-6 DECIMAL = 6 def setUp(self): set_backend(KHIVABackend.KHIVA_BACKEND_CPU) def test_real_1d(self): a = Array([1, 2, 3, 4, 5, 6, 7, 8]) expected = np.array([1, 2, 3, 4, 5, 6, 7, 8]) np.testing.assert_array_equal(a.to_numpy(), expected) def test_real_2d(self): a = Array([[1, 2, 3, 4], [5, 6, 7, 8]]) expected = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]) np.testing.assert_array_equal(a.to_numpy(), expected) def test_real_3d(self): a = Array([[[1, 5], [2, 6]], [[3, 7], [4, 8]]]) expected = np.array([[[1, 5], [2, 6]], [[3, 7], [4, 8]]]) np.testing.assert_array_equal(a.to_numpy(), expected) def test_real_4d(self): a = Array([[[[1, 9], [2, 10]], [[3, 11], [4, 12]]], [[[5, 13], [6, 14]], [[7, 15], [8, 16]]]]) expected = np.array([[[[1, 9], [2, 10]], [[3, 11], [4, 12]]], [[[5, 13], [6, 14]], [[7, 15], [8, 16]]]]) np.testing.assert_array_equal(a.to_numpy(), expected) def test_complex64_1d(self): a = Array(np.array([1 + 5j, 2 + 6j, 3 + 7j, 4 + 8j]).astype(np.complex64), khiva_type=dtype.c32) expected = np.array([1 + 5j, 2 + 6j, 3 + 7j, 4 + 8j]).astype(np.complex64) np.testing.assert_array_equal(a.to_numpy(), expected) def test_complex64_2d(self): a = Array( np.array([[1 + 5j, 2 + 6j, 3 + 7j, 4 + 8j], [9 + 13j, 10 + 14j, 11 + 15j, 12 + 16j]]).astype(np.complex64), khiva_type=dtype.c32) expected = np.array([[1 + 5j, 2 + 6j, 3 + 7j, 4 + 8j], [9 + 13j, 10 + 14j, 11 + 15j, 12 + 16j]]).astype( np.complex64) np.testing.assert_array_equal(a.to_numpy(), expected) def test_complex64_3d(self): a = Array( np.array([[[1 + 1j, 5 + 5j], [2 + 2j, 6 + 6j]], [[3 + 3j, 7 + 7j], [4 + 4j, 8 + 8j]]]).astype(np.complex64), khiva_type=dtype.c32) expected = np.array([[[1 + 1j, 5 + 5j], [2 + 2j, 6 + 6j]], [[3 + 3j, 7 + 7j], [4 + 4j, 8 + 8j]]]).astype( np.complex64) np.testing.assert_array_equal(a.to_numpy(), expected) def test_complex64_4d(self): a = Array( np.array([[[[1 + 1j, 9 + 9j], [2 + 2j, 10 + 10j]], [[3 + 3j, 11 + 11j], [4 + 4j, 12 + 12j]]], [[[5 + 5j, 13 + 13j], [6 + 6j, 14 + 14j]], [[7 + 7j, 15 + 15j], [8 + 8j, 16 + 16j]]]]) .astype(np.complex64), khiva_type=dtype.c32) expected = np.array([[[[1 + 1j, 9 + 9j], [2 + 2j, 10 + 10j]], [[3 + 3j, 11 + 11j], [4 + 4j, 12 + 12j]]], [[[5 + 5j, 13 + 13j], [6 + 6j, 14 + 14j]], [[7 + 7j, 15 + 15j], [8 + 8j, 16 + 16j]]]]).astype( np.complex64) np.testing.assert_array_equal(a.to_numpy(), expected) def test_complex128_1d(self): a = Array(np.array([1 + 5j, 2 + 6j, 3 + 7j, 4 + 8j]).astype(np.complex128), khiva_type=dtype.c64) expected = np.array([1 + 5j, 2 + 6j, 3 + 7j, 4 + 8j]).astype(np.complex128) np.testing.assert_array_equal(a.to_numpy(), expected) def test_complex128_2d(self): a = Array( np.array([[1 + 5j, 2 + 6j, 3 + 7j, 4 + 8j], [9 + 13j, 10 + 14j, 11 + 15j, 12 + 16j]]).astype(np.complex128), khiva_type=dtype.c32) expected = np.array([[1 + 5j, 2 + 6j, 3 + 7j, 4 + 8j], [9 + 13j, 10 + 14j, 11 + 15j, 12 + 16j]]).astype( np.complex128) np.testing.assert_array_equal(a.to_numpy(), expected) def test_complex128_3d(self): a = Array( np.array([[[1 + 1j, 5 + 5j], [2 + 2j, 6 + 6j]], [[3 + 3j, 7 + 7j], [4 + 4j, 8 + 8j]]]).astype( np.complex128), khiva_type=dtype.c32) expected = np.array([[[1 + 1j, 5 + 5j], [2 + 2j, 6 + 6j]], [[3 + 3j, 7 + 7j], [4 + 4j, 8 + 8j]]]).astype( np.complex128) np.testing.assert_array_equal(a.to_numpy(), expected) def test_complex128_4d(self): a = Array( np.array([[[[1 + 1j, 9 + 9j], [2 + 2j, 10 + 10j]], [[3 + 3j, 11 + 11j], [4 + 4j, 12 + 12j]]], [[[5 + 5j, 13 + 13j], [6 + 6j, 14 + 14j]], [[7 + 7j, 15 + 15j], [8 + 8j, 16 + 16j]]]]) .astype(np.complex128), khiva_type=dtype.c32) expected = np.array([[[[1 + 1j, 9 + 9j], [2 + 2j, 10 + 10j]], [[3 + 3j, 11 + 11j], [4 + 4j, 12 + 12j]]], [[[5 + 5j, 13 + 13j], [6 + 6j, 14 + 14j]], [[7 + 7j, 15 + 15j], [8 + 8j, 16 + 16j]]]]).astype( np.complex128) np.testing.assert_array_equal(a.to_numpy(), expected) def test_get_type(self): a = Array([[1, 2, 3, 4], [5, 6, 7, 8]], khiva_type=dtype.s64) expected = dtype.s64 self.assertEqual(a.get_type(), expected) def test_join(self): a = Array([1, 2, 3, 4], khiva_type=dtype.f64) b = Array([5, 6, 7, 8], khiva_type=dtype.f64) c = a.join(0, b) np.testing.assert_array_equal(c.to_numpy(), np.array([1, 2, 3, 4, 5, 6, 7, 8])) def testPlus(self): a = Array([1, 2, 3, 4]) b = Array([1, 2, 3, 4]) c = a + b np.testing.assert_array_equal(c.to_numpy(), np.array([2, 4, 6, 8])) def testTimes(self): a = Array([1, 2, 3, 4]) b = Array([1, 2, 3, 4]) c = a * b np.testing.assert_array_equal(c.to_numpy(), np.array([1, 4, 9, 16])) def testMinus(self): a = Array([1, 2, 3, 4]) b = Array([1, 2, 3, 4]) c = a - b np.testing.assert_array_equal(c.to_numpy(), np.array([0, 0, 0, 0])) def testRDivide(self): a = Array([1, 2, 3, 4]) b = Array([1, 2, 3, 4]) c = a / b expected = np.array([1., 1., 1., 1.]) for d, e in zip(expected, c.to_numpy()): self.assertAlmostEqual(d, e, delta=1e-5) def testMod(self): a = Array([1, 2, 3, 4]) b = Array([2, 2, 2, 2]) c = a % b np.testing.assert_array_equal(c.to_numpy(), np.array([1, 0, 1, 0])) def testPower(self): a = Array([1, 2, 3, 4]) b = Array([2, 2, 2, 2]) c = a ** b np.testing.assert_array_equal(c.to_numpy(), np.array([1, 4, 9, 16])) def testLt(self): a = Array([1, 2, 3, 4]) b = Array([2, 2, 2, 2]) c = a < b np.testing.assert_array_equal(c.to_numpy(), np.array([True, False, False, False])) def testGt(self): a = Array([1, 2, 3, 4]) b = Array([2, 2, 2, 2]) c = a > b np.testing.assert_array_equal(c.to_numpy(), np.array([False, False, True, True])) def testLe(self): a = Array([1, 2, 3, 4]) b = Array([2, 2, 2, 2]) c = a <= b np.testing.assert_array_equal(c.to_numpy(), np.array([True, True, False, False])) def testGe(self): a = Array([1, 2, 3, 4]) b = Array([2, 2, 2, 2]) c = a >= b np.testing.assert_array_equal(c.to_numpy(), np.array([False, True, True, True])) def testEq(self): a = Array([1, 2, 3, 4]) b = Array([1, 2, 3, 5]) c = a == b np.testing.assert_array_equal(c.to_numpy(), np.array([True, True, True, False])) def testNeq(self): a = Array([1, 2, 3, 4]) b = Array([1, 2, 3, 5]) c = a != b np.testing.assert_array_equal(c.to_numpy(), np.array([False, False, False, True])) def testAnd(self): a = Array([True, True, True, True], dtype.b8) b = Array([True, False, True, False], dtype.b8) c = a & b np.testing.assert_array_equal(c.to_numpy(), np.array([True, False, True, False])) def testOr(self): a = Array([True, True, True, True], dtype.b8) b = Array([True, False, True, False], dtype.b8) c = a | b np.testing.assert_array_equal(c.to_numpy(), np.array([True, True, True, True])) def testXor(self): a = Array([True, True, True, True], dtype.b8) b = Array([True, False, True, False], dtype.b8) c = a ^ b np.testing.assert_array_equal(c.to_numpy(), np.array([False, True, False, True])) def testBitshift(self): a = Array([2, 4, 6, 8], dtype.s32) c = a >> 1 np.testing.assert_array_equal(c.to_numpy(), np.array([1, 2, 3, 4])) def testBitsra(self): a = Array([2, 4, 6, 8], dtype.s32) c = a << 1 np.testing.assert_array_equal(c.to_numpy(), np.array([4, 8, 12, 16])) def testCtranspose(self): a = Array([[0 - 1j, 4 + 2j], [2 + 1j, 0 - 2j]], khiva_type=dtype.c32) b = a.transpose(True) expected = [[0 + 1j, 2 - 1j], [4 - 2j, 0 + 2j]] np.testing.assert_array_equal(b.to_numpy(), expected) def testTranspose(self): a = Array([[1, 3], [2, 4]], dtype.s32) c = a.transpose() np.testing.assert_array_equal(c.to_numpy(), np.array([[1, 2], [3, 4]])) def testCol(self): a = Array([[1, 3], [2, 4]], dtype.s32) c = a.get_col(0) np.testing.assert_array_equal(c.to_numpy(), np.array([1, 3])) def testCols(self): a = Array(np.transpose([[1, 2, 3], [4, 5, 6]]), dtype.s32) c = a.get_cols(0, 1) np.testing.assert_array_equal(c.to_numpy(), np.transpose(np.array([[1, 2], [4, 5]]))) def testRow(self): a = Array(np.transpose([[1, 2], [3, 4]]), dtype.s32) c = a.get_row(0) np.testing.assert_array_equal(c.to_numpy(), [1, 2]) def testRows(self): a = Array(np.transpose([[1, 2], [3, 4], [5, 6]]), dtype.s32) c = a.get_rows(0, 1) np.testing.assert_array_equal(c.to_numpy(), np.transpose(np.array([[1, 2], [3, 4]]))) def testMtimes(self): a = Array([1, 2, 3, 4]) b = Array([1, 2, 3, 4]) d = a.transpose() c = b.matmul(d) expected = np.transpose([[1, 2, 3, 4], [2, 4, 6, 8], [3, 6, 9, 12], [4, 8, 12, 16]]) np.testing.assert_array_equal(c.to_numpy(), expected) def testAs(self): a = Array([1, 2, 3, 4], khiva_type=dtype.s32) b = a.as_type(dtype.u32) expected_data = [1, 2, 3, 4] np.testing.assert_array_equal(b.to_numpy(), expected_data) self.assertEqual(b.khiva_type, dtype.u32) def testCopy(self): a = Array([1, 2, 3, 4], khiva_type=dtype.s32) b = a.copy() np.testing.assert_array_equal(a.to_numpy(), b.to_numpy()) self.assertEqual(b.khiva_type, b.khiva_type) def testArrayfire(self): a = af.Array([1, 2, 3, 4]) a_data = a.to_list() b = Array.from_arrayfire(a) np.testing.assert_array_equal(np.asarray(a_data), np.asarray(b.to_list())) def testFromPandas(self): df = pd.DataFrame([[1, 2, 3, 4], [5, 6, 7, 8]]) df_array = Array(df, khiva_type=dtype.s32) np.testing.assert_array_equal(df.values, df_array.to_pandas().values) def testLength(self): a = Array([1, 2, 3, 4]) self.assertEqual(len(a), 4) def testIadd(self): a = Array([1, 2, 3, 4]) b = Array([1, 2, 3, 4]) a += b np.testing.assert_array_equal(a.to_numpy(), np.array([2, 4, 6, 8])) def testIaddSelfArray(self): a = Array([1, 2, 3, 4, 5]) a += a np.testing.assert_array_equal(a.to_numpy(), np.array([2, 4, 6, 8, 10])) def testISub(self): a = Array([1, 2, 3, 4]) b = Array([1, 2, 3, 4]) a -= b np.testing.assert_array_equal(a.to_numpy(), np.array([0, 0, 0, 0])) def testIMul(self): a = Array([1, 2, 3, 4]) b = Array([1, 2, 3, 4]) a *= b np.testing.assert_array_equal(a.to_numpy(), np.array([1, 4, 9, 16])) def testITrueDiv(self): a = Array([1, 2, 3, 4]) b = Array([1, 2, 3, 4]) a /= b np.testing.assert_array_equal(a.to_numpy(), np.array([1, 1, 1, 1])) def testDiv(self): a = Array([1, 2, 3, 4]) b = Array([1, 2, 3, 4]) c = a / b np.testing.assert_array_equal(c.to_numpy(), np.array([1, 1, 1, 1])) def testMod(self): a = Array([1, 2, 3, 4]) b = Array([1, 2, 3, 4]) a %= b np.testing.assert_array_equal(a.to_numpy(), np.array([0, 0, 0, 0])) def testIPow(self): a = Array([1, 2, 3, 4]) b = Array([2, 2, 2, 2]) a **= b np.testing.assert_array_equal(a.to_numpy(), np.array([1, 4, 9, 16])) def testIAnd(self): a = Array([1, 1, 1, 1], khiva_type=dtype.b8) b = Array([1, 0, 1, 0], khiva_type=dtype.b8) a &= b np.testing.assert_array_equal(a.to_numpy(), np.array([1, 0, 1, 0])) def testIOr(self): a = Array([1, 1, 1, 1], khiva_type=dtype.b8) b = Array([1, 0, 1, 0], khiva_type=dtype.b8) a |= b np.testing.assert_array_equal(a.to_numpy(), np.array([1, 1, 1, 1])) def testXor(self): a = Array([True, True, True, True], dtype.b8) b = Array([True, False, True, False], dtype.b8) a ^= b np.testing.assert_array_equal(a.to_numpy(), np.array([False, True, False, True])) def testBitshift(self): a = Array([2, 4, 6, 8], dtype.s32) a >>= 1 np.testing.assert_array_equal(a.to_numpy(), np.array([1, 2, 3, 4])) def testBitsra(self): a = Array([2, 4, 6, 8], dtype.s32) a <<= 1 np.testing.assert_array_equal(a.to_numpy(), np.array([4, 8, 12, 16])) def testNeg(self): a = Array([[1, 2], [3, 4]]) b = -a np.testing.assert_array_equal(b.to_numpy(), np.array([[-1, -2], [-3, -4]])) def testNot(self): a = Array([True, True, True, False], khiva_type=dtype.b8) b = ~a np.testing.assert_array_equal(b.to_numpy(), np.array([False, False, False, True])) def testStr(self): a = Array([2, 4, 6, 8], dtype.s32) self.assertTrue("khiva.Array()\nType: dtype.s32\nDims: [4 1 1 1]" == str(a)) def testRepre(self): a = Array([1, 2, 3, 4]) self.assertTrue("khiva.Array()\nType: dtype.f32\nDims: [4 1 1 1]" == str(repr(a))) def testNonZero(self): a = Array([1, 2, 3, 4]) self.assertTrue(a) def testGetData1(self): a = Array([1]) np.testing.assert_array_equal(a._get_data(), np.array([1])) def testToList1(self): a = Array([1]) self.assertIs(type(a.to_list()), list) self.assertEqual(a.to_list()[0], 1) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(ArrayTest) unittest.TextTestRunner(verbosity=2).run(suite) khiva-python-0.2.2/tests/unit_tests/clustering_unit_tests.py000066400000000000000000000056471346407502000245260ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import unittest from khiva.clustering import * from khiva.array import Array import numpy as np from khiva.library import set_backend, KHIVABackend ######################################################################################################################## class ClusteringTest(unittest.TestCase): DELTA = 1e-3 DECIMAL = 3 def setUp(self): set_backend(KHIVABackend.KHIVA_BACKEND_CPU) def test_kmeans(self): tss = Array([[0.0, 1.0, 2.0, 3.0], [6.0, 7.0, 8.0, 9.0], [2.0, -2.0, 4.0, -4.0], [8.0, 5.0, 3.0, 1.0], [15.0, 10.0, 5.0, 0.0], [7.0, -7.0, 1.0, -1.0]]) expected_c = np.array([[0.0, 0.1667, 0.3333, 0.5], [1.5, -1.5, 0.8333, -0.8333], [4.8333, 3.6667, 2.6667, 1.6667]]) result = k_means(tss, 3) result_c = result[0].to_numpy() for i in range(0, 4): self.assertAlmostEqual(result_c[0, i] + result_c[1, i] + result_c[2, i], expected_c[0, i] + expected_c[1, i] + expected_c[2, i], delta=self.DELTA) def test_k_shape(self): tss = Array([[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], [0.0, 10.0, 4.0, 5.0, 7.0, -3.0, 0.0], [-1.0, 15.0, -12.0, 8.0, 9.0, 4.0, 5.0], [2.0, 8.0, 7.0, -6.0, -1.0, 2.0, 9.0], [-5.0, -5.0, -6.0, 7.0, 9.0, 9.0, 0.0]]) expected_c = np.array([[-0.5234, 0.1560, -0.3627, -1.2764, -0.7781, 0.9135, 1.8711], [-0.7825, 1.5990, 0.1701, 0.4082, 0.8845, -1.4969, -0.7825], [-0.6278, 1.3812, -2.0090, 0.5022, 0.6278, 0.0000, 0.1256]]) expected_l = np.array([0, 1, 2, 0, 0]) (centroids, labels) = k_shape(tss, 3) centr = centroids.to_numpy() lab = labels.to_numpy() np.testing.assert_array_almost_equal(centr, expected_c, decimal=self.DECIMAL) np.testing.assert_array_almost_equal(lab, expected_l, decimal=self.DECIMAL) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(ClusteringTest) unittest.TextTestRunner(verbosity=2).run(suite) khiva-python-0.2.2/tests/unit_tests/dimensionality_unit_tests.py000066400000000000000000000073471346407502000253760ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import unittest from khiva.dimensionality import * from khiva.array import Array import numpy as np from khiva.library import set_backend, KHIVABackend ######################################################################################################################## class DimensionalityTest(unittest.TestCase): DELTA = 1e-6 DECIMAL = 6 def setUp(self): set_backend(KHIVABackend.KHIVA_BACKEND_CPU) def test_ramer_douglas_peucker(self): a = Array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 0.1, -0.1, 5.0, 6.0, 7.0, 8.1, 9.0, 9.0, 9.0]]) ramer_douglas_peucker_result = ramer_douglas_peucker(a, 1.0).to_numpy() expected = np.array([[0, 2, 3, 6, 9], [0, -0.1, 5.0, 8.1, 9.0]]) np.testing.assert_array_almost_equal(ramer_douglas_peucker_result, expected, decimal=self.DECIMAL) def test_visvalingam(self): a = Array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 0.1, -0.1, 5.0, 6.0, 7.0, 8.1, 9.0, 9.0, 9.0]]) visvalingam_result = visvalingam(a, 5).to_numpy() expected = np.array([[0, 2, 3, 7, 9], [0, -0.1, 5.0, 9.0, 9.0]], dtype=np.float32) np.testing.assert_array_almost_equal(visvalingam_result, expected, decimal=self.DECIMAL) def test_paa(self): a = Array( [[0.0, 0.1, -0.1, 5.0, 6.0, 7.0, 8.1, 9.0, 9.0, 9.0], [0.0, 0.1, -0.1, 5.0, 6.0, 7.0, 8.1, 9.0, 9.0, 9.0]]) paa_result = paa(a, 5).to_numpy() expected = np.array([[0.05, 2.45, 6.5, 8.55, 9.0], [0.05, 2.45, 6.5, 8.55, 9.0]]) np.testing.assert_array_almost_equal(paa_result, expected, decimal=self.DECIMAL) def test_sax(self): a = Array([[0.0, 0.1, -0.1, 5.0, 6.0], [7.0, 8.1, 9.0, 9.0, 9.0]]) sax_result = sax(a, 3).to_numpy() expected = np.array([[0.0, 0.1, -0.1, 5.0, 6.0], [0.0, 1.0, 2.0, 2.0, 2.0]], dtype=np.float32) np.testing.assert_array_almost_equal(sax_result, expected, decimal=self.DECIMAL) def test_pip(self): a = Array( [[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0], [0.0, 0.1, -0.1, 5.0, 6.0, 7.0, 8.1, 9.0, 9.0, 9.0]]) pip_result = pip(a, 6).to_numpy() expected = np.array([[0.0, 2.0, 3.0, 6.0, 7.0, 9.0], [0.0, -0.1, 5.0, 8.1, 9.0, 9.0]]) np.testing.assert_array_almost_equal(pip_result, expected, decimal=self.DECIMAL) def test_pla_bottom_up(self): tss = Array([[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0], [0.0, 0.1, -0.1, 5.0, 6.0, 7.0, 8.1, 9.0, 9.0, 9.0]]) expected = [[0, 1, 2, 3, 4, 7, 8, 9], [0, 0.1, -0.1, 5, 6, 9, 9, 9]] result = pla_bottom_up(tss, 1).to_numpy() np.testing.assert_array_almost_equal(result, expected, decimal=self.DECIMAL) def test_pla_sliding_window(self): tss = Array([[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0], [0.0, 0.1, -0.1, 5.0, 6.0, 7.0, 8.1, 9.0, 9.0, 9.0]]) expected = [[0, 2, 3, 7, 8, 9], [0, -0.1, 5, 9, 9, 9]] result = pla_sliding_window(tss, 1).to_numpy() np.testing.assert_array_almost_equal(result, expected, decimal=self.DECIMAL) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(DimensionalityTest) unittest.TextTestRunner(verbosity=2).run(suite) khiva-python-0.2.2/tests/unit_tests/distances_unit_tests.py000066400000000000000000000060711346407502000243140ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import unittest from khiva.distances import * from khiva.array import Array import numpy as np from khiva.library import set_backend, KHIVABackend ######################################################################################################################## class DistancesTest(unittest.TestCase): def setUp(self): set_backend(KHIVABackend.KHIVA_BACKEND_CPU) def test_euclidean(self): euclidean_result = euclidean(Array(data=[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]])).to_numpy().flatten() expected = np.array([0, 0, 0, 8, 0, 0, 16, 8, 0]) np.testing.assert_array_almost_equal(euclidean_result, expected, decimal=1) def test_dtw(self): euclidean_result = dtw(Array( data=[[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4], [5, 5, 5, 5, 5]])).to_numpy() expected = np.array([[0, 0, 0, 0, 0], [5, 0, 0, 0, 0], [10, 5, 0, 0, 0], [15, 10, 5, 0, 0], [20, 15, 10, 5, 0]]) np.testing.assert_array_almost_equal(euclidean_result, expected, decimal=1) def test_hamming(self): result = hamming(Array( data=[[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4], [5, 5, 5, 5, 5]])).to_numpy() expected = np.array([[0, 0, 0, 0, 0], [5, 0, 0, 0, 0], [5, 5, 0, 0, 0], [5, 5, 5, 0, 0], [5, 5, 5, 5, 0]]) np.testing.assert_array_almost_equal(result, expected, decimal=1) def test_manhattan(self): result = manhattan(Array( data=[[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4], [5, 5, 5, 5, 5]])).to_numpy() expected = np.array([[0, 0, 0, 0, 0], [5, 0, 0, 0, 0], [10, 5, 0, 0, 0], [15, 10, 5, 0, 0], [20, 15, 10, 5, 0]]) np.testing.assert_array_almost_equal(result, expected, decimal=2) def test_sbd(self): sbd_result = sbd( Array(data=[[1, 2, 3, 4, 5], [1, 1, 0, 1, 1], [10, 12, 0, 0, 1]])).to_numpy().flatten() expected = np.array([0, 0, 0, 0.505025, 0, 0, 0.458583, 0.564093, 0]) np.testing.assert_array_almost_equal(sbd_result, expected, decimal=1) def test_squared_euclidean(self): squared_euclidean_result = squared_euclidean( Array(data=[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]])).to_numpy().flatten() expected = np.array([0, 0, 0, 64, 0, 0, 256, 64, 0]) np.testing.assert_array_almost_equal(squared_euclidean_result, expected, decimal=1) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(DistancesTest) unittest.TextTestRunner(verbosity=2).run(suite) khiva-python-0.2.2/tests/unit_tests/features_unit_tests.py000066400000000000000000000766171346407502000241720ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import unittest import numpy as np from khiva.features import * from khiva.array import Array, dtype from khiva.library import set_backend, KHIVABackend import arrayfire as af ######################################################################################################################## class FeaturesTest(unittest.TestCase): DELTA = 1e-6 def setUp(self): set_backend(KHIVABackend.KHIVA_BACKEND_CPU) def test_cid_ce(self): cid_ce_result = cid_ce(Array(data=[[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]), False).to_numpy() self.assertAlmostEqual(cid_ce_result[0], 2.23606797749979, delta=self.DELTA) self.assertAlmostEqual(cid_ce_result[1], 2.23606797749979, delta=self.DELTA) cid_ce_result = cid_ce(Array(data=[[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]), True).to_numpy() self.assertAlmostEqual(cid_ce_result[0], 1.30930734141595, delta=self.DELTA) self.assertAlmostEqual(cid_ce_result[1], 1.30930734141595, delta=self.DELTA) def test_c3(self): c3_result = c3(Array(data=[[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]), 2).to_numpy() self.assertEqual(c3_result[0], 7.5) self.assertEqual(c3_result[1], 586.5) def test_abs_sum_of_changes(self): abs_sum_of_changes_result = absolute_sum_of_changes( Array(data=[[0, 1, 2, 3], [4, 6, 8, 10], [11, 14, 17, 20]])).to_numpy() self.assertEqual(abs_sum_of_changes_result[0], 3) self.assertEqual(abs_sum_of_changes_result[1], 6) self.assertEqual(abs_sum_of_changes_result[2], 9) def test_abs_energy(self): abs_energy_result = abs_energy(Array(data=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10])).to_numpy() self.assertAlmostEqual(abs_energy_result, 385, delta=self.DELTA) def test_cross_correlation(self): cross_correlation_result = cross_correlation(xss=Array(data=[1, 2, 3, 4]), yss=Array(data=[4, 6, 8, 10, 12]), unbiased=False).to_numpy() self.assertAlmostEqual(cross_correlation_result[0], 0.790569415, delta=self.DELTA) self.assertAlmostEqual(cross_correlation_result[1], 0.790569415, delta=self.DELTA) self.assertAlmostEqual(cross_correlation_result[2], 0.079056941, delta=self.DELTA) self.assertAlmostEqual(cross_correlation_result[3], -0.395284707, delta=self.DELTA) self.assertAlmostEqual(cross_correlation_result[4], -0.474341649, delta=self.DELTA) def test_auto_covariance(self): auto_covariance_result = auto_covariance( Array(data=[[0, 1, 2, 3], [10, 11, 12, 13]])).to_numpy() self.assertAlmostEqual(auto_covariance_result[0][0], 1.25, delta=self.DELTA) self.assertAlmostEqual(auto_covariance_result[0][1], 0.3125, delta=self.DELTA) self.assertAlmostEqual(auto_covariance_result[0][2], -0.375, delta=self.DELTA) self.assertAlmostEqual(auto_covariance_result[0][3], -0.5625, delta=self.DELTA) self.assertAlmostEqual(auto_covariance_result[1][0], 1.25, delta=self.DELTA) self.assertAlmostEqual(auto_covariance_result[1][1], 0.3125, delta=self.DELTA) self.assertAlmostEqual(auto_covariance_result[1][2], -0.375, delta=self.DELTA) self.assertAlmostEqual(auto_covariance_result[1][3], -0.5625, delta=self.DELTA) def test_cross_covariance(self): cross_covariance_result = cross_covariance( xss=Array(data=[[0, 1, 2, 3], [10, 11, 12, 13]]), yss=Array(data=[[4, 6, 8, 10, 12], [14, 16, 18, 20, 22]]), unbiased=False).to_numpy().flatten() for i in range(4): self.assertAlmostEqual(cross_covariance_result[(i * 5)], 2.5, delta=self.DELTA) self.assertAlmostEqual(cross_covariance_result[(i * 5) + 1], 2.5, delta=self.DELTA) self.assertAlmostEqual(cross_covariance_result[(i * 5) + 2], 0.25, delta=self.DELTA) self.assertAlmostEqual(cross_covariance_result[(i * 5) + 3], -1.25, delta=self.DELTA) self.assertAlmostEqual(cross_covariance_result[(i * 5) + 4], -1.5, delta=self.DELTA) def test_approximate_entropy(self): approximate_entropy_result = approximate_entropy( Array(data=[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]], khiva_type=dtype.f32), 4, 0.5).to_numpy() self.assertAlmostEqual(approximate_entropy_result[0], 0.13484281753639338, delta=self.DELTA) self.assertAlmostEqual(approximate_entropy_result[1], 0.13484281753639338, delta=self.DELTA) def test_auto_correlation(self): auto_correlation_result = auto_correlation( Array(data=[[0, 1, 2, 3], [10, 11, 12, 13]]), 4, False).to_numpy().flatten() self.assertAlmostEqual(auto_correlation_result[0], 1, delta=self.DELTA) self.assertAlmostEqual(auto_correlation_result[1], 0.25, delta=self.DELTA) self.assertAlmostEqual(auto_correlation_result[2], -0.3, delta=self.DELTA) self.assertAlmostEqual(auto_correlation_result[3], -0.45, delta=self.DELTA) self.assertAlmostEqual(auto_correlation_result[4], 1.0, delta=self.DELTA) self.assertAlmostEqual(auto_correlation_result[5], 0.25, delta=self.DELTA) self.assertAlmostEqual(auto_correlation_result[6], -0.3, delta=self.DELTA) self.assertAlmostEqual(auto_correlation_result[7], -0.45, delta=self.DELTA) def test_binned_entropy(self): binned_entropy_result = binned_entropy(Array(data=[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], [1, 1, 3, 10, 5, 6, 1, 8, 9, 10, 11, 1, 13, 14, 10, 16, 17, 10, 19, 20]]), 5).to_numpy() self.assertAlmostEqual(binned_entropy_result[0], 1.6094379124341005, delta=self.DELTA) self.assertAlmostEqual(binned_entropy_result[1], 1.5614694247763998, delta=self.DELTA) def test_count_above_mean(self): count_above_mean_result = count_above_mean(Array(data=[[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]])).to_numpy() self.assertAlmostEqual(count_above_mean_result[0], 3, delta=self.DELTA) self.assertAlmostEqual(count_above_mean_result[1], 3, delta=self.DELTA) def test_count_below_mean(self): count_below_mean_result = count_below_mean(Array(data=[[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]])).to_numpy() self.assertAlmostEqual(count_below_mean_result[0], 3, delta=self.DELTA) self.assertAlmostEqual(count_below_mean_result[1], 3, delta=self.DELTA) def test_energy_ratio_by_chunks(self): energy_ratio_by_chunks_result = energy_ratio_by_chunks(Array([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]), 2, 0).to_numpy() self.assertAlmostEqual(energy_ratio_by_chunks_result[0], 0.090909091, delta=self.DELTA) self.assertAlmostEqual(energy_ratio_by_chunks_result[1], 0.330376940, delta=self.DELTA) energy_ratio_by_chunks_result = energy_ratio_by_chunks(Array([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]), 2, 1).to_numpy() self.assertAlmostEqual(energy_ratio_by_chunks_result[0], 0.909090909, delta=self.DELTA) self.assertAlmostEqual(energy_ratio_by_chunks_result[1], 0.669623060, delta=self.DELTA) def test_first_location_of_maximum(self): first_location_of_maximum_result = first_location_of_maximum( Array([[5, 4, 3, 5, 0, 1, 5, 3, 2, 1], [2, 4, 3, 5, 2, 5, 4, 3, 5, 2]])).to_numpy() self.assertAlmostEqual(first_location_of_maximum_result[0], 0.0, delta=self.DELTA) self.assertAlmostEqual(first_location_of_maximum_result[1], 0.3, delta=self.DELTA) def test_first_location_of_minimum(self): first_location_of_minimum_result = first_location_of_minimum( Array([[5, 4, 3, 0, 0, 1], [5, 4, 3, 0, 2, 1]])).to_numpy() self.assertAlmostEqual(first_location_of_minimum_result[0], 0.5, delta=self.DELTA) self.assertAlmostEqual(first_location_of_minimum_result[1], 0.5, delta=self.DELTA) def test_friedrich_coefficients(self): friedrich_coefficients_result = friedrich_coefficients( Array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]]), 4, 2).to_numpy() expected = np.array([[-0.0009912563255056738, -0.0027067768387496471, -0.00015192681166809052, 0.10512571036815643, 0.89872437715530396], [-0.0009912563255056738, -0.0027067768387496471, -0.00015192681166809052, 0.10512571036815643, 0.89872437715530396]]) np.testing.assert_array_almost_equal(friedrich_coefficients_result, expected, decimal=6) def test_has_duplicates(self): has_duplicates_result = has_duplicates( Array([[5, 4, 3, 0, 0, 1], [5, 4, 3, 0, 2, 1]])).to_numpy() self.assertEqual(has_duplicates_result[0], True) self.assertEqual(has_duplicates_result[1], False) def test_has_duplicate_max(self): has_duplicate_max_result = has_duplicate_max( Array([[5, 4, 3, 0, 5, 1], [5, 4, 3, 0, 2, 1]])).to_numpy() self.assertEqual(has_duplicate_max_result[0], True) self.assertEqual(has_duplicate_max_result[1], False) def test_index_mass_quantile(self): index_mass_quantile_result = index_mass_quantile(Array([[5, 4, 3, 0, 0, 1], [5, 4, 0, 0, 2, 1]]), 0.5).to_numpy() self.assertAlmostEqual(index_mass_quantile_result[0], 0.333333333, delta=self.DELTA) self.assertAlmostEqual(index_mass_quantile_result[1], 0.333333333, delta=self.DELTA) def test_kurtosis(self): kurtosis_result = kurtosis(Array([[0, 1, 2, 3, 4, 5], [2, 2, 2, 20, 30, 25]])).to_numpy() self.assertAlmostEqual(kurtosis_result[0], -1.2, delta=1e-4) self.assertAlmostEqual(kurtosis_result[1], -2.66226722, delta=1e-4) def test_large_standard_deviation(self): large_standard_deviation_result = large_standard_deviation( Array([[-1, -1, -1, 1, 1, 1], [4, 6, 8, 4, 5, 4]]), 0.4).to_numpy() self.assertEqual(large_standard_deviation_result[0], True) self.assertEqual(large_standard_deviation_result[1], False) def test_last_location_of_maximum(self): last_location_of_maximum_result = last_location_of_maximum( Array([[0, 4, 3, 5, 5, 1], [0, 4, 3, 2, 5, 1]])).to_numpy() self.assertAlmostEqual(last_location_of_maximum_result[0], 0.8333333333333334, delta=self.DELTA) self.assertAlmostEqual(last_location_of_maximum_result[1], 0.8333333333333334, delta=self.DELTA) def test_last_location_of_minimum(self): last_location_of_minimum_result = last_location_of_minimum( Array([[0, 4, 3, 5, 5, 1, 0, 4], [3, 2, 5, 1, 4, 5, 1, 2]])).to_numpy() self.assertAlmostEqual(last_location_of_minimum_result[0], 0.875, delta=self.DELTA) self.assertAlmostEqual(last_location_of_minimum_result[1], 0.875, delta=self.DELTA) def test_length(self): length_result = length(Array([[0, 4, 3, 5, 5, 1], [0, 4, 3, 2, 5, 1]])).to_numpy().flatten() self.assertEqual(length_result[0], 6) self.assertEqual(length_result[1], 6) def test_linear_trend(self): pvalue, rvalue, intercept, slope, stderr = linear_trend(Array([[0, 4, 3, 5, 5, 1], [2, 4, 1, 2, 5, 3]])) pvalue = pvalue.to_numpy() self.assertAlmostEqual(pvalue[0], 0.6260380997892747, delta=self.DELTA) self.assertAlmostEqual(pvalue[1], 0.5272201945463578, delta=self.DELTA) rvalue = rvalue.to_numpy() self.assertAlmostEqual(rvalue[0], 0.2548235957188128, delta=self.DELTA) self.assertAlmostEqual(rvalue[1], 0.3268228676411533, delta=self.DELTA) intercept = intercept.to_numpy() self.assertAlmostEqual(intercept[0], 2.2857142857142856, delta=self.DELTA) self.assertAlmostEqual(intercept[1], 2.1904761904761907, delta=self.DELTA) slope = slope.to_numpy() self.assertAlmostEqual(slope[0], 0.2857142857142857, delta=self.DELTA) self.assertAlmostEqual(slope[1], 0.2571428571428572, delta=self.DELTA) stderr = stderr.to_numpy() self.assertAlmostEqual(stderr[0], 0.5421047417431507, delta=self.DELTA) self.assertAlmostEqual(stderr[1], 0.37179469135129783, delta=self.DELTA) def test_has_duplicate_min(self): has_duplicate_min_result = has_duplicate_min( Array(data=[[5, 4, 3, 0, 0, 1], [5, 4, 3, 0, 2, 1]])).to_numpy() self.assertEqual(has_duplicate_min_result[0], True) self.assertEqual(has_duplicate_min_result[1], False) def test_longest_strike_above_mean(self): longest_strike_above_mean_result = longest_strike_above_mean( Array(data=[[20, 20, 20, 1, 1, 1, 20, 20, 20, 20, 1, 1, 1, 1, 1, 1, 1, 1, 20, 20], [20, 20, 20, 1, 1, 1, 20, 20, 20, 1, 1, 1, 1, 1, 1, 1, 1, 1, 20, 20]])).to_numpy() self.assertEqual(longest_strike_above_mean_result[0], 4) self.assertEqual(longest_strike_above_mean_result[1], 3) def test_longest_strike_below_mean(self): longest_strike_below_mean_result = longest_strike_below_mean( Array([[20, 20, 20, 1, 1, 1, 20, 20, 20, 20, 1, 1, 1, 1, 1, 1, 1, 1, 20, 20], [20, 20, 20, 1, 1, 1, 20, 20, 20, 1, 1, 1, 1, 1, 1, 1, 1, 1, 20, 20]], dtype.f32)).to_numpy() self.assertEqual(longest_strike_below_mean_result[0], 8) self.assertEqual(longest_strike_below_mean_result[1], 9) def test_maximum(self): maximum_result = maximum(Array([[20, 20, 20, 18, 25, 19, 20, 20, 20, 20, 40, 30, 1, 50, 1, 1, 5, 1, 20, 20], [20, 20, 20, 2, 19, 1, 20, 20, 20, 1, 15, 1, 30, 1, 1, 18, 4, 1, 20, 20]])).to_numpy() self.assertEqual(maximum_result[0], 50) self.assertEqual(maximum_result[1], 30) def test_mean_absolute_change(self): mean_absolute_change_result = mean_absolute_change( Array([[0, 1, 2, 3, 4, 5], [8, 10, 12, 14, 16, 18]])).to_numpy() r = 5.0 / 6.0 self.assertAlmostEqual(mean_absolute_change_result[0], r, delta=self.DELTA) self.assertAlmostEqual(mean_absolute_change_result[1], r * 2, delta=self.DELTA) def test_fft_coefficient(self): fftCoefficient_result = fft_coefficient( Array([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]), 0) a = fftCoefficient_result[0].to_numpy() self.assertAlmostEqual(a[0], 15, delta=self.DELTA) self.assertAlmostEqual(a[1], 51, delta=self.DELTA) b = fftCoefficient_result[1].to_numpy() self.assertAlmostEqual(b[0], 0, delta=self.DELTA) self.assertAlmostEqual(b[1], 0, delta=self.DELTA) c = fftCoefficient_result[2].to_numpy() self.assertAlmostEqual(c[0], 15, delta=self.DELTA) self.assertAlmostEqual(c[1], 51, delta=self.DELTA) d = fftCoefficient_result[3].to_numpy() self.assertAlmostEqual(d[0], 0, delta=self.DELTA) self.assertAlmostEqual(d[1], 0, delta=self.DELTA) def test_aggregated_autocorrelation_mean(self): aggregated_autocorrelation_result = aggregated_autocorrelation( Array([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]]), 0).to_numpy() self.assertAlmostEqual(aggregated_autocorrelation_result[0], -0.6571428571428571, delta=self.DELTA) self.assertAlmostEqual(aggregated_autocorrelation_result[1], -0.6571428571428571, delta=self.DELTA) def test_aggregated_autocorrelation_median(self): aggregated_autocorrelation_result = aggregated_autocorrelation( Array([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]]), 1).to_numpy() self.assertAlmostEqual(aggregated_autocorrelation_result[0], -0.54285717010498047, delta=self.DELTA) self.assertAlmostEqual(aggregated_autocorrelation_result[1], -0.54285717010498047, delta=self.DELTA) def test_aggregated_autocorrelation_min(self): aggregated_autocorrelation_result = aggregated_autocorrelation( Array([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]]), 2).to_numpy() self.assertAlmostEqual(aggregated_autocorrelation_result[0], -2.142857142857143, delta=1e-4) self.assertAlmostEqual(aggregated_autocorrelation_result[1], -2.142857142857143, delta=1e-4) def test_aggregated_autocorrelation_max(self): aggregated_autocorrelation_result = aggregated_autocorrelation( Array([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]]), 3).to_numpy() self.assertAlmostEqual(aggregated_autocorrelation_result[0], 0.6, delta=self.DELTA) self.assertAlmostEqual(aggregated_autocorrelation_result[1], 0.6, delta=self.DELTA) def test_aggregated_autocorrelation_stdev(self): aggregated_autocorrelation_result = aggregated_autocorrelation( Array([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]]), 4).to_numpy() self.assertAlmostEqual(aggregated_autocorrelation_result[0], 0.9744490855905009, delta=self.DELTA) self.assertAlmostEqual(aggregated_autocorrelation_result[1], 0.9744490855905009, delta=self.DELTA) def test_aggregated_autocorrelation_var(self): aggregated_autocorrelation_result = aggregated_autocorrelation( Array([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]]), 5).to_numpy() self.assertAlmostEqual(aggregated_autocorrelation_result[0], 0.9495510204081633, delta=self.DELTA) self.assertAlmostEqual(aggregated_autocorrelation_result[1], 0.9495510204081633, delta=self.DELTA) def test_aggregated_linear_trend_mean(self): aggregated_linear_trend_result = aggregated_linear_trend( Array([[2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5]]), 3, 0) self.assertAlmostEqual(aggregated_linear_trend_result[0].to_numpy(), 1, delta=self.DELTA) self.assertAlmostEqual(aggregated_linear_trend_result[1].to_numpy(), 2, delta=self.DELTA) self.assertAlmostEqual(aggregated_linear_trend_result[2].to_numpy(), 1, delta=self.DELTA) self.assertAlmostEqual(aggregated_linear_trend_result[3].to_numpy(), 0, delta=self.DELTA) self.assertAlmostEqual(aggregated_linear_trend_result[4].to_numpy(), 0, delta=self.DELTA) def test_aggregated_linear_trend_min(self): aggregated_linear_trend_result = aggregated_linear_trend( Array([2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5]), 3, 2) self.assertAlmostEqual(aggregated_linear_trend_result[0].to_numpy(), 1, delta=1e-3) self.assertAlmostEqual(aggregated_linear_trend_result[1].to_numpy(), 2, delta=1e-3) self.assertAlmostEqual(aggregated_linear_trend_result[2].to_numpy(), 1, delta=1e-3) self.assertAlmostEqual(aggregated_linear_trend_result[3].to_numpy(), 0, delta=1e-3) self.assertAlmostEqual(aggregated_linear_trend_result[4].to_numpy(), 0, delta=1e-3) def test_cwt_coefficients(self): cwt_coefficients_result = cwt_coefficients(Array([[0.1, 0.2, 0.3], [0.1, 0.2, 0.3]]), Array(data=[1, 2, 3], khiva_type=dtype.s32), 2, 2).to_numpy() self.assertAlmostEqual(cwt_coefficients_result[0], 0.26517161726951599, delta=self.DELTA) self.assertAlmostEqual(cwt_coefficients_result[1], 0.26517161726951599, delta=self.DELTA) def test_mean_second_derivative_central(self): mean_second_derivative_central_result = mean_second_derivative_central( Array([[1, 3, 7, 4, 8], [2, 5, 1, 7, 4]])).to_numpy() self.assertAlmostEqual(mean_second_derivative_central_result[0], 1.0 / 5.0, delta=self.DELTA) self.assertAlmostEqual(mean_second_derivative_central_result[1], -3.0 / 5.0, delta=self.DELTA) def test_minimum(self): minimum_result = minimum( Array([[20, 20, 20, 18, 25, 19, 20, 20, 20, 20, 40, 30, 1, 50, 13, 15, 5, 16, 20, 20], [20, 20, 20, 2, 19, 4, 20, 20, 20, 4, 15, 6, 30, 7, 9, 18, 4, 10, 20, 20]])).to_numpy() self.assertAlmostEqual(minimum_result[0], 1, delta=self.DELTA) self.assertAlmostEqual(minimum_result[1], 2, delta=self.DELTA) def test_number_crossing_m(self): number_crossing_m_result = number_crossing_m( Array([[1, 2, 1, 1, -3, -4, 7, 8, 9, 10, -2, 1, -3, 5, 6, 7, -10], [1, 2, 1, 1, -3, -4, 7, 8, 9, 10, -2, 1, -3, 5, 6, 7, -10]]), 0).to_numpy() self.assertAlmostEqual(number_crossing_m_result[0], 7, delta=self.DELTA) self.assertAlmostEqual(number_crossing_m_result[1], 7, delta=self.DELTA) def test_mean(self): mean_result = mean(Array([[20, 20, 20, 18, 25, 19, 20, 20, 20, 20, 40, 30, 1, 50, 1, 1, 5, 1, 20, 20], [20, 20, 20, 2, 19, 1, 20, 20, 20, 1, 15, 1, 30, 1, 1, 18, 4, 1, 20, 20]])).to_numpy() self.assertAlmostEqual(mean_result[0], 18.55, delta=1e-4) self.assertAlmostEqual(mean_result[1], 12.7, delta=1e-4) def test_median(self): median_result = median(Array([[20, 20, 20, 18, 25, 19, 20, 20, 20, 20, 40, 30, 1, 50, 1, 1, 5, 1, 20, 20], [20, 20, 20, 2, 19, 1, 20, 20, 20, 1, 15, 1, 30, 1, 1, 18, 4, 1, 20, 20]])).to_numpy() self.assertAlmostEqual(median_result[0], 20, delta=self.DELTA) self.assertAlmostEqual(median_result[1], 18.5, delta=self.DELTA) def test_mean_change(self): mean_change_result = mean_change(Array([[0, 1, 2, 3, 4, 5], [8, 10, 12, 14, 16, 18]])).to_numpy() self.assertAlmostEqual(mean_change_result[0], 5.0 / 6.0, delta=self.DELTA) self.assertAlmostEqual(mean_change_result[1], 10.0 / 6.0, delta=self.DELTA) def test_max_langevin_fixed_point(self): max_langevin_fixed_point_result = max_langevin_fixed_point( Array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]]), 7, 2).to_numpy() self.assertAlmostEqual(max_langevin_fixed_point_result[0], 4.562970585, delta=1e-4) self.assertAlmostEqual(max_langevin_fixed_point_result[1], 4.562970585, delta=1e-4) def test_fft_aggregated(self): fft_aggregated_result = fft_aggregated( Array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], dtype.f32)).to_numpy().flatten() self.assertAlmostEqual(fft_aggregated_result[0], 1.135143, delta=1e-4) self.assertAlmostEqual(fft_aggregated_result[1], 2.368324, delta=1e-4) self.assertAlmostEqual(fft_aggregated_result[2], 1.248777, delta=1e-4) self.assertAlmostEqual(fft_aggregated_result[3], 3.642666, delta=1e-4) self.assertAlmostEqual(fft_aggregated_result[4], 1.135143, delta=1e-4) self.assertAlmostEqual(fft_aggregated_result[5], 2.368324, delta=1e-4) self.assertAlmostEqual(fft_aggregated_result[6], 1.248777, delta=1e-4) self.assertAlmostEqual(fft_aggregated_result[7], 3.642666, delta=1e-4) def test_number_cwt_peaks(self): result = number_cwt_peaks(Array([[1, 1, 1, 1, 1, 1, 1, 5, 1, 1, 1, 1, 1, 1, 5, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 5, 1, 1, 1, 1, 1, 1, 5, 1, 1, 1, 1, 1, 1]]), 2).to_numpy() self.assertEqual(result[0], 2) self.assertEqual(result[1], 2) def test_number_peaks(self): result = number_peaks(Array([[3, 0, 0, 4, 0, 0, 13], [3, 0, 0, 4, 0, 0, 13]]), 2).to_numpy() self.assertAlmostEqual(result[0], 1, delta=1e-4) self.assertAlmostEqual(result[1], 1, delta=1e-4) def test_partial_autocorrelation(self): numel = 3000.0 step = 1 / (numel - 1) a = [step * i for i in range(int(numel))] a = Array([a, a]) lags = Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], khiva_type=dtype.s32) result = partial_autocorrelation(a, lags).to_numpy() expected = np.array([[1.0, 0.9993331432342529, -0.0006701064994559, -0.0006701068487018, -0.0008041285327636, -0.0005360860959627, -0.0007371186511591, -0.0004690756904893, -0.0008041299879551, -0.0007371196406893], [1.0, 0.9993331432342529, -0.0006701064994559, -0.0006701068487018, -0.0008041285327636, -0.0005360860959627, -0.0007371186511591, -0.0004690756904893, -0.0008041299879551, -0.0007371196406893]]) np.testing.assert_array_almost_equal(result, expected, decimal=3) def test_percentage_of_reocurring_datapoints_to_all_datapoints(self): result = percentage_of_reoccurring_datapoints_to_all_datapoints( Array([[3, 0, 0, 4, 0, 0, 13], [3, 0, 0, 4, 0, 0, 13]]), False).to_numpy() self.assertAlmostEqual(result[0], 0.25, delta=1e-4) self.assertAlmostEqual(result[1], 0.25, delta=1e-4) def test_percentage_of_reocurring_values_to_all_values(self): result = percentage_of_reoccurring_values_to_all_values( Array([[1, 1, 2, 3, 4, 4, 5, 6], [1, 2, 2, 3, 4, 5, 6, 7]]), False).to_numpy() self.assertEqual(result[0], 4.0 / 8.0) self.assertEqual(result[1], 2.0 / 8.0) def test_quantile(self): result = quantile(Array([[0, 0, 0, 0, 3, 4, 13], [0, 0, 0, 0, 3, 4, 13]]), Array([0.6], dtype.f32)).to_numpy() self.assertAlmostEqual(result[0], 1.79999999, delta=1e-4) self.assertAlmostEqual(result[1], 1.79999999, delta=1e-4) def test_range_count(self): result = range_count(Array([[3, 0, 0, 4, 0, 0, 13], [3, 0, 5, 4, 0, 0, 13]]), 2, 12).to_numpy() self.assertEqual(result[0], 2) self.assertEqual(result[1], 3) def test_ratio_beyond_r_sigma(self): result = ratio_beyond_r_sigma(Array([[3, 0, 0, 4, 0, 0, 13], [3, 0, 0, 4, 0, 0, 13]]), 0.5).to_numpy() self.assertAlmostEqual(result[0], 0.7142857142857143, delta=1e-4) self.assertAlmostEqual(result[1], 0.7142857142857143, delta=1e-4) def test_ratio_value_number_to_time_series_length(self): result = ratio_value_number_to_time_series_length( Array([[3, 0, 0, 4, 0, 0, 13], [3, 5, 0, 4, 6, 0, 13]])).to_numpy() self.assertAlmostEqual(result[0], 4.0 / 7.0, delta=1e-4) self.assertAlmostEqual(result[1], 6.0 / 7.0, delta=1e-4) def test_sample_entropy(self): result = sample_entropy(Array([[3, 0, 0, 4, 0, 0, 13], [3, 0, 0, 4, 0, 0, 13]])).to_numpy() self.assertAlmostEqual(result[0], 1.2527629, delta=1e-4) self.assertAlmostEqual(result[1], 1.2527629, delta=1e-4) def test_skewness(self): result = skewness(Array([[3, 0, 0, 4, 0, 0, 13], [3, 0, 0, 4, 0, 0, 13]])).to_numpy() self.assertAlmostEqual(result[0], 2.038404735373753, delta=1e-4) self.assertAlmostEqual(result[1], 2.038404735373753, delta=1e-4) def test_spkt_welch_density(self): result = spkt_welch_density(Array([[0, 1, 1, 3, 4, 5, 6, 7, 8, 9], [0, 1, 1, 3, 4, 5, 6, 7, 8, 9]]), 0).to_numpy() self.assertAlmostEqual(result[0], 1.6666667, delta=1e-5) self.assertAlmostEqual(result[1], 1.6666667, delta=1e-5) def test_standard_deviation(self): result = standard_deviation( Array([[20, 20, 20, 18, 25, 19, 20, 20, 20, 20, 40, 30, 1, 50, 1, 1, 5, 1, 20, 20], [20, 20, 20, 2, 19, 1, 20, 20, 20, 1, 15, 1, 30, 1, 1, 18, 4, 1, 20, 20]])).to_numpy() self.assertAlmostEqual(result[0], 12.363150892875165, delta=1e-4) self.assertAlmostEqual(result[1], 9.51367436903324, delta=1e-4) def test_sum_of_reoccurring_datapoints(self): result = sum_of_reoccurring_datapoints(Array([[3, 3, 0, 4, 0, 13, 13], [3, 3, 0, 4, 0, 13, 13]])).to_numpy() self.assertEqual(result[0], 32) self.assertEqual(result[1], 32) def test_sum_of_reoccurring_values(self): result = sum_of_reoccurring_values(Array([[4, 4, 6, 6, 7], [4, 7, 7, 8, 8]])).to_numpy() self.assertEqual(result[0], 10) self.assertEqual(result[1], 15) def test_sum_values(self): result = sum_values(Array([[1, 2, 3, 4.1], [-1.2, -2, -3, -4]])).to_numpy() self.assertAlmostEqual(result[0], 10.1, delta=self.DELTA) self.assertAlmostEqual(result[1], -10.2, delta=self.DELTA) def test_symmetry_looking(self): result = symmetry_looking(Array([[20, 20, 20, 18, 25, 19, 20, 20, 20, 20, 40, 30, 1, 50, 1, 1, 5, 1, 20, 20], [20, 20, 20, 2, 19, 1, 20, 20, 20, 1, 15, 1, 30, 1, 1, 18, 4, 1, 20, 20]]), 0.1).to_numpy() self.assertEqual(result[0], bool(1)) self.assertEqual(result[1], bool(0)) def test_time_reversal_asymmetry_statistic(self): result = time_reversal_asymmetry_statistic(Array( [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], [20, 20, 20, 2, 19, 1, 20, 20, 20, 1, 15, 1, 30, 1, 1, 18, 4, 1, 20, 20]]), 2).to_numpy() self.assertEqual(result[0], 1052) self.assertEqual(result[1], -150.625) def test_value_count(self): result = value_count(Array(data=[[20, 20, 20, 18, 25, 19, 20, 20, 20, 20, 40, 30, 1, 50, 1, 1, 5, 1, 20, 20], [20, 20, 20, 2, 19, 1, 20, 20, 20, 1, 15, 1, 30, 1, 1, 18, 4, 1, 20, 20]]), 20).to_numpy() self.assertAlmostEqual(result[0], 9, delta=1e-4) self.assertAlmostEqual(result[1], 8, delta=1e-4) def test_variance(self): result = variance(Array(data=[[1, 1, -1, -1], [1, 2, -2, -1]])).to_numpy() self.assertEqual(result[0], 1) self.assertEqual(result[1], 2.5) def test_variance_larger_than_standard_deviation(self): result = variance_larger_than_standard_deviation( Array(data=[[20, 20, 20, 18, 25, 19, 20, 20, 20, 20, 40, 30, 1, 50, 1, 1, 5, 1, 20, 20], [20, 20, 20, 2, 19, 1, 20, 20, 20, 1, 15, 1, 30, 1, 1, 18, 4, 1, 20, 20]])).to_numpy() self.assertEqual(result[0], True) self.assertEqual(result[1], True) def test_concatenated(self): a = Array([[1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [1, 8], [1, 9], [1, 10], [1, 11]]) b = absolute_sum_of_changes(a).to_arrayfire() c = af.transpose(b) d = Array.from_arrayfire(c) e = abs_energy(d).to_numpy() self.assertAlmostEqual(e, 385, delta=self.DELTA) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(FeaturesTest) unittest.TextTestRunner(verbosity=2).run(suite) khiva-python-0.2.2/tests/unit_tests/library_unit_tests.py000066400000000000000000000076021346407502000240040ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import unittest import re import os import requests from khiva.library import * ######################################################################################################################## class LibraryTest(unittest.TestCase): def setUp(self): pass def test_get_backend_info(self): info = get_backend_info() word = info.split()[0] self.assertEqual(word, "ArrayFire") def test_set_backend(self): backends = get_backends() cuda = backends & KHIVABackend.KHIVA_BACKEND_CUDA.value opencl = backends & KHIVABackend.KHIVA_BACKEND_OPENCL.value cpu = backends & KHIVABackend.KHIVA_BACKEND_CPU.value b = get_backend() if cuda: set_backend(KHIVABackend.KHIVA_BACKEND_CUDA) self.assertEqual(get_backend(), KHIVABackend.KHIVA_BACKEND_CUDA) set_backend(b) if opencl: set_backend(KHIVABackend.KHIVA_BACKEND_OPENCL) self.assertEqual(get_backend(), KHIVABackend.KHIVA_BACKEND_OPENCL) set_backend(b) if cpu: set_backend(KHIVABackend.KHIVA_BACKEND_CPU) self.assertEqual(get_backend(), KHIVABackend.KHIVA_BACKEND_CPU) set_backend(b) def test_get_device(self): backends = get_backends() cuda = backends & KHIVABackend.KHIVA_BACKEND_CUDA.value opencl = backends & KHIVABackend.KHIVA_BACKEND_OPENCL.value cpu = backends & KHIVABackend.KHIVA_BACKEND_CPU.value if cuda: set_backend(KHIVABackend.KHIVA_BACKEND_CUDA) for i in range(get_device_count()): set_device(i) self.assertEqual(get_device_id(), i) if opencl: set_backend(KHIVABackend.KHIVA_BACKEND_OPENCL) for i in range(get_device_count()): set_device(i) self.assertEqual(get_device_id(), i) if cpu: set_backend(KHIVABackend.KHIVA_BACKEND_CPU) for i in range(get_device_count()): set_device(i) self.assertEqual(get_device_id(), i) def test_version(self): self.assertEqual(version(), self.get_khiva_version_from_file()) def get_khiva_version_from_github(self): # Hit Github API to get the list of tags. r = requests.get('https://api.github.com/repos/shapelets/khiva/tags') tag_name = '0.2.0' if r.status_code == 200: response = r.json() number_tags = len(response) tag_name = response[number_tags - 1]['name'] # Remove symbols from numbering tag_name = tag_name.replace('v', '') tag_name = tag_name.replace('-RC', '') return tag_name def get_khiva_version_from_file(self): version = "" if os.name == 'nt': path_file = "C:/Program Files/Khiva/v0/include/khiva/version.h" else: path_file = "/usr/local/include/khiva/version.h" version_file = open(path_file, "rt") contents = version_file.read() version_file.close() regex = r'([0-9]+\.[0-9]+\.[0-9]+)' match = re.search(regex, contents) if match: version = match.group(1) return version if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(LibraryTest) unittest.TextTestRunner(verbosity=2).run(suite) khiva-python-0.2.2/tests/unit_tests/linalg_unit_tests.py000066400000000000000000000024451346407502000236060ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import unittest from khiva.linalg import * from khiva.array import * from khiva.library import set_backend, KHIVABackend ######################################################################################################################## class LinalgTest(unittest.TestCase): DELTA = 1e-6 def setUp(self): set_backend(KHIVABackend.KHIVA_BACKEND_CPU) def test_lls(self): lls_result = lls(Array(np.array([[4, 3], [-1, -2]])), Array([3, 1], dtype.f32)) a = lls_result.to_numpy() self.assertAlmostEqual(a[0], 1, delta=self.DELTA) self.assertAlmostEqual(a[1], 1, delta=self.DELTA) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(LinalgTest) unittest.TextTestRunner(verbosity=2).run(suite) khiva-python-0.2.2/tests/unit_tests/matrix_unit_tests.py000066400000000000000000000171401346407502000236420ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import unittest import os from khiva.matrix import * from khiva.array import * from khiva.library import set_backend, KHIVABackend ######################################################################################################################## class MatrixTest(unittest.TestCase): DELTA = 1e-6 DECIMAL = 6 def setUp(self): set_backend(KHIVABackend.KHIVA_BACKEND_CPU) def test_stomp_self_join(self): stomp_self_join_result = stomp_self_join( Array(data=[[10, 10, 11, 11, 10, 11, 10, 10, 11, 11, 10, 11, 10, 10], [ 11, 10, 10, 11, 10, 11, 11, 10, 11, 11, 10, 10, 11, 10]]), 3) expected_index = [6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 9, 10, 11, 6, 7, 8, 3, 4, 5, 0, 1, 2] for i in range(6): self.assertAlmostEqual(stomp_self_join_result[0].to_numpy()[0][i], 0.0, delta=1e-2) self.assertEqual(stomp_self_join_result[1].to_numpy()[0][i], expected_index[i]) def test_stomp(self): stomp_result = stomp(Array([[10, 11, 10, 11], [10, 11, 10, 11]]), Array([[10, 11, 10, 11, 10, 11, 10, 11], [10, 11, 10, 11, 10, 11, 10, 11]]), 3) expected_index = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1] a = stomp_result[0].to_numpy().flatten() b = stomp_result[1].to_numpy().flatten() for i in range(24): self.assertAlmostEqual(a[i], 0, delta=1e-2) self.assertAlmostEqual(b[i], expected_index[i]) def test_find_best_n_motifs(self): stomp_result = stomp(Array([10, 10, 10, 10, 10, 10, 9, 10, 10, 10, 10, 10, 11, 10, 9], dtype.f32), Array([10, 11, 10, 9], dtype.f32), 3) find_best_n_motifs_result = find_best_n_motifs(stomp_result[0], stomp_result[1], 3, 1) a = find_best_n_motifs_result[1].to_numpy() b = find_best_n_motifs_result[2].to_numpy() self.assertAlmostEqual(a, 12, delta=self.DELTA) self.assertAlmostEqual(b, 1, delta=self.DELTA) def test_find_best_n_motifs_multiple_profiles(self): stomp_result = stomp(Array([[10, 10, 10, 10, 10, 10, 9, 10, 10, 10, 10, 10, 11, 10, 9], [10, 10, 10, 10, 10, 10, 9, 10, 10, 10, 10, 10, 11, 10, 9]], dtype.f32), Array([[10, 11, 10, 9], [10, 11, 10, 9]], dtype.f32), 3) find_best_n_motifs_result = find_best_n_motifs(stomp_result[0], stomp_result[1], 3, 1) a = find_best_n_motifs_result[1].to_numpy() b = find_best_n_motifs_result[2].to_numpy() np.testing.assert_array_almost_equal(a, np.array([[12, 12], [12, 12]]), decimal=self.DECIMAL) np.testing.assert_array_almost_equal(b, np.array([[1, 1], [1, 1]]), decimal=self.DECIMAL) def test_find_best_n_motifs_mirror(self): stomp_result = stomp_self_join(Array([10.1, 11, 10.2, 10.15, 10.775, 10.1, 11, 10.2], dtype.f32), 3) find_best_n_motifs_result = find_best_n_motifs(stomp_result[0], stomp_result[1], 3, 2, True) a = find_best_n_motifs_result[1].to_numpy() b = find_best_n_motifs_result[2].to_numpy() self.assertAlmostEqual(a[0], 0, delta=self.DELTA) self.assertAlmostEqual(a[1], 0, delta=self.DELTA) self.assertAlmostEqual(b[0], 5, delta=self.DELTA) self.assertAlmostEqual(b[1], 3, delta=self.DELTA) def test_find_best_n_motifs_consecutive(self): stomp_result = stomp_self_join(Array([10.1, 11, 10.1, 10.15, 10.075, 10.1, 11, 10.1, 10.15], dtype.f32), 3) find_best_n_motifs_result = find_best_n_motifs(stomp_result[0], stomp_result[1], 3, 2) a = find_best_n_motifs_result[1].to_numpy() b = find_best_n_motifs_result[2].to_numpy() self.assertAlmostEqual(a[1], 6, delta=self.DELTA) self.assertAlmostEqual(b[1], 3, delta=self.DELTA) def test_find_best_n_discords(self): stomp_result = stomp(Array(np.array([11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11])), Array(np.array([9, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 9])), 3) find_best_n_discords_result = find_best_n_discords(stomp_result[0], stomp_result[1], 3, 2) a = find_best_n_discords_result[2].to_numpy() self.assertEqual(a[0], 0) # The test failed in the CPU used in the Travis CI build machine if os.environ.get("TRAVIS") == "true": self.assertEqual(a[1], 2) else: self.assertEqual(a[1], 10) def test_find_best_n_discords_multiple_profiles(self): stomp_result = stomp(Array(np.array([[11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11], [11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11]])), Array(np.array([[9, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 9], [9, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 9]])), 3) find_best_n_discords_result = find_best_n_discords(stomp_result[0], stomp_result[1], 3, 2) a = find_best_n_discords_result[2].to_numpy() # The test failed in the CPU used in the Travis CI build machine if os.environ.get("TRAVIS") == "true": np.testing.assert_array_almost_equal(a, np.array([[[0, 2], [0, 2]], [[0, 2], [0, 2]]]), decimal=self.DECIMAL) else: np.testing.assert_array_almost_equal(a, np.array([[[0, 10], [0, 10]], [[0, 10], [0, 10]]]), decimal=self.DECIMAL) def test_find_best_n_discords_mirror(self): stomp_result = stomp_self_join(Array(np.array([10, 11, 10, 10, 11, 10])), 3) find_best_n_discords_result = find_best_n_discords(stomp_result[0], stomp_result[1], 3, 1, True) a = find_best_n_discords_result[1].to_numpy() b = find_best_n_discords_result[2].to_numpy() self.assertEqual(a, 3) self.assertEqual(b, 1) def test_find_best_n_discords_consecutive(self): stomp_result = stomp_self_join( Array(np.array([10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 9.999, 9.998]), dtype.f32), 3) find_best_n_discords_result = find_best_n_discords(stomp_result[0], stomp_result[1], 3, 2, True) a = find_best_n_discords_result[2].to_numpy() self.assertEqual(a[0], 12) # The test failed in the CPU used in the Travis CI build machine if os.environ.get("TRAVIS") == "true": self.assertEqual(a[1], 11) else: self.assertNotEqual(a[1], 11) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(MatrixTest) unittest.TextTestRunner(verbosity=2).run(suite) khiva-python-0.2.2/tests/unit_tests/normalization_unit_tests.py000066400000000000000000000103541346407502000252240ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import unittest import numpy as np from khiva.normalization import * from khiva.array import Array from khiva.library import set_backend, KHIVABackend ######################################################################################################################## class NormalizationTest(unittest.TestCase): DELTA = 1e-6 DECIMAL = 6 def setUp(self): set_backend(KHIVABackend.KHIVA_BACKEND_CPU) def test_znorm(self): znorm_result = znorm(Array([[0, 1, 2, 3], [4, 5, 6, 7]]), 0.00000001).to_numpy().flatten() expected = [-1.341640786499870, -0.447213595499958, 0.447213595499958, 1.341640786499870] for i in range(len(expected)): self.assertAlmostEqual(znorm_result[i], expected[i], delta=self.DELTA) self.assertAlmostEqual(znorm_result[i + 4], expected[i], delta=self.DELTA) def test_znorm_in_place(self): tss = Array(data=[[0, 1, 2, 3], [4, 5, 6, 7]]) znorm_in_place(tss) tss = tss.to_numpy() self.assertAlmostEqual(tss[0][0], -1.341640786499870, delta=self.DELTA) self.assertAlmostEqual(tss[0][1], -0.447213595499958, delta=self.DELTA) self.assertAlmostEqual(tss[0][2], 0.447213595499958, delta=self.DELTA) self.assertAlmostEqual(tss[0][3], 1.341640786499870, delta=self.DELTA) self.assertAlmostEqual(tss[1][0], -1.341640786499870, delta=self.DELTA) self.assertAlmostEqual(tss[1][1], -0.447213595499958, delta=self.DELTA) self.assertAlmostEqual(tss[1][2], 0.447213595499958, delta=self.DELTA) self.assertAlmostEqual(tss[1][3], 1.341640786499870, delta=self.DELTA) def test_max_min_norm(self): max_min_norm_result = max_min_norm(Array([[0, 1, 2, 3], [4, 5, 6, 7]]), 2.0, 1.0).to_numpy() expected = np.array([[1.0, 1.3333333333333, 1.66666667, 2.0], [1.0, 1.3333333333333, 1.66666667, 2.0]]) np.testing.assert_array_almost_equal(max_min_norm_result, expected, decimal=self.DECIMAL) def test_max_min_norm_in_place(self): tss = Array([[0, 1, 2, 3], [4, 5, 6, 7]]) max_min_norm_in_place(tss, 2.0, 1.0) tss = tss.to_numpy() expected = np.array([[1.0, 1.3333333333333, 1.66666667, 2.0], [1.0, 1.3333333333333, 1.66666667, 2.0]]) np.testing.assert_array_almost_equal(tss, expected, decimal=self.DECIMAL) def test_decimal_scaling_norm(self): decimal_scaling_norm_result = decimal_scaling_norm(Array([[0, 1, -2, 3], [40, 50, 60, -70]])).to_numpy() expected = np.array([[0.0, 0.1, -0.2, 0.3], [0.4, 0.5, 0.6, -0.7]]) np.testing.assert_array_almost_equal(decimal_scaling_norm_result, expected, decimal=self.DECIMAL) def test_decimal_scaling_norm_in_place(self): tss = Array([[0, 1, -2, 3], [40, 50, 60, -70]]) decimal_scaling_norm_in_place(tss) tss = tss.to_numpy() expected = np.array([[0.0, 0.1, -0.2, 0.3], [0.4, 0.5, 0.6, -0.7]]) np.testing.assert_array_almost_equal(tss, expected, decimal=self.DECIMAL) def test_mean_norm(self): result = mean_norm(Array([[0, 1, 2, 3], [4, 5, 6, 7]])).to_numpy() expected = np.array([[-0.5, -0.166666667, 0.166666667, 0.5], [-0.5, -0.166666667, 0.166666667, 0.5]]) np.testing.assert_array_almost_equal(result, expected, decimal=self.DECIMAL) def test_mean_norm_in_place(self): a = Array([[0, 1, 2, 3], [4, 5, 6, 7]]) mean_norm_in_place(a) expected = np.array([[-0.5, -0.166666667, 0.166666667, 0.5], [-0.5, -0.166666667, 0.166666667, 0.5]]) np.testing.assert_array_almost_equal(a.to_numpy(), expected, decimal=self.DECIMAL) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(NormalizationTest) unittest.TextTestRunner(verbosity=2).run(suite) khiva-python-0.2.2/tests/unit_tests/polynomial_unit_tests.py000066400000000000000000000037051346407502000245230ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import unittest import numpy as np from khiva.polynomial import * from khiva.array import Array from khiva.library import set_backend, KHIVABackend ######################################################################################################################## class PolynomialTest(unittest.TestCase): DELTA = 1e-6 DECIMAL = 6 def setUp(self): set_backend(KHIVABackend.KHIVA_BACKEND_CPU) def test_polyfit1(self): polyfit_result = polyfit(Array([0, 1, 2, 3, 4, 5]), Array([0, 1, 2, 3, 4, 5]), 1).to_numpy() expected = np.array([1.0, 0.0]) np.testing.assert_array_almost_equal(polyfit_result, expected, decimal=self.DECIMAL) def test_polyfit3(self): polyfit_result = polyfit(Array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0]), Array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0]), 3).to_numpy() expected = np.array([0.08703704, -0.81349206, 1.69312169, -0.03968254]) np.testing.assert_array_almost_equal(polyfit_result, expected, decimal=self.DECIMAL - 1) def test_roots(self): roots_result = roots(Array([5, -20, 5, 50, -20, -40])).to_numpy() expected = np.array([2 + 0j, 2 + 0j, 2 + 0j, -1 + 0j, -1 + 0j]) np.testing.assert_array_almost_equal(roots_result, expected, decimal=2) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(PolynomialTest) unittest.TextTestRunner(verbosity=2).run(suite) khiva-python-0.2.2/tests/unit_tests/regression_unit_tests.py000066400000000000000000000073721346407502000245240ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import unittest from khiva.regression import * from khiva.array import Array from khiva.library import set_backend, KHIVABackend ######################################################################################################################## class RegressionTest(unittest.TestCase): DELTA = 1e-6 def setUp(self): set_backend(KHIVABackend.KHIVA_BACKEND_CPU) def test_linear(self): euclidean_result = linear(Array([0.24580423, 0.59642861, 0.35879163, 0.37891011, 0.02445137, 0.23830957, 0.38793433, 0.68054104, 0.83934083, 0.76073689]), Array([0.2217416, 0.06344161, 0.77944375, 0.72174137, 0.19413884, 0.51146167, 0.06880307, 0.39414268, 0.98172767, 0.30490851])) self.assertAlmostEqual(euclidean_result[0].to_numpy(), 0.344864266, delta=self.DELTA) self.assertAlmostEqual(euclidean_result[1].to_numpy(), 0.268578232, delta=self.DELTA) self.assertAlmostEqual(euclidean_result[2].to_numpy(), 0.283552942, delta=self.DELTA) self.assertAlmostEqual(euclidean_result[3].to_numpy(), 0.427239418, delta=self.DELTA) self.assertAlmostEqual(euclidean_result[4].to_numpy(), 0.412351891, delta=self.DELTA) def test_linear_multiple_time_series(self): euclidean_result = linear(Array([[0.24580423, 0.59642861, 0.35879163, 0.37891011, 0.02445137, 0.23830957, 0.38793433, 0.68054104, 0.83934083, 0.76073689], [0.24580423, 0.59642861, 0.35879163, 0.37891011, 0.02445137, 0.23830957, 0.38793433, 0.68054104, 0.83934083, 0.76073689]]), Array([[0.2217416, 0.06344161, 0.77944375, 0.72174137, 0.19413884, 0.51146167, 0.06880307, 0.39414268, 0.98172767, 0.30490851], [0.2217416, 0.06344161, 0.77944375, 0.72174137, 0.19413884, 0.51146167, 0.06880307, 0.39414268, 0.98172767, 0.30490851]])) slope = euclidean_result[0].to_numpy() intercept = euclidean_result[1].to_numpy() rvalue = euclidean_result[2].to_numpy() pvalue = euclidean_result[3].to_numpy() stderrest = euclidean_result[4].to_numpy() self.assertAlmostEqual(slope[0], 0.344864266, delta=self.DELTA) self.assertAlmostEqual(intercept[0], 0.268578232, delta=self.DELTA) self.assertAlmostEqual(rvalue[0], 0.283552942, delta=self.DELTA) self.assertAlmostEqual(pvalue[0], 0.427239418, delta=self.DELTA) self.assertAlmostEqual(stderrest[0], 0.412351891, delta=self.DELTA) self.assertAlmostEqual(slope[1], 0.344864266, delta=self.DELTA) self.assertAlmostEqual(intercept[1], 0.268578232, delta=self.DELTA) self.assertAlmostEqual(rvalue[1], 0.283552942, delta=self.DELTA) self.assertAlmostEqual(pvalue[1], 0.427239418, delta=self.DELTA) self.assertAlmostEqual(stderrest[1], 0.412351891, delta=self.DELTA) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(RegressionTest) unittest.TextTestRunner(verbosity=2).run(suite) khiva-python-0.2.2/tests/unit_tests/regularization_unit_tests.py000066400000000000000000000045461346407502000254030ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import unittest import numpy as np from khiva.regularization import * from khiva.array import Array from khiva.library import set_backend, KHIVABackend ######################################################################################################################## class RegularizationTest(unittest.TestCase): DELTA = 1e-6 DECIMAL = 6 def setUp(self): set_backend(KHIVABackend.KHIVA_BACKEND_CPU) def test_group_by_single_column(self): group_by_result = group_by(Array([[0, 1, 1, 2, 2, 3], [0, 3, 3, 1, 1, 2]]), 0).to_numpy() expected = [0, 3, 1, 2] np.testing.assert_array_almost_equal(group_by_result, expected, decimal=self.DECIMAL) def test_group_by_double_key_column(self): group_by_result = group_by(Array([[0, 1, 1, 2, 2, 3], [1, 2, 2, 3, 3, 4], [0, 3, 3, 1, 1, 2]]), 0, 2, 1).to_numpy() expected = [0, 3, 1, 2] np.testing.assert_array_almost_equal(group_by_result, expected, decimal=self.DECIMAL) def test_group_by_double_key_column_2(self): group_by_result = group_by(Array([[0, 0, 1, 1, 1], [0, 1, 0, 0, 1], [1, 2, 3, 4, 5]]), 0, 2, 1).to_numpy() expected = [1, 2, 3.5, 5] np.testing.assert_array_almost_equal(group_by_result, expected, decimal=self.DECIMAL) def test_group_by_double_key_double_value_column(self): group_by_result = group_by(Array([[0, 0, 0, 2, 2], [2, 2, 2, 4, 4], [0, 1, 2, 3, 4], [1, 1, 1, 1, 1]]), 0, 2, 2).to_numpy() expected = [[1, 3.5], [1, 1]] np.testing.assert_array_almost_equal(group_by_result, expected, decimal=self.DECIMAL) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(RegularizationTest) unittest.TextTestRunner(verbosity=2).run(suite) khiva-python-0.2.2/tests/unit_tests/statistics_unit_tests.py000066400000000000000000000121771346407502000245350ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright (c) 2019 Shapelets.io # # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. ######################################################################################################################## # IMPORT ######################################################################################################################## import unittest from khiva.statistics import * from khiva.array import Array import numpy as np from khiva.library import set_backend, KHIVABackend ######################################################################################################################## class StatisticsTest(unittest.TestCase): def setUp(self): set_backend(KHIVABackend.KHIVA_BACKEND_CPU) def test_covariance_unbiased(self): result = covariance(Array(data=[[-2.1, -1, 4.3], [3, 1.1, 0.12], [3, 1.1, 0.12]]), True).to_numpy().flatten() expected = np.array([11.70999999, -4.286, -4.286, -4.286, 2.14413333, 2.14413333, -4.286, 2.14413333, 2.14413333]) np.testing.assert_array_almost_equal(result, expected, decimal=6) def test_covariance_biased(self): result = covariance(Array(data=[[-2.1, -1, 4.3], [3, 1.1, 0.12], [3, 1.1, 0.12]]), False).to_numpy().flatten() expected = np.array([7.80666667, -2.85733333, -2.85733333, -2.85733333, 1.42942222, 1.42942222, -2.85733333, 1.42942222, 1.42942222]) np.testing.assert_array_almost_equal(result, expected, decimal=6) def test_kurtosis(self): result = kurtosis(Array(data=[[0, 1, 2, 3, 4, 5], [2, 2, 2, 20, 30, 25]])).to_numpy().flatten() expected = np.array([-1.2, -2.66226722]) np.testing.assert_array_almost_equal(result, expected, decimal=2) def test_ljung_box(self): result = ljung_box(Array(data=[[0, 1, 2, 3], [4, 5, 6, 7]]), 3).to_numpy().flatten() expected = np.array([6.4400, 6.4400]) np.testing.assert_array_almost_equal(result, expected, decimal=6) def test_moment(self): result = moment(Array(data=[[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]]), 2).to_numpy().flatten() expected = np.array([9.166666666, 9.166666666]) np.testing.assert_array_almost_equal(result, expected, decimal=6) result = moment(Array(data=[[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]]), 4).to_numpy().flatten() expected = np.array([163.1666666666, 163.1666666666]) np.testing.assert_array_almost_equal(result, expected, decimal=2) def test_quantile(self): result = quantile(Array([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]), Array([0.1, 0.2])).to_numpy().flatten() expected = np.array([0.5, 1.0, 6.5, 7.0]) np.testing.assert_array_almost_equal(result, expected, decimal=2) def test_quantile_cut_2(self): result = quantiles_cut(Array([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]), 2) a = result.transpose() expected = np.array([-0.00000001, 2.5, -0.00000001, 2.5, -0.00000001, 2.5, 2.5, 5.0, 2.5, 5.0, 2.5, 5.0, 6.0, 8.5, 6.0, 8.5, 6.0, 8.5, 8.5, 11.0, 8.5, 11.0, 8.5, 11.0]) np.testing.assert_array_almost_equal(a.to_numpy().flatten(), expected, decimal=6) def test_quantile_cut_3(self): result = quantiles_cut(Array([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]), 3) a = result.transpose() expected = np.array( [-0.00000001, 1.66666667, -0.00000001, 1.6666667, 1.6666667, 3.3333333, 1.6666667, 3.3333333, 3.3333333, 5.0, 3.3333333, 5.0, 5.9999999, 7.66666667, 5.9999999, 7.6666667, 7.6666667, 9.3333333, 7.6666667, 9.3333333, 9.3333333, 11.0, 9.3333333, 11.0]) np.testing.assert_array_almost_equal(a.to_numpy().flatten(), expected, decimal=6) def test_quantile_cut_7(self): result = quantiles_cut(Array([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]), 7) a = result.transpose() expected = np.array([0, 0.7142857, 0.7142857, 1.4285715, 1.4285715, 2.1428573, 2.8571429, 3.5714288, 3.5714288, 4.2857146, 4.2857146, 5, 5.9999999, 6.7142857, 6.7142857, 7.4285715, 7.4285715, 8.1428573, 8.8571429, 9.5714288, 9.5714288, 10.2857146, 10.2857146, 11]) np.testing.assert_array_almost_equal(a.to_numpy().flatten(), expected, decimal=6) def test_sample_stdev(self): result = sample_stdev(Array(data=[[0, 1, 2, 3, 4, 5], [2, 2, 2, 20, 30, 25]])).to_numpy().flatten() expected = np.array([1.870828693, 12.988456413]) np.testing.assert_array_almost_equal(result, expected, decimal=2) def test_skewness(self): result = skewness(Array(data=[[0, 1, 2, 3, 4, 5], [2, 2, 2, 20, 30, 25]])).to_numpy().flatten() expected = np.array([0.0, 0.236177069879499]) np.testing.assert_array_almost_equal(result, expected, decimal=2) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(StatisticsTest) unittest.TextTestRunner(verbosity=2).run(suite)