Namespaces
	constants
	Holds usefull constants.

	coordinates

	edac

	endian

	error

	filesystem

	filter

	imageProcessing

	integrate

	linalg

	polynomial

	random

	roots

	rotations

	special

	stl_algorithms

	utils

Data Structures
struct	all_arithmetic

struct	all_arithmetic< Head, Tail... >

struct	all_arithmetic< T >

struct	all_same

struct	all_same< T1, Head, Tail... >

struct	all_same< T1, T2 >

class	DataCube
	Convenience container for holding a uniform array of NdArrays. More...

class	DtypeInfo
	Holds info about the dtype. More...

class	DtypeInfo< std::complex< dtype > >
	Holds info about the std::complex. More...

struct	greaterThan

struct	is_complex

struct	is_complex< std::complex< T > >

struct	is_valid_dtype

class	NdArray
	Holds 1D and 2D arrays, the main work horse of the NumCpp library. More...

class	NdArrayColumnIterator
	Custom column iterator for NdArray. More...

class	NdArrayConstColumnIterator
	Custom column const_iterator for NdArray. More...

class	NdArrayConstIterator
	Custom const_iterator for NdArray. More...

class	NdArrayIterator
	Custom iterator for NdArray. More...

class	Shape
	A Shape Class for NdArrays. More...

class	Slice
	A Class for slicing into NdArrays. More...

class	Timer
	A timer class for timing code execution. More...

class	Vec2
	Holds a 2D vector. More...

class	Vec3
	Holds a 3D vector. More...

Typedefs
template<bool B, class T = void>
using	enable_if_t = typename std::enable_if< B, T >::type

using	int16 = std::int16_t

using	int32 = std::int32_t

using	int64 = std::int64_t

using	int8 = std::int8_t

using	uint16 = std::uint16_t

using	uint32 = std::uint32_t

using	uint64 = std::uint64_t

using	uint8 = std::uint8_t

Enumerations
enum class	Axis { NONE = 0 , ROW , COL }
	Enum To describe an axis. More...

enum class	Endian { NATIVE = 0 , BIG , LITTLE }
	Enum for endianess. More...

Functions
template<typename dtype >
auto	abs (const NdArray< dtype > &inArray)

template<typename dtype >
auto	abs (dtype inValue) noexcept

template<typename dtype >
NdArray< std::complex< dtype > >	add (const NdArray< dtype > &inArray, const std::complex< dtype > &value)

template<typename dtype >
NdArray< dtype >	add (const NdArray< dtype > &inArray, dtype value)

template<typename dtype >
NdArray< dtype >	add (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	add (const NdArray< dtype > &inArray1, const NdArray< std::complex< dtype >> &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	add (const NdArray< std::complex< dtype >> &inArray, dtype value)

template<typename dtype >
NdArray< std::complex< dtype > >	add (const NdArray< std::complex< dtype >> &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	add (const std::complex< dtype > &value, const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	add (dtype value, const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< std::complex< dtype > >	add (dtype value, const NdArray< std::complex< dtype >> &inArray)

template<typename dtype >
uint32	alen (const NdArray< dtype > &inArray) noexcept

template<typename dtype >
NdArray< bool >	all (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
bool	allclose (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2, double inTolerance=1e-5)

template<typename dtype >
NdArray< dtype >	amax (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	amin (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
auto	angle (const NdArray< std::complex< dtype >> &inArray)

template<typename dtype >
auto	angle (const std::complex< dtype > &inValue)

template<typename dtype >
NdArray< bool >	any (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	append (const NdArray< dtype > &inArray, const NdArray< dtype > &inAppendValues, Axis inAxis=Axis::NONE)

template<typename dtype >
void	applyFunction (NdArray< dtype > &inArray, const std::function< dtype(dtype)> &inFunc)

template<typename dtype >
void	applyPoly1d (NdArray< dtype > &inArray, const polynomial::Poly1d< dtype > &inPoly)

template<typename dtype >
NdArray< dtype >	arange (const Slice &inSlice)

template<typename dtype >
NdArray< dtype >	arange (dtype inStart, dtype inStop, dtype inStep=1)

template<typename dtype >
NdArray< dtype >	arange (dtype inStop)

template<typename dtype >
auto	arccos (const NdArray< dtype > &inArray)

template<typename dtype >
auto	arccos (dtype inValue) noexcept

template<typename dtype >
auto	arccosh (const NdArray< dtype > &inArray)

template<typename dtype >
auto	arccosh (dtype inValue) noexcept

template<typename dtype >
auto	arcsin (const NdArray< dtype > &inArray)

template<typename dtype >
auto	arcsin (dtype inValue) noexcept

template<typename dtype >
auto	arcsinh (const NdArray< dtype > &inArray)

template<typename dtype >
auto	arcsinh (dtype inValue) noexcept

template<typename dtype >
auto	arctan (const NdArray< dtype > &inArray)

template<typename dtype >
auto	arctan (dtype inValue) noexcept

template<typename dtype >
auto	arctan2 (const NdArray< dtype > &inY, const NdArray< dtype > &inX)

template<typename dtype >
auto	arctan2 (dtype inY, dtype inX) noexcept

template<typename dtype >
auto	arctanh (const NdArray< dtype > &inArray)

template<typename dtype >
auto	arctanh (dtype inValue) noexcept

template<typename dtype >
NdArray< uint32 >	argmax (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< uint32 >	argmin (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< uint32 >	argsort (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< uint32 >	argwhere (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	around (const NdArray< dtype > &inArray, uint8 inNumDecimals=0)

template<typename dtype >
dtype	around (dtype inValue, uint8 inNumDecimals=0)

template<typename dtype >
bool	array_equal (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2) noexcept

template<typename dtype >
bool	array_equiv (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2) noexcept

template<typename dtype >
NdArray< dtype >	asarray (const dtype iterBegin, const dtype iterEnd)

template<typename dtype >
NdArray< dtype >	asarray (const dtype *ptr, uint32 numRows, uint32 numCols)

template<typename dtype >
NdArray< dtype >	asarray (const dtype *ptr, uint32 size)

template<typename dtype , std::enable_if_t< is_valid_dtype_v< dtype >, int > = 0>
NdArray< dtype >	asarray (const std::deque< dtype > &inDeque)

template<typename dtype >
NdArray< dtype >	asarray (const std::deque< std::deque< dtype >> &inDeque)

template<typename dtype >
NdArray< dtype >	asarray (const std::list< dtype > &inList)

template<typename dtype , typename dtypeComp >
NdArray< dtype >	asarray (const std::set< dtype, dtypeComp > &inSet)

template<typename dtype >
NdArray< dtype >	asarray (const std::vector< std::vector< dtype >> &inVector)

template<typename dtype , typename BoolType , std::enable_if_t< std::is_same< BoolType, bool >::value, int > = 0>
NdArray< dtype >	asarray (dtype *ptr, uint32 numRows, uint32 numCols, BoolType takeOwnership) noexcept

template<typename dtype , typename BoolType , std::enable_if_t< std::is_same< BoolType, bool >::value, int > = 0>
NdArray< dtype >	asarray (dtype *ptr, uint32 size, BoolType takeOwnership) noexcept

template<typename Iterator >
auto	asarray (Iterator iterBegin, Iterator iterEnd)

template<typename dtype , size_t ArraySize, std::enable_if_t< is_valid_dtype_v< dtype >, int > = 0>
NdArray< dtype >	asarray (std::array< dtype, ArraySize > &inArray, bool copy=true)

template<typename dtype , size_t Dim0Size, size_t Dim1Size>
NdArray< dtype >	asarray (std::array< std::array< dtype, Dim1Size >, Dim0Size > &inArray, bool copy=true)

template<typename dtype , std::enable_if_t< is_valid_dtype_v< dtype >, int > = 0>
NdArray< dtype >	asarray (std::initializer_list< dtype > inList)

template<typename dtype >
NdArray< dtype >	asarray (std::initializer_list< std::initializer_list< dtype >> inList)

template<typename dtype , std::enable_if_t< is_valid_dtype_v< dtype >, int > = 0>
NdArray< dtype >	asarray (std::vector< dtype > &inVector, bool copy=true)

template<typename dtype , size_t Dim1Size>
NdArray< dtype >	asarray (std::vector< std::array< dtype, Dim1Size >> &inVector, bool copy=true)

template<typename dtypeOut = double, typename dtype >
NdArray< dtypeOut >	astype (const NdArray< dtype > inArray)

template<typename dtype >
auto	average (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< double >	average (const NdArray< dtype > &inArray, const NdArray< dtype > &inWeights, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< std::complex< double > >	average (const NdArray< std::complex< dtype >> &inArray, const NdArray< dtype > &inWeights, Axis inAxis=Axis::NONE)

NdArray< double >	bartlett (int32 m)

template<typename dtype >
std::string	binaryRepr (dtype inValue)

template<typename dtype >
NdArray< dtype >	bincount (const NdArray< dtype > &inArray, const NdArray< dtype > &inWeights, uint16 inMinLength=1)

template<typename dtype >
NdArray< dtype >	bincount (const NdArray< dtype > &inArray, uint16 inMinLength=1)

template<typename dtype >
NdArray< int >	bit_count (const NdArray< dtype > &inArray)

template<typename dtype >
constexpr int	bit_count (dtype inValue) noexcept

template<typename dtype >
NdArray< dtype >	bitwise_and (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< dtype >	bitwise_not (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	bitwise_or (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< dtype >	bitwise_xor (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

NdArray< double >	blackman (int32 m)

template<typename dtype >
NdArray< dtype >	byteswap (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< double >	cbrt (const NdArray< dtype > &inArray)

template<typename dtype >
double	cbrt (dtype inValue) noexcept

template<typename dtype >
NdArray< dtype >	ceil (const NdArray< dtype > &inArray)

template<typename dtype >
dtype	ceil (dtype inValue) noexcept

template<typename dtype >
NdArray< double >	centerOfMass (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	clip (const NdArray< dtype > &inArray, dtype inMinValue, dtype inMaxValue)

template<typename dtype >
dtype	clip (dtype inValue, dtype inMinValue, dtype inMaxValue)

template<typename dtype >
NdArray< dtype >	column_stack (const std::initializer_list< NdArray< dtype >> &inArrayList)

template<typename dtype >
auto	complex (const NdArray< dtype > &inReal)

template<typename dtype >
auto	complex (const NdArray< dtype > &inReal, const NdArray< dtype > &inImag)

template<typename dtype >
auto	complex (dtype inReal)

template<typename dtype >
auto	complex (dtype inReal, dtype inImag)

template<typename Out , typename In >
std::complex< Out >	complex_cast (const std::complex< In > &value) noexcept

template<typename dtype >
NdArray< dtype >	concatenate (const std::initializer_list< NdArray< dtype >> &inArrayList, Axis inAxis=Axis::NONE)

template<typename dtype >
auto	conj (const NdArray< std::complex< dtype >> &inArray)

template<typename dtype >
auto	conj (const std::complex< dtype > &inValue)

template<typename dtype >
NdArray< bool >	contains (const NdArray< dtype > &inArray, dtype inValue, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	copy (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	copySign (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< dtype > &	copyto (NdArray< dtype > &inDestArray, const NdArray< dtype > &inSrcArray)

template<typename dtype >
NdArray< double >	corrcoef (const NdArray< dtype > &x)

template<typename dtype >
auto	cos (const NdArray< dtype > &inArray)

template<typename dtype >
auto	cos (dtype inValue) noexcept

template<typename dtype >
auto	cosh (const NdArray< dtype > &inArray)

template<typename dtype >
auto	cosh (dtype inValue) noexcept

template<typename dtype >
NdArray< uint32 >	count_nonzero (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< double >	cov (const NdArray< dtype > &x, bool bias=false)

template<typename dtype >
NdArray< double >	cov_inv (const NdArray< dtype > &x, bool bias=false)

template<typename dtype >
NdArray< dtype >	cross (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	cube (const NdArray< dtype > &inArray)

template<typename dtype >
constexpr dtype	cube (dtype inValue) noexcept

template<typename dtype >
NdArray< dtype >	cumprod (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	cumsum (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
auto	deg2rad (const NdArray< dtype > &inArray)

template<typename dtype >
constexpr auto	deg2rad (dtype inValue) noexcept

template<typename dtype >
auto	degrees (const NdArray< dtype > &inArray)

template<typename dtype >
constexpr auto	degrees (dtype inValue) noexcept

template<typename dtype >
NdArray< dtype >	deleteIndices (const NdArray< dtype > &inArray, const NdArray< uint32 > &inArrayIdxs, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	deleteIndices (const NdArray< dtype > &inArray, const Slice &inIndicesSlice, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	deleteIndices (const NdArray< dtype > &inArray, uint32 inIndex, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	diag (const NdArray< dtype > &inArray, int32 k=0)

template<typename dtype >
NdArray< dtype >	diagflat (const NdArray< dtype > &inArray, int32 k=0)

template<typename dtype >
NdArray< dtype >	diagonal (const NdArray< dtype > &inArray, int32 inOffset=0, Axis inAxis=Axis::ROW)

template<typename dtype >
NdArray< dtype >	diff (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< std::complex< dtype > >	divide (const NdArray< dtype > &inArray, const std::complex< dtype > &value)

template<typename dtype >
NdArray< dtype >	divide (const NdArray< dtype > &inArray, dtype value)

template<typename dtype >
NdArray< dtype >	divide (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	divide (const NdArray< dtype > &inArray1, const NdArray< std::complex< dtype >> &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	divide (const NdArray< std::complex< dtype >> &inArray, dtype value)

template<typename dtype >
NdArray< std::complex< dtype > >	divide (const NdArray< std::complex< dtype >> &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	divide (const std::complex< dtype > &value, const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	divide (dtype value, const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< std::complex< dtype > >	divide (dtype value, const NdArray< std::complex< dtype >> &inArray)

template<typename dtype >
NdArray< dtype >	dot (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	dot (const NdArray< dtype > &inArray1, const NdArray< std::complex< dtype >> &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	dot (const NdArray< std::complex< dtype >> &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
void	dump (const NdArray< dtype > &inArray, const std::string &inFilename)

template<typename dtype >
NdArray< dtype >	empty (const Shape &inShape)

template<typename dtype >
NdArray< dtype >	empty (uint32 inNumRows, uint32 inNumCols)

template<typename dtype >
NdArray< dtype >	empty_like (const NdArray< dtype > &inArray)

template<typename dtype >
Endian	endianess (const NdArray< dtype > &inArray) noexcept

template<typename dtype >
NdArray< bool >	equal (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
auto	exp (const NdArray< dtype > &inArray)

template<typename dtype >
auto	exp (dtype inValue) noexcept

template<typename dtype >
auto	exp2 (const NdArray< dtype > &inArray)

template<typename dtype >
auto	exp2 (dtype inValue) noexcept

template<typename dtype >
auto	expm1 (const NdArray< dtype > &inArray)

template<typename dtype >
auto	expm1 (dtype inValue) noexcept

template<typename dtype >
NdArray< dtype >	extract (const NdArray< bool > &condition, const NdArray< dtype > &arr)

template<typename dtype >
NdArray< dtype >	eye (const Shape &inShape, int32 inK=0)

template<typename dtype >
NdArray< dtype >	eye (uint32 inN, int32 inK=0)

template<typename dtype >
NdArray< dtype >	eye (uint32 inN, uint32 inM, int32 inK=0)

template<typename dtype >
void	fillDiagonal (NdArray< dtype > &inArray, dtype inValue) noexcept

NdArray< uint32 >	find (const NdArray< bool > &mask, uint32 n=std::numeric_limits< uint32 >::max())

template<typename dtype >
NdArray< dtype >	fix (const NdArray< dtype > &inArray)

template<typename dtype >
dtype	fix (dtype inValue) noexcept

template<typename dtype >
NdArray< uint32 >	flatnonzero (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	flatten (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	flip (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	fliplr (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	flipud (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	floor (const NdArray< dtype > &inArray)

template<typename dtype >
dtype	floor (dtype inValue) noexcept

template<typename dtype >
NdArray< dtype >	floor_divide (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
dtype	floor_divide (dtype inValue1, dtype inValue2) noexcept

template<typename dtype >
NdArray< dtype >	fmax (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
dtype	fmax (dtype inValue1, dtype inValue2) noexcept

template<typename dtype >
NdArray< dtype >	fmin (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
dtype	fmin (dtype inValue1, dtype inValue2) noexcept

template<typename dtype >
NdArray< dtype >	fmod (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype , enable_if_t< is_integral_v< dtype >, int > = 0>
dtype	fmod (dtype inValue1, dtype inValue2) noexcept

template<typename dtype >
NdArray< dtype >	frombuffer (const char *inBufferPtr, uint32 inNumBytes)

template<typename dtype >
NdArray< dtype >	fromfile (const std::string &inFilename)

template<typename dtype >
NdArray< dtype >	fromfile (const std::string &inFilename, const char inSep)

template<typename dtype , typename Iter >
NdArray< dtype >	fromiter (Iter inBegin, Iter inEnd)

template<typename dtype >
NdArray< dtype >	full (const Shape &inShape, dtype inFillValue)

template<typename dtype >
NdArray< dtype >	full (uint32 inNumRows, uint32 inNumCols, dtype inFillValue)

template<typename dtype >
NdArray< dtype >	full (uint32 inSquareSize, dtype inFillValue)

template<typename dtype >
NdArray< dtype >	full_like (const NdArray< dtype > &inArray, dtype inFillValue)

template<typename dtype >
dtype	gcd (const NdArray< dtype > &inArray)

template<typename dtype >
dtype	gcd (dtype inValue1, dtype inValue2) noexcept

template<typename dtype >
NdArray< double >	geomspace (dtype start, dtype stop, uint32 num=50, bool endPoint=true)

template<typename dtype >
NdArray< double >	gradient (const NdArray< dtype > &inArray, Axis inAxis=Axis::ROW)

template<typename dtype >
NdArray< std::complex< double > >	gradient (const NdArray< std::complex< dtype >> &inArray, Axis inAxis=Axis::ROW)

template<typename dtype >
NdArray< bool >	greater (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< bool >	greater_equal (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

NdArray< double >	hamming (int32 m)

NdArray< double >	hanning (int32 m)

template<typename dtype >
NdArray< uint32 >	histogram (const NdArray< dtype > &inArray, const NdArray< double > &inBinEdges)

template<typename dtype >
std::pair< NdArray< uint32 >, NdArray< double > >	histogram (const NdArray< dtype > &inArray, uint32 inNumBins=10)

template<typename dtype >
NdArray< dtype >	hstack (std::initializer_list< NdArray< dtype >> inArrayList)

template<typename dtype >
NdArray< double >	hypot (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
double	hypot (dtype inValue1, dtype inValue2) noexcept

template<typename dtype >
double	hypot (dtype inValue1, dtype inValue2, dtype inValue3) noexcept

template<typename dtype >
NdArray< dtype >	identity (uint32 inSquareSize)

template<typename dtype >
auto	imag (const NdArray< std::complex< dtype >> &inArray)

template<typename dtype >
auto	imag (const std::complex< dtype > &inValue)

template<typename dtype >
dtype	inner (const NdArray< dtype > &a, const NdArray< dtype > &b)

template<typename dtype >
NdArray< dtype >	interp (const NdArray< dtype > &inX, const NdArray< dtype > &inXp, const NdArray< dtype > &inFp)

template<typename dtype >
constexpr double	interp (dtype inValue1, dtype inValue2, double inPercent) noexcept

template<typename dtype >
NdArray< dtype >	intersect1d (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< dtype >	invert (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< bool >	isclose (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2, double inRtol=1e-05, double inAtol=1e-08)

template<typename dtype >
NdArray< bool >	isinf (const NdArray< dtype > &inArray)

template<typename dtype >
bool	isinf (dtype inValue) noexcept

template<typename dtype >
NdArray< bool >	isnan (const NdArray< dtype > &inArray)

template<typename dtype >
bool	isnan (dtype inValue) noexcept

template<typename dtype >
NdArray< bool >	isneginf (const NdArray< dtype > &inArray)

template<typename dtype >
bool	isneginf (dtype inValue) noexcept

template<typename dtype >
NdArray< bool >	isposinf (const NdArray< dtype > &inArray)

template<typename dtype >
bool	isposinf (dtype inValue) noexcept

NdArray< double >	kaiser (int32 m, double beta)

template<typename dtype >
dtype	lcm (const NdArray< dtype > &inArray)

template<typename dtype >
dtype	lcm (dtype inValue1, dtype inValue2) noexcept

template<typename dtype >
NdArray< dtype >	ldexp (const NdArray< dtype > &inArray1, const NdArray< uint8 > &inArray2)

template<typename dtype >
dtype	ldexp (dtype inValue1, uint8 inValue2) noexcept

template<typename dtype >
NdArray< dtype >	left_shift (const NdArray< dtype > &inArray, uint8 inNumBits)

template<typename dtype >
NdArray< bool >	less (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< bool >	less_equal (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< dtype >	linspace (dtype inStart, dtype inStop, uint32 inNum=50, bool endPoint=true)

template<typename dtype >
NdArray< dtype >	load (const std::string &inFilename)

template<typename dtype >
auto	log (const NdArray< dtype > &inArray)

template<typename dtype >
auto	log (dtype inValue) noexcept

template<typename dtype >
auto	log10 (const NdArray< dtype > &inArray)

template<typename dtype >
auto	log10 (dtype inValue) noexcept

template<typename dtype >
auto	log1p (const NdArray< dtype > &inArray)

template<typename dtype >
auto	log1p (dtype inValue) noexcept

template<typename dtype >
auto	log2 (const NdArray< dtype > &inArray)

template<typename dtype >
auto	log2 (dtype inValue) noexcept

template<typename dtype >
auto	logb (const NdArray< dtype > &inArray, dtype inBase)

template<typename dtype >
auto	logb (dtype inValue, dtype inBase) noexcept

template<typename dtype >
NdArray< bool >	logical_and (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< bool >	logical_not (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< bool >	logical_or (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< bool >	logical_xor (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< double >	logspace (dtype start, dtype stop, uint32 num=50, bool endPoint=true, double base=10.0)

template<typename dtype >
NdArray< dtype >	matmul (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	matmul (const NdArray< dtype > &inArray1, const NdArray< std::complex< dtype >> &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	matmul (const NdArray< std::complex< dtype >> &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< dtype >	max (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	maximum (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< double >	mean (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< std::complex< double > >	mean (const NdArray< std::complex< dtype >> &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	median (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
std::pair< NdArray< dtype >, NdArray< dtype > >	meshgrid (const NdArray< dtype > &inICoords, const NdArray< dtype > &inJCoords)

template<typename dtype >
std::pair< NdArray< dtype >, NdArray< dtype > >	meshgrid (const Slice &inSlice1, const Slice &inSlice2)

template<typename dtype >
NdArray< dtype >	min (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	minimum (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< dtype >	mod (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	multiply (const NdArray< dtype > &inArray, const std::complex< dtype > &value)

template<typename dtype >
NdArray< dtype >	multiply (const NdArray< dtype > &inArray, dtype value)

template<typename dtype >
NdArray< dtype >	multiply (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	multiply (const NdArray< dtype > &inArray1, const NdArray< std::complex< dtype >> &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	multiply (const NdArray< std::complex< dtype >> &inArray, dtype value)

template<typename dtype >
NdArray< std::complex< dtype > >	multiply (const NdArray< std::complex< dtype >> &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	multiply (const std::complex< dtype > &value, const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	multiply (dtype value, const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< std::complex< dtype > >	multiply (dtype value, const NdArray< std::complex< dtype >> &inArray)

template<typename dtype >
NdArray< dtype >	nan_to_num (NdArray< dtype > inArray, dtype nan=static_cast< dtype >(0.0), dtype posInf=DtypeInfo< dtype >::max(), dtype negInf=DtypeInfo< dtype >::min())

template<typename dtype >
NdArray< uint32 >	nanargmax (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< uint32 >	nanargmin (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	nancumprod (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	nancumsum (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	nanmax (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< double >	nanmean (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	nanmedian (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	nanmin (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< double >	nanpercentile (const NdArray< dtype > &inArray, double inPercentile, Axis inAxis=Axis::NONE, const std::string &inInterpMethod="linear")

template<typename dtype >
NdArray< dtype >	nanprod (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

NdArray< double >	nans (const Shape &inShape)

NdArray< double >	nans (uint32 inNumRows, uint32 inNumCols)

NdArray< double >	nans (uint32 inSquareSize)

template<typename dtype >
NdArray< double >	nans_like (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< double >	nanstdev (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	nansum (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< double >	nanvar (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
uint64	nbytes (const NdArray< dtype > &inArray) noexcept

template<typename dtype >
NdArray< dtype >	negative (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	newbyteorder (const NdArray< dtype > &inArray, Endian inEndianess)

template<typename dtype >
dtype	newbyteorder (dtype inValue, Endian inEndianess)

template<typename dtype >
NdArray< bool >	none (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
std::pair< NdArray< uint32 >, NdArray< uint32 > >	nonzero (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< double >	norm (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< std::complex< double > >	norm (const NdArray< std::complex< dtype >> &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< bool >	not_equal (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype1 , typename dtype2 >
NdArray< double >	nth_root (const NdArray< dtype1 > &inArray, dtype2 inRoot)

template<typename dtype1 , typename dtype2 >
double	nth_root (dtype1 inValue, dtype2 inRoot) noexcept

template<typename dtype >
NdArray< dtype >	ones (const Shape &inShape)

template<typename dtype >
NdArray< dtype >	ones (uint32 inNumRows, uint32 inNumCols)

template<typename dtype >
NdArray< dtype >	ones (uint32 inSquareSize)

template<typename dtypeOut , typename dtype >
NdArray< dtypeOut >	ones_like (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< bool >	operator! (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< bool >	operator!= (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< bool >	operator!= (const NdArray< dtype > &lhs, dtype inValue)

template<typename dtype >
NdArray< bool >	operator!= (dtype inValue, const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	operator% (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype >	operator% (const NdArray< dtype > &lhs, dtype rhs)

template<typename dtype , enable_if_t< std::is_integral< dtype >::value, int > = 0>
NdArray< dtype >	operator% (dtype lhs, const NdArray< dtype > &rhs)

template<typename dtype , enable_if_t< std::is_integral< dtype >::value, int > = 0>
NdArray< dtype > &	operator%= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype , enable_if_t< std::is_integral< dtype >::value, int > = 0>
NdArray< dtype > &	operator%= (NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< dtype >	operator& (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype >	operator& (const NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< dtype >	operator& (dtype lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< bool >	operator&& (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< bool >	operator&& (const NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< bool >	operator&& (dtype lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype > &	operator&= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype > &	operator&= (NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< dtype >	operator* (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator* (const NdArray< dtype > &lhs, const NdArray< std::complex< dtype >> &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator* (const NdArray< dtype > &lhs, const std::complex< dtype > &rhs)

template<typename dtype >
NdArray< dtype >	operator* (const NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator* (const NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator* (const NdArray< std::complex< dtype >> &lhs, dtype rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator* (const std::complex< dtype > &lhs, const NdArray< dtype > &rhs)

double	operator* (const Vec2 &lhs, const Vec2 &rhs) noexcept

Vec2	operator* (const Vec2 &lhs, double rhs) noexcept

double	operator* (const Vec3 &lhs, const Vec3 &rhs) noexcept

Vec3	operator* (const Vec3 &lhs, double rhs) noexcept

Vec2	operator* (double lhs, const Vec2 &rhs) noexcept

Vec3	operator* (double lhs, const Vec3 &rhs) noexcept

template<typename dtype >
NdArray< dtype >	operator* (dtype lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator* (dtype lhs, const NdArray< std::complex< dtype >> &rhs)

template<typename dtype >
NdArray< dtype > &	operator*= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype > &	operator*= (NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< std::complex< dtype > > &	operator*= (NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > > &	operator*= (NdArray< std::complex< dtype >> &lhs, dtype rhs)

template<typename dtype >
NdArray< dtype >	operator+ (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator+ (const NdArray< dtype > &lhs, const NdArray< std::complex< dtype >> &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator+ (const NdArray< dtype > &lhs, const std::complex< dtype > &rhs)

template<typename dtype >
NdArray< dtype >	operator+ (const NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator+ (const NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator+ (const NdArray< std::complex< dtype >> &lhs, dtype rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator+ (const std::complex< dtype > &lhs, const NdArray< dtype > &rhs)

Vec2	operator+ (const Vec2 &lhs, const Vec2 &rhs) noexcept

Vec2	operator+ (const Vec2 &lhs, double rhs) noexcept

Vec3	operator+ (const Vec3 &lhs, const Vec3 &rhs) noexcept

Vec3	operator+ (const Vec3 &lhs, double rhs) noexcept

Vec2	operator+ (double lhs, const Vec2 &rhs) noexcept

Vec3	operator+ (double lhs, const Vec3 &rhs) noexcept

template<typename dtype >
NdArray< dtype >	operator+ (dtype lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator+ (dtype lhs, const NdArray< std::complex< dtype >> &rhs)

template<class dtype , typename SizeType , typename PointerType , typename DifferenceType >
NdArrayColumnIterator< dtype, SizeType, PointerType, DifferenceType >	operator+ (typename NdArrayColumnIterator< dtype, SizeType, PointerType, DifferenceType >::difference_type offset, NdArrayColumnIterator< dtype, SizeType, PointerType, DifferenceType > next) noexcept

template<class dtype , typename SizeType , typename PointerType , typename DifferenceType >
NdArrayConstColumnIterator< dtype, SizeType, PointerType, DifferenceType >	operator+ (typename NdArrayConstColumnIterator< dtype, SizeType, PointerType, DifferenceType >::difference_type offset, NdArrayConstColumnIterator< dtype, SizeType, PointerType, DifferenceType > next) noexcept

template<class dtype , typename PointerType , typename DifferenceType >
NdArrayConstIterator< dtype, PointerType, DifferenceType >	operator+ (typename NdArrayConstIterator< dtype, PointerType, DifferenceType >::difference_type offset, NdArrayConstIterator< dtype, PointerType, DifferenceType > next) noexcept

template<class dtype , typename PointerType , typename DifferenceType >
NdArrayIterator< dtype, PointerType, DifferenceType >	operator+ (typename NdArrayIterator< dtype, PointerType, DifferenceType >::difference_type offset, NdArrayIterator< dtype, PointerType, DifferenceType > next) noexcept

template<typename dtype >
NdArray< dtype >	operator++ (NdArray< dtype > &lhs, int)

template<typename dtype >
NdArray< dtype > &	operator++ (NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype > &	operator+= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype > &	operator+= (NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< std::complex< dtype > > &	operator+= (NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > > &	operator+= (NdArray< std::complex< dtype >> &lhs, dtype rhs)

template<typename dtype >
NdArray< dtype >	operator- (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	operator- (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator- (const NdArray< dtype > &lhs, const NdArray< std::complex< dtype >> &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator- (const NdArray< dtype > &lhs, const std::complex< dtype > &rhs)

template<typename dtype >
NdArray< dtype >	operator- (const NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator- (const NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator- (const NdArray< std::complex< dtype >> &lhs, dtype rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator- (const std::complex< dtype > &lhs, const NdArray< dtype > &rhs)

Vec2	operator- (const Vec2 &lhs, const Vec2 &rhs) noexcept

Vec2	operator- (const Vec2 &lhs, double rhs) noexcept

Vec2	operator- (const Vec2 &vec) noexcept

Vec3	operator- (const Vec3 &lhs, const Vec3 &rhs) noexcept

Vec3	operator- (const Vec3 &lhs, double rhs) noexcept

Vec3	operator- (const Vec3 &vec) noexcept

Vec2	operator- (double lhs, const Vec2 &rhs) noexcept

Vec3	operator- (double lhs, const Vec3 &rhs) noexcept

template<typename dtype >
NdArray< dtype >	operator- (dtype lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator- (dtype lhs, const NdArray< std::complex< dtype >> &rhs)

template<typename dtype >
NdArray< dtype >	operator-- (NdArray< dtype > &lhs, int)

template<typename dtype >
NdArray< dtype > &	operator-- (NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype > &	operator-= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype > &	operator-= (NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< std::complex< dtype > > &	operator-= (NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > > &	operator-= (NdArray< std::complex< dtype >> &lhs, dtype rhs)

template<typename dtype >
NdArray< dtype >	operator/ (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator/ (const NdArray< dtype > &lhs, const NdArray< std::complex< dtype >> &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator/ (const NdArray< dtype > &lhs, const std::complex< dtype > &rhs)

template<typename dtype >
NdArray< dtype >	operator/ (const NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator/ (const NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator/ (const NdArray< std::complex< dtype >> &lhs, dtype rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator/ (const std::complex< dtype > &lhs, const NdArray< dtype > &rhs)

Vec2	operator/ (const Vec2 &lhs, double rhs) noexcept

Vec3	operator/ (const Vec3 &lhs, double rhs) noexcept

template<typename dtype >
NdArray< dtype >	operator/ (dtype lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > >	operator/ (dtype lhs, const NdArray< std::complex< dtype >> &rhs)

template<typename dtype >
NdArray< dtype > &	operator/= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype > &	operator/= (NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< std::complex< dtype > > &	operator/= (NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< std::complex< dtype > > &	operator/= (NdArray< std::complex< dtype >> &lhs, dtype rhs)

template<typename dtype >
NdArray< bool >	operator< (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< bool >	operator< (const NdArray< dtype > &lhs, dtype inValue)

template<typename T >
bool	operator< (const std::complex< T > &lhs, const std::complex< T > &rhs) noexcept

template<typename dtype >
NdArray< bool >	operator< (dtype inValue, const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	operator<< (const NdArray< dtype > &lhs, uint8 inNumBits)

template<typename dtype >
std::ostream &	operator<< (std::ostream &inOStream, const NdArray< dtype > &inArray)

std::ostream &	operator<< (std::ostream &stream, const Vec2 &vec)

std::ostream &	operator<< (std::ostream &stream, const Vec3 &vec)

template<typename dtype >
NdArray< dtype > &	operator<<= (NdArray< dtype > &lhs, uint8 inNumBits)

template<typename dtype >
NdArray< bool >	operator<= (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< bool >	operator<= (const NdArray< dtype > &lhs, dtype inValue)

template<typename T >
bool	operator<= (const std::complex< T > &lhs, const std::complex< T > &rhs) noexcept

template<typename dtype >
NdArray< bool >	operator<= (dtype inValue, const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< bool >	operator== (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< bool >	operator== (const NdArray< dtype > &lhs, dtype inValue)

template<typename dtype >
NdArray< bool >	operator== (dtype inValue, const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< bool >	operator> (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< bool >	operator> (const NdArray< dtype > &lhs, dtype inValue)

template<typename T >
bool	operator> (const std::complex< T > &lhs, const std::complex< T > &rhs) noexcept

template<typename dtype >
NdArray< bool >	operator> (dtype inValue, const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< bool >	operator>= (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< bool >	operator>= (const NdArray< dtype > &lhs, dtype inValue)

template<typename T >
bool	operator>= (const std::complex< T > &lhs, const std::complex< T > &rhs) noexcept

template<typename dtype >
NdArray< bool >	operator>= (dtype inValue, const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	operator>> (const NdArray< dtype > &lhs, uint8 inNumBits)

template<typename dtype >
NdArray< dtype > &	operator>>= (NdArray< dtype > &lhs, uint8 inNumBits)

template<typename dtype >
NdArray< dtype >	operator^ (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype >	operator^ (const NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< dtype >	operator^ (dtype lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype > &	operator^= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype > &	operator^= (NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< dtype >	operator\| (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype >	operator\| (const NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< dtype >	operator\| (dtype lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype > &	operator\|= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype > &	operator\|= (NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< bool >	operator\|\| (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< bool >	operator\|\| (const NdArray< dtype > &lhs, dtype rhs)

template<typename dtype >
NdArray< bool >	operator\|\| (dtype lhs, const NdArray< dtype > &rhs)

template<typename dtype >
NdArray< dtype >	operator~ (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	outer (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< dtype >	pad (const NdArray< dtype > &inArray, uint16 inPadWidth, dtype inPadValue)

template<typename dtype >
NdArray< dtype >	partition (const NdArray< dtype > &inArray, uint32 inKth, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< double >	percentile (const NdArray< dtype > &inArray, double inPercentile, Axis inAxis=Axis::NONE, const std::string &inInterpMethod="linear")

template<typename dtype >
void	place (NdArray< dtype > &arr, const NdArray< bool > &mask, const NdArray< dtype > &vals)

template<typename dtype >
auto	polar (const NdArray< dtype > &magnitude, const NdArray< dtype > &phaseAngle)

template<typename dtype >
auto	polar (dtype magnitude, dtype phaseAngle)

template<typename dtype >
NdArray< dtype >	power (const NdArray< dtype > &inArray, const NdArray< uint8 > &inExponents)

template<typename dtype >
NdArray< dtype >	power (const NdArray< dtype > &inArray, uint8 inExponent)

template<typename dtype >
constexpr dtype	power (dtype inValue, uint8 inExponent) noexcept

template<typename dtype1 , typename dtype2 >
auto	powerf (const NdArray< dtype1 > &inArray, const NdArray< dtype2 > &inExponents)

template<typename dtype1 , typename dtype2 >
auto	powerf (const NdArray< dtype1 > &inArray, dtype2 inExponent)

template<typename dtype1 , typename dtype2 >
auto	powerf (dtype1 inValue, dtype2 inExponent) noexcept

template<typename dtype >
void	print (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	prod (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
auto	proj (const NdArray< std::complex< dtype >> &inArray)

template<typename dtype >
auto	proj (const std::complex< dtype > &inValue)

template<typename dtype >
NdArray< dtype >	ptp (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype > &	put (NdArray< dtype > &inArray, const NdArray< uint32 > &inIndices, const NdArray< dtype > &inValues)

template<typename dtype >
NdArray< dtype > &	put (NdArray< dtype > &inArray, const NdArray< uint32 > &inIndices, dtype inValue)

template<typename dtype >
NdArray< dtype > &	putmask (NdArray< dtype > &inArray, const NdArray< bool > &inMask, const NdArray< dtype > &inValues)

template<typename dtype >
NdArray< dtype > &	putmask (NdArray< dtype > &inArray, const NdArray< bool > &inMask, dtype inValue)

template<typename dtype >
auto	rad2deg (const NdArray< dtype > &inArray)

template<typename dtype >
constexpr auto	rad2deg (dtype inValue) noexcept

template<typename dtype >
auto	radians (const NdArray< dtype > &inArray)

template<typename dtype >
constexpr auto	radians (dtype inValue) noexcept

template<typename dtype >
NdArray< dtype > &	ravel (NdArray< dtype > &inArray) noexcept

template<typename dtype >
auto	real (const NdArray< std::complex< dtype >> &inArray)

template<typename dtype >
auto	real (const std::complex< dtype > &inValue)

template<typename dtype >
NdArray< double >	reciprocal (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< std::complex< double > >	reciprocal (const NdArray< std::complex< dtype >> &inArray)

template<typename dtype >
NdArray< double >	remainder (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
double	remainder (dtype inValue1, dtype inValue2) noexcept

template<typename dtype >
NdArray< dtype >	repeat (const NdArray< dtype > &inArray, const Shape &inRepeatShape)

template<typename dtype >
NdArray< dtype >	repeat (const NdArray< dtype > &inArray, uint32 inNumRows, uint32 inNumCols)

template<typename dtype >
NdArray< dtype >	replace (const NdArray< dtype > &inArray, dtype oldValue, dtype newValue)

template<typename dtype >
NdArray< dtype > &	reshape (NdArray< dtype > &inArray, const Shape &inNewShape)

template<typename dtype >
NdArray< dtype > &	reshape (NdArray< dtype > &inArray, int32 inNumRows, int32 inNumCols)

template<typename dtype >
NdArray< dtype > &	reshape (NdArray< dtype > &inArray, uint32 inSize)

template<typename dtype >
NdArray< dtype > &	resizeFast (NdArray< dtype > &inArray, const Shape &inNewShape)

template<typename dtype >
NdArray< dtype > &	resizeFast (NdArray< dtype > &inArray, uint32 inNumRows, uint32 inNumCols)

template<typename dtype >
NdArray< dtype > &	resizeSlow (NdArray< dtype > &inArray, const Shape &inNewShape)

template<typename dtype >
NdArray< dtype > &	resizeSlow (NdArray< dtype > &inArray, uint32 inNumRows, uint32 inNumCols)

template<typename dtype >
NdArray< dtype >	right_shift (const NdArray< dtype > &inArray, uint8 inNumBits)

template<typename dtype >
NdArray< dtype >	rint (const NdArray< dtype > &inArray)

template<typename dtype >
dtype	rint (dtype inValue) noexcept

template<typename dtype >
NdArray< double >	rms (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< std::complex< double > >	rms (const NdArray< std::complex< dtype >> &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	roll (const NdArray< dtype > &inArray, int32 inShift, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	rot90 (const NdArray< dtype > &inArray, uint8 inK=1)

template<typename dtype >
NdArray< dtype >	round (const NdArray< dtype > &inArray, uint8 inDecimals=0)

template<typename dtype >
dtype	round (dtype inValue, uint8 inDecimals=0)

template<typename dtype >
NdArray< dtype >	row_stack (const std::initializer_list< NdArray< dtype >> &inArrayList)

template<typename dtype >
NdArray< dtype >	select (const std::vector< const NdArray< bool > * > &condVec, const std::vector< const NdArray< dtype > * > &choiceVec, dtype defaultValue=dtype{ 0 })

template<typename dtype >
NdArray< dtype >	select (const std::vector< NdArray< bool >> &condList, const std::vector< NdArray< dtype >> &choiceList, dtype defaultValue=dtype{ 0 })

template<typename dtype >
NdArray< dtype >	setdiff1d (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
Shape	shape (const NdArray< dtype > &inArray) noexcept

template<typename dtype >
NdArray< int8 >	sign (const NdArray< dtype > &inArray)

template<typename dtype >
int8	sign (dtype inValue) noexcept

template<typename dtype >
NdArray< bool >	signbit (const NdArray< dtype > &inArray)

template<typename dtype >
bool	signbit (dtype inValue) noexcept

template<typename dtype >
auto	sin (const NdArray< dtype > &inArray)

template<typename dtype >
auto	sin (dtype inValue) noexcept

template<typename dtype >
auto	sinc (const NdArray< dtype > &inArray)

template<typename dtype >
auto	sinc (dtype inValue) noexcept

template<typename dtype >
auto	sinh (const NdArray< dtype > &inArray)

template<typename dtype >
auto	sinh (dtype inValue) noexcept

template<typename dtype >
uint32	size (const NdArray< dtype > &inArray) noexcept

template<typename dtype >
NdArray< dtype >	sort (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
auto	sqrt (const NdArray< dtype > &inArray)

template<typename dtype >
auto	sqrt (dtype inValue) noexcept

template<typename dtype >
NdArray< dtype >	square (const NdArray< dtype > &inArray)

template<typename dtype >
constexpr dtype	square (dtype inValue) noexcept

template<typename dtype >
NdArray< dtype >	stack (std::initializer_list< NdArray< dtype >> inArrayList, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< double >	stdev (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< std::complex< double > >	stdev (const NdArray< std::complex< dtype >> &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< std::complex< dtype > >	subtract (const NdArray< dtype > &inArray, const std::complex< dtype > &value)

template<typename dtype >
NdArray< dtype >	subtract (const NdArray< dtype > &inArray, dtype value)

template<typename dtype >
NdArray< dtype >	subtract (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	subtract (const NdArray< dtype > &inArray1, const NdArray< std::complex< dtype >> &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	subtract (const NdArray< std::complex< dtype >> &inArray, dtype value)

template<typename dtype >
NdArray< std::complex< dtype > >	subtract (const NdArray< std::complex< dtype >> &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< std::complex< dtype > >	subtract (const std::complex< dtype > &value, const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	subtract (dtype value, const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< std::complex< dtype > >	subtract (dtype value, const NdArray< std::complex< dtype >> &inArray)

template<typename dtype >
NdArray< dtype >	sum (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
void	swap (NdArray< dtype > &inArray1, NdArray< dtype > &inArray2) noexcept

template<typename dtype >
NdArray< dtype >	swapaxes (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype > &	swapCols (NdArray< dtype > &inArray, int32 colIdx1, int32 colIdx2) noexcept

template<typename dtype >
NdArray< dtype > &	swapRows (NdArray< dtype > &inArray, int32 rowIdx1, int32 rowIdx2) noexcept

template<typename dtype , typename Indices , enable_if_t< is_same_v< Indices, NdArray< int32 >>\|\|is_same_v< Indices, NdArray< uint32 >>, int > = 0>
NdArray< dtype >	take (const NdArray< dtype > &inArray, const Indices &inIndices, Axis inAxis=Axis::NONE)

template<typename dtype >
auto	tan (const NdArray< dtype > &inArray)

template<typename dtype >
auto	tan (dtype inValue) noexcept

template<typename dtype >
auto	tanh (const NdArray< dtype > &inArray)

template<typename dtype >
auto	tanh (dtype inValue) noexcept

template<typename dtype >
NdArray< dtype >	tile (const NdArray< dtype > &inArray, const Shape &inReps)

template<typename dtype >
NdArray< dtype >	tile (const NdArray< dtype > &inArray, uint32 inNumRows, uint32 inNumCols)

template<typename dtype >
void	tofile (const NdArray< dtype > &inArray, const std::string &inFilename)

template<typename dtype >
void	tofile (const NdArray< dtype > &inArray, const std::string &inFilename, const char inSep)

template<typename dtype >
std::vector< dtype >	toStlVector (const NdArray< dtype > &inArray)

template<typename dtype >
dtype	trace (const NdArray< dtype > &inArray, int16 inOffset=0, Axis inAxis=Axis::ROW) noexcept

template<typename dtype >
NdArray< dtype >	transpose (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< double >	trapz (const NdArray< dtype > &inArray, double dx=1.0, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< double >	trapz (const NdArray< dtype > &inArrayY, const NdArray< dtype > &inArrayX, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	tril (const NdArray< dtype > &inArray, int32 inOffset=0)

template<typename dtype >
NdArray< dtype >	tril (uint32 inN, int32 inOffset=0)

template<typename dtype >
NdArray< dtype >	tril (uint32 inN, uint32 inM, int32 inOffset=0)

template<typename dtype >
NdArray< dtype >	trim_zeros (const NdArray< dtype > &inArray, const std::string &inTrim="fb")

template<typename dtype >
NdArray< dtype >	triu (const NdArray< dtype > &inArray, int32 inOffset=0)

template<typename dtype >
NdArray< dtype >	triu (uint32 inN, int32 inOffset=0)

template<typename dtype >
NdArray< dtype >	triu (uint32 inN, uint32 inM, int32 inOffset=0)

template<typename dtype >
NdArray< dtype >	trunc (const NdArray< dtype > &inArray)

template<typename dtype >
dtype	trunc (dtype inValue) noexcept

template<typename dtype >
NdArray< dtype >	union1d (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)

template<typename dtype >
NdArray< dtype >	unique (const NdArray< dtype > &inArray)

template<typename dtype >
NdArray< dtype >	unwrap (const NdArray< dtype > &inArray)

template<typename dtype >
dtype	unwrap (dtype inValue) noexcept

template<typename dtype >
NdArray< double >	var (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< std::complex< double > >	var (const NdArray< std::complex< dtype >> &inArray, Axis inAxis=Axis::NONE)

template<typename dtype >
NdArray< dtype >	vstack (std::initializer_list< NdArray< dtype >> inArrayList)

template<typename dtype >
NdArray< dtype >	where (const NdArray< bool > &inMask, const NdArray< dtype > &inA, const NdArray< dtype > &inB)

template<typename dtype >
NdArray< dtype >	where (const NdArray< bool > &inMask, const NdArray< dtype > &inA, dtype inB)

template<typename dtype >
NdArray< dtype >	where (const NdArray< bool > &inMask, dtype inA, const NdArray< dtype > &inB)

template<typename dtype >
NdArray< dtype >	where (const NdArray< bool > &inMask, dtype inA, dtype inB)

template<typename dtype >
NdArray< dtype >	zeros (const Shape &inShape)

template<typename dtype >
NdArray< dtype >	zeros (uint32 inNumRows, uint32 inNumCols)

template<typename dtype >
NdArray< dtype >	zeros (uint32 inSquareSize)

template<typename dtypeOut , typename dtype >
NdArray< dtypeOut >	zeros_like (const NdArray< dtype > &inArray)

Variables
template<typename... Ts>
constexpr bool	all_arithmetic_v = all_arithmetic<Ts...>::value

template<typename... Ts>
constexpr bool	all_same_v = all_same<Ts...>::value

template<std::size_t Value1, std::size_t Value2>
constexpr bool	greaterThan_v = greaterThan<Value1, Value2>::value

template<typename T >
constexpr bool	is_arithmetic_v = std::is_arithmetic<T>::value

template<class T >
constexpr bool	is_complex_v = is_complex<T>::value

template<typename T >
constexpr bool	is_floating_point_v = std::is_floating_point<T>::value

template<typename T >
constexpr bool	is_integral_v = std::is_integral<T>::value

template<class A , class B >
constexpr bool	is_same_v = std::is_same<A, B>::value

template<typename T >
constexpr bool	is_unsigned_v = std::is_unsigned<T>::value

template<class dtype >
constexpr bool	is_valid_dtype_v = is_valid_dtype<dtype>::value

constexpr char	VERSION [] = "2.8.0"
	Current NumCpp version number. More...

Typedef Documentation

◆ enable_if_t

template<bool B, class T = void>

using nc::enable_if_t = typedef typename std::enable_if<B, T>::type

std::enable_if helper, for c++14 compatibility

◆ int16

using nc::int16 = typedef std::int16_t

◆ int32

using nc::int32 = typedef std::int32_t

◆ int64

using nc::int64 = typedef std::int64_t

◆ int8

using nc::int8 = typedef std::int8_t

◆ uint16

using nc::uint16 = typedef std::uint16_t

◆ uint32

using nc::uint32 = typedef std::uint32_t

◆ uint64

using nc::uint64 = typedef std::uint64_t

◆ uint8

using nc::uint8 = typedef std::uint8_t

Enumeration Type Documentation

◆ Axis

enum nc::Axis

strong

Enum To describe an axis.

Enumerator
NONE
ROW
COL

◆ Endian

enum nc::Endian

strong

Enum for endianess.

Enumerator
NATIVE
BIG
LITTLE

Function Documentation

◆ abs() [1/2]

template<typename dtype >

auto nc::abs ( const NdArray< dtype > & inArray )

Calculate the absolute value element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.absolute.html

Parameters

inArray

Returns: NdArray

◆ abs() [2/2]

template<typename dtype >

auto nc::abs ( dtype inValue )

noexcept

Calculate the absolute value.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.absolute.html

Parameters

inValue

Returns: value

Examples: ReadMe.cpp.

◆ add() [1/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::add	(	const NdArray< dtype > &	inArray,
		const std::complex< dtype > &	value
	)

Add arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.add.html

Parameters

inArray
value

Returns: NdArray

◆ add() [2/9]

template<typename dtype >

NdArray<dtype> nc::add	(	const NdArray< dtype > &	inArray,
		dtype	value
	)

Add arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.add.html

Parameters

inArray
value

Returns: NdArray

◆ add() [3/9]

template<typename dtype >

NdArray<dtype> nc::add	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Add arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.add.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ add() [4/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::add	(	const NdArray< dtype > &	inArray1,
		const NdArray< std::complex< dtype >> &	inArray2
	)

Add arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.add.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ add() [5/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::add	(	const NdArray< std::complex< dtype >> &	inArray,
		dtype	value
	)

Add arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.add.html

Parameters

inArray
value

Returns: NdArray

◆ add() [6/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::add	(	const NdArray< std::complex< dtype >> &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Add arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.add.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ add() [7/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::add	(	const std::complex< dtype > &	value,
		const NdArray< dtype > &	inArray
	)

Add arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.add.html

Parameters

value
inArray

Returns: NdArray

◆ add() [8/9]

template<typename dtype >

NdArray<dtype> nc::add	(	dtype	value,
		const NdArray< dtype > &	inArray
	)

Add arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.add.html

Parameters

value
inArray

Returns: NdArray

◆ add() [9/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::add	(	dtype	value,
		const NdArray< std::complex< dtype >> &	inArray
	)

Add arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.add.html

Parameters

value
inArray

Returns: NdArray

◆ alen()

template<typename dtype >

uint32 nc::alen ( const NdArray< dtype > & inArray )

noexcept

Return the length of the first dimension of the input array.

Parameters

inArray

Returns: length uint16

◆ all()

template<typename dtype >

NdArray<bool> nc::all	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Test whether all array elements along a given axis evaluate to True.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.all.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: bool

Examples: ReadMe.cpp.

◆ allclose()

template<typename dtype >

bool nc::allclose	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2,
		double	inTolerance = `1e-5`
	)

Returns True if two arrays are element-wise equal within a tolerance. inTolerance must be a positive number

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.allclose.html

Parameters

inArray1
inArray2
inTolerance	(Optional, default 1e-5)

Returns: bool

Examples: ReadMe.cpp.

◆ amax()

template<typename dtype >

NdArray<dtype> nc::amax	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Return the maximum of an array or maximum along an axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.amax.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: max value

◆ amin()

template<typename dtype >

NdArray<dtype> nc::amin	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Return the minimum of an array or minimum along an axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.amin.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: min value

◆ angle() [1/2]

template<typename dtype >

auto nc::angle ( const NdArray< std::complex< dtype >> & inArray )

Return the angle of the complex argument.

NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.angle.html

Parameters

inArray

Returns: NdArray

◆ angle() [2/2]

template<typename dtype >

auto nc::angle ( const std::complex< dtype > & inValue )

Return the angle of the complex argument.

NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.angle.html

Parameters

inValue

Returns: value

◆ any()

template<typename dtype >

NdArray<bool> nc::any	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Test whether any array element along a given axis evaluates to True.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.any.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

Examples: ReadMe.cpp.

◆ append()

template<typename dtype >

NdArray<dtype> nc::append	(	const NdArray< dtype > &	inArray,
		const NdArray< dtype > &	inAppendValues,
		Axis	inAxis = `Axis::NONE`
	)

Append values to the end of an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.append.html

Parameters

inArray
inAppendValues
inAxis	(Optional, default NONE): The axis along which values are appended. If axis is not given, both inArray and inAppendValues are flattened before use.

Returns: NdArray

Examples: ReadMe.cpp.

◆ applyFunction()

template<typename dtype >

void nc::applyFunction	(	NdArray< dtype > &	inArray,
		const std::function< dtype(dtype)> &	inFunc
	)

Apply the input function element wise to the input array in place.

Parameters

inArray
inFunc

Returns: NdArray

◆ applyPoly1d()

template<typename dtype >

void nc::applyPoly1d	(	NdArray< dtype > &	inArray,
		const polynomial::Poly1d< dtype > &	inPoly
	)

Apply polynomial elemnt wise to the input values.

Parameters

inArray
inPoly

Returns: NdArray

◆ arange() [1/3]

template<typename dtype >

NdArray<dtype> nc::arange ( const Slice & inSlice )

Return evenly spaced values within a given interval.

Values are generated within the half - open interval[start, stop) (in other words, the interval including start but excluding stop). For integer arguments the function is equivalent to the Python built - in range function, but returns an ndarray rather than a list.

When using a non - integer step, such as 0.1, the results will often not be consistent.It is better to use linspace for these cases.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arange.html

Parameters

inSlice

Returns: NdArray

◆ arange() [2/3]

template<typename dtype >

NdArray<dtype> nc::arange	(	dtype	inStart,
		dtype	inStop,
		dtype	inStep = `1`
	)

Return evenly spaced values within a given interval.

Values are generated within the half - open interval[start, stop) (in other words, the interval including start but excluding stop). For integer arguments the function is equivalent to the Python built - in range function, but returns an ndarray rather than a list.

When using a non - integer step, such as 0.1, the results will often not be consistent.It is better to use linspace for these cases.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arange.html

Parameters

inStart
inStop
inStep	(Optional, defaults to 1)

Returns: NdArray

◆ arange() [3/3]

template<typename dtype >

NdArray<dtype> nc::arange ( dtype inStop )

Return evenly spaced values within a given interval.

Values are generated within the half - open interval[start, stop) (in other words, the interval including start but excluding stop). For integer arguments the function is equivalent to the Python built - in range function, but returns an ndarray rather than a list.

When using a non - integer step, such as 0.1, the results will often not be consistent.It is better to use linspace for these cases.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arange.html

Parameters

inStop start is 0 and step is 1

Returns: NdArray

◆ arccos() [1/2]

template<typename dtype >

auto nc::arccos ( const NdArray< dtype > & inArray )

Trigonometric inverse cosine, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arccos.html

Parameters

inArray

Returns: NdArray

◆ arccos() [2/2]

template<typename dtype >

auto nc::arccos ( dtype inValue )

noexcept

Trigonometric inverse cosine

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arccos.html

Parameters

inValue

Returns: value

◆ arccosh() [1/2]

template<typename dtype >

auto nc::arccosh ( const NdArray< dtype > & inArray )

Trigonometric inverse hyperbolic cosine, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arccosh.html

Parameters

inArray

Returns: NdArray

◆ arccosh() [2/2]

template<typename dtype >

auto nc::arccosh ( dtype inValue )

noexcept

Trigonometric inverse hyperbolic cosine.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arccosh.html

Parameters

inValue

Returns: value

◆ arcsin() [1/2]

template<typename dtype >

auto nc::arcsin ( const NdArray< dtype > & inArray )

Trigonometric inverse sine, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arcsin.html

Parameters

inArray

Returns: NdArray

◆ arcsin() [2/2]

template<typename dtype >

auto nc::arcsin ( dtype inValue )

noexcept

Trigonometric inverse sine.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arcsin.html

Parameters

inValue

Returns: value

◆ arcsinh() [1/2]

template<typename dtype >

auto nc::arcsinh ( const NdArray< dtype > & inArray )

Trigonometric inverse hyperbolic sine, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arcsinh.html

Parameters

inArray

Returns: NdArray

◆ arcsinh() [2/2]

template<typename dtype >

auto nc::arcsinh ( dtype inValue )

noexcept

Trigonometric inverse hyperbolic sine.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arcsinh.html

Parameters

inValue

Returns: value

◆ arctan() [1/2]

template<typename dtype >

auto nc::arctan ( const NdArray< dtype > & inArray )

Trigonometric inverse tangent, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arctan.html

Parameters

inArray

Returns: NdArray

◆ arctan() [2/2]

template<typename dtype >

auto nc::arctan ( dtype inValue )

noexcept

Trigonometric inverse tangent.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arctan.html

Parameters

inValue

Returns: value

◆ arctan2() [1/2]

template<typename dtype >

auto nc::arctan2	(	const NdArray< dtype > &	inY,
		const NdArray< dtype > &	inX
	)

Trigonometric inverse tangent, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arctan2.html

Parameters

inY
inX

Returns: NdArray

◆ arctan2() [2/2]

template<typename dtype >

auto nc::arctan2	(	dtype	inY,
		dtype	inX
	)

noexcept

Trigonometric inverse tangent.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arctan2.html

Parameters

inY
inX

Returns: value

◆ arctanh() [1/2]

template<typename dtype >

auto nc::arctanh ( const NdArray< dtype > & inArray )

Trigonometric inverse hyperbolic tangent, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arctanh.html

Parameters

inArray

Returns: NdArray

◆ arctanh() [2/2]

template<typename dtype >

auto nc::arctanh ( dtype inValue )

noexcept

Trigonometric inverse hyperbolic tangent.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arctanh.html

Parameters

inValue

Returns: value

◆ argmax()

template<typename dtype >

NdArray<uint32> nc::argmax	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Returns the indices of the maximum values along an axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.argmax.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

Examples: ReadMe.cpp.

◆ argmin()

template<typename dtype >

NdArray<uint32> nc::argmin	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Returns the indices of the minimum values along an axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.argmin.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

Examples: ReadMe.cpp.

◆ argsort()

template<typename dtype >

NdArray<uint32> nc::argsort	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Returns the indices that would sort an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.argsort.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

Examples: ReadMe.cpp.

◆ argwhere()

template<typename dtype >

NdArray<uint32> nc::argwhere ( const NdArray< dtype > & inArray )

Find the indices of array elements that are non-zero, grouped by element.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.argwhere.html

Parameters

inArray

Returns: NdArray

◆ around() [1/2]

template<typename dtype >

NdArray<dtype> nc::around	(	const NdArray< dtype > &	inArray,
		uint8	inNumDecimals = `0`
	)

Evenly round to the given number of decimals.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.around.html

Parameters

inArray
inNumDecimals	(Optional, default = 0)

Returns: NdArray

◆ around() [2/2]

template<typename dtype >

dtype nc::around	(	dtype	inValue,
		uint8	inNumDecimals = `0`
	)

Evenly round to the given number of decimals.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.around.html

Parameters

inValue
inNumDecimals	(Optional, default = 0)

Returns: value

◆ array_equal()

template<typename dtype >

bool nc::array_equal	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

noexcept

True if two arrays have the same shape and elements, False otherwise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.array_equal.html

Parameters

inArray1
inArray2

Returns: bool

Examples: InterfaceWithEigen.cpp, and InterfaceWithOpenCV.cpp.

◆ array_equiv()

template<typename dtype >

bool nc::array_equiv	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

noexcept

Returns True if input arrays are shape consistent and all elements equal.

Shape consistent means they are either the same shape, or one input array can be broadcasted to create the same shape as the other one.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.array_equiv.html

Parameters

inArray1
inArray2

Returns: bool

◆ asarray() [1/17]

template<typename dtype >

NdArray<dtype> nc::asarray	(	const dtype *	iterBegin,
		const dtype *	iterEnd
	)

Convert the forward_list to an array. Makes a copy of the data.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

iterBegin
iterEnd

Returns: NdArray

◆ asarray() [2/17]

template<typename dtype >

NdArray<dtype> nc::asarray	(	const dtype *	ptr,
		uint32	numRows,
		uint32	numCols
	)

Convert the c-style array to an array. Makes a copy of the data.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

ptr	to array
numRows	number of rows of the buffer
numCols	number of cols of the buffer

Returns: NdArray

◆ asarray() [3/17]

template<typename dtype >

NdArray<dtype> nc::asarray	(	const dtype *	ptr,
		uint32	size
	)

Convert the c-style array to an array. Makes a copy of the data.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

ptr	to array
size	the number of elements in the array

Returns: NdArray

◆ asarray() [4/17]

template<typename dtype , std::enable_if_t< is_valid_dtype_v< dtype >, int > = 0>

NdArray<dtype> nc::asarray ( const std::deque< dtype > & inDeque )

Convert the vector to an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

inDeque

Returns: NdArray

◆ asarray() [5/17]

template<typename dtype >

NdArray<dtype> nc::asarray ( const std::deque< std::deque< dtype >> & inDeque )

Convert the vector to an array. Makes a copy of the data.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

inDeque

Returns: NdArray

◆ asarray() [6/17]

template<typename dtype >

NdArray<dtype> nc::asarray ( const std::list< dtype > & inList )

Convert the list to an array. Makes a copy of the data.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

inList

Returns: NdArray

◆ asarray() [7/17]

template<typename dtype , typename dtypeComp >

NdArray<dtype> nc::asarray ( const std::set< dtype, dtypeComp > & inSet )

Convert the set to an array. Makes a copy of the data.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

inSet

Returns: NdArray

◆ asarray() [8/17]

template<typename dtype >

NdArray<dtype> nc::asarray ( const std::vector< std::vector< dtype >> & inVector )

Convert the vector to an array. Makes a copy of the data.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

inVector

Returns: NdArray

◆ asarray() [9/17]

template<typename dtype , typename BoolType , std::enable_if_t< std::is_same< BoolType, bool >::value, int > = 0>

NdArray<dtype> nc::asarray	(	dtype *	ptr,
		uint32	numRows,
		uint32	numCols,
		BoolType	takeOwnership
	)

noexcept

Convert the c-style array to an array. Makes a copy of the data.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

ptr	to array
numRows	number of rows of the buffer
numCols	number of cols of the buffer
takeOwnership	whether or not to take ownership of the data and call delete[] in the destructor.

Returns: NdArray

◆ asarray() [10/17]

template<typename dtype , typename BoolType , std::enable_if_t< std::is_same< BoolType, bool >::value, int > = 0>

NdArray<dtype> nc::asarray	(	dtype *	ptr,
		uint32	size,
		BoolType	takeOwnership
	)

noexcept

Convert the c-style array to an array. Makes a copy of the data.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

ptr	to array
size	the number of elements in the array
takeOwnership	whether or not to take ownership of the data and call delete[] in the destructor.

Returns: NdArray

◆ asarray() [11/17]

template<typename Iterator >

auto nc::asarray	(	Iterator	iterBegin,
		Iterator	iterEnd
	)

Convert the forward_list to an array. Makes a copy of the data.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

iterBegin
iterEnd

Returns: NdArray

◆ asarray() [12/17]

template<typename dtype , size_t ArraySize, std::enable_if_t< is_valid_dtype_v< dtype >, int > = 0>

NdArray<dtype> nc::asarray	(	std::array< dtype, ArraySize > &	inArray,
		bool	copy = `true`
	)

Convert the std::array to an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

inArray
copy	(optional) boolean for whether to make a copy and own the data, or act as a non-owning shell. Default true.

Returns: NdArray

◆ asarray() [13/17]

template<typename dtype , size_t Dim0Size, size_t Dim1Size>

NdArray<dtype> nc::asarray	(	std::array< std::array< dtype, Dim1Size >, Dim0Size > &	inArray,
		bool	copy = `true`
	)

Convert the std::array to an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

inArray
copy	(optional) boolean for whether to make a copy and own the data, or act as a non-owning shell. Default true.

Returns: NdArray

◆ asarray() [14/17]

template<typename dtype , std::enable_if_t< is_valid_dtype_v< dtype >, int > = 0>

NdArray<dtype> nc::asarray ( std::initializer_list< dtype > inList )

Convert the list initializer to an array. eg: NdArray<int> myArray = NC::asarray<int>({1,2,3});

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

inList

Returns: NdArray

◆ asarray() [15/17]

template<typename dtype >

NdArray<dtype> nc::asarray ( std::initializer_list< std::initializer_list< dtype >> inList )

Convert the list initializer to an array. eg: NdArray<int> myArray = NC::asarray<int>({{1,2,3}, {4, 5, 6}});

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

inList

Returns: NdArray

◆ asarray() [16/17]

template<typename dtype , std::enable_if_t< is_valid_dtype_v< dtype >, int > = 0>

NdArray<dtype> nc::asarray	(	std::vector< dtype > &	inVector,
		bool	copy = `true`
	)

Convert the vector to an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

inVector
copy	(optional) boolean for whether to make a copy and own the data, or act as a non-owning shell. Default true.

Returns: NdArray

◆ asarray() [17/17]

template<typename dtype , size_t Dim1Size>

NdArray<dtype> nc::asarray	(	std::vector< std::array< dtype, Dim1Size >> &	inVector,
		bool	copy = `true`
	)

Convert the vector to an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html

Parameters

inVector
copy	(optional) boolean for whether to make a copy and own the data, or act as a non-owning shell. Default true.

Returns: NdArray

◆ astype()

template<typename dtypeOut = double, typename dtype >

NdArray<dtypeOut> nc::astype ( const NdArray< dtype > inArray )

Returns a copy of the array, cast to a specified type.

Parameters

inArray

Returns: NdArray

◆ average() [1/3]

template<typename dtype >

auto nc::average	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Compute the average along the specified axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.average.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ average() [2/3]

template<typename dtype >

NdArray<double> nc::average	(	const NdArray< dtype > &	inArray,
		const NdArray< dtype > &	inWeights,
		Axis	inAxis = `Axis::NONE`
	)

Compute the weighted average along the specified axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.average.html

Parameters

inArray
inWeights
inAxis	(Optional, default NONE)

Returns: NdArray

◆ average() [3/3]

template<typename dtype >

NdArray<std::complex<double> > nc::average	(	const NdArray< std::complex< dtype >> &	inArray,
		const NdArray< dtype > &	inWeights,
		Axis	inAxis = `Axis::NONE`
	)

Compute the weighted average along the specified axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.average.html

Parameters

inArray
inWeights
inAxis	(Optional, default NONE)

Returns: NdArray

◆ bartlett()

NdArray<double> nc::bartlett ( int32 m )

inline

The Bartlett window is very similar to a triangular window, except that the end points are at zero. It is often used in signal processing for tapering a signal, without generating too much ripple in the frequency domain.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.bartlett.html

Parameters

m	Number of points in the output window. If zero or less, an empty array is returned.

Returns: NdArray

◆ binaryRepr()

template<typename dtype >

std::string nc::binaryRepr ( dtype inValue )

Return the binary representation of the input number as a string.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.binary_repr.html

Parameters

inValue

Returns: std::string

◆ bincount() [1/2]

template<typename dtype >

NdArray<dtype> nc::bincount	(	const NdArray< dtype > &	inArray,
		const NdArray< dtype > &	inWeights,
		uint16	inMinLength = `1`
	)

Count number of occurrences of each value in array of non-negative ints. Negative values will be counted in the zero bin.

The number of bins(of size 1) is one larger than the largest value in x. If minlength is specified, there will be at least this number of bins in the output array(though it will be longer if necessary, depending on the contents of x).Each bin gives the number of occurrences of its index value in x.If weights is specified the input array is weighted by it, i.e. if a value n is found at position i, out[n] += weight[i] instead of out[n] += 1. Weights array shall be of the same shape as inArray.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.bincount.html

Parameters

inArray
inWeights
inMinLength

Returns: NdArray

◆ bincount() [2/2]

template<typename dtype >

NdArray<dtype> nc::bincount	(	const NdArray< dtype > &	inArray,
		uint16	inMinLength = `1`
	)

Count number of occurrences of each value in array of non-negative ints. Negative values will be counted in the zero bin.

The number of bins(of size 1) is one larger than the largest value in x. If minlength is specified, there will be at least this number of bins in the output array(though it will be longer if necessary, depending on the contents of x).Each bin gives the number of occurrences of its index value in x.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.bincount.html

Parameters

inArray
inMinLength

Returns: NdArray

◆ bit_count() [1/2]

template<typename dtype >

NdArray<int> nc::bit_count ( const NdArray< dtype > & inArray )

Computes the number of 1-bits in an integer

Parameters

inArray

Returns: NdArray

◆ bit_count() [2/2]

template<typename dtype >

constexpr int nc::bit_count ( dtype inValue )

constexprnoexcept

Computes the number of 1-bits in an integer

Parameters

inValue

Returns: value

◆ bitwise_and()

template<typename dtype >

NdArray<dtype> nc::bitwise_and	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Compute the bit-wise AND of two arrays element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.bitwise_and.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ bitwise_not()

template<typename dtype >

NdArray<dtype> nc::bitwise_not ( const NdArray< dtype > & inArray )

Compute the bit-wise NOT the input array element-wise.

inArray

Returns: NdArray

◆ bitwise_or()

template<typename dtype >

NdArray<dtype> nc::bitwise_or	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Compute the bit-wise OR of two arrays element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.bitwise_or.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ bitwise_xor()

template<typename dtype >

NdArray<dtype> nc::bitwise_xor	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Compute the bit-wise XOR of two arrays element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.bitwise_xor.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ blackman()

NdArray<double> nc::blackman ( int32 m )

inline

The Blackman window is a taper formed by using the first three terms of a summation of cosines. It was designed to have close to the minimal leakage possible. It is close to optimal, only slightly worse than a Kaiser window.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.blackman.html

Parameters

m	Number of points in the output window. If zero or less, an empty array is returned.

Returns: NdArray

◆ byteswap()

template<typename dtype >

NdArray<dtype> nc::byteswap ( const NdArray< dtype > & inArray )

Return a new array with the bytes of the array elements swapped.

Parameters

inArray

Returns: NdArray

◆ cbrt() [1/2]

template<typename dtype >

NdArray<double> nc::cbrt ( const NdArray< dtype > & inArray )

Return the cube-root of an array, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cbrt.html

Parameters

inArray

Returns: NdArray

◆ cbrt() [2/2]

template<typename dtype >

double nc::cbrt ( dtype inValue )

noexcept

Return the cube-root of an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cbrt.html

Parameters

inValue

Returns: value

Examples: ReadMe.cpp.

◆ ceil() [1/2]

template<typename dtype >

NdArray<dtype> nc::ceil ( const NdArray< dtype > & inArray )

Return the ceiling of the input, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ceil.html

Parameters

inArray

Returns: NdArray

◆ ceil() [2/2]

template<typename dtype >

dtype nc::ceil ( dtype inValue )

noexcept

Return the ceiling of the input.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ceil.html

Parameters

inValue

Returns: value

◆ centerOfMass()

template<typename dtype >

NdArray<double> nc::centerOfMass	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Returns the center of mass of the array values along an axis.

Parameters

inArray
inAxis	(Optional, default NONE which is a 2d center of mass)

Returns: NdArray: if axis is NONE then a 1x2 array of the centroid row/col is returned.

◆ clip() [1/2]

template<typename dtype >

NdArray<dtype> nc::clip	(	const NdArray< dtype > &	inArray,
		dtype	inMinValue,
		dtype	inMaxValue
	)

Clip (limit) the values in an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.clip.html

Parameters

inArray
inMinValue
inMaxValue

Returns: NdArray

◆ clip() [2/2]

template<typename dtype >

dtype nc::clip	(	dtype	inValue,
		dtype	inMinValue,
		dtype	inMaxValue
	)

Clip (limit) the value.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.clip.html

Parameters

inValue
inMinValue
inMaxValue

Returns: NdArray

Examples: ReadMe.cpp.

◆ column_stack()

template<typename dtype >

NdArray<dtype> nc::column_stack ( const std::initializer_list< NdArray< dtype >> & inArrayList )

Stack 1-D arrays as columns into a 2-D array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.column_stack.html

Parameters

inArrayList {list} of arrays to stack

Returns: NdArray

◆ complex() [1/4]

template<typename dtype >

auto nc::complex ( const NdArray< dtype > & inReal )

Returns a std::complex from the input real and imag components

Parameters

inReal the real component of the complex number

Returns: NdArray

◆ complex() [2/4]

template<typename dtype >

auto nc::complex	(	const NdArray< dtype > &	inReal,
		const NdArray< dtype > &	inImag
	)

Returns a std::complex from the input real and imag components

Parameters

inReal	the real component of the complex number
inImag	the imaginary component of the complex number

Returns: NdArray

◆ complex() [3/4]

template<typename dtype >

auto nc::complex ( dtype inReal )

Returns a std::complex from the input real and imag components

Parameters

inReal the real component of the complex number

Returns: value

◆ complex() [4/4]

template<typename dtype >

auto nc::complex	(	dtype	inReal,
		dtype	inImag
	)

Returns a std::complex from the input real and imag components

Parameters

inReal	the real component of the complex number
inImag	the imaginary component of the complex number

Returns: value

◆ complex_cast()

template<typename Out , typename In >

std::complex<Out> nc::complex_cast ( const std::complex< In > & value )

noexcept

Greater than or equal operator for std::complex<T>

Parameters

value

Returns: std::complex<Out>

◆ concatenate()

template<typename dtype >

NdArray<dtype> nc::concatenate	(	const std::initializer_list< NdArray< dtype >> &	inArrayList,
		Axis	inAxis = `Axis::NONE`
	)

Join a sequence of arrays along an existing axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.concatenate.html

Parameters

inArrayList
inAxis	(Optional, default NONE)

Returns: NdArray

◆ conj() [1/2]

template<typename dtype >

auto nc::conj ( const NdArray< std::complex< dtype >> & inArray )

Return the complex conjugate of the complex argument.

NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.conj.html

Parameters

inArray

Returns: NdArray

◆ conj() [2/2]

template<typename dtype >

auto nc::conj ( const std::complex< dtype > & inValue )

Return the complex conjugate of the complex argument.

NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.conj.html

Parameters

inValue

Returns: value

◆ contains()

template<typename dtype >

NdArray<bool> nc::contains	(	const NdArray< dtype > &	inArray,
		dtype	inValue,
		Axis	inAxis = `Axis::NONE`
	)

returns whether or not a value is included the array

Parameters

inArray
inValue
inAxis	(Optional, default NONE)

Returns: bool

◆ copy()

template<typename dtype >

NdArray<dtype> nc::copy ( const NdArray< dtype > & inArray )

Return an array copy of the given object.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.copy.html

Parameters

inArray

Returns: NdArray

◆ copySign()

template<typename dtype >

NdArray<dtype> nc::copySign	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Change the sign of x1 to that of x2, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.copysign.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ copyto()

template<typename dtype >

NdArray<dtype>& nc::copyto	(	NdArray< dtype > &	inDestArray,
		const NdArray< dtype > &	inSrcArray
	)

Copies values from one array to another

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.copyto.html

Parameters

inDestArray
inSrcArray

Returns: NdArray

◆ corrcoef()

template<typename dtype >

NdArray<double> nc::corrcoef ( const NdArray< dtype > & x )

Return Pearson product-moment correlation coefficients.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.corrcoef.html

Parameters

x	A 1-D or 2-D array containing multiple variables and observations. Each row of x represents a variable, and each column a single observation of all those variables.

Returns: NdArray

◆ cos() [1/2]

template<typename dtype >

auto nc::cos ( const NdArray< dtype > & inArray )

Cosine element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cos.html

Parameters

inArray

Returns: NdArray

◆ cos() [2/2]

template<typename dtype >

auto nc::cos ( dtype inValue )

noexcept

Cosine

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cos.html

Parameters

inValue

Returns: value

Examples: GaussNewtonNlls.cpp, and ReadMe.cpp.

◆ cosh() [1/2]

template<typename dtype >

auto nc::cosh ( const NdArray< dtype > & inArray )

Hyperbolic Cosine element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cosh.html

Parameters

inArray

Returns: NdArray

◆ cosh() [2/2]

template<typename dtype >

auto nc::cosh ( dtype inValue )

noexcept

Hyperbolic Cosine.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cosh.html

Parameters

inValue

Returns: value

Examples: ReadMe.cpp.

◆ count_nonzero()

template<typename dtype >

NdArray<uint32> nc::count_nonzero	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Counts the number of non-zero values in the array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.count_nonzero.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

Examples: ReadMe.cpp.

◆ cov()

template<typename dtype >

NdArray<double> nc::cov	(	const NdArray< dtype > &	x,
		bool	bias = `false`
	)

Estimate a covariance matrix.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.cov.html

Parameters

x	A 1-D or 2-D array containing multiple variables and observations. Each row of x represents a variable, and each column a single observation of all those variables.
bias	Default normalization (false) is by (N - 1), where N is the number of observations given (unbiased estimate). If bias is True, then normalization is by N.

Returns: NdArray

◆ cov_inv()

template<typename dtype >

NdArray<double> nc::cov_inv	(	const NdArray< dtype > &	x,
		bool	bias = `false`
	)

Estimate an inverse covariance matrix, aka the concentration matrix

Parameters

x	A 1-D or 2-D array containing multiple variables and observations. Each row of x represents a variable, and each column a single observation of all those variables.
bias	Default normalization (false) is by (N - 1), where N is the number of observations given (unbiased estimate). If bias is True, then normalization is by N.

Returns: NdArray

◆ cross()

template<typename dtype >

NdArray<dtype> nc::cross	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2,
		Axis	inAxis = `Axis::NONE`
	)

Return the cross product of two (arrays of) vectors.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cross.html

Parameters

inArray1
inArray2
inAxis	(Optional, default NONE)

Returns: NdArray

◆ cube() [1/2]

template<typename dtype >

NdArray<dtype> nc::cube ( const NdArray< dtype > & inArray )

Cubes the elements of the array

Parameters

inArray

Returns: NdArray

◆ cube() [2/2]

template<typename dtype >

constexpr dtype nc::cube ( dtype inValue )

constexprnoexcept

Cubes the input

Parameters

inValue

Returns: cubed value

◆ cumprod()

template<typename dtype >

NdArray<dtype> nc::cumprod	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Return the cumulative product of elements along a given axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cumprod.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ cumsum()

template<typename dtype >

NdArray<dtype> nc::cumsum	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Return the cumulative sum of the elements along a given axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cumsum.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ deg2rad() [1/2]

template<typename dtype >

auto nc::deg2rad ( const NdArray< dtype > & inArray )

Convert angles from degrees to radians.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.deg2rad.html

Parameters

inArray

Returns: NdArray

◆ deg2rad() [2/2]

template<typename dtype >

constexpr auto nc::deg2rad ( dtype inValue )

constexprnoexcept

Convert angles from degrees to radians.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.deg2rad.html

Parameters

inValue

Returns: value

◆ degrees() [1/2]

template<typename dtype >

auto nc::degrees ( const NdArray< dtype > & inArray )

Convert angles from degrees to radians.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.degrees.html

Parameters

inArray

Returns: NdArray

◆ degrees() [2/2]

template<typename dtype >

constexpr auto nc::degrees ( dtype inValue )

constexprnoexcept

Convert angles from degrees to radians.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.degrees.html

Parameters

inValue

Returns: value

◆ deleteIndices() [1/3]

template<typename dtype >

NdArray<dtype> nc::deleteIndices	(	const NdArray< dtype > &	inArray,
		const NdArray< uint32 > &	inArrayIdxs,
		Axis	inAxis = `Axis::NONE`
	)

Return a new array with sub-arrays along an axis deleted.

Parameters

inArray
inArrayIdxs
inAxis	(Optional, default NONE) if none the indices will be applied to the flattened array

Returns: NdArray

◆ deleteIndices() [2/3]

template<typename dtype >

NdArray<dtype> nc::deleteIndices	(	const NdArray< dtype > &	inArray,
		const Slice &	inIndicesSlice,
		Axis	inAxis = `Axis::NONE`
	)

Return a new array with sub-arrays along an axis deleted.

Parameters

inArray
inIndicesSlice
inAxis	(Optional, default NONE) if none the indices will be applied to the flattened array

Returns: NdArray

◆ deleteIndices() [3/3]

template<typename dtype >

NdArray<dtype> nc::deleteIndices	(	const NdArray< dtype > &	inArray,
		uint32	inIndex,
		Axis	inAxis = `Axis::NONE`
	)

Return a new array with sub-arrays along an axis deleted.

Parameters

inArray
inIndex
inAxis	(Optional, default NONE) if none the indices will be applied to the flattened array

Returns: NdArray

◆ diag()

template<typename dtype >

NdArray<dtype> nc::diag	(	const NdArray< dtype > &	inArray,
		int32	k = `0`
	)

Extract a diagonal or construct a diagonal array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.diag.html

Parameters

inArray
k	Diagonal in question. The default is 0. Use k>0 for diagonals above the main diagonal, and k<0 for diagonals below the main diagonal.

Returns: NdArray

◆ diagflat()

template<typename dtype >

NdArray<dtype> nc::diagflat	(	const NdArray< dtype > &	inArray,
		int32	k = `0`
	)

Create a two-dimensional array with the flattened input as a diagonal.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.diagflat.html

Parameters

inArray
k	Diagonal to set; 0, the default, corresponds to the �main� diagonal, a positive (negative) k giving the number of the diagonal above (below) the main.

Returns: NdArray

◆ diagonal()

template<typename dtype >

NdArray<dtype> nc::diagonal	(	const NdArray< dtype > &	inArray,
		int32	inOffset = `0`,
		Axis	inAxis = `Axis::ROW`
	)

Return specified diagonals.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.diagonal.html

Parameters

inArray
inOffset	(Defaults to 0)
inAxis	(Optional, default ROW) axis the offset is applied to

Returns: NdArray

Examples: ReadMe.cpp.

◆ diff()

template<typename dtype >

NdArray<dtype> nc::diff	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Calculate the n-th discrete difference along given axis. Unsigned dtypes will give you weird results...obviously.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.diff.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

Examples: ReadMe.cpp.

◆ divide() [1/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::divide	(	const NdArray< dtype > &	inArray,
		const std::complex< dtype > &	value
	)

divide arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.divide.html

Parameters

inArray
value

Returns: NdArray

◆ divide() [2/9]

template<typename dtype >

NdArray<dtype> nc::divide	(	const NdArray< dtype > &	inArray,
		dtype	value
	)

divide arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.divide.html

Parameters

inArray
value

Returns: NdArray

◆ divide() [3/9]

template<typename dtype >

NdArray<dtype> nc::divide	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

divide arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.divide.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ divide() [4/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::divide	(	const NdArray< dtype > &	inArray1,
		const NdArray< std::complex< dtype >> &	inArray2
	)

divide arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.divide.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ divide() [5/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::divide	(	const NdArray< std::complex< dtype >> &	inArray,
		dtype	value
	)

divide arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.divide.html

Parameters

inArray
value

Returns: NdArray

◆ divide() [6/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::divide	(	const NdArray< std::complex< dtype >> &	inArray1,
		const NdArray< dtype > &	inArray2
	)

divide arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.divide.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ divide() [7/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::divide	(	const std::complex< dtype > &	value,
		const NdArray< dtype > &	inArray
	)

divide arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.divide.html

Parameters

value
inArray

Returns: NdArray

◆ divide() [8/9]

template<typename dtype >

NdArray<dtype> nc::divide	(	dtype	value,
		const NdArray< dtype > &	inArray
	)

divide arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.divide.html

Parameters

value
inArray

Returns: NdArray

◆ divide() [9/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::divide	(	dtype	value,
		const NdArray< std::complex< dtype >> &	inArray
	)

divide arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.divide.html

Parameters

value
inArray

Returns: NdArray

◆ dot() [1/3]

template<typename dtype >

NdArray<dtype> nc::dot	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Dot product of two arrays.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.dot.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ dot() [2/3]

template<typename dtype >

NdArray<std::complex<dtype> > nc::dot	(	const NdArray< dtype > &	inArray1,
		const NdArray< std::complex< dtype >> &	inArray2
	)

Dot product of two arrays.

For 2-D arrays it is equivalent to matrix multiplication, and for 1-D arrays to inner product of vectors.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.dot.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ dot() [3/3]

template<typename dtype >

NdArray<std::complex<dtype> > nc::dot	(	const NdArray< std::complex< dtype >> &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Dot product of two arrays.

For 2-D arrays it is equivalent to matrix multiplication, and for 1-D arrays to inner product of vectors.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.dot.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ dump()

template<typename dtype >

void nc::dump	(	const NdArray< dtype > &	inArray,
		const std::string &	inFilename
	)

Dump a binary file of the array to the specified file. The array can be read back with or NC::load.

Parameters

inArray
inFilename

Returns: NdArray

Examples: ReadMe.cpp.

◆ empty() [1/2]

template<typename dtype >

NdArray<dtype> nc::empty ( const Shape & inShape )

Return a new array of given shape and type, without initializing entries.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.empty.html

Parameters

inShape

Returns: NdArray

◆ empty() [2/2]

template<typename dtype >

NdArray<dtype> nc::empty	(	uint32	inNumRows,
		uint32	inNumCols
	)

Return a new array of given shape and type, without initializing entries.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.empty.html

Parameters

inNumRows
inNumCols

Returns: NdArray

◆ empty_like()

template<typename dtype >

NdArray<dtype> nc::empty_like ( const NdArray< dtype > & inArray )

Return a new array with the same shape as a given array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.empty_like.html

Parameters

inArray

Returns: NdArray

◆ endianess()

template<typename dtype >

Endian nc::endianess ( const NdArray< dtype > & inArray )

noexcept

Return the endianess of the array values.

Parameters

inArray

Returns: Endian

◆ equal()

template<typename dtype >

NdArray<bool> nc::equal	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Return (x1 == x2) element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.equal.html

Parameters

inArray1
inArray2

Returns: NdArray

Examples: ReadMe.cpp.

◆ exp() [1/2]

template<typename dtype >

auto nc::exp ( const NdArray< dtype > & inArray )

Calculate the exponential of all elements in the input array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.exp.html

Parameters

inArray

Returns: NdArray

◆ exp() [2/2]

template<typename dtype >

auto nc::exp ( dtype inValue )

noexcept

Calculate the exponential of the input value.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.exp.html

Parameters

inValue

Returns: value

Examples: GaussNewtonNlls.cpp, and ReadMe.cpp.

◆ exp2() [1/2]

template<typename dtype >

auto nc::exp2 ( const NdArray< dtype > & inArray )

Calculate 2**p for all p in the input array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.exp2.html

Parameters

inArray

Returns: NdArray

◆ exp2() [2/2]

template<typename dtype >

auto nc::exp2 ( dtype inValue )

noexcept

Calculate 2**p for all p in the input value.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.exp2.html

Parameters

inValue

Returns: value

◆ expm1() [1/2]

template<typename dtype >

auto nc::expm1 ( const NdArray< dtype > & inArray )

Calculate exp(x) - 1 for all elements in the array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.expm1.html

Parameters

inArray

Returns: NdArray

◆ expm1() [2/2]

template<typename dtype >

auto nc::expm1 ( dtype inValue )

noexcept

Calculate exp(x) - 1 for the input value.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.expm1.html

Parameters

inValue

Returns: value

Examples: ReadMe.cpp.

◆ extract()

template<typename dtype >

NdArray<dtype> nc::extract	(	const NdArray< bool > &	condition,
		const NdArray< dtype > &	arr
	)

Return the elements of an array that satisfy some condition.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.extract.html

Parameters

condition	An array whose nonzero or True entries indicate the elements of arr to extract.
arr	Input array of the same size as condition

Returns: NdArray

◆ eye() [1/3]

template<typename dtype >

NdArray<dtype> nc::eye	(	const Shape &	inShape,
		int32	inK = `0`
	)

Return a 2-D array with ones on the diagonal and zeros elsewhere.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.eye.html

Parameters

inShape
inK	Index of the diagonal: 0 (the default) refers to the main diagonal, a positive value refers to an upper diagonal, and a negative value to a lower diagonal.

Returns: NdArray

◆ eye() [2/3]

template<typename dtype >

NdArray<dtype> nc::eye	(	uint32	inN,
		int32	inK = `0`
	)

Return a 2-D array with ones on the diagonal and zeros elsewhere.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.eye.html

Parameters

inN	number of rows and columns (N)
inK	Index of the diagonal: 0 (the default) refers to the main diagonal, a positive value refers to an upper diagonal, and a negative value to a lower diagonal.

Returns: NdArray

◆ eye() [3/3]

template<typename dtype >

NdArray<dtype> nc::eye	(	uint32	inN,
		uint32	inM,
		int32	inK = `0`
	)

Return a 2-D array with ones on the diagonal and zeros elsewhere.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.eye.html

Parameters

inN	number of rows (N)
inM	number of columns (M)
inK	Index of the diagonal: 0 (the default) refers to the main diagonal, a positive value refers to an upper diagonal, and a negative value to a lower diagonal.

Returns: NdArray

◆ fillDiagonal()

template<typename dtype >

void nc::fillDiagonal	(	NdArray< dtype > &	inArray,
		dtype	inValue
	)

noexcept

Fill the main diagonal of the given array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fill_diagonal.html

Parameters

inArray
inValue

◆ find()

NdArray<uint32> nc::find	(	const NdArray< bool > &	mask,
		uint32	n = `std::numeric_limits<uint32>::max()`
	)

inline

Find flat indices of nonzero elements.

Parameters

mask	the mask to apply to the array
n	the first n indices to return (optional, default all)

Returns: NdArray

◆ fix() [1/2]

template<typename dtype >

NdArray<dtype> nc::fix ( const NdArray< dtype > & inArray )

Round to nearest integer towards zero.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fix.html

Parameters

inArray

Returns: NdArray

◆ fix() [2/2]

template<typename dtype >

dtype nc::fix ( dtype inValue )

noexcept

Round to nearest integer towards zero.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fix.html

Parameters

inValue

Returns: value

◆ flatnonzero()

template<typename dtype >

NdArray<uint32> nc::flatnonzero ( const NdArray< dtype > & inArray )

Return indices that are non-zero in the flattened version of a.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.flatnonzero.html

Parameters

inArray

Returns: NdArray

◆ flatten()

template<typename dtype >

NdArray<dtype> nc::flatten ( const NdArray< dtype > & inArray )

Return a copy of the array collapsed into one dimension.

Parameters

inArray

Returns: NdArray

◆ flip()

template<typename dtype >

NdArray<dtype> nc::flip	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Reverse the order of elements in an array along the given axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.flip.html

Parameters

inArray
inAxis

Returns: NdArray

Examples: ReadMe.cpp.

◆ fliplr()

template<typename dtype >

NdArray<dtype> nc::fliplr ( const NdArray< dtype > & inArray )

Flip array in the left/right direction.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fliplr.html

Parameters

inArray

Returns: NdArray

Examples: ReadMe.cpp.

◆ flipud()

template<typename dtype >

NdArray<dtype> nc::flipud ( const NdArray< dtype > & inArray )

Flip array in the up/down direction.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.flipud.html

Parameters

inArray

Returns: NdArray

Examples: ReadMe.cpp.

◆ floor() [1/2]

template<typename dtype >

NdArray<dtype> nc::floor ( const NdArray< dtype > & inArray )

Return the floor of the input, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.floor.html

Parameters

inArray

Returns: NdArray

◆ floor() [2/2]

template<typename dtype >

dtype nc::floor ( dtype inValue )

noexcept

Return the floor of the input.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.floor.html

Parameters

inValue

Returns: value

◆ floor_divide() [1/2]

template<typename dtype >

NdArray<dtype> nc::floor_divide	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Return the largest integer smaller or equal to the division of the inputs.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.floor_divide.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ floor_divide() [2/2]

template<typename dtype >

dtype nc::floor_divide	(	dtype	inValue1,
		dtype	inValue2
	)

noexcept

Return the largest integer smaller or equal to the division of the inputs.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.floor_divide.html

Parameters

inValue1
inValue2

Returns: value

◆ fmax() [1/2]

template<typename dtype >

NdArray<dtype> nc::fmax	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Element-wise maximum of array elements.

Compare two arrays and returns a new array containing the element - wise maxima

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fmax.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ fmax() [2/2]

template<typename dtype >

dtype nc::fmax	(	dtype	inValue1,
		dtype	inValue2
	)

noexcept

maximum of inputs.

Compare two value and returns a value containing the maxima

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fmax.html

Parameters

inValue1
inValue2

Returns: value

◆ fmin() [1/2]

template<typename dtype >

NdArray<dtype> nc::fmin	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Element-wise minimum of array elements.

Compare two arrays and returns a new array containing the element - wise minima

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fmin.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ fmin() [2/2]

template<typename dtype >

dtype nc::fmin	(	dtype	inValue1,
		dtype	inValue2
	)

noexcept

minimum of inputs.

Compare two value and returns a value containing the minima

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fmin.html

Parameters

inValue1
inValue2

Returns: value

◆ fmod() [1/2]

template<typename dtype >

NdArray<dtype> nc::fmod	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Return the element-wise remainder of division.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fmod.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ fmod() [2/2]

template<typename dtype , enable_if_t< is_integral_v< dtype >, int > = 0>

dtype nc::fmod	(	dtype	inValue1,
		dtype	inValue2
	)

noexcept

Return the remainder of division.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fmod.html

Parameters

inValue1
inValue2

Returns: value

◆ frombuffer()

template<typename dtype >

NdArray<dtype> nc::frombuffer	(	const char *	inBufferPtr,
		uint32	inNumBytes
	)

Interpret a buffer as a 1-dimensional array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.frombuffer.html

Parameters

inBufferPtr
inNumBytes

Returns: NdArray

◆ fromfile() [1/2]

template<typename dtype >

NdArray<dtype> nc::fromfile ( const std::string & inFilename )

Construct an array from data in a binary file.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fromfile.html

Parameters

inFilename

Returns: NdArray

◆ fromfile() [2/2]

template<typename dtype >

NdArray<dtype> nc::fromfile	(	const std::string &	inFilename,
		const char	inSep
	)

Construct an array from data in a text file.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fromfile.html

Parameters

inFilename
inSep	Delimiter separator between values in the file

Returns: NdArray

◆ fromiter()

template<typename dtype , typename Iter >

NdArray<dtype> nc::fromiter	(	Iter	inBegin,
		Iter	inEnd
	)

Create a new 1-dimensional array from an iterable object.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fromiter.html

Parameters

inBegin
inEnd

Returns: NdArray

◆ full() [1/3]

template<typename dtype >

NdArray<dtype> nc::full	(	const Shape &	inShape,
		dtype	inFillValue
	)

Return a new array of given shape and type, filled with inFillValue

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.full.html

Parameters

inShape
inFillValue

Returns: NdArray

◆ full() [2/3]

template<typename dtype >

NdArray<dtype> nc::full	(	uint32	inNumRows,
		uint32	inNumCols,
		dtype	inFillValue
	)

Return a new array of given shape and type, filled with inFillValue

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.full.html

Parameters

inNumRows
inNumCols
inFillValue

Returns: NdArray

◆ full() [3/3]

template<typename dtype >

NdArray<dtype> nc::full	(	uint32	inSquareSize,
		dtype	inFillValue
	)

Return a new array of given shape and type, filled with inFillValue

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.full.html

Parameters

inSquareSize
inFillValue

Returns: NdArray

◆ full_like()

template<typename dtype >

NdArray<dtype> nc::full_like	(	const NdArray< dtype > &	inArray,
		dtype	inFillValue
	)

Return a full array with the same shape and type as a given array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.full_like.html

Parameters

inArray
inFillValue

Returns: NdArray

◆ gcd() [1/2]

template<typename dtype >

dtype nc::gcd ( const NdArray< dtype > & inArray )

Returns the greatest common divisor of the values in the input array. NOTE: Use of this function requires using the Boost includes.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.gcd.html

Parameters

inArray

Returns: NdArray<double>

◆ gcd() [2/2]

template<typename dtype >

dtype nc::gcd	(	dtype	inValue1,
		dtype	inValue2
	)

noexcept

Returns the greatest common divisor of |x1| and |x2|. NOTE: Use of this function requires either using the Boost includes or a C++17 compliant compiler.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.gcd.html

Parameters

inValue1
inValue2

Returns: dtype

◆ geomspace()

template<typename dtype >

NdArray<double> nc::geomspace	(	dtype	start,
		dtype	stop,
		uint32	num = `50`,
		bool	endPoint = `true`
	)

Return numbers spaced evenly on a log scale (a geometric progression).

This is similar to logspace, but with endpoints specified directly. Each output sample is a constant multiple of the previous.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.geomspace.html

Parameters

start	the starting value of a sequence
stop	The final value of the sequence, unless endpoint is False. In that case, num + 1 values are spaced over the interval in log-space, of which all but the last (a sequence of length num) are returned.
num	Number of samples to generate. Default 50.
endPoint	If true, stop is the last sample. Otherwide,it is not included. Default is true.

Returns: NdArray

◆ gradient() [1/2]

template<typename dtype >

NdArray<double> nc::gradient	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::ROW`
	)

Return the gradient of the array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.gradient.html

Parameters

inArray
inAxis	(default ROW)

Returns: NdArray

◆ gradient() [2/2]

template<typename dtype >

NdArray<std::complex<double> > nc::gradient	(	const NdArray< std::complex< dtype >> &	inArray,
		Axis	inAxis = `Axis::ROW`
	)

Return the gradient of the array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.gradient.html

Parameters

inArray
inAxis	(default ROW)

Returns: NdArray

◆ greater()

template<typename dtype >

NdArray<bool> nc::greater	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Return the truth value of (x1 > x2) element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.greater.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ greater_equal()

template<typename dtype >

NdArray<bool> nc::greater_equal	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Return the truth value of (x1 >= x2) element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.greater_equal.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ hamming()

NdArray<double> nc::hamming ( int32 m )

inline

Return the Hamming window.

The Hamming window is a taper formed by using a weighted cosine.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.hamming.html

Parameters

m	Number of points in the output window. If zero or less, an empty array is returned.

Returns: NdArray

◆ hanning()

NdArray<double> nc::hanning ( int32 m )

inline

Return the Hamming window.

The Hanning window is a taper formed by using a weighted cosine.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.hanning.html

Parameters

m	Number of points in the output window. If zero or less, an empty array is returned.

Returns: NdArray

◆ histogram() [1/2]

template<typename dtype >

NdArray<uint32> nc::histogram	(	const NdArray< dtype > &	inArray,
		const NdArray< double > &	inBinEdges
	)

Compute the histogram of a set of data.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.histogram.html

Parameters

inArray
inBinEdges	monotonically increasing array of bin edges, including the rightmost edge, allowing for non-uniform bin widths.

Returns: array of histogram counts

◆ histogram() [2/2]

template<typename dtype >

std::pair<NdArray<uint32>, NdArray<double> > nc::histogram	(	const NdArray< dtype > &	inArray,
		uint32	inNumBins = `10`
	)

Compute the histogram of a set of data.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.histogram.html

Parameters

inArray
inNumBins(	default 10)

Returns: std::pair of NdArrays; first is histogram counts, seconds is the bin edges

◆ hstack()

template<typename dtype >

NdArray<dtype> nc::hstack ( std::initializer_list< NdArray< dtype >> inArrayList )

Stack arrays in sequence horizontally (column wise).

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.hstack.html

Parameters

inArrayList {list} of arrays to stack

Returns: NdArray

Examples: ReadMe.cpp.

◆ hypot() [1/3]

template<typename dtype >

NdArray<double> nc::hypot	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Given the "legs" of a right triangle, return its hypotenuse.

Equivalent to sqrt(x1**2 + x2**2), element - wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.hypot.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ hypot() [2/3]

template<typename dtype >

double nc::hypot	(	dtype	inValue1,
		dtype	inValue2
	)

noexcept

Given the "legs" of a right triangle, return its hypotenuse.

Equivalent to sqrt(x1**2 + x2**2), element - wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.hypot.html

Parameters

inValue1
inValue2

Returns: value

◆ hypot() [3/3]

template<typename dtype >

double nc::hypot	(	dtype	inValue1,
		dtype	inValue2,
		dtype	inValue3
	)

noexcept

Given the "legs" of a right triangle, return its hypotenuse.

Equivalent to sqrt(x1**2 + x2**2 + x3**2), element - wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.hypot.html

Parameters

inValue1
inValue2
inValue3

Returns: value

◆ identity()

template<typename dtype >

NdArray<dtype> nc::identity ( uint32 inSquareSize )

Return the identity array.

The identity array is a square array with ones on the main diagonal.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.identity.html

Parameters

inSquareSize

Returns: NdArray

◆ imag() [1/2]

template<typename dtype >

auto nc::imag ( const NdArray< std::complex< dtype >> & inArray )

Return the imaginary part of the complex argument.

NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.imag.html

Parameters

inArray

Returns: NdArray

◆ imag() [2/2]

template<typename dtype >

auto nc::imag ( const std::complex< dtype > & inValue )

Return the imaginar part of the complex argument.

NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.imag.html

Parameters

inValue

Returns: value

◆ inner()

template<typename dtype >

dtype nc::inner	(	const NdArray< dtype > &	a,
		const NdArray< dtype > &	b
	)

Inner product of two 1-D arrays.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.inner.html

Parameters

a	array 1
b	array 2

Returns: NdArray

◆ interp() [1/2]

template<typename dtype >

NdArray<dtype> nc::interp	(	const NdArray< dtype > &	inX,
		const NdArray< dtype > &	inXp,
		const NdArray< dtype > &	inFp
	)

One-dimensional linear interpolation.

Returns the one - dimensional piecewise linear interpolant to a function with given values at discrete data - points. If input arrays are not one dimensional they will be internally flattened.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.interp.html

Parameters

inX	The x-coordinates at which to evaluate the interpolated values.
inXp	The x-coordinates of the data points, must be increasing. Otherwise, xp is internally sorted.
inFp	The y-coordinates of the data points, same length as inXp.

Returns: NdArray

◆ interp() [2/2]

template<typename dtype >

constexpr double nc::interp	(	dtype	inValue1,
		dtype	inValue2,
		double	inPercent
	)

constexprnoexcept

Returns the linear interpolation between two points

Parameters

inValue1
inValue2
inPercent

Returns: linear interpolated point

Examples: ReadMe.cpp.

◆ intersect1d()

template<typename dtype >

NdArray<dtype> nc::intersect1d	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Find the intersection of two arrays.

Return the sorted, unique values that are in both of the input arrays.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.intersect1d.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ invert()

template<typename dtype >

NdArray<dtype> nc::invert ( const NdArray< dtype > & inArray )

Compute bit-wise inversion, or bit-wise NOT, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.invert.html

Parameters

inArray

Returns: NdArray

◆ isclose()

template<typename dtype >

NdArray<bool> nc::isclose	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2,
		double	inRtol = `1e-05`,
		double	inAtol = `1e-08`
	)

Returns a boolean array where two arrays are element-wise equal within a tolerance.

For finite values, isclose uses the following equation to test whether two floating point values are equivalent. absolute(a - b) <= (atol + rtol * absolute(b))

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isclose.html

Parameters

inArray1
inArray2
inRtol	relative tolerance (default 1e-5)
inAtol	absolute tolerance (default 1e-9)

Returns: NdArray

Examples: ReadMe.cpp.

◆ isinf() [1/2]

template<typename dtype >

NdArray<bool> nc::isinf ( const NdArray< dtype > & inArray )

Test element-wise for inf and return result as a boolean array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isinf.html

Parameters

inArray

Returns: NdArray

◆ isinf() [2/2]

template<typename dtype >

bool nc::isinf ( dtype inValue )

noexcept

Test for inf and return result as a boolean.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isinf.html

Parameters

inValue

Returns: bool

◆ isnan() [1/2]

template<typename dtype >

NdArray<bool> nc::isnan ( const NdArray< dtype > & inArray )

Test element-wise for NaN and return result as a boolean array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isnan.html

Parameters

inArray

Returns: NdArray

◆ isnan() [2/2]

template<typename dtype >

bool nc::isnan ( dtype inValue )

noexcept

Test for NaN and return result as a boolean.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isnan.html

Parameters

inValue

Returns: bool

Examples: ReadMe.cpp.

◆ isneginf() [1/2]

template<typename dtype >

NdArray<bool> nc::isneginf ( const NdArray< dtype > & inArray )

Test element-wise for negative inf and return result as a boolean array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isneginf.html

Parameters

inArray

Returns: NdArray

◆ isneginf() [2/2]

template<typename dtype >

bool nc::isneginf ( dtype inValue )

noexcept

Test for negative inf and return result as a boolean.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isneginf.html

Parameters

inValue

Returns: bool

◆ isposinf() [1/2]

template<typename dtype >

NdArray<bool> nc::isposinf ( const NdArray< dtype > & inArray )

Test element-wise for positive inf and return result as a boolean array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isposinf.html

Parameters

inArray

Returns: NdArray

◆ isposinf() [2/2]

template<typename dtype >

bool nc::isposinf ( dtype inValue )

noexcept

Test for positive inf and return result as a boolean.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isposinf.html

Parameters

inValue

Returns: bool

◆ kaiser()

NdArray<double> nc::kaiser	(	int32	m,
		double	beta
	)

inline

The Kaiser window is a taper formed by using a Bessel function.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.kaiser.html

Parameters

m	Number of points in the output window. If zero or less, an empty array is returned.
beta	shape parameter for the window

Returns: NdArray

◆ lcm() [1/2]

template<typename dtype >

dtype nc::lcm ( const NdArray< dtype > & inArray )

Returns the least common multiple of the values of the input array. NOTE: Use of this function requires using the Boost includes.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.lcm.html

Parameters

inArray

Returns: NdArray<double>

◆ lcm() [2/2]

template<typename dtype >

dtype nc::lcm	(	dtype	inValue1,
		dtype	inValue2
	)

noexcept

Returns the least common multiple of |x1| and |x2|. NOTE: Use of this function requires either using the Boost includes or a C++17 compliant compiler.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.lcm.html

Parameters

inValue1
inValue2

Returns: dtype

◆ ldexp() [1/2]

template<typename dtype >

NdArray<dtype> nc::ldexp	(	const NdArray< dtype > &	inArray1,
		const NdArray< uint8 > &	inArray2
	)

Returns x1 * 2^x2, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ldexp.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ ldexp() [2/2]

template<typename dtype >

dtype nc::ldexp	(	dtype	inValue1,
		uint8	inValue2
	)

noexcept

Returns x1 * 2^x2.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ldexp.html

Parameters

inValue1
inValue2

Returns: value

◆ left_shift()

template<typename dtype >

NdArray<dtype> nc::left_shift	(	const NdArray< dtype > &	inArray,
		uint8	inNumBits
	)

Shift the bits of an integer to the left.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.left_shift.html

Parameters

inArray
inNumBits

Returns: NdArray

◆ less()

template<typename dtype >

NdArray<bool> nc::less	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Return the truth value of (x1 < x2) element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.less.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ less_equal()

template<typename dtype >

NdArray<bool> nc::less_equal	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Return the truth value of (x1 <= x2) element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.less_equal.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ linspace()

template<typename dtype >

NdArray<dtype> nc::linspace	(	dtype	inStart,
		dtype	inStop,
		uint32	inNum = `50`,
		bool	endPoint = `true`
	)

Return evenly spaced numbers over a specified interval.

Returns num evenly spaced samples, calculated over the interval[start, stop].

The endpoint of the interval can optionally be excluded.

Mostly only usefull if called with a floating point type for the template argument.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.linspace.html

Parameters

inStart
inStop
inNum	number of points (default = 50)
endPoint	include endPoint (default = true)

Returns: NdArray

◆ load()

template<typename dtype >

NdArray<dtype> nc::load ( const std::string & inFilename )

loads a .bin file from the dump() method into an NdArray

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.load.html

Parameters

inFilename

Returns: NdArray

◆ log() [1/2]

template<typename dtype >

auto nc::log ( const NdArray< dtype > & inArray )

Natural logarithm, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.log.html

Parameters

inArray

Returns: NdArray

◆ log() [2/2]

template<typename dtype >

auto nc::log ( dtype inValue )

noexcept

Natural logarithm.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.log.html

Parameters

inValue

Returns: value

Examples: ReadMe.cpp.

◆ log10() [1/2]

template<typename dtype >

auto nc::log10 ( const NdArray< dtype > & inArray )

Return the base 10 logarithm of the input array, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.log10.html

Parameters

inArray

Returns: NdArray

◆ log10() [2/2]

template<typename dtype >

auto nc::log10 ( dtype inValue )

noexcept

Return the base 10 logarithm of the input array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.log10.html

Parameters

inValue

Returns: value

◆ log1p() [1/2]

template<typename dtype >

auto nc::log1p ( const NdArray< dtype > & inArray )

Return the natural logarithm of one plus the input array, element-wise.

Calculates log(1 + x).

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.log1p.html

Parameters

inArray

Returns: NdArray

◆ log1p() [2/2]

template<typename dtype >

auto nc::log1p ( dtype inValue )

noexcept

Return the natural logarithm of one plus the input array.

Calculates log(1 + x).

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.log1p.html

Parameters

inValue

Returns: value

Examples: ReadMe.cpp.

◆ log2() [1/2]

template<typename dtype >

auto nc::log2 ( const NdArray< dtype > & inArray )

Base-2 logarithm of x.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.log2.html

Parameters

inArray

Returns: NdArray

◆ log2() [2/2]

template<typename dtype >

auto nc::log2 ( dtype inValue )

noexcept

Base-2 logarithm of x.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.log2.html

Parameters

inValue

Returns: value

◆ logb() [1/2]

template<typename dtype >

auto nc::logb	(	const NdArray< dtype > &	inArray,
		dtype	inBase
	)

Logarithm of an arbitrary base

Parameters

inArray
inBase	the logorithm base

Returns: NdArray

◆ logb() [2/2]

template<typename dtype >

auto nc::logb	(	dtype	inValue,
		dtype	inBase
	)

noexcept

Logarithm of an arbitrary base

Parameters

inValue
inBase	the logorithm base

Returns: value

◆ logical_and()

template<typename dtype >

NdArray<bool> nc::logical_and	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Compute the truth value of x1 AND x2 element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.logical_and.html

Parameters

inArray1
inArray2

Returns: NdArray

Examples: ReadMe.cpp.

◆ logical_not()

template<typename dtype >

NdArray<bool> nc::logical_not ( const NdArray< dtype > & inArray )

Compute the truth value of NOT x element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.logical_not.html

Parameters

inArray

Returns: NdArray

◆ logical_or()

template<typename dtype >

NdArray<bool> nc::logical_or	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Compute the truth value of x1 OR x2 element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.logical_or.html

Parameters

inArray1
inArray2

Returns: NdArray

Examples: ReadMe.cpp.

◆ logical_xor()

template<typename dtype >

NdArray<bool> nc::logical_xor	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Compute the truth value of x1 XOR x2 element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.logical_xor.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ logspace()

template<typename dtype >

NdArray<double> nc::logspace	(	dtype	start,
		dtype	stop,
		uint32	num = `50`,
		bool	endPoint = `true`,
		double	base = `10.0`
	)

Return numbers spaced evenly on a log scale.

This is similar to logspace, but with endpoints specified directly. Each output sample is a constant multiple of the previous.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.logspace.html

Parameters

start	the starting value of a sequence
stop	The final value of the sequence, unless endpoint is False. In that case, num + 1 values are spaced over the interval in log-space, of which all but the last (a sequence of length num) are returned.
num	Number of samples to generate. Default 50.
endPoint	If true, stop is the last sample. Otherwise,it is not included. Default is true.
base	The base of the log space. The step size between the elements in ln(samples) / ln(base)

Returns: NdArray

◆ matmul() [1/3]

template<typename dtype >

NdArray<dtype> nc::matmul	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Matrix product of two arrays.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.matmul.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ matmul() [2/3]

template<typename dtype >

NdArray<std::complex<dtype> > nc::matmul	(	const NdArray< dtype > &	inArray1,
		const NdArray< std::complex< dtype >> &	inArray2
	)

Matrix product of two arrays.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.matmul.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ matmul() [3/3]

template<typename dtype >

NdArray<std::complex<dtype> > nc::matmul	(	const NdArray< std::complex< dtype >> &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Matrix product of two arrays.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.matmul.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ max()

template<typename dtype >

NdArray<dtype> nc::max	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Return the maximum of an array or maximum along an axis.

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

Examples: ReadMe.cpp.

◆ maximum()

template<typename dtype >

NdArray<dtype> nc::maximum	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Element-wise maximum of array elements.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.maximum.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ mean() [1/2]

template<typename dtype >

NdArray<double> nc::mean	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Compute the mean along the specified axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.mean.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

Examples: ReadMe.cpp.

◆ mean() [2/2]

template<typename dtype >

NdArray<std::complex<double> > nc::mean	(	const NdArray< std::complex< dtype >> &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Compute the mean along the specified axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.mean.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ median()

template<typename dtype >

NdArray<dtype> nc::median	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Compute the median along the specified axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.median.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ meshgrid() [1/2]

template<typename dtype >

std::pair<NdArray<dtype>, NdArray<dtype> > nc::meshgrid	(	const NdArray< dtype > &	inICoords,
		const NdArray< dtype > &	inJCoords
	)

Return coordinate matrices from coordinate vectors. Make 2D coordinate arrays for vectorized evaluations of 2D scaler vector fields over 2D grids, given one - dimensional coordinate arrays x1, x2, ..., xn. If input arrays are not one dimensional they will be flattened.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.meshgrid.html

Parameters

inICoords
inJCoords

Returns: std::pair<NdArray<dtype>, NdArray<dtype> >, i and j matrices

◆ meshgrid() [2/2]

template<typename dtype >

std::pair<NdArray<dtype>, NdArray<dtype> > nc::meshgrid	(	const Slice &	inSlice1,
		const Slice &	inSlice2
	)

Return coordinate matrices from coordinate vectors. Make 2D coordinate arrays for vectorized evaluations of 2D scaler vector fields over 2D grids, given one - dimensional coordinate arrays x1, x2, ..., xn.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.meshgrid.html

Parameters

inSlice1
inSlice2

Returns: std::pair<NdArray<dtype>, NdArray<dtype> >, i and j matrices

◆ min()

template<typename dtype >

NdArray<dtype> nc::min	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Return the minimum of an array or minimum along an axis.

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

Examples: ReadMe.cpp.

◆ minimum()

template<typename dtype >

NdArray<dtype> nc::minimum	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Element-wise minimum of array elements.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.minimum.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ mod()

template<typename dtype >

NdArray<dtype> nc::mod	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Return element-wise remainder of division.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.mod.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ multiply() [1/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::multiply	(	const NdArray< dtype > &	inArray,
		const std::complex< dtype > &	value
	)

multiply arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.multiply.html

Parameters

inArray
value

Returns: NdArray

◆ multiply() [2/9]

template<typename dtype >

NdArray<dtype> nc::multiply	(	const NdArray< dtype > &	inArray,
		dtype	value
	)

multiply arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.multiply.html

Parameters

inArray
value

Returns: NdArray

◆ multiply() [3/9]

template<typename dtype >

NdArray<dtype> nc::multiply	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

multiply arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.multiply.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ multiply() [4/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::multiply	(	const NdArray< dtype > &	inArray1,
		const NdArray< std::complex< dtype >> &	inArray2
	)

multiply arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.multiply.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ multiply() [5/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::multiply	(	const NdArray< std::complex< dtype >> &	inArray,
		dtype	value
	)

multiply arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.multiply.html

Parameters

inArray
value

Returns: NdArray

◆ multiply() [6/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::multiply	(	const NdArray< std::complex< dtype >> &	inArray1,
		const NdArray< dtype > &	inArray2
	)

multiply arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.multiply.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ multiply() [7/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::multiply	(	const std::complex< dtype > &	value,
		const NdArray< dtype > &	inArray
	)

multiply arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.multiply.html

Parameters

value
inArray

Returns: NdArray

◆ multiply() [8/9]

template<typename dtype >

NdArray<dtype> nc::multiply	(	dtype	value,
		const NdArray< dtype > &	inArray
	)

multiply arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.multiply.html

Parameters

value
inArray

Returns: NdArray

◆ multiply() [9/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::multiply	(	dtype	value,
		const NdArray< std::complex< dtype >> &	inArray
	)

multiply arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.multiply.html

Parameters

value
inArray

Returns: NdArray

◆ nan_to_num()

template<typename dtype >

NdArray<dtype> nc::nan_to_num	(	NdArray< dtype >	inArray,
		dtype	nan = `static_cast<dtype>(0.0)`,
		dtype	posInf = `DtypeInfo<dtype>::max()`,
		dtype	negInf = `DtypeInfo<dtype>::min()`
	)

Replace NaN with zero and infinity with large finite numbers (default behaviour) or with the numbers defined by the user using the nan, posinf and/or neginf keywords.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.nan_to_num.html

Parameters

inArray
nan	value to be used to fill NaN values, default 0
posInf	value to be used to fill positive infinity values, default a very large number
negInf	value to be used to fill negative infinity values, default a very large negative number

Returns: NdArray

◆ nanargmax()

template<typename dtype >

NdArray<uint32> nc::nanargmax	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Returns the indices of the maximum values along an axis ignoring NaNs.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanargmax.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ nanargmin()

template<typename dtype >

NdArray<uint32> nc::nanargmin	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Returns the indices of the minimum values along an axis ignoring NaNs.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanargmin.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ nancumprod()

template<typename dtype >

NdArray<dtype> nc::nancumprod	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Return the cumulative product of elements along a given axis ignoring NaNs.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nancumprod.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ nancumsum()

template<typename dtype >

NdArray<dtype> nc::nancumsum	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Return the cumulative sum of the elements along a given axis ignoring NaNs.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nancumsum.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ nanmax()

template<typename dtype >

NdArray<dtype> nc::nanmax	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Return the maximum of an array or maximum along an axis ignoring NaNs.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanmax.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ nanmean()

template<typename dtype >

NdArray<double> nc::nanmean	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Compute the mean along the specified axis ignoring NaNs.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanmean.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ nanmedian()

template<typename dtype >

NdArray<dtype> nc::nanmedian	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Compute the median along the specified axis ignoring NaNs.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanmedian.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ nanmin()

template<typename dtype >

NdArray<dtype> nc::nanmin	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Return the minimum of an array or maximum along an axis ignoring NaNs.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanmin.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ nanpercentile()

template<typename dtype >

NdArray<double> nc::nanpercentile	(	const NdArray< dtype > &	inArray,
		double	inPercentile,
		Axis	inAxis = `Axis::NONE`,
		const std::string &	inInterpMethod = `"linear"`
	)

Compute the qth percentile of the data along the specified axis, while ignoring nan values.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanpercentile.html

Parameters

inArray
inPercentile
inAxis	(Optional, default NONE)
inInterpMethod	(default linear) choices = ['linear','lower','higher','nearest','midpoint']

Returns: NdArray

◆ nanprod()

template<typename dtype >

NdArray<dtype> nc::nanprod	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Return the product of array elements over a given axis treating Not a Numbers (NaNs) as ones.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanprod.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ nans() [1/3]

NdArray<double> nc::nans ( const Shape & inShape )

inline

Return a new array of given shape and type, filled with nans. Only really works for dtype = float/double

Parameters

inShape

Returns: NdArray

◆ nans() [2/3]

NdArray<double> nc::nans	(	uint32	inNumRows,
		uint32	inNumCols
	)

inline

Return a new array of given shape and type, filled with nans. Only really works for dtype = float/double

Parameters

inNumRows
inNumCols

Returns: NdArray

◆ nans() [3/3]

NdArray<double> nc::nans ( uint32 inSquareSize )

inline

Return a new array of given shape and type, filled with nans. Only really works for dtype = float/double

Parameters

inSquareSize

Returns: NdArray

Examples: ReadMe.cpp.

◆ nans_like()

template<typename dtype >

NdArray<double> nc::nans_like ( const NdArray< dtype > & inArray )

Return a new array of given shape and type, filled with nans.

Parameters

inArray

Returns: NdArray

◆ nanstdev()

template<typename dtype >

NdArray<double> nc::nanstdev	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Compute the standard deviation along the specified axis, while ignoring NaNs.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanstd.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ nansum()

template<typename dtype >

NdArray<dtype> nc::nansum	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Return the sum of array elements over a given axis treating Not a Numbers (NaNs) as zero.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nansum.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ nanvar()

template<typename dtype >

NdArray<double> nc::nanvar	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Compute the variance along the specified axis, while ignoring NaNs.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanvar.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ nbytes()

template<typename dtype >

uint64 nc::nbytes ( const NdArray< dtype > & inArray )

noexcept

Returns the number of bytes held by the array

Parameters

inArray

Returns: number of bytes

◆ negative()

template<typename dtype >

NdArray<dtype> nc::negative ( const NdArray< dtype > & inArray )

Numerical negative, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.negative.html

Parameters

inArray

Returns: NdArray

◆ newbyteorder() [1/2]

template<typename dtype >

NdArray<dtype> nc::newbyteorder	(	const NdArray< dtype > &	inArray,
		Endian	inEndianess
	)

Return the array with the same data viewed with a different byte order. only works for integer types, floating point types will not compile and you will be confused as to why...

Parameters

inArray
inEndianess

Returns: NdArray

◆ newbyteorder() [2/2]

template<typename dtype >

dtype nc::newbyteorder	(	dtype	inValue,
		Endian	inEndianess
	)

Return the array with the same data viewed with a different byte order. only works for integer types, floating point types will not compile and you will be confused as to why...

Parameters

inValue
inEndianess

Returns: inValue

◆ none()

template<typename dtype >

NdArray<bool> nc::none	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Test whether no array elements along a given axis evaluate to True.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.all.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: bool

◆ nonzero()

template<typename dtype >

std::pair<NdArray<uint32>, NdArray<uint32> > nc::nonzero ( const NdArray< dtype > & inArray )

Return the indices of the flattened array of the elements that are non-zero.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nonzero.html

Parameters

inArray

Returns: NdArray

Examples: ReadMe.cpp.

◆ norm() [1/2]

template<typename dtype >

NdArray<double> nc::norm	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Matrix or vector norm.

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ norm() [2/2]

template<typename dtype >

NdArray<std::complex<double> > nc::norm	(	const NdArray< std::complex< dtype >> &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Matrix or vector norm.

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ not_equal()

template<typename dtype >

NdArray<bool> nc::not_equal	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Return (x1 != x2) element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.not_equal.html

Parameters

inArray1
inArray2

Returns: NdArray

Examples: ReadMe.cpp.

◆ nth_root() [1/2]

template<typename dtype1 , typename dtype2 >

NdArray<double> nc::nth_root	(	const NdArray< dtype1 > &	inArray,
		dtype2	inRoot
	)

Return the nth-root of an array.

Parameters

inArray
inRoot

Returns: NdArray

◆ nth_root() [2/2]

template<typename dtype1 , typename dtype2 >

double nc::nth_root	(	dtype1	inValue,
		dtype2	inRoot
	)

noexcept

Return the nth-root of an value.

Parameters

inValue
inRoot

Returns: value

◆ ones() [1/3]

template<typename dtype >

NdArray<dtype> nc::ones ( const Shape & inShape )

Return a new array of given shape and type, filled with ones.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ones.html

Parameters

inShape

Returns: NdArray

◆ ones() [2/3]

template<typename dtype >

NdArray<dtype> nc::ones	(	uint32	inNumRows,
		uint32	inNumCols
	)

Return a new array of given shape and type, filled with ones.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ones.html

Parameters

inNumRows
inNumCols

Returns: NdArray

◆ ones() [3/3]

template<typename dtype >

NdArray<dtype> nc::ones ( uint32 inSquareSize )

Return a new array of given shape and type, filled with ones.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ones.html

Parameters

inSquareSize

Returns: NdArray

◆ ones_like()

template<typename dtypeOut , typename dtype >

NdArray<dtypeOut> nc::ones_like ( const NdArray< dtype > & inArray )

Return a new array of given shape and type, filled with ones.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ones_like.html

Parameters

inArray

Returns: NdArray

◆ operator!()

template<typename dtype >

NdArray<bool> nc::operator! ( const NdArray< dtype > & inArray )

Takes the not of the array

Parameters

inArray

Returns: NdArray

◆ operator!=() [1/3]

template<typename dtype >

NdArray<bool> nc::operator!=	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Returns an array of booleans of element wise comparison of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator!=() [2/3]

template<typename dtype >

NdArray<bool> nc::operator!=	(	const NdArray< dtype > &	lhs,
		dtype	inValue
	)

Returns an array of booleans of element wise comparison an array and a scaler

Parameters

lhs
inValue

Returns: NdArray

◆ operator!=() [3/3]

template<typename dtype >

NdArray<bool> nc::operator!=	(	dtype	inValue,
		const NdArray< dtype > &	inArray
	)

Returns an array of booleans of element wise comparison an array and a scaler

Parameters

inValue
inArray

Returns: NdArray

◆ operator%() [1/3]

template<typename dtype >

NdArray<dtype> nc::operator%	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Takes the modulus of the elements of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator%() [2/3]

template<typename dtype >

NdArray<dtype> nc::operator%	(	const NdArray< dtype > &	lhs,
		dtype	rhs
	)

Modulus of the array and the scaler

Parameters

lhs
rhs

Returns: NdArray

◆ operator%() [3/3]

template<typename dtype , enable_if_t< std::is_integral< dtype >::value, int > = 0>

NdArray< dtype > nc::operator%	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Modulus of the scaler and the array

Parameters

lhs
rhs

Returns: NdArray

◆ operator%=() [1/2]

template<typename dtype , enable_if_t< std::is_integral< dtype >::value, int > = 0>

NdArray< dtype > & nc::operator%=	(	NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Modulus the elements of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator%=() [2/2]

template<typename dtype , enable_if_t< std::is_integral< dtype >::value, int > = 0>

NdArray< dtype > & nc::operator%=	(	NdArray< dtype > &	lhs,
		dtype	rhs
	)

Modulus the scaler to the array

Parameters

lhs
rhs

Returns: NdArray

◆ operator&() [1/3]

template<typename dtype >

NdArray<dtype> nc::operator&	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Takes the bitwise and of the elements of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator&() [2/3]

template<typename dtype >

NdArray<dtype> nc::operator&	(	const NdArray< dtype > &	lhs,
		dtype	rhs
	)

Takes the bitwise and of the array and the scaler

Parameters

lhs
rhs

Returns: NdArray

◆ operator&() [3/3]

template<typename dtype >

NdArray<dtype> nc::operator&	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Takes the bitwise and of the sclar and the array

Parameters

lhs
rhs

Returns: NdArray

◆ operator&&() [1/3]

template<typename dtype >

NdArray<bool> nc::operator&&	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Takes the and of the elements of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator&&() [2/3]

template<typename dtype >

NdArray<bool> nc::operator&&	(	const NdArray< dtype > &	lhs,
		dtype	rhs
	)

Takes the and of the array and the scaler

Parameters

lhs
rhs

Returns: NdArray

◆ operator&&() [3/3]

template<typename dtype >

NdArray<bool> nc::operator&&	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Takes the and of the array and the scaler

Parameters

lhs
rhs

Returns: NdArray

◆ operator&=() [1/2]

template<typename dtype >

NdArray<dtype>& nc::operator&=	(	NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Bitwise and the elements of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator&=() [2/2]

template<typename dtype >

NdArray<dtype>& nc::operator&=	(	NdArray< dtype > &	lhs,
		dtype	rhs
	)

Bitwise and the scaler to the array

Parameters

lhs
rhs

Returns: NdArray

◆ operator*() [1/15]

template<typename dtype >

NdArray<dtype> nc::operator*	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Multiplies the elements of two arrays (1)

Parameters

lhs
rhs

Returns: NdArray

◆ operator*() [2/15]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator*	(	const NdArray< dtype > &	lhs,
		const NdArray< std::complex< dtype >> &	rhs
	)

Multiplies the elements of two arrays (2)

Parameters

lhs
rhs

Returns: NdArray

◆ operator*() [3/15]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator*	(	const NdArray< dtype > &	lhs,
		const std::complex< dtype > &	rhs
	)

Multiplies the scaler to the array (6)

Parameters

lhs
rhs

Returns: NdArray

◆ operator*() [4/15]

template<typename dtype >

NdArray<dtype> nc::operator*	(	const NdArray< dtype > &	lhs,
		dtype	rhs
	)

Multiplies the scaler to the array (4)

Parameters

lhs
rhs

Returns: NdArray

◆ operator*() [5/15]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator*	(	const NdArray< std::complex< dtype >> &	lhs,
		const NdArray< dtype > &	rhs
	)

Multiplies the elements of two arrays (3)

Parameters

lhs
rhs

Returns: NdArray

◆ operator*() [6/15]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator*	(	const NdArray< std::complex< dtype >> &	lhs,
		dtype	rhs
	)

Multiplies the scaler to the array (8)

Parameters

lhs
rhs

Returns: NdArray

◆ operator*() [7/15]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator*	(	const std::complex< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Multiplies the scaler to the array (7)

Parameters

lhs
rhs

Returns: NdArray

◆ operator*() [8/15]

double nc::operator*	(	const Vec2 &	lhs,
		const Vec2 &	rhs
	)

inlinenoexcept

Vector mulitplication (dot product)

Parameters

lhs
rhs

Returns: dot product

◆ operator*() [9/15]

Vec2 nc::operator*	(	const Vec2 &	lhs,
		double	rhs
	)

inlinenoexcept

Scalar mulitplication

Parameters

lhs
rhs

Returns: Vec2

◆ operator*() [10/15]

double nc::operator*	(	const Vec3 &	lhs,
		const Vec3 &	rhs
	)

inlinenoexcept

Vector mulitplication (dot product)

Parameters

lhs
rhs

Returns: dot product

◆ operator*() [11/15]

Vec3 nc::operator*	(	const Vec3 &	lhs,
		double	rhs
	)

inlinenoexcept

Scalar mulitplication

Parameters

lhs
rhs

Returns: Vec3

◆ operator*() [12/15]

Vec2 nc::operator*	(	double	lhs,
		const Vec2 &	rhs
	)

inlinenoexcept

Scalar mulitplication

Parameters

lhs
rhs

Returns: Vec2

◆ operator*() [13/15]

Vec3 nc::operator*	(	double	lhs,
		const Vec3 &	rhs
	)

inlinenoexcept

Scalar mulitplication

Parameters

lhs
rhs

Returns: Vec3

◆ operator*() [14/15]

template<typename dtype >

NdArray<dtype> nc::operator*	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Multiplies the scaler to the array (5)

Parameters

lhs
rhs

Returns: NdArray

◆ operator*() [15/15]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator*	(	dtype	lhs,
		const NdArray< std::complex< dtype >> &	rhs
	)

Multiplies the scaler to the array (9)

Parameters

lhs
rhs

Returns: NdArray

◆ operator*=() [1/4]

template<typename dtype >

NdArray<dtype>& nc::operator*=	(	NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Multiplies the elements of two arrays (1)

Parameters

lhs
rhs

Returns: NdArray

◆ operator*=() [2/4]

template<typename dtype >

NdArray<dtype>& nc::operator*=	(	NdArray< dtype > &	lhs,
		dtype	rhs
	)

Multiplies the scaler to the array (3)

Parameters

lhs
rhs

Returns: NdArray

◆ operator*=() [3/4]

template<typename dtype >

NdArray<std::complex<dtype> >& nc::operator*=	(	NdArray< std::complex< dtype >> &	lhs,
		const NdArray< dtype > &	rhs
	)

Multiplies the elements of two arrays (2)

Parameters

lhs
rhs

Returns: NdArray

◆ operator*=() [4/4]

template<typename dtype >

NdArray<std::complex<dtype> >& nc::operator*=	(	NdArray< std::complex< dtype >> &	lhs,
		dtype	rhs
	)

Multiplies the scaler to the array (4)

Parameters

lhs
rhs

Returns: NdArray

◆ operator+() [1/19]

template<typename dtype >

NdArray<dtype> nc::operator+	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Adds the elements of two arrays (1)

Parameters

lhs
rhs

Returns: NdArray

◆ operator+() [2/19]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator+	(	const NdArray< dtype > &	lhs,
		const NdArray< std::complex< dtype >> &	rhs
	)

Adds the elements of two arrays (2)

Parameters

lhs
rhs

Returns: NdArray

◆ operator+() [3/19]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator+	(	const NdArray< dtype > &	lhs,
		const std::complex< dtype > &	rhs
	)

Adds the scaler to the array (6)

Parameters

lhs
rhs

Returns: NdArray

◆ operator+() [4/19]

template<typename dtype >

NdArray<dtype> nc::operator+	(	const NdArray< dtype > &	lhs,
		dtype	rhs
	)

Adds the scaler to the array (4)

Parameters

lhs
rhs

Returns: NdArray

◆ operator+() [5/19]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator+	(	const NdArray< std::complex< dtype >> &	lhs,
		const NdArray< dtype > &	rhs
	)

Adds the elements of two arrays (3)

Parameters

lhs
rhs

Returns: NdArray

◆ operator+() [6/19]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator+	(	const NdArray< std::complex< dtype >> &	lhs,
		dtype	rhs
	)

Adds the scaler to the array (8)

Parameters

lhs
rhs

Returns: NdArray

◆ operator+() [7/19]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator+	(	const std::complex< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Adds the scaler to the array (7)

Parameters

lhs
rhs

Returns: NdArray

◆ operator+() [8/19]

Vec2 nc::operator+	(	const Vec2 &	lhs,
		const Vec2 &	rhs
	)

inlinenoexcept

Adds the two vectors

Parameters

lhs
rhs

Returns: Vec2

◆ operator+() [9/19]

Vec2 nc::operator+	(	const Vec2 &	lhs,
		double	rhs
	)

inlinenoexcept

Adds the scaler to the vector

Parameters

lhs
rhs

Returns: Vec2

◆ operator+() [10/19]

Vec3 nc::operator+	(	const Vec3 &	lhs,
		const Vec3 &	rhs
	)

inlinenoexcept

Adds the two vectors

Parameters

lhs
rhs

Returns: Vec3

◆ operator+() [11/19]

Vec3 nc::operator+	(	const Vec3 &	lhs,
		double	rhs
	)

inlinenoexcept

Adds the scaler to the vector

Parameters

lhs
rhs

Returns: Vec3

◆ operator+() [12/19]

Vec2 nc::operator+	(	double	lhs,
		const Vec2 &	rhs
	)

inlinenoexcept

Adds the scaler to the vector

Parameters

lhs
rhs

Returns: Vec2

◆ operator+() [13/19]

Vec3 nc::operator+	(	double	lhs,
		const Vec3 &	rhs
	)

inlinenoexcept

Adds the scaler to the vector

Parameters

lhs
rhs

Returns: Vec3

◆ operator+() [14/19]

template<typename dtype >

NdArray<dtype> nc::operator+	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Adds the scaler to the array (5)

Parameters

lhs
rhs

Returns: NdArray

◆ operator+() [15/19]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator+	(	dtype	lhs,
		const NdArray< std::complex< dtype >> &	rhs
	)

Adds the scaler to the array (9)

Parameters

lhs
rhs

Returns: NdArray

◆ operator+() [16/19]

template<class dtype , typename SizeType , typename PointerType , typename DifferenceType >

NdArrayColumnIterator<dtype, SizeType, PointerType, DifferenceType> nc::operator+	(	typename NdArrayColumnIterator< dtype, SizeType, PointerType, DifferenceType >::difference_type	offset,
		NdArrayColumnIterator< dtype, SizeType, PointerType, DifferenceType >	next
	)

noexcept

Iterator addition operator

Parameters

offset
next

Returns: bool

◆ operator+() [17/19]

template<class dtype , typename SizeType , typename PointerType , typename DifferenceType >

NdArrayConstColumnIterator<dtype, SizeType, PointerType, DifferenceType> nc::operator+	(	typename NdArrayConstColumnIterator< dtype, SizeType, PointerType, DifferenceType >::difference_type	offset,
		NdArrayConstColumnIterator< dtype, SizeType, PointerType, DifferenceType >	next
	)

noexcept

Iterator addition operator

Parameters

offset
next

Returns: bool

◆ operator+() [18/19]

template<class dtype , typename PointerType , typename DifferenceType >

NdArrayConstIterator<dtype, PointerType, DifferenceType> nc::operator+	(	typename NdArrayConstIterator< dtype, PointerType, DifferenceType >::difference_type	offset,
		NdArrayConstIterator< dtype, PointerType, DifferenceType >	next
	)

noexcept

Iterator addition operator

Parameters

offset
next

Returns: bool

◆ operator+() [19/19]

template<class dtype , typename PointerType , typename DifferenceType >

NdArrayIterator<dtype, PointerType, DifferenceType> nc::operator+	(	typename NdArrayIterator< dtype, PointerType, DifferenceType >::difference_type	offset,
		NdArrayIterator< dtype, PointerType, DifferenceType >	next
	)

noexcept

Iterator addition operator

Parameters

offset
next

Returns: NdArrayIterator

◆ operator++() [1/2]

template<typename dtype >

NdArray<dtype> nc::operator++	(	NdArray< dtype > &	lhs,
		int
	)

postfix increments the elements of an array

Parameters

lhs

Returns: NdArray

◆ operator++() [2/2]

template<typename dtype >

NdArray<dtype>& nc::operator++ ( NdArray< dtype > & rhs )

prefix incraments the elements of an array

Returns: NdArray

◆ operator+=() [1/4]

template<typename dtype >

NdArray<dtype>& nc::operator+=	(	NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Adds the elements of two arrays (1)

Parameters

lhs
rhs

Returns: NdArray

◆ operator+=() [2/4]

template<typename dtype >

NdArray<dtype>& nc::operator+=	(	NdArray< dtype > &	lhs,
		dtype	rhs
	)

Adds the scaler to the array (3)

Parameters

lhs
rhs

Returns: NdArray

◆ operator+=() [3/4]

template<typename dtype >

NdArray<std::complex<dtype> >& nc::operator+=	(	NdArray< std::complex< dtype >> &	lhs,
		const NdArray< dtype > &	rhs
	)

Adds the elements of two arrays (2)

Parameters

lhs
rhs

Returns: NdArray

◆ operator+=() [4/4]

template<typename dtype >

NdArray<std::complex<dtype> >& nc::operator+=	(	NdArray< std::complex< dtype >> &	lhs,
		dtype	rhs
	)

Adds the scaler to the array (4)

Parameters

lhs
rhs

Returns: NdArray

◆ operator-() [1/18]

template<typename dtype >

NdArray<dtype> nc::operator- ( const NdArray< dtype > & inArray )

Negative Operator

Returns: NdArray

◆ operator-() [2/18]

template<typename dtype >

NdArray<dtype> nc::operator-	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Subtracts the elements of two arrays (1)

Parameters

lhs
rhs

Returns: NdArray

◆ operator-() [3/18]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator-	(	const NdArray< dtype > &	lhs,
		const NdArray< std::complex< dtype >> &	rhs
	)

Subtracts the elements of two arrays (2)

Parameters

lhs
rhs

Returns: NdArray

◆ operator-() [4/18]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator-	(	const NdArray< dtype > &	lhs,
		const std::complex< dtype > &	rhs
	)

Subtracts the scaler from the array (6)

Parameters

lhs
rhs

Returns: NdArray

◆ operator-() [5/18]

template<typename dtype >

NdArray<dtype> nc::operator-	(	const NdArray< dtype > &	lhs,
		dtype	rhs
	)

Subtracts the scaler from the array (4)

Parameters

lhs
rhs

Returns: NdArray

◆ operator-() [6/18]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator-	(	const NdArray< std::complex< dtype >> &	lhs,
		const NdArray< dtype > &	rhs
	)

Subtracts the elements of two arrays (3)

Parameters

lhs
rhs

Returns: NdArray

◆ operator-() [7/18]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator-	(	const NdArray< std::complex< dtype >> &	lhs,
		dtype	rhs
	)

Subtracts the scaler from the array (8)

Parameters

lhs
rhs

Returns: NdArray

◆ operator-() [8/18]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator-	(	const std::complex< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Subtracts the scaler from the array (7)

Parameters

lhs
rhs

Returns: NdArray

◆ operator-() [9/18]

Vec2 nc::operator-	(	const Vec2 &	lhs,
		const Vec2 &	rhs
	)

inlinenoexcept

Subtracts the two vectors

Parameters

lhs
rhs

Returns: Vec2

◆ operator-() [10/18]

Vec2 nc::operator-	(	const Vec2 &	lhs,
		double	rhs
	)

inlinenoexcept

Subtracts the scaler from the vector

Parameters

lhs
rhs

Returns: Vec2

◆ operator-() [11/18]

Vec2 nc::operator- ( const Vec2 & vec )

inlinenoexcept

Returns the negative vector

Returns: Vec2

◆ operator-() [12/18]

Vec3 nc::operator-	(	const Vec3 &	lhs,
		const Vec3 &	rhs
	)

inlinenoexcept

Subtracts the two vectors

Parameters

lhs
rhs

Returns: Vec3

◆ operator-() [13/18]

Vec3 nc::operator-	(	const Vec3 &	lhs,
		double	rhs
	)

inlinenoexcept

Subtracts the scaler from the vector

Parameters

lhs
rhs

Returns: Vec3

◆ operator-() [14/18]

Vec3 nc::operator- ( const Vec3 & vec )

inlinenoexcept

Returns the negative vector

Returns: Vec3

◆ operator-() [15/18]

Vec2 nc::operator-	(	double	lhs,
		const Vec2 &	rhs
	)

inlinenoexcept

Subtracts the scaler from the vector

Parameters

lhs
rhs

Returns: Vec2

◆ operator-() [16/18]

Vec3 nc::operator-	(	double	lhs,
		const Vec3 &	rhs
	)

inlinenoexcept

Subtracts the scaler from the vector

Parameters

lhs
rhs

Returns: Vec3

◆ operator-() [17/18]

template<typename dtype >

NdArray<dtype> nc::operator-	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Subtracts the scaler from the array (5)

Parameters

lhs
rhs

Returns: NdArray

◆ operator-() [18/18]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator-	(	dtype	lhs,
		const NdArray< std::complex< dtype >> &	rhs
	)

Subtracts the scaler from the array (9)

Parameters

lhs
rhs

Returns: NdArray

◆ operator--() [1/2]

template<typename dtype >

NdArray<dtype> nc::operator--	(	NdArray< dtype > &	lhs,
		int
	)

postfix decrements the elements of an array

Parameters

lhs

Returns: NdArray

◆ operator--() [2/2]

template<typename dtype >

NdArray<dtype>& nc::operator-- ( NdArray< dtype > & rhs )

prefix decrements the elements of an array

Returns: NdArray

◆ operator-=() [1/4]

template<typename dtype >

NdArray<dtype>& nc::operator-=	(	NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Subtracts the elements of two arrays (1)

Parameters

lhs
rhs

Returns: NdArray

◆ operator-=() [2/4]

template<typename dtype >

NdArray<dtype>& nc::operator-=	(	NdArray< dtype > &	lhs,
		dtype	rhs
	)

Subtracts the scaler from the array (3)

Parameters

lhs
rhs

Returns: NdArray

◆ operator-=() [3/4]

template<typename dtype >

NdArray<std::complex<dtype> >& nc::operator-=	(	NdArray< std::complex< dtype >> &	lhs,
		const NdArray< dtype > &	rhs
	)

Subtracts the elements of two arrays (2)

Parameters

lhs
rhs

Returns: NdArray

◆ operator-=() [4/4]

template<typename dtype >

NdArray<std::complex<dtype> >& nc::operator-=	(	NdArray< std::complex< dtype >> &	lhs,
		dtype	rhs
	)

Subtracts the scaler from the array (4)

Parameters

lhs
rhs

Returns: NdArray

◆ operator/() [1/11]

template<typename dtype >

NdArray<dtype> nc::operator/	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Divides the elements of two arrays (1)

Parameters

lhs
rhs

Returns: NdArray

◆ operator/() [2/11]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator/	(	const NdArray< dtype > &	lhs,
		const NdArray< std::complex< dtype >> &	rhs
	)

Divides the elements of two arrays (2)

Parameters

lhs
rhs

Returns: NdArray

◆ operator/() [3/11]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator/	(	const NdArray< dtype > &	lhs,
		const std::complex< dtype > &	rhs
	)

Divides the scaler from the array (6)

Parameters

lhs
rhs

Returns: NdArray

◆ operator/() [4/11]

template<typename dtype >

NdArray<dtype> nc::operator/	(	const NdArray< dtype > &	lhs,
		dtype	rhs
	)

Divides the scaler from the array (4)

Parameters

lhs
rhs

Returns: NdArray

◆ operator/() [5/11]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator/	(	const NdArray< std::complex< dtype >> &	lhs,
		const NdArray< dtype > &	rhs
	)

Divides the elements of two arrays (3)

Parameters

lhs
rhs

Returns: NdArray

◆ operator/() [6/11]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator/	(	const NdArray< std::complex< dtype >> &	lhs,
		dtype	rhs
	)

Divides the scaler from the array (8)

Parameters

lhs
rhs

Returns: NdArray

◆ operator/() [7/11]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator/	(	const std::complex< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Divides the scaler from the array (7)

Parameters

lhs
rhs

Returns: NdArray

◆ operator/() [8/11]

Vec2 nc::operator/	(	const Vec2 &	lhs,
		double	rhs
	)

inlinenoexcept

Scalar division

Parameters

lhs
rhs

Returns: Vec2

◆ operator/() [9/11]

Vec3 nc::operator/	(	const Vec3 &	lhs,
		double	rhs
	)

inlinenoexcept

Scalar division

Parameters

lhs
rhs

Returns: Vec3

◆ operator/() [10/11]

template<typename dtype >

NdArray<dtype> nc::operator/	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Divides the scaler from the array (5)

Parameters

lhs
rhs

Returns: NdArray

◆ operator/() [11/11]

template<typename dtype >

NdArray<std::complex<dtype> > nc::operator/	(	dtype	lhs,
		const NdArray< std::complex< dtype >> &	rhs
	)

Divides the scaler from the array (9)

Parameters

lhs
rhs

Returns: NdArray

◆ operator/=() [1/4]

template<typename dtype >

NdArray<dtype>& nc::operator/=	(	NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Divides the elements of two arrays (1)

Parameters

lhs
rhs

Returns: NdArray

◆ operator/=() [2/4]

template<typename dtype >

NdArray<dtype>& nc::operator/=	(	NdArray< dtype > &	lhs,
		dtype	rhs
	)

Divides the scaler from the array (3)

Parameters

lhs
rhs

Returns: NdArray

◆ operator/=() [3/4]

template<typename dtype >

NdArray<std::complex<dtype> >& nc::operator/=	(	NdArray< std::complex< dtype >> &	lhs,
		const NdArray< dtype > &	rhs
	)

Divides the elements of two arrays (2)

Parameters

lhs
rhs

Returns: NdArray

◆ operator/=() [4/4]

template<typename dtype >

NdArray<std::complex<dtype> >& nc::operator/=	(	NdArray< std::complex< dtype >> &	lhs,
		dtype	rhs
	)

Divides the scaler from the array (4)

Parameters

lhs
rhs

Returns: NdArray

◆ operator<() [1/4]

template<typename dtype >

NdArray<bool> nc::operator<	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Returns an array of booleans of element wise comparison of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator<() [2/4]

template<typename dtype >

NdArray<bool> nc::operator<	(	const NdArray< dtype > &	lhs,
		dtype	inValue
	)

Returns an array of booleans of element wise comparison the array and a scaler

Parameters

lhs
inValue

Returns: NdArray

◆ operator<() [3/4]

template<typename T >

bool nc::operator<	(	const std::complex< T > &	lhs,
		const std::complex< T > &	rhs
	)

noexcept

Less than operator for std::complex<T>

Parameters

lhs
rhs

Returns: bool true if lhs < rhs

◆ operator<() [4/4]

template<typename dtype >

NdArray<bool> nc::operator<	(	dtype	inValue,
		const NdArray< dtype > &	inArray
	)

Returns an array of booleans of element wise comparison the array and a scaler

Parameters

inValue
inArray

Returns: NdArray

◆ operator<<() [1/4]

template<typename dtype >

NdArray<dtype> nc::operator<<	(	const NdArray< dtype > &	lhs,
		uint8	inNumBits
	)

Bitshifts left the elements of the array

Parameters

lhs
inNumBits

Returns: NdArray

◆ operator<<() [2/4]

template<typename dtype >

std::ostream& nc::operator<<	(	std::ostream &	inOStream,
		const NdArray< dtype > &	inArray
	)

io operator for the NdArray class

Parameters

inOStream
inArray

Returns: std::ostream

◆ operator<<() [3/4]

std::ostream& nc::operator<<	(	std::ostream &	stream,
		const Vec2 &	vec
	)

inline

stream output operator

Parameters

stream
vec

Returns: std::ostream

◆ operator<<() [4/4]

std::ostream& nc::operator<<	(	std::ostream &	stream,
		const Vec3 &	vec
	)

inline

stream output operator

Parameters

stream
vec

Returns: std::ostream

◆ operator<<=()

template<typename dtype >

NdArray<dtype>& nc::operator<<=	(	NdArray< dtype > &	lhs,
		uint8	inNumBits
	)

Bitshifts left the elements of the array

Parameters

lhs
inNumBits

Returns: NdArray

◆ operator<=() [1/4]

template<typename dtype >

NdArray<bool> nc::operator<=	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Returns an array of booleans of element wise comparison of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator<=() [2/4]

template<typename dtype >

NdArray<bool> nc::operator<=	(	const NdArray< dtype > &	lhs,
		dtype	inValue
	)

Returns an array of booleans of element wise comparison the array and a scaler

Parameters

lhs
inValue

Returns: NdArray

◆ operator<=() [3/4]

template<typename T >

bool nc::operator<=	(	const std::complex< T > &	lhs,
		const std::complex< T > &	rhs
	)

noexcept

Less than or equal operator for std::complex<T>

Parameters

lhs
rhs

Returns: bool true if lhs <= rhs

◆ operator<=() [4/4]

template<typename dtype >

NdArray<bool> nc::operator<=	(	dtype	inValue,
		const NdArray< dtype > &	inArray
	)

Returns an array of booleans of element wise comparison the array and a scaler

Parameters

inValue
inArray

Returns: NdArray

◆ operator==() [1/3]

template<typename dtype >

NdArray<bool> nc::operator==	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Returns an array of booleans of element wise comparison of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator==() [2/3]

template<typename dtype >

NdArray<bool> nc::operator==	(	const NdArray< dtype > &	lhs,
		dtype	inValue
	)

Returns an array of booleans of element wise comparison an array and a scaler

Parameters

lhs
inValue

Returns: NdArray

◆ operator==() [3/3]

template<typename dtype >

NdArray<bool> nc::operator==	(	dtype	inValue,
		const NdArray< dtype > &	inArray
	)

Returns an array of booleans of element wise comparison an array and a scaler

Parameters

inValue
inArray

Returns: NdArray

◆ operator>() [1/4]

template<typename dtype >

NdArray<bool> nc::operator>	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Returns an array of booleans of element wise comparison of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator>() [2/4]

template<typename dtype >

NdArray<bool> nc::operator>	(	const NdArray< dtype > &	lhs,
		dtype	inValue
	)

Returns an array of booleans of element wise comparison the array and a scaler

Parameters

lhs
inValue

Returns: NdArray

◆ operator>() [3/4]

template<typename T >

bool nc::operator>	(	const std::complex< T > &	lhs,
		const std::complex< T > &	rhs
	)

noexcept

Greater than operator for std::complex<T>

Parameters

lhs
rhs

Returns: bool true if lhs > rhs

◆ operator>() [4/4]

template<typename dtype >

NdArray<bool> nc::operator>	(	dtype	inValue,
		const NdArray< dtype > &	inArray
	)

Returns an array of booleans of element wise comparison the array and a scaler

Parameters

inValue
inArray

Returns: NdArray

◆ operator>=() [1/4]

template<typename dtype >

NdArray<bool> nc::operator>=	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Returns an array of booleans of element wise comparison of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator>=() [2/4]

template<typename dtype >

NdArray<bool> nc::operator>=	(	const NdArray< dtype > &	lhs,
		dtype	inValue
	)

Returns an array of booleans of element wise comparison the array and a scaler

Parameters

lhs
inValue

Returns: NdArray

◆ operator>=() [3/4]

template<typename T >

bool nc::operator>=	(	const std::complex< T > &	lhs,
		const std::complex< T > &	rhs
	)

noexcept

Greater than or equal operator for std::complex<T>

Parameters

lhs
rhs

Returns: bool true if lhs >= rhs

◆ operator>=() [4/4]

template<typename dtype >

NdArray<bool> nc::operator>=	(	dtype	inValue,
		const NdArray< dtype > &	inArray
	)

Returns an array of booleans of element wise comparison the array and a scaler

Parameters

inValue
inArray

Returns: NdArray

◆ operator>>()

template<typename dtype >

NdArray<dtype> nc::operator>>	(	const NdArray< dtype > &	lhs,
		uint8	inNumBits
	)

Bitshifts right the elements of the array

Parameters

lhs
inNumBits

Returns: NdArray

◆ operator>>=()

template<typename dtype >

NdArray<dtype>& nc::operator>>=	(	NdArray< dtype > &	lhs,
		uint8	inNumBits
	)

Bitshifts right the elements of the array

Parameters

lhs
inNumBits

Returns: NdArray

◆ operator^() [1/3]

template<typename dtype >

NdArray<dtype> nc::operator^	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Takes the bitwise xor of the elements of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator^() [2/3]

template<typename dtype >

NdArray<dtype> nc::operator^	(	const NdArray< dtype > &	lhs,
		dtype	rhs
	)

Takes the bitwise xor of the array and the scaler

Parameters

lhs
rhs

Returns: NdArray

◆ operator^() [3/3]

template<typename dtype >

NdArray<dtype> nc::operator^	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Takes the bitwise xor of the sclar and the array

Parameters

lhs
rhs

Returns: NdArray

◆ operator^=() [1/2]

template<typename dtype >

NdArray<dtype>& nc::operator^=	(	NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Bitwise xor the elements of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator^=() [2/2]

template<typename dtype >

NdArray<dtype>& nc::operator^=	(	NdArray< dtype > &	lhs,
		dtype	rhs
	)

Bitwise xor the scaler to the array

Parameters

lhs
rhs

Returns: NdArray

◆ operator|() [1/3]

template<typename dtype >

NdArray<dtype> nc::operator\|	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Takes the bitwise or of the elements of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator|() [2/3]

template<typename dtype >

NdArray<dtype> nc::operator\|	(	const NdArray< dtype > &	lhs,
		dtype	rhs
	)

Takes the bitwise or of the array and the scaler

Parameters

lhs
rhs

Returns: NdArray

◆ operator|() [3/3]

template<typename dtype >

NdArray<dtype> nc::operator\|	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Takes the bitwise or of the sclar and the array

Parameters

lhs
rhs

Returns: NdArray

◆ operator|=() [1/2]

template<typename dtype >

NdArray<dtype>& nc::operator\|=	(	NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Bitwise or the elements of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator|=() [2/2]

template<typename dtype >

NdArray<dtype>& nc::operator\|=	(	NdArray< dtype > &	lhs,
		dtype	rhs
	)

Bitwise or the scaler to the array

Parameters

lhs
rhs

Returns: NdArray

◆ operator||() [1/3]

template<typename dtype >

NdArray<bool> nc::operator\|\|	(	const NdArray< dtype > &	lhs,
		const NdArray< dtype > &	rhs
	)

Takes the or of the elements of two arrays

Parameters

lhs
rhs

Returns: NdArray

◆ operator||() [2/3]

template<typename dtype >

NdArray<bool> nc::operator\|\|	(	const NdArray< dtype > &	lhs,
		dtype	rhs
	)

Takes the or of the array and the scaler

Parameters

lhs
rhs

Returns: NdArray

◆ operator||() [3/3]

template<typename dtype >

NdArray<bool> nc::operator\|\|	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Takes the or of the array and the scaler

Parameters

lhs
rhs

Returns: NdArray

◆ operator~()

template<typename dtype >

NdArray<dtype> nc::operator~ ( const NdArray< dtype > & inArray )

Takes the bitwise not of the array

Parameters

inArray

Returns: NdArray

◆ outer()

template<typename dtype >

NdArray<dtype> nc::outer	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

The outer product of two vectors. Inputs are flattened if not already 1-dimensional.

NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.outer.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ pad()

template<typename dtype >

NdArray<dtype> nc::pad	(	const NdArray< dtype > &	inArray,
		uint16	inPadWidth,
		dtype	inPadValue
	)

Pads an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.pad.html

Parameters

inArray
inPadWidth
inPadValue

Returns: NdArray

◆ partition()

template<typename dtype >

NdArray<dtype> nc::partition	(	const NdArray< dtype > &	inArray,
		uint32	inKth,
		Axis	inAxis = `Axis::NONE`
	)

Rearranges the elements in the array in such a way that value of the element in kth position is in the position it would be in a sorted array. All elements smaller than the kth element are moved before this element and all equal or greater are moved behind it. The ordering of the elements in the two partitions is undefined.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.partition.html

Parameters

inArray
inKth	kth element
inAxis	(Optional, default NONE)

Returns: NdArray

◆ percentile()

template<typename dtype >

NdArray<double> nc::percentile	(	const NdArray< dtype > &	inArray,
		double	inPercentile,
		Axis	inAxis = `Axis::NONE`,
		const std::string &	inInterpMethod = `"linear"`
	)

Compute the qth percentile of the data along the specified axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.percentile.html

Parameters

inArray
inPercentile	percentile must be in the range [0, 100]
inAxis	(Optional, default NONE)
inInterpMethod	(Optional) interpolation method linear: i + (j - i) * fraction, where fraction is the fractional part of the index surrounded by i and j. lower : i. higher : j. nearest : i or j, whichever is nearest. midpoint : (i + j) / 2.

Returns: NdArray

◆ place()

template<typename dtype >

void nc::place	(	NdArray< dtype > &	arr,
		const NdArray< bool > &	mask,
		const NdArray< dtype > &	vals
	)

Change elements of an array based on conditional and input values.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.place.html

Parameters

arr	Array to put data into.
mask	Boolean mask array. Must have the same size as arr
vals	Values to put into a. Only the first N elements are used, where N is the number of True values in mask. If vals is smaller than N, it will be repeated.

Returns: NdArray

◆ polar() [1/2]

template<typename dtype >

auto nc::polar	(	const NdArray< dtype > &	magnitude,
		const NdArray< dtype > &	phaseAngle
	)

Returns a complex number with magnitude r and phase angle theta.

Parameters

magnitude
phaseAngle

Returns: NdArray<std::complex>

◆ polar() [2/2]

template<typename dtype >

auto nc::polar	(	dtype	magnitude,
		dtype	phaseAngle
	)

Returns a complex number with magnitude r and phase angle theta.

Parameters

magnitude
phaseAngle

Returns: std::complex

◆ power() [1/3]

template<typename dtype >

NdArray<dtype> nc::power	(	const NdArray< dtype > &	inArray,
		const NdArray< uint8 > &	inExponents
	)

Raises the elements of the array to the input integer powers

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.power.html

Parameters

inArray
inExponents

Returns: NdArray

◆ power() [2/3]

template<typename dtype >

NdArray<dtype> nc::power	(	const NdArray< dtype > &	inArray,
		uint8	inExponent
	)

Raises the elements of the array to the input integer power

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.power.html

Parameters

inArray
inExponent

Returns: NdArray

◆ power() [3/3]

template<typename dtype >

constexpr dtype nc::power	(	dtype	inValue,
		uint8	inExponent
	)

constexprnoexcept

Raises the elements of the array to the input integer power

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.power.html

Parameters

inValue
inExponent

Returns: value raised to the power

Examples: GaussNewtonNlls.cpp.

◆ powerf() [1/3]

template<typename dtype1 , typename dtype2 >

auto nc::powerf	(	const NdArray< dtype1 > &	inArray,
		const NdArray< dtype2 > &	inExponents
	)

Raises the elements of the array to the input floating point powers

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.power.html

Parameters

inArray
inExponents

Returns: NdArray

◆ powerf() [2/3]

template<typename dtype1 , typename dtype2 >

auto nc::powerf	(	const NdArray< dtype1 > &	inArray,
		dtype2	inExponent
	)

Raises the elements of the array to the input floating point power

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.power.html

Parameters

inArray
inExponent

Returns: NdArray

◆ powerf() [3/3]

template<typename dtype1 , typename dtype2 >

auto nc::powerf	(	dtype1	inValue,
		dtype2	inExponent
	)

noexcept

Raises the elements of the array to the input floating point power

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.power.html

Parameters

inValue
inExponent

Returns: value raised to the power

◆ print()

template<typename dtype >

void nc::print ( const NdArray< dtype > & inArray )

Prints the array to the console.

Parameters

inArray

Returns: None

◆ prod()

template<typename dtype >

NdArray<dtype> nc::prod	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Return the product of array elements over a given axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.prod.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ proj() [1/2]

template<typename dtype >

auto nc::proj ( const NdArray< std::complex< dtype >> & inArray )

Returns the projection of the complex number z onto the Riemann sphere.

Parameters

inArray

Returns: NdArray

◆ proj() [2/2]

template<typename dtype >

auto nc::proj ( const std::complex< dtype > & inValue )

Returns the projection of the complex number z onto the Riemann sphere.

Parameters

inValue

Returns: value

◆ ptp()

template<typename dtype >

NdArray<dtype> nc::ptp	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Range of values (maximum - minimum) along an axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ptp.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ put() [1/2]

template<typename dtype >

NdArray<dtype>& nc::put	(	NdArray< dtype > &	inArray,
		const NdArray< uint32 > &	inIndices,
		const NdArray< dtype > &	inValues
	)

Replaces specified elements of an array with given values. The indexing works on the flattened target array

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.put.html

Parameters

inArray
inIndices
inValues

Returns: NdArray

◆ put() [2/2]

template<typename dtype >

NdArray<dtype>& nc::put	(	NdArray< dtype > &	inArray,
		const NdArray< uint32 > &	inIndices,
		dtype	inValue
	)

Replaces specified elements of an array with given values. The indexing works on the flattened target array

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.put.html

Parameters

inArray
inIndices
inValue

Returns: NdArray

◆ putmask() [1/2]

template<typename dtype >

NdArray<dtype>& nc::putmask	(	NdArray< dtype > &	inArray,
		const NdArray< bool > &	inMask,
		const NdArray< dtype > &	inValues
	)

Changes elements of an array based on conditional and input values.

Sets a.flat[n] = values[n] for each n where mask.flat[n] == True.

If values is not the same size as a and mask then it will repeat.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.putmask.html

Parameters

inArray
inMask
inValues

Returns: NdArray

◆ putmask() [2/2]

template<typename dtype >

NdArray<dtype>& nc::putmask	(	NdArray< dtype > &	inArray,
		const NdArray< bool > &	inMask,
		dtype	inValue
	)

Changes elements of an array based on conditional and input values.

Sets a.flat[n] = values[n] for each n where mask.flat[n] == True.

If values is not the same size as a and mask then it will repeat.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.putmask.html

Parameters

inArray
inMask
inValue

Returns: NdArray

◆ rad2deg() [1/2]

template<typename dtype >

auto nc::rad2deg ( const NdArray< dtype > & inArray )

Convert angles from radians to degrees.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.rad2deg.html

Parameters

inArray

Returns: NdArray

◆ rad2deg() [2/2]

template<typename dtype >

constexpr auto nc::rad2deg ( dtype inValue )

constexprnoexcept

Convert angles from radians to degrees.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.rad2deg.html

Parameters

inValue

Returns: value

◆ radians() [1/2]

template<typename dtype >

auto nc::radians ( const NdArray< dtype > & inArray )

Convert angles from degrees to radians.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.radians.html

Parameters

inArray

Returns: NdArray

◆ radians() [2/2]

template<typename dtype >

constexpr auto nc::radians ( dtype inValue )

constexprnoexcept

Convert angles from degrees to radians.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.radians.html

Parameters

inValue

Returns: value

◆ ravel()

template<typename dtype >

NdArray<dtype>& nc::ravel ( NdArray< dtype > & inArray )

noexcept

Flattens the array but does not make a copy.

Numpy Reference: https://docs.scipy.org/doc/numpy/reference/generated/numpy.ravel.html

Parameters

inArray

Returns: NdArray

◆ real() [1/2]

template<typename dtype >

auto nc::real ( const NdArray< std::complex< dtype >> & inArray )

Return the real part of the complex argument.

NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.real.html

Parameters

inArray

Returns: NdArray

◆ real() [2/2]

template<typename dtype >

auto nc::real ( const std::complex< dtype > & inValue )

Return the real part of the complex argument.

NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.real.html

Parameters

inValue

Returns: value

◆ reciprocal() [1/2]

template<typename dtype >

NdArray<double> nc::reciprocal ( const NdArray< dtype > & inArray )

Return the reciprocal of the argument, element-wise.

Calculates 1 / x.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.reciprocal.html

Parameters

inArray

Returns: NdArray

◆ reciprocal() [2/2]

template<typename dtype >

NdArray<std::complex<double> > nc::reciprocal ( const NdArray< std::complex< dtype >> & inArray )

Return the reciprocal of the argument, element-wise.

Calculates 1 / x.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.reciprocal.html

Parameters

inArray

Returns: NdArray

◆ remainder() [1/2]

template<typename dtype >

NdArray<double> nc::remainder	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Return element-wise remainder of division.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.remainder.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ remainder() [2/2]

template<typename dtype >

double nc::remainder	(	dtype	inValue1,
		dtype	inValue2
	)

noexcept

Return remainder of division.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.remainder.html

Parameters

inValue1
inValue2

Returns: NdArray

Examples: ReadMe.cpp.

◆ repeat() [1/2]

template<typename dtype >

NdArray<dtype> nc::repeat	(	const NdArray< dtype > &	inArray,
		const Shape &	inRepeatShape
	)

Repeat elements of an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.repeat.html

Parameters

inArray
inRepeatShape

Returns: NdArray

◆ repeat() [2/2]

template<typename dtype >

NdArray<dtype> nc::repeat	(	const NdArray< dtype > &	inArray,
		uint32	inNumRows,
		uint32	inNumCols
	)

Repeat elements of an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.repeat.html

Parameters

inArray
inNumRows
inNumCols

Returns: NdArray

◆ replace()

template<typename dtype >

NdArray<dtype> nc::replace	(	const NdArray< dtype > &	inArray,
		dtype	oldValue,
		dtype	newValue
	)

Replaces the matching elements of an array with the new value

Parameters

inArray
oldValue	the value to replace
newValue	the value to replace with

Returns: NdArray

◆ reshape() [1/3]

template<typename dtype >

NdArray<dtype>& nc::reshape	(	NdArray< dtype > &	inArray,
		const Shape &	inNewShape
	)

Gives a new shape to an array without changing its data.

The new shape should be compatible with the original shape. If an single integer, then the result will be a 1-D array of that length. One shape dimension can be -1. In this case, the value is inferred from the length of the array and remaining dimensions.

Parameters

inArray
inNewShape

Returns: NdArray

◆ reshape() [2/3]

template<typename dtype >

NdArray<dtype>& nc::reshape	(	NdArray< dtype > &	inArray,
		int32	inNumRows,
		int32	inNumCols
	)

Gives a new shape to an array without changing its data.

The new shape should be compatible with the original shape. If an single integer, then the result will be a 1-D array of that length. One shape dimension can be -1. In this case, the value is inferred from the length of the array and remaining dimensions.

Parameters

inArray
inNumRows
inNumCols

Returns: NdArray

◆ reshape() [3/3]

template<typename dtype >

NdArray<dtype>& nc::reshape	(	NdArray< dtype > &	inArray,
		uint32	inSize
	)

Gives a new shape to an array without changing its data.

The new shape should be compatible with the original shape. If an single integer, then the result will be a 1-D array of that length. One shape dimension can be -1. In this case, the value is inferred from the length of the array and remaining dimensions.

Parameters

inArray
inSize

Returns: NdArray

◆ resizeFast() [1/2]

template<typename dtype >

NdArray<dtype>& nc::resizeFast	(	NdArray< dtype > &	inArray,
		const Shape &	inNewShape
	)

Change shape and size of array in-place. All previous data of the array is lost.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.resize.html

Parameters

inArray
inNewShape

Returns: NdArray

◆ resizeFast() [2/2]

template<typename dtype >

NdArray<dtype>& nc::resizeFast	(	NdArray< dtype > &	inArray,
		uint32	inNumRows,
		uint32	inNumCols
	)

Change shape and size of array in-place. All previous data of the array is lost.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.resize.html

Parameters

inArray
inNumRows
inNumCols

Returns: NdArray

◆ resizeSlow() [1/2]

template<typename dtype >

NdArray<dtype>& nc::resizeSlow	(	NdArray< dtype > &	inArray,
		const Shape &	inNewShape
	)

Return a new array with the specified shape. If new shape is larger than old shape then array will be padded with zeros. If new shape is smaller than the old shape then the data will be discarded.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.resize.html

Parameters

inArray
inNewShape

Returns: NdArray

◆ resizeSlow() [2/2]

template<typename dtype >

NdArray<dtype>& nc::resizeSlow	(	NdArray< dtype > &	inArray,
		uint32	inNumRows,
		uint32	inNumCols
	)

Return a new array with the specified shape. If new shape is larger than old shape then array will be padded with zeros. If new shape is smaller than the old shape then the data will be discarded.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.resize.html

Parameters

inArray
inNumRows
inNumCols

Returns: NdArray

◆ right_shift()

template<typename dtype >

NdArray<dtype> nc::right_shift	(	const NdArray< dtype > &	inArray,
		uint8	inNumBits
	)

Shift the bits of an integer to the right.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.right_shift.html

Parameters

inArray
inNumBits

Returns: NdArray

◆ rint() [1/2]

template<typename dtype >

NdArray<dtype> nc::rint ( const NdArray< dtype > & inArray )

Round elements of the array to the nearest integer.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.rint.html

Parameters

inArray

Returns: NdArray

◆ rint() [2/2]

template<typename dtype >

dtype nc::rint ( dtype inValue )

noexcept

Round value to the nearest integer.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.rint.html

Parameters

inValue

Returns: value

◆ rms() [1/2]

template<typename dtype >

NdArray<double> nc::rms	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Compute the root mean square (RMS) along the specified axis.

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

Examples: GaussNewtonNlls.cpp.

◆ rms() [2/2]

template<typename dtype >

NdArray<std::complex<double> > nc::rms	(	const NdArray< std::complex< dtype >> &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Compute the root mean square (RMS) along the specified axis.

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ roll()

template<typename dtype >

NdArray<dtype> nc::roll	(	const NdArray< dtype > &	inArray,
		int32	inShift,
		Axis	inAxis = `Axis::NONE`
	)

Roll array elements along a given axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.roll.html

Parameters

inArray
inShift	(elements to shift, positive means forward, negative means backwards)
inAxis	(Optional, default NONE)

Returns: NdArray

◆ rot90()

template<typename dtype >

NdArray<dtype> nc::rot90	(	const NdArray< dtype > &	inArray,
		uint8	inK = `1`
	)

Rotate an array by 90 degrees counter clockwise in the plane.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.rot90.html

Parameters

inArray
inK	the number of times to rotate 90 degrees

Returns: NdArray

◆ round() [1/2]

template<typename dtype >

NdArray<dtype> nc::round	(	const NdArray< dtype > &	inArray,
		uint8	inDecimals = `0`
	)

Round an array to the given number of decimals.

Parameters

inArray
inDecimals

Returns: NdArray

◆ round() [2/2]

template<typename dtype >

dtype nc::round	(	dtype	inValue,
		uint8	inDecimals = `0`
	)

Round value to the given number of decimals.

Parameters

inValue
inDecimals

Returns: value

◆ row_stack()

template<typename dtype >

NdArray<dtype> nc::row_stack ( const std::initializer_list< NdArray< dtype >> & inArrayList )

Stack arrays in sequence vertically (row wise).

Parameters

inArrayList {list} of arrays to stack

Returns: NdArray

◆ select() [1/2]

template<typename dtype >

NdArray<dtype> nc::select	(	const std::vector< const NdArray< bool > * > &	condVec,
		const std::vector< const NdArray< dtype > * > &	choiceVec,
		dtype	defaultValue = `dtype{ 0 }`
	)

Return an array drawn from elements in choiceVec, depending on conditions.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.select.html?highlight=select#numpy.select

Parameters

condVec	The vector of conditions which determine from which array in choiceVec the output elements are taken. When multiple conditions are satisfied, the first one encountered in choiceVec is used.
choiceVec	The vector of array pointers from which the output elements are taken. It has to be of the same length as condVec.
defaultValue	The element inserted in output when all conditions evaluate to False

Returns: NdArray

◆ select() [2/2]

template<typename dtype >

NdArray<dtype> nc::select	(	const std::vector< NdArray< bool >> &	condList,
		const std::vector< NdArray< dtype >> &	choiceList,
		dtype	defaultValue = `dtype{ 0 }`
	)

Return an array drawn from elements in choiceList, depending on conditions.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.select.html?highlight=select#numpy.select

Parameters

condList	The list of conditions which determine from which array in choiceList the output elements are taken. When multiple conditions are satisfied, the first one encountered in choiceList is used.
choiceList	The list of array pointers from which the output elements are taken. It has to be of the same length as condVec.
defaultValue	The element inserted in output when all conditions evaluate to False

Returns: NdArray

◆ setdiff1d()

template<typename dtype >

NdArray<dtype> nc::setdiff1d	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Find the set difference of two arrays.

Return the sorted, unique values in ar1 that are not in ar2.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.setdiff1d.html

Parameters

inArray1
inArray2

Returns: NdArray

Examples: ReadMe.cpp.

◆ shape()

template<typename dtype >

Shape nc::shape ( const NdArray< dtype > & inArray )

noexcept

Return the shape of the array

Parameters

inArray

Returns: Shape

◆ sign() [1/2]

template<typename dtype >

NdArray<int8> nc::sign ( const NdArray< dtype > & inArray )

Returns an element-wise indication of the sign of a number.

The sign function returns - 1 if x < 0, 0 if x == 0, 1 if x > 0. nan is returned for nan inputs.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sign.html

Parameters

inArray

Returns: NdArray

◆ sign() [2/2]

template<typename dtype >

int8 nc::sign ( dtype inValue )

noexcept

Returns an element-wise indication of the sign of a number.

The sign function returns - 1 if x < 0, 0 if x == 0, 1 if x > 0. nan is returned for nan inputs.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sign.html

Parameters

inValue

Returns: NdArray

Examples: ReadMe.cpp.

◆ signbit() [1/2]

template<typename dtype >

NdArray<bool> nc::signbit ( const NdArray< dtype > & inArray )

Returns element-wise True where signbit is set (less than zero).

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.signbit.html

Parameters

inArray

Returns: NdArray

◆ signbit() [2/2]

template<typename dtype >

bool nc::signbit ( dtype inValue )

noexcept

Returns element-wise True where signbit is set (less than zero).

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.signbit.html

Parameters

inValue

Returns: NdArray

◆ sin() [1/2]

template<typename dtype >

auto nc::sin ( const NdArray< dtype > & inArray )

Trigonometric sine, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sin.html

Parameters

inArray

Returns: NdArray

◆ sin() [2/2]

template<typename dtype >

auto nc::sin ( dtype inValue )

noexcept

Trigonometric sine.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sin.html

Parameters

inValue

Returns: value

Examples: GaussNewtonNlls.cpp, and ReadMe.cpp.

◆ sinc() [1/2]

template<typename dtype >

auto nc::sinc ( const NdArray< dtype > & inArray )

Return the sinc function.

The sinc function is sin(pi*x) / (pi*x).

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sinc.html

Parameters

inArray

Returns: NdArray

◆ sinc() [2/2]

template<typename dtype >

auto nc::sinc ( dtype inValue )

noexcept

Return the sinc function.

The sinc function is sin(pi*x) / (pi*x).

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sinc.html

Parameters

inValue

Returns: value

◆ sinh() [1/2]

template<typename dtype >

auto nc::sinh ( const NdArray< dtype > & inArray )

Hyperbolic sine, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sinh.html

Parameters

inArray

Returns: NdArray

◆ sinh() [2/2]

template<typename dtype >

auto nc::sinh ( dtype inValue )

noexcept

Hyperbolic sine.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sinh.html

Parameters

inValue

Returns: value

Examples: ReadMe.cpp.

◆ size()

template<typename dtype >

uint32 nc::size ( const NdArray< dtype > & inArray )

noexcept

Return the number of elements.

Parameters

inArray

Returns: uint32 size

◆ sort()

template<typename dtype >

NdArray<dtype> nc::sort	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Return a sorted copy of an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sort.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

Examples: ReadMe.cpp.

◆ sqrt() [1/2]

template<typename dtype >

auto nc::sqrt ( const NdArray< dtype > & inArray )

Return the positive square-root of an array, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sqrt.html

Parameters

inArray

Returns: NdArray

◆ sqrt() [2/2]

template<typename dtype >

auto nc::sqrt ( dtype inValue )

noexcept

Return the positive square-root of a value.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sqrt.html

Parameters

inValue

Returns: value

Examples: ReadMe.cpp.

◆ square() [1/2]

template<typename dtype >

NdArray<dtype> nc::square ( const NdArray< dtype > & inArray )

Return the square of an array, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.square.html

Parameters

inArray

Returns: NdArray

◆ square() [2/2]

template<typename dtype >

constexpr dtype nc::square ( dtype inValue )

constexprnoexcept

Return the square of an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.square.html

Parameters

inValue

Returns: value

Examples: GaussNewtonNlls.cpp, and ReadMe.cpp.

◆ stack()

template<typename dtype >

NdArray<dtype> nc::stack	(	std::initializer_list< NdArray< dtype >>	inArrayList,
		Axis	inAxis = `Axis::NONE`
	)

Compute the variance along the specified axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.stack.html

Parameters

inArrayList	{list} of arrays to stack
inAxis	axis to stack the input NdArrays

Returns: NdArray

Examples: ReadMe.cpp.

◆ stdev() [1/2]

template<typename dtype >

NdArray<double> nc::stdev	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Compute the standard deviation along the specified axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.std.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ stdev() [2/2]

template<typename dtype >

NdArray<std::complex<double> > nc::stdev	(	const NdArray< std::complex< dtype >> &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Compute the standard deviation along the specified axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.std.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ subtract() [1/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::subtract	(	const NdArray< dtype > &	inArray,
		const std::complex< dtype > &	value
	)

subtract arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html

Parameters

inArray
value

Returns: NdArray

◆ subtract() [2/9]

template<typename dtype >

NdArray<dtype> nc::subtract	(	const NdArray< dtype > &	inArray,
		dtype	value
	)

subtract arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html

Parameters

inArray
value

Returns: NdArray

◆ subtract() [3/9]

template<typename dtype >

NdArray<dtype> nc::subtract	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

subtract arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ subtract() [4/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::subtract	(	const NdArray< dtype > &	inArray1,
		const NdArray< std::complex< dtype >> &	inArray2
	)

subtract arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ subtract() [5/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::subtract	(	const NdArray< std::complex< dtype >> &	inArray,
		dtype	value
	)

subtract arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html

Parameters

inArray
value

Returns: NdArray

◆ subtract() [6/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::subtract	(	const NdArray< std::complex< dtype >> &	inArray1,
		const NdArray< dtype > &	inArray2
	)

subtract arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ subtract() [7/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::subtract	(	const std::complex< dtype > &	value,
		const NdArray< dtype > &	inArray
	)

subtract arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html

Parameters

value
inArray

Returns: NdArray

◆ subtract() [8/9]

template<typename dtype >

NdArray<dtype> nc::subtract	(	dtype	value,
		const NdArray< dtype > &	inArray
	)

subtract arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html

Parameters

value
inArray

Returns: NdArray

◆ subtract() [9/9]

template<typename dtype >

NdArray<std::complex<dtype> > nc::subtract	(	dtype	value,
		const NdArray< std::complex< dtype >> &	inArray
	)

subtract arguments element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html

Parameters

value
inArray

Returns: NdArray

◆ sum()

template<typename dtype >

NdArray<dtype> nc::sum	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Sum of array elements over a given axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sum.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ swap()

template<typename dtype >

void nc::swap	(	NdArray< dtype > &	inArray1,
		NdArray< dtype > &	inArray2
	)

noexcept

Swaps the contents of two arrays

Parameters

inArray1
inArray2

◆ swapaxes()

template<typename dtype >

NdArray<dtype> nc::swapaxes ( const NdArray< dtype > & inArray )

Interchange two axes of an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.swapaxes.html

Parameters

inArray

Returns: NdArray

◆ swapCols()

template<typename dtype >

NdArray<dtype>& nc::swapCols	(	NdArray< dtype > &	inArray,
		int32	colIdx1,
		int32	colIdx2
	)

noexcept

Swaps cols of the array

Parameters

inArray
colIdx1
colIdx2

◆ swapRows()

template<typename dtype >

NdArray<dtype>& nc::swapRows	(	NdArray< dtype > &	inArray,
		int32	rowIdx1,
		int32	rowIdx2
	)

noexcept

Swaps rows of the array

Parameters

inArray
rowIdx1
rowIdx2

◆ take()

template<typename dtype , typename Indices , enable_if_t< is_same_v< Indices, NdArray< int32 >>||is_same_v< Indices, NdArray< uint32 >>, int > = 0>

NdArray<dtype> nc::take	(	const NdArray< dtype > &	inArray,
		const Indices &	inIndices,
		Axis	inAxis = `Axis::NONE`
	)

Evenly round to the given number of decimals.

NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.take.html

Parameters

inArray
inIndices
inAxis

Returns: NdArray

◆ tan() [1/2]

template<typename dtype >

auto nc::tan ( const NdArray< dtype > & inArray )

Compute tangent element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.tan.html

Parameters

inArray

Returns: NdArray

◆ tan() [2/2]

template<typename dtype >

auto nc::tan ( dtype inValue )

noexcept

Compute tangent.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.tan.html

Parameters

inValue

Returns: value

Examples: ReadMe.cpp.

◆ tanh() [1/2]

template<typename dtype >

auto nc::tanh ( const NdArray< dtype > & inArray )

Compute hyperbolic tangent element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.tanh.html

Parameters

inArray

Returns: NdArray

◆ tanh() [2/2]

template<typename dtype >

auto nc::tanh ( dtype inValue )

noexcept

Compute hyperbolic tangent.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.tanh.html

Parameters

inValue

Returns: value

Examples: ReadMe.cpp.

◆ tile() [1/2]

template<typename dtype >

NdArray<dtype> nc::tile	(	const NdArray< dtype > &	inArray,
		const Shape &	inReps
	)

Construct an array by repeating A the number of times given by reps.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.tile.html

Parameters

inArray
inReps

Returns: NdArray

◆ tile() [2/2]

template<typename dtype >

NdArray<dtype> nc::tile	(	const NdArray< dtype > &	inArray,
		uint32	inNumRows,
		uint32	inNumCols
	)

Construct an array by repeating A the number of times given by reps.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.tile.html

Parameters

inArray
inNumRows
inNumCols

Returns: NdArray

◆ tofile() [1/2]

template<typename dtype >

void nc::tofile	(	const NdArray< dtype > &	inArray,
		const std::string &	inFilename
	)

Write array to a file as binary. The data produced by this method can be recovered using the function fromfile().

Parameters

inArray
inFilename

Returns: None

◆ tofile() [2/2]

template<typename dtype >

void nc::tofile	(	const NdArray< dtype > &	inArray,
		const std::string &	inFilename,
		const char	inSep
	)

Write array to a file as text. The data produced by this method can be recovered using the function fromfile().

Parameters

inArray
inFilename
inSep	Separator between array items for text output.

Returns: None

◆ toStlVector()

template<typename dtype >

std::vector<dtype> nc::toStlVector ( const NdArray< dtype > & inArray )

Write flattened array to an STL vector

Parameters

inArray

Returns: std::vector

◆ trace()

template<typename dtype >

dtype nc::trace	(	const NdArray< dtype > &	inArray,
		int16	inOffset = `0`,
		Axis	inAxis = `Axis::ROW`
	)

noexcept

Return the sum along diagonals of the array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.trace.html

Parameters

inArray
inOffset	(Offset from main diaganol, default = 0, negative=above, positve=below)
inAxis	(Optional, default ROW)

Returns: NdArray

◆ transpose()

template<typename dtype >

NdArray<dtype> nc::transpose ( const NdArray< dtype > & inArray )

Permute the dimensions of an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.transpose.html

Parameters

inArray

Returns: NdArray

Examples: GaussNewtonNlls.cpp, and InterfaceWithOpenCV.cpp.

◆ trapz() [1/2]

template<typename dtype >

NdArray<double> nc::trapz	(	const NdArray< dtype > &	inArray,
		double	dx = `1.0`,
		Axis	inAxis = `Axis::NONE`
	)

Integrate along the given axis using the composite trapezoidal rule.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.trapz.html

Parameters

inArray
dx	(Optional defaults to 1.0)
inAxis	(Optional, default NONE)

Returns: NdArray

◆ trapz() [2/2]

template<typename dtype >

NdArray<double> nc::trapz	(	const NdArray< dtype > &	inArrayY,
		const NdArray< dtype > &	inArrayX,
		Axis	inAxis = `Axis::NONE`
	)

Integrate along the given axis using the composite trapezoidal rule.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.trapz.html

Parameters

inArrayY
inArrayX
inAxis	(Optional, default NONE)

Returns: NdArray

◆ tril() [1/3]

template<typename dtype >

NdArray<dtype> nc::tril	(	const NdArray< dtype > &	inArray,
		int32	inOffset = `0`
	)

Lower triangle of an array.

Return a copy of an array with elements above the k - th diagonal zeroed.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.tril.html

Parameters

inArray	number of rows and cols
inOffset	(the sub-diagonal at and below which the array is filled. k = 0 is the main diagonal, while k < 0 is below it, and k > 0 is above. The default is 0.)

Returns: NdArray

◆ tril() [2/3]

template<typename dtype >

NdArray<dtype> nc::tril	(	uint32	inN,
		int32	inOffset = `0`
	)

An array with ones at and below the given diagonal and zeros elsewhere.

Parameters

inN	number of rows and cols
inOffset	(the sub-diagonal at and below which the array is filled. k = 0 is the main diagonal, while k < 0 is below it, and k > 0 is above. The default is 0.)

Returns: NdArray

Examples: ReadMe.cpp.

◆ tril() [3/3]

template<typename dtype >

NdArray<dtype> nc::tril	(	uint32	inN,
		uint32	inM,
		int32	inOffset = `0`
	)

An array with ones at and below the given diagonal and zeros elsewhere.

Parameters

inN	number of rows
inM	number of columns
inOffset	(the sub-diagonal at and below which the array is filled. k = 0 is the main diagonal, while k < 0 is below it, and k > 0 is above. The default is 0.)

Returns: NdArray

◆ trim_zeros()

template<typename dtype >

NdArray<dtype> nc::trim_zeros	(	const NdArray< dtype > &	inArray,
		const std::string &	inTrim = `"fb"`
	)

Trim the leading and/or trailing zeros from a 1-D array or sequence.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.trim_zeros.html

Parameters

inArray
inTrim	("f" = front, "b" = back, "fb" = front and back)

Returns: NdArray

◆ triu() [1/3]

template<typename dtype >

NdArray<dtype> nc::triu	(	const NdArray< dtype > &	inArray,
		int32	inOffset = `0`
	)

Upper triangle of an array.

Return a copy of an array with elements below the k - th diagonal zeroed.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.triu.html

Parameters

inArray	number of rows and cols
inOffset	(the sub-diagonal at and below which the array is filled. k = 0 is the main diagonal, while k < 0 is below it, and k > 0 is above. The default is 0.)

Returns: NdArray

◆ triu() [2/3]

template<typename dtype >

NdArray<dtype> nc::triu	(	uint32	inN,
		int32	inOffset = `0`
	)

An array with ones at and above the given diagonal and zeros elsewhere.

Parameters

inN	number of rows and cols
inOffset	(the sub-diagonal at and above which the array is filled. k = 0 is the main diagonal, while k < 0 is below it, and k > 0 is above. The default is 0.)

Returns: NdArray

◆ triu() [3/3]

template<typename dtype >

NdArray< dtype > nc::triu	(	uint32	inN,
		uint32	inM,
		int32	inOffset
	)

An array with ones at and above the given diagonal and zeros elsewhere.

Parameters

inN	number of rows
inM	number of columns
inOffset	(the sub-diagonal at and above which the array is filled. k = 0 is the main diagonal, while k < 0 is below it, and k > 0 is above. The default is 0.)

Returns: NdArray

Examples: ReadMe.cpp.

◆ trunc() [1/2]

template<typename dtype >

NdArray<dtype> nc::trunc ( const NdArray< dtype > & inArray )

Return the truncated value of the input, element-wise.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.trunc.html

Parameters

inArray

Returns: NdArray

◆ trunc() [2/2]

template<typename dtype >

dtype nc::trunc ( dtype inValue )

noexcept

Return the truncated value of the input.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.trunc.html

Parameters

inValue

Returns: value

◆ union1d()

template<typename dtype >

NdArray<dtype> nc::union1d	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2
	)

Find the union of two arrays.

Return the unique, sorted array of values that are in either of the two input arrays.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.union1d.html

Parameters

inArray1
inArray2

Returns: NdArray

◆ unique()

template<typename dtype >

NdArray<dtype> nc::unique ( const NdArray< dtype > & inArray )

Find the unique elements of an array.

Returns the sorted unique elements of an array.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.unique.html

Parameters

inArray

Returns: NdArray

Examples: ReadMe.cpp.

◆ unwrap() [1/2]

template<typename dtype >

NdArray<dtype> nc::unwrap ( const NdArray< dtype > & inArray )

Unwrap by changing deltas between values to 2*pi complement. Unwraps to [-pi, pi].

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.unwrap.html

Parameters

inArray

Returns: NdArray

◆ unwrap() [2/2]

template<typename dtype >

dtype nc::unwrap ( dtype inValue )

noexcept

Unwrap by changing deltas between values to 2*pi complement. Unwraps to [-pi, pi].

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.unwrap.html

Parameters

inValue

Returns: value

◆ var() [1/2]

template<typename dtype >

NdArray<double> nc::var	(	const NdArray< dtype > &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Compute the variance along the specified axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.var.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ var() [2/2]

template<typename dtype >

NdArray<std::complex<double> > nc::var	(	const NdArray< std::complex< dtype >> &	inArray,
		Axis	inAxis = `Axis::NONE`
	)

Compute the variance along the specified axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.var.html

Parameters

inArray
inAxis	(Optional, default NONE)

Returns: NdArray

◆ vstack()

template<typename dtype >

NdArray<dtype> nc::vstack ( std::initializer_list< NdArray< dtype >> inArrayList )

Compute the variance along the specified axis.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.vstack.html

Parameters

inArrayList {list} of arrays to stack

Returns: NdArray

Examples: GaussNewtonNlls.cpp, and ReadMe.cpp.

◆ where() [1/4]

template<typename dtype >

NdArray<dtype> nc::where	(	const NdArray< bool > &	inMask,
		const NdArray< dtype > &	inA,
		const NdArray< dtype > &	inB
	)

Return elements, either from x or y, depending on the input mask. The output array contains elements of x where mask is True, and elements from y elsewhere.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.where.html

Parameters

inMask
inA
inB

Returns: NdArray

Examples: ReadMe.cpp.

◆ where() [2/4]

template<typename dtype >

NdArray<dtype> nc::where	(	const NdArray< bool > &	inMask,
		const NdArray< dtype > &	inA,
		dtype	inB
	)

Return elements, either from x or y, depending on the input mask. The output array contains elements of x where mask is True, and elements from y elsewhere.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.where.html

Parameters

inMask
inA
inB

Returns: NdArray

◆ where() [3/4]

template<typename dtype >

NdArray<dtype> nc::where	(	const NdArray< bool > &	inMask,
		dtype	inA,
		const NdArray< dtype > &	inB
	)

Return elements, either from x or y, depending on the input mask. The output array contains elements of x where mask is True, and elements from y elsewhere.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.where.html

Parameters

inMask
inA
inB

Returns: NdArray

◆ where() [4/4]

template<typename dtype >

NdArray<dtype> nc::where	(	const NdArray< bool > &	inMask,
		dtype	inA,
		dtype	inB
	)

Return elements, either from x or y, depending on the input mask. The output array contains elements of x where mask is True, and elements from y elsewhere.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.where.html

Parameters

inMask
inA
inB

Returns: NdArray

◆ zeros() [1/3]

template<typename dtype >

NdArray<dtype> nc::zeros ( const Shape & inShape )

Return a new array of given shape and type, filled with zeros.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.zeros.html

Parameters

inShape

Returns: NdArray

◆ zeros() [2/3]

template<typename dtype >

NdArray<dtype> nc::zeros	(	uint32	inNumRows,
		uint32	inNumCols
	)

Return a new array of given shape and type, filled with zeros.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.zeros.html

Parameters

inNumRows
inNumCols

Returns: NdArray

◆ zeros() [3/3]

template<typename dtype >

NdArray<dtype> nc::zeros ( uint32 inSquareSize )

Return a new array of given shape and type, filled with zeros.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.zeros.html

Parameters

inSquareSize

Returns: NdArray

◆ zeros_like()

template<typename dtypeOut , typename dtype >

NdArray<dtypeOut> nc::zeros_like ( const NdArray< dtype > & inArray )

Return a new array of given shape and type, filled with zeros.

NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.zeros_like.html

Parameters

inArray

Returns: NdArray

is_valid_dtype helper

◆ VERSION

constexpr char nc::VERSION[] = "2.8.0"

constexpr

Current NumCpp version number.

Namespaces

Data Structures

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ enable_if_t

◆ int16

◆ int32

◆ int64

◆ int8

◆ uint16

◆ uint32

◆ uint64

◆ uint8

Enumeration Type Documentation

◆ Axis

◆ Endian

Function Documentation

◆ abs() [1/2]

◆ abs() [2/2]

◆ add() [1/9]

◆ add() [2/9]

◆ add() [3/9]

◆ add() [4/9]

◆ add() [5/9]

◆ add() [6/9]

◆ add() [7/9]

◆ add() [8/9]

◆ add() [9/9]

◆ alen()

◆ all()

◆ allclose()

◆ amax()

◆ amin()

◆ angle() [1/2]

◆ angle() [2/2]

◆ any()

◆ append()

◆ applyFunction()

◆ applyPoly1d()

◆ arange() [1/3]

◆ arange() [2/3]

◆ arange() [3/3]

◆ arccos() [1/2]

◆ arccos() [2/2]

◆ arccosh() [1/2]

◆ arccosh() [2/2]

◆ arcsin() [1/2]

◆ arcsin() [2/2]

◆ arcsinh() [1/2]

◆ arcsinh() [2/2]

◆ arctan() [1/2]

◆ arctan() [2/2]

◆ arctan2() [1/2]

◆ arctan2() [2/2]

◆ arctanh() [1/2]

◆ arctanh() [2/2]

◆ argmax()

◆ argmin()

◆ argsort()

◆ argwhere()

◆ around() [1/2]

◆ around() [2/2]

◆ array_equal()

◆ array_equiv()

◆ asarray() [1/17]

◆ asarray() [2/17]

◆ asarray() [3/17]

◆ asarray() [4/17]

◆ asarray() [5/17]

◆ asarray() [6/17]

◆ asarray() [7/17]

◆ asarray() [8/17]

◆ asarray() [9/17]

◆ asarray() [10/17]

◆ asarray() [11/17]

◆ asarray() [12/17]

◆ asarray() [13/17]