 |
NumCpp
2.16.0
A Templatized Header Only C++ Implementation of the Python NumPy Library
|
|
NumCpp
2.16.0
A Templatized Header Only C++ Implementation of the Python NumPy Library
|
Namespaces | |
| namespace | broadcast |
| namespace | constants |
| namespace | coordinates |
| namespace | detail |
| namespace | edac |
| namespace | endian |
| namespace | error |
| namespace | fft |
| namespace | filter |
| namespace | imageProcessing |
| namespace | integrate |
| namespace | linalg |
| namespace | logger |
| namespace | polynomial |
| namespace | random |
| namespace | roots |
| namespace | rotations |
| namespace | special |
| namespace | stl_algorithms |
| namespace | type_traits |
| namespace | utils |
Data Structures | |
| struct | all_arithmetic |
| struct | all_arithmetic< Head, Tail... > |
| struct | all_arithmetic< T > |
| struct | all_same |
| struct | all_same< T1, Head, Tail... > |
| struct | all_same< T1, T2 > |
| struct | ComplexHash |
| class | DataCube |
| Convenience container for holding a uniform array of NdArrays. More... | |
| class | DateTime |
| Date Time class for working with iso formatted date times. More... | |
| class | DtypeInfo |
| Holds info about the dtype. More... | |
| class | DtypeInfo< std::complex< dtype > > |
| Holds info about the std::complex. More... | |
| struct | greaterThan |
| struct | is_complex |
| struct | is_complex< std::complex< T > > |
| struct | is_ndarray_int |
| struct | is_ndarray_int< NdArray< dtype, Allocator > > |
| struct | is_valid_dtype |
| class | NdArray |
| Holds 1D and 2D arrays, the main work horse of the NumCpp library. More... | |
| class | NdArrayColumnIterator |
| Custom column iterator for NdArray. More... | |
| class | NdArrayConstColumnIterator |
| Custom column const_iterator for NdArray. More... | |
| class | NdArrayConstIterator |
| Custom const_iterator for NdArray. More... | |
| class | NdArrayIterator |
| Custom iterator for NdArray. More... | |
| class | Shape |
| A Shape Class for NdArrays. More... | |
| class | Slice |
| A Class for slicing into NdArrays. More... | |
| class | Timer |
| A timer class for timing code execution. More... | |
| class | Vec2 |
| Holds a 2D vector. More... | |
| class | Vec3 |
| Holds a 3D vector. More... | |
Typedefs | |
| using | Clock = std::chrono::system_clock |
| Clock Type. | |
| using | Duration = std::chrono::nanoseconds |
| Duration Type. | |
| using | int16 = std::int16_t |
| using | int32 = std::int32_t |
| using | int64 = std::int64_t |
| using | int8 = std::int8_t |
| template<typename T > | |
| using | ndarray_int_concept = std::enable_if_t< is_ndarray_int_v< T >, int > |
| using | TimePoint = std::chrono::time_point< Clock, Duration > |
| TimePoint Type. | |
| using | uint16 = std::uint16_t |
| using | uint32 = std::uint32_t |
| using | uint64 = std::uint64_t |
| using | uint8 = std::uint8_t |
Enumerations | |
| enum class | Axis { NONE = 0 , ROW , COL } |
| Enum To describe an axis. More... | |
| enum class | Bias : bool { YES = true , NO = false } |
| Bias boolean. More... | |
| enum class | Endian { NATIVE = 0 , BIG , LITTLE } |
| Enum for endianess. More... | |
| enum class | EndPoint : bool { YES = true , NO = false } |
| End Point boolean. More... | |
| enum class | Increasing : bool { YES = true , NO = false } |
| Increasing boolean. More... | |
| enum class | InterpolationMethod { LINEAR , LOWER , HIGHER , NEAREST , MIDPOINT } |
| enum class | IsRoots : bool { YES = true , NO = false } |
| Is Roots boolean. More... | |
| enum class | PointerPolicy { COPY , SHELL } |
| Policy for NdArray constructor that takes in a pointer to data. More... | |
| enum class | PrintElapsedTime : bool { YES = true , NO = false } |
| Print Elapsed Time boolean. More... | |
| enum class | PrintResults : bool { YES = true , NO = false } |
| Print Results boolean. More... | |
| enum class | Replace : bool { YES = true , NO = false } |
| Replace boolean. More... | |
| enum class | Side { LEFT , RIGHT } |
Variables | |
| template<typename... Ts> | |
| constexpr bool | all_arithmetic_v = all_arithmetic<Ts...>::value |
| template<typename... Ts> | |
| constexpr bool | all_same_v = all_same<Ts...>::value |
| template<std::size_t Value1, std::size_t Value2> | |
| constexpr bool | greaterThan_v = greaterThan<Value1, Value2>::value |
| template<class T > | |
| constexpr bool | is_complex_v = is_complex<T>::value |
| template<typename T > | |
| constexpr bool | is_ndarray_int_v = is_ndarray_int<T>::value |
| template<class dtype > | |
| constexpr bool | is_valid_dtype_v = is_valid_dtype<dtype>::value |
| constexpr char | VERSION [] = "2.16.0" |
| Current NumCpp version number. | |
| using nc::Duration = typedef std::chrono::nanoseconds |
Duration Type.
| using nc::ndarray_int_concept = typedef std::enable_if_t<is_ndarray_int_v<T>, int> |
| using nc::TimePoint = typedef std::chrono::time_point<Clock, Duration> |
TimePoint Type.
| using nc::uint16 = typedef std::uint16_t |
| using nc::uint32 = typedef std::uint32_t |
| using nc::uint64 = typedef std::uint64_t |
|
strong |
|
strong |
|
strong |
|
strong |
|
strong |
|
strong |
Policy for NdArray constructor that takes in a pointer to data.
| Enumerator | |
|---|---|
| COPY | |
| SHELL | |
|
strong |
|
strong |
|
strong |
Calculate the absolute value element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.absolute.html
| inArray |
Calculate the absolute value.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.absolute.html
| inValue |
| 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
| inArray | |
| value |
Add arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.add.html
| inArray | |
| value |
Add arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.add.html
| inArray1 | |
| inArray2 |
| 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
| inArray1 | |
| inArray2 |
| 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
| inArray | |
| value |
| 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
| inArray1 | |
| inArray2 |
| 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
| value | |
| inArray |
Add arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.add.html
| value | |
| inArray |
| 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
| value | |
| inArray |
Return the length of the first dimension of the input array.
| inArray |
Test whether all array elements along a given axis evaluate to True.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.all.html
| inArray | |
| inAxis | (Optional, default NONE) |
| 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
| inArray1 | |
| inArray2 | |
| inTolerance | (Optional, default 1e-5) |
Return the maximum of an array or maximum along an axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.amax.html
| inArray | |
| inAxis | (Optional, default NONE) |
Return the minimum of an array or minimum along an axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.amin.html
| inArray | |
| inAxis | (Optional, default NONE) |
Return the angle of the complex argument.
NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.angle.html
| inArray |
Return the angle of the complex argument.
NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.angle.html
| inValue |
Test whether any array element along a given axis evaluates to True.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.any.html
| inArray | |
| inAxis | (Optional, default NONE) |
| 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
| 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. |
Apply the input function element wise to the input array in place.
| inArray | |
| inFunc |
Apply polynomial elemnt wise to the input values.
| inArray | |
| inPoly |
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
| inSlice |
| 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
| inStart | |
| inStop | |
| inStep | (Optional, defaults to 1) |
| 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
| inStop | start is 0 and step is 1 |
Trigonometric inverse cosine, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arccos.html
| inArray |
Trigonometric inverse cosine
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arccos.html
| inValue |
Trigonometric inverse hyperbolic cosine, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arccosh.html
| inArray |
Trigonometric inverse hyperbolic cosine.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arccosh.html
| inValue |
Trigonometric inverse sine, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arcsin.html
| inArray |
Trigonometric inverse sine.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arcsin.html
| inValue |
Trigonometric inverse hyperbolic sine, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arcsinh.html
| inArray |
Trigonometric inverse hyperbolic sine.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arcsinh.html
| inValue |
Trigonometric inverse tangent, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arctan.html
| inArray |
Trigonometric inverse tangent.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arctan.html
| inValue |
Trigonometric inverse tangent, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arctan2.html
| inY | |
| inX |
Trigonometric inverse tangent.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arctan2.html
| inY | |
| inX |
Trigonometric inverse hyperbolic tangent, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arctanh.html
| inArray |
Trigonometric inverse hyperbolic tangent.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.arctanh.html
| inValue |
Returns the indices of the maximum values along an axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.argmax.html
| inArray | |
| inAxis | (Optional, default NONE) |
Returns the indices of the minimum values along an axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.argmin.html
| inArray | |
| inAxis | (Optional, default NONE) |
| NdArray< uint32 > nc::argpartition | ( | const NdArray< dtype > & | inArray, |
| uint32 | inKth, | ||
| Axis | inAxis = Axis::NONE |
||
| ) |
Perform an indirect partition along the given axis using the algorithm specified by the kind keyword. It returns an array of indices of the same shape as a that index data along the given axis in partitioned order.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.argpartition.html
| inArray | |
| inKth | kth element |
| inAxis | (Optional, default NONE) |
Returns the indices that would sort an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.argsort.html
| inArray | |
| inAxis | (Optional, default NONE) |
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
| inArray |
Evenly round to the given number of decimals.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.around.html
| inArray | |
| inNumDecimals | (Optional, default = 0) |
Evenly round to the given number of decimals.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.around.html
| inValue | |
| inNumDecimals | (Optional, default = 0) |
|
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
| inArray1 | |
| 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
| inArray1 | |
| inArray2 |
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
| iterBegin | |
| iterEnd |
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
| ptr | to array |
| numRows | number of rows of the buffer |
| numCols | number of cols of the buffer |
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
| ptr | to array |
| size | the number of elements in the array |
Convert the vector to an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html
| 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
| inDeque |
Convert the list to an array. Makes a copy of the data.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html
| inList |
Convert the set to an array. Makes a copy of the data.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html
| inSet |
Convert the vector to an array. Makes a copy of the data.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html
| inVector |
|
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
| ptr | to array |
| size | the number of elements in the array |
| pointerPolicy | (optional) whether to make a copy and own the data, or act as a non-owning shell. Default Copy |
|
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
| ptr | to array |
| numRows | number of rows of the buffer |
| numCols | number of cols of the buffer |
| pointerPolicy | (optional) whether to make a copy and own the data, or act as a non-owning shell. Default Copy |
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
| iterBegin | |
| iterEnd |
| NdArray< dtype > nc::asarray | ( | std::array< dtype, ArraySize > & | inArray, |
| PointerPolicy | pointerPolicy = PointerPolicy::COPY |
||
| ) |
Convert the std::array to an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html
| inArray | |
| pointerPolicy | (optional) whether to make a copy and own the data, or act as a non-owning shell. Default Copy |
| NdArray< dtype > nc::asarray | ( | std::array< std::array< dtype, Dim1Size >, Dim0Size > & | inArray, |
| PointerPolicy | pointerPolicy = PointerPolicy::COPY |
||
| ) |
Convert the std::array to an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html
| inArray | |
| pointerPolicy | (optional) whether to make a copy and own the data, or act as a non-owning shell. Default Copy |
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
| 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
| inList |
| NdArray< dtype > nc::asarray | ( | std::vector< dtype > & | inVector, |
| PointerPolicy | pointerPolicy = PointerPolicy::COPY |
||
| ) |
Convert the vector to an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html
| inVector | |
| pointerPolicy | (optional) whether to make a copy and own the data, or act as a non-owning shell. Default Copy |
| NdArray< dtype > nc::asarray | ( | std::vector< std::array< dtype, Dim1Size > > & | inVector, |
| PointerPolicy | pointerPolicy = PointerPolicy::COPY |
||
| ) |
Convert the vector to an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.asarray.html
| inVector | |
| pointerPolicy | (optional) whether to make a copy and own the data, or act as a non-owning shell. Default Copy |
Compute the average along the specified axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.average.html
| inArray | |
| inAxis | (Optional, default NONE) |
| 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
| inArray | |
| inWeights | |
| inAxis | (Optional, default NONE) |
| 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
| inArray | |
| inWeights | |
| inAxis | (Optional, default NONE) |
The Bartlett window is very similar to a triangular window, except that the end points are at zero. It is often used in signal processing for tapering a signal, without generating too much ripple in the frequency domain.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.bartlett.html
| m | Number of points in the output window. If zero or less, an empty array is returned. |
Return the binary representation of the input number as a string.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.binary_repr.html
| inValue |
| 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
| inArray | |
| inWeights | |
| inMinLength |
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
| inArray | |
| inMinLength |
Computes the number of 1-bits in an integer
| inValue |
| 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
| inArray1 | |
| inArray2 |
| 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
| inArray1 | |
| inArray2 |
| 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
| inArray1 | |
| inArray2 |
The Blackman window is a taper formed by using the first three terms of a summation of cosines. It was designed to have close to the minimal leakage possible. It is close to optimal, only slightly worse than a Kaiser window.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.blackman.html
| m | Number of points in the output window. If zero or less, an empty array is returned. |
Return the cube-root of an array, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cbrt.html
| inArray |
Return the cube-root of an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cbrt.html
| inValue |
Return the ceiling of the input, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ceil.html
| inArray |
Return the ceiling of the input.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ceil.html
| inValue |
Returns the center of mass of the array values along an axis.
| inArray | |
| inAxis | (Optional, default NONE which is a 2d center of mass) |
Clip (limit) the values in an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.clip.html
| inArray | |
| inMinValue | |
| inMaxValue |
Clip (limit) the value.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.clip.html
| inValue | |
| inMinValue | |
| inMaxValue |
Stack 1-D arrays as columns into a 2-D array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.column_stack.html
| inArrayList | {list} of arrays to stack |
Stack 1-D arrays as columns into a 2-D array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.column_stack.html
| inArrayList | {list} of arrays to stack |
| auto nc::complex | ( | const NdArray< dtype > & | inReal | ) |
Returns a std::complex from the input real and imag components
| inReal | the real component of the complex number |
Returns a std::complex from the input real and imag components
| inReal | the real component of the complex number |
| inImag | the imaginary component of the complex number |
Returns a std::complex from the input real and imag components
| inArray | the real component of the complex number |
Returns a std::complex from the input real and imag components
| inReal | the real component of the complex number |
Returns a std::complex from the input real and imag components
| inReal | the real component of the complex number |
| inImag | the imaginary component of the complex number |
Greater than or equal operator for std::complex<T>
| value |
| 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
| inArrayList | |
| inAxis | (Optional, default NONE) |
| NdArray< dtype > nc::concatenate | ( | const std::vector< NdArray< dtype > > & | inArrayList, |
| Axis | inAxis = Axis::NONE |
||
| ) |
Join a sequence of arrays along an existing axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.concatenate.html
| inArrayList | |
| inAxis | (Optional, default NONE) |
Return the complex conjugate of the complex argument.
NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.conj.html
| inArray |
Return the complex conjugate of the complex argument.
NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.conj.html
| inValue |
| NdArray< bool > nc::contains | ( | const NdArray< dtype > & | inArray, |
| dtype | inValue, | ||
| Axis | inAxis = Axis::NONE |
||
| ) |
returns whether or not a value is included the array
| inArray | |
| inValue | |
| inAxis | (Optional, default NONE) |
Return an array copy of the given object.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.copy.html
| inArray |
| 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
| inArray1 | |
| inArray2 |
| 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
| inDestArray | |
| inSrcArray |
Return Pearson product-moment correlation coefficients.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.corrcoef.html
| x | A 1-D or 2-D array containing multiple variables and observations. Each row of x represents a variable, and each column a single observation of all those variables. |
Cosine element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cos.html
| inArray |
Cosine
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cos.html
| inValue |
Hyperbolic Cosine element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cosh.html
| inArray |
Hyperbolic Cosine.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cosh.html
| inValue |
Counts the number of non-zero values in the array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.count_nonzero.html
| inArray | |
| inAxis | (Optional, default NONE) |
Estimate a covariance matrix.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.cov.html
| x | A 1-D or 2-D array containing multiple variables and observations. Each row of x represents a variable, and each column a single observation of all those variables. |
| bias | Default normalization (false) is by (N - 1), where N is the number of observations given (unbiased estimate). If bias is True, then normalization is by N. |
Estimate an inverse covariance matrix, aka the concentration matrix
| x | A 1-D or 2-D array containing multiple variables and observations. Each row of x represents a variable, and each column a single observation of all those variables. |
| bias | Default normalization (false) is by (N - 1), where N is the number of observations given (unbiased estimate). If bias is True, then normalization is by N. |
| 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
| inArray1 | |
| inArray2 | |
| inAxis | (Optional, default NONE) |
Cubes the input
| inValue |
Return the cumulative product of elements along a given axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cumprod.html
| inArray | |
| inAxis | (Optional, default NONE) |
Return the cumulative sum of the elements along a given axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.cumsum.html
| inArray | |
| inAxis | (Optional, default NONE) |
Convert angles from degrees to radians.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.deg2rad.html
| inArray |
Convert angles from degrees to radians.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.deg2rad.html
| inValue |
Convert angles from degrees to radians.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.degrees.html
| inArray |
Convert angles from degrees to radians.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.degrees.html
| inValue |
| NdArray< dtype > nc::deleteIndices | ( | const NdArray< dtype > & | inArray, |
| const Indices & | inIndices, | ||
| Axis | inAxis = Axis::NONE |
||
| ) |
Return a new array with sub-arrays along an axis deleted.
| inArray | |
| inIndices | |
| inAxis | (Optional, default NONE) if NONE the indices will be applied to the flattened array |
| NdArray< dtype > nc::deleteIndices | ( | const NdArray< dtype > & | inArray, |
| int32 | inIndex, | ||
| Axis | inAxis = Axis::NONE |
||
| ) |
Return a new array with sub-arrays along an axis deleted.
| inArray | |
| inIndex | |
| inAxis | (Optional, default NONE) if none the indices will be applied to the flattened array |
| NdArray< dtype > nc::deleteIndices | ( | const NdArray< dtype > & | inArray, |
| Slice | inIndicesSlice, | ||
| Axis | inAxis = Axis::NONE |
||
| ) |
Return a new array with sub-arrays along an axis deleted.
| inArray | |
| inIndicesSlice | |
| inAxis | (Optional, default NONE) if none the indices will be applied to the flattened array |
Extract a diagonal or construct a diagonal array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.diag.html
| inArray | |
| k | Diagonal in question. The default is 0. Use k>0 for diagonals above the main diagonal, and k<0 for diagonals below the main diagonal. |
Create a two-dimensional array with the flattened input as a diagonal.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.diagflat.html
| inArray | |
| k | Diagonal to set; 0, the default, corresponds to the �main� diagonal, a positive (negative) k giving the number of the diagonal above (below) the main. |
| 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
| inArray | |
| inOffset | (Defaults to 0) |
| inAxis | (Optional, default ROW) axis the offset is applied to |
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
| inArray | |
| inAxis | (Optional, default NONE) |
Return the indices of the bins to which each value in input array belongs.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.digitize.html
| x | Input array to be binned. |
| bins | Array of bins. |
| 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
| inArray | |
| value |
divide arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.divide.html
| inArray | |
| value |
| 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
| inArray1 | |
| inArray2 |
| 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
| inArray1 | |
| inArray2 |
| 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
| inArray | |
| value |
| 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
| inArray1 | |
| inArray2 |
| 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
| value | |
| inArray |
divide arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.divide.html
| value | |
| inArray |
| 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
| value | |
| inArray |
| std::pair< NdArray< dtype >, NdArray< dtype > > nc::divmod | ( | const NdArray< dtype > & | inArray1, |
| const NdArray< dtype > & | inArray2 | ||
| ) |
Return element-wise quotient and remainder simultaneously along the specified axis.
NumPy Reference: https://numpy.org/doc/2.3/reference/generated/numpy.divmod.html#numpy-divmod
| inArray1 | |
| inArray2 |
Dot product of two arrays.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.dot.html
| inArray1 | |
| inArray2 |
| 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
| inArray1 | |
| inArray2 |
| 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
| inArray1 | |
| inArray2 |
Dump a binary file of the array to the specified file. The array can be read back with or NC::load.
| inArray | |
| inFilename |
Return a new array of given shape and type, without initializing entries.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.empty.html
| 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
| inNumRows | |
| inNumCols |
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
| inArray |
Return the endianess of the array values.
| inArray |
Return (x1 == x2) element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.equal.html
| inArray1 | |
| inArray2 |
Calculate the exponential of all elements in the input array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.exp.html
| inArray |
Calculate the exponential of the input value.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.exp.html
| inValue |
Calculate 2**p for all p in the input array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.exp2.html
| inArray |
Calculate 2**p for all p in the input value.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.exp2.html
| inValue |
Calculate exp(x) - 1 for all elements in the array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.expm1.html
| inArray |
Calculate exp(x) - 1 for the input value.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.expm1.html
| inValue |
Return the elements of an array that satisfy some condition.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.extract.html
| condition | An array whose nonzero or True entries indicate the elements of arr to extract. |
| arr | Input array of the same size as condition |
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
| inShape | |
| inK | Index of the diagonal: 0 (the default) refers to the main diagonal, a positive value refers to an upper diagonal, and a negative value to a lower diagonal. |
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
| inN | number of rows and columns (N) |
| inK | Index of the diagonal: 0 (the default) refers to the main diagonal, a positive value refers to an upper diagonal, and a negative value to a lower diagonal. |
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
| inN | number of rows (N) |
| inM | number of columns (M) |
| inK | Index of the diagonal: 0 (the default) refers to the main diagonal, a positive value refers to an upper diagonal, and a negative value to a lower diagonal. |
Fill the main diagonal of the given array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fill_diagonal.html
| inArray | |
| inValue |
|
inline |
Find flat indices of nonzero elements.
| mask | the mask to apply to the array |
| n | the first n indices to return (optional, default all) |
Find duplication in a array
Return an array of duplicated elements
NumPy Reference: https://numpy.org/doc/stable//reference/generated/numpy.rec.find_duplicate.html
| inArray |
| NdArray< std::complex< dtype > > nc::find_duplicates | ( | const NdArray< std::complex< dtype > > & | inArray | ) |
Find duplication in a array
Return an array of duplicated elements
NumPy Reference: https://numpy.org/doc/stable//reference/generated/numpy.rec.find_duplicate.html
| inArray |
Round to nearest integer towards zero.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fix.html
| inArray |
Round to nearest integer towards zero.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fix.html
| inValue |
Return indices that are non-zero in the flattened version of a.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.flatnonzero.html
| inArray |
Reverse the order of elements in an array along the given axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.flip.html
| inArray | |
| inAxis |
Flip array in the left/right direction.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fliplr.html
| inArray |
Flip array in the up/down direction.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.flipud.html
| inArray |
Return the floor of the input, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.floor.html
| inArray |
Return the floor of the input.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.floor.html
| inValue |
| 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
| inArray1 | |
| 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
| inValue1 | |
| inValue2 |
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
| inScalar | |
| inArray |
Element-wise maximum of array elements.
Compare two arrays and returns a new array containing the element - wise maxima
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fmax.html
| inArray | |
| inScalar |
Element-wise maximum of array elements.
Compare two arrays and returns a new array containing the element - wise maxima
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fmax.html
| inArray1 | |
| inArray2 |
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
| inValue1 | |
| inValue2 |
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
| inScalar | |
| inArray |
Element-wise minimum of array elements.
Compare two arrays and returns a new array containing the element - wise minima
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fmin.html
| inArray | |
| inScalar |
Element-wise minimum of array elements.
Compare two arrays and returns a new array containing the element - wise minima
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fmin.html
| inArray1 | |
| inArray2 |
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
| inValue1 | |
| inValue2 |
Return the element-wise remainder of division.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fmod.html
| inArray1 | |
| inArray2 |
Return the remainder of division.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fmod.html
| inValue1 | |
| inValue2 |
Interpret a buffer as a 1-dimensional array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.frombuffer.html
| inBufferPtr | |
| inNumBytes |
Construct an array from data in a binary file.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fromfile.html
| inFilename |
Construct an array from data in a text file.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fromfile.html
| inFilename | |
| inSep | Delimiter separator between values in the file |
| NdArray< dtype > nc::fromfunction | ( | const std::function< dtype(typename NdArray< dtype >::size_type)> | func, |
| typename NdArray< dtype >::size_type | size | ||
| ) |
Construct an array by executing a function over each coordinate. The resulting array therefore has a value fn(x) at coordinate(x).
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.fromfunction.html
| func | callable that accepts an integer coordinate and returns type T |
| size | the size of the 1d array to create |
| NdArray< dtype > nc::fromfunction | ( | const std::function< dtype(typename NdArray< dtype >::size_type, typename NdArray< dtype >::size_type)> | func, |
| Shape | shape | ||
| ) |
Construct an array by executing a function over each coordinate. The resulting array therefore has a value fn(x, y) at coordinate(x, y).
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.fromfunction.html
| func | callable that accepts an integer coordinate and returns type T |
| shape | the shape of the array to create |
Create a new 1-dimensional array from an iterable object.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fromiter.html
| inBegin | |
| inEnd |
Construct an array from data in a string
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.fromstring.html
| inStr | |
| inSep | Delimiter separator between values in the string |
Return a new array of given shape and type, filled with inFillValue
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.full.html
| inShape | |
| 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
| inNumRows | |
| inNumCols | |
| 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
| inSquareSize | |
| 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
| inArray | |
| inFillValue |
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
| inArray |
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
| inValue1 | |
| inValue2 |
| NdArray< double > nc::geomspace | ( | dtype | start, |
| dtype | stop, | ||
| uint32 | num = 50, |
||
| EndPoint | endPoint = EndPoint::YES |
||
| ) |
Return numbers spaced evenly on a log scale (a geometric progression).
This is similar to logspace, but with endpoints specified directly. Each output sample is a constant multiple of the previous.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.geomspace.html
| start | the starting value of a sequence |
| stop | The final value of the sequence, unless endpoint is False. In that case, num + 1 values are spaced over the interval in log-space, of which all but the last (a sequence of length num) are returned. |
| num | Number of samples to generate. Default 50. |
| endPoint | If true, stop is the last sample. Otherwide,it is not included. Default is true. |
Return the gradient of the array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.gradient.html
| inArray | |
| inAxis | (default ROW) |
| 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
| inArray | |
| inAxis | (default ROW) |
| 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
| inArray1 | |
| inArray2 |
| 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
| inArray1 | |
| inArray2 |
Return the Hamming window.
The Hamming window is a taper formed by using a weighted cosine.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.hamming.html
| m | Number of points in the output window. If zero or less, an empty array is returned. |
Return the Hamming window.
The Hanning window is a taper formed by using a weighted cosine.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.hanning.html
| m | Number of points in the output window. If zero or less, an empty array is returned. |
| 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
| inArray | |
| inBinEdges | monotonically increasing array of bin edges, including the rightmost edge, allowing for non-uniform bin widths. |
| 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
| inArray | |
| inNumBins( | default 10) |
| std::vector< NdArray< dtype > > nc::hsplit | ( | const NdArray< dtype > & | inArray, |
| const Indices & | indices | ||
| ) |
Split an array into multiple sub-arrays horizontal (column-wise).
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.hsplit.html
| inArray | |
| indices | the indices to split |
Stack arrays in sequence horizontally (column wise).
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.hstack.html
| inArrayList | {list} of arrays to stack |
Stack arrays in sequence horizontally (column wise).
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.hstack.html
| inArrayList | {list} of arrays to stack |
| 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
| inArray1 | |
| inArray2 |
| NdArray< double > nc::hypot | ( | const NdArray< dtype > & | inArray1, |
| const NdArray< dtype > & | inArray2, | ||
| const NdArray< dtype > & | inArray3 | ||
| ) |
Given the "legs" of a right triangle, return its hypotenuse.
Equivalent to sqrt(x1**2 + x2**2), element - wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.hypot.html
| inArray1 | |
| inArray2 | |
| inArray3 |
Given the "legs" of a right triangle, return its hypotenuse.
Equivalent to sqrt(x1**2 + x2**2), element - wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.hypot.html
| inValue1 | |
| inValue2 |
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
| inValue1 | |
| inValue2 | |
| inValue3 |
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
| inSquareSize |
Return the imaginary part of the complex argument.
NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.imag.html
| inArray |
Return the imaginar part of the complex argument.
NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.imag.html
| inValue |
Inner product of two 1-D arrays.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.inner.html
| a | array 1 |
| b | array 2 |
| NdArray< dtype > nc::insert | ( | const NdArray< dtype > & | arr, |
| const Indices & | indices, | ||
| const dtype & | value, | ||
| Axis | axis = Axis::NONE |
||
| ) |
Insert values along the given axis before the given indices.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.insert.html
| arr | input array. |
| indices | indices to insert the values before |
| value | value to insert |
| axis | axis along which to insert values |
| NdArray< dtype > nc::insert | ( | const NdArray< dtype > & | arr, |
| const Indices & | indices, | ||
| const NdArray< dtype > & | values, | ||
| Axis | axis = Axis::NONE |
||
| ) |
Insert values along the given axis before the given indices.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.insert.html
| arr | input array. |
| indices | indices to insert the values before |
| values | values to insert |
| axis | axis along which to insert values |
Insert values before the given indices.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.insert.html
| arr | input array. |
| index | index to insert the value before in the flattened |
| value | value to insert |
| NdArray< dtype > nc::insert | ( | const NdArray< dtype > & | arr, |
| int32 | index, | ||
| const dtype & | value, | ||
| Axis | axis | ||
| ) |
Insert values along the given axis before the given indices.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.insert.html
| arr | input array. |
| index | index to insert the values before |
| value | value to insert |
| axis | axis along which to insert values |
| NdArray< dtype > nc::insert | ( | const NdArray< dtype > & | arr, |
| int32 | index, | ||
| const NdArray< dtype > & | values | ||
| ) |
Insert values before the given indices.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.insert.html
| arr | input array. |
| index | index to insert the values before in the flattened |
| values | value to insert |
| NdArray< dtype > nc::insert | ( | const NdArray< dtype > & | arr, |
| int32 | index, | ||
| const NdArray< dtype > & | values, | ||
| Axis | axis | ||
| ) |
Insert values along the given axis before the given indices.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.insert.html
| arr | input array. |
| index | index to insert the values before |
| values | values to insert |
| axis | axis along which to insert values |
| NdArray< dtype > nc::insert | ( | const NdArray< dtype > & | arr, |
| Slice | slice, | ||
| const dtype & | value, | ||
| Axis | axis = Axis::NONE |
||
| ) |
Insert values along the given axis before the given indices.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.insert.html
| arr | input array. |
| slice | slice to insert the values before |
| value | values to insert |
| axis | axis along which to insert values |
| NdArray< dtype > nc::insert | ( | const NdArray< dtype > & | arr, |
| Slice | slice, | ||
| const NdArray< dtype > & | values, | ||
| Axis | axis = Axis::NONE |
||
| ) |
Insert values along the given axis before the given indices.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.insert.html
| arr | input array. |
| slice | slice to insert the values before |
| values | values to insert |
| axis | axis along which to insert values |
| 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
| inX | The x-coordinates at which to evaluate the interpolated values. |
| inXp | The x-coordinates of the data points, must be increasing. Otherwise, xp is internally sorted. |
| inFp | The y-coordinates of the data points, same length as inXp. |
Returns the linear interpolation between two points
| inValue1 | |
| inValue2 | |
| inPercent |
| 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
| inArray1 | |
| inArray2 |
Compute bit-wise inversion, or bit-wise NOT, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.invert.html
| inArray |
| 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
| inArray1 | |
| inArray2 | |
| inRtol | relative tolerance (default 1e-5) |
| inAtol | absolute tolerance (default 1e-9) |
Test element-wise for inf and return result as a boolean array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isinf.html
| inArray |
Test for inf and return result as a boolean.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isinf.html
| inValue |
Test element-wise for NaN and return result as a boolean array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isnan.html
| inArray |
Test for NaN and return result as a boolean.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isnan.html
| inValue |
Test element-wise for negative inf and return result as a boolean array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isneginf.html
| inArray |
Test for negative inf and return result as a boolean.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isneginf.html
| inValue |
Test element-wise for positive inf and return result as a boolean array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isposinf.html
| inArray |
Test for positive inf and return result as a boolean.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.isposinf.html
| inValue |
The Kaiser window is a taper formed by using a Bessel function.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.kaiser.html
| m | Number of points in the output window. If zero or less, an empty array is returned. |
| beta | shape parameter for the window |
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
| inArray |
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
| inValue1 | |
| inValue2 |
Returns x1 * 2^x2, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ldexp.html
| inArray1 | |
| inArray2 |
Returns x1 * 2^x2.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ldexp.html
| inValue1 | |
| inValue2 |
Shift the bits of an integer to the left.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.left_shift.html
| inArray | |
| inNumBits |
Return the truth value of (x1 < x2) element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.less.html
| inArray1 | |
| inArray2 |
| 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
| inArray1 | |
| inArray2 |
| NdArray< dtype > nc::linspace | ( | dtype | inStart, |
| dtype | inStop, | ||
| uint32 | inNum = 50, |
||
| EndPoint | endPoint = EndPoint::YES |
||
| ) |
Return evenly spaced numbers over a specified interval.
Returns num evenly spaced samples, calculated over the interval[start, stop].
The endpoint of the interval can optionally be excluded.
Mostly only usefull if called with a floating point type for the template argument.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.linspace.html
| inStart | |
| inStop | |
| inNum | number of points (default = 50) |
| endPoint | include endPoint (default = true) |
loads a .bin file from the dump() method into an NdArray
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.load.html
| inFilename |
Natural logarithm, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.log.html
| inArray |
Natural logarithm.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.log.html
| inValue |
Return the base 10 logarithm of the input array, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.log10.html
| inArray |
Return the base 10 logarithm of the input array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.log10.html
| inValue |
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
| inArray |
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
| inValue |
Base-2 logarithm of x.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.log2.html
| inArray |
Base-2 logarithm of x.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.log2.html
| inValue |
Logarithm of the sum of exponentiations of the inputs, element-wise.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.logaddexp.html
| x1 | |
| x2 |
Logarithm of the sum of exponentiations of the inputs.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.logaddexp.html
| x1 | |
| x2 |
Logarithm of the sum of exponentiations of the inputs, element-wise.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.logaddexp.html
| x1 | |
| x2 |
Logarithm of the sum of exponentiations of the inputs.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.logaddexp.html
| x1 | |
| x2 |
Logarithm of an arbitrary base
| inValue | |
| inBase | the logorithm base |
| 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
| inArray1 | |
| inArray2 |
Compute the truth value of NOT x element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.logical_not.html
| inArray |
| 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
| inArray1 | |
| inArray2 |
| 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
| inArray1 | |
| inArray2 |
| NdArray< double > nc::logspace | ( | dtype | start, |
| dtype | stop, | ||
| uint32 | num = 50, |
||
| EndPoint | endPoint = EndPoint::YES, |
||
| double | base = 10. |
||
| ) |
Return numbers spaced evenly on a log scale.
This is similar to logspace, but with endpoints specified directly. Each output sample is a constant multiple of the previous.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.logspace.html
| start | the starting value of a sequence |
| stop | The final value of the sequence, unless endpoint is False. In that case, num + 1 values are spaced over the interval in log-space, of which all but the last (a sequence of length num) are returned. |
| num | Number of samples to generate. Default 50. |
| endPoint | If true, stop is the last sample. Otherwise,it is not included. Default is true. |
| base | The base of the log space. The step size between the elements in ln(samples) / ln(base) |
| 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
| inArray1 | |
| inArray2 |
| 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
| inArray1 | |
| inArray2 |
| 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
| inArray1 | |
| inArray2 |
Return the maximum of an array or maximum along an axis.
| inArray | |
| inAxis | (Optional, default NONE) |
Element-wise maximum of array elements.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.maximum.html
| inScalar | |
| inArray |
Element-wise maximum of array elements.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.maximum.html
| inArray | |
| inScalar |
| 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
| inArray1 | |
| inArray2 |
Compute the mean along the specified axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.mean.html
| inArray | |
| inAxis | (Optional, default NONE) |
| 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
| inArray | |
| inAxis | (Optional, default NONE) |
Compute the median along the specified axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.median.html
| inArray | |
| inAxis | (Optional, default NONE) |
| std::pair< NdArray< dtype >, NdArray< dtype > > nc::meshgrid | ( | const NdArray< dtype > & | inICoords, |
| const NdArray< dtype > & | inJCoords | ||
| ) |
Return coordinate matrices from coordinate vectors. Make 2D coordinate arrays for vectorized evaluations of 2D scalar vector fields over 2D grids, given one - dimensional coordinate arrays x1, x2, ..., xn. If input arrays are not one dimensional they will be flattened.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.meshgrid.html
| inICoords | |
| inJCoords |
| std::pair< NdArray< dtype >, NdArray< dtype > > nc::meshgrid | ( | const Slice & | inSlice1, |
| const Slice & | inSlice2 | ||
| ) |
Return coordinate matrices from coordinate vectors. Make 2D coordinate arrays for vectorized evaluations of 2D scalar vector fields over 2D grids, given one - dimensional coordinate arrays x1, x2, ..., xn.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.meshgrid.html
| inSlice1 | |
| inSlice2 |
Return the minimum of an array or minimum along an axis.
| inArray | |
| inAxis | (Optional, default NONE) |
Element-wise minimum of array elements.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.minimum.html
| inScalar | |
| inArray |
Element-wise minimum of array elements.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.minimum.html
| inArray | |
| inScalar |
| 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
| inArray1 | |
| inArray2 |
Return element-wise remainder of division.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.mod.html
| inArray1 | |
| inArray2 |
Compute the mode along the specified axis.
NumPy Reference: https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.mode.html
| inArray | |
| inAxis | (Optional, default NONE) |
| NdArray< std::complex< dtype > > nc::mode | ( | const NdArray< std::complex< dtype > > & | inArray, |
| Axis | inAxis = Axis::NONE |
||
| ) |
Compute the mode along the specified axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.mode.html
| inArray | |
| inAxis | (Optional, default NONE) |
| 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
| inArray | |
| value |
multiply arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.multiply.html
| inArray | |
| value |
| 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
| inArray1 | |
| inArray2 |
| 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
| inArray1 | |
| inArray2 |
| 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
| inArray | |
| value |
| 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
| inArray1 | |
| inArray2 |
| 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
| value | |
| inArray |
multiply arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.multiply.html
| value | |
| inArray |
| 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
| value | |
| inArray |
| NdArray< dtype > nc::nan_to_num | ( | NdArray< dtype > | inArray, |
| dtype | nan = static_cast<dtype>(0.), |
||
| dtype | posInf = DtypeInfo<dtype>::max(), |
||
| dtype | negInf = DtypeInfo<dtype>::min() |
||
| ) |
Replace NaN with zero and infinity with large finite numbers (default behaviour) or with the numbers defined by the user using the nan, posinf and/or neginf keywords.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.nan_to_num.html
| inArray | |
| nan | value to be used to fill NaN values, default 0 |
| posInf | value to be used to fill positive infinity values, default a very large number |
| negInf | value to be used to fill negative infinity values, default a very large negative number |
Returns the indices of the maximum values along an axis ignoring NaNs.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanargmax.html
| inArray | |
| inAxis | (Optional, default 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
| inArray | |
| inAxis | (Optional, default 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
| inArray | |
| inAxis | (Optional, default 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
| inArray | |
| inAxis | (Optional, default 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
| inArray | |
| inAxis | (Optional, default NONE) |
Compute the mean along the specified axis ignoring NaNs.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanmean.html
| inArray | |
| inAxis | (Optional, default NONE) |
Compute the median along the specified axis ignoring NaNs.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanmedian.html
| inArray | |
| inAxis | (Optional, default 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
| inArray | |
| inAxis | (Optional, default NONE) |
| NdArray< double > nc::nanpercentile | ( | const NdArray< dtype > & | inArray, |
| double | inPercentile, | ||
| Axis | inAxis = Axis::NONE, |
||
| InterpolationMethod | inInterpMethod = InterpolationMethod::LINEAR |
||
| ) |
Compute the qth percentile of the data along the specified axis, while ignoring nan values.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanpercentile.html
| inArray | |
| inPercentile | |
| inAxis | (Optional, default NONE) |
| inInterpMethod | (default linear) choices = ['linear','lower','higher','nearest','midpoint'] |
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
| inArray | |
| inAxis | (Optional, default NONE) |
Return a new array of given shape and type, filled with nans. Only really works for dtype = float/double
| inShape |
Return a new array of given shape and type, filled with nans. Only really works for dtype = float/double
| inNumRows | |
| inNumCols |
Return a new array of given shape and type, filled with nans. Only really works for dtype = float/double
| inSquareSize |
Compute the standard deviation along the specified axis, while ignoring NaNs.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanstd.html
| inArray | |
| inAxis | (Optional, default 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
| inArray | |
| inAxis | (Optional, default NONE) |
Compute the variance along the specified axis, while ignoring NaNs.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.nanvar.html
| inArray | |
| inAxis | (Optional, default NONE) |
Returns the number of bytes held by the array
| inArray |
Numerical negative, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.negative.html
| inArray |
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...
| inArray | |
| 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...
| inValue | |
| inEndianess |
Test whether no array elements along a given axis evaluate to True.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.all.html
| inArray | |
| inAxis | (Optional, default NONE) |
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
| inArray |
| 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
| inArray1 | |
| inArray2 |
Return the nth-root of an value.
| inValue | |
| inRoot |
Return a new array of given shape and type, filled with ones.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ones.html
| 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
| inNumRows | |
| 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
| inSquareSize |
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
| inArray |
Non Equality operator for DateTime.
| lhs | the left hand side value |
| rhs | the right hand side value |
Returns an array of booleans of element wise comparison of two arrays
| lhs | |
| rhs |
Returns an array of booleans of element wise comparison an array and a scalar
| lhs | |
| inValue |
Returns an array of booleans of element wise comparison an array and a scalar
| inValue | |
| inArray |
Vector mulitplication (dot product)
| lhs | |
| rhs |
|
inlinenoexcept |
Vector mulitplication (dot product)
| lhs | |
| rhs |
|
inlinenoexcept |
|
inlinenoexcept |
|
inlinenoexcept |
|
inlinenoexcept |
|
inlinenoexcept |
|
inlinenoexcept |
|
inlinenoexcept |
|
noexcept |
Iterator addition operator
| offset | |
| next |
|
noexcept |
Iterator addition operator
| offset | |
| next |
|
noexcept |
Iterator addition operator
| offset | |
| next |
|
noexcept |
prefix incraments the elements of an array
Subtraction operator.
| lhs | the left hand side value |
| rhs | the right hand side value |
Negative Operator
|
inlinenoexcept |
|
inlinenoexcept |
Returns the negative vector
|
inlinenoexcept |
|
inlinenoexcept |
Returns the negative vector
|
inlinenoexcept |
|
inlinenoexcept |
prefix decrements the elements of an array
|
inlinenoexcept |
|
inlinenoexcept |
Less than operator.
| lhs | the left hand side value |
| rhs | the right hand side value |
Returns an array of booleans of element wise comparison of two arrays
| lhs | |
| rhs |
Returns an array of booleans of element wise comparison the array and a scalar
| lhs | |
| inValue |
|
noexcept |
Less than operator for std::complex<T>
| lhs | |
| rhs |
Returns an array of booleans of element wise comparison the array and a scalar
| inValue | |
| inArray |
| std::ostream & nc::operator<< | ( | std::ostream & | inOStream, |
| const NdArray< dtype > & | inArray | ||
| ) |
|
inlinenoexcept |
Stream operator.
| os | the output stream |
| datetime | the datetime object |
|
inline |
Output stream operator for the TimePoint type.
| os | the output stream |
| timepoint | the TimePoint |
|
inline |
Output stream operator for the Duration type.
| os | the output stream |
| duration | the Duration |
|
inline |
stream output operator
| stream | |
| vec |
|
inline |
stream output operator
| stream | |
| vec |
Less than or equal operator.
| lhs | the left hand side value |
| rhs | the right hand side value |
Returns an array of booleans of element wise comparison of two arrays
| lhs | |
| rhs |
Returns an array of booleans of element wise comparison the array and a scalar
| lhs | |
| inValue |
|
noexcept |
Less than or equal operator for std::complex<T>
| lhs | |
| rhs |
Returns an array of booleans of element wise comparison the array and a scalar
| inValue | |
| inArray |
Equality operator for DateTime.
| lhs | the left hand side value |
| rhs | the right hand side value |
Returns an array of booleans of element wise comparison of two arrays
| lhs | |
| rhs |
Returns an array of booleans of element wise comparison an array and a scalar
| lhs | |
| inValue |
Returns an array of booleans of element wise comparison an array and a scalar
| inValue | |
| inArray |
Greater than operator.
| lhs | the left hand side value |
| rhs | the right hand side value |
Returns an array of booleans of element wise comparison of two arrays
| lhs | |
| rhs |
Returns an array of booleans of element wise comparison the array and a scalar
| lhs | |
| inValue |
|
noexcept |
Greater than operator for std::complex<T>
| lhs | |
| rhs |
Returns an array of booleans of element wise comparison the array and a scalar
| inValue | |
| inArray |
Greater than or equal operator.
| lhs | the left hand side value |
| rhs | the right hand side value |
Returns an array of booleans of element wise comparison of two arrays
| lhs | |
| rhs |
Returns an array of booleans of element wise comparison the array and a scalar
| lhs | |
| inValue |
|
noexcept |
Greater than or equal operator for std::complex<T>
| lhs | |
| rhs |
Returns an array of booleans of element wise comparison the array and a scalar
| inValue | |
| inArray |
The outer product of two vectors. Inputs are flattened if not already 1-dimensional.
NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.outer.html
| inArray1 | |
| inArray2 |
| NdArray< uint8 > nc::packbitsBigEndian | ( | const NdArray< dtype > & | a, |
| Axis | axis = Axis::NONE |
||
| ) |
Packs the elements of a binary-valued array into bits in a uint8 array.
Numpy Reference: https://numpy.org/doc/stable/reference/generated/numpy.packbits.html
| a | An array of integers or booleans whose elements should be packed to bits. |
| axis | The dimension over which bit-packing is done. None implies packing the flattened array. |
| NdArray< uint8 > nc::packbitsLittleEndian | ( | const NdArray< dtype > & | a, |
| Axis | axis = Axis::NONE |
||
| ) |
Packs the elements of a binary-valued array into bits in a uint8 array.
Numpy Reference: https://numpy.org/doc/stable/reference/generated/numpy.packbits.html
| a | An array of integers or booleans whose elements should be packed to bits. |
| axis | The dimension over which bit-packing is done. None implies packing the flattened array. |
Pads an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.pad.html
| inArray | |
| inPadWidth | |
| inPadValue |
| NdArray< dtype > nc::partition | ( | const NdArray< dtype > & | inArray, |
| uint32 | inKth, | ||
| Axis | inAxis = Axis::NONE |
||
| ) |
Rearranges the elements in the array in such a way that value of the element in kth position is in the position it would be in a sorted array. All elements smaller than the kth element are moved before this element and all equal or greater are moved behind it. The ordering of the elements in the two partitions is undefined.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.partition.html
| inArray | |
| inKth | kth element |
| inAxis | (Optional, default NONE) |
| NdArray< double > nc::percentile | ( | const NdArray< dtype > & | inArray, |
| double | inPercentile, | ||
| Axis | inAxis = Axis::NONE, |
||
| InterpolationMethod | inInterpMethod = InterpolationMethod::LINEAR |
||
| ) |
Compute the qth percentile of the data along the specified axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.percentile.html
| inArray | |
| inPercentile | percentile must be in the range [0, 100] |
| inAxis | (Optional, default NONE) |
| inInterpMethod | (Optional) interpolation method linear: i + (j - i) * fraction, where fraction is the fractional part of the index surrounded by i and j. lower : i. higher : j. nearest : i or j, whichever is nearest. midpoint : (i + j) / 2. |
| void nc::place | ( | NdArray< dtype > & | arr, |
| const NdArray< bool > & | mask, | ||
| const NdArray< dtype > & | vals | ||
| ) |
Change elements of an array based on conditional and input values.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.place.html
| arr | Array to put data into. |
| mask | Boolean mask array. Must have the same size as arr |
| vals | Values to put into a. Only the first N elements are used, where N is the number of True values in mask. If vals is smaller than N, it will be repeated. |
Returns a complex number with magnitude r and phase angle theta.
| magnitude | |
| phaseAngle |
Returns a complex number with magnitude r and phase angle theta.
| magnitude | |
| phaseAngle |
| NdArray< dtype > nc::power | ( | const NdArray< dtype > & | inArray, |
| const NdArray< uint8 > & | inExponents | ||
| ) |
Raises the elements of the array to the input integer powers
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.power.html
| inArray | |
| inExponents |
Raises the elements of the array to the input integer power
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.power.html
| inArray | |
| inExponent |
Raises the elements of the array to the input integer power
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.power.html
| inValue | |
| inExponent |
Raises the elements of the array to the input floating point powers
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.power.html
| inArray | |
| inExponents |
Raises the elements of the array to the input floating point power
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.power.html
| inArray | |
| inExponent |
Raises the elements of the array to the input floating point power
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.power.html
| inValue | |
| inExponent |
Prints the array to the console.
| inArray |
Return the product of array elements over a given axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.prod.html
| inArray | |
| inAxis | (Optional, default NONE) |
Returns the projection of the complex number z onto the Riemann sphere.
| inArray |
Returns the projection of the complex number z onto the Riemann sphere.
| inValue |
Range of values (maximum - minimum) along an axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ptp.html
| inArray | |
| inAxis | (Optional, default NONE) |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const Indices & | inIndices, | ||
| const dtype & | inValue | ||
| ) |
Set a.flat[n] = values for all n in indices.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inIndices | |
| inValue |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const Indices & | inIndices, | ||
| const NdArray< dtype > & | inValues | ||
| ) |
Set a.flat[n] = values[n] for all n in indices.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inIndices | |
| inValues |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const Indices & | inRowIndices, | ||
| int32 | inColIndex, | ||
| const dtype & | inValue | ||
| ) |
Set the slice indices to the input value.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowIndices | |
| inColIndex | |
| inValue |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const Indices & | inRowIndices, | ||
| int32 | inColIndex, | ||
| const NdArray< dtype > & | inValues | ||
| ) |
Set the slice indices to the input values.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowIndices | |
| inColIndex | |
| inValues |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const RowIndices & | inRowIndices, | ||
| const ColIndices & | inColIndices, | ||
| const dtype & | inValue | ||
| ) |
Set the slice indices to the input value.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowIndices | |
| inColIndices | |
| inValue |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const RowIndices & | inRowIndices, | ||
| const ColIndices & | inColIndices, | ||
| const NdArray< dtype > & | inValues | ||
| ) |
Set the slice indices to the input values.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowIndices | |
| inColIndices | |
| inValues |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const RowIndices & | inRowIndices, | ||
| const Slice & | inColSlice, | ||
| const dtype & | inValue | ||
| ) |
Set the slice indices to the input value.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowIndices | |
| inColSlice | |
| inValue |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const RowIndices & | inRowIndices, | ||
| const Slice & | inColSlice, | ||
| const NdArray< dtype > & | inValues | ||
| ) |
Set the slice indices to the input values.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowIndices | |
| inColSlice | |
| inValues |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const Slice & | inRowSlice, | ||
| const ColIndices & | inColIndices, | ||
| const dtype & | inValue | ||
| ) |
Set the slice indices to the input value.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowSlice | |
| inColIndices | |
| inValue |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const Slice & | inRowSlice, | ||
| const ColIndices & | inColIndices, | ||
| const NdArray< dtype > & | inValues | ||
| ) |
Set the slice indices to the input values.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowSlice | |
| inColIndices | |
| inValues |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const Slice & | inRowSlice, | ||
| const Slice & | inColSlice, | ||
| const dtype & | inValue | ||
| ) |
Set the slice indices to the input value.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowSlice | |
| inColSlice | |
| inValue |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const Slice & | inRowSlice, | ||
| const Slice & | inColSlice, | ||
| const NdArray< dtype > & | inValues | ||
| ) |
Set the slice indices to the input values.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowSlice | |
| inColSlice | |
| inValues |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const Slice & | inRowSlice, | ||
| int32 | inColIndex, | ||
| const dtype & | inValue | ||
| ) |
Set the slice indices to the input value.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowSlice | |
| inColIndex | |
| inValue |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const Slice & | inRowSlice, | ||
| int32 | inColIndex, | ||
| const NdArray< dtype > & | inValues | ||
| ) |
Set the slice indices to the input values.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowSlice | |
| inColIndex | |
| inValues |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const Slice & | inSlice, | ||
| const dtype & | inValue | ||
| ) |
Set the slice indices to the input value.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inSlice | |
| inValue |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| const Slice & | inSlice, | ||
| const NdArray< dtype > & | inValues | ||
| ) |
Set the slice indices to the input values.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inSlice | |
| inValues |
set the flat index element to the value
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inIndex | |
| inValue |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| int32 | inRow, | ||
| int32 | inCol, | ||
| const dtype & | inValue | ||
| ) |
set the 2D row/col index element to the value
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRow | |
| inCol | |
| inValue |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| int32 | inRowIndex, | ||
| const Indices & | inColIndices, | ||
| const dtype & | inValue | ||
| ) |
Set the slice indices to the input value.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowIndex | |
| inColIndices | |
| inValue |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| int32 | inRowIndex, | ||
| const Indices & | inColIndices, | ||
| const NdArray< dtype > & | inValues | ||
| ) |
Set the slice indices to the input values.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowIndex | |
| inColIndices | |
| inValues |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| int32 | inRowIndex, | ||
| const Slice & | inColSlice, | ||
| const dtype & | inValue | ||
| ) |
Set the slice indices to the input value.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowIndex | |
| inColSlice | |
| inValue |
| NdArray< dtype > & nc::put | ( | NdArray< dtype > & | inArray, |
| int32 | inRowIndex, | ||
| const Slice & | inColSlice, | ||
| const NdArray< dtype > & | inValues | ||
| ) |
Set the slice indices to the input values.
Numpy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.ndarray.put.html
| inArray | |
| inRowIndex | |
| inColSlice | |
| inValues |
| NdArray< dtype > & nc::putmask | ( | NdArray< dtype > & | inArray, |
| const NdArray< bool > & | inMask, | ||
| const NdArray< dtype > & | inValues | ||
| ) |
Changes elements of an array based on conditional and input values.
Sets a.flat[n] = values[n] for each n where mask.flat[n] == True.
If values is not the same size as a and mask then it will repeat.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.putmask.html
| inArray | |
| inMask | |
| inValues |
| NdArray< dtype > & nc::putmask | ( | NdArray< dtype > & | inArray, |
| const NdArray< bool > & | inMask, | ||
| dtype | inValue | ||
| ) |
Changes elements of an array based on conditional and input values.
Sets a.flat[n] = values[n] for each n where mask.flat[n] == True.
If values is not the same size as a and mask then it will repeat.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.putmask.html
| inArray | |
| inMask | |
| inValue |
Convert angles from radians to degrees.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.rad2deg.html
| inArray |
Convert angles from radians to degrees.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.rad2deg.html
| inValue |
Convert angles from degrees to radians.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.radians.html
| inArray |
Convert angles from degrees to radians.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.radians.html
| inValue |
Flattens the array but does not make a copy.
Numpy Reference: https://docs.scipy.org/doc/numpy/reference/generated/numpy.ravel.html
| inArray |
Return the real part of the complex argument.
NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.real.html
| inArray |
Return the real part of the complex argument.
NumPy Reference: https://numpy.org/devdocs/reference/generated/numpy.real.html
| inValue |
Return the reciprocal of the argument, element-wise.
Calculates 1 / x.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.reciprocal.html
| inArray |
| NdArray< std::complex< double > > nc::reciprocal | ( | const NdArray< std::complex< dtype > > & | inArray | ) |
Return the reciprocal of the argument, element-wise.
Calculates 1 / x.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.reciprocal.html
| inArray |
| NdArray< double > nc::remainder | ( | const NdArray< dtype > & | inArray1, |
| const NdArray< dtype > & | inArray2 | ||
| ) |
Return element-wise remainder of division.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.remainder.html
| inArray1 | |
| inArray2 |
Return remainder of division.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.remainder.html
| inValue1 | |
| inValue2 |
Repeat elements of an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.repeat.html
| inArray | |
| inRepeatShape |
| NdArray< dtype > nc::repeat | ( | const NdArray< dtype > & | inArray, |
| uint32 | inNumRows, | ||
| uint32 | inNumCols | ||
| ) |
Repeat elements of an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.repeat.html
| inArray | |
| inNumRows | |
| inNumCols |
Replaces the matching elements of an array with the new value
| inArray | |
| oldValue | the value to replace |
| newValue | the value to replace with |
Gives a new shape to an array without changing its data.
The new shape should be compatible with the original shape. If an single integer, then the result will be a 1-D array of that length. One shape dimension can be -1. In this case, the value is inferred from the length of the array and remaining dimensions.
| inArray | |
| inNewShape |
Gives a new shape to an array without changing its data.
The new shape should be compatible with the original shape. If an single integer, then the result will be a 1-D array of that length. One shape dimension can be -1. In this case, the value is inferred from the length of the array and remaining dimensions.
| inArray | |
| inNumRows | |
| inNumCols |
Gives a new shape to an array without changing its data.
The new shape should be compatible with the original shape. If an single integer, then the result will be a 1-D array of that length. One shape dimension can be -1. In this case, the value is inferred from the length of the array and remaining dimensions.
| inArray | |
| inSize |
Change shape and size of array in-place. All previous data of the array is lost.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.resize.html
| inArray | |
| inNewShape |
| NdArray< dtype > & nc::resizeFast | ( | NdArray< dtype > & | inArray, |
| uint32 | inNumRows, | ||
| uint32 | inNumCols | ||
| ) |
Change shape and size of array in-place. All previous data of the array is lost.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.resize.html
| inArray | |
| inNumRows | |
| inNumCols |
Return a new array with the specified shape. If new shape is larger than old shape then array will be padded with zeros. If new shape is smaller than the old shape then the data will be discarded.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.resize.html
| inArray | |
| inNewShape |
| NdArray< dtype > & nc::resizeSlow | ( | NdArray< dtype > & | inArray, |
| uint32 | inNumRows, | ||
| uint32 | inNumCols | ||
| ) |
Return a new array with the specified shape. If new shape is larger than old shape then array will be padded with zeros. If new shape is smaller than the old shape then the data will be discarded.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.resize.html
| inArray | |
| inNumRows | |
| inNumCols |
Shift the bits of an integer to the right.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.right_shift.html
| inArray | |
| inNumBits |
Round elements of the array to the nearest integer.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.rint.html
| inArray |
Round value to the nearest integer.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.rint.html
| inValue |
Compute the root mean square (RMS) along the specified axis.
| inArray | |
| inAxis | (Optional, default NONE) |
| NdArray< std::complex< double > > nc::rms | ( | const NdArray< std::complex< dtype > > & | inArray, |
| Axis | inAxis = Axis::NONE |
||
| ) |
Compute the root mean square (RMS) along the specified axis.
| inArray | |
| inAxis | (Optional, default NONE) |
| NdArray< dtype > nc::roll | ( | const NdArray< dtype > & | inArray, |
| int32 | inShift, | ||
| Axis | inAxis = Axis::NONE |
||
| ) |
Roll array elements along a given axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.roll.html
| inArray | |
| inShift | (elements to shift, positive means forward, negative means backwards) |
| inAxis | (Optional, default NONE) |
Rotate an array by 90 degrees counter clockwise in the plane.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.rot90.html
| inArray | |
| inK | the number of times to rotate 90 degrees |
Round value to the given number of decimals.
| inValue | |
| inDecimals |
Stack arrays in sequence vertically (row wise).
| inArrayList | {list} of arrays to stack |
Stack arrays in sequence vertically (row wise).
| inArrayList | {list} of arrays to stack |
| NdArray< typename NdArray< dtype >::index_type > nc::searchsorted | ( | const NdArray< dtype > & | inArray, |
| const NdArray< dtype > & | inValues, | ||
| Side | side = Side::LEFT |
||
| ) |
Find indices where elements should be inserted to maintain order. Find the indices into a sorted array a such that, if the corresponding elements in v were inserted before the indices, the order of a would be preserved. Assuming that a is sorted : side returned index i satisfies left a[i - 1] < v <= a[i] right a[i - 1] <= v < a[i]
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.searchsorted.html
| inArray | the input array |
| inValues | values to insert into a |
| side | If ‘left’, the index of the first suitable location found is given. If ‘right’, return the last such index. If there is no suitable index, return either 0 or N (where N is the length of a). |
| NdArray< dtype >::index_type nc::searchsorted | ( | const NdArray< dtype > & | inArray, |
| dtype | inValue, | ||
| Side | side = Side::LEFT |
||
| ) |
Find indices where elements should be inserted to maintain order. Find the indices into a sorted array a such that, if the corresponding elements in v were inserted before the indices, the order of a would be preserved. Assuming that a is sorted : side returned index i satisfies left a[i - 1] < v <= a[i] right a[i - 1] <= v < a[i]
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.searchsorted.html
| inArray | the input array |
| inValue | values to insert into a |
| side | If ‘left’, the index of the first suitable location found is given. If ‘right’, return the last such index. If there is no suitable index, return either 0 or N (where N is the length of a). |
| NdArray< dtype > nc::select | ( | const std::vector< const NdArray< bool > * > & | condVec, |
| const std::vector< const NdArray< dtype > * > & | choiceVec, | ||
| dtype | defaultValue = dtype{ 0 } |
||
| ) |
Return an array drawn from elements in choiceVec, depending on conditions.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.select.html?highlight=select#numpy.select
| condVec | The vector of conditions which determine from which array in choiceVec the output elements are taken. When multiple conditions are satisfied, the first one encountered in choiceVec is used. |
| choiceVec | The vector of array pointers from which the output elements are taken. It has to be of the same length as condVec. |
| defaultValue | The element inserted in output when all conditions evaluate to False |
| NdArray< dtype > nc::select | ( | const std::vector< NdArray< bool > > & | condList, |
| const std::vector< NdArray< dtype > > & | choiceList, | ||
| dtype | defaultValue = dtype{ 0 } |
||
| ) |
Return an array drawn from elements in choiceList, depending on conditions.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.select.html?highlight=select#numpy.select
| condList | The list of conditions which determine from which array in choiceList the output elements are taken. When multiple conditions are satisfied, the first one encountered in choiceList is used. |
| choiceList | The list of array pointers from which the output elements are taken. It has to be of the same length as condVec. |
| defaultValue | The element inserted in output when all conditions evaluate to False |
| NdArray< dtype > nc::setdiff1d | ( | const NdArray< dtype > & | inArray1, |
| const NdArray< dtype > & | inArray2 | ||
| ) |
Find the set difference of two arrays.
Return the sorted, unique values in ar1 that are not in ar2.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.setdiff1d.html
| inArray1 | |
| inArray2 |
Returns an element-wise indication of the sign of a number.
The sign function returns - 1 if x < 0, 0 if x == 0, 1 if x > 0. nan is returned for nan inputs.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sign.html
| inArray |
Returns an element-wise indication of the sign of a number.
The sign function returns - 1 if x < 0, 0 if x == 0, 1 if x > 0. nan is returned for nan inputs.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sign.html
| inValue |
Returns element-wise True where signbit is set (less than zero).
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.signbit.html
| inArray |
Returns element-wise True where signbit is set (less than zero).
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.signbit.html
| inValue |
Trigonometric sine, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sin.html
| inArray |
Trigonometric sine.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sin.html
| inValue |
Return the sinc function.
The sinc function is sin(pi*x) / (pi*x).
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sinc.html
| inArray |
Return the sinc function.
The sinc function is sin(pi*x) / (pi*x).
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sinc.html
| inValue |
Hyperbolic sine, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sinh.html
| inArray |
Hyperbolic sine.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sinh.html
| inValue |
Return the number of elements.
| inArray |
Return a sorted copy of an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sort.html
| inArray | |
| inAxis | (Optional, default NONE) |
| std::vector< NdArray< dtype > > nc::split | ( | const NdArray< dtype > & | inArray, |
| const Indices & | indices, | ||
| Axis | inAxis = Axis::ROW |
||
| ) |
Split an array into multiple sub-arrays as views into array.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.split.html
| inArray | |
| indices | the indices to split |
| inAxis | (Optional, default NONE) |
Return the positive square-root of an array, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sqrt.html
| inArray |
Return the positive square-root of a value.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sqrt.html
| inValue |
Return the square of an array, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.square.html
| inArray |
Return the square of an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.square.html
| inValue |
| NdArray< dtype > nc::stack | ( | std::initializer_list< NdArray< dtype > > | inArrayList, |
| Axis | inAxis = Axis::NONE |
||
| ) |
Compute the variance along the specified axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.stack.html
| inArrayList | {list} of arrays to stack |
| inAxis | axis to stack the input NdArrays |
| NdArray< dtype > nc::stack | ( | std::vector< NdArray< dtype > > | inArrayList, |
| Axis | inAxis = Axis::NONE |
||
| ) |
Compute the variance along the specified axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.stack.html
| inArrayList | {list} of arrays to stack |
| inAxis | axis to stack the input NdArrays |
Compute the standard deviation along the specified axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.std.html
| inArray | |
| inAxis | (Optional, default NONE) |
| NdArray< std::complex< double > > nc::stdev | ( | const NdArray< std::complex< dtype > > & | inArray, |
| Axis | inAxis = Axis::NONE |
||
| ) |
Compute the standard deviation along the specified axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.std.html
| inArray | |
| inAxis | (Optional, default NONE) |
| NdArray< std::complex< dtype > > nc::subtract | ( | const NdArray< dtype > & | inArray, |
| const std::complex< dtype > & | value | ||
| ) |
subtract arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html
| inArray | |
| value |
subtract arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html
| inArray | |
| value |
| NdArray< dtype > nc::subtract | ( | const NdArray< dtype > & | inArray1, |
| const NdArray< dtype > & | inArray2 | ||
| ) |
subtract arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html
| inArray1 | |
| inArray2 |
| NdArray< std::complex< dtype > > nc::subtract | ( | const NdArray< dtype > & | inArray1, |
| const NdArray< std::complex< dtype > > & | inArray2 | ||
| ) |
subtract arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html
| inArray1 | |
| inArray2 |
| NdArray< std::complex< dtype > > nc::subtract | ( | const NdArray< std::complex< dtype > > & | inArray, |
| dtype | value | ||
| ) |
subtract arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html
| inArray | |
| value |
| NdArray< std::complex< dtype > > nc::subtract | ( | const NdArray< std::complex< dtype > > & | inArray1, |
| const NdArray< dtype > & | inArray2 | ||
| ) |
subtract arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html
| inArray1 | |
| inArray2 |
| NdArray< std::complex< dtype > > nc::subtract | ( | const std::complex< dtype > & | value, |
| const NdArray< dtype > & | inArray | ||
| ) |
subtract arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html
| value | |
| inArray |
subtract arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html
| value | |
| inArray |
| NdArray< std::complex< dtype > > nc::subtract | ( | dtype | value, |
| const NdArray< std::complex< dtype > > & | inArray | ||
| ) |
subtract arguments element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.subtract.html
| value | |
| inArray |
Sum of array elements over a given axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.sum.html
| inArray | |
| inAxis | (Optional, default NONE) |
Swaps the contents of two arrays
| inArray1 | |
| inArray2 |
Interchange two axes of an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.swapaxes.html
| inArray |
|
noexcept |
Swaps cols of the array
| inArray | |
| colIdx1 | |
| colIdx2 |
|
noexcept |
Swaps rows of the array
| inArray | |
| rowIdx1 | |
| rowIdx2 |
| NdArray< dtype > nc::take | ( | const NdArray< dtype > & | inArray, |
| const Indices & | inIndices, | ||
| Axis | inAxis = Axis::NONE |
||
| ) |
Evenly round to the given number of decimals.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.take.html
| inArray | |
| inIndices | |
| inAxis |
Compute tangent element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.tan.html
| inArray |
Compute tangent.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.tan.html
| inValue |
Compute hyperbolic tangent element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.tanh.html
| inArray |
Compute hyperbolic tangent.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.tanh.html
| inValue |
Construct an array by repeating A the number of times given by reps.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.tile.html
| inArray | |
| inReps |
Construct an array by repeating A the number of times given by reps.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.tile.html
| inArray | |
| inNumRows | |
| inNumCols |
Write array to a file as binary. The data produced by this method can be recovered using the function fromfile().
| inArray | |
| inFilename |
| void nc::tofile | ( | const NdArray< dtype > & | inArray, |
| const std::string & | inFilename, | ||
| const char | inSep | ||
| ) |
Write array to a file as text. The data produced by this method can be recovered using the function fromfile().
| inArray | |
| inFilename | |
| inSep | Separator between array items for text output. |
Write flattened array to an STL vector
| inArray |
|
noexcept |
Return the sum along diagonals of the array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.trace.html
| inArray | |
| inOffset | (Offset from main diaganol, default = 0, negative=above, positve=below) |
| inAxis | (Optional, default ROW) |
Permute the dimensions of an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.transpose.html
| inArray |
| NdArray< double > nc::trapz | ( | const NdArray< dtype > & | inArray, |
| double | dx = 1., |
||
| Axis | inAxis = Axis::NONE |
||
| ) |
Integrate along the given axis using the composite trapezoidal rule.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.trapz.html
| inArray | |
| dx | (Optional defaults to 1.) |
| inAxis | (Optional, default NONE) |
| NdArray< double > nc::trapz | ( | const NdArray< dtype > & | inArrayY, |
| const NdArray< dtype > & | inArrayX, | ||
| Axis | inAxis = Axis::NONE |
||
| ) |
Integrate along the given axis using the composite trapezoidal rule.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.trapz.html
| inArrayY | |
| inArrayX | |
| inAxis | (Optional, default NONE) |
Lower triangle of an array.
Return a copy of an array with elements above the k - th diagonal zeroed.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.tril.html
| inArray | number of rows and cols |
| inOffset | (the sub-diagonal at and below which the array is filled. k = 0 is the main diagonal, while k < 0 is below it, and k > 0 is above. The default is 0.) |
An array with ones at and below the given diagonal and zeros elsewhere.
| inN | number of rows and cols |
| inOffset | (the sub-diagonal at and below which the array is filled. k = 0 is the main diagonal, while k < 0 is below it, and k > 0 is above. The default is 0.) |
An array with ones at and below the given diagonal and zeros elsewhere.
| inN | number of rows |
| inM | number of columns |
| inOffset | (the sub-diagonal at and below which the array is filled. k = 0 is the main diagonal, while k < 0 is below it, and k > 0 is above. The default is 0.) |
| NdArray< dtype > nc::trim_zeros | ( | const NdArray< dtype > & | inArray, |
| const std::string & | inTrim = "fb" |
||
| ) |
Trim the leading and/or trailing zeros from a 1-D array or sequence.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.trim_zeros.html
| inArray | |
| inTrim | ("f" = front, "b" = back, "fb" = front and back) |
Upper triangle of an array.
Return a copy of an array with elements below the k - th diagonal zeroed.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.triu.html
| inArray | number of rows and cols |
| inOffset | (the sub-diagonal at and below which the array is filled. k = 0 is the main diagonal, while k < 0 is below it, and k > 0 is above. The default is 0.) |
An array with ones at and above the given diagonal and zeros elsewhere.
| inN | number of rows and cols |
| inOffset | (the sub-diagonal at and above which the array is filled. k = 0 is the main diagonal, while k < 0 is below it, and k > 0 is above. The default is 0.) |
An array with ones at and above the given diagonal and zeros elsewhere.
| inN | number of rows |
| inM | number of columns |
| inOffset | (the sub-diagonal at and above which the array is filled. k = 0 is the main diagonal, while k < 0 is below it, and k > 0 is above. The default is 0.) |
Return the truncated value of the input, element-wise.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.trunc.html
| inArray |
Return the truncated value of the input.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.trunc.html
| inValue |
| NdArray< dtype > nc::union1d | ( | const NdArray< dtype > & | inArray1, |
| const NdArray< dtype > & | inArray2 | ||
| ) |
Find the union of two arrays.
Return the unique, sorted array of values that are in either of the two input arrays.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.union1d.html
| inArray1 | |
| inArray2 |
Find the unique elements of an array.
Returns the sorted unique elements of an array.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.unique.html
| inArray |
|
inline |
Unpacks elements of a uint8 array into a binary-valued output array.
Each element of a represents a bit - field that should be unpacked into a binary - valued output array.The shape of the output array is either 1 - D(if axis is None) or the same shape as the input array with unpacking done along the axis specified.
Numpy Reference: https://numpy.org/doc/stable/reference/generated/numpy.unpackbits.html
| a | An array of uint8 whose elements should be unpacked to bits. |
| axis | The dimension over which bit-unpacking is done. None implies unpacking the flattened array. |
|
inline |
Unpacks elements of a uint8 array into a binary-valued output array.
Each element of a represents a bit - field that should be unpacked into a binary - valued output array.The shape of the output array is either 1 - D(if axis is None) or the same shape as the input array with unpacking done along the axis specified.
Numpy Reference: https://numpy.org/doc/stable/reference/generated/numpy.unpackbits.html
| a | An array of uint8 whose elements should be unpacked to bits. |
| axis | The dimension over which bit-unpacking is done. None implies unpacking the flattened array. |
Unwrap by changing deltas between values to 2*pi complement. Unwraps to [-pi, pi].
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.unwrap.html
| inArray |
Unwrap by changing deltas between values to 2*pi complement. Unwraps to [-pi, pi].
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.unwrap.html
| inValue |
| auto nc::vander | ( | const NdArray< dtype > & | x, |
| Increasing | increasing = Increasing::YES |
||
| ) |
Generate a Vandermonde matrix. The columns of the output matrix are powers of the input vector. The order of the powers is determined by the increasing boolean argument. Specifically, when increasing is False, the i-th output column is the input vector raised element-wise to the power of N - i - 1. Such a matrix with a geometric progression in each row is named for Alexandre- Theophile Vandermonde.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.vander.html
| x | 1-D input array, otherwise the array will be flattened |
| increasing | Order of the powers of the columns. If True, the powers increase from left to right, if False (the default) they are reversed. |
| auto nc::vander | ( | const NdArray< dtype > & | x, |
| uint32 | n, | ||
| Increasing | increasing = Increasing::YES |
||
| ) |
Generate a Vandermonde matrix. The columns of the output matrix are powers of the input vector. The order of the powers is determined by the increasing boolean argument. Specifically, when increasing is False, the i-th output column is the input vector raised element-wise to the power of N - i - 1. Such a matrix with a geometric progression in each row is named for Alexandre- Theophile Vandermonde.
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.vander.html
| x | 1-D input array, otherwise the array will be flattened |
| n | Number of columns in the output. If N is not specified, a square array is returned (N = len(x)). |
| increasing | Order of the powers of the columns. If True, the powers increase from left to right, if False (the default) they are reversed. |
Compute the variance along the specified axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.var.html
| inArray | |
| inAxis | (Optional, default NONE) |
| NdArray< std::complex< double > > nc::var | ( | const NdArray< std::complex< dtype > > & | inArray, |
| Axis | inAxis = Axis::NONE |
||
| ) |
Compute the variance along the specified axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.var.html
| inArray | |
| inAxis | (Optional, default NONE) |
| std::vector< NdArray< dtype > > nc::vsplit | ( | const NdArray< dtype > & | inArray, |
| const Indices & | indices | ||
| ) |
Split an array into multiple sub-arrays vertically (row-wise).
NumPy Reference: https://numpy.org/doc/stable/reference/generated/numpy.vsplit.html
| inArray | |
| indices | the indices to split |
Compute the variance along the specified axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.vstack.html
| inArrayList | {list} of arrays to stack |
Compute the variance along the specified axis.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.vstack.html
| inArrayList | {list} of arrays to stack |
| NdArray< dtype > nc::where | ( | const NdArray< bool > & | inMask, |
| const NdArray< dtype > & | inA, | ||
| const NdArray< dtype > & | inB | ||
| ) |
Return elements, either from x or y, depending on the input mask. The output array contains elements of x where mask is True, and elements from y elsewhere.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.where.html
| inMask | |
| inA | |
| inB |
| NdArray< dtype > nc::where | ( | const NdArray< bool > & | inMask, |
| const NdArray< dtype > & | inA, | ||
| dtype | inB | ||
| ) |
Return elements, either from x or y, depending on the input mask. The output array contains elements of x where mask is True, and elements from y elsewhere.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.where.html
| inMask | |
| inA | |
| inB |
| NdArray< dtype > nc::where | ( | const NdArray< bool > & | inMask, |
| dtype | inA, | ||
| const NdArray< dtype > & | inB | ||
| ) |
Return elements, either from x or y, depending on the input mask. The output array contains elements of x where mask is True, and elements from y elsewhere.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.where.html
| inMask | |
| inA | |
| inB |
Return elements, either from x or y, depending on the input mask. The output array contains elements of x where mask is True, and elements from y elsewhere.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.where.html
| inMask | |
| inA | |
| inB |
Wrap the input angle to [-pi, pi].
| inAngles | in radians |
Wrap the input angle to [-pi, pi].
| inAngle | in radians |
Wrap the input angle to [0, 2*pi].
| inAngles | in radians |
Wrap the input angle to [0, 2*pi].
| inAngle | in radians |
Return a new array of given shape and type, filled with zeros.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.zeros.html
| inShape |
Return a new array of given shape and type, filled with zeros.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.zeros.html
| inNumRows | |
| inNumCols |
Return a new array of given shape and type, filled with zeros.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.zeros.html
| inSquareSize |
Return a new array of given shape and type, filled with zeros.
NumPy Reference: https://www.numpy.org/devdocs/reference/generated/numpy.zeros_like.html
| inArray |
|
constexpr |
all_arithmetic helper
all_same helper
|
constexpr |
greaterThan helper
|
constexpr |
is_complex helper
|
constexpr |
is_ndarray_int helper
is_valid_dtype helper
1.9.8