nc Namespace Reference

Namespaces
namespace	broadcast
namespace	constants
namespace	coordinates
namespace	detail
namespace	edac
namespace	endian
namespace	error
namespace	filter
namespace	imageProcessing
namespace	integrate
namespace	linalg
namespace	logger
namespace	polynomial
namespace	random
namespace	roots
namespace	rotations
namespace	special
namespace	stl_algorithms
namespace	type_traits
namespace	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	DateTime
	Date Time class for working with iso formatted date times. 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_ndarray_int
struct	is_ndarray_int< NdArray< dtype, Allocator > >
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
using	Clock = std::chrono::system_clock
	Clock Type. More...
using	Duration = std::chrono::nanoseconds
	Duration Type. More...
using	int16 = std::int16_t
using	int32 = std::int32_t
using	int64 = std::int64_t
using	int8 = std::int8_t
template<typename T >
using	ndarray_int_concept = std::enable_if_t< is_ndarray_int_v< T >, int >
using	TimePoint = std::chrono::time_point< Clock, Duration >
	TimePoint Type. More...
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	Bias : bool { YES = true , NO = false }
	Bias boolean. More...
enum class	Endian { NATIVE = 0 , BIG , LITTLE }
	Enum for endianess. More...
enum class	EndPoint : bool { YES = true , NO = false }
	End Point boolean. More...
enum class	Increasing : bool { YES = true , NO = false }
	Increasing boolean. More...
enum class	InterpolationMethod {   LINEAR , LOWER , HIGHER , NEAREST ,   MIDPOINT }
enum class	IsRoots : bool { YES = true , NO = false }
	Is Roots boolean. More...
enum class	PointerPolicy { COPY , SHELL }
	Policy for NdArray constructor that takes in a pointer to data. More...
enum class	PrintElapsedTime : bool { YES = true , NO = false }
	Print Elapsed Time boolean. More...
enum class	PrintResults : bool { YES = true , NO = false }
	Print Results boolean. More...
enum class	Replace : bool { YES = true , NO = false }
	Replace boolean. More...
enum class	Side { LEFT , RIGHT }

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 UIntType , std::enable_if_t< std::is_integral_v< UIntType > &&!std::is_same_v< UIntType, bool >, int > = 0>
NdArray< dtype >	asarray (dtype *ptr, UIntType size, PointerPolicy pointerPolicy=PointerPolicy::COPY) noexcept
template<typename dtype , typename UIntType1 , typename UIntType2 , std::enable_if_t< std::is_integral_v< UIntType1 > &&!std::is_same_v< UIntType1, bool >, int > = 0, std::enable_if_t< std::is_integral_v< UIntType2 > &&!std::is_same_v< UIntType2, bool >, int > = 0>
NdArray< dtype >	asarray (dtype *ptr, UIntType1 numRows, UIntType2 numCols, PointerPolicy pointerPolicy=PointerPolicy::COPY) 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, PointerPolicy pointerPolicy=PointerPolicy::COPY)
template<typename dtype , size_t Dim0Size, size_t Dim1Size>
NdArray< dtype >	asarray (std::array< std::array< dtype, Dim1Size >, Dim0Size > &inArray, PointerPolicy pointerPolicy=PointerPolicy::COPY)
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, PointerPolicy pointerPolicy=PointerPolicy::COPY)
template<typename dtype , size_t Dim1Size>
NdArray< dtype >	asarray (std::vector< std::array< dtype, Dim1Size > > &inVector, PointerPolicy pointerPolicy=PointerPolicy::COPY)
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 >
NdArray< dtype >	column_stack (const std::vector< 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 >
NdArray< dtype >	concatenate (const std::vector< 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, Bias bias=Bias::NO)
template<typename dtype >
NdArray< double >	cov_inv (const NdArray< dtype > &x, Bias bias=Bias::NO)
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 , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>
NdArray< dtype >	deleteIndices (const NdArray< dtype > &inArray, const Indices &inIndices, Axis inAxis=Axis::NONE)
template<typename dtype >
NdArray< dtype >	deleteIndices (const NdArray< dtype > &inArray, int32 inIndex, Axis inAxis=Axis::NONE)
template<typename dtype >
NdArray< dtype >	deleteIndices (const NdArray< dtype > &inArray, Slice inIndicesSlice, 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 dtype1 , typename dtype2 >
NdArray< uint32 >	digitize (const NdArray< dtype1 > &x, const NdArray< dtype2 > &bins)
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 dtype &inScalar, const NdArray< dtype > &inArray)
template<typename dtype >
NdArray< dtype >	fmax (const NdArray< dtype > &inArray, const dtype &inScalar)
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 dtype &inScalar, const NdArray< dtype > &inArray)
template<typename dtype >
NdArray< dtype >	fmin (const NdArray< dtype > &inArray, const dtype &inScalar)
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 , std::enable_if_t< std::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 >
NdArray< dtype >	fromfunction (const std::function< dtype(typename NdArray< dtype >::size_type)> func, typename NdArray< dtype >::size_type size)
template<typename dtype >
NdArray< dtype >	fromfunction (const std::function< dtype(typename NdArray< dtype >::size_type, typename NdArray< dtype >::size_type)> func, Shape shape)
template<typename dtype , typename Iter >
NdArray< dtype >	fromiter (Iter inBegin, Iter inEnd)
template<typename dtype >
NdArray< dtype >	fromstring (const std::string &inStr, const char inSep=' ')
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, EndPoint endPoint=EndPoint::YES)
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 , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>
std::vector< NdArray< dtype > >	hsplit (const NdArray< dtype > &inArray, const Indices &indices)
template<typename dtype >
NdArray< dtype >	hstack (std::initializer_list< NdArray< dtype > > inArrayList)
template<typename dtype >
NdArray< dtype >	hstack (std::vector< NdArray< dtype > > inArrayList)
template<typename dtype >
NdArray< double >	hypot (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
template<typename dtype >
NdArray< double >	hypot (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2, const NdArray< dtype > &inArray3)
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 , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>
NdArray< dtype >	insert (const NdArray< dtype > &arr, const Indices &indices, const dtype &value, Axis axis=Axis::NONE)
template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>
NdArray< dtype >	insert (const NdArray< dtype > &arr, const Indices &indices, const NdArray< dtype > &values, Axis axis=Axis::NONE)
template<typename dtype >
NdArray< dtype >	insert (const NdArray< dtype > &arr, int32 index, const dtype &value)
template<typename dtype >
NdArray< dtype >	insert (const NdArray< dtype > &arr, int32 index, const dtype &value, Axis axis)
template<typename dtype >
NdArray< dtype >	insert (const NdArray< dtype > &arr, int32 index, const NdArray< dtype > &values)
template<typename dtype >
NdArray< dtype >	insert (const NdArray< dtype > &arr, int32 index, const NdArray< dtype > &values, Axis axis)
template<typename dtype >
NdArray< dtype >	insert (const NdArray< dtype > &arr, Slice slice, const dtype &value, Axis axis=Axis::NONE)
template<typename dtype >
NdArray< dtype >	insert (const NdArray< dtype > &arr, Slice slice, const NdArray< dtype > &values, Axis axis=Axis::NONE)
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, EndPoint endPoint=EndPoint::YES)
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	logaddexp (const NdArray< dtype > &x1, const NdArray< dtype > &x2)
template<typename dtype >
auto	logaddexp (dtype x1, dtype x2) noexcept
template<typename dtype >
auto	logaddexp2 (const NdArray< dtype > &x1, const NdArray< dtype > &x2)
template<typename dtype >
auto	logaddexp2 (dtype x1, dtype x2) 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, EndPoint endPoint=EndPoint::YES, double base=10.)
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 dtype &inScalar, const NdArray< dtype > &inArray)
template<typename dtype >
NdArray< dtype >	maximum (const NdArray< dtype > &inArray, const dtype &inScalar)
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 dtype &inScalar, const NdArray< dtype > &inArray)
template<typename dtype >
NdArray< dtype >	minimum (const NdArray< dtype > &inArray, const dtype &inScalar)
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.), 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, InterpolationMethod inInterpMethod=InterpolationMethod::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< double >	normalize (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
template<typename dtype >
NdArray< std::complex< double > >	normalize (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)
bool	operator!= (const DateTime &lhs, const DateTime &rhs) noexcept
	Non Equality operator for DateTime. More...
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 , std::enable_if_t< std::is_integral_v< dtype >||std::is_floating_point_v< dtype >, int > = 0>
NdArray< dtype >	operator% (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
template<typename dtype , std::enable_if_t< std::is_integral_v< dtype >, int > = 0>
NdArray< dtype >	operator% (dtype lhs, const NdArray< dtype > &rhs)
template<typename dtype >
NdArray< dtype >	operator% (NdArray< dtype > lhs, dtype rhs)
template<typename dtype , std::enable_if_t< std::is_integral_v< dtype >||std::is_floating_point_v< dtype >, int > = 0>
NdArray< dtype > &	operator%= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
template<typename dtype , std::enable_if_t< std::is_integral_v< dtype >||std::is_floating_point_v< dtype >, 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& (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&= (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< std::complex< dtype > >	operator* (const NdArray< std::complex< dtype > > &lhs, const NdArray< 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, dtype rhs)
template<typename dtype >
NdArray< std::complex< dtype > >	operator* (NdArray< std::complex< dtype > > lhs, 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< std::complex< dtype > >	operator+ (const NdArray< std::complex< dtype > > &lhs, const NdArray< 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<typename dtype >
NdArray< dtype >	operator+ (NdArray< dtype > lhs, dtype rhs)
template<typename dtype >
NdArray< std::complex< dtype > >	operator+ (NdArray< std::complex< dtype > > lhs, 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)
Duration	operator- (const DateTime &lhs, const DateTime &rhs) noexcept
	Subtraction operator. More...
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< std::complex< dtype > >	operator- (const NdArray< std::complex< dtype > > &lhs, const NdArray< 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, dtype rhs)
template<typename dtype >
NdArray< std::complex< dtype > >	operator- (NdArray< std::complex< dtype > > lhs, 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< std::complex< dtype > >	operator/ (const NdArray< std::complex< dtype > > &lhs, const NdArray< 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, dtype rhs)
template<typename dtype >
NdArray< std::complex< dtype > >	operator/ (NdArray< std::complex< dtype > > lhs, 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)
bool	operator< (const DateTime &lhs, const DateTime &rhs) noexcept
	Less than operator. More...
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 &os, const DateTime &datetime) noexcept
	Stream operator. More...
std::ostream &	operator<< (std::ostream &os, const TimePoint &timepoint)
	Output stream operator for the TimePoint type. More...
std::ostream &	operator<< (std::ostream &os, Duration duration)
	Output stream operator for the Duration type. More...
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)
bool	operator<= (const DateTime &lhs, const DateTime &rhs) noexcept
	Less than or equal operator. More...
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)
bool	operator== (const DateTime &lhs, const DateTime &rhs) noexcept
	Equality operator for DateTime. More...
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)
bool	operator> (const DateTime &lhs, const DateTime &rhs) noexcept
	Greater than operator. More...
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)
bool	operator>= (const DateTime &lhs, const DateTime &rhs) noexcept
	Greater than or equal operator. More...
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^ (dtype lhs, const NdArray< dtype > &rhs)
template<typename dtype >
NdArray< dtype >	operator^ (NdArray< dtype > lhs, 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| (dtype lhs, const NdArray< dtype > &rhs)
template<typename dtype >
NdArray< dtype >	operator| (NdArray< dtype > lhs, 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 , std::enable_if_t< std::is_integral_v< dtype >||std::is_same_v< dtype, bool >, int > = 0>
NdArray< uint8 >	packbitsBigEndian (const NdArray< dtype > &a, Axis axis=Axis::NONE)
template<typename dtype , std::enable_if_t< std::is_integral_v< dtype >||std::is_same_v< dtype, bool >, int > = 0>
NdArray< uint8 >	packbitsLittleEndian (const NdArray< dtype > &a, Axis axis=Axis::NONE)
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, InterpolationMethod inInterpMethod=InterpolationMethod::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 , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>
NdArray< dtype > &	put (NdArray< dtype > &inArray, const Indices &inIndices, const dtype &inValue)
template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>
NdArray< dtype > &	put (NdArray< dtype > &inArray, const Indices &inIndices, const NdArray< dtype > &inValues)
template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>
NdArray< dtype > &	put (NdArray< dtype > &inArray, const Indices &inRowIndices, int32 inColIndex, const dtype &inValue)
template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>
NdArray< dtype > &	put (NdArray< dtype > &inArray, const Indices &inRowIndices, int32 inColIndex, const NdArray< dtype > &inValues)
template<typename dtype , typename RowIndices , typename ColIndices , type_traits::ndarray_int_concept< RowIndices > = 0, type_traits::ndarray_int_concept< ColIndices > = 0>
NdArray< dtype > &	put (NdArray< dtype > &inArray, const RowIndices &inRowIndices, const ColIndices &inColIndices, const dtype &inValue)
template<typename dtype , typename RowIndices , typename ColIndices , type_traits::ndarray_int_concept< RowIndices > = 0, type_traits::ndarray_int_concept< ColIndices > = 0>
NdArray< dtype > &	put (NdArray< dtype > &inArray, const RowIndices &inRowIndices, const ColIndices &inColIndices, const NdArray< dtype > &inValues)
template<typename dtype , typename RowIndices , type_traits::ndarray_int_concept< RowIndices > = 0>
NdArray< dtype > &	put (NdArray< dtype > &inArray, const RowIndices &inRowIndices, const Slice &inColSlice, const dtype &inValue)
template<typename dtype , typename RowIndices , type_traits::ndarray_int_concept< RowIndices > = 0>
NdArray< dtype > &	put (NdArray< dtype > &inArray, const RowIndices &inRowIndices, const Slice &inColSlice, const NdArray< dtype > &inValues)
template<typename dtype , typename ColIndices , type_traits::ndarray_int_concept< ColIndices > = 0>
NdArray< dtype > &	put (NdArray< dtype > &inArray, const Slice &inRowSlice, const ColIndices &inColIndices, const dtype &inValue)
template<typename dtype , typename ColIndices , type_traits::ndarray_int_concept< ColIndices > = 0>
NdArray< dtype > &	put (NdArray< dtype > &inArray, const Slice &inRowSlice, const ColIndices &inColIndices, const NdArray< dtype > &inValues)
template<typename dtype >
NdArray< dtype > &	put (NdArray< dtype > &inArray, const Slice &inRowSlice, const Slice &inColSlice, const dtype &inValue)
template<typename dtype >
NdArray< dtype > &	put (NdArray< dtype > &inArray, const Slice &inRowSlice, const Slice &inColSlice, const NdArray< dtype > &inValues)
template<typename dtype >
NdArray< dtype > &	put (NdArray< dtype > &inArray, const Slice &inRowSlice, int32 inColIndex, const dtype &inValue)
template<typename dtype >
NdArray< dtype > &	put (NdArray< dtype > &inArray, const Slice &inRowSlice, int32 inColIndex, const NdArray< dtype > &inValues)
template<typename dtype >
NdArray< dtype > &	put (NdArray< dtype > &inArray, const Slice &inSlice, const dtype &inValue)
template<typename dtype >
NdArray< dtype > &	put (NdArray< dtype > &inArray, const Slice &inSlice, const NdArray< dtype > &inValues)
template<typename dtype >
NdArray< dtype > &	put (NdArray< dtype > &inArray, int32 inIndex, const dtype &inValue)
template<typename dtype >
NdArray< dtype > &	put (NdArray< dtype > &inArray, int32 inRow, int32 inCol, const dtype &inValue)
template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>
NdArray< dtype > &	put (NdArray< dtype > &inArray, int32 inRowIndex, const Indices &inColIndices, const dtype &inValue)
template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>
NdArray< dtype > &	put (NdArray< dtype > &inArray, int32 inRowIndex, const Indices &inColIndices, const NdArray< dtype > &inValues)
template<typename dtype >
NdArray< dtype > &	put (NdArray< dtype > &inArray, int32 inRowIndex, const Slice &inColSlice, const dtype &inValue)
template<typename dtype >
NdArray< dtype > &	put (NdArray< dtype > &inArray, int32 inRowIndex, const Slice &inColSlice, const NdArray< dtype > &inValues)
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 >	row_stack (const std::vector< NdArray< dtype > > &inArrayList)
template<typename dtype >
NdArray< typename NdArray< dtype >::index_type >	searchsorted (const NdArray< dtype > &inArray, const NdArray< dtype > &inValues, Side side=Side::LEFT)
template<typename dtype >
NdArray< dtype >::index_type	searchsorted (const NdArray< dtype > &inArray, dtype inValue, Side side=Side::LEFT)
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 , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>
std::vector< NdArray< dtype > >	split (const NdArray< dtype > &inArray, const Indices &indices, Axis inAxis=Axis::ROW)
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< dtype >	stack (std::vector< 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 , type_traits::ndarray_int_concept< Indices > = 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., 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)
NdArray< uint8 >	unpackbitsBigEndian (const NdArray< uint8 > &a, Axis axis=Axis::NONE)
NdArray< uint8 >	unpackbitsLittleEndian (const NdArray< uint8 > &a, Axis axis=Axis::NONE)
template<typename dtype >
NdArray< dtype >	unwrap (const NdArray< dtype > &inArray)
template<typename dtype >
dtype	unwrap (dtype inValue) noexcept
template<typename dtype >
auto	vander (const NdArray< dtype > &x, Increasing increasing=Increasing::YES)
template<typename dtype >
auto	vander (const NdArray< dtype > &x, uint32 n, Increasing increasing=Increasing::YES)
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 , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>
std::vector< NdArray< dtype > >	vsplit (const NdArray< dtype > &inArray, const Indices &indices)
template<typename dtype >
NdArray< dtype >	vstack (std::initializer_list< NdArray< dtype > > inArrayList)
template<typename dtype >
NdArray< dtype >	vstack (std::vector< 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< double >	wrap (const NdArray< dtype > &inAngles) noexcept
	Wrap the input angle to [-pi, pi]. More...
template<typename dtype >
double	wrap (dtype inAngle) noexcept
	Wrap the input angle to [-pi, pi]. More...
template<typename dtype >
NdArray< double >	wrap2Pi (const NdArray< dtype > &inAngles) noexcept
	Wrap the input angle to [0, 2*pi]. More...
template<typename dtype >
double	wrap2Pi (dtype inAngle) noexcept
	Wrap the input angle to [0, 2*pi]. More...
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<class T >
constexpr bool	is_complex_v = is_complex<T>::value
template<typename T >
constexpr bool	is_ndarray_int_v = is_ndarray_int<T>::value
template<class dtype >
constexpr bool	is_valid_dtype_v = is_valid_dtype<dtype>::value
constexpr char	VERSION [] = "2.12.1"
	Current NumCpp version number. More...

Typedef Documentation

Clock

using nc::Clock = typedef std::chrono::system_clock

Clock Type.

Duration

using nc::Duration = typedef std::chrono::nanoseconds

Duration Type.

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

ndarray_int_concept

template<typename T >

using nc::ndarray_int_concept = typedef std::enable_if_t<is_ndarray_int_v<T>, int>

is_ndarray_int

TimePoint

using nc::TimePoint = typedef std::chrono::time_point<Clock, Duration>

TimePoint Type.

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 class nc::Axis

strong

Enum To describe an axis.

Enumerator
NONE
ROW
COL

Bias

enum class nc::Bias : bool

strong

Bias boolean.

Enumerator
YES
NO

Endian

enum class nc::Endian

strong

Enum for endianess.

Enumerator
NATIVE
BIG
LITTLE

EndPoint

enum class nc::EndPoint : bool

strong

End Point boolean.

Enumerator
YES
NO

Increasing

enum class nc::Increasing : bool

strong

Increasing boolean.

Enumerator
YES
NO

InterpolationMethod

enum class nc::InterpolationMethod

strong

Interpolation method

Enumerator
LINEAR
LOWER
HIGHER
NEAREST
MIDPOINT

IsRoots

enum class nc::IsRoots : bool

strong

Is Roots boolean.

Enumerator
YES
NO

PointerPolicy

enum class nc::PointerPolicy

strong

Policy for NdArray constructor that takes in a pointer to data.

Enumerator
COPY
SHELL

PrintElapsedTime

enum class nc::PrintElapsedTime : bool

strong

Print Elapsed Time boolean.

Enumerator
YES
NO

PrintResults

enum class nc::PrintResults : bool

strong

Print Results boolean.

Enumerator
YES
NO

Replace

enum class nc::Replace : bool

strong

Replace boolean.

Enumerator
YES
NO

Side

enum class nc::Side

strong

Right or Left side

Enumerator
LEFT
RIGHT

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

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

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 UIntType , std::enable_if_t< std::is_integral_v< UIntType > &&!std::is_same_v< UIntType, bool >, int > = 0>

NdArray< dtype > nc::asarray ( dtype *  ptr, UIntType  size, PointerPolicy  pointerPolicy = PointerPolicy::COPY  )

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
pointerPolicy	(optional) whether to make a copy and own the data, or act as a non-owning shell. Default Copy

Returns

NdArray

asarray() [10/17]

template<typename dtype , typename UIntType1 , typename UIntType2 , std::enable_if_t< std::is_integral_v< UIntType1 > &&!std::is_same_v< UIntType1, bool >, int > = 0, std::enable_if_t< std::is_integral_v< UIntType2 > &&!std::is_same_v< UIntType2, bool >, int > = 0>

NdArray< dtype > nc::asarray ( dtype *  ptr, UIntType1  numRows, UIntType2  numCols, PointerPolicy  pointerPolicy = PointerPolicy::COPY  )

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
pointerPolicy	(optional) whether to make a copy and own the data, or act as a non-owning shell. Default Copy

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,
		PointerPolicy	pointerPolicy = PointerPolicy::COPY
	)

Convert the std::array to an array.

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

Parameters

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

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,
		PointerPolicy	pointerPolicy = PointerPolicy::COPY
	)

Convert the std::array to an array.

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

Parameters

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

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,
		PointerPolicy	pointerPolicy = PointerPolicy::COPY
	)

Convert the vector to an array.

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

Parameters

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

Returns

NdArray

asarray() [17/17]

template<typename dtype , size_t Dim1Size>

NdArray< dtype > nc::asarray	(	std::vector< std::array< dtype, Dim1Size > > &	inVector,
		PointerPolicy	pointerPolicy = PointerPolicy::COPY
	)

Convert the vector to an array.

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

Parameters

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

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() [1/2]

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

column_stack() [2/2]

template<typename dtype >

NdArray< dtype > nc::column_stack

(

const std::vector< 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() [1/2]

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

concatenate() [2/2]

template<typename dtype >

NdArray< dtype > nc::concatenate	(	const std::vector< 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,
		Bias	bias = Bias::NO
	)

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,
		Bias	bias = Bias::NO
	)

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 , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>

NdArray< dtype > nc::deleteIndices	(	const NdArray< dtype > &	inArray,
		const Indices &	inIndices,
		Axis	inAxis = Axis::NONE
	)

Return a new array with sub-arrays along an axis deleted.

Parameters

inArray
inIndices
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,
		int32	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

deleteIndices() [3/3]

template<typename dtype >

NdArray< dtype > nc::deleteIndices	(	const NdArray< dtype > &	inArray,
		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

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.

digitize()

template<typename dtype1 , typename dtype2 >

NdArray< uint32 > nc::digitize	(	const NdArray< dtype1 > &	x,
		const NdArray< dtype2 > &	bins
	)

Return the indices of the bins to which each value in input array belongs.

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

Parameters

x	Input array to be binned.
bins	Array of bins.

Returns

NdArray

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

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/4]

template<typename dtype >

NdArray< dtype > nc::fmax	(	const dtype &	inScalar,
		const NdArray< dtype > &	inArray
	)

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

inScalar
inArray

Returns

NdArray

fmax() [2/4]

template<typename dtype >

NdArray< dtype > nc::fmax	(	const NdArray< dtype > &	inArray,
		const dtype &	inScalar
	)

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

inArray
inScalar

Returns

NdArray

fmax() [3/4]

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() [4/4]

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/4]

template<typename dtype >

NdArray< dtype > nc::fmin	(	const dtype &	inScalar,
		const NdArray< dtype > &	inArray
	)

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

inScalar
inArray

Returns

NdArray

fmin() [2/4]

template<typename dtype >

NdArray< dtype > nc::fmin	(	const NdArray< dtype > &	inArray,
		const dtype &	inScalar
	)

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

inArray
inScalar

Returns

NdArray

fmin() [3/4]

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() [4/4]

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 , std::enable_if_t< std::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

fromfunction() [1/2]

template<typename dtype >

NdArray< dtype > nc::fromfunction	(	const std::function< dtype(typename NdArray< dtype >::size_type)>	func,
		typename NdArray< dtype >::size_type	size
	)

Construct an array by executing a function over each coordinate. The resulting array therefore has a value fn(x) at coordinate(x).

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

Parameters

func	callable that accepts an integer coordinate and returns type T
size	the size of the 1d array to create

Returns

NdArray

fromfunction() [2/2]

template<typename dtype >

NdArray< dtype > nc::fromfunction	(	const std::function< dtype(typename NdArray< dtype >::size_type, typename NdArray< dtype >::size_type)>	func,
		Shape	shape
	)

Construct an array by executing a function over each coordinate. The resulting array therefore has a value fn(x, y) at coordinate(x, y).

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

Parameters

func	callable that accepts an integer coordinate and returns type T
shape	the shape of the array to create

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

fromstring()

template<typename dtype >

NdArray< dtype > nc::fromstring	(	const std::string &	inStr,
		const char	inSep = ' '
	)

Construct an array from data in a string

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

Parameters

inStr
inSep	Delimiter separator between values in the string

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,
		EndPoint	endPoint = EndPoint::YES
	)

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

hsplit()

template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>

std::vector< NdArray< dtype > > nc::hsplit	(	const NdArray< dtype > &	inArray,
		const Indices &	indices
	)

Split an array into multiple sub-arrays horizontal (column-wise).

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

Parameters

inArray
indices	the indices to split

Returns

NdArray

hstack() [1/2]

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.

hstack() [2/2]

template<typename dtype >

NdArray< dtype > nc::hstack

(

std::vector< 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

hypot() [1/4]

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/4]

template<typename dtype >

NdArray< double > nc::hypot	(	const NdArray< dtype > &	inArray1,
		const NdArray< dtype > &	inArray2,
		const NdArray< dtype > &	inArray3
	)

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
inArray3

Returns

NdArray

hypot() [3/4]

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() [4/4]

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

insert() [1/8]

template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>

NdArray< dtype > nc::insert	(	const NdArray< dtype > &	arr,
		const Indices &	indices,
		const dtype &	value,
		Axis	axis = Axis::NONE
	)

Insert values along the given axis before the given indices.

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

Parameters

arr	input array.
indices	indices to insert the values before
value	value to insert
axis	axis along which to insert values

Returns

index: index before which values are inserted.

insert() [2/8]

template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>

NdArray< dtype > nc::insert	(	const NdArray< dtype > &	arr,
		const Indices &	indices,
		const NdArray< dtype > &	values,
		Axis	axis = Axis::NONE
	)

Insert values along the given axis before the given indices.

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

Parameters

arr	input array.
indices	indices to insert the values before
values	values to insert
axis	axis along which to insert values

Returns

index: index before which values are inserted.

insert() [3/8]

template<typename dtype >

NdArray< dtype > nc::insert	(	const NdArray< dtype > &	arr,
		int32	index,
		const dtype &	value
	)

Insert values before the given indices.

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

Parameters

arr	input array.
index	index to insert the value before in the flattened
value	value to insert

Returns

index: index before which values are inserted.

insert() [4/8]

template<typename dtype >

NdArray< dtype > nc::insert	(	const NdArray< dtype > &	arr,
		int32	index,
		const dtype &	value,
		Axis	axis
	)

Insert values along the given axis before the given indices.

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

Parameters

arr	input array.
index	index to insert the values before
value	value to insert
axis	axis along which to insert values

Returns

index: index before which values are inserted.

insert() [5/8]

template<typename dtype >

NdArray< dtype > nc::insert	(	const NdArray< dtype > &	arr,
		int32	index,
		const NdArray< dtype > &	values
	)

Insert values before the given indices.

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

Parameters

arr	input array.
index	index to insert the values before in the flattened
values	value to insert

Returns

index: index before which values are inserted.

insert() [6/8]

template<typename dtype >

NdArray< dtype > nc::insert	(	const NdArray< dtype > &	arr,
		int32	index,
		const NdArray< dtype > &	values,
		Axis	axis
	)

Insert values along the given axis before the given indices.

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

Parameters

arr	input array.
index	index to insert the values before
values	values to insert
axis	axis along which to insert values

Returns

index: index before which values are inserted.

insert() [7/8]

template<typename dtype >

NdArray< dtype > nc::insert	(	const NdArray< dtype > &	arr,
		Slice	slice,
		const dtype &	value,
		Axis	axis = Axis::NONE
	)

Insert values along the given axis before the given indices.

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

Parameters

arr	input array.
slice	slice to insert the values before
value	values to insert
axis	axis along which to insert values

Returns

index: index before which values are inserted.

insert() [8/8]

template<typename dtype >

NdArray< dtype > nc::insert	(	const NdArray< dtype > &	arr,
		Slice	slice,
		const NdArray< dtype > &	values,
		Axis	axis = Axis::NONE
	)

Insert values along the given axis before the given indices.

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

Parameters

arr	input array.
slice	slice to insert the values before
values	values to insert
axis	axis along which to insert values

Returns

index: index before which values are inserted.

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,
		EndPoint	endPoint = EndPoint::YES
	)

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

logaddexp() [1/2]

template<typename dtype >

auto nc::logaddexp	(	const NdArray< dtype > &	x1,
		const NdArray< dtype > &	x2
	)

Logarithm of the sum of exponentiations of the inputs, element-wise.

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

Parameters

x1
x2

Returns

NdArray

logaddexp() [2/2]

template<typename dtype >

auto nc::logaddexp ( dtype  x1, dtype  x2  )

noexcept

Logarithm of the sum of exponentiations of the inputs.

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

Parameters

x1
x2

Returns

value

logaddexp2() [1/2]

template<typename dtype >

auto nc::logaddexp2	(	const NdArray< dtype > &	x1,
		const NdArray< dtype > &	x2
	)

Logarithm of the sum of exponentiations of the inputs, element-wise.

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

Parameters

x1
x2

Returns

NdArray

logaddexp2() [2/2]

template<typename dtype >

auto nc::logaddexp2 ( dtype  x1, dtype  x2  )

noexcept

Logarithm of the sum of exponentiations of the inputs.

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

Parameters

x1
x2

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,
		EndPoint	endPoint = EndPoint::YES,
		double	base = 10.
	)

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() [1/3]

template<typename dtype >

NdArray< dtype > nc::maximum	(	const dtype &	inScalar,
		const NdArray< dtype > &	inArray
	)

Element-wise maximum of array elements.

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

Parameters

inScalar
inArray

Returns

NdArray

maximum() [2/3]

template<typename dtype >

NdArray< dtype > nc::maximum	(	const NdArray< dtype > &	inArray,
		const dtype &	inScalar
	)

Element-wise maximum of array elements.

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

Parameters

inArray
inScalar

Returns

NdArray

maximum() [3/3]

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 scalar 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 scalar 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() [1/3]

template<typename dtype >

NdArray< dtype > nc::minimum	(	const dtype &	inScalar,
		const NdArray< dtype > &	inArray
	)

Element-wise minimum of array elements.

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

Parameters

inScalar
inArray

Returns

NdArray

minimum() [2/3]

template<typename dtype >

NdArray< dtype > nc::minimum	(	const NdArray< dtype > &	inArray,
		const dtype &	inScalar
	)

Element-wise minimum of array elements.

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

Parameters

inArray
inScalar

Returns

NdArray

minimum() [3/3]

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.),
		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,
		InterpolationMethod	inInterpMethod = InterpolationMethod::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

normalize() [1/2]

template<typename dtype >

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

Matrix or vector norm.

Parameters

inArray
inAxis	(Optional, default NONE)

Returns

NdArray

normalize() [2/2]

template<typename dtype >

NdArray< std::complex< double > > nc::normalize	(	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/4]

bool nc::operator!= ( const DateTime &  lhs, const DateTime &  rhs  )

inlinenoexcept

Non Equality operator for DateTime.

Parameters

lhs	the left hand side value
rhs	the right hand side value

Returns

bool

operator!=() [2/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!=() [3/4]

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 scalar

Parameters

lhs
inValue

Returns

NdArray

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 an array and a scalar

Parameters

inValue
inArray

Returns

NdArray

operator%() [1/3]

template<typename dtype , std::enable_if_t< std::is_integral_v< dtype >||std::is_floating_point_v< dtype >, int > = 0>

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 , std::enable_if_t< std::is_integral_v< dtype >, int > = 0>

NdArray< dtype > nc::operator%	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Modulus of the scalar and the array

Parameters

lhs
rhs

Returns

NdArray

operator%() [3/3]

template<typename dtype >

NdArray< dtype > nc::operator%	(	NdArray< dtype >	lhs,
		dtype	rhs
	)

Modulus of the array and the scalar

Parameters

lhs
rhs

Returns

NdArray

operator%=() [1/2]

template<typename dtype , std::enable_if_t< std::is_integral_v< dtype >||std::is_floating_point_v< dtype >, 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 , std::enable_if_t< std::is_integral_v< dtype >||std::is_floating_point_v< dtype >, int > = 0>

NdArray< dtype > & nc::operator%=	(	NdArray< dtype > &	lhs,
		dtype	rhs
	)

Modulus the scalar 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&	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Takes the bitwise and of the sclar and the array

Parameters

lhs
rhs

Returns

NdArray

operator&() [3/3]

template<typename dtype >

NdArray< dtype > nc::operator&	(	NdArray< dtype >	lhs,
		dtype	rhs
	)

Takes the bitwise and of the array and the scalar

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 scalar

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 scalar

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 scalar 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 scalar to the array (6)

Parameters

lhs
rhs

Returns

NdArray

operator*() [4/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*() [5/15]

template<typename dtype >

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

Multiplies the scalar to the array (7)

Parameters

lhs
rhs

Returns

NdArray

operator*() [6/15]

double nc::operator* ( const Vec2 &  lhs, const Vec2 &  rhs  )

inlinenoexcept

Vector mulitplication (dot product)

Parameters

lhs
rhs

Returns

dot product

operator*() [7/15]

Vec2 nc::operator* ( const Vec2 &  lhs, double  rhs  )

inlinenoexcept

Scalar mulitplication

Parameters

lhs
rhs

Returns

Vec2

operator*() [8/15]

double nc::operator* ( const Vec3 &  lhs, const Vec3 &  rhs  )

inlinenoexcept

Vector mulitplication (dot product)

Parameters

lhs
rhs

Returns

dot product

operator*() [9/15]

Vec3 nc::operator* ( const Vec3 &  lhs, double  rhs  )

inlinenoexcept

Scalar mulitplication

Parameters

lhs
rhs

Returns

Vec3

operator*() [10/15]

Vec2 nc::operator* ( double  lhs, const Vec2 &  rhs  )

inlinenoexcept

Scalar mulitplication

Parameters

lhs
rhs

Returns

Vec2

operator*() [11/15]

Vec3 nc::operator* ( double  lhs, const Vec3 &  rhs  )

inlinenoexcept

Scalar mulitplication

Parameters

lhs
rhs

Returns

Vec3

operator*() [12/15]

template<typename dtype >

NdArray< dtype > nc::operator*	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Multiplies the scalar to the array (5)

Parameters

lhs
rhs

Returns

NdArray

operator*() [13/15]

template<typename dtype >

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

Multiplies the scalar to the array (9)

Parameters

lhs
rhs

Returns

NdArray

operator*() [14/15]

template<typename dtype >

NdArray< dtype > nc::operator*	(	NdArray< dtype >	lhs,
		dtype	rhs
	)

Multiplies the scalar to the array (4)

Parameters

lhs
rhs

Returns

NdArray

operator*() [15/15]

template<typename dtype >

NdArray< std::complex< dtype > > nc::operator*	(	NdArray< std::complex< dtype > >	lhs,
		dtype	rhs
	)

Multiplies the scalar to the array (8)

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 scalar 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 scalar 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 scalar to the array (6)

Parameters

lhs
rhs

Returns

NdArray

operator+() [4/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+() [5/19]

template<typename dtype >

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

Adds the scalar to the array (7)

Parameters

lhs
rhs

Returns

NdArray

operator+() [6/19]

Vec2 nc::operator+ ( const Vec2 &  lhs, const Vec2 &  rhs  )

inlinenoexcept

Adds the two vectors

Parameters

lhs
rhs

Returns

Vec2

operator+() [7/19]

Vec2 nc::operator+ ( const Vec2 &  lhs, double  rhs  )

inlinenoexcept

Adds the scalar to the vector

Parameters

lhs
rhs

Returns

Vec2

operator+() [8/19]

Vec3 nc::operator+ ( const Vec3 &  lhs, const Vec3 &  rhs  )

inlinenoexcept

Adds the two vectors

Parameters

lhs
rhs

Returns

Vec3

operator+() [9/19]

Vec3 nc::operator+ ( const Vec3 &  lhs, double  rhs  )

inlinenoexcept

Adds the scalar to the vector

Parameters

lhs
rhs

Returns

Vec3

operator+() [10/19]

Vec2 nc::operator+ ( double  lhs, const Vec2 &  rhs  )

inlinenoexcept

Adds the scalar to the vector

Parameters

lhs
rhs

Returns

Vec2

operator+() [11/19]

Vec3 nc::operator+ ( double  lhs, const Vec3 &  rhs  )

inlinenoexcept

Adds the scalar to the vector

Parameters

lhs
rhs

Returns

Vec3

operator+() [12/19]

template<typename dtype >

NdArray< dtype > nc::operator+	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Adds the scalar to the array (5)

Parameters

lhs
rhs

Returns

NdArray

operator+() [13/19]

template<typename dtype >

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

Adds the scalar to the array (9)

Parameters

lhs
rhs

Returns

NdArray

operator+() [14/19]

template<typename dtype >

NdArray< dtype > nc::operator+	(	NdArray< dtype >	lhs,
		dtype	rhs
	)

Adds the scalar to the array (4)

Parameters

lhs
rhs

Returns

NdArray

operator+() [15/19]

template<typename dtype >

NdArray< std::complex< dtype > > nc::operator+	(	NdArray< std::complex< dtype > >	lhs,
		dtype	rhs
	)

Adds the scalar to the array (8)

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 scalar 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 scalar to the array (4)

Parameters

lhs
rhs

Returns

NdArray

operator-() [1/19]

Duration nc::operator- ( const DateTime &  lhs, const DateTime &  rhs  )

inlinenoexcept

Subtraction operator.

Parameters

lhs	the left hand side value
rhs	the right hand side value

Returns

bool

operator-() [2/19]

template<typename dtype >

NdArray< dtype > nc::operator-

(

const NdArray< dtype > &

inArray

)

Negative Operator

Returns

NdArray

operator-() [3/19]

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-() [4/19]

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-() [5/19]

template<typename dtype >

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

Subtracts the scalar from the array (6)

Parameters

lhs
rhs

Returns

NdArray

operator-() [6/19]

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/19]

template<typename dtype >

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

Subtracts the scalar from the array (7)

Parameters

lhs
rhs

Returns

NdArray

operator-() [8/19]

Vec2 nc::operator- ( const Vec2 &  lhs, const Vec2 &  rhs  )

inlinenoexcept

Subtracts the two vectors

Parameters

lhs
rhs

Returns

Vec2

operator-() [9/19]

Vec2 nc::operator- ( const Vec2 &  lhs, double  rhs  )

inlinenoexcept

Subtracts the scalar from the vector

Parameters

lhs
rhs

Returns

Vec2

operator-() [10/19]

Vec2 nc::operator- ( const Vec2 &  vec )

inlinenoexcept

Returns the negative vector

Returns

Vec2

operator-() [11/19]

Vec3 nc::operator- ( const Vec3 &  lhs, const Vec3 &  rhs  )

inlinenoexcept

Subtracts the two vectors

Parameters

lhs
rhs

Returns

Vec3

operator-() [12/19]

Vec3 nc::operator- ( const Vec3 &  lhs, double  rhs  )

inlinenoexcept

Subtracts the scalar from the vector

Parameters

lhs
rhs

Returns

Vec3

operator-() [13/19]

Vec3 nc::operator- ( const Vec3 &  vec )

inlinenoexcept

Returns the negative vector

Returns

Vec3

operator-() [14/19]

Vec2 nc::operator- ( double  lhs, const Vec2 &  rhs  )

inlinenoexcept

Subtracts the scalar from the vector

Parameters

lhs
rhs

Returns

Vec2

operator-() [15/19]

Vec3 nc::operator- ( double  lhs, const Vec3 &  rhs  )

inlinenoexcept

Subtracts the scalar from the vector

Parameters

lhs
rhs

Returns

Vec3

operator-() [16/19]

template<typename dtype >

NdArray< dtype > nc::operator-	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Subtracts the scalar from the array (5)

Parameters

lhs
rhs

Returns

NdArray

operator-() [17/19]

template<typename dtype >

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

Subtracts the scalar from the array (9)

Parameters

lhs
rhs

Returns

NdArray

operator-() [18/19]

template<typename dtype >

NdArray< dtype > nc::operator-	(	NdArray< dtype >	lhs,
		dtype	rhs
	)

Subtracts the scalar from the array (4)

Parameters

lhs
rhs

Returns

NdArray

operator-() [19/19]

template<typename dtype >

NdArray< std::complex< dtype > > nc::operator-	(	NdArray< std::complex< dtype > >	lhs,
		dtype	rhs
	)

Subtracts the scalar from the array (8)

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 scalar 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 scalar 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 scalar from the array (6)

Parameters

lhs
rhs

Returns

NdArray

operator/() [4/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/() [5/11]

template<typename dtype >

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

Divides the scalar from the array (7)

Parameters

lhs
rhs

Returns

NdArray

operator/() [6/11]

Vec2 nc::operator/ ( const Vec2 &  lhs, double  rhs  )

inlinenoexcept

Scalar division

Parameters

lhs
rhs

Returns

Vec2

operator/() [7/11]

Vec3 nc::operator/ ( const Vec3 &  lhs, double  rhs  )

inlinenoexcept

Scalar division

Parameters

lhs
rhs

Returns

Vec3

operator/() [8/11]

template<typename dtype >

NdArray< dtype > nc::operator/	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Divides the scalar from the array (5)

Parameters

lhs
rhs

Returns

NdArray

operator/() [9/11]

template<typename dtype >

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

Divides the scalar from the array (9)

Parameters

lhs
rhs

Returns

NdArray

operator/() [10/11]

template<typename dtype >

NdArray< dtype > nc::operator/	(	NdArray< dtype >	lhs,
		dtype	rhs
	)

Divides the scalar from the array (4)

Parameters

lhs
rhs

Returns

NdArray

operator/() [11/11]

template<typename dtype >

NdArray< std::complex< dtype > > nc::operator/	(	NdArray< std::complex< dtype > >	lhs,
		dtype	rhs
	)

Divides the scalar from the array (8)

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 scalar 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 scalar from the array (4)

Parameters

lhs
rhs

Returns

NdArray

operator<() [1/5]

bool nc::operator< ( const DateTime &  lhs, const DateTime &  rhs  )

inlinenoexcept

Less than operator.

Parameters

lhs	the left hand side value
rhs	the right hand side value

Returns

bool

operator<() [2/5]

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<() [3/5]

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 scalar

Parameters

lhs
inValue

Returns

NdArray

operator<() [4/5]

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<() [5/5]

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 scalar

Parameters

inValue
inArray

Returns

NdArray

operator<<() [1/7]

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/7]

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/7]

std::ostream & nc::operator<< ( std::ostream &  os, const DateTime &  datetime  )

inlinenoexcept

Stream operator.

Parameters

os	the output stream
datetime	the datetime object

Returns

ostream

operator<<() [4/7]

std::ostream & nc::operator<< ( std::ostream &  os, const TimePoint &  timepoint  )

inline

Output stream operator for the TimePoint type.

Parameters

os	the output stream
timepoint	the TimePoint

Returns

std::ostream

operator<<() [5/7]

std::ostream & nc::operator<< ( std::ostream &  os, Duration  duration  )

inline

Output stream operator for the Duration type.

Parameters

os	the output stream
duration	the Duration

Returns

std::ostream

operator<<() [6/7]

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

inline

stream output operator

Parameters

stream
vec

Returns

std::ostream

operator<<() [7/7]

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/5]

bool nc::operator<= ( const DateTime &  lhs, const DateTime &  rhs  )

inlinenoexcept

Less than or equal operator.

Parameters

lhs	the left hand side value
rhs	the right hand side value

Returns

bool

operator<=() [2/5]

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<=() [3/5]

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 scalar

Parameters

lhs
inValue

Returns

NdArray

operator<=() [4/5]

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<=() [5/5]

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 scalar

Parameters

inValue
inArray

Returns

NdArray

operator==() [1/4]

bool nc::operator== ( const DateTime &  lhs, const DateTime &  rhs  )

inlinenoexcept

Equality operator for DateTime.

Parameters

lhs	the left hand side value
rhs	the right hand side value

Returns

bool

operator==() [2/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==() [3/4]

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 scalar

Parameters

lhs
inValue

Returns

NdArray

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 an array and a scalar

Parameters

inValue
inArray

Returns

NdArray

operator>() [1/5]

bool nc::operator> ( const DateTime &  lhs, const DateTime &  rhs  )

inlinenoexcept

Greater than operator.

Parameters

lhs	the left hand side value
rhs	the right hand side value

Returns

bool

operator>() [2/5]

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>() [3/5]

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 scalar

Parameters

lhs
inValue

Returns

NdArray

operator>() [4/5]

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>() [5/5]

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 scalar

Parameters

inValue
inArray

Returns

NdArray

operator>=() [1/5]

bool nc::operator>= ( const DateTime &  lhs, const DateTime &  rhs  )

inlinenoexcept

Greater than or equal operator.

Parameters

lhs	the left hand side value
rhs	the right hand side value

Returns

bool

operator>=() [2/5]

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>=() [3/5]

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 scalar

Parameters

lhs
inValue

Returns

NdArray

operator>=() [4/5]

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>=() [5/5]

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 scalar

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^	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Takes the bitwise xor of the sclar and the array

Parameters

lhs
rhs

Returns

NdArray

operator^() [3/3]

template<typename dtype >

NdArray< dtype > nc::operator^	(	NdArray< dtype >	lhs,
		dtype	rhs
	)

Takes the bitwise xor of the array and the scalar

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 scalar 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|	(	dtype	lhs,
		const NdArray< dtype > &	rhs
	)

Takes the bitwise or of the sclar and the array

Parameters

lhs
rhs

Returns

NdArray

operator|() [3/3]

template<typename dtype >

NdArray< dtype > nc::operator|	(	NdArray< dtype >	lhs,
		dtype	rhs
	)

Takes the bitwise or of the array and the scalar

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 scalar 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 scalar

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 scalar

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

packbitsBigEndian()

template<typename dtype , std::enable_if_t< std::is_integral_v< dtype >||std::is_same_v< dtype, bool >, int > = 0>

NdArray< uint8 > nc::packbitsBigEndian	(	const NdArray< dtype > &	a,
		Axis	axis = Axis::NONE
	)

Packs the elements of a binary-valued array into bits in a uint8 array.

Numpy Reference: https://numpy.org/doc/stable/reference/generated/numpy.packbits.html

Parameters

a	An array of integers or booleans whose elements should be packed to bits.
axis	The dimension over which bit-packing is done. None implies packing the flattened array.

Returns

NdArray<uint8>

packbitsLittleEndian()

template<typename dtype , std::enable_if_t< std::is_integral_v< dtype >||std::is_same_v< dtype, bool >, int > = 0>

NdArray< uint8 > nc::packbitsLittleEndian	(	const NdArray< dtype > &	a,
		Axis	axis = Axis::NONE
	)

Packs the elements of a binary-valued array into bits in a uint8 array.

Numpy Reference: https://numpy.org/doc/stable/reference/generated/numpy.packbits.html

Parameters

a	An array of integers or booleans whose elements should be packed to bits.
axis	The dimension over which bit-packing is done. None implies packing the flattened array.

Returns

NdArray<uint8>

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,
		InterpolationMethod	inInterpMethod = InterpolationMethod::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.

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

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/22]

template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const Indices &	inIndices,
		const dtype &	inValue
	)

Set a.flat[n] = values for all n in indices.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inIndices
inValue

Returns

reference to self

put() [2/22]

template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const Indices &	inIndices,
		const NdArray< dtype > &	inValues
	)

Set a.flat[n] = values[n] for all n in indices.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inIndices
inValues

Returns

reference to self

put() [3/22]

template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const Indices &	inRowIndices,
		int32	inColIndex,
		const dtype &	inValue
	)

Set the slice indices to the input value.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowIndices
inColIndex
inValue

Returns

reference to self

put() [4/22]

template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const Indices &	inRowIndices,
		int32	inColIndex,
		const NdArray< dtype > &	inValues
	)

Set the slice indices to the input values.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowIndices
inColIndex
inValues

Returns

reference to self

put() [5/22]

template<typename dtype , typename RowIndices , typename ColIndices , type_traits::ndarray_int_concept< RowIndices > = 0, type_traits::ndarray_int_concept< ColIndices > = 0>

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const RowIndices &	inRowIndices,
		const ColIndices &	inColIndices,
		const dtype &	inValue
	)

Set the slice indices to the input value.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowIndices
inColIndices
inValue

Returns

reference to self

put() [6/22]

template<typename dtype , typename RowIndices , typename ColIndices , type_traits::ndarray_int_concept< RowIndices > = 0, type_traits::ndarray_int_concept< ColIndices > = 0>

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const RowIndices &	inRowIndices,
		const ColIndices &	inColIndices,
		const NdArray< dtype > &	inValues
	)

Set the slice indices to the input values.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowIndices
inColIndices
inValues

Returns

reference to self

put() [7/22]

template<typename dtype , typename RowIndices , type_traits::ndarray_int_concept< RowIndices > = 0>

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const RowIndices &	inRowIndices,
		const Slice &	inColSlice,
		const dtype &	inValue
	)

Set the slice indices to the input value.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowIndices
inColSlice
inValue

Returns

reference to self

put() [8/22]

template<typename dtype , typename RowIndices , type_traits::ndarray_int_concept< RowIndices > = 0>

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const RowIndices &	inRowIndices,
		const Slice &	inColSlice,
		const NdArray< dtype > &	inValues
	)

Set the slice indices to the input values.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowIndices
inColSlice
inValues

Returns

reference to self

put() [9/22]

template<typename dtype , typename ColIndices , type_traits::ndarray_int_concept< ColIndices > = 0>

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const Slice &	inRowSlice,
		const ColIndices &	inColIndices,
		const dtype &	inValue
	)

Set the slice indices to the input value.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowSlice
inColIndices
inValue

Returns

reference to self

put() [10/22]

template<typename dtype , typename ColIndices , type_traits::ndarray_int_concept< ColIndices > = 0>

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const Slice &	inRowSlice,
		const ColIndices &	inColIndices,
		const NdArray< dtype > &	inValues
	)

Set the slice indices to the input values.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowSlice
inColIndices
inValues

Returns

reference to self

put() [11/22]

template<typename dtype >

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const Slice &	inRowSlice,
		const Slice &	inColSlice,
		const dtype &	inValue
	)

Set the slice indices to the input value.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowSlice
inColSlice
inValue

Returns

reference to self

put() [12/22]

template<typename dtype >

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const Slice &	inRowSlice,
		const Slice &	inColSlice,
		const NdArray< dtype > &	inValues
	)

Set the slice indices to the input values.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowSlice
inColSlice
inValues

Returns

reference to self

put() [13/22]

template<typename dtype >

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const Slice &	inRowSlice,
		int32	inColIndex,
		const dtype &	inValue
	)

Set the slice indices to the input value.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowSlice
inColIndex
inValue

Returns

reference to self

put() [14/22]

template<typename dtype >

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const Slice &	inRowSlice,
		int32	inColIndex,
		const NdArray< dtype > &	inValues
	)

Set the slice indices to the input values.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowSlice
inColIndex
inValues

Returns

reference to self

put() [15/22]

template<typename dtype >

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const Slice &	inSlice,
		const dtype &	inValue
	)

Set the slice indices to the input value.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inSlice
inValue

Returns

reference to self

put() [16/22]

template<typename dtype >

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		const Slice &	inSlice,
		const NdArray< dtype > &	inValues
	)

Set the slice indices to the input values.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inSlice
inValues

Returns

reference to self

put() [17/22]

template<typename dtype >

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		int32	inIndex,
		const dtype &	inValue
	)

set the flat index element to the value

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inIndex
inValue

put() [18/22]

template<typename dtype >

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		int32	inRow,
		int32	inCol,
		const dtype &	inValue
	)

set the 2D row/col index element to the value

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRow
inCol
inValue

put() [19/22]

template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		int32	inRowIndex,
		const Indices &	inColIndices,
		const dtype &	inValue
	)

Set the slice indices to the input value.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowIndex
inColIndices
inValue

Returns

reference to self

put() [20/22]

template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		int32	inRowIndex,
		const Indices &	inColIndices,
		const NdArray< dtype > &	inValues
	)

Set the slice indices to the input values.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowIndex
inColIndices
inValues

Returns

reference to self

put() [21/22]

template<typename dtype >

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		int32	inRowIndex,
		const Slice &	inColSlice,
		const dtype &	inValue
	)

Set the slice indices to the input value.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowIndex
inColSlice
inValue

Returns

reference to self

put() [22/22]

template<typename dtype >

NdArray< dtype > & nc::put	(	NdArray< dtype > &	inArray,
		int32	inRowIndex,
		const Slice &	inColSlice,
		const NdArray< dtype > &	inValues
	)

Set the slice indices to the input values.

Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html

Parameters

inArray
inRowIndex
inColSlice
inValues

Returns

reference to self

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() [1/2]

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

row_stack() [2/2]

template<typename dtype >

NdArray< dtype > nc::row_stack

(

const std::vector< NdArray< dtype > > &

inArrayList

)

Stack arrays in sequence vertically (row wise).

Parameters

inArrayList

{list} of arrays to stack

Returns

NdArray

searchsorted() [1/2]

template<typename dtype >

NdArray< typename NdArray< dtype >::index_type > nc::searchsorted	(	const NdArray< dtype > &	inArray,
		const NdArray< dtype > &	inValues,
		Side	side = Side::LEFT
	)

Find indices where elements should be inserted to maintain order. Find the indices into a sorted array a such that, if the corresponding elements in v were inserted before the indices, the order of a would be preserved. Assuming that a is sorted : side returned index i satisfies left a[i - 1] < v <= a[i] right a[i - 1] <= v < a[i]

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

Parameters

inArray	the input array
inValues	values to insert into a
side	If ‘left’, the index of the first suitable location found is given. If ‘right’, return the last such index. If there is no suitable index, return either 0 or N (where N is the length of a).

Returns

Array of insertion points with the same shape as v, or an integer if v is a scalar.

searchsorted() [2/2]

template<typename dtype >

NdArray< dtype >::index_type nc::searchsorted	(	const NdArray< dtype > &	inArray,
		dtype	inValue,
		Side	side = Side::LEFT
	)

Find indices where elements should be inserted to maintain order. Find the indices into a sorted array a such that, if the corresponding elements in v were inserted before the indices, the order of a would be preserved. Assuming that a is sorted : side returned index i satisfies left a[i - 1] < v <= a[i] right a[i - 1] <= v < a[i]

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

Parameters

inArray	the input array
inValue	values to insert into a
side	If ‘left’, the index of the first suitable location found is given. If ‘right’, return the last such index. If there is no suitable index, return either 0 or N (where N is the length of a).

Returns

Array of insertion points with the same shape as v, or an integer if v is a scalar.

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.

split()

template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>

std::vector< NdArray< dtype > > nc::split	(	const NdArray< dtype > &	inArray,
		const Indices &	indices,
		Axis	inAxis = Axis::ROW
	)

Split an array into multiple sub-arrays as views into array.

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

Parameters

inArray
indices	the indices to split
inAxis	(Optional, default NONE)

Returns

NdArray

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() [1/2]

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.

stack() [2/2]

template<typename dtype >

NdArray< dtype > nc::stack	(	std::vector< 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

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 , type_traits::ndarray_int_concept< Indices > = 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

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.

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.,
		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.)
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.

unpackbitsBigEndian()

NdArray< uint8 > nc::unpackbitsBigEndian ( const NdArray< uint8 > &  a, Axis  axis = Axis::NONE  )

inline

Unpacks elements of a uint8 array into a binary-valued output array.

Each element of a represents a bit - field that should be unpacked into a binary - valued output array.The shape of the output array is either 1 - D(if axis is None) or the same shape as the input array with unpacking done along the axis specified.

Numpy Reference: https://numpy.org/doc/stable/reference/generated/numpy.unpackbits.html

Parameters

a	An array of uint8 whose elements should be unpacked to bits.
axis	The dimension over which bit-unpacking is done. None implies unpacking the flattened array.

Returns

NdArray<uint8>

unpackbitsLittleEndian()

NdArray< uint8 > nc::unpackbitsLittleEndian ( const NdArray< uint8 > &  a, Axis  axis = Axis::NONE  )

inline

Unpacks elements of a uint8 array into a binary-valued output array.

Each element of a represents a bit - field that should be unpacked into a binary - valued output array.The shape of the output array is either 1 - D(if axis is None) or the same shape as the input array with unpacking done along the axis specified.

Numpy Reference: https://numpy.org/doc/stable/reference/generated/numpy.unpackbits.html

Parameters

a	An array of uint8 whose elements should be unpacked to bits.
axis	The dimension over which bit-unpacking is done. None implies unpacking the flattened array.

Returns

NdArray<uint8>

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

vander() [1/2]

template<typename dtype >

auto nc::vander	(	const NdArray< dtype > &	x,
		Increasing	increasing = Increasing::YES
	)

Generate a Vandermonde matrix. The columns of the output matrix are powers of the input vector. The order of the powers is determined by the increasing boolean argument. Specifically, when increasing is False, the i-th output column is the input vector raised element-wise to the power of N - i - 1. Such a matrix with a geometric progression in each row is named for Alexandre- Theophile Vandermonde.

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

Parameters

x	1-D input array, otherwise the array will be flattened
increasing	Order of the powers of the columns. If True, the powers increase from left to right, if False (the default) they are reversed.

Returns

NdArray

vander() [2/2]

template<typename dtype >

auto nc::vander	(	const NdArray< dtype > &	x,
		uint32	n,
		Increasing	increasing = Increasing::YES
	)

Generate a Vandermonde matrix. The columns of the output matrix are powers of the input vector. The order of the powers is determined by the increasing boolean argument. Specifically, when increasing is False, the i-th output column is the input vector raised element-wise to the power of N - i - 1. Such a matrix with a geometric progression in each row is named for Alexandre- Theophile Vandermonde.

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

Parameters

x	1-D input array, otherwise the array will be flattened
n	Number of columns in the output. If N is not specified, a square array is returned (N = len(x)).
increasing	Order of the powers of the columns. If True, the powers increase from left to right, if False (the default) they are reversed.

Returns

NdArray

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

vsplit()

template<typename dtype , typename Indices , type_traits::ndarray_int_concept< Indices > = 0>

std::vector< NdArray< dtype > > nc::vsplit	(	const NdArray< dtype > &	inArray,
		const Indices &	indices
	)

Split an array into multiple sub-arrays vertically (row-wise).

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

Parameters

inArray
indices	the indices to split

Returns

NdArray

vstack() [1/2]

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.

vstack() [2/2]

template<typename dtype >

NdArray< dtype > nc::vstack

(

std::vector< 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

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

wrap() [1/2]

template<typename dtype >

NdArray< double > nc::wrap ( const NdArray< dtype > &  inAngles )

noexcept

Wrap the input angle to [-pi, pi].

Parameters

inAngles

in radians

Returns

Wrapped angles

wrap() [2/2]

template<typename dtype >

double nc::wrap ( dtype  inAngle )

noexcept

Wrap the input angle to [-pi, pi].

Parameters

inAngle

in radians

Returns

Wrapped angle

wrap2Pi() [1/2]

template<typename dtype >

NdArray< double > nc::wrap2Pi ( const NdArray< dtype > &  inAngles )

noexcept

Wrap the input angle to [0, 2*pi].

Parameters

inAngles

in radians

Returns

Wrapped angles

wrap2Pi() [2/2]

template<typename dtype >

double nc::wrap2Pi ( dtype  inAngle )

noexcept

Wrap the input angle to [0, 2*pi].

Parameters

inAngle

in radians

Returns

Wrapped angle

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

Variable Documentation

all_arithmetic_v

template<typename... Ts>

constexpr bool nc::all_arithmetic_v = all_arithmetic<Ts...>::value

constexpr

all_arithmetic helper

all_same_v

template<typename... Ts>

constexpr bool nc::all_same_v = all_same<Ts...>::value

constexpr

all_same helper

greaterThan_v

template<std::size_t Value1, std::size_t Value2>

constexpr bool nc::greaterThan_v = greaterThan<Value1, Value2>::value

constexpr

greaterThan helper

is_complex_v

template<class T >

constexpr bool nc::is_complex_v = is_complex<T>::value

constexpr

is_complex helper

is_ndarray_int_v

template<typename T >

constexpr bool nc::is_ndarray_int_v = is_ndarray_int<T>::value

constexpr

is_ndarray_int helper

is_valid_dtype_v

template<class dtype >

constexpr bool nc::is_valid_dtype_v = is_valid_dtype<dtype>::value

constexpr

is_valid_dtype helper

VERSION

constexpr char nc::VERSION[] = "2.12.1"

constexpr

Current NumCpp version number.