类
struct	is_vector_like

函数
std::pair< double, double >	twoSum (double a, double b)

double	eps (double t)

template<typename Container >
auto	size (const Container &vec) noexcept -> decltype(vec.size())

template<class _Scalar , size_t N>
constexpr size_t	size (const _Scalar(&)[N]) noexcept

template<typename _Scalar >
int	sign (_Scalar val)

template<typename T >
std::enable_if< std::is_arithmetic< T >::value, T >::type	rem (T x, T y)

template<typename T >
std::enable_if< std::is_floating_point< T >::value, T >::type	mod (T x, T y)

template<typename T >
std::enable_if< std::is_arithmetic< T >::value, T >::type	fix (T x)

double	cot (double a)

double	acot (double a)

template<typename Container1 , typename Container2 >
double	dot (const Container1 &vec1, const Container2 &vec2)

template<size_t N1, size_t N2>
double	dot (const double(&vec1)[N1], const double(&vec2)[N2])

double	dot (const double vec1, const double vec2, size_t N)

double	dot3 (const double vec1, const double vec2)

template<typename Vector3D1 , typename Vector3D2 >
auto	cross (const Vector3D1 &vec1, const Vector3D2 &vec2) -> typename std::enable_if<!std::is_pointer< Vector3D1 >::value &&!std::is_pointer< Vector3D2 >::value, Vector3D1 >::type

void	cross (double res, const double vec1, const double *vec2)

template<size_t N1, size_t N2>
std::array< double, 3 >	cross (const double(&vec1)[N1], const double(&vec2)[N2])

std::array< double, 3 >	cross3 (const double vec1, const double vec2)

double	squaredNorm (const double *vec, size_t N)

template<typename Vector >
auto	squaredNorm (const Vector &vec) -> typename std::enable_if<!std::is_pointer< Vector >::value, double >::type

template<size_t N>
double	squaredNorm (const double(&vec)[N])

double	norm (const double *vec, size_t N)

template<typename Vector >
auto	norm (const Vector &vec) -> typename std::enable_if<!std::is_pointer< Vector >::value, double >::type

template<size_t N>
double	norm (const double(&vec)[N])

double	normalize (double *vec, size_t N)

template<typename Vector >
auto	normalize (Vector &vec) -> typename std::enable_if<!std::is_pointer< Vector >::value, double >::type

template<size_t N>
double	normalize (double(&vec)[N])

template<typename Vector >
auto	normalized (const Vector &vec) -> typename std::enable_if<!std::is_pointer< Vector >::value, Vector >::type

template<size_t N>
std::array< double, N >	normalized (double(&vec)[N])

template<size_t N>
std::array< double, N >	normalized (const double *vec)

template<typename _Scalar , size_t I, size_t J, size_t K>
std::array< std::array< _Scalar, K >, I >	mtimes (const _Scalar(&left)[I][J], const _Scalar(&right)[J][K])

详细描述

提供向量运算相关的函数

注解: 采用模板函数实现向量运算，只要类型支持标准化的接口即可使用这些函数

一般来说，用于向量运算的类型都能支持随机访问，所以这里没有参考标准库的实现来处理不支持随机访问的数据容器直接使用使用for循环 + 下标访问实现向量运算