Linear algebra

group NVCV_CPP_CUDATOOLS_LINALG

Functions

template<class T, int N> constexpr __host__ __device__ Vector< T, N > & operator+= (Vector< T, N > &lhs, const Vector< T, N > &rhs)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > operator+ (const Vector< T, N > &a, const Vector< T, N > &b)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > & operator+= (Vector< T, N > &lhs, T rhs)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > operator+ (const Vector< T, N > &a, T b)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > operator+ (T a, const Vector< T, N > &b)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > & operator-= (Vector< T, N > &lhs, const Vector< T, N > &rhs)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > operator- (const Vector< T, N > &a, const Vector< T, N > &b)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > & operator-= (Vector< T, N > &lhs, T rhs)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > operator- (const Vector< T, N > &a, T b)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > operator- (T a, const Vector< T, N > &b)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > & operator*= (Vector< T, N > &lhs, const T &rhs)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > operator* (const Vector< T, N > &a, const T &b)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > operator* (const T &a, const Vector< T, N > &b)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > & operator*= (Vector< T, N > &lhs, const Vector< T, N > &rhs)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > operator* (const Vector< T, N > &a, const Vector< T, N > &b)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > & operator/= (Vector< T, N > &lhs, const T &rhs)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > operator/ (const Vector< T, N > &a, const T &b)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > operator/ (T a, const Vector< T, N > &b)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > & operator/= (Vector< T, N > &lhs, const Vector< T, N > &rhs)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > operator/ (const Vector< T, N > &a, const Vector< T, N > &b)

template<class T, int N>
std::ostream &operator<<(std::ostream &out, const Vector<T, N> &v)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > operator- (const Vector< T, N > &v)

template<class T, int N> constexpr __host__ __device__ bool operator== (const Vector< T, N > &a, const Vector< T, N > &b)

template<class T, int N> constexpr __host__ __device__ bool operator== (const T &a, const Vector< T, N > &b)

template<class T, int N> constexpr __host__ __device__ bool operator== (const Vector< T, N > &a, const T &b)

template<class T, int N> constexpr __host__ __device__ bool operator< (const Vector< T, N > &a, const Vector< T, N > &b)

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > operator* (const Matrix< T, M, N > &m, T val)

template<class T, int M, int N>
std::ostream &operator<<(std::ostream &out, const Matrix<T, M, N> &m)

template<class T, int M, int N, int P> constexpr __host__ __device__ Matrix< T, M, P > operator* (const Matrix< T, M, N > &a, const Matrix< T, N, P > &b)

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > & operator*= (Matrix< T, M, N > &lhs, T rhs)

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > operator* (T val, const Matrix< T, M, N > &m)

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > & operator+= (Matrix< T, M, N > &lhs, const Matrix< T, M, N > &rhs)

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > operator+ (const Matrix< T, M, N > &lhs, const Matrix< T, M, N > &rhs)

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > & operator-= (Matrix< T, M, N > &lhs, const Matrix< T, M, N > &rhs)

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > operator- (const Matrix< T, M, N > &a, const Matrix< T, M, N > &b)

template<class T, int M, int N> constexpr __host__ __device__ Vector< T, N > operator* (const Vector< T, M > &v, const Matrix< T, M, N > &m)

template<class T, int M, int N> constexpr __host__ __device__ Vector< T, M > operator* (const Matrix< T, M, N > &m, const Vector< T, N > &v)

template<class T, int M, int N, class = std::enable_if_t<(M == N && N > 1)>> constexpr __host__ __device__ Matrix< T, M, N > operator* (const Matrix< T, M, 1 > &m, const Vector< T, N > &v)

template<class T, int M, int N> constexpr __host__ __device__ Vector< T, N > & operator*= (Vector< T, M > &v, const Matrix< T, M, M > &m)

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > & operator*= (Matrix< T, M, N > &lhs, const Matrix< T, N, N > &rhs)

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > operator- (const Matrix< T, M, N > &m)

template<class T, int M, int N> constexpr __host__ __device__ bool operator== (const Matrix< T, M, N > &a, const Matrix< T, M, N > &b)

template<class T, int M, int N> constexpr __host__ __device__ bool operator== (const T &a, const Matrix< T, M, N > &b)

template<class T, int M, int N> constexpr __host__ __device__ bool operator== (const Matrix< T, M, N > &a, const T &b)

template<class T, int M, int N> constexpr __host__ __device__ bool operator< (const Matrix< T, M, N > &a, const Matrix< T, M, N > &b)

template<typename T, int N, int M>
constexpr Matrix<T, N, M> as_matrix(const T (&values)[N][M])

template<class T, int N> constexpr __host__ __device__ Vector< T, N > zeros ()

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > zeros ()

template<class T, int N> constexpr __host__ __device__ Vector< T, N > ones ()

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > ones ()

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > identity ()

template<class T, int M> constexpr __host__ __device__ Matrix< T, M, M > vander (const Vector< T, M > &v)

template<class T, int R> constexpr __host__ __device__ Matrix< T, R, R > compan (const Vector< T, R > &a)

template<class T, int M> constexpr __host__ __device__ Matrix< T, M, M > diag (const Vector< T, M > &v)

template<class T, int N> constexpr __host__ __device__ T dot (const Vector< T, N > &a, const Vector< T, N > &b)

template<class T, int N> constexpr __host__ __device__ Vector< T, N > reverse (const Vector< T, N > &a)

template<class T, int M> constexpr __host__ __device__ Matrix< T, M, M > & transp_inplace (Matrix< T, M, M > &m)

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, N, M > transp (const Matrix< T, M, N > &m)

template<class T, int N> constexpr __host__ __device__ Matrix< T, N, 1 > transp (const Vector< T, N > &v)

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > flip_rows (const Matrix< T, M, N > &m)

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > flip_cols (const Matrix< T, M, N > &m)

template<class T, int M, int N> constexpr __host__ __device__ Matrix< T, M, N > flip (const Matrix< T, M, N > &m)

template<class T> constexpr __host__ __device__ T det (const Matrix< T, 0, 0 > &m)

template<class T> constexpr __host__ __device__ T det (const Matrix< T, 1, 1 > &m)

template<class T> constexpr __host__ __device__ T det (const Matrix< T, 2, 2 > &m)

template<class T> constexpr __host__ __device__ T det (const Matrix< T, 3, 3 > &m)

template<class T, int M> constexpr __host__ __device__ T det (const Matrix< T, M, M > &m)

template<class T, int N, class = std::enable_if_t<(N < 4)>> constexpr __host__ __device__ bool inv_inplace (Matrix< T, N, N > &m)

template<class F = float, class T, int N> constexpr __host__ __device__ bool lu_inplace (Matrix< T, N, N > &m, Vector< int, N > &p)

template<class T, int N> constexpr __host__ __device__ void solve_inplace (const Matrix< T, N, N > &lu, const Vector< int, N > &p, Vector< T, N > &b)

template<class T, int N> constexpr __host__ __device__ bool solve_inplace (const Matrix< T, N, N > &m, Vector< T, N > &b)

template<class T, int N>
class Vector

#include <LinAlg.hpp>

Vector class to represent small vectors.

Template Parameters:

• T – Vector value type.

• N – Number of elements.

template<class T, int M, int N = M>
class Matrix

#include <LinAlg.hpp>

Matrix class to represent small matrices.

Template Parameters:

• T – Matrix value type.

• M – Number of rows.

• N – Number of columns. Default is M.