NumCpp  2.4.2
A Templatized Header Only C++ Implementation of the Python NumPy Library
nc Namespace Reference

Namespaces

 boostPythonInterface
 
 constants
 Holds usefull constants.
 
 coordinates
 
 endian
 
 error
 
 filesystem
 
 filter
 
 imageProcessing
 
 integrate
 
 linalg
 
 polynomial
 
 pybindInterface
 
 random
 
 roots
 
 rotations
 
 special
 
 stl_algorithms
 
 utils
 

Data Structures

struct  all_arithmetic
 
struct  all_arithmetic< Head, Tail... >
 
struct  all_arithmetic< T >
 
struct  all_same
 
struct  all_same< T1, Head, Tail... >
 
struct  all_same< T1, T2 >
 
class  DataCube
 Convenience container for holding a uniform array of NdArrays. More...
 
class  DtypeInfo
 Holds info about the dtype. More...
 
class  DtypeInfo< std::complex< dtype > >
 Holds info about the std::complex. More...
 
struct  is_complex
 
struct  is_complex< std::complex< T > >
 
struct  is_valid_dtype
 
class  NdArray
 Holds 1D and 2D arrays, the main work horse of the NumCpp library. More...
 
class  NdArrayColumnIterator
 Custom column iterator for NdArray. More...
 
class  NdArrayConstColumnIterator
 Custom column const_iterator for NdArray. More...
 
class  NdArrayConstIterator
 Custom const_iterator for NdArray. More...
 
class  NdArrayIterator
 Custom iterator for NdArray. More...
 
class  Shape
 A Shape Class for NdArrays. More...
 
class  Slice
 A Class for slicing into NdArrays. More...
 
class  Timer
 A timer class for timing code execution. More...
 
class  Vec2
 Holds a 2D vector. More...
 
class  Vec3
 Holds a 3D vector. More...
 

Typedefs

template<bool B, class T = void>
using enable_if_t = typename std::enable_if< B, T >::type
 
using int16 = std::int16_t
 
using int32 = std::int32_t
 
using int64 = std::int64_t
 
using int8 = std::int8_t
 
using uint16 = std::uint16_t
 
using uint32 = std::uint32_t
 
using uint64 = std::uint64_t
 
using uint8 = std::uint8_t
 

Enumerations

enum class  Axis { NONE = 0 , ROW , COL }
 Enum To describe an axis. More...
 
enum class  Endian { NATIVE = 0 , BIG , LITTLE }
 Enum for endianess. More...
 

Functions

template<typename dtype >
auto abs (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto abs (dtype inValue) noexcept
 
template<typename dtype >
NdArray< std::complex< dtype > > add (const NdArray< dtype > &inArray, const std::complex< dtype > &value)
 
template<typename dtype >
NdArray< dtype > add (const NdArray< dtype > &inArray, dtype value)
 
template<typename dtype >
NdArray< dtype > add (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > add (const NdArray< dtype > &inArray1, const NdArray< std::complex< dtype >> &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > add (const NdArray< std::complex< dtype >> &inArray, dtype value)
 
template<typename dtype >
NdArray< std::complex< dtype > > add (const NdArray< std::complex< dtype >> &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > add (const std::complex< dtype > &value, const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > add (dtype value, const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< std::complex< dtype > > add (dtype value, const NdArray< std::complex< dtype >> &inArray)
 
template<typename dtype >
uint32 alen (const NdArray< dtype > &inArray) noexcept
 
template<typename dtype >
NdArray< bool > all (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
bool allclose (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2, double inTolerance=1e-5)
 
template<typename dtype >
NdArray< dtype > amax (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > amin (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
auto angle (const NdArray< std::complex< dtype >> &inArray)
 
template<typename dtype >
auto angle (const std::complex< dtype > &inValue)
 
template<typename dtype >
NdArray< bool > any (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > append (const NdArray< dtype > &inArray, const NdArray< dtype > &inAppendValues, Axis inAxis=Axis::NONE)
 
template<typename dtype >
void applyFunction (NdArray< dtype > &inArray, const std::function< dtype(dtype)> &inFunc)
 
template<typename dtype >
void applyPoly1d (NdArray< dtype > &inArray, const polynomial::Poly1d< dtype > &inPoly)
 
template<typename dtype >
NdArray< dtype > arange (const Slice &inSlice)
 
template<typename dtype >
NdArray< dtype > arange (dtype inStart, dtype inStop, dtype inStep=1)
 
template<typename dtype >
NdArray< dtype > arange (dtype inStop)
 
template<typename dtype >
auto arccos (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto arccos (dtype inValue) noexcept
 
template<typename dtype >
auto arccosh (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto arccosh (dtype inValue) noexcept
 
template<typename dtype >
auto arcsin (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto arcsin (dtype inValue) noexcept
 
template<typename dtype >
auto arcsinh (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto arcsinh (dtype inValue) noexcept
 
template<typename dtype >
auto arctan (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto arctan (dtype inValue) noexcept
 
template<typename dtype >
auto arctan2 (const NdArray< dtype > &inY, const NdArray< dtype > &inX)
 
template<typename dtype >
auto arctan2 (dtype inY, dtype inX) noexcept
 
template<typename dtype >
auto arctanh (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto arctanh (dtype inValue) noexcept
 
template<typename dtype >
NdArray< uint32argmax (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< uint32argmin (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< uint32argsort (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< uint32argwhere (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 Bool , std::enable_if_t< std::is_same< Bool, bool >::value, int > = 0>
NdArray< dtype > asarray (dtype *ptr, uint32 numRows, uint32 numCols, Bool takeOwnership) noexcept
 
template<typename dtype , typename Bool , std::enable_if_t< std::is_same< Bool, bool >::value, int > = 0>
NdArray< dtype > asarray (dtype *ptr, uint32 size, Bool takeOwnership) noexcept
 
template<typename Iterator >
auto asarray (Iterator iterBegin, Iterator iterEnd)
 
template<typename dtype , size_t ArraySize, std::enable_if_t< is_valid_dtype_v< dtype >, int > = 0>
NdArray< dtype > asarray (std::array< dtype, ArraySize > &inArray, bool copy=true)
 
template<typename dtype , size_t Dim0Size, size_t Dim1Size>
NdArray< dtype > asarray (std::array< std::array< dtype, Dim1Size >, Dim0Size > &inArray, bool copy=true)
 
template<typename dtype , std::enable_if_t< is_valid_dtype_v< dtype >, int > = 0>
NdArray< dtype > asarray (std::initializer_list< dtype > inList)
 
template<typename dtype >
NdArray< dtype > asarray (std::initializer_list< std::initializer_list< dtype > > inList)
 
template<typename dtype , std::enable_if_t< is_valid_dtype_v< dtype >, int > = 0>
NdArray< dtype > asarray (std::vector< dtype > &inVector, bool copy=true)
 
template<typename dtype , size_t Dim1Size>
NdArray< dtype > asarray (std::vector< std::array< dtype, Dim1Size >> &inVector, bool copy=true)
 
template<typename dtypeOut = double, typename dtype >
NdArray< dtypeOut > astype (const NdArray< dtype > inArray)
 
template<typename dtype >
auto average (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< double > average (const NdArray< dtype > &inArray, const NdArray< dtype > &inWeights, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< std::complex< double > > average (const NdArray< std::complex< dtype >> &inArray, const NdArray< dtype > &inWeights, Axis inAxis=Axis::NONE)
 
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< 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)
 
template<typename dtype >
NdArray< dtype > byteswap (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< double > cbrt (const NdArray< dtype > &inArray)
 
template<typename dtype >
double cbrt (dtype inValue) noexcept
 
template<typename dtype >
NdArray< dtype > ceil (const NdArray< dtype > &inArray)
 
template<typename dtype >
dtype ceil (dtype inValue) noexcept
 
template<typename dtype >
NdArray< double > centerOfMass (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > clip (const NdArray< dtype > &inArray, dtype inMinValue, dtype inMaxValue)
 
template<typename dtype >
dtype clip (dtype inValue, dtype inMinValue, dtype inMaxValue)
 
template<typename dtype >
NdArray< dtype > column_stack (const std::initializer_list< NdArray< dtype > > &inArrayList)
 
template<typename dtype >
auto complex (const NdArray< dtype > &inReal)
 
template<typename dtype >
auto complex (const NdArray< dtype > &inReal, const NdArray< dtype > &inImag)
 
template<typename dtype >
auto complex (dtype inReal)
 
template<typename dtype >
auto complex (dtype inReal, dtype inImag)
 
template<typename Out , typename In >
std::complex< Out > complex_cast (const std::complex< In > &value) noexcept
 
template<typename dtype >
NdArray< dtype > concatenate (const std::initializer_list< NdArray< dtype > > &inArrayList, Axis inAxis=Axis::NONE)
 
template<typename dtype >
auto conj (const NdArray< std::complex< dtype >> &inArray)
 
template<typename dtype >
auto conj (const std::complex< dtype > &inValue)
 
template<typename dtype >
NdArray< bool > contains (const NdArray< dtype > &inArray, dtype inValue, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > copy (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > copySign (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< dtype > & copyto (NdArray< dtype > &inDestArray, const NdArray< dtype > &inSrcArray)
 
template<typename dtype >
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< uint32count_nonzero (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > cross (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > cube (const NdArray< dtype > &inArray)
 
template<typename dtype >
constexpr dtype cube (dtype inValue) noexcept
 
template<typename dtype >
NdArray< dtype > cumprod (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > cumsum (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
auto deg2rad (const NdArray< dtype > &inArray)
 
template<typename dtype >
constexpr auto deg2rad (dtype inValue) noexcept
 
template<typename dtype >
auto degrees (const NdArray< dtype > &inArray)
 
template<typename dtype >
constexpr auto degrees (dtype inValue) noexcept
 
template<typename dtype >
NdArray< dtype > deleteIndices (const NdArray< dtype > &inArray, const NdArray< uint32 > &inArrayIdxs, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > deleteIndices (const NdArray< dtype > &inArray, const Slice &inIndicesSlice, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > deleteIndices (const NdArray< dtype > &inArray, uint32 inIndex, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > diag (const NdArray< dtype > &inArray, int32 k=0)
 
template<typename dtype >
NdArray< dtype > diagflat (const NdArray< dtype > &inArray, int32 k=0)
 
template<typename dtype >
NdArray< dtype > diagonal (const NdArray< dtype > &inArray, int32 inOffset=0, Axis inAxis=Axis::ROW)
 
template<typename dtype >
NdArray< dtype > diff (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< std::complex< dtype > > divide (const NdArray< dtype > &inArray, const std::complex< dtype > &value)
 
template<typename dtype >
NdArray< dtype > divide (const NdArray< dtype > &inArray, dtype value)
 
template<typename dtype >
NdArray< dtype > divide (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > divide (const NdArray< dtype > &inArray1, const NdArray< std::complex< dtype >> &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > divide (const NdArray< std::complex< dtype >> &inArray, dtype value)
 
template<typename dtype >
NdArray< std::complex< dtype > > divide (const NdArray< std::complex< dtype >> &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > divide (const std::complex< dtype > &value, const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > divide (dtype value, const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< std::complex< dtype > > divide (dtype value, const NdArray< std::complex< dtype >> &inArray)
 
template<typename dtype >
NdArray< dtype > dot (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > dot (const NdArray< dtype > &inArray1, const NdArray< std::complex< dtype >> &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > dot (const NdArray< std::complex< dtype >> &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
void dump (const NdArray< dtype > &inArray, const std::string &inFilename)
 
template<typename dtype >
NdArray< dtype > empty (const Shape &inShape)
 
template<typename dtype >
NdArray< dtype > empty (uint32 inNumRows, uint32 inNumCols)
 
template<typename dtype >
NdArray< dtype > empty_like (const NdArray< dtype > &inArray)
 
template<typename dtype >
Endian endianess (const NdArray< dtype > &inArray) noexcept
 
template<typename dtype >
NdArray< bool > equal (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
auto exp (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto exp (dtype inValue) noexcept
 
template<typename dtype >
auto exp2 (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto exp2 (dtype inValue) noexcept
 
template<typename dtype >
auto expm1 (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto expm1 (dtype inValue) noexcept
 
template<typename dtype >
NdArray< dtype > 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< uint32find (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< uint32flatnonzero (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > flatten (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > flip (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > fliplr (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > flipud (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > floor (const NdArray< dtype > &inArray)
 
template<typename dtype >
dtype floor (dtype inValue) noexcept
 
template<typename dtype >
NdArray< dtype > floor_divide (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
dtype floor_divide (dtype inValue1, dtype inValue2) noexcept
 
template<typename dtype >
NdArray< dtype > fmax (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
dtype fmax (dtype inValue1, dtype inValue2) noexcept
 
template<typename dtype >
NdArray< dtype > fmin (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
dtype fmin (dtype inValue1, dtype inValue2) noexcept
 
template<typename dtype >
NdArray< dtype > fmod (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
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, const std::string &inSep="")
 
template<typename dtype , typename Iter >
NdArray< dtype > fromiter (Iter inBegin, Iter inEnd)
 
template<typename dtype >
NdArray< dtype > full (const Shape &inShape, dtype inFillValue)
 
template<typename dtype >
NdArray< dtype > full (uint32 inNumRows, uint32 inNumCols, dtype inFillValue)
 
template<typename dtype >
NdArray< dtype > full (uint32 inSquareSize, dtype inFillValue)
 
template<typename dtype >
NdArray< dtype > full_like (const NdArray< dtype > &inArray, dtype inFillValue)
 
template<typename dtype >
dtype gcd (const NdArray< dtype > &inArray)
 
template<typename dtype >
dtype gcd (dtype inValue1, dtype inValue2) noexcept
 
template<typename dtype >
NdArray< double > 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)
 
template<typename dtype >
NdArray< uint32histogram (const NdArray< dtype > &inArray, const NdArray< double > &inBinEdges)
 
template<typename dtype >
std::pair< NdArray< uint32 >, NdArray< double > > histogram (const NdArray< dtype > &inArray, uint32 inNumBins=10)
 
template<typename dtype >
NdArray< dtype > hstack (const std::initializer_list< NdArray< dtype > > &inArrayList)
 
template<typename dtype >
NdArray< double > hypot (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
double hypot (dtype inValue1, dtype inValue2) noexcept
 
template<typename dtype >
double hypot (dtype inValue1, dtype inValue2, dtype inValue3) noexcept
 
template<typename dtype >
NdArray< dtype > identity (uint32 inSquareSize)
 
template<typename dtype >
auto imag (const NdArray< std::complex< dtype >> &inArray)
 
template<typename dtype >
auto imag (const std::complex< dtype > &inValue)
 
template<typename dtype >
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 >
dtype lcm (const NdArray< dtype > &inArray)
 
template<typename dtype >
dtype lcm (dtype inValue1, dtype inValue2) noexcept
 
template<typename dtype >
NdArray< dtype > ldexp (const NdArray< dtype > &inArray1, const NdArray< uint8 > &inArray2)
 
template<typename dtype >
dtype ldexp (dtype inValue1, uint8 inValue2) noexcept
 
template<typename dtype >
NdArray< dtype > left_shift (const NdArray< dtype > &inArray, uint8 inNumBits)
 
template<typename dtype >
NdArray< bool > less (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< bool > less_equal (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< dtype > linspace (dtype inStart, dtype inStop, uint32 inNum=50, bool endPoint=true)
 
template<typename dtype >
NdArray< dtype > load (const std::string &inFilename)
 
template<typename dtype >
auto log (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto log (dtype inValue) noexcept
 
template<typename dtype >
auto log10 (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto log10 (dtype inValue) noexcept
 
template<typename dtype >
auto log1p (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto log1p (dtype inValue) noexcept
 
template<typename dtype >
auto log2 (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto log2 (dtype inValue) noexcept
 
template<typename dtype >
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< dtype > matmul (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > matmul (const NdArray< dtype > &inArray1, const NdArray< std::complex< dtype >> &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > matmul (const NdArray< std::complex< dtype >> &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< dtype > max (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > maximum (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< double > mean (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< std::complex< double > > mean (const NdArray< std::complex< dtype >> &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > median (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
std::pair< NdArray< dtype >, NdArray< dtype > > meshgrid (const NdArray< dtype > &inICoords, const NdArray< dtype > &inJCoords)
 
template<typename dtype >
std::pair< NdArray< dtype >, NdArray< dtype > > meshgrid (const Slice &inSlice1, const Slice &inSlice2)
 
template<typename dtype >
NdArray< dtype > min (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > minimum (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< dtype > mod (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > multiply (const NdArray< dtype > &inArray, const std::complex< dtype > &value)
 
template<typename dtype >
NdArray< dtype > multiply (const NdArray< dtype > &inArray, dtype value)
 
template<typename dtype >
NdArray< dtype > multiply (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > multiply (const NdArray< dtype > &inArray1, const NdArray< std::complex< dtype >> &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > multiply (const NdArray< std::complex< dtype >> &inArray, dtype value)
 
template<typename dtype >
NdArray< std::complex< dtype > > multiply (const NdArray< std::complex< dtype >> &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > multiply (const std::complex< dtype > &value, const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > multiply (dtype value, const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< std::complex< dtype > > multiply (dtype value, const NdArray< std::complex< dtype >> &inArray)
 
template<typename dtype >
NdArray< dtype > nan_to_num (NdArray< dtype > inArray, dtype nan=static_cast< dtype >(0.0), dtype posInf=DtypeInfo< dtype >::max(), dtype negInf=DtypeInfo< dtype >::min())
 
template<typename dtype >
NdArray< uint32nanargmax (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< uint32nanargmin (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > nancumprod (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > nancumsum (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > nanmax (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< double > nanmean (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > nanmedian (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > nanmin (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< double > nanpercentile (const NdArray< dtype > &inArray, double inPercentile, Axis inAxis=Axis::NONE, const std::string &inInterpMethod="linear")
 
template<typename dtype >
NdArray< dtype > nanprod (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
NdArray< double > nans (const Shape &inShape)
 
NdArray< double > nans (uint32 inNumRows, uint32 inNumCols)
 
NdArray< double > nans (uint32 inSquareSize)
 
template<typename dtype >
NdArray< double > nans_like (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< double > nanstdev (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > nansum (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< double > nanvar (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
uint64 nbytes (const NdArray< dtype > &inArray) noexcept
 
template<typename dtype >
NdArray< dtype > negative (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > newbyteorder (const NdArray< dtype > &inArray, Endian inEndianess)
 
template<typename dtype >
dtype newbyteorder (dtype inValue, Endian inEndianess)
 
template<typename dtype >
NdArray< bool > none (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
std::pair< NdArray< uint32 >, NdArray< uint32 > > nonzero (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< double > norm (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< std::complex< double > > norm (const NdArray< std::complex< dtype >> &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< bool > not_equal (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< dtype > ones (const Shape &inShape)
 
template<typename dtype >
NdArray< dtype > ones (uint32 inNumRows, uint32 inNumCols)
 
template<typename dtype >
NdArray< dtype > ones (uint32 inSquareSize)
 
template<typename dtypeOut , typename dtype >
NdArray< dtypeOut > ones_like (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< bool > operator! (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< bool > operator!= (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< bool > operator!= (const NdArray< dtype > &lhs, dtype inValue)
 
template<typename dtype >
NdArray< bool > operator!= (dtype inValue, const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > operator% (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > operator% (const NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< dtype > operator% (dtype lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > & operator%= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > & operator%= (NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< dtype > operator& (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > operator& (const NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< dtype > operator& (dtype lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< bool > operator&& (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< bool > operator&& (const NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< bool > operator&& (dtype lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > & operator&= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > & operator&= (NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< dtype > operator* (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator* (const NdArray< dtype > &lhs, const NdArray< std::complex< dtype >> &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator* (const NdArray< dtype > &lhs, const std::complex< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > operator* (const NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator* (const NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator* (const NdArray< std::complex< dtype >> &lhs, dtype rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator* (const std::complex< dtype > &lhs, const NdArray< dtype > &rhs)
 
double operator* (const Vec2 &lhs, const Vec2 &rhs) noexcept
 
Vec2 operator* (const Vec2 &lhs, double rhs) noexcept
 
double operator* (const Vec3 &lhs, const Vec3 &rhs) noexcept
 
Vec3 operator* (const Vec3 &lhs, double rhs) noexcept
 
Vec2 operator* (double lhs, const Vec2 &rhs) noexcept
 
Vec3 operator* (double lhs, const Vec3 &rhs) noexcept
 
template<typename dtype >
NdArray< dtype > operator* (dtype lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator* (dtype lhs, const NdArray< std::complex< dtype >> &rhs)
 
template<typename dtype >
NdArray< dtype > & operator*= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > & operator*= (NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > & operator*= (NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > & operator*= (NdArray< std::complex< dtype >> &lhs, dtype rhs)
 
template<typename dtype >
NdArray< dtype > operator+ (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator+ (const NdArray< dtype > &lhs, const NdArray< std::complex< dtype >> &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator+ (const NdArray< dtype > &lhs, const std::complex< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > operator+ (const NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator+ (const NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator+ (const NdArray< std::complex< dtype >> &lhs, dtype rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator+ (const std::complex< dtype > &lhs, const NdArray< dtype > &rhs)
 
Vec2 operator+ (const Vec2 &lhs, const Vec2 &rhs) noexcept
 
Vec2 operator+ (const Vec2 &lhs, double rhs) noexcept
 
Vec3 operator+ (const Vec3 &lhs, const Vec3 &rhs) noexcept
 
Vec3 operator+ (const Vec3 &lhs, double rhs) noexcept
 
Vec2 operator+ (double lhs, const Vec2 &rhs) noexcept
 
Vec3 operator+ (double lhs, const Vec3 &rhs) noexcept
 
template<typename dtype >
NdArray< dtype > operator+ (dtype lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator+ (dtype lhs, const NdArray< std::complex< dtype >> &rhs)
 
template<class dtype , typename SizeType , typename PointerType , typename DifferenceType >
NdArrayColumnIterator< dtype, SizeType, PointerType, DifferenceType > operator+ (typename NdArrayColumnIterator< dtype, SizeType, PointerType, DifferenceType >::difference_type offset, NdArrayColumnIterator< dtype, SizeType, PointerType, DifferenceType > next) noexcept
 
template<class dtype , typename SizeType , typename PointerType , typename DifferenceType >
NdArrayConstColumnIterator< dtype, SizeType, PointerType, DifferenceType > operator+ (typename NdArrayConstColumnIterator< dtype, SizeType, PointerType, DifferenceType >::difference_type offset, NdArrayConstColumnIterator< dtype, SizeType, PointerType, DifferenceType > next) noexcept
 
template<class dtype , typename PointerType , typename DifferenceType >
NdArrayConstIterator< dtype, PointerType, DifferenceType > operator+ (typename NdArrayConstIterator< dtype, PointerType, DifferenceType >::difference_type offset, NdArrayConstIterator< dtype, PointerType, DifferenceType > next) noexcept
 
template<class dtype , typename PointerType , typename DifferenceType >
NdArrayIterator< dtype, PointerType, DifferenceType > operator+ (typename NdArrayIterator< dtype, PointerType, DifferenceType >::difference_type offset, NdArrayIterator< dtype, PointerType, DifferenceType > next) noexcept
 
template<typename dtype >
NdArray< dtype > operator++ (NdArray< dtype > &lhs, int)
 
template<typename dtype >
NdArray< dtype > & operator++ (NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > & operator+= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > & operator+= (NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > & operator+= (NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > & operator+= (NdArray< std::complex< dtype >> &lhs, dtype rhs)
 
template<typename dtype >
NdArray< dtype > operator- (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > operator- (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator- (const NdArray< dtype > &lhs, const NdArray< std::complex< dtype >> &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator- (const NdArray< dtype > &lhs, const std::complex< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > operator- (const NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator- (const NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator- (const NdArray< std::complex< dtype >> &lhs, dtype rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator- (const std::complex< dtype > &lhs, const NdArray< dtype > &rhs)
 
Vec2 operator- (const Vec2 &lhs, const Vec2 &rhs) noexcept
 
Vec2 operator- (const Vec2 &lhs, double rhs) noexcept
 
Vec2 operator- (const Vec2 &vec) noexcept
 
Vec3 operator- (const Vec3 &lhs, const Vec3 &rhs) noexcept
 
Vec3 operator- (const Vec3 &lhs, double rhs) noexcept
 
Vec3 operator- (const Vec3 &vec) noexcept
 
Vec2 operator- (double lhs, const Vec2 &rhs) noexcept
 
Vec3 operator- (double lhs, const Vec3 &rhs) noexcept
 
template<typename dtype >
NdArray< dtype > operator- (dtype lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator- (dtype lhs, const NdArray< std::complex< dtype >> &rhs)
 
template<typename dtype >
NdArray< dtype > operator-- (NdArray< dtype > &lhs, int)
 
template<typename dtype >
NdArray< dtype > & operator-- (NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > & operator-= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > & operator-= (NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > & operator-= (NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > & operator-= (NdArray< std::complex< dtype >> &lhs, dtype rhs)
 
template<typename dtype >
NdArray< dtype > operator/ (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator/ (const NdArray< dtype > &lhs, const NdArray< std::complex< dtype >> &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator/ (const NdArray< dtype > &lhs, const std::complex< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > operator/ (const NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator/ (const NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator/ (const NdArray< std::complex< dtype >> &lhs, dtype rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator/ (const std::complex< dtype > &lhs, const NdArray< dtype > &rhs)
 
Vec2 operator/ (const Vec2 &lhs, double rhs) noexcept
 
Vec3 operator/ (const Vec3 &lhs, double rhs) noexcept
 
template<typename dtype >
NdArray< dtype > operator/ (dtype lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > operator/ (dtype lhs, const NdArray< std::complex< dtype >> &rhs)
 
template<typename dtype >
NdArray< dtype > & operator/= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > & operator/= (NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > & operator/= (NdArray< std::complex< dtype >> &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< std::complex< dtype > > & operator/= (NdArray< std::complex< dtype >> &lhs, dtype rhs)
 
template<typename dtype >
NdArray< bool > operator< (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< bool > operator< (const NdArray< dtype > &lhs, dtype inValue)
 
template<typename T >
bool operator< (const std::complex< T > &lhs, const std::complex< T > &rhs) noexcept
 
template<typename dtype >
NdArray< bool > operator< (dtype inValue, const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > operator<< (const NdArray< dtype > &lhs, uint8 inNumBits)
 
template<typename dtype >
std::ostream & operator<< (std::ostream &inOStream, const NdArray< dtype > &inArray)
 
std::ostream & operator<< (std::ostream &stream, const Vec2 &vec)
 
std::ostream & operator<< (std::ostream &stream, const Vec3 &vec)
 
template<typename dtype >
NdArray< dtype > & operator<<= (NdArray< dtype > &lhs, uint8 inNumBits)
 
template<typename dtype >
NdArray< bool > operator<= (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< bool > operator<= (const NdArray< dtype > &lhs, dtype inValue)
 
template<typename T >
bool operator<= (const std::complex< T > &lhs, const std::complex< T > &rhs) noexcept
 
template<typename dtype >
NdArray< bool > operator<= (dtype inValue, const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< bool > operator== (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< bool > operator== (const NdArray< dtype > &lhs, dtype inValue)
 
template<typename dtype >
NdArray< bool > operator== (dtype inValue, const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< bool > operator> (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< bool > operator> (const NdArray< dtype > &lhs, dtype inValue)
 
template<typename T >
bool operator> (const std::complex< T > &lhs, const std::complex< T > &rhs) noexcept
 
template<typename dtype >
NdArray< bool > operator> (dtype inValue, const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< bool > operator>= (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< bool > operator>= (const NdArray< dtype > &lhs, dtype inValue)
 
template<typename T >
bool operator>= (const std::complex< T > &lhs, const std::complex< T > &rhs) noexcept
 
template<typename dtype >
NdArray< bool > operator>= (dtype inValue, const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > operator>> (const NdArray< dtype > &lhs, uint8 inNumBits)
 
template<typename dtype >
NdArray< dtype > & operator>>= (NdArray< dtype > &lhs, uint8 inNumBits)
 
template<typename dtype >
NdArray< dtype > operator^ (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > operator^ (const NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< dtype > operator^ (dtype lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > & operator^= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > & operator^= (NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< dtype > operator| (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > operator| (const NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< dtype > operator| (dtype lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > & operator|= (NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > & operator|= (NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< bool > operator|| (const NdArray< dtype > &lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< bool > operator|| (const NdArray< dtype > &lhs, dtype rhs)
 
template<typename dtype >
NdArray< bool > operator|| (dtype lhs, const NdArray< dtype > &rhs)
 
template<typename dtype >
NdArray< dtype > operator~ (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > outer (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< dtype > pad (const NdArray< dtype > &inArray, uint16 inPadWidth, dtype inPadValue)
 
template<typename dtype >
NdArray< dtype > partition (const NdArray< dtype > &inArray, uint32 inKth, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< double > percentile (const NdArray< dtype > &inArray, double inPercentile, Axis inAxis=Axis::NONE, const std::string &inInterpMethod="linear")
 
template<typename dtype >
auto polar (const NdArray< dtype > &magnitude, const NdArray< dtype > &phaseAngle)
 
template<typename dtype >
auto polar (dtype magnitude, dtype phaseAngle)
 
template<typename dtype >
NdArray< dtype > power (const NdArray< dtype > &inArray, const NdArray< uint8 > &inExponents)
 
template<typename dtype >
NdArray< dtype > power (const NdArray< dtype > &inArray, uint8 inExponent)
 
template<typename dtype >
constexpr dtype power (dtype inValue, uint8 inExponent) noexcept
 
template<typename dtype1 , typename dtype2 >
auto powerf (const NdArray< dtype1 > &inArray, const NdArray< dtype2 > &inExponents)
 
template<typename dtype1 , typename dtype2 >
auto powerf (const NdArray< dtype1 > &inArray, dtype2 inExponent)
 
template<typename dtype1 , typename dtype2 >
auto powerf (dtype1 inValue, dtype2 inExponent) noexcept
 
template<typename dtype >
void print (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > prod (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
auto proj (const NdArray< std::complex< dtype >> &inArray)
 
template<typename dtype >
auto proj (const std::complex< dtype > &inValue)
 
template<typename dtype >
NdArray< dtype > ptp (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > & put (NdArray< dtype > &inArray, const NdArray< uint32 > &inIndices, const NdArray< dtype > &inValues)
 
template<typename dtype >
NdArray< dtype > & put (NdArray< dtype > &inArray, const NdArray< uint32 > &inIndices, dtype inValue)
 
template<typename dtype >
NdArray< dtype > & putmask (NdArray< dtype > &inArray, const NdArray< bool > &inMask, const NdArray< dtype > &inValues)
 
template<typename dtype >
NdArray< dtype > & putmask (NdArray< dtype > &inArray, const NdArray< bool > &inMask, dtype inValue)
 
template<typename dtype >
auto rad2deg (const NdArray< dtype > &inArray)
 
template<typename dtype >
constexpr auto rad2deg (dtype inValue) noexcept
 
template<typename dtype >
auto radians (const NdArray< dtype > &inArray)
 
template<typename dtype >
constexpr auto radians (dtype inValue) noexcept
 
template<typename dtype >
NdArray< dtype > & ravel (NdArray< dtype > &inArray) noexcept
 
template<typename dtype >
auto real (const NdArray< std::complex< dtype >> &inArray)
 
template<typename dtype >
auto real (const std::complex< dtype > &inValue)
 
template<typename dtype >
NdArray< double > reciprocal (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< std::complex< double > > reciprocal (const NdArray< std::complex< dtype >> &inArray)
 
template<typename dtype >
NdArray< double > remainder (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
double remainder (dtype inValue1, dtype inValue2) noexcept
 
template<typename dtype >
NdArray< dtype > repeat (const NdArray< dtype > &inArray, const Shape &inRepeatShape)
 
template<typename dtype >
NdArray< dtype > repeat (const NdArray< dtype > &inArray, uint32 inNumRows, uint32 inNumCols)
 
template<typename dtype >
NdArray< dtype > replace (const NdArray< dtype > &inArray, dtype oldValue, dtype newValue)
 
template<typename dtype >
NdArray< dtype > & reshape (NdArray< dtype > &inArray, const Shape &inNewShape)
 
template<typename dtype >
NdArray< dtype > & reshape (NdArray< dtype > &inArray, int32 inNumRows, int32 inNumCols)
 
template<typename dtype >
NdArray< dtype > & reshape (NdArray< dtype > &inArray, uint32 inSize)
 
template<typename dtype >
NdArray< dtype > & resizeFast (NdArray< dtype > &inArray, const Shape &inNewShape)
 
template<typename dtype >
NdArray< dtype > & resizeFast (NdArray< dtype > &inArray, uint32 inNumRows, uint32 inNumCols)
 
template<typename dtype >
NdArray< dtype > & resizeSlow (NdArray< dtype > &inArray, const Shape &inNewShape)
 
template<typename dtype >
NdArray< dtype > & resizeSlow (NdArray< dtype > &inArray, uint32 inNumRows, uint32 inNumCols)
 
template<typename dtype >
NdArray< dtype > right_shift (const NdArray< dtype > &inArray, uint8 inNumBits)
 
template<typename dtype >
NdArray< dtype > rint (const NdArray< dtype > &inArray)
 
template<typename dtype >
dtype rint (dtype inValue) noexcept
 
template<typename dtype >
NdArray< double > rms (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< std::complex< double > > rms (const NdArray< std::complex< dtype >> &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > roll (const NdArray< dtype > &inArray, int32 inShift, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > rot90 (const NdArray< dtype > &inArray, uint8 inK=1)
 
template<typename dtype >
NdArray< dtype > round (const NdArray< dtype > &inArray, uint8 inDecimals=0)
 
template<typename dtype >
dtype round (dtype inValue, uint8 inDecimals=0)
 
template<typename dtype >
NdArray< dtype > row_stack (const std::initializer_list< NdArray< dtype > > &inArrayList)
 
template<typename dtype >
NdArray< dtype > setdiff1d (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
Shape shape (const NdArray< dtype > &inArray) noexcept
 
template<typename dtype >
NdArray< int8sign (const NdArray< dtype > &inArray)
 
template<typename dtype >
int8 sign (dtype inValue) noexcept
 
template<typename dtype >
NdArray< bool > signbit (const NdArray< dtype > &inArray)
 
template<typename dtype >
bool signbit (dtype inValue) noexcept
 
template<typename dtype >
auto sin (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto sin (dtype inValue) noexcept
 
template<typename dtype >
auto sinc (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto sinc (dtype inValue) noexcept
 
template<typename dtype >
auto sinh (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto sinh (dtype inValue) noexcept
 
template<typename dtype >
uint32 size (const NdArray< dtype > &inArray) noexcept
 
template<typename dtype >
NdArray< dtype > sort (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
auto sqrt (const NdArray< dtype > &inArray)
 
template<typename dtype >
auto sqrt (dtype inValue) noexcept
 
template<typename dtype >
NdArray< dtype > square (const NdArray< dtype > &inArray)
 
template<typename dtype >
constexpr dtype square (dtype inValue) noexcept
 
template<typename dtype >
NdArray< dtype > stack (const std::initializer_list< NdArray< dtype > > &inArrayList, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< double > stdev (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< std::complex< double > > stdev (const NdArray< std::complex< dtype >> &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< std::complex< dtype > > subtract (const NdArray< dtype > &inArray, const std::complex< dtype > &value)
 
template<typename dtype >
NdArray< dtype > subtract (const NdArray< dtype > &inArray, dtype value)
 
template<typename dtype >
NdArray< dtype > subtract (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > subtract (const NdArray< dtype > &inArray1, const NdArray< std::complex< dtype >> &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > subtract (const NdArray< std::complex< dtype >> &inArray, dtype value)
 
template<typename dtype >
NdArray< std::complex< dtype > > subtract (const NdArray< std::complex< dtype >> &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< std::complex< dtype > > subtract (const std::complex< dtype > &value, const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > subtract (dtype value, const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< std::complex< dtype > > subtract (dtype value, const NdArray< std::complex< dtype >> &inArray)
 
template<typename dtype >
NdArray< dtype > sum (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
void swap (NdArray< dtype > &inArray1, NdArray< dtype > &inArray2) noexcept
 
template<typename dtype >
NdArray< dtype > swapaxes (const NdArray< dtype > &inArray)
 
template<typename dtype >
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, const std::string &inSep="")
 
template<typename dtype >
std::vector< dtype > toStlVector (const NdArray< dtype > &inArray)
 
template<typename dtype >
dtype trace (const NdArray< dtype > &inArray, int16 inOffset=0, Axis inAxis=Axis::ROW) noexcept
 
template<typename dtype >
NdArray< dtype > transpose (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< double > trapz (const NdArray< dtype > &inArray, double dx=1.0, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< double > trapz (const NdArray< dtype > &inArrayY, const NdArray< dtype > &inArrayX, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > tril (const NdArray< dtype > &inArray, int32 inOffset=0)
 
template<typename dtype >
NdArray< dtype > tril (uint32 inN, int32 inOffset=0)
 
template<typename dtype >
NdArray< dtype > tril (uint32 inN, uint32 inM, int32 inOffset=0)
 
template<typename dtype >
NdArray< dtype > trim_zeros (const NdArray< dtype > &inArray, const std::string &inTrim="fb")
 
template<typename dtype >
NdArray< dtype > triu (const NdArray< dtype > &inArray, int32 inOffset=0)
 
template<typename dtype >
NdArray< dtype > triu (uint32 inN, int32 inOffset=0)
 
template<typename dtype >
NdArray< dtype > triu (uint32 inN, uint32 inM, int32 inOffset=0)
 
template<typename dtype >
NdArray< dtype > trunc (const NdArray< dtype > &inArray)
 
template<typename dtype >
dtype trunc (dtype inValue) noexcept
 
template<typename dtype >
NdArray< dtype > union1d (const NdArray< dtype > &inArray1, const NdArray< dtype > &inArray2)
 
template<typename dtype >
NdArray< dtype > unique (const NdArray< dtype > &inArray)
 
template<typename dtype >
NdArray< dtype > unwrap (const NdArray< dtype > &inArray)
 
template<typename dtype >
dtype unwrap (dtype inValue) noexcept
 
template<typename dtype >
NdArray< double > var (const NdArray< dtype > &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< std::complex< double > > var (const NdArray< std::complex< dtype >> &inArray, Axis inAxis=Axis::NONE)
 
template<typename dtype >
NdArray< dtype > vstack (const std::initializer_list< NdArray< dtype > > &inArrayList)
 
template<typename dtype >
NdArray< dtype > where (const NdArray< bool > &inMask, const NdArray< dtype > &inA, const NdArray< dtype > &inB)
 
template<typename dtype >
NdArray< dtype > where (const NdArray< bool > &inMask, const NdArray< dtype > &inA, dtype inB)
 
template<typename dtype >
NdArray< dtype > where (const NdArray< bool > &inMask, dtype inA, const NdArray< dtype > &inB)
 
template<typename dtype >
NdArray< dtype > where (const NdArray< bool > &inMask, dtype inA, dtype inB)
 
template<typename dtype >
NdArray< dtype > zeros (const Shape &inShape)
 
template<typename dtype >
NdArray< dtype > zeros (uint32 inNumRows, uint32 inNumCols)
 
template<typename dtype >
NdArray< dtype > zeros (uint32 inSquareSize)
 
template<typename dtypeOut , typename dtype >
NdArray< dtypeOut > zeros_like (const NdArray< dtype > &inArray)
 

Variables

template<typename... Ts>
constexpr bool all_arithmetic_v = all_arithmetic<Ts...>::value
 
template<typename... Ts>
constexpr bool all_same_v = all_same<Ts...>::value
 
template<typename T >
constexpr bool is_arithmetic_v = std::is_arithmetic<T>::value
 
template<class T >
constexpr bool is_complex_v = is_complex<T>::value
 
template<typename T >
constexpr bool is_floating_point_v = std::is_floating_point<T>::value
 
template<typename T >
constexpr bool is_integral_v = std::is_integral<T>::value
 
template<class A , class B >
constexpr bool is_same_v = std::is_same<A, B>::value
 
template<class dtype >
constexpr bool is_valid_dtype_v = is_valid_dtype<dtype>::value
 
constexpr char VERSION [] = "2.4.2"
 Current NumCpp version number. More...
 

Typedef Documentation

◆ enable_if_t

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

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

◆ int16

using nc::int16 = typedef std::int16_t

◆ int32

using nc::int32 = typedef std::int32_t

◆ int64

using nc::int64 = typedef std::int64_t

◆ int8

using nc::int8 = typedef std::int8_t

◆ uint16

using nc::uint16 = typedef std::uint16_t

◆ uint32

using nc::uint32 = typedef std::uint32_t

◆ uint64

using nc::uint64 = typedef std::uint64_t

◆ uint8

using nc::uint8 = typedef std::uint8_t

Enumeration Type Documentation

◆ Axis

enum nc::Axis
strong

Enum To describe an axis.

Enumerator
NONE 
ROW 
COL 

◆ Endian

enum nc::Endian
strong

Enum for endianess.

Enumerator
NATIVE 
BIG 
LITTLE 

Function Documentation

◆ abs() [1/2]

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

Calculate the absolute value element-wise.

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

Parameters
inArray
Returns
NdArray

◆ abs() [2/2]

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

Calculate the absolute value.

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

Parameters
inValue
Returns
value
Examples
ReadMe.cpp.

◆ add() [1/9]

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

Add arguments element-wise.

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

Parameters
inArray
value
Returns
NdArray

◆ add() [2/9]

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

Add arguments element-wise.

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

Parameters
inArray
value
Returns
NdArray

◆ add() [3/9]

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

Add arguments element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ add() [4/9]

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

Add arguments element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ add() [5/9]

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

Add arguments element-wise.

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

Parameters
inArray
value
Returns
NdArray

◆ add() [6/9]

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

Add arguments element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ add() [7/9]

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

Add arguments element-wise.

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

Parameters
value
inArray
Returns
NdArray

◆ add() [8/9]

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

Add arguments element-wise.

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

Parameters
value
inArray
Returns
NdArray

◆ add() [9/9]

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

Add arguments element-wise.

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

Parameters
value
inArray
Returns
NdArray

◆ alen()

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

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

Parameters
inArray
Returns
length uint16

◆ all()

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

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

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
bool
Examples
ReadMe.cpp.

◆ allclose()

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

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

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

Parameters
inArray1
inArray2
inTolerance(Optional, default 1e-5)
Returns
bool
Examples
ReadMe.cpp.

◆ amax()

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

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

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
max value

◆ amin()

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

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

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
min value

◆ angle() [1/2]

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

Return the angle of the complex argument.

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

Parameters
inArray
Returns
NdArray

◆ angle() [2/2]

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

Return the angle of the complex argument.

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

Parameters
inValue
Returns
value

◆ any()

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

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

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray
Examples
ReadMe.cpp.

◆ append()

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

Append values to the end of an array.

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

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

◆ applyFunction()

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

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

Parameters
inArray
inFunc
Returns
NdArray

◆ applyPoly1d()

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

Apply polynomial elemnt wise to the input values.

Parameters
inArray
inPoly
Returns
NdArray

◆ arange() [1/3]

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

Return evenly spaced values within a given interval.

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

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

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

Parameters
inSlice
Returns
NdArray

◆ arange() [2/3]

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

Return evenly spaced values within a given interval.

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

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

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

Parameters
inStart
inStop
inStep(Optional, defaults to 1)
Returns
NdArray

◆ arange() [3/3]

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

Return evenly spaced values within a given interval.

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

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

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

Parameters
inStopstart 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
ptrto array
numRowsnumber of rows of the buffer
numColsnumber 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
ptrto array
sizethe 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 Bool , std::enable_if_t< std::is_same< Bool, bool >::value, int > = 0>
NdArray<dtype> nc::asarray ( dtype *  ptr,
uint32  numRows,
uint32  numCols,
Bool  takeOwnership 
)
noexcept

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

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

Parameters
ptrto array
numRowsnumber of rows of the buffer
numColsnumber of cols of the buffer
takeOwnershipwhether or not to take ownership of the data and call delete[] in the destructor.
Returns
NdArray

◆ asarray() [10/17]

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

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

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

Parameters
ptrto array
sizethe number of elements in the array
takeOwnershipwhether or not to take ownership of the data and call delete[] in the destructor.
Returns
NdArray

◆ asarray() [11/17]

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

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

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

Parameters
iterBegin
iterEnd
Returns
NdArray

◆ asarray() [12/17]

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

Convert the std::array to an array.

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

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

◆ asarray() [13/17]

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

Convert the std::array to an array.

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

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

◆ asarray() [14/17]

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

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

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

Parameters
inList
Returns
NdArray

◆ asarray() [15/17]

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

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

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

Parameters
inList
Returns
NdArray

◆ asarray() [16/17]

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

Convert the vector to an array.

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

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

◆ asarray() [17/17]

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

Convert the vector to an array.

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

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

◆ astype()

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

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

Parameters
inArray
Returns
NdArray

◆ average() [1/3]

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

Compute the average along the specified axis.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ average() [2/3]

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

Compute the weighted average along the specified axis.

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

Parameters
inArray
inWeights
inAxis(Optional, default NONE)
Returns
NdArray

◆ average() [3/3]

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

Compute the weighted average along the specified axis.

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

Parameters
inArray
inWeights
inAxis(Optional, default NONE)
Returns
NdArray

◆ 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

◆ 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

◆ byteswap()

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

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

Parameters
inArray
Returns
NdArray

◆ cbrt() [1/2]

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

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

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

Parameters
inArray
Returns
NdArray

◆ cbrt() [2/2]

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

Return the cube-root of an array.

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

Parameters
inValue
Returns
value
Examples
ReadMe.cpp.

◆ ceil() [1/2]

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

Return the ceiling of the input, element-wise.

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

Parameters
inArray
Returns
NdArray

◆ ceil() [2/2]

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

Return the ceiling of the input.

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

Parameters
inValue
Returns
value

◆ centerOfMass()

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

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

Parameters
inArray
inAxis(Optional, default NONE which is a 2d center of mass)
Returns
NdArray: if axis is NONE then a 1x2 array of the centroid row/col is returned.

◆ clip() [1/2]

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

Clip (limit) the values in an array.

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

Parameters
inArray
inMinValue
inMaxValue
Returns
NdArray

◆ clip() [2/2]

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

Clip (limit) the value.

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

Parameters
inValue
inMinValue
inMaxValue
Returns
NdArray
Examples
ReadMe.cpp.

◆ column_stack()

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

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

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

Parameters
inArrayList{list} of arrays to stack
Returns
NdArray

◆ complex() [1/4]

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

Returns a std::complex from the input real and imag components

Parameters
inRealthe 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
inRealthe real component of the complex number
inImagthe 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
inRealthe 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
inRealthe real component of the complex number
inImagthe imaginary component of the complex number
Returns
value

◆ complex_cast()

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

Greater than or equal operator for std::complex<T>

Parameters
value
Returns
std::complex<Out>

◆ concatenate()

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

Join a sequence of arrays along an existing axis.

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

Parameters
inArrayList
inAxis(Optional, default NONE)
Returns
NdArray

◆ conj() [1/2]

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

Return the complex conjugate of the complex argument.

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

Parameters
inArray
Returns
NdArray

◆ conj() [2/2]

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

Return the complex conjugate of the complex argument.

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

Parameters
inValue
Returns
value

◆ contains()

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

returns whether or not a value is included the array

Parameters
inArray
inValue
inAxis(Optional, default NONE)
Returns
bool

◆ copy()

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

Return an array copy of the given object.

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

Parameters
inArray
Returns
NdArray

◆ copySign()

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

Change the sign of x1 to that of x2, element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ copyto()

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

Copies values from one array to another

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

Parameters
inDestArray
inSrcArray
Returns
NdArray

◆ 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.

◆ cross()

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

Return the cross product of two (arrays of) vectors.

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

Parameters
inArray1
inArray2
inAxis(Optional, default NONE)
Returns
NdArray

◆ cube() [1/2]

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

Cubes the elements of the array

Parameters
inArray
Returns
NdArray

◆ cube() [2/2]

template<typename dtype >
constexpr dtype nc::cube ( dtype  inValue)
constexprnoexcept

Cubes the input

Parameters
inValue
Returns
cubed value

◆ cumprod()

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

Return the cumulative product of elements along a given axis.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ cumsum()

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

Return the cumulative sum of the elements along a given axis.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ deg2rad() [1/2]

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

Convert angles from degrees to radians.

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

Parameters
inArray
Returns
NdArray

◆ deg2rad() [2/2]

template<typename dtype >
constexpr auto nc::deg2rad ( dtype  inValue)
constexprnoexcept

Convert angles from degrees to radians.

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

Parameters
inValue
Returns
value

◆ degrees() [1/2]

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

Convert angles from degrees to radians.

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

Parameters
inArray
Returns
NdArray

◆ degrees() [2/2]

template<typename dtype >
constexpr auto nc::degrees ( dtype  inValue)
constexprnoexcept

Convert angles from degrees to radians.

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

Parameters
inValue
Returns
value

◆ deleteIndices() [1/3]

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

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

Parameters
inArray
inArrayIdxs
inAxis(Optional, default NONE) if none the indices will be applied to the flattened array
Returns
NdArray

◆ deleteIndices() [2/3]

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

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

Parameters
inArray
inIndicesSlice
inAxis(Optional, default NONE) if none the indices will be applied to the flattened array
Returns
NdArray

◆ deleteIndices() [3/3]

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

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

Parameters
inArray
inIndex
inAxis(Optional, default NONE) if none the indices will be applied to the flattened array
Returns
NdArray

◆ diag()

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

Extract a diagonal or construct a diagonal array.

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

Parameters
inArray
kDiagonal 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
kDiagonal to set; 0, the default, corresponds to the �main� diagonal, a positive (negative) k giving the number of the diagonal above (below) the main.
Returns
NdArray

◆ diagonal()

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

Return specified diagonals.

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

Parameters
inArray
inOffset(Defaults to 0)
inAxis(Optional, default ROW) axis the offset is applied to
Returns
NdArray
Examples
ReadMe.cpp.

◆ diff()

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

Calculate the n-th discrete difference along given axis. Unsigned dtypes will give you weird results...obviously.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray
Examples
ReadMe.cpp.

◆ divide() [1/9]

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

divide arguments element-wise.

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

Parameters
inArray
value
Returns
NdArray

◆ divide() [2/9]

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

divide arguments element-wise.

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

Parameters
inArray
value
Returns
NdArray

◆ divide() [3/9]

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

divide arguments element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ divide() [4/9]

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

divide arguments element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ divide() [5/9]

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

divide arguments element-wise.

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

Parameters
inArray
value
Returns
NdArray

◆ divide() [6/9]

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

divide arguments element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ divide() [7/9]

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

divide arguments element-wise.

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

Parameters
value
inArray
Returns
NdArray

◆ divide() [8/9]

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

divide arguments element-wise.

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

Parameters
value
inArray
Returns
NdArray

◆ divide() [9/9]

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

divide arguments element-wise.

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

Parameters
value
inArray
Returns
NdArray

◆ dot() [1/3]

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

Dot product of two arrays.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ dot() [2/3]

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

Dot product of two arrays.

For 2-D arrays it is equivalent to matrix multiplication, and for 1-D arrays to inner product of vectors.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ dot() [3/3]

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

Dot product of two arrays.

For 2-D arrays it is equivalent to matrix multiplication, and for 1-D arrays to inner product of vectors.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ dump()

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

Dump a binary file of the array to the specified file. The array can be read back with or NC::load.

Parameters
inArray
inFilename
Returns
NdArray
Examples
ReadMe.cpp.

◆ empty() [1/2]

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

Return a new array of given shape and type, without initializing entries.

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

Parameters
inShape
Returns
NdArray

◆ empty() [2/2]

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

Return a new array of given shape and type, without initializing entries.

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

Parameters
inNumRows
inNumCols
Returns
NdArray

◆ empty_like()

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

Return a new array with the same shape as a given array.

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

Parameters
inArray
Returns
NdArray

◆ endianess()

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

Return the endianess of the array values.

Parameters
inArray
Returns
Endian

◆ equal()

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

Return (x1 == x2) element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray
Examples
ReadMe.cpp.

◆ exp() [1/2]

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

Calculate the exponential of all elements in the input array.

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

Parameters
inArray
Returns
NdArray

◆ exp() [2/2]

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

Calculate the exponential of the input value.

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

Parameters
inValue
Returns
value
Examples
GaussNewtonNlls.cpp, and ReadMe.cpp.

◆ exp2() [1/2]

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

Calculate 2**p for all p in the input array.

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

Parameters
inArray
Returns
NdArray

◆ exp2() [2/2]

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

Calculate 2**p for all p in the input value.

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

Parameters
inValue
Returns
value

◆ expm1() [1/2]

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

Calculate exp(x) - 1 for all elements in the array.

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

Parameters
inArray
Returns
NdArray

◆ expm1() [2/2]

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

Calculate exp(x) - 1 for the input value.

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

Parameters
inValue
Returns
value
Examples
ReadMe.cpp.

◆ 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
inKIndex 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
inNnumber of rows and columns (N)
inKIndex 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
inNnumber of rows (N)
inMnumber of columns (M)
inKIndex 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
maskthe mask to apply to the array
nthe first n indices to return (optional, default all)
Returns
NdArray

◆ fix() [1/2]

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

Round to nearest integer towards zero.

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

Parameters
inArray
Returns
NdArray

◆ fix() [2/2]

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

Round to nearest integer towards zero.

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

Parameters
inValue
Returns
value

◆ flatnonzero()

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

Return indices that are non-zero in the flattened version of a.

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

Parameters
inArray
Returns
NdArray

◆ flatten()

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

Return a copy of the array collapsed into one dimension.

Parameters
inArray
Returns
NdArray

◆ flip()

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

Reverse the order of elements in an array along the given axis.

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

Parameters
inArray
inAxis
Returns
NdArray
Examples
ReadMe.cpp.

◆ fliplr()

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

Flip array in the left/right direction.

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

Parameters
inArray
Returns
NdArray
Examples
ReadMe.cpp.

◆ flipud()

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

Flip array in the up/down direction.

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

Parameters
inArray
Returns
NdArray
Examples
ReadMe.cpp.

◆ floor() [1/2]

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

Return the floor of the input, element-wise.

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

Parameters
inArray
Returns
NdArray

◆ floor() [2/2]

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

Return the floor of the input.

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

Parameters
inValue
Returns
value

◆ floor_divide() [1/2]

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

Return the largest integer smaller or equal to the division of the inputs.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ floor_divide() [2/2]

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

Return the largest integer smaller or equal to the division of the inputs.

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

Parameters
inValue1
inValue2
Returns
value

◆ fmax() [1/2]

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

Element-wise maximum of array elements.

Compare two arrays and returns a new array containing the element - wise maxima

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ fmax() [2/2]

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

maximum of inputs.

Compare two value and returns a value containing the maxima

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

Parameters
inValue1
inValue2
Returns
value

◆ fmin() [1/2]

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

Element-wise minimum of array elements.

Compare two arrays and returns a new array containing the element - wise minima

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ fmin() [2/2]

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

minimum of inputs.

Compare two value and returns a value containing the minima

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

Parameters
inValue1
inValue2
Returns
value

◆ fmod() [1/2]

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

Return the element-wise remainder of division.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ fmod() [2/2]

template<typename dtype >
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()

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

Construct an array from data in a text or binary file.

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

Parameters
inFilename
inSepSeparator between items if file is a text file. Empty ("") separator means the file should be treated as binary. Right now the only supported seperators are " ", "\t", "\n"
Returns
NdArray

◆ fromiter()

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

Create a new 1-dimensional array from an iterable object.

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

Parameters
inBegin
inEnd
Returns
NdArray

◆ full() [1/3]

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

Return a new array of given shape and type, filled with inFillValue

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

Parameters
inShape
inFillValue
Returns
NdArray

◆ full() [2/3]

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

Return a new array of given shape and type, filled with inFillValue

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

Parameters
inNumRows
inNumCols
inFillValue
Returns
NdArray

◆ full() [3/3]

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

Return a new array of given shape and type, filled with inFillValue

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

Parameters
inSquareSize
inFillValue
Returns
NdArray

◆ full_like()

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

Return a full array with the same shape and type as a given array.

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

Parameters
inArray
inFillValue
Returns
NdArray

◆ gcd() [1/2]

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

Returns the greatest common divisor of the values in the input array. NOTE: Use of this function requires using the Boost includes.

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

Parameters
inArray
Returns
NdArray<double>

◆ gcd() [2/2]

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

Returns the greatest common divisor of |x1| and |x2|. NOTE: Use of this function requires either using the Boost includes or a C++17 compliant compiler.

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

Parameters
inValue1
inValue2
Returns
dtype

◆ 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

◆ 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
inBinEdgesmonotonically increasing array of bin edges, including the rightmost edge, allowing for non-uniform bin widths.
Returns
array of histogram counts

◆ histogram() [2/2]

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

Compute the histogram of a set of data.

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

Parameters
inArray
inNumBins(default 10)
Returns
std::pair of NdArrays; first is histogram counts, seconds is the bin edges

◆ hstack()

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

Stack arrays in sequence horizontally (column wise).

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

Parameters
inArrayList{list} of arrays to stack
Returns
NdArray
Examples
ReadMe.cpp.

◆ hypot() [1/3]

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

Given the "legs" of a right triangle, return its hypotenuse.

Equivalent to sqrt(x1**2 + x2**2), element - wise.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ hypot() [2/3]

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

Given the "legs" of a right triangle, return its hypotenuse.

Equivalent to sqrt(x1**2 + x2**2), element - wise.

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

Parameters
inValue1
inValue2
Returns
value

◆ hypot() [3/3]

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

Given the "legs" of a right triangle, return its hypotenuse.

Equivalent to sqrt(x1**2 + x2**2 + x3**2), element - wise.

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

Parameters
inValue1
inValue2
inValue3
Returns
value

◆ identity()

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

Return the identity array.

The identity array is a square array with ones on the main diagonal.

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

Parameters
inSquareSize
Returns
NdArray

◆ imag() [1/2]

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

Return the imaginary part of the complex argument.

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

Parameters
inArray
Returns
NdArray

◆ imag() [2/2]

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

Return the imaginar part of the complex argument.

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

Parameters
inValue
Returns
value

◆ 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
inXThe x-coordinates at which to evaluate the interpolated values.
inXpThe x-coordinates of the data points, must be increasing. Otherwise, xp is internally sorted.
inFpThe 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
inRtolrelative tolerance (default 1e-5)
inAtolabsolute 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.

◆ lcm() [1/2]

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

Returns the least common multiple of the values of the input array. NOTE: Use of this function requires using the Boost includes.

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

Parameters
inArray
Returns
NdArray<double>

◆ lcm() [2/2]

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

Returns the least common multiple of |x1| and |x2|. NOTE: Use of this function requires either using the Boost includes or a C++17 compliant compiler.

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

Parameters
inValue1
inValue2
Returns
dtype

◆ ldexp() [1/2]

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

Returns x1 * 2^x2, element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ ldexp() [2/2]

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

Returns x1 * 2^x2.

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

Parameters
inValue1
inValue2
Returns
value

◆ left_shift()

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

Shift the bits of an integer to the left.

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

Parameters
inArray
inNumBits
Returns
NdArray

◆ less()

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

Return the truth value of (x1 < x2) element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ less_equal()

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

Return the truth value of (x1 <= x2) element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ linspace()

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

Return evenly spaced numbers over a specified interval.

Returns num evenly spaced samples, calculated over the interval[start, stop].

The endpoint of the interval can optionally be excluded.

Mostly only usefull if called with a floating point type for the template argument.

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

Parameters
inStart
inStop
inNumnumber of points (default = 50)
endPointinclude 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

◆ 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

◆ matmul() [1/3]

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

Matrix product of two arrays.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ matmul() [2/3]

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

Matrix product of two arrays.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ matmul() [3/3]

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

Matrix product of two arrays.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ max()

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

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray
Examples
ReadMe.cpp.

◆ maximum()

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

Element-wise maximum of array elements.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ mean() [1/2]

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

Compute the mean along the specified axis.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray
Examples
ReadMe.cpp.

◆ mean() [2/2]

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

Compute the mean along the specified axis.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ median()

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

Compute the median along the specified axis.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ meshgrid() [1/2]

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

Return coordinate matrices from coordinate vectors. Make 2D coordinate arrays for vectorized evaluations of 2D scaler vector fields over 2D grids, given one - dimensional coordinate arrays x1, x2, ..., xn. If input arrays are not one dimensional they will be flattened.

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

Parameters
inICoords
inJCoords
Returns
std::pair<NdArray<dtype>, NdArray<dtype> >, i and j matrices

◆ meshgrid() [2/2]

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

Return coordinate matrices from coordinate vectors. Make 2D coordinate arrays for vectorized evaluations of 2D scaler vector fields over 2D grids, given one - dimensional coordinate arrays x1, x2, ..., xn.

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

Parameters
inSlice1
inSlice2
Returns
std::pair<NdArray<dtype>, NdArray<dtype> >, i and j matrices

◆ min()

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

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray
Examples
ReadMe.cpp.

◆ minimum()

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

Element-wise minimum of array elements.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ mod()

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

Return element-wise remainder of division.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ multiply() [1/9]

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

multiply arguments element-wise.

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

Parameters
inArray
value
Returns
NdArray

◆ multiply() [2/9]

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

multiply arguments element-wise.

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

Parameters
inArray
value
Returns
NdArray

◆ multiply() [3/9]

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

multiply arguments element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ multiply() [4/9]

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

multiply arguments element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ multiply() [5/9]

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

multiply arguments element-wise.

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

Parameters
inArray
value
Returns
NdArray

◆ multiply() [6/9]

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

multiply arguments element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray

◆ multiply() [7/9]

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

multiply arguments element-wise.

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

Parameters
value
inArray
Returns
NdArray

◆ multiply() [8/9]

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

multiply arguments element-wise.

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

Parameters
value
inArray
Returns
NdArray

◆ multiply() [9/9]

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

multiply arguments element-wise.

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

Parameters
value
inArray
Returns
NdArray

◆ nan_to_num()

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

Replace NaN with zero and infinity with large finite numbers (default behaviour) or with the numbers defined by the user using the nan, posinf and/or neginf keywords.

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

Parameters
inArray
nanvalue to be used to fill NaN values, default 0
posInfvalue to be used to fill positive infinity values, default a very large number
negInfvalue to be used to fill negative infinity values, default a very large negative number
Returns
NdArray

◆ nanargmax()

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

Returns the indices of the maximum values along an axis ignoring NaNs.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ nanargmin()

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

Returns the indices of the minimum values along an axis ignoring NaNs.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ nancumprod()

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

Return the cumulative product of elements along a given axis ignoring NaNs.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ nancumsum()

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

Return the cumulative sum of the elements along a given axis ignoring NaNs.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ nanmax()

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

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

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ nanmean()

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

Compute the mean along the specified axis ignoring NaNs.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ nanmedian()

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

Compute the median along the specified axis ignoring NaNs.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ nanmin()

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

Return the minimum of an array or maximum along an axis ignoring NaNs.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ nanpercentile()

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

Compute the qth percentile of the data along the specified axis, while ignoring nan values.

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

Parameters
inArray
inPercentile
inAxis(Optional, default NONE)
inInterpMethod(default linear) choices = ['linear','lower','higher','nearest','midpoint']
Returns
NdArray

◆ nanprod()

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

Return the product of array elements over a given axis treating Not a Numbers (NaNs) as ones.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ nans() [1/3]

NdArray<double> nc::nans ( const Shape inShape)
inline

Return a new array of given shape and type, filled with nans. Only really works for dtype = float/double

Parameters
inShape
Returns
NdArray

◆ nans() [2/3]

NdArray<double> nc::nans ( uint32  inNumRows,
uint32  inNumCols 
)
inline

Return a new array of given shape and type, filled with nans. Only really works for dtype = float/double

Parameters
inNumRows
inNumCols
Returns
NdArray

◆ nans() [3/3]

NdArray<double> nc::nans ( uint32  inSquareSize)
inline

Return a new array of given shape and type, filled with nans. Only really works for dtype = float/double

Parameters
inSquareSize
Returns
NdArray
Examples
ReadMe.cpp.

◆ nans_like()

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

Return a new array of given shape and type, filled with nans.

Parameters
inArray
Returns
NdArray

◆ nanstdev()

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

Compute the standard deviation along the specified axis, while ignoring NaNs.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ nansum()

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

Return the sum of array elements over a given axis treating Not a Numbers (NaNs) as zero.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ nanvar()

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

Compute the variance along the specified axis, while ignoring NaNs.

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ nbytes()

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

Returns the number of bytes held by the array

Parameters
inArray
Returns
number of bytes

◆ negative()

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

Numerical negative, element-wise.

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

Parameters
inArray
Returns
NdArray

◆ newbyteorder() [1/2]

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

Return the array with the same data viewed with a different byte order. only works for integer types, floating point types will not compile and you will be confused as to why...

Parameters
inArray
inEndianess
Returns
NdArray

◆ newbyteorder() [2/2]

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

Return the array with the same data viewed with a different byte order. only works for integer types, floating point types will not compile and you will be confused as to why...

Parameters
inValue
inEndianess
Returns
inValue

◆ none()

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

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

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

Parameters
inArray
inAxis(Optional, default NONE)
Returns
bool

◆ nonzero()

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

Return the indices of the flattened array of the elements that are non-zero.

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

Parameters
inArray
Returns
NdArray
Examples
ReadMe.cpp.

◆ norm() [1/2]

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

Matrix or vector norm.

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ norm() [2/2]

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

Matrix or vector norm.

Parameters
inArray
inAxis(Optional, default NONE)
Returns
NdArray

◆ not_equal()

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

Return (x1 != x2) element-wise.

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

Parameters
inArray1
inArray2
Returns
NdArray
Examples
ReadMe.cpp.

◆ ones() [1/3]

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

Return a new array of given shape and type, filled with ones.

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

Parameters
inShape
Returns
NdArray

◆ ones() [2/3]

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

Return a new array of given shape and type, filled with ones.

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

Parameters
inNumRows
inNumCols
Returns
NdArray

◆ ones() [3/3]

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

Return a new array of given shape and type, filled with ones.

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

Parameters
inSquareSize
Returns
NdArray

◆ ones_like()

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

Return a new array of given shape and type, filled with ones.

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

Parameters
inArray
Returns
NdArray

◆ operator!()

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

Takes the not of the array

Parameters
inArray
Returns
NdArray

◆ operator!=() [1/3]

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

Returns an array of booleans of element wise comparison of two arrays

Parameters
lhs
rhs
Returns
NdArray

◆ operator!=() [2/3]

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

Returns an array of booleans of element wise comparison an array and a scaler

Parameters
lhs
inValue
Returns
NdArray

◆ operator!=() [3/3]

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

Returns an array of booleans of element wise comparison an array and a scaler

Parameters
inValue
inArray
Returns
NdArray

◆ operator%() [1/3]

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

Takes the modulus of the elements of two arrays

Parameters
lhs
rhs
Returns
NdArray

◆ operator%() [2/3]

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

Modulus of the array and the scaler

Parameters
lhs
rhs
Returns
NdArray

◆ operator%() [3/3]

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

Modulus of the scaler and the array

Parameters
lhs
rhs
Returns
NdArray

◆ operator%=() [1/2]

template<typename dtype >
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 >
NdArray<dtype>& nc::operator%= ( NdArray< dtype > &  lhs,
dtype  rhs 
)

Modulus the scaler to the array

Parameters
lhs
rhs
Returns
NdArray

◆ operator&() [1/3]

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

Takes the bitwise and of the elements of two arrays

Parameters
lhs
rhs
Returns
NdArray

◆ operator&() [2/3]

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

Takes the bitwise and of the array and the scaler

Parameters
lhs
rhs
Returns
NdArray

◆ operator&() [3/3]

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

Takes the bitwise and of the sclar and the array

Parameters
lhs
rhs
Returns
NdArray

◆ operator&&() [1/3]

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

Takes the and of the elements of two arrays

Parameters
lhs
rhs
Returns
NdArray

◆ operator&&() [2/3]

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

Takes the and of the array and the scaler

Parameters
lhs
rhs
Returns
NdArray

◆ operator&&() [3/3]

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

Takes the and of the array and the scaler

Parameters
lhs
rhs
Returns
NdArray

◆ operator&=() [1/2]

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

Bitwise and the elements of two arrays

Parameters
lhs
rhs
Returns
NdArray

◆ operator&=() [2/2]

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

Bitwise and the scaler to the array

Parameters
lhs
rhs
Returns
NdArray

◆ operator*() [1/15]

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

Multiplies the elements of two arrays (1)

Parameters
lhs
rhs
Returns
NdArray

◆ operator*() [2/15]

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

Multiplies the elements of two arrays (2)

Parameters
lhs
rhs
Returns
NdArray

◆ operator*() [3/15]

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

Multiplies the scaler to the array (6)

Parameters
lhs
rhs
Returns
NdArray

◆ operator*() [4/15]

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

Multiplies the scaler to the array (4)

Parameters
lhs
rhs
Returns
NdArray

◆ operator*() [5/15]

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

Multiplies the elements of two arrays (3)

Parameters
lhs
rhs
Returns
NdArray

◆ operator*() [6/15]

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

Multiplies the scaler to the array (8)

Parameters
lhs
rhs
Returns
NdArray

◆ operator*() [7/15]

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

Multiplies the scaler to the array (7)

Parameters
lhs
rhs
Returns
NdArray

◆ operator*() [8/15]

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

Vector mulitplication (dot product)

Parameters
lhs
rhs
Returns
dot product

◆ operator*() [9/15]

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

Scalar mulitplication

Parameters
lhs
rhs
Returns
Vec2

◆ operator*() [10/15]

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

Vector mulitplication (dot product)

Parameters
lhs
rhs
Returns
dot product

◆ operator*() [11/15]

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

Scalar mulitplication

Parameters
lhs
rhs
Returns
Vec3

◆ operator*() [12/15]

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

Scalar mulitplication

Parameters
lhs
rhs
Returns
Vec2

◆ operator*() [13/15]

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

Scalar mulitplication

Parameters
lhs
rhs
Returns
Vec3

◆ operator*() [14/15]

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

Multiplies the scaler to the array (5)

Parameters
lhs
rhs
Returns
NdArray

◆ operator*() [15/15]

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

Multiplies the scaler to the array (9)

Parameters
lhs
rhs
Returns
NdArray

◆ operator*=() [1/4]

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

Multiplies the elements of two arrays (1)

Parameters
lhs
rhs
Returns
NdArray

◆ operator*=() [2/4]

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

Multiplies the scaler to the array (3)

Parameters
lhs
rhs
Returns
NdArray

◆ operator*=() [3/4]

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

Multiplies the elements of two arrays (2)

Parameters
lhs
rhs
Returns
NdArray

◆ operator*=() [4/4]

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

Multiplies the scaler to the array (4)

Parameters
lhs
rhs
Returns
NdArray

◆ operator+() [1/19]

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

Adds the elements of two arrays (1)

Parameters
lhs
rhs
Returns
NdArray

◆ operator+() [2/19]

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

Adds the elements of two arrays (2)

Parameters
lhs
rhs
Returns
NdArray

◆ operator+() [3/19]

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

Adds the scaler to the array (6)

Parameters
lhs
rhs
Returns
NdArray

◆ operator+() [4/19]

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

Adds the scaler to the array (4)

Parameters
lhs
rhs
Returns
NdArray

◆ operator+() [5/19]

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

Adds the elements of two arrays (3)

Parameters
lhs
rhs
Returns
NdArray

◆ operator+() [6/19]

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

Adds the scaler to the array (8)

Parameters
lhs
rhs
Returns
NdArray

◆ operator+() [7/19]

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

Adds the scaler to the array (7)

Parameters
lhs
rhs
Returns
NdArray

◆ operator+() [8/19]

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

Adds the two vectors

Parameters
lhs
rhs
Returns
Vec2

◆ operator+() [9/19]

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

Adds the scaler to the vector

Parameters
lhs
rhs
Returns
Vec2

◆ operator+() [10/19]

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

Adds the two vectors

Parameters
lhs
rhs
Returns
Vec3

◆ operator+() [11/19]

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

Adds the scaler to the vector

Parameters
lhs
rhs
Returns
Vec3

◆ operator+() [12/19]

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

Adds the scaler to the vector

Parameters
lhs
rhs
Returns
Vec2

◆ operator+() [13/19]

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

Adds the scaler to the vector

Parameters
lhs
rhs
Returns
Vec3

◆ operator+() [14/19]

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

Adds the scaler to the array (5)

Parameters
lhs
rhs
Returns
NdArray

◆ operator+() [15/19]

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

Adds the scaler to the array (9)

Parameters
lhs
rhs
Returns
NdArray

◆ operator+() [16/19]

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

Iterator addition operator

Parameters
offset
next
Returns
bool

◆ operator+() [17/19]

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

Iterator addition operator

Parameters
offset
next
Returns
bool

◆ operator+() [18/19]

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

Iterator addition operator

Parameters
offset
next
Returns
bool

◆ operator+() [19/19]

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

Iterator addition operator

Parameters
offset
next
Returns
NdArrayIterator

◆ operator++() [1/2]

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

postfix increments the elements of an array

Parameters
lhs
Returns
NdArray

◆ operator++() [2/2]

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

prefix incraments the elements of an array

Returns
NdArray

◆ operator+=() [1/4]

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

Adds the elements of two arrays (1)

Parameters
lhs
rhs
Returns
NdArray

◆ operator+=() [2/4]

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

Adds the scaler to the array (3)

Parameters
lhs
rhs
Returns
NdArray

◆ operator+=() [3/4]

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

Adds the elements of two arrays (2)

Parameters
lhs
rhs
Returns
NdArray

◆ operator+=() [4/4]

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

Adds the scaler to the array (4)

Parameters
lhs
rhs
Returns
NdArray

◆ operator-() [1/18]

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

Negative Operator

Returns
NdArray

◆ operator-() [2/18]

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

Subtracts the elements of two arrays (1)

Parameters
lhs
rhs
Returns
NdArray

◆ operator-() [3/18]

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

Subtracts the elements of two arrays (2)

Parameters
lhs
rhs
Returns
NdArray

◆ operator-() [4/18]

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

Subtracts the scaler from the array (6)

Parameters
lhs
rhs
Returns
NdArray

◆ operator-() [5/18]

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

Subtracts the scaler from the array (4)

Parameters
lhs
rhs
Returns
NdArray

◆ operator-() [6/18]

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

Subtracts the elements of two arrays (3)

Parameters
lhs
rhs
Returns
NdArray

◆ operator-() [7/18]

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

Subtracts the scaler from the array (8)

Parameters
lhs
rhs
Returns
NdArray

◆ operator-() [8/18]

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

Subtracts the scaler from the array (7)

Parameters
lhs
rhs
Returns
NdArray

◆ operator-() [9/18]

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

Subtracts the two vectors

Parameters
lhs
rhs
Returns
Vec2

◆ operator-() [10/18]

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

Subtracts the scaler from the vector

Parameters
lhs
rhs
Returns
Vec2

◆ operator-() [11/18]

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

Returns the negative vector

Returns
Vec2

◆ operator-() [12/18]

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

Subtracts the two vectors

Parameters
lhs
rhs
Returns
Vec3

◆ operator-() [13/18]

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

Subtracts the scaler from the vector

Parameters
lhs
rhs
Returns
Vec3

◆ operator-() [14/18]

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

Returns the negative vector

Returns
Vec3

◆ operator-() [15/18]

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

Subtracts the scaler from the vector

Parameters
lhs
rhs
Returns
Vec2

◆ operator-() [16/18]

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

Subtracts the scaler from the vector

Parameters
lhs
rhs
Returns
Vec3

◆ operator-() [17/18]

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

Subtracts the scaler from the array (5)

Parameters
lhs
rhs
Returns
NdArray

◆ operator-() [18/18]

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

Subtracts the scaler from the array (9)

Parameters
lhs
rhs
Returns
NdArray

◆ operator--() [1/2]

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

postfix decrements the elements of an array

Parameters
lhs
Returns
NdArray

◆ operator--() [2/2]

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

prefix decrements the elements of an array

Returns
NdArray

◆ operator-=() [1/4]

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

Subtracts the elements of two arrays (1)

Parameters
lhs
rhs
Returns
NdArray

◆ operator-=() [2/4]

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

Subtracts the scaler from the array (3)

Parameters
lhs
rhs
Returns
NdArray

◆ operator-=() [3/4]

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

Subtracts the elements of two arrays (2)

Parameters
lhs
rhs
Returns
NdArray

◆ operator-=() [4/4]

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

Subtracts the scaler from the array (4)

Parameters
lhs
rhs
Returns
NdArray

◆ operator/() [1/11]

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

Divides the elements of two arrays (1)

Parameters
lhs
rhs
Returns
NdArray

◆ operator/() [2/11]

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

Divides the elements of two arrays (2)

Parameters
lhs
rhs
Returns
NdArray

◆ operator/() [3/11]

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

Divides the scaler from the array (6)

Parameters
lhs
rhs
Returns
NdArray

◆ operator/() [4/11]

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

Divides the scaler from the array (4)

Parameters
lhs
rhs
Returns
NdArray

◆ operator/() [5/11]

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

Divides the elements of two arrays (3)

Parameters
lhs
rhs
Returns
NdArray

◆ operator/() [6/11]

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

Divides the scaler from the array (8)

Parameters
lhs
rhs
Returns
NdArray

◆ operator/() [7/11]

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

Divides the scaler from the array (7)

Parameters
lhs
rhs
Returns
NdArray

◆ operator/() [8/11]

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

Scalar division

Parameters
lhs
rhs
Returns
Vec2

◆ operator/() [9/11]

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

Scalar division

Parameters
lhs
rhs
Returns
Vec3

◆ operator/() [10/11]

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

Divides the scaler from the array (5)

Parameters
lhs
rhs
Returns
NdArray

◆ operator/() [11/11]

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

Divides the scaler from the array (9)

Parameters
lhs
rhs
Returns
NdArray

◆ operator/=() [1/4]

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

Divides the elements of two arrays (1)

Parameters
lhs
rhs
Returns
NdArray

◆ operator/=() [2/4]

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

Divides the scaler from the array (3)

Parameters
lhs
rhs
Returns
NdArray

◆ operator/=() [3/4]

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

Divides the elements of two arrays (2)

Parameters
lhs
rhs
Returns
NdArray

◆ operator/=() [4/4]

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

Divides the scaler from the array (4)

Parameters
lhs
rhs
Returns
NdArray

◆ operator<() [1/4]

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

Returns an array of booleans of element wise comparison of two arrays

Parameters
lhs
rhs
Returns
NdArray

◆ operator<() [2/4]

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

Returns an array of booleans of element wise comparison the array and a scaler

Parameters
lhs
inValue
Returns
NdArray

◆ operator<() [3/4]

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

Less than operator for std::complex<T>

Parameters
lhs
rhs
Returns
bool true if lhs < rhs

◆ operator<() [4/4]

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

Returns an array of booleans of element wise comparison the array and a scaler

Parameters
inValue
inArray
Returns
NdArray

◆ operator<<() [1/4]

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

Bitshifts left the elements of the array

Parameters
lhs
inNumBits
Returns
NdArray

◆ operator<<() [2/4]

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

io operator for the NdArray class

Parameters
inOStream
inArray
Returns
std::ostream

◆ operator<<() [3/4]

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

stream output operator

Parameters
stream
vec
Returns
std::ostream

◆ operator<<() [4/4]

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

stream output operator

Parameters
stream
vec
Returns
std::ostream

◆ operator<<=()

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

Bitshifts left the elements of the array

Parameters
lhs
inNumBits
Returns
NdArray

◆ operator<=() [1/4]

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

Returns an array of booleans of element wise comparison of two arrays

Parameters
lhs
rhs
Returns
NdArray

◆ operator<=() [2/4]

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

Returns an array of booleans of element wise comparison the array and a scaler

Parameters
lhs
inValue
Returns
NdArray

◆ operator<=() [3/4]

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

Less than or equal operator for std::complex<T>

Parameters
lhs
rhs
Returns
bool true if lhs <= rhs

◆ operator<=() [4/4]

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

Returns an array of booleans of element wise comparison the array and a scaler

Parameters
inValue
inArray
Returns
NdArray

◆ operator==() [1/3]

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

Returns an array of booleans of element wise comparison of two arrays

Parameters
lhs
rhs
Returns
NdArray

◆ operator==() [2/3]

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

Returns an array of booleans of element wise comparison an array and a scaler

Parameters
lhs
inValue
Returns
NdArray

◆ operator==() [3/3]

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

Returns an array of booleans of element wise comparison an array and a scaler

Parameters
inValue
inArray
Returns
NdArray

◆ operator>() [1/4]

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

Returns an array of booleans of element wise comparison of two arrays

Parameters
lhs
rhs
Returns
NdArray

◆ operator>() [2/4]

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

Returns an array of booleans of element wise comparison the array and a scaler

Parameters
lhs
inValue
Returns
NdArray

◆ operator>() [3/4]

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

Greater than operator for std::complex<T>

Parameters
lhs
rhs
Returns
bool true if lhs > rhs

◆ operator>() [4/4]

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

Returns an array of booleans of element wise comparison the array and a scaler

Parameters
inValue
inArray
Returns
NdArray

◆ operator>=() [1/4]

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

Returns an array of booleans of element wise comparison of two arrays

Parameters
lhs
rhs
Returns
NdArray

◆ operator>=() [2/4]

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

Returns an array of booleans of element wise comparison the array and a scaler

Parameters
lhs
inValue
Returns
NdArray