C++ implementation of the Python Numpy library

Information

Category: C/C++ / Math
Watchers: 72
Star: 2.3k
Fork: 356
Last update: May 23, 2022

Resource links

https://github.com/dpilger26/NumCpp

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

Author: David Pilger [email protected]

Version: 1.3

License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files(the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Testing

C++ Standards: C++11, C++14, and C++17
Compilers: VS 2017/2019, GCC 7.4.0/8.3/9.1, and Clang 6.0/8.0/9.0
Boost Versions: 1.68 and 1.70

Documentation

GitHub

Installation

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 NdArrays, but it has limited usefulness past a simple container.

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

INITIALIZERS

Many initializer functions are provided that return NdArrays for common needs.

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

SLICING/BROADCASTING

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<double>(nc::Shape(3,4))`
	`nc::random::randn<double>({3, 4})`
`np.random.randint(0, 10, [3, 4])`	`nc::random::randInt<int>(nc::Shape(3,4),0,10)`
	`nc::random::randInt<int>({3, 4},0,10)`
`np.random.rand(3, 4)`	`nc::random::rand<double>(nc::Shape(3,4))`
	`nc::random::rand<double>({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 NdArrays.

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 NdArrays 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<dtype>(filename, "\n")`
`np.dump(a, filename)`	`nc::dump(a, filename)`
`np.load(filename)`	`nc::load<dtype>(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)`

13 Open More issues

Closed

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 Jan 4, 2021 by TomAvrech 8

Closed

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 Aug 17, 2020 by linlll 8

Closed

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 Jun 13, 2021 by TangToy 7

Closed

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 Feb 15, 2020 by Houman-HM 7

Closed

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 .

Thanks in advance.

enhancement

opened Feb 14, 2020 by Houman-HM 7

Closed

there are some bugs when i try to build Readme

i try to build Numcpp on ubuntu1604. there are some bugs . cake is 3.15.2 and boost is 1.68. ***there is the log Scanning dependencies of target Example [ 50%] Building CXX object CMakeFiles/Example.dir/ReadMe.cpp.o In file included from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Functions.hpp:57:0, from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp.hpp:37, from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/ReadMe.cpp:1: /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Functions/asarray.hpp: In function 'nc::NdArray nc::asarray(const std::array<_Tp, _Nm>&)': /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Functions/asarray.hpp:55:23: error: missing template arguments before '(' token return NdArray(inArray); ^ /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Functions/asarray.hpp: In function 'nc::NdArray nc::asarray(const std::vector<_RealType>&)': /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Functions/asarray.hpp:72:23: error: missing template arguments before '(' token return NdArray(inVector); ^ /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Functions/asarray.hpp: In function 'nc::NdArray nc::asarray(const std::deque<_Tp>&)': /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Functions/asarray.hpp:89:23: error: missing template arguments before '(' token return NdArray(inDeque); ^ /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Functions/asarray.hpp: In function 'nc::NdArray nc::asarray(const std::set&)': /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Functions/asarray.hpp:106:23: error: missing template arguments before '(' token return NdArray(inSet); ^ /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Functions/asarray.hpp: In function 'nc::NdArray nc::asarray(std::initializer_list<Tp>&)': /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Functions/asarray.hpp:124:23: error: missing template arguments before '(' token return NdArray(inList); ^ /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Functions/asarray.hpp: In function 'nc::NdArray nc::asarray(std::initializer_list<std::initializer_list<Tp> >&)': /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Functions/asarray.hpp:142:23: error: missing template arguments before '(' token return NdArray(inList); ^ In file included from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations/DCM.hpp:35:0, from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations.hpp:31, from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp.hpp:44, from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/ReadMe.cpp:1: /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations/Quaternion.hpp: At global scope: /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations/Quaternion.hpp:61:70: error: array must be initialized with a brace-enclosed initializer std::array<double, 4> components = { 0.0, 0.0, 0.0, 1.0 }; ^ /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations/Quaternion.hpp:61:70: error: too many initializers for 'std::array<double, 4ul>' In file included from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations/DCM.hpp:35:0, from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations.hpp:31, from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp.hpp:44, from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/ReadMe.cpp:1: /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations/Quaternion.hpp: In static member function 'static nc::rotations::Quaternion nc::rotations::Quaternion::identity()': /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations/Quaternion.hpp:357:35: error: use of deleted function 'constexpr nc::rotations::Quaternion::Quaternion()' return Quaternion(); ^ In file included from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations/DCM.hpp:35:0, from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations.hpp:31, from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp.hpp:44, from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/ReadMe.cpp:1: /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations/Quaternion.hpp:179:13: note: 'constexpr nc::rotations::Quaternion::Quaternion() noexcept' is implicitly deleted because its exception-specification does not match the implicit exception-specification 'noexcept (false)' Quaternion() noexcept = default; ^ In file included from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations/DCM.hpp:35:0, from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations.hpp:31, from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp.hpp:44, from /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/ReadMe.cpp:1: /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations/Quaternion.hpp: In member function 'nc::NdArray nc::rotations::Quaternion::toNdArray() const': /home/lisas/numcpp_new/numcpp_new/NumCpp/examples/ReadMe/../../include/NumCpp/Rotations/Quaternion.hpp:655:31: error: missing template arguments before '(' token return NdArray(components); ^ CMakeFiles/Example.dir/build.make:62: recipe for target 'CMakeFiles/Example.dir/ReadMe.cpp.o' failed make[2]: *** [CMakeFiles/Example.dir/ReadMe.cpp.o] Error 1 CMakeFiles/Makefile2:75: recipe for target 'CMakeFiles/Example.dir/all' failed make[1]: *** [CMakeFiles/Example.dir/all] Error 2 Makefile:83: recipe for target 'all' failed make: *** [all] Error 2

best lisa shi

opened Aug 15, 2019 by shixinlishixinli 6

Open

Multiply with BroadCasting. e.g. shape: [1,3] * [2,1] => [2 * 3]

Thanks for you project. But I found that the broadcasting in numpy is likely not supported in NumCpp. For example, I have two matrixs: A=[1,2,3] B = [[1], [2], [3]] In numpy, A * B is [ [1,2,3], [2,4,6], [3,6,9]] However, in NumCpp, the error occured. Thus I want to ask that are the shapes of two matrixs must be the same in NumCpp?

enhancement

opened Apr 20, 2022 by ValkyriaLenneth 0

Open

np.expand_dims not support

This is great project ,but it doesn't support np.expand_dims which often used

enhancement

opened Apr 19, 2022 by jjqcat 0

Open

outer function currently doesn't support input arrays of different sizes

Describe the bug outer function currently doesn't support input arrays of different sizes

To Reproduce nc::NdArray<double> x = {1., 2.}; nc::NdArray<double> y = {1., 2., 3.}; auto output = nc::outer (x, z);

Expected behavior output should be something like { {1, 2, 3}, {2, 4, 6} }

Code suggestions In addition to below, it would be good for the function to flatten the input arrays.

` template NdArray outer(const NdArray& inArray1, const NdArray& inArray2) { STATIC_ASSERT_ARITHMETIC_OR_COMPLEX(dtype);

const auto size1 = inArray1.size();
const auto size2 = inArray2.size();

auto returnArray = NdArray<dtype>(size1, size2);
for (uint32 row = 0; row < size1; ++row)
{
    const auto array1Value = inArray1[row];

    std::transform(inArray2.begin(), inArray2.end(), returnArray.begin(row),
        [array1Value](dtype value) -> dtype
        {
            return array1Value * value;
        });
}

return returnArray;

} `

enhancement

opened Mar 29, 2022 by misungson 0

Open

np.linalg.eigvals === ??

hi~ Will you consider supporting np.linalg.eigvals in the future?

enhancement

opened Mar 24, 2022 by LetGo 0

Open

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:

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

Expected behavior Should compile normally

Screenshots If applicable, add screenshots to help explain your problem.

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.

Screenshots If applicable, add screenshots to help explain your problem.

Additional context Add any other context about the problem here.

enhancement question

opened Mar 13, 2022 by erikthegamer1242 3

Open

np.lib.stride_tricks.as_strided implement

can you please support np.lib.stride_tricks.as_strided function? Thanks

enhancement

opened Mar 9, 2022 by samychen 0

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.6.2(Sep 29, 2021)

tofile and fromfile will now work for generic struct dtypes

Source code(tar.gz)
Source code(zip)

Version_2.6.1(Sep 28, 2021)

Added more delimiter support to fromfile method

Source code(tar.gz)
Source code(zip)

Version_2.6.0(Sep 27, 2021)

Added linalg::solve

Source code(tar.gz)
Source code(zip)

Version_2.5.1(Sep 17, 2021)

Made behavior of interp function consistent with NumPy when passing in non-sorted data

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)

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 Legion runtime

The fundamental package for scientific computing with Python.

A lightweight, pure Python, numpy compliant ndarray class.

nightly numpy - Rust binding of NumPy C-API

Fast NumPy array functions written in C

JET is a different approach to make numeric python substantially faster

A Neural Networking library based on NumPy only

Quick and easy geographical functions in Python

pyAudioDspTools is a python 3 package for manipulating audio by just using numpy.

NumPy-like API accelerated with CUDA

Machine learning, in numpy

NumPy file parsing and serialization for TensorFlow.js

Manipulate arrays of complex data structures as easily as Numpy.

Crab is a ﬂexible, fast recommender engine for Python that integrates classic information ﬁltering recommendation algorithms in the world of scientiﬁc Python packages (numpy, scipy, matplotlib).

A single handwritten digit classifier, using the MNIST dataset. Pure Numpy.

NumPy implementation of Poincaré Embeddings for Learning Hierarchical Representations (Facebook Research)

Minimal Deep Learning library is written in Python/Cython/C++ and Numpy/CUDA/cuDNN.

A pure-python/numpy autograd tensor library

Math to Code is an interactive Python tutorial to teach engineers how to read and implement math using the NumPy library.

Minimal deep learning library written from scratch in Python, using NumPy/CuPy.

Share this repo

Related Repos

Math

1.1k

DirectXMath is an all inline SIMD C++ linear algebra library for use in games and graphics...

DirectXMath is an all inline SIMD C++ linear algebra library for use in games and graphics apps

Math

fast math tool written on asm/c

math_tool fast math tool written on asm/c This project was created for easy use of mathematical / geometric rules and operations. This project contain

Math

313

Blitz++ Multi-Dimensional Array Library for C++

Blitz++ is a C++ template class library that provides high-performance multidimensional array containers for scientific computing.

Math

363

C++ math library for 2D/3D/4D vector, matrix, quaternion, and geometric algebra.

This is a C++ math library containing classes for vectors, matrices, quaternions, and elements of projective geometric algebra.

Math

363

A C++ compile-time math library using generalized constant expressions

GCE-Math (Generalized Constant Expression Math) is a templated C++ library enabling compile-time computation of mathematical functions.

Math

High-Performance Linear Algebra-based Graph Primitives on GPUs

GraphBLAST GraphBLAST is a GPU implementation of GraphBLAS, an open standard for building blocks of graph algorithms. It gives data scientists without GPU programming experience the power to implement graph algorithms on the GPU. We

Math

762

A simple and fast linear algebra library for games and graphics

glam A simple and fast 3D math library for games and graphics. Development status glam is in alpha stage. Minimal base functionality has been implemented and the look and feel of the API has solidified.

Math

279

C++ header-only fixed-point math library

fpm A C++ header-only fixed-point math library. "fpm" stands for "fixed-point math". It is designed to serve as a drop-in replacement for floating-point types and aims to provide as much of the standard library's functionality a

Math

720

linalg.h is a single header, public domain, short vector math library for C++

linalg.h linalg.h is a single header, public domain, short vector math library for C++. It is inspired by the syntax of popular shading and compute languages and is intended to serve as a lightweight alternative to projects

Math

560

A header-only C++ library for large scale eigenvalue problems

Math

single-header c++ math library

Introduction nicemath is a compact single-header C++ library that provides data types and routines for basic linear algebra operations often encountered in computer graphics and game development. To use the library, simply p

Math

456

Realtime Math

Realtime Math This library is geared towards realtime applications that require their math to be as fast as possible. Much care was taken to maximize inlining opportunities and for code generation to be optimal when a

Math

2.3k

C++ implementation of the Python Numpy library

Math

574

A header-only C++ library for numerical optimization --

ensmallen is a C++ header-only library for numerical optimization. Documentation and downloads: http://ensmallen.org ensmallen provides a simple set of abstractions for writing an objective function to optimize. It also prov

Math

1.2k

A data-driven compute platform

NOTE: The Fluent project has been renamed to Hydro, and the project has been broken up into multiple repositories. You can find all of them in the Hydro Project organization on Github. This repository has been archived and will be deleted e