# C++ implementation of the Python Numpy library

##### Overview # NumCpp: A Templatized Header Only C++ Implementation of the Python NumPy Library

## Testing

Compilers:
Visual Studio: 2017, 2019
GNU: 6.5, 7.5, 8.4, 9.3, 10.1
Clang: 6, 7, 8, 9, 10

Boost Versions:
1.68+

## From NumPy To NumCpp – A Quick Start Guide

This quick start guide is meant as a very brief overview of some of the things that can be done with NumCpp. For a full breakdown of everything available in the NumCpp library please visit the Full Documentation.

### CONTAINERS

The main data structure in NumCpp is the `NdArray`. It is inherently a 2D array class, with 1D arrays being implemented as 1xN arrays. There is also a `DataCube` class that is provided as a convenience container for storing an array of 2D `NdArray`s, but it has limited usefulness past a simple container.

NumPy NumCpp
`a = np.array([[1, 2], [3, 4], [5, 6]])` `nc::NdArray a = { {1, 2}, {3, 4}, {5, 6} }`
`a.reshape([2, 3])` `a.reshape(2, 3)`
`a.astype(np.double)` `a.astype()`

### INITIALIZERS

Many initializer functions are provided that return `NdArray`s for common needs.

NumPy NumCpp
`np.linspace(1, 10, 5)` `nc::linspace(1, 10, 5)`
`np.arange(3, 7)` `nc::arange(3, 7)`
`np.eye(4)` `nc::eye(4)`
`np.zeros([3, 4])` `nc::zeros(3, 4)`
`nc::NdArray(3, 4) a = 0`
`np.ones([3, 4])` `nc::ones(3, 4)`
`nc::NdArray(3, 4) a = 1`
`np.nans([3, 4])` `nc::nans(3, 4)`
`nc::NdArray(3, 4) a = nc::constants::nan`
`np.empty([3, 4])` `nc::empty(3, 4)`
`nc::NdArray(3, 4) a`

NumCpp offers NumPy style slicing and broadcasting.

NumPy NumCpp
`a[2, 3]` `a(2, 3)`
`a[2:5, 5:8]` `a(nc::Slice(2, 5), nc::Slice(5, 8))`
`a({2, 5}, {5, 8})`
`a[:, 7]` `a(a.rSlice(), 7)`
`a[a > 5]` `a[a > 50]`
`a[a > 5] = 0` `a.putMask(a > 50, 666)`

### RANDOM

The random module provides simple ways to create random arrays.

NumPy NumCpp
`np.random.seed(666)` `nc::random::seed(666)`
`np.random.randn(3, 4)` `nc::random::randN(nc::Shape(3,4))`
`nc::random::randN({3, 4})`
`np.random.randint(0, 10, [3, 4])` `nc::random::randInt(nc::Shape(3,4),0,10)`
`nc::random::randInt({3, 4},0,10)`
`np.random.rand(3, 4)` `nc::random::rand(nc::Shape(3,4))`
`nc::random::rand({3, 4})`
`np.random.choice(a, 3)` `nc::random::choice(a, 3)`

### CONCATENATION

Many ways to concatenate `NdArray` are available.

NumPy NumCpp
`np.stack([a, b, c], axis=0)` `nc::stack({a, b, c}, nc::Axis::ROW)`
`np.vstack([a, b, c])` `nc::vstack({a, b, c})`
`np.hstack([a, b, c])` `nc::hstack({a, b, c})`
`np.append(a, b, axis=1)` `nc::append(a, b, nc::Axis::COL)`

### DIAGONAL, TRIANGULAR, AND FLIP

The following return new `NdArray`s.

NumPy NumCpp
`np.diagonal(a)` `nc::diagonal(a)`
`np.triu(a)` `nc::triu(a)`
`np.tril(a)` `nc::tril(a)`
`np.flip(a, axis=0)` `nc::flip(a, nc::Axis::ROW)`
`np.flipud(a)` `nc::flipud(a)`
`np.fliplr(a)` `nc::fliplr(a)`

### ITERATION

NumCpp follows the idioms of the C++ STL providing iterator pairs to iterate on arrays in different fashions.

NumPy NumCpp
`for value in a` `for(auto it = a.begin(); it < a.end(); ++it)`
`for(auto& value : a)`

### LOGICAL

Logical FUNCTIONS in NumCpp behave the same as NumPy.

NumPy NumCpp
`np.where(a > 5, a, b)` `nc::where(a > 5, a, b)`
`np.any(a)` `nc::any(a)`
`np.all(a)` `nc::all(a)`
`np.logical_and(a, b)` `nc::logical_and(a, b)`
`np.logical_or(a, b)` `nc::logical_or(a, b)`
`np.isclose(a, b)` `nc::isclose(a, b)`
`np.allclose(a, b)` `nc::allclose(a, b)`

### COMPARISONS

NumPy NumCpp
`np.equal(a, b)` `nc::equal(a, b)`
`a == b`
`np.not_equal(a, b)` `nc::not_equal(a, b)`
`a != b`
`rows, cols = np.nonzero(a)` `auto [rows, cols] = nc::nonzero(a)`

### MINIMUM, MAXIMUM, SORTING

NumPy NumCpp
`np.min(a)` `nc::min(a)`
`np.max(a)` `nc::max(a)`
`np.argmin(a)` `nc::argmin(a)`
`np.argmax(a)` `nc::argmax(a)`
`np.sort(a, axis=0)` `nc::sort(a, nc::Axis::ROW)`
`np.argsort(a, axis=1)` `nc::argsort(a, nc::Axis::COL)`
`np.unique(a)` `nc::unique(a)`
`np.setdiff1d(a, b)` `nc::setdiff1d(a, b)`
`np.diff(a)` `nc::diff(a)`

### REDUCERS

Reducers accumulate values of `NdArray`s along specified axes. When no axis is specified, values are accumulated along all axes.

NumPy NumCpp
`np.sum(a)` `nc::sum(a)`
`np.sum(a, axis=0)` `nc::sum(a, nc::Axis::ROW)`
`np.prod(a)` `nc::prod(a)`
`np.prod(a, axis=0)` `nc::prod(a, nc::Axis::ROW)`
`np.mean(a)` `nc::mean(a)`
`np.mean(a, axis=0)` `nc::mean(a, nc::Axis::ROW)`
`np.count_nonzero(a)` `nc::count_nonzero(a)`
`np.count_nonzero(a, axis=0)` `nc::count_nonzero(a, nc::Axis::ROW)`

### I/O

Print and file output methods. All NumCpp classes support a `print()` method and `<<` stream operators.

NumPy NumCpp
`print(a)` `a.print()`
`std::cout << a`
`a.tofile(filename, sep=’\n’)` `a.tofile(filename, "\n")`
`np.fromfile(filename, sep=’\n’)` `nc::fromfile(filename, "\n")`
`np.dump(a, filename)` `nc::dump(a, filename)`
`np.load(filename)` `nc::load(filename)`

### MATHEMATICAL FUNCTIONS

NumCpp universal functions are provided for a large set number of mathematical functions.

#### BASIC FUNCTIONS

NumPy NumCpp
`np.abs(a)` `nc::abs(a)`
`np.sign(a)` `nc::sign(a)`
`np.remainder(a, b)` `nc::remainder(a, b)`
`np.clip(a, 3, 8)` `nc::clip(a, 3, 8)`
`np.interp(x, xp, fp)` `nc::interp(x, xp, fp)`

#### EXPONENTIAL FUNCTIONS

NumPy NumCpp
`np.exp(a)` `nc::exp(a)`
`np.expm1(a)` `nc::expm1(a)`
`np.log(a)` `nc::log(a)`
`np.log1p(a)` `nc::log1p(a)`

#### POWER FUNCTIONS

NumPy NumCpp
`np.power(a, 4)` `nc::power(a, 4)`
`np.sqrt(a)` `nc::sqrt(a)`
`np.square(a)` `nc::square(a)`
`np.cbrt(a)` `nc::cbrt(a)`

#### TRIGONOMETRIC FUNCTIONS

NumPy NumCpp
`np.sin(a)` `nc::sin(a)`
`np.cos(a)` `nc::cos(a)`
`np.tan(a)` `nc::tan(a)`

#### HYPERBOLIC FUNCTIONS

NumPy NumCpp
`np.sinh(a)` `nc::sinh(a)`
`np.cosh(a)` `nc::cosh(a)`
`np.tanh(a)` `nc::tanh(a)`

#### CLASSIFICATION FUNCTIONS

NumPy NumCpp
`np.isnan(a)` `nc::isnan(a)`
`np.isinf(a)` `nc::isinf(a)`

#### LINEAR ALGEBRA

NumPy NumCpp
`np.linalg.norm(a)` `nc::norm(a)`
`np.dot(a, b)` `nc::dot(a, b)`
`np.linalg.det(a)` `nc::linalg::det(a)`
`np.linalg.inv(a)` `nc::linalg::inv(a)`
`np.linalg.lstsq(a, b)` `nc::linalg::lstsq(a, b)`
`np.linalg.matrix_power(a, 3)` `nc::linalg::matrix_power(a, 3)`
`Np.linalg.multi_dot(a, b, c)` `nc::linalg::multi_dot({a, b, c})`
`np.linalg.svd(a)` `nc::linalg::svd(a)`
• #### NdArrayCore.hpp Visual Studio error

In https://github.com/dpilger26/NumCpp/blob/master/include/NumCpp/NdArray/NdArrayCore.hpp Line 4690, You've commented: // NOTE: this needs to be defined outside of the class to get rid of a compiler // error in Visual Studio

But I see it's already outside of the class, yet I get a Visual Studio compilation error:

Severity Code Description Project File Line Suppression State Error(active) E0135 class template "nc::NdArray<dtype, Allocator>" has no member "nonzero" my_lib C : \NumCpp - master\include\NumCpp\NdArray\NdArrayCore.hpp 4693

What is needed to be done in order to fix this error ?

opened by TomAvrech 8
• #### Problem for random seed

``````nc::random::seed(unsigned int(time(NULL)));
cout << nc::random::randFloat<float>(0, 1) << endl;
``````

Here is my code, but the final executable program products the same number every time it starts. However, the following code can generate different numbers each time.

``````mt19937_64 generator;
generator.seed(unsigned int(time(NULL)));
boost::random::uniform_real_distribution<float> rand(0, 1);
cout << rand(generator) << endl;
``````
question
opened by linlll 8
• #### How to realize element-wise slice in Numcpp?

In Numpy, I can slice the array like this:

``````  test_np = np.array([1, 2, 3, 4, 5])
indice = [2, 4]
slice_np = test_np[indice]#[3, 5]
``````

However, I have not found any API that can slice the array in Numcpp like this. It seems either Slice() or at() can not slice the array like this. Does it exist any API in Numcpp that can slice like this? Thanks!

enhancement
opened by TangToy 7
• #### Compilation error: ambiguous overload for operator

I just installed Numcpp on a new machine and tried to compile a piece of code which was working on another machine. However, on the new machine, I get compilation `error: ambiguous overload for ‘operator+’ (operand types are ‘nc::NdArray<double>’ and ‘int’).` There are errors related to the ambiguity for nearly all the operators. I was wondering if you could help me fix this issue. I am using Boost 1.7, Clang 6.0, and tried different versions of gcc, including 7 , 8.3.0, 9.2. Thanks in advance.

opened by Houman-HM 7
• #### Numpy diag in Numcpp

Hey, I was wondering if you could let me know how I can get numpy.diag in Numcpp. I could not find anything regarding that method in the documentation. There is nc:diagonal, which is different with numpy.diag. Wondering if you have already implemented numpy.diag .

enhancement
opened by Houman-HM 7
• #### there are some bugs when i try to build Readme

hi

best lisa shi

opened by shixinlishixinli 6
• #### can stack function change the input parameter type to list or vector?

i'm try to use `vstack` to stack a series `ndarray`,but the size of series is uncertain and the `initializer_list` can't convert from `vector` or `list`. so,can i change the implement of the stack function?

opened by novioleo 6
• #### Creating NdArray from cv::Mat having double values

Hi I am trying to use NumCpp in my iOS project. I have a cv::Mat object with double values in it. But I am unable to create NdArray from this source. It is only allowing me to use nc::uint8 as type.

auto ncArray = nc::NdArray(textSource.data, textSource.rows, textSource.cols);

What can I do to have NdArray with double type from cv::Mat object ? Kindly provide some guidance on it.

question
opened by nasircsms 5
• #### include problem in vscode

Describe the bug I clone the whole directory into my project file, and I wrote `include "NumCpp/include/NumCpp.hpp"`. Then error shows up. It says that 'NumCpp/Coordinates/Coordinate.hpp' file not found. So I delete that line of code, and I found out that every include statements in NumCpp.hpp are causing errors. But I am not sure what is happening.

Expected behavior Include NumCpp.hpp file without any error or warning occurring.

Screenshots  Additional context I am using vscode on arm64 m1 MacBook pro.

Thanks.

opened by Rocky14683 4
• #### When compiling with NumCpp getting a lot of errors

Describe the bug Installed NumCpp latest on ArchLinux using CMake, and when building using g++ getting a lot of errors. Except for the include line, I haven't even used it anywhere inside my code.

To Reproduce Steps to reproduce the behavior:

1. Install NumCpp using CMake
2. Include in a cpp file like this: `#include <NumCpp.hpp>`
3. Compile using g++ like this: `g++ test.cpp -o test`
4. Get errors: log.txt

Expected behavior Should compile normally

Additional context g++ verion: g++ (GCC) 11.2.0 c++ standard used: c++14

Expected behavior A clear and concise description of what you expected to happen.

enhancement question
opened by erikthegamer1242 4
• #### NumCpp on Ubuntu and macOS

I am going to Numpy library C++ API on Ubuntu and macOS. how can i build NumCpp on Ubuntu and macOS? If possible, please share how to build on various platform.

opened by mauricewells 4
• #### Could NOT find Boost

Hi I tried to install it on Ubuntu 20.04. Following error occured:

``````-- Compiling with C++ standard: 17
CMake Error at /usr/share/cmake-3.16/Modules/FindPackageHandleStandardArgs.cmake:146 (message):
Could NOT find Boost (missing: Boost_INCLUDE_DIR) (Required is at least
version "1.68.0")
Call Stack (most recent call first):
/usr/share/cmake-3.16/Modules/FindPackageHandleStandardArgs.cmake:393 (_FPHSA_FAILURE_MESSAGE)
/usr/share/cmake-3.16/Modules/FindBoost.cmake:2179 (find_package_handle_standard_args)
CMakeLists.txt:47 (find_package)

-- Configuring incomplete, errors occurred!
``````

I have done following steps:

``````git clone https://github.com/dpilger26/NumCpp.git
cd NumCpp
mkdir build
cd build
cmake ..
``````

I tried to solve it with:

``````sudo apt install build-essential libboost-system-dev libboost-thread-dev libboost-program-options-dev libboost-test-dev
``````

Well it does not help.

opened by Michdo93 4
• #### Does NumCpp support broadcast?

I did subtract operation between a vector1 with shape `[2, 47]` and vector2 with shape `[1, 47]`. The error message is:

``````Function: operator-
Line: 412
Error: Array dimensions do not match.libc++abi: terminating with uncaught exception of type std::invalid_argument: File: xxx/NumCpp/include/NumCpp/NdArray/NdArrayOperators.hpp
Function: operator-
Line: 412
Error: Array dimensions do not match.
``````

It seems that NumCpp could not automatically transform vector2 into shape `[2, 47]`. How could I do this manually?

opened by for-just-we 1
• #### Does NumCpp generates vectorized instructions (AVX512)?

Does NumCpp generates vectorized instructions (e.g. AVX512) after compiling with proper flags?

NumPy is able to leverage performance benefits from SIMD (vectorized) instruction set as per this link.

opened by IshaanKarnik 0
• #### vsplit is wanted

Is your feature request related to a problem? Please describe. It would be great to have numpy.vsplit function in NumCpp, if I am not missing this in the current lib.

enhancement
opened by Ten000hours 0

## Version 2.8.0

• fixed error in `inv` when a zero was on the diagnol for Issue #132
• fixed Issue #140
• added `bit_count`, Computes the number of 1-bits in the absolute value of the input
• added `swapRows` and `swapCols` methods to `NdArray`, and also free functions
• added `pinv`, https://numpy.org/doc/stable/reference/generated/numpy.linalg.pinv.html
• added `take` for Issue #149, https://numpy.org/doc/stable/reference/generated/numpy.take.html
• new non-global `random` interface
• added ellipse metrics to `imageProcessing::Centroids`
• various minor performance improvements and bug fixes
Source code(tar.gz)
Source code(zip)
• #### Version_2.7.0(Jan 5, 2022)

• added `bartlett`, https://numpy.org/doc/stable/reference/generated/numpy.bartlett.html
• added `blackman`, https://numpy.org/doc/stable/reference/generated/numpy.blackman.html
• added `corrcoef`, https://numpy.org/doc/stable/reference/generated/numpy.corrcoef.html
• added `cov`, https://numpy.org/doc/stable/reference/generated/numpy.cov.html
• added `cov_inv`, the inverse covariance matrix, aka the concentration matrix
• added `extract`, https://numpy.org/doc/stable/reference/generated/numpy.extract.html
• added `geomspace`, https://numpy.org/doc/stable/reference/generated/numpy.geomspace.html
• added `hamming`, https://numpy.org/doc/stable/reference/generated/numpy.hamming.html
• added `hanning`, https://numpy.org/doc/stable/reference/generated/numpy.hanning.html
• added `inner`, https://numpy.org/doc/stable/reference/generated/numpy.inner.html
• added `isneginf`, https://numpy.org/doc/stable/reference/generated/numpy.isneginf.html
• added `isposinf`, https://numpy.org/doc/stable/reference/generated/numpy.isposinf.html
• added `kaiser`, https://numpy.org/doc/stable/reference/generated/numpy.kaiser.html
• added `logb`, logarithm of with an arbitrary base b
• added `logspace`, https://numpy.org/doc/stable/reference/generated/numpy.logspace.html
• added `nth_root`, the nth root of a value
• added `place`, https://numpy.org/doc/stable/reference/generated/numpy.place.html
• added `select` function, https://numpy.org/doc/stable/reference/generated/numpy.select.html
• `fmod` and the modulus `%` operator now work with float dtypes
• added Hamming EDAC (Error Dectection and Correction) `encode` and `decode` functions, https://en.wikipedia.org/wiki/Hamming_code
• various minor performance improvements and bug fixes
Source code(tar.gz)
Source code(zip)

• #### Version_2.5.0(Aug 5, 2021)

• added additional `NdArray` slice overloads
• Removed `NO_MULTITHREAD` compiler flag and replaced with `NUMCPP_USE_MULTITHREAD` so that single threaded is now the default
• renamed `NO_USE_BOOST` compiler flag to `NUMCPP_NO_USE_BOOST`
• renamed `INCLUDE_BOOST_PYTHON_INTERFACE` compiler flat to `NUMCPP_INCLUDE_BOOST_PYTHON_INTERFACE`
• renamed `INCLUDE_PYBIND_PYTHON_INTERFACE` compiler flag to `NUMCPP_INCLUDE_PYBIND_PYTHON_INTERFACE`
Source code(tar.gz)
Source code(zip)

• #### Version_2.4.0(Jan 31, 2021)

• Compile with NO_USE_BOOST definition to remove the Boost libraries as a dependency, with reduced functionality:
• gcd with a pair of values (still available using a C++17 compliant compiler)
• gcd array
• lcm with a pair of values (still available using a C++17 compliant compiler)
• lcm array
• polynomial::chebyshev_t
• polynomial::chebyshev_u
• polynomial::hermite (still available using a C++17 compliant compiler)
• polynomial::laguerre (still available using a C++17 compliant compiler)
• polynomial::legendre_p (still available using a C++17 compliant compiler)
• polynomial::legendre_q
• polynomial::spherical_harmonic
• random::beta
• random::laplace
• random::nonCentralChiSquared
• random::triangle
• random::uniformOnSphere
• special::airy_ai
• special::airy_ai_prime
• special::airy_bi
• special::airy_bi_prime
• special::bernoulli
• special::bessel_in (still available using a C++17 compliant compiler)
• special::bessel_in_prime
• special::bessel_jn (still available using a C++17 compliant compiler)
• special::bessel_jn_prime
• special::bessel_kn (still available using a C++17 compliant compiler)
• special::bessel_kn_prime
• special::bessel_yn (still available using a C++17 compliant compiler)
• special::bessel_yn_prime
• special::beta (still available using a C++17 compliant compiler)
• special::cyclic_hankel_1
• special::cyclic_hankel_2
• special::digamma
• special::erf
• special::erf_inv
• special::erfc
• special::erfc_inv
• special::gamma
• special::gamma1pm1
• special::log_gamma
• special::polygamma
• special::prime
• special::riemann_zeta (still available using a C++17 compliant compiler)
• special::spherical_bessel_jn (still available using a C++17 compliant compiler)
• special::spherical_bessel_yn (still available using a C++17 compliant compiler)
• special::spherical_hankel_1
• special::spherical_hankel_2
• special::trigamma
• Added replace option into random::choice
• Added complete and incomplete elliptical integrals of the first, second, and third kind to special namespace (requires either Boost or C++17 compliant compiler)
• Added exponential integral to special namespace (requires either Boost or C++17 compliant compiler)
Source code(tar.gz)
Source code(zip)

• #### Version_2.0.0(Jun 21, 2020)

• Dropped support of C++11, now requires a C++14 or higher compiler
• Added support for `std::complex<T>`, closing Issue #58
• Added more `NdArray` constructors for STL containers including `std::vector<std::vector<T>>`, closing Issue #59
• Added `polyfit` routine inline with Numpy `polyfit`, closing Issue #61
• Added ability to use `NdArray` as container for generic structs
• Non-linear least squares fitting using Gauss-Newton
• Root finding routines
• Numerical integration routines
• `lu_decomposition` and `pivotLU_decomposition` added to `Linalg` namespace
• New STL iterators added to `NdArray`
• `iterator`
• `const_iterator`
• `reverse_iterator`
• `const_reverse_iterator`
• `column_iterator`
• `const_column_iterator`
• `reverse_column_iterator`
• `const_reverse_column_iterator`
• Added `rodriguesRotation` and `wahbasProblem` to `Rotations` namespace
• Various efficiency and/or bug fixes
Source code(tar.gz)
Source code(zip)
• #### Version_1.3.0(Nov 20, 2020)

###### David Pilger ###### C++ implementation of the Python Numpy library

NumCpp: A Templatized Header Only C++ Implementation of the Python NumPy Library

2.7k Jan 3, 2023
###### C++ implementation of the Python Numpy library

NumCpp: A Templatized Header Only C++ Implementation of the Python NumPy Library Author: David Pilger [email protected] Version: License Testing C++

2.7k Jan 1, 2023
###### Python Inference Script is a Python package that enables developers to author machine learning workflows in Python and deploy without Python.

Python Inference Script(PyIS) Python Inference Script is a Python package that enables developers to author machine learning workflows in Python and d

13 Nov 4, 2022
###### filters.python and readers.numpy for PDAL

PDAL Python Plugins PDAL Python plugins allow you to process data with PDAL into Numpy arrays. They support embedding Python in PDAL pipelines with th

3 Dec 14, 2022
203 Dec 30, 2022
###### An Aspiring Drop-In Replacement for NumPy at Scale

Legate NumPy Legate NumPy is a Legate library that aims to provide a distributed and accelerated drop-in replacement for the NumPy API on top of the L

501 Dec 26, 2022
###### cvnp: pybind11 casts between numpy and OpenCV, possibly with shared memory

cvnp: pybind11 casts and transformers between numpy and OpenCV, possibly with shared memory Explicit transformers between cv::Mat / cv::Matx and numpy

19 Jan 5, 2023
###### BLLIP reranking parser (also known as Charniak-Johnson parser, Charniak parser, Brown reranking parser) See http://pypi.python.org/pypi/bllipparser/ for Python module.

BLLIP Reranking Parser Copyright Mark Johnson, Eugene Charniak, 24th November 2005 --- August 2006 We request acknowledgement in any publications that

218 Dec 17, 2022
###### A Binary Clock. Written 3 different ways. C and SDL, Python and PyGame, Python and PyGame Zero.

Super Clock A Binary Clock. Written 3 different ways. Python with PyGame Zero, Python with PyGame and C with SDL2. Time is displayed in 3 groups of 8

3 Dec 8, 2021
###### A fast Python Common substrings of multiple strings library with C++ implementation

A fast Python Common substrings of multiple strings library with C++ implementation Having a bunch of strings, can I print some substrings which appea

7 Aug 21, 2022
###### MicroPython - a lean and efficient Python implementation for microcontrollers and constrained systems

The MicroPython project This is the MicroPython project, which aims to put an implementation of Python 3.x on microcontrollers and small embedded syst

15.7k Jan 7, 2023
###### Implementation of python itertools and builtin iteration functions for C++17

CPPItertools Range-based for loop add-ons inspired by the Python builtins and itertools library. Like itertools and the Python3 builtins, this library

1.2k Jan 7, 2023
###### Python and C++ implementation of "MarkerPose: Robust real-time planar target tracking for accurate stereo pose estimation". Accepted at LXCV Workshop @ CVPR 2021.

MarkerPose: Robust Real-time Planar Target Tracking for Accurate Stereo Pose Estimation This is a PyTorch and LibTorch implementation of MarkerPose: a

47 Nov 18, 2022
###### Instagram's experimental performance oriented greenfield implementation of Python.

Welcome to Skybison! Skybison is experimental performance-oriented greenfield implementation of Python 3.8. It contains a number of performance optimi

288 Jan 3, 2023
###### Python wrapper for Kaldi's native I/O. The internal implementation uses C++ code from Kaldi.

Python wrapper for Kaldi's native I/O. The internal implementation uses C++ code from Kaldi. A Python wrapper with pybind11 is provided to read ark/scp files from Kaldi in Python.

21 Dec 13, 2022
1.1k Jan 4, 2023
###### PillowResize library is a C++ porting of the resize method from the Pillow python library.

Pillow Resize Table of Contents Description Compilation Installation Usage Description PillowResize library is a C++ porting of the resize method from

47 Nov 17, 2022
896 Aug 31, 2021