#include <initializer_list>
#include <assert.h>
#include <vector>
#include <opencv2/core/check.hpp>
#include "intrin_rvv_compat_overloaded.hpp"

Classes
struct	cv::VTraits< vfloat32m1_t >

struct	cv::VTraits< vfloat32m2_t >

struct	cv::VTraits< vfloat32m4_t >

struct	cv::VTraits< vfloat32m8_t >

struct	cv::VTraits< vfloat64m1_t >

struct	cv::VTraits< vfloat64m2_t >

struct	cv::VTraits< vfloat64m4_t >

struct	cv::VTraits< vfloat64m8_t >

struct	cv::VTraits< vint16m1_t >

struct	cv::VTraits< vint16m2_t >

struct	cv::VTraits< vint16m4_t >

struct	cv::VTraits< vint16m8_t >

struct	cv::VTraits< vint32m1_t >

struct	cv::VTraits< vint32m2_t >

struct	cv::VTraits< vint32m4_t >

struct	cv::VTraits< vint32m8_t >

struct	cv::VTraits< vint64m1_t >

struct	cv::VTraits< vint64m2_t >

struct	cv::VTraits< vint64m4_t >

struct	cv::VTraits< vint64m8_t >

struct	cv::VTraits< vint8m1_t >

struct	cv::VTraits< vint8m2_t >

struct	cv::VTraits< vint8m4_t >

struct	cv::VTraits< vint8m8_t >

struct	cv::VTraits< vuint16m1_t >

struct	cv::VTraits< vuint16m2_t >

struct	cv::VTraits< vuint16m4_t >

struct	cv::VTraits< vuint16m8_t >

struct	cv::VTraits< vuint32m1_t >

struct	cv::VTraits< vuint32m2_t >

struct	cv::VTraits< vuint32m4_t >

struct	cv::VTraits< vuint32m8_t >

struct	cv::VTraits< vuint64m1_t >

struct	cv::VTraits< vuint64m2_t >

struct	cv::VTraits< vuint64m4_t >

struct	cv::VTraits< vuint64m8_t >

struct	cv::VTraits< vuint8m1_t >

struct	cv::VTraits< vuint8m2_t >

struct	cv::VTraits< vuint8m4_t >

struct	cv::VTraits< vuint8m8_t >

Namespaces
namespace	cv
	"black box" representation of the file storage associated with a file on disk.

Macros
#define	CV_RVV_MAX_VLEN 1024

#define	CV_SIMD_SCALABLE 1

#define	CV_SIMD_SCALABLE_64F 1

#define	OPENCV_HAL_IMPL_RVV_ABS(_Tprvec, _Tpvec, suffix)

#define	OPENCV_HAL_IMPL_RVV_ABSDIFF(_Tpvec, abs)

#define	OPENCV_HAL_IMPL_RVV_ABSDIFF_S(_Tpvec, _rTpvec, width)

#define	OPENCV_HAL_IMPL_RVV_BIN_FUNC(_Tpvec, func, intrin, vl)

#define	OPENCV_HAL_IMPL_RVV_BIN_MADD(_Tpvec, rvv_add)

#define	OPENCV_HAL_IMPL_RVV_BIN_MMUL(_Tpvec, rvv_mul)

#define	OPENCV_HAL_IMPL_RVV_BIN_OP(_Tpvec, ocv_intrin, rvv_intrin)

#define	OPENCV_HAL_IMPL_RVV_BROADCAST(_Tpvec, suffix)

#define	OPENCV_HAL_IMPL_RVV_CHECK_ALLANY(_Tpvec, vl)

#define	OPENCV_HAL_IMPL_RVV_EXPAND(_Tp, _Tpwvec, _Tpwvec_m2, _Tpvec, width, suffix, suffix2, cvt)

#define	OPENCV_HAL_IMPL_RVV_EXTRACT(_Tpvec, _Tp, vl)

#define	OPENCV_HAL_IMPL_RVV_EXTRACT_FP(_Tpvec, _Tp, suffix, vl)

#define	OPENCV_HAL_IMPL_RVV_EXTRACT_INTEGER(_Tpvec, _Tp, suffix, vl)

#define	OPENCV_HAL_IMPL_RVV_FLOAT_CMP(_Tpvec, suffix, vl)

#define	OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP(_Tpvec, op, intrin, suffix, vl)

#define	OPENCV_HAL_IMPL_RVV_FLT64_BIT_OP(intrin)

#define	OPENCV_HAL_IMPL_RVV_FLT_BIT_OP(intrin)

#define	OPENCV_HAL_IMPL_RVV_GRT0_INT(_Tpvec, _Tp)

#define	OPENCV_HAL_IMPL_RVV_HADD(_Tpvec, _Tpvec2, _Tm2, width, width2, suffix, add)

#define	OPENCV_HAL_IMPL_RVV_INIT_FP(_Tpv, _Tp, suffix, vl)

#define	OPENCV_HAL_IMPL_RVV_INIT_INTEGER(_Tpvec, _Tp, suffix1, suffix2, vl)

#define	OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, op, intrin, suffix, vl)

#define	OPENCV_HAL_IMPL_RVV_INTERLEAVED(_Tpvec, _Tp, suffix, width, hwidth, vl)

#define	OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ(_Tpvec, width, vzext_vfx, func)

#define	OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ_NOEXPEND(_Tpvec, func)

#define	OPENCV_HAL_IMPL_RVV_LOADSTORE_OP(_Tpvec, _nTpvec, _Tp, hvl, vl, width, suffix, vmv)

#define	OPENCV_HAL_IMPL_RVV_LOGIC_OP(_Tpvec, vl)

#define	OPENCV_HAL_IMPL_RVV_LUT(_Tpvec, _Tp, suffix)

#define	OPENCV_HAL_IMPL_RVV_LUT_VEC(_Tpvec, _Tp)

#define	OPENCV_HAL_IMPL_RVV_MUL_EXPAND(_Tpvec, _Tpwvec, _TpwvecM2, suffix, wmul)

#define	OPENCV_HAL_IMPL_RVV_MUL_SAT(_Tpvec, _clip, _wmul)

#define	OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET(_Tpvec1, _Tpvec2, suffix1, suffix2, nsuffix1, nsuffix2)

#define	OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET(_Tpvec1, suffix1)

#define	OPENCV_HAL_IMPL_RVV_PACK(_Tpvec, _Tp, _wTpvec, hwidth, hsuffix, suffix, rshr, shr)

#define	OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS(_Tpvec, v_trunc)

#define	OPENCV_HAL_IMPL_RVV_PACK_U(_Tpvec, _Tp, _wTpvec, _wTp, hwidth, width, hsuffix, suffix, rshr, cast, hvl, vl)

#define	OPENCV_HAL_IMPL_RVV_REDUCE(_Tpvec, func, scalartype, suffix, vl, red)

#define	OPENCV_HAL_IMPL_RVV_REDUCE_SAD(_Tpvec, scalartype)

#define	OPENCV_HAL_IMPL_RVV_REDUCE_SUM(_Tpvec, _wTpvec, _nwTpvec, scalartype, wsuffix, vl, red)

#define	OPENCV_HAL_IMPL_RVV_REDUCE_SUM_FP(_Tpvec, _wTpvec, _nwTpvec, scalartype, wsuffix, vl)

#define	OPENCV_HAL_IMPL_RVV_REVERSE(_Tpvec, width)

#define	OPENCV_HAL_IMPL_RVV_ROTATE_FP(_Tpvec, suffix, vl)

#define	OPENCV_HAL_IMPL_RVV_ROTATE_INTEGER(_Tpvec, suffix, vl)

#define	OPENCV_HAL_IMPL_RVV_SELECT(_Tpvec, vl)

#define	OPENCV_HAL_IMPL_RVV_SIGNED_CMP(_Tpvec, suffix, vl)

#define	OPENCV_HAL_IMPL_RVV_SIGNED_SHIFT_OP(_Tpvec, vl)

#define	OPENCV_HAL_IMPL_RVV_SIGNMASK_OP(_Tpvec)

#define	OPENCV_HAL_IMPL_RVV_TRAITS(REG, TYP, SUF, SZ)

#define	OPENCV_HAL_IMPL_RVV_TRANSPOSE4x4(_Tpvec, suffix)

#define	OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET(_Tpvec1, _Tpvec2, suffix1, suffix2, nsuffix1, nsuffix2, width1, width2)

#define	OPENCV_HAL_IMPL_RVV_UNPACKS(_Tpvec, width)

#define	OPENCV_HAL_IMPL_RVV_UNSIGNED_CMP(_Tpvec, suffix, vl)

#define	OPENCV_HAL_IMPL_RVV_UNSIGNED_SHIFT_OP(_Tpvec, vl)

#define	OPENCV_HAL_IMPL_RVV_ZIP(_Tpvec, _wTpvec, suffix, width, width2, convert2um2, convert2um1)

#define	OPENCV_HAL_IMPL_RVV_ZIP4(_Tpvec, _wTpvec, suffix, convert2u, convert)

Typedefs
using	cv::int64 = long int

using	cv::schar = signed char

using	cv::uchar = unsigned char

using	cv::uint = unsigned int

using	cv::uint64 = unsigned long int

using	cv::ushort = unsigned short

using	cv::v_float32 = vfloat32m1_t

using	cv::v_float64 = vfloat64m1_t

using	cv::v_int16 = vint16m1_t

using	cv::v_int32 = vint32m1_t

using	cv::v_int64 = vint64m1_t

using	cv::v_int8 = vint8m1_t

using	cv::v_uint16 = vuint16m1_t

using	cv::v_uint32 = vuint32m1_t

using	cv::v_uint64 = vuint64m1_t

using	cv::v_uint8 = vuint8m1_t

Functions
v_float32	cv::v_abs (const v_float32 &a)

v_float64	cv::v_abs (const v_float64 &a)

v_uint16	cv::v_abs (const v_int16 &a)

v_uint32	cv::v_abs (const v_int32 &a)

v_uint8	cv::v_abs (const v_int8 &a)

v_float32	cv::v_absdiff (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_absdiff (const v_float64 &a, const v_float64 &b)

v_uint16	cv::v_absdiff (const v_int16 &a, const v_int16 &b)

v_uint32	cv::v_absdiff (const v_int32 &a, const v_int32 &b)

v_uint8	cv::v_absdiff (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_absdiff (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_absdiff (const v_uint32 &a, const v_uint32 &b)

v_uint8	cv::v_absdiff (const v_uint8 &a, const v_uint8 &b)

v_int16	cv::v_absdiffs (const v_int16 &a, const v_int16 &b)

v_int8	cv::v_absdiffs (const v_int8 &a, const v_int8 &b)

v_float32	cv::v_add (const v_float32 &a, const v_float32 &b)

template<typename... Args>
v_float32	cv::v_add (const v_float32 &f1, const v_float32 &f2, const Args &... vf)

v_float64	cv::v_add (const v_float64 &a, const v_float64 &b)

template<typename... Args>
v_float64	cv::v_add (const v_float64 &f1, const v_float64 &f2, const Args &... vf)

v_int16	cv::v_add (const v_int16 &a, const v_int16 &b)

template<typename... Args>
v_int16	cv::v_add (const v_int16 &f1, const v_int16 &f2, const Args &... vf)

v_int32	cv::v_add (const v_int32 &a, const v_int32 &b)

template<typename... Args>
v_int32	cv::v_add (const v_int32 &f1, const v_int32 &f2, const Args &... vf)

v_int64	cv::v_add (const v_int64 &a, const v_int64 &b)

template<typename... Args>
v_int64	cv::v_add (const v_int64 &f1, const v_int64 &f2, const Args &... vf)

v_int8	cv::v_add (const v_int8 &a, const v_int8 &b)

template<typename... Args>
v_int8	cv::v_add (const v_int8 &f1, const v_int8 &f2, const Args &... vf)

v_uint16	cv::v_add (const v_uint16 &a, const v_uint16 &b)

template<typename... Args>
v_uint16	cv::v_add (const v_uint16 &f1, const v_uint16 &f2, const Args &... vf)

v_uint32	cv::v_add (const v_uint32 &a, const v_uint32 &b)

template<typename... Args>
v_uint32	cv::v_add (const v_uint32 &f1, const v_uint32 &f2, const Args &... vf)

v_uint64	cv::v_add (const v_uint64 &a, const v_uint64 &b)

template<typename... Args>
v_uint64	cv::v_add (const v_uint64 &f1, const v_uint64 &f2, const Args &... vf)

v_uint8	cv::v_add (const v_uint8 &a, const v_uint8 &b)

template<typename... Args>
v_uint8	cv::v_add (const v_uint8 &f1, const v_uint8 &f2, const Args &... vf)

v_int16	cv::v_add_wrap (const v_int16 &a, const v_int16 &b)

v_int8	cv::v_add_wrap (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_add_wrap (const v_uint16 &a, const v_uint16 &b)

v_uint8	cv::v_add_wrap (const v_uint8 &a, const v_uint8 &b)

v_float32	cv::v_and (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_and (const v_float64 &a, const v_float64 &b)

v_int16	cv::v_and (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_and (const v_int32 &a, const v_int32 &b)

v_int64	cv::v_and (const v_int64 &a, const v_int64 &b)

v_int8	cv::v_and (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_and (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_and (const v_uint32 &a, const v_uint32 &b)

v_uint64	cv::v_and (const v_uint64 &a, const v_uint64 &b)

v_uint8	cv::v_and (const v_uint8 &a, const v_uint8 &b)

template<int s = 0>
v_float32	cv::v_broadcast_element (v_float32 v, int i=s)

template<int s = 0>
v_int32	cv::v_broadcast_element (v_int32 v, int i=s)

template<int s = 0>
v_uint32	cv::v_broadcast_element (v_uint32 v, int i=s)

v_float32	cv::v_broadcast_highest (v_float32 v)

v_int32	cv::v_broadcast_highest (v_int32 v)

v_uint32	cv::v_broadcast_highest (v_uint32 v)

v_int32	cv::v_ceil (const v_float32 &a)

v_int32	cv::v_ceil (const v_float64 &a)

bool	cv::v_check_all (const v_float32 &a)

bool	cv::v_check_all (const v_float64 &a)

bool	cv::v_check_all (const v_int16 &a)

bool	cv::v_check_all (const v_int32 &a)

bool	cv::v_check_all (const v_int64 &a)

bool	cv::v_check_all (const v_int8 &a)

bool	cv::v_check_all (const v_uint16 &a)

bool	cv::v_check_all (const v_uint32 &a)

bool	cv::v_check_all (const v_uint64 &a)

bool	cv::v_check_all (const v_uint8 &a)

bool	cv::v_check_any (const v_float32 &a)

bool	cv::v_check_any (const v_float64 &a)

bool	cv::v_check_any (const v_int16 &a)

bool	cv::v_check_any (const v_int32 &a)

bool	cv::v_check_any (const v_int64 &a)

bool	cv::v_check_any (const v_int8 &a)

bool	cv::v_check_any (const v_uint16 &a)

bool	cv::v_check_any (const v_uint32 &a)

bool	cv::v_check_any (const v_uint64 &a)

bool	cv::v_check_any (const v_uint8 &a)

void	cv::v_cleanup ()

v_float32	cv::v_combine_high (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_combine_high (const v_float64 &a, const v_float64 &b)

v_int16	cv::v_combine_high (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_combine_high (const v_int32 &a, const v_int32 &b)

v_int8	cv::v_combine_high (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_combine_high (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_combine_high (const v_uint32 &a, const v_uint32 &b)

v_uint8	cv::v_combine_high (const v_uint8 &a, const v_uint8 &b)

v_float32	cv::v_combine_low (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_combine_low (const v_float64 &a, const v_float64 &b)

v_int16	cv::v_combine_low (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_combine_low (const v_int32 &a, const v_int32 &b)

v_int8	cv::v_combine_low (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_combine_low (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_combine_low (const v_uint32 &a, const v_uint32 &b)

v_uint8	cv::v_combine_low (const v_uint8 &a, const v_uint8 &b)

v_float32	cv::v_cvt_f32 (const v_float64 &a)

v_float32	cv::v_cvt_f32 (const v_float64 &a, const v_float64 &b)

v_float32	cv::v_cvt_f32 (const v_int32 &a)

v_float64	cv::v_cvt_f64 (const v_float32 &a)

v_float64	cv::v_cvt_f64 (const v_int32 &a)

v_float64	cv::v_cvt_f64 (const v_int64 &a)

v_float64	cv::v_cvt_f64_high (const v_float32 &a)

v_float64	cv::v_cvt_f64_high (const v_int32 &a)

v_float32	cv::v_div (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_div (const v_float64 &a, const v_float64 &b)

v_int32	cv::v_dotprod (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_dotprod (const v_int16 &a, const v_int16 &b, const v_int32 &c)

v_int64	cv::v_dotprod (const v_int32 &a, const v_int32 &b)

v_int64	cv::v_dotprod (const v_int32 &a, const v_int32 &b, const v_int64 &c)

v_int64	cv::v_dotprod_expand (const v_int16 &a, const v_int16 &b)

v_int64	cv::v_dotprod_expand (const v_int16 &a, const v_int16 &b, const v_int64 &c)

v_float64	cv::v_dotprod_expand (const v_int32 &a, const v_int32 &b)

v_float64	cv::v_dotprod_expand (const v_int32 &a, const v_int32 &b, const v_float64 &c)

v_int32	cv::v_dotprod_expand (const v_int8 &a, const v_int8 &b)

v_int32	cv::v_dotprod_expand (const v_int8 &a, const v_int8 &b, const v_int32 &c)

v_uint64	cv::v_dotprod_expand (const v_uint16 &a, const v_uint16 &b)

v_uint64	cv::v_dotprod_expand (const v_uint16 &a, const v_uint16 &b, const v_uint64 &c)

v_uint32	cv::v_dotprod_expand (const v_uint8 &a, const v_uint8 &b)

v_uint32	cv::v_dotprod_expand (const v_uint8 &a, const v_uint8 &b, const v_uint32 &c)

v_int64	cv::v_dotprod_expand_fast (const v_int16 &a, const v_int16 &b)

v_int64	cv::v_dotprod_expand_fast (const v_int16 &a, const v_int16 &b, const v_int64 &c)

v_float64	cv::v_dotprod_expand_fast (const v_int32 &a, const v_int32 &b)

v_float64	cv::v_dotprod_expand_fast (const v_int32 &a, const v_int32 &b, const v_float64 &c)

v_int32	cv::v_dotprod_expand_fast (const v_int8 &a, const v_int8 &b)

v_int32	cv::v_dotprod_expand_fast (const v_int8 &a, const v_int8 &b, const v_int32 &c)

v_uint64	cv::v_dotprod_expand_fast (const v_uint16 &a, const v_uint16 &b)

v_uint64	cv::v_dotprod_expand_fast (const v_uint16 &a, const v_uint16 &b, const v_uint64 &c)

v_uint32	cv::v_dotprod_expand_fast (const v_uint8 &a, const v_uint8 &b)

v_uint32	cv::v_dotprod_expand_fast (const v_uint8 &a, const v_uint8 &b, const v_uint32 &c)

v_int32	cv::v_dotprod_fast (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_dotprod_fast (const v_int16 &a, const v_int16 &b, const v_int32 &c)

v_int64	cv::v_dotprod_fast (const v_int32 &a, const v_int32 &b)

v_int64	cv::v_dotprod_fast (const v_int32 &a, const v_int32 &b, const v_int64 &c)

v_float32	cv::v_eq (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_eq (const v_float64 &a, const v_float64 &b)

v_int16	cv::v_eq (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_eq (const v_int32 &a, const v_int32 &b)

v_int64	cv::v_eq (const v_int64 &a, const v_int64 &b)

v_int8	cv::v_eq (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_eq (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_eq (const v_uint32 &a, const v_uint32 &b)

v_uint64	cv::v_eq (const v_uint64 &a, const v_uint64 &b)

v_uint8	cv::v_eq (const v_uint8 &a, const v_uint8 &b)

void	cv::v_expand (const v_int16 &a, v_int32 &b0, v_int32 &b1)

void	cv::v_expand (const v_int32 &a, v_int64 &b0, v_int64 &b1)

void	cv::v_expand (const v_int8 &a, v_int16 &b0, v_int16 &b1)

void	cv::v_expand (const v_uint16 &a, v_uint32 &b0, v_uint32 &b1)

void	cv::v_expand (const v_uint32 &a, v_uint64 &b0, v_uint64 &b1)

void	cv::v_expand (const v_uint8 &a, v_uint16 &b0, v_uint16 &b1)

v_int32	cv::v_expand_high (const v_int16 &a)

v_int64	cv::v_expand_high (const v_int32 &a)

v_int16	cv::v_expand_high (const v_int8 &a)

v_uint32	cv::v_expand_high (const v_uint16 &a)

v_uint64	cv::v_expand_high (const v_uint32 &a)

v_uint16	cv::v_expand_high (const v_uint8 &a)

v_int32	cv::v_expand_low (const v_int16 &a)

v_int64	cv::v_expand_low (const v_int32 &a)

v_int16	cv::v_expand_low (const v_int8 &a)

v_uint32	cv::v_expand_low (const v_uint16 &a)

v_uint64	cv::v_expand_low (const v_uint32 &a)

v_uint16	cv::v_expand_low (const v_uint8 &a)

template<int s = 0>
v_float32	cv::v_extract (const v_float32 &a, const v_float32 &b, int i=s)

template<int s = 0>
v_float64	cv::v_extract (const v_float64 &a, const v_float64 &b, int i=s)

template<int s = 0>
v_int16	cv::v_extract (const v_int16 &a, const v_int16 &b, int i=s)

template<int s = 0>
v_int32	cv::v_extract (const v_int32 &a, const v_int32 &b, int i=s)

template<int s = 0>
v_int64	cv::v_extract (const v_int64 &a, const v_int64 &b, int i=s)

template<int s = 0>
v_int8	cv::v_extract (const v_int8 &a, const v_int8 &b, int i=s)

template<int s = 0>
v_uint16	cv::v_extract (const v_uint16 &a, const v_uint16 &b, int i=s)

template<int s = 0>
v_uint32	cv::v_extract (const v_uint32 &a, const v_uint32 &b, int i=s)

template<int s = 0>
v_uint64	cv::v_extract (const v_uint64 &a, const v_uint64 &b, int i=s)

template<int s = 0>
v_uint8	cv::v_extract (const v_uint8 &a, const v_uint8 &b, int i=s)

float	cv::v_extract_highest (v_float32 v)

double	cv::v_extract_highest (v_float64 v)

short	cv::v_extract_highest (v_int16 v)

int	cv::v_extract_highest (v_int32 v)

int64	cv::v_extract_highest (v_int64 v)

schar	cv::v_extract_highest (v_int8 v)

ushort	cv::v_extract_highest (v_uint16 v)

unsigned int	cv::v_extract_highest (v_uint32 v)

uint64	cv::v_extract_highest (v_uint64 v)

uchar	cv::v_extract_highest (v_uint8 v)

template<int s = 0>
float	cv::v_extract_n (v_float32 v, int i=s)

template<int s = 0>
double	cv::v_extract_n (v_float64 v, int i=s)

template<int s = 0>
short	cv::v_extract_n (v_int16 v, int i=s)

template<int s = 0>
int	cv::v_extract_n (v_int32 v, int i=s)

template<int s = 0>
int64	cv::v_extract_n (v_int64 v, int i=s)

template<int s = 0>
schar	cv::v_extract_n (v_int8 v, int i=s)

template<int s = 0>
ushort	cv::v_extract_n (v_uint16 v, int i=s)

template<int s = 0>
unsigned int	cv::v_extract_n (v_uint32 v, int i=s)

template<int s = 0>
uint64	cv::v_extract_n (v_uint64 v, int i=s)

template<int s = 0>
uchar	cv::v_extract_n (v_uint8 v, int i=s)

v_int32	cv::v_floor (const v_float32 &a)

v_int32	cv::v_floor (const v_float64 &a)

v_float32	cv::v_fma (const v_float32 &a, const v_float32 &b, const v_float32 &c)

v_float64	cv::v_fma (const v_float64 &a, const v_float64 &b, const v_float64 &c)

v_int32	cv::v_fma (const v_int32 &a, const v_int32 &b, const v_int32 &c)

v_float32	cv::v_ge (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_ge (const v_float64 &a, const v_float64 &b)

v_int16	cv::v_ge (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_ge (const v_int32 &a, const v_int32 &b)

v_int64	cv::v_ge (const v_int64 &a, const v_int64 &b)

v_int8	cv::v_ge (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_ge (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_ge (const v_uint32 &a, const v_uint32 &b)

v_uint64	cv::v_ge (const v_uint64 &a, const v_uint64 &b)

v_uint8	cv::v_ge (const v_uint8 &a, const v_uint8 &b)

float	cv::v_get0 (const v_float32 &v)

double	cv::v_get0 (const v_float64 &v)

short	cv::v_get0 (const v_int16 &v)

int	cv::v_get0 (const v_int32 &v)

int64	cv::v_get0 (const v_int64 &v)

schar	cv::v_get0 (const v_int8 &v)

ushort	cv::v_get0 (const v_uint16 &v)

unsigned	cv::v_get0 (const v_uint32 &v)

uint64	cv::v_get0 (const v_uint64 &v)

uchar	cv::v_get0 (const v_uint8 &v)

v_float32	cv::v_gt (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_gt (const v_float64 &a, const v_float64 &b)

v_int16	cv::v_gt (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_gt (const v_int32 &a, const v_int32 &b)

v_int64	cv::v_gt (const v_int64 &a, const v_int64 &b)

v_int8	cv::v_gt (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_gt (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_gt (const v_uint32 &a, const v_uint32 &b)

v_uint64	cv::v_gt (const v_uint64 &a, const v_uint64 &b)

v_uint8	cv::v_gt (const v_uint8 &a, const v_uint8 &b)

static v_int32	cv::v_hadd (v_int16 a)

static v_int64	cv::v_hadd (v_int32 a)

static v_int16	cv::v_hadd (v_int8 a)

static v_uint32	cv::v_hadd (v_uint16 a)

static v_uint64	cv::v_hadd (v_uint32 a)

static v_uint16	cv::v_hadd (v_uint8 a)

static v_int32	cv::v_hadd (vint32m2_t a)

static v_int64	cv::v_hadd (vint64m2_t a)

v_float32	cv::v_interleave_pairs (const v_float32 &vec)

v_int16	cv::v_interleave_pairs (const v_int16 &vec)

v_int32	cv::v_interleave_pairs (const v_int32 &vec)

v_int8	cv::v_interleave_pairs (const v_int8 &vec)

v_uint16	cv::v_interleave_pairs (const v_uint16 &vec)

v_uint32	cv::v_interleave_pairs (const v_uint32 &vec)

v_uint8	cv::v_interleave_pairs (const v_uint8 &vec)

v_float32	cv::v_interleave_quads (const v_float32 &vec)

v_int16	cv::v_interleave_quads (const v_int16 &vec)

v_int32	cv::v_interleave_quads (const v_int32 &vec)

v_int8	cv::v_interleave_quads (const v_int8 &vec)

v_uint16	cv::v_interleave_quads (const v_uint16 &vec)

v_uint32	cv::v_interleave_quads (const v_uint32 &vec)

v_uint8	cv::v_interleave_quads (const v_uint8 &vec)

v_float32	cv::v_invsqrt (const v_float32 &x)

v_float64	cv::v_invsqrt (const v_float64 &x)

v_float32	cv::v_le (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_le (const v_float64 &a, const v_float64 &b)

v_int16	cv::v_le (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_le (const v_int32 &a, const v_int32 &b)

v_int64	cv::v_le (const v_int64 &a, const v_int64 &b)

v_int8	cv::v_le (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_le (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_le (const v_uint32 &a, const v_uint32 &b)

v_uint64	cv::v_le (const v_uint64 &a, const v_uint64 &b)

v_uint8	cv::v_le (const v_uint8 &a, const v_uint8 &b)

v_float64x2	cv::v_load (const double *ptr)

v_float32x4	cv::v_load (const float *ptr)

v_int32x4	cv::v_load (const int *ptr)

v_int64x2	cv::v_load (const int64 *ptr)

v_int8x16	cv::v_load (const schar *ptr)

v_int16x8	cv::v_load (const short *ptr)

v_uint8x16	cv::v_load (const uchar *ptr)

v_uint64x2	cv::v_load (const uint64 *ptr)

v_uint32	cv::v_load (const unsigned int *ptr)

v_uint16x8	cv::v_load (const ushort *ptr)

v_float64	cv::v_load (std::initializer_list< double > nScalars)

v_float32	cv::v_load (std::initializer_list< float > nScalars)

v_int32	cv::v_load (std::initializer_list< int > nScalars)

v_int64	cv::v_load (std::initializer_list< int64 > nScalars)

v_int8	cv::v_load (std::initializer_list< schar > nScalars)

v_int16	cv::v_load (std::initializer_list< short > nScalars)

v_uint8	cv::v_load (std::initializer_list< uchar > nScalars)

v_uint64	cv::v_load (std::initializer_list< uint64 > nScalars)

v_uint32	cv::v_load (std::initializer_list< unsigned int > nScalars)

v_uint16	cv::v_load (std::initializer_list< ushort > nScalars)

v_float64x2	cv::v_load_aligned (const double *ptr)

v_float32x4	cv::v_load_aligned (const float *ptr)

v_int32x4	cv::v_load_aligned (const int *ptr)

v_int64x2	cv::v_load_aligned (const int64 *ptr)

v_int8x16	cv::v_load_aligned (const schar *ptr)

v_int16x8	cv::v_load_aligned (const short *ptr)

v_uint8x16	cv::v_load_aligned (const uchar *ptr)

v_uint64x2	cv::v_load_aligned (const uint64 *ptr)

v_uint32	cv::v_load_aligned (const unsigned int *ptr)

v_uint16x8	cv::v_load_aligned (const ushort *ptr)

void	cv::v_load_deinterleave (const double *ptr, v_float64 &a, v_float64 &b)

void	cv::v_load_deinterleave (const double *ptr, v_float64 &a, v_float64 &b, v_float64 &c)

void	cv::v_load_deinterleave (const double *ptr, v_float64 &a, v_float64 &b, v_float64 &c, v_float64 &d)

void	cv::v_load_deinterleave (const float *ptr, v_float32 &a, v_float32 &b)

void	cv::v_load_deinterleave (const float *ptr, v_float32 &a, v_float32 &b, v_float32 &c)

void	cv::v_load_deinterleave (const float *ptr, v_float32 &a, v_float32 &b, v_float32 &c, v_float32 &d)

void	cv::v_load_deinterleave (const int *ptr, v_int32 &a, v_int32 &b)

void	cv::v_load_deinterleave (const int *ptr, v_int32 &a, v_int32 &b, v_int32 &c)

void	cv::v_load_deinterleave (const int *ptr, v_int32 &a, v_int32 &b, v_int32 &c, v_int32 &d)

void	cv::v_load_deinterleave (const int64 *ptr, v_int64 &a, v_int64 &b)

void	cv::v_load_deinterleave (const int64 *ptr, v_int64 &a, v_int64 &b, v_int64 &c)

void	cv::v_load_deinterleave (const int64 *ptr, v_int64 &a, v_int64 &b, v_int64 &c, v_int64 &d)

void	cv::v_load_deinterleave (const schar *ptr, v_int8 &a, v_int8 &b)

void	cv::v_load_deinterleave (const schar *ptr, v_int8 &a, v_int8 &b, v_int8 &c)

void	cv::v_load_deinterleave (const schar *ptr, v_int8 &a, v_int8 &b, v_int8 &c, v_int8 &d)

void	cv::v_load_deinterleave (const short *ptr, v_int16 &a, v_int16 &b)

void	cv::v_load_deinterleave (const short *ptr, v_int16 &a, v_int16 &b, v_int16 &c)

void	cv::v_load_deinterleave (const short *ptr, v_int16 &a, v_int16 &b, v_int16 &c, v_int16 &d)

void	cv::v_load_deinterleave (const uchar *ptr, v_uint8 &a, v_uint8 &b)

void	cv::v_load_deinterleave (const uchar *ptr, v_uint8 &a, v_uint8 &b, v_uint8 &c)

void	cv::v_load_deinterleave (const uchar *ptr, v_uint8 &a, v_uint8 &b, v_uint8 &c, v_uint8 &d)

void	cv::v_load_deinterleave (const uint64 *ptr, v_uint64 &a, v_uint64 &b)

void	cv::v_load_deinterleave (const uint64 *ptr, v_uint64 &a, v_uint64 &b, v_uint64 &c)

void	cv::v_load_deinterleave (const uint64 *ptr, v_uint64 &a, v_uint64 &b, v_uint64 &c, v_uint64 &d)

void	cv::v_load_deinterleave (const unsigned *ptr, v_uint32 &a, v_uint32 &b)

void	cv::v_load_deinterleave (const unsigned *ptr, v_uint32 &a, v_uint32 &b, v_uint32 &c)

void	cv::v_load_deinterleave (const unsigned *ptr, v_uint32 &a, v_uint32 &b, v_uint32 &c, v_uint32 &d)

void	cv::v_load_deinterleave (const ushort *ptr, v_uint16 &a, v_uint16 &b)

void	cv::v_load_deinterleave (const ushort *ptr, v_uint16 &a, v_uint16 &b, v_uint16 &c)

void	cv::v_load_deinterleave (const ushort *ptr, v_uint16 &a, v_uint16 &b, v_uint16 &c, v_uint16 &d)

v_reg< float, simd128_width/sizeof(float)>	cv::v_load_expand (const float16_t *ptr)

v_int64x2	cv::v_load_expand (const int *ptr)

v_int16x8	cv::v_load_expand (const schar *ptr)

v_int32x4	cv::v_load_expand (const short *ptr)

v_uint16x8	cv::v_load_expand (const uchar *ptr)

v_uint64x2	cv::v_load_expand (const uint *ptr)

v_uint32x4	cv::v_load_expand (const ushort *ptr)

v_int32x4	cv::v_load_expand_q (const schar *ptr)

v_uint32x4	cv::v_load_expand_q (const uchar *ptr)

template<typename... Targs>
v_float32	cv::v_load_f32 (Targs... nScalars)

template<typename... Targs>
v_float64	cv::v_load_f64 (Targs... nScalars)

v_float64x2	cv::v_load_halves (const double ptr0, const double ptr1)

v_float32x4	cv::v_load_halves (const float ptr0, const float ptr1)

v_int32x4	cv::v_load_halves (const int ptr0, const int ptr1)

v_int64x2	cv::v_load_halves (const int64 ptr0, const int64 ptr1)

v_int8x16	cv::v_load_halves (const schar ptr0, const schar ptr1)

v_int16x8	cv::v_load_halves (const short ptr0, const short ptr1)

v_uint8x16	cv::v_load_halves (const uchar ptr0, const uchar ptr1)

v_uint64x2	cv::v_load_halves (const uint64 ptr0, const uint64 ptr1)

v_uint32	cv::v_load_halves (const unsigned int ptr0, const unsigned int ptr1)

v_uint16x8	cv::v_load_halves (const ushort ptr0, const ushort ptr1)

template<typename... Targs>
v_int16	cv::v_load_i16 (Targs... nScalars)

template<typename... Targs>
v_int32	cv::v_load_i32 (Targs... nScalars)

template<typename... Targs>
v_int64	cv::v_load_i64 (Targs... nScalars)

template<typename... Targs>
v_int8	cv::v_load_i8 (Targs... nScalars)

v_float64x2	cv::v_load_low (const double *ptr)

v_float32x4	cv::v_load_low (const float *ptr)

v_int32x4	cv::v_load_low (const int *ptr)

v_int64x2	cv::v_load_low (const int64 *ptr)

v_int8x16	cv::v_load_low (const schar *ptr)

v_int16x8	cv::v_load_low (const short *ptr)

v_uint8x16	cv::v_load_low (const uchar *ptr)

v_uint64x2	cv::v_load_low (const uint64 *ptr)

v_uint32	cv::v_load_low (const unsigned int *ptr)

v_uint16x8	cv::v_load_low (const ushort *ptr)

template<typename... Targs>
v_uint16	cv::v_load_u16 (Targs... nScalars)

template<typename... Targs>
v_uint32	cv::v_load_u32 (Targs... nScalars)

template<typename... Targs>
v_uint64	cv::v_load_u64 (Targs... nScalars)

template<typename... Targs>
v_uint8	cv::v_load_u8 (Targs... nScalars)

v_float32	cv::v_lt (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_lt (const v_float64 &a, const v_float64 &b)

v_int16	cv::v_lt (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_lt (const v_int32 &a, const v_int32 &b)

v_int64	cv::v_lt (const v_int64 &a, const v_int64 &b)

v_int8	cv::v_lt (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_lt (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_lt (const v_uint32 &a, const v_uint32 &b)

v_uint64	cv::v_lt (const v_uint64 &a, const v_uint64 &b)

v_uint8	cv::v_lt (const v_uint8 &a, const v_uint8 &b)

v_float64x2	cv::v_lut (const double tab, const int idx)

v_float64	cv::v_lut (const double *tab, const v_int32 &vidx)

v_float32x4	cv::v_lut (const float tab, const int idx)

v_float32	cv::v_lut (const float *tab, const v_int32 &vidx)

v_int32x4	cv::v_lut (const int tab, const int idx)

v_int32	cv::v_lut (const int *tab, const v_int32 &vidx)

v_int64x2	cv::v_lut (const int64_t tab, const int idx)

v_int8x16	cv::v_lut (const schar tab, const int idx)

v_int16x8	cv::v_lut (const short tab, const int idx)

v_uint8x16	cv::v_lut (const uchar tab, const int idx)

v_uint64x2	cv::v_lut (const uint64 tab, const int idx)

v_uint32x4	cv::v_lut (const unsigned tab, const int idx)

v_uint32	cv::v_lut (const unsigned *tab, const v_int32 &vidx)

v_uint16x8	cv::v_lut (const ushort tab, const int idx)

v_float64x2	cv::v_lut_pairs (const double tab, const int idx)

v_float32x4	cv::v_lut_pairs (const float tab, const int idx)

v_int32x4	cv::v_lut_pairs (const int tab, const int idx)

v_int64	cv::v_lut_pairs (const int64_t tab, const int idx)

v_int8x16	cv::v_lut_pairs (const schar tab, const int idx)

v_int16x8	cv::v_lut_pairs (const short tab, const int idx)

v_uint8x16	cv::v_lut_pairs (const uchar tab, const int idx)

v_uint64x2	cv::v_lut_pairs (const uint64 tab, const int idx)

v_uint32x4	cv::v_lut_pairs (const unsigned tab, const int idx)

v_uint16x8	cv::v_lut_pairs (const ushort tab, const int idx)

v_float64	cv::v_lut_quads (const double tab, const int idx)

v_float32x4	cv::v_lut_quads (const float tab, const int idx)

v_int32x4	cv::v_lut_quads (const int tab, const int idx)

v_int64	cv::v_lut_quads (const int64_t tab, const int idx)

v_int8x16	cv::v_lut_quads (const schar tab, const int idx)

v_int16x8	cv::v_lut_quads (const short tab, const int idx)

v_uint8x16	cv::v_lut_quads (const uchar tab, const int idx)

v_uint64	cv::v_lut_quads (const uint64 tab, const int idx)

v_uint32x4	cv::v_lut_quads (const unsigned tab, const int idx)

v_uint16x8	cv::v_lut_quads (const ushort tab, const int idx)

v_float32	cv::v_magnitude (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_magnitude (const v_float64 &a, const v_float64 &b)

v_float32	cv::v_matmul (const v_float32 &v, const v_float32 &m0, const v_float32 &m1, const v_float32 &m2, const v_float32 &m3)

v_float32	cv::v_matmuladd (const v_float32 &v, const v_float32 &m0, const v_float32 &m1, const v_float32 &m2, const v_float32 &a)

v_float32	cv::v_max (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_max (const v_float64 &a, const v_float64 &b)

v_int16	cv::v_max (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_max (const v_int32 &a, const v_int32 &b)

v_int8	cv::v_max (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_max (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_max (const v_uint32 &a, const v_uint32 &b)

v_uint8	cv::v_max (const v_uint8 &a, const v_uint8 &b)

v_float32	cv::v_min (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_min (const v_float64 &a, const v_float64 &b)

v_int16	cv::v_min (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_min (const v_int32 &a, const v_int32 &b)

v_int8	cv::v_min (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_min (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_min (const v_uint32 &a, const v_uint32 &b)

v_uint8	cv::v_min (const v_uint8 &a, const v_uint8 &b)

v_float32	cv::v_mul (const v_float32 &a, const v_float32 &b)

template<typename... Args>
v_float32	cv::v_mul (const v_float32 &f1, const v_float32 &f2, const Args &... vf)

v_float64	cv::v_mul (const v_float64 &a, const v_float64 &b)

template<typename... Args>
v_float64	cv::v_mul (const v_float64 &f1, const v_float64 &f2, const Args &... vf)

v_int16	cv::v_mul (const v_int16 &a, const v_int16 &b)

template<typename... Args>
v_int16	cv::v_mul (const v_int16 &a1, const v_int16 &a2, const Args &... va)

v_int32	cv::v_mul (const v_int32 &a, const v_int32 &b)

template<typename... Args>
v_int32	cv::v_mul (const v_int32 &f1, const v_int32 &f2, const Args &... vf)

v_int8	cv::v_mul (const v_int8 &a, const v_int8 &b)

template<typename... Args>
v_int8	cv::v_mul (const v_int8 &a1, const v_int8 &a2, const Args &... va)

v_uint16	cv::v_mul (const v_uint16 &a, const v_uint16 &b)

template<typename... Args>
v_uint16	cv::v_mul (const v_uint16 &a1, const v_uint16 &a2, const Args &... va)

v_uint32	cv::v_mul (const v_uint32 &a, const v_uint32 &b)

template<typename... Args>
v_uint32	cv::v_mul (const v_uint32 &f1, const v_uint32 &f2, const Args &... vf)

v_uint8	cv::v_mul (const v_uint8 &a, const v_uint8 &b)

template<typename... Args>
v_uint8	cv::v_mul (const v_uint8 &a1, const v_uint8 &a2, const Args &... va)

void	cv::v_mul_expand (const v_int16 &a, const v_int16 &b, v_int32 &c, v_int32 &d)

void	cv::v_mul_expand (const v_int8 &a, const v_int8 &b, v_int16 &c, v_int16 &d)

void	cv::v_mul_expand (const v_uint16 &a, const v_uint16 &b, v_uint32 &c, v_uint32 &d)

void	cv::v_mul_expand (const v_uint32 &a, const v_uint32 &b, v_uint64 &c, v_uint64 &d)

void	cv::v_mul_expand (const v_uint8 &a, const v_uint8 &b, v_uint16 &c, v_uint16 &d)

v_int16	cv::v_mul_hi (const v_int16 &a, const v_int16 &b)

v_uint16	cv::v_mul_hi (const v_uint16 &a, const v_uint16 &b)

v_int16	cv::v_mul_wrap (const v_int16 &a, const v_int16 &b)

v_int8	cv::v_mul_wrap (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_mul_wrap (const v_uint16 &a, const v_uint16 &b)

v_uint8	cv::v_mul_wrap (const v_uint8 &a, const v_uint8 &b)

v_float32	cv::v_muladd (const v_float32 &a, const v_float32 &b, const v_float32 &c)

v_float64	cv::v_muladd (const v_float64 &a, const v_float64 &b, const v_float64 &c)

v_int32	cv::v_muladd (const v_int32 &a, const v_int32 &b, const v_int32 &c)

v_float32	cv::v_ne (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_ne (const v_float64 &a, const v_float64 &b)

v_int16	cv::v_ne (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_ne (const v_int32 &a, const v_int32 &b)

v_int64	cv::v_ne (const v_int64 &a, const v_int64 &b)

v_int8	cv::v_ne (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_ne (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_ne (const v_uint32 &a, const v_uint32 &b)

v_uint64	cv::v_ne (const v_uint64 &a, const v_uint64 &b)

v_uint8	cv::v_ne (const v_uint8 &a, const v_uint8 &b)

v_float32	cv::v_not (const v_float32 &a)

v_float64	cv::v_not (const v_float64 &a)

v_int16	cv::v_not (const v_int16 &a)

v_int32	cv::v_not (const v_int32 &a)

v_int64	cv::v_not (const v_int64 &a)

v_int8	cv::v_not (const v_int8 &a)

v_uint16	cv::v_not (const v_uint16 &a)

v_uint32	cv::v_not (const v_uint32 &a)

v_uint64	cv::v_not (const v_uint64 &a)

v_uint8	cv::v_not (const v_uint8 &a)

v_float32	cv::v_not_nan (const v_float32 &a)

v_float64	cv::v_not_nan (const v_float64 &a)

v_float32	cv::v_or (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_or (const v_float64 &a, const v_float64 &b)

v_int16	cv::v_or (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_or (const v_int32 &a, const v_int32 &b)

v_int64	cv::v_or (const v_int64 &a, const v_int64 &b)

v_int8	cv::v_or (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_or (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_or (const v_uint32 &a, const v_uint32 &b)

v_uint64	cv::v_or (const v_uint64 &a, const v_uint64 &b)

v_uint8	cv::v_or (const v_uint8 &a, const v_uint8 &b)

v_int8	cv::v_pack (const v_int16 &a, const v_int16 &b)

v_int16	cv::v_pack (const v_int32 &a, const v_int32 &b)

v_int32	cv::v_pack (const v_int64 &a, const v_int64 &b)

v_uint8	cv::v_pack (const v_uint16 &a, const v_uint16 &b)

v_uint16	cv::v_pack (const v_uint32 &a, const v_uint32 &b)

v_uint32	cv::v_pack (const v_uint64 &a, const v_uint64 &b)

v_uint8	cv::v_pack_b (const v_uint16 &a, const v_uint16 &b)

v_uint8	cv::v_pack_b (const v_uint32 &a, const v_uint32 &b, const v_uint32 &c, const v_uint32 &d)

v_uint8	cv::v_pack_b (const v_uint64 &a, const v_uint64 &b, const v_uint64 &c, const v_uint64 &d, const v_uint64 &e, const v_uint64 &f, const v_uint64 &g, const v_uint64 &h)

void	cv::v_pack_store (float16_t *ptr, const v_float32 &v)

void	cv::v_pack_store (int *ptr, const v_int64 &a)

void	cv::v_pack_store (schar *ptr, const v_int16 &a)

void	cv::v_pack_store (short *ptr, const v_int32 &a)

void	cv::v_pack_store (uchar *ptr, const v_uint16 &a)

void	cv::v_pack_store (unsigned *ptr, const v_uint64 &a)

void	cv::v_pack_store (ushort *ptr, const v_uint32 &a)

v_float32	cv::v_pack_triplets (const v_float32 &vec)

v_float64	cv::v_pack_triplets (const v_float64 &vec)

v_int16	cv::v_pack_triplets (const v_int16 &vec)

v_int32	cv::v_pack_triplets (const v_int32 &vec)

v_int64	cv::v_pack_triplets (const v_int64 &vec)

v_int8	cv::v_pack_triplets (const v_int8 &vec)

v_uint16	cv::v_pack_triplets (const v_uint16 &vec)

v_uint32	cv::v_pack_triplets (const v_uint32 &vec)

v_uint64	cv::v_pack_triplets (const v_uint64 &vec)

v_uint8	cv::v_pack_triplets (const v_uint8 &vec)

v_uint8	cv::v_pack_u (const v_int16 &a, const v_int16 &b)

v_uint16	cv::v_pack_u (const v_int32 &a, const v_int32 &b)

void	cv::v_pack_u_store (uchar *ptr, const v_int16 &a)

void	cv::v_pack_u_store (ushort *ptr, const v_int32 &a)

v_uint16	cv::v_popcount (const v_int16 &a)

v_uint32	cv::v_popcount (const v_int32 &a)

v_uint64	cv::v_popcount (const v_int64 &a)

v_uint8	cv::v_popcount (const v_int8 &a)

v_uint16	cv::v_popcount (const v_uint16 &a)

v_uint32	cv::v_popcount (const v_uint32 &a)

v_uint64	cv::v_popcount (const v_uint64 &a)

v_uint8	cv::v_popcount (const v_uint8 &a)

void	cv::v_recombine (const v_float32 &a, const v_float32 &b, v_float32 &c, v_float32 &d)

void	cv::v_recombine (const v_float64 &a, const v_float64 &b, v_float64 &c, v_float64 &d)

void	cv::v_recombine (const v_int16 &a, const v_int16 &b, v_int16 &c, v_int16 &d)

void	cv::v_recombine (const v_int32 &a, const v_int32 &b, v_int32 &c, v_int32 &d)

void	cv::v_recombine (const v_int8 &a, const v_int8 &b, v_int8 &c, v_int8 &d)

void	cv::v_recombine (const v_uint16 &a, const v_uint16 &b, v_uint16 &c, v_uint16 &d)

void	cv::v_recombine (const v_uint32 &a, const v_uint32 &b, v_uint32 &c, v_uint32 &d)

void	cv::v_recombine (const v_uint8 &a, const v_uint8 &b, v_uint8 &c, v_uint8 &d)

float	cv::v_reduce_max (const v_float32 &a)

short	cv::v_reduce_max (const v_int16 &a)

int	cv::v_reduce_max (const v_int32 &a)

schar	cv::v_reduce_max (const v_int8 &a)

ushort	cv::v_reduce_max (const v_uint16 &a)

unsigned	cv::v_reduce_max (const v_uint32 &a)

uchar	cv::v_reduce_max (const v_uint8 &a)

float	cv::v_reduce_min (const v_float32 &a)

short	cv::v_reduce_min (const v_int16 &a)

int	cv::v_reduce_min (const v_int32 &a)

schar	cv::v_reduce_min (const v_int8 &a)

ushort	cv::v_reduce_min (const v_uint16 &a)

unsigned	cv::v_reduce_min (const v_uint32 &a)

uchar	cv::v_reduce_min (const v_uint8 &a)

float	cv::v_reduce_sad (const v_float32 &a, const v_float32 &b)

unsigned	cv::v_reduce_sad (const v_int16 &a, const v_int16 &b)

unsigned	cv::v_reduce_sad (const v_int32 &a, const v_int32 &b)

unsigned	cv::v_reduce_sad (const v_int8 &a, const v_int8 &b)

unsigned	cv::v_reduce_sad (const v_uint16 &a, const v_uint16 &b)

unsigned	cv::v_reduce_sad (const v_uint32 &a, const v_uint32 &b)

unsigned	cv::v_reduce_sad (const v_uint8 &a, const v_uint8 &b)

float	cv::v_reduce_sum (const v_float32 &a)

float	cv::v_reduce_sum (const v_float64 &a)

int	cv::v_reduce_sum (const v_int16 &a)

int	cv::v_reduce_sum (const v_int32 &a)

int64	cv::v_reduce_sum (const v_int64 &a)

int	cv::v_reduce_sum (const v_int8 &a)

unsigned	cv::v_reduce_sum (const v_uint16 &a)

unsigned	cv::v_reduce_sum (const v_uint32 &a)

uint64	cv::v_reduce_sum (const v_uint64 &a)

unsigned	cv::v_reduce_sum (const v_uint8 &a)

v_float32	cv::v_reduce_sum4 (const v_float32 &a, const v_float32 &b, const v_float32 &c, const v_float32 &d)

v_float32	cv::v_reinterpret_as_f32 (const v_float32 &v)

v_float32	cv::v_reinterpret_as_f32 (const v_float64 &v)

v_float32	cv::v_reinterpret_as_f32 (const v_int16 &v)

v_float32	cv::v_reinterpret_as_f32 (const v_int32 &v)

v_float32	cv::v_reinterpret_as_f32 (const v_int64 &v)

v_float32	cv::v_reinterpret_as_f32 (const v_int8 &v)

v_float32	cv::v_reinterpret_as_f32 (const v_uint16 &v)

v_float32	cv::v_reinterpret_as_f32 (const v_uint32 &v)

v_float32	cv::v_reinterpret_as_f32 (const v_uint64 &v)

v_float32	cv::v_reinterpret_as_f32 (const v_uint8 &v)

v_float64	cv::v_reinterpret_as_f64 (const v_float32 &v)

v_float64	cv::v_reinterpret_as_f64 (const v_float64 &v)

v_float64	cv::v_reinterpret_as_f64 (const v_int16 &v)

v_float64	cv::v_reinterpret_as_f64 (const v_int32 &v)

v_float64	cv::v_reinterpret_as_f64 (const v_int64 &v)

v_float64	cv::v_reinterpret_as_f64 (const v_int8 &v)

v_float64	cv::v_reinterpret_as_f64 (const v_uint16 &v)

v_float64	cv::v_reinterpret_as_f64 (const v_uint32 &v)

v_float64	cv::v_reinterpret_as_f64 (const v_uint64 &v)

v_float64	cv::v_reinterpret_as_f64 (const v_uint8 &v)

v_int16	cv::v_reinterpret_as_s16 (const v_float32 &v)

v_int16	cv::v_reinterpret_as_s16 (const v_float64 &v)

v_int16	cv::v_reinterpret_as_s16 (const v_int16 &v)

v_int16	cv::v_reinterpret_as_s16 (const v_int32 &v)

v_int16	cv::v_reinterpret_as_s16 (const v_int64 &v)

v_int16	cv::v_reinterpret_as_s16 (const v_int8 &v)

v_int16	cv::v_reinterpret_as_s16 (const v_uint16 &v)

v_int16	cv::v_reinterpret_as_s16 (const v_uint32 &v)

v_int16	cv::v_reinterpret_as_s16 (const v_uint64 &v)

v_int16	cv::v_reinterpret_as_s16 (const v_uint8 &v)

v_int32	cv::v_reinterpret_as_s32 (const v_float32 &v)

v_int32	cv::v_reinterpret_as_s32 (const v_float64 &v)

v_int32	cv::v_reinterpret_as_s32 (const v_int16 &v)

v_int32	cv::v_reinterpret_as_s32 (const v_int32 &v)

v_int32	cv::v_reinterpret_as_s32 (const v_int64 &v)

v_int32	cv::v_reinterpret_as_s32 (const v_int8 &v)

v_int32	cv::v_reinterpret_as_s32 (const v_uint16 &v)

v_int32	cv::v_reinterpret_as_s32 (const v_uint32 &v)

v_int32	cv::v_reinterpret_as_s32 (const v_uint64 &v)

v_int32	cv::v_reinterpret_as_s32 (const v_uint8 &v)

v_int64	cv::v_reinterpret_as_s64 (const v_float32 &v)

v_int64	cv::v_reinterpret_as_s64 (const v_float64 &v)

v_int64	cv::v_reinterpret_as_s64 (const v_int16 &v)

v_int64	cv::v_reinterpret_as_s64 (const v_int32 &v)

v_int64	cv::v_reinterpret_as_s64 (const v_int64 &v)

v_int64	cv::v_reinterpret_as_s64 (const v_int8 &v)

v_int64	cv::v_reinterpret_as_s64 (const v_uint16 &v)

v_int64	cv::v_reinterpret_as_s64 (const v_uint32 &v)

v_int64	cv::v_reinterpret_as_s64 (const v_uint64 &v)

v_int64	cv::v_reinterpret_as_s64 (const v_uint8 &v)

v_int8	cv::v_reinterpret_as_s8 (const v_float32 &v)

v_int8	cv::v_reinterpret_as_s8 (const v_float64 &v)

v_int8	cv::v_reinterpret_as_s8 (const v_int16 &v)

v_int8	cv::v_reinterpret_as_s8 (const v_int32 &v)

v_int8	cv::v_reinterpret_as_s8 (const v_int64 &v)

v_int8	cv::v_reinterpret_as_s8 (const v_int8 &v)

v_int8	cv::v_reinterpret_as_s8 (const v_uint16 &v)

v_int8	cv::v_reinterpret_as_s8 (const v_uint32 &v)

v_int8	cv::v_reinterpret_as_s8 (const v_uint64 &v)

v_int8	cv::v_reinterpret_as_s8 (const v_uint8 &v)

v_uint16	cv::v_reinterpret_as_u16 (const v_float32 &v)

v_uint16	cv::v_reinterpret_as_u16 (const v_float64 &v)

v_uint16	cv::v_reinterpret_as_u16 (const v_int16 &v)

v_uint16	cv::v_reinterpret_as_u16 (const v_int32 &v)

v_uint16	cv::v_reinterpret_as_u16 (const v_int64 &v)

v_uint16	cv::v_reinterpret_as_u16 (const v_int8 &v)

v_uint16	cv::v_reinterpret_as_u16 (const v_uint16 &v)

v_uint16	cv::v_reinterpret_as_u16 (const v_uint32 &v)

v_uint16	cv::v_reinterpret_as_u16 (const v_uint64 &v)

v_uint16	cv::v_reinterpret_as_u16 (const v_uint8 &v)

v_uint32	cv::v_reinterpret_as_u32 (const v_float32 &v)

v_uint32	cv::v_reinterpret_as_u32 (const v_float64 &v)

v_uint32	cv::v_reinterpret_as_u32 (const v_int16 &v)

v_uint32	cv::v_reinterpret_as_u32 (const v_int32 &v)

v_uint32	cv::v_reinterpret_as_u32 (const v_int64 &v)

v_uint32	cv::v_reinterpret_as_u32 (const v_int8 &v)

v_uint32	cv::v_reinterpret_as_u32 (const v_uint16 &v)

v_uint32	cv::v_reinterpret_as_u32 (const v_uint32 &v)

v_uint32	cv::v_reinterpret_as_u32 (const v_uint64 &v)

v_uint32	cv::v_reinterpret_as_u32 (const v_uint8 &v)

v_uint64	cv::v_reinterpret_as_u64 (const v_float32 &v)

v_uint64	cv::v_reinterpret_as_u64 (const v_float64 &v)

v_uint64	cv::v_reinterpret_as_u64 (const v_int16 &v)

v_uint64	cv::v_reinterpret_as_u64 (const v_int32 &v)

v_uint64	cv::v_reinterpret_as_u64 (const v_int64 &v)

v_uint64	cv::v_reinterpret_as_u64 (const v_int8 &v)

v_uint64	cv::v_reinterpret_as_u64 (const v_uint16 &v)

v_uint64	cv::v_reinterpret_as_u64 (const v_uint32 &v)

v_uint64	cv::v_reinterpret_as_u64 (const v_uint64 &v)

v_uint64	cv::v_reinterpret_as_u64 (const v_uint8 &v)

v_uint8	cv::v_reinterpret_as_u8 (const v_float32 &v)

v_uint8	cv::v_reinterpret_as_u8 (const v_float64 &v)

v_uint8	cv::v_reinterpret_as_u8 (const v_int16 &v)

v_uint8	cv::v_reinterpret_as_u8 (const v_int32 &v)

v_uint8	cv::v_reinterpret_as_u8 (const v_int64 &v)

v_uint8	cv::v_reinterpret_as_u8 (const v_int8 &v)

v_uint8	cv::v_reinterpret_as_u8 (const v_uint16 &v)

v_uint8	cv::v_reinterpret_as_u8 (const v_uint32 &v)

v_uint8	cv::v_reinterpret_as_u8 (const v_uint64 &v)

v_uint8	cv::v_reinterpret_as_u8 (const v_uint8 &v)

v_float32	cv::v_reverse (const v_float32 &a)

v_float64	cv::v_reverse (const v_float64 &a)

v_int16	cv::v_reverse (const v_int16 &a)

v_int32	cv::v_reverse (const v_int32 &a)

v_int64	cv::v_reverse (const v_int64 &a)

v_int8	cv::v_reverse (const v_int8 &a)

v_uint16	cv::v_reverse (const v_uint16 &a)

v_uint32	cv::v_reverse (const v_uint32 &a)

v_uint64	cv::v_reverse (const v_uint64 &a)

v_uint8	cv::v_reverse (const v_uint8 &a)

template<int n>
v_float32	cv::v_rotate_left (const v_float32 &a)

template<int n>
v_float32	cv::v_rotate_left (const v_float32 &a, const v_float32 &b)

template<int n>
v_float64	cv::v_rotate_left (const v_float64 &a)

template<int n>
v_float64	cv::v_rotate_left (const v_float64 &a, const v_float64 &b)

template<int n>
v_int16	cv::v_rotate_left (const v_int16 &a)

template<int n>
v_int16	cv::v_rotate_left (const v_int16 &a, const v_int16 &b)

template<int n>
v_int32	cv::v_rotate_left (const v_int32 &a)

template<int n>
v_int32	cv::v_rotate_left (const v_int32 &a, const v_int32 &b)

template<int n>
v_int64	cv::v_rotate_left (const v_int64 &a)

template<int n>
v_int64	cv::v_rotate_left (const v_int64 &a, const v_int64 &b)

template<int n>
v_int8	cv::v_rotate_left (const v_int8 &a)

template<int n>
v_int8	cv::v_rotate_left (const v_int8 &a, const v_int8 &b)

template<int n>
v_uint16	cv::v_rotate_left (const v_uint16 &a)

template<int n>
v_uint16	cv::v_rotate_left (const v_uint16 &a, const v_uint16 &b)

template<int n>
v_uint32	cv::v_rotate_left (const v_uint32 &a)

template<int n>
v_uint32	cv::v_rotate_left (const v_uint32 &a, const v_uint32 &b)

template<int n>
v_uint64	cv::v_rotate_left (const v_uint64 &a)

template<int n>
v_uint64	cv::v_rotate_left (const v_uint64 &a, const v_uint64 &b)

template<int n>
v_uint8	cv::v_rotate_left (const v_uint8 &a)

template<int n>
v_uint8	cv::v_rotate_left (const v_uint8 &a, const v_uint8 &b)

template<>
v_float32	cv::v_rotate_left< 0 > (const v_float32 &a)

template<>
v_float32	cv::v_rotate_left< 0 > (const v_float32 &a, const v_float32 &b)

template<>
v_float64	cv::v_rotate_left< 0 > (const v_float64 &a)

template<>
v_float64	cv::v_rotate_left< 0 > (const v_float64 &a, const v_float64 &b)

template<>
v_int16	cv::v_rotate_left< 0 > (const v_int16 &a)

template<>
v_int16	cv::v_rotate_left< 0 > (const v_int16 &a, const v_int16 &b)

template<>
v_int32	cv::v_rotate_left< 0 > (const v_int32 &a)

template<>
v_int32	cv::v_rotate_left< 0 > (const v_int32 &a, const v_int32 &b)

template<>
v_int64	cv::v_rotate_left< 0 > (const v_int64 &a)

template<>
v_int64	cv::v_rotate_left< 0 > (const v_int64 &a, const v_int64 &b)

template<>
v_int8	cv::v_rotate_left< 0 > (const v_int8 &a)

template<>
v_int8	cv::v_rotate_left< 0 > (const v_int8 &a, const v_int8 &b)

template<>
v_uint16	cv::v_rotate_left< 0 > (const v_uint16 &a)

template<>
v_uint16	cv::v_rotate_left< 0 > (const v_uint16 &a, const v_uint16 &b)

template<>
v_uint32	cv::v_rotate_left< 0 > (const v_uint32 &a)

template<>
v_uint32	cv::v_rotate_left< 0 > (const v_uint32 &a, const v_uint32 &b)

template<>
v_uint64	cv::v_rotate_left< 0 > (const v_uint64 &a)

template<>
v_uint64	cv::v_rotate_left< 0 > (const v_uint64 &a, const v_uint64 &b)

template<>
v_uint8	cv::v_rotate_left< 0 > (const v_uint8 &a)

template<>
v_uint8	cv::v_rotate_left< 0 > (const v_uint8 &a, const v_uint8 &b)

template<int n>
v_float32	cv::v_rotate_right (const v_float32 &a)

template<int n>
v_float32	cv::v_rotate_right (const v_float32 &a, const v_float32 &b)

template<int n>
v_float64	cv::v_rotate_right (const v_float64 &a)

template<int n>
v_float64	cv::v_rotate_right (const v_float64 &a, const v_float64 &b)

template<int n>
v_int16	cv::v_rotate_right (const v_int16 &a)

template<int n>
v_int16	cv::v_rotate_right (const v_int16 &a, const v_int16 &b)

template<int n>
v_int32	cv::v_rotate_right (const v_int32 &a)

template<int n>
v_int32	cv::v_rotate_right (const v_int32 &a, const v_int32 &b)

template<int n>
v_int64	cv::v_rotate_right (const v_int64 &a)

template<int n>
v_int64	cv::v_rotate_right (const v_int64 &a, const v_int64 &b)

template<int n>
v_int8	cv::v_rotate_right (const v_int8 &a)

template<int n>
v_int8	cv::v_rotate_right (const v_int8 &a, const v_int8 &b)

template<int n>
v_uint16	cv::v_rotate_right (const v_uint16 &a)

template<int n>
v_uint16	cv::v_rotate_right (const v_uint16 &a, const v_uint16 &b)

template<int n>
v_uint32	cv::v_rotate_right (const v_uint32 &a)

template<int n>
v_uint32	cv::v_rotate_right (const v_uint32 &a, const v_uint32 &b)

template<int n>
v_uint64	cv::v_rotate_right (const v_uint64 &a)

template<int n>
v_uint64	cv::v_rotate_right (const v_uint64 &a, const v_uint64 &b)

template<int n>
v_uint8	cv::v_rotate_right (const v_uint8 &a)

template<int n>
v_uint8	cv::v_rotate_right (const v_uint8 &a, const v_uint8 &b)

v_int32	cv::v_round (const v_float32 &a)

v_int32	cv::v_round (const v_float64 &a)

v_int32	cv::v_round (const v_float64 &a, const v_float64 &b)

template<int n = 0>
v_int8	cv::v_rshr_pack (const v_int16 &a, const v_int16 &b, int N=n)

template<int n = 0>
v_int16	cv::v_rshr_pack (const v_int32 &a, const v_int32 &b, int N=n)

template<int n = 0>
v_int32	cv::v_rshr_pack (const v_int64 &a, const v_int64 &b, int N=n)

template<int n = 0>
v_uint8	cv::v_rshr_pack (const v_uint16 &a, const v_uint16 &b, int N=n)

template<int n = 0>
v_uint16	cv::v_rshr_pack (const v_uint32 &a, const v_uint32 &b, int N=n)

template<int n = 0>
v_uint32	cv::v_rshr_pack (const v_uint64 &a, const v_uint64 &b, int N=n)

template<int n = 0>
void	cv::v_rshr_pack_store (int *ptr, const v_int64 &a, int N=n)

template<int n = 0>
void	cv::v_rshr_pack_store (schar *ptr, const v_int16 &a, int N=n)

template<int n = 0>
void	cv::v_rshr_pack_store (short *ptr, const v_int32 &a, int N=n)

template<int n = 0>
void	cv::v_rshr_pack_store (uchar *ptr, const v_uint16 &a, int N=n)

template<int n = 0>
void	cv::v_rshr_pack_store (unsigned *ptr, const v_uint64 &a, int N=n)

template<int n = 0>
void	cv::v_rshr_pack_store (ushort *ptr, const v_uint32 &a, int N=n)

template<int N = 0>
v_uint8	cv::v_rshr_pack_u (const v_int16 &a, const v_int16 &b, int n=N)

template<int N = 0>
v_uint16	cv::v_rshr_pack_u (const v_int32 &a, const v_int32 &b, int n=N)

template<int N = 0>
void	cv::v_rshr_pack_u_store (uchar *ptr, const v_int16 &a, int n=N)

template<int N = 0>
void	cv::v_rshr_pack_u_store (ushort *ptr, const v_int32 &a, int n=N)

int	cv::v_scan_forward (const v_float32 &a)

int	cv::v_scan_forward (const v_float64 &a)

int	cv::v_scan_forward (const v_int16 &a)

int	cv::v_scan_forward (const v_int32 &a)

int	cv::v_scan_forward (const v_int64 &a)

int	cv::v_scan_forward (const v_int8 &a)

int	cv::v_scan_forward (const v_uint16 &a)

int	cv::v_scan_forward (const v_uint32 &a)

int	cv::v_scan_forward (const v_uint64 &a)

int	cv::v_scan_forward (const v_uint8 &a)

v_float32	cv::v_select (const v_float32 &mask, const v_float32 &a, const v_float32 &b)

v_float64	cv::v_select (const v_float64 &mask, const v_float64 &a, const v_float64 &b)

v_int16	cv::v_select (const v_int16 &mask, const v_int16 &a, const v_int16 &b)

v_int32	cv::v_select (const v_int32 &mask, const v_int32 &a, const v_int32 &b)

v_int8	cv::v_select (const v_int8 &mask, const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_select (const v_uint16 &mask, const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_select (const v_uint32 &mask, const v_uint32 &a, const v_uint32 &b)

v_uint8	cv::v_select (const v_uint8 &mask, const v_uint8 &a, const v_uint8 &b)

v_uint32	cv::v_setall_u32 (uint v)

template<int s = 0>
v_int16	cv::v_shl (const v_int16 &a, int n=s)

template<int s = 0>
v_int32	cv::v_shl (const v_int32 &a, int n=s)

template<int s = 0>
v_int64	cv::v_shl (const v_int64 &a, int n=s)

template<int s = 0>
v_uint16	cv::v_shl (const v_uint16 &a, int n=s)

template<int s = 0>
v_uint32	cv::v_shl (const v_uint32 &a, int n=s)

template<int s = 0>
v_uint64	cv::v_shl (const v_uint64 &a, int n=s)

template<int s = 0>
v_int16	cv::v_shr (const v_int16 &a, int n=s)

template<int s = 0>
v_int32	cv::v_shr (const v_int32 &a, int n=s)

template<int s = 0>
v_int64	cv::v_shr (const v_int64 &a, int n=s)

template<int s = 0>
v_uint16	cv::v_shr (const v_uint16 &a, int n=s)

template<int s = 0>
v_uint32	cv::v_shr (const v_uint32 &a, int n=s)

template<int s = 0>
v_uint64	cv::v_shr (const v_uint64 &a, int n=s)

int	cv::v_signmask (const v_float32 &a)

int	cv::v_signmask (const v_float64 &a)

int	cv::v_signmask (const v_int16 &a)

int	cv::v_signmask (const v_int32 &a)

int	cv::v_signmask (const v_int64 &a)

int	cv::v_signmask (const v_int8 &a)

int64	cv::v_signmask (const v_uint16 &a)

int	cv::v_signmask (const v_uint32 &a)

int	cv::v_signmask (const v_uint64 &a)

int64	cv::v_signmask (const v_uint8 &a)

v_float32	cv::v_sqr_magnitude (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_sqr_magnitude (const v_float64 &a, const v_float64 &b)

v_float32	cv::v_sqrt (const v_float32 &x)

v_float64	cv::v_sqrt (const v_float64 &x)

void	cv::v_store (double *ptr, const v_float64 &a)

void	cv::v_store (double *ptr, const v_float64 &a, hal::StoreMode)

void	cv::v_store (float *ptr, const v_float32 &a)

void	cv::v_store (float *ptr, const v_float32 &a, hal::StoreMode)

void	cv::v_store (int *ptr, const v_int32 &a)

void	cv::v_store (int *ptr, const v_int32 &a, hal::StoreMode)

void	cv::v_store (int64 *ptr, const v_int64 &a)

void	cv::v_store (int64 *ptr, const v_int64 &a, hal::StoreMode)

void	cv::v_store (schar *ptr, const v_int8 &a)

void	cv::v_store (schar *ptr, const v_int8 &a, hal::StoreMode)

void	cv::v_store (short *ptr, const v_int16 &a)

void	cv::v_store (short *ptr, const v_int16 &a, hal::StoreMode)

void	cv::v_store (uchar *ptr, const v_uint8 &a)

void	cv::v_store (uchar *ptr, const v_uint8 &a, hal::StoreMode)

void	cv::v_store (uint64 *ptr, const v_uint64 &a)

void	cv::v_store (uint64 *ptr, const v_uint64 &a, hal::StoreMode)

void	cv::v_store (unsigned int *ptr, const v_uint32 &a)

void	cv::v_store (unsigned int *ptr, const v_uint32 &a, hal::StoreMode)

void	cv::v_store (ushort *ptr, const v_uint16 &a)

void	cv::v_store (ushort *ptr, const v_uint16 &a, hal::StoreMode)

void	cv::v_store_aligned (double *ptr, const v_float64 &a)

void	cv::v_store_aligned (float *ptr, const v_float32 &a)

void	cv::v_store_aligned (int *ptr, const v_int32 &a)

void	cv::v_store_aligned (int64 *ptr, const v_int64 &a)

void	cv::v_store_aligned (schar *ptr, const v_int8 &a)

void	cv::v_store_aligned (short *ptr, const v_int16 &a)

void	cv::v_store_aligned (uchar *ptr, const v_uint8 &a)

void	cv::v_store_aligned (uint64 *ptr, const v_uint64 &a)

void	cv::v_store_aligned (unsigned int *ptr, const v_uint32 &a)

void	cv::v_store_aligned (ushort *ptr, const v_uint16 &a)

void	cv::v_store_aligned_nocache (double *ptr, const v_float64 &a)

void	cv::v_store_aligned_nocache (float *ptr, const v_float32 &a)

void	cv::v_store_aligned_nocache (int *ptr, const v_int32 &a)

void	cv::v_store_aligned_nocache (int64 *ptr, const v_int64 &a)

void	cv::v_store_aligned_nocache (schar *ptr, const v_int8 &a)

void	cv::v_store_aligned_nocache (short *ptr, const v_int16 &a)

void	cv::v_store_aligned_nocache (uchar *ptr, const v_uint8 &a)

void	cv::v_store_aligned_nocache (uint64 *ptr, const v_uint64 &a)

void	cv::v_store_aligned_nocache (unsigned int *ptr, const v_uint32 &a)

void	cv::v_store_aligned_nocache (ushort *ptr, const v_uint16 &a)

void	cv::v_store_high (double *ptr, const v_float64 &a)

void	cv::v_store_high (float *ptr, const v_float32 &a)

void	cv::v_store_high (int *ptr, const v_int32 &a)

void	cv::v_store_high (int64 *ptr, const v_int64 &a)

void	cv::v_store_high (schar *ptr, const v_int8 &a)

void	cv::v_store_high (short *ptr, const v_int16 &a)

void	cv::v_store_high (uchar *ptr, const v_uint8 &a)

void	cv::v_store_high (uint64 *ptr, const v_uint64 &a)

void	cv::v_store_high (unsigned int *ptr, const v_uint32 &a)

void	cv::v_store_high (ushort *ptr, const v_uint16 &a)

void	cv::v_store_interleave (double *ptr, const v_float64 &a, const v_float64 &b, const v_float64 &c, const v_float64 &d, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (double *ptr, const v_float64 &a, const v_float64 &b, const v_float64 &c, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (double *ptr, const v_float64 &a, const v_float64 &b, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (float *ptr, const v_float32 &a, const v_float32 &b, const v_float32 &c, const v_float32 &d, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (float *ptr, const v_float32 &a, const v_float32 &b, const v_float32 &c, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (float *ptr, const v_float32 &a, const v_float32 &b, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (int *ptr, const v_int32 &a, const v_int32 &b, const v_int32 &c, const v_int32 &d, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (int *ptr, const v_int32 &a, const v_int32 &b, const v_int32 &c, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (int *ptr, const v_int32 &a, const v_int32 &b, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (int64 *ptr, const v_int64 &a, const v_int64 &b, const v_int64 &c, const v_int64 &d, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (int64 *ptr, const v_int64 &a, const v_int64 &b, const v_int64 &c, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (int64 *ptr, const v_int64 &a, const v_int64 &b, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (schar *ptr, const v_int8 &a, const v_int8 &b, const v_int8 &c, const v_int8 &d, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (schar *ptr, const v_int8 &a, const v_int8 &b, const v_int8 &c, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (schar *ptr, const v_int8 &a, const v_int8 &b, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (short *ptr, const v_int16 &a, const v_int16 &b, const v_int16 &c, const v_int16 &d, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (short *ptr, const v_int16 &a, const v_int16 &b, const v_int16 &c, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (short *ptr, const v_int16 &a, const v_int16 &b, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (uchar *ptr, const v_uint8 &a, const v_uint8 &b, const v_uint8 &c, const v_uint8 &d, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (uchar *ptr, const v_uint8 &a, const v_uint8 &b, const v_uint8 &c, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (uchar *ptr, const v_uint8 &a, const v_uint8 &b, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (uint64 *ptr, const v_uint64 &a, const v_uint64 &b, const v_uint64 &c, const v_uint64 &d, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (uint64 *ptr, const v_uint64 &a, const v_uint64 &b, const v_uint64 &c, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (uint64 *ptr, const v_uint64 &a, const v_uint64 &b, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (unsigned *ptr, const v_uint32 &a, const v_uint32 &b, const v_uint32 &c, const v_uint32 &d, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (unsigned *ptr, const v_uint32 &a, const v_uint32 &b, const v_uint32 &c, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (unsigned *ptr, const v_uint32 &a, const v_uint32 &b, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (ushort *ptr, const v_uint16 &a, const v_uint16 &b, const v_uint16 &c, const v_uint16 &d, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (ushort *ptr, const v_uint16 &a, const v_uint16 &b, const v_uint16 &c, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_interleave (ushort *ptr, const v_uint16 &a, const v_uint16 &b, hal::StoreMode=hal::STORE_UNALIGNED)

void	cv::v_store_low (double *ptr, const v_float64 &a)

void	cv::v_store_low (float *ptr, const v_float32 &a)

void	cv::v_store_low (int *ptr, const v_int32 &a)

void	cv::v_store_low (int64 *ptr, const v_int64 &a)

void	cv::v_store_low (schar *ptr, const v_int8 &a)

void	cv::v_store_low (short *ptr, const v_int16 &a)

void	cv::v_store_low (uchar *ptr, const v_uint8 &a)

void	cv::v_store_low (uint64 *ptr, const v_uint64 &a)

void	cv::v_store_low (unsigned int *ptr, const v_uint32 &a)

void	cv::v_store_low (ushort *ptr, const v_uint16 &a)

v_float32	cv::v_sub (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_sub (const v_float64 &a, const v_float64 &b)

v_int16	cv::v_sub (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_sub (const v_int32 &a, const v_int32 &b)

v_int64	cv::v_sub (const v_int64 &a, const v_int64 &b)

v_int8	cv::v_sub (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_sub (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_sub (const v_uint32 &a, const v_uint32 &b)

v_uint64	cv::v_sub (const v_uint64 &a, const v_uint64 &b)

v_uint8	cv::v_sub (const v_uint8 &a, const v_uint8 &b)

v_int16	cv::v_sub_wrap (const v_int16 &a, const v_int16 &b)

v_int8	cv::v_sub_wrap (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_sub_wrap (const v_uint16 &a, const v_uint16 &b)

v_uint8	cv::v_sub_wrap (const v_uint8 &a, const v_uint8 &b)

void	cv::v_transpose4x4 (const v_float32 &a0, const v_float32 &a1, const v_float32 &a2, const v_float32 &a3, v_float32 &b0, v_float32 &b1, v_float32 &b2, v_float32 &b3)

void	cv::v_transpose4x4 (const v_int32 &a0, const v_int32 &a1, const v_int32 &a2, const v_int32 &a3, v_int32 &b0, v_int32 &b1, v_int32 &b2, v_int32 &b3)

void	cv::v_transpose4x4 (const v_uint32 &a0, const v_uint32 &a1, const v_uint32 &a2, const v_uint32 &a3, v_uint32 &b0, v_uint32 &b1, v_uint32 &b2, v_uint32 &b3)

v_int32	cv::v_trunc (const v_float32 &a)

v_int32	cv::v_trunc (const v_float64 &a)

v_float32	cv::v_xor (const v_float32 &a, const v_float32 &b)

v_float64	cv::v_xor (const v_float64 &a, const v_float64 &b)

v_int16	cv::v_xor (const v_int16 &a, const v_int16 &b)

v_int32	cv::v_xor (const v_int32 &a, const v_int32 &b)

v_int64	cv::v_xor (const v_int64 &a, const v_int64 &b)

v_int8	cv::v_xor (const v_int8 &a, const v_int8 &b)

v_uint16	cv::v_xor (const v_uint16 &a, const v_uint16 &b)

v_uint32	cv::v_xor (const v_uint32 &a, const v_uint32 &b)

v_uint64	cv::v_xor (const v_uint64 &a, const v_uint64 &b)

v_uint8	cv::v_xor (const v_uint8 &a, const v_uint8 &b)

void	cv::v_zip (const v_float32 &a0, const v_float32 &a1, v_float32 &b0, v_float32 &b1)

void	cv::v_zip (const v_int16 &a0, const v_int16 &a1, v_int16 &b0, v_int16 &b1)

void	cv::v_zip (const v_int32 &a0, const v_int32 &a1, v_int32 &b0, v_int32 &b1)

void	cv::v_zip (const v_int8 &a0, const v_int8 &a1, v_int8 &b0, v_int8 &b1)

void	cv::v_zip (const v_uint16 &a0, const v_uint16 &a1, v_uint16 &b0, v_uint16 &b1)

void	cv::v_zip (const v_uint32 &a0, const v_uint32 &a1, v_uint32 &b0, v_uint32 &b1)

void	cv::v_zip (const v_uint8 &a0, const v_uint8 &a1, v_uint8 &b0, v_uint8 &b1)

void	cv::v_zip4 (const v_float32 &a0, const v_float32 &a1, v_float32 &b0, v_float32 &b1)

void	cv::v_zip4 (const v_int32 &a0, const v_int32 &a1, v_int32 &b0, v_int32 &b1)

void	cv::v_zip4 (const v_uint32 &a0, const v_uint32 &a1, v_uint32 &b0, v_uint32 &b1)

Init with zero
Create new vector with zero elements
v_float32x4	cv::v_setzero_f32 ()

v_float64x2	cv::v_setzero_f64 ()

v_int16x8	cv::v_setzero_s16 ()

v_int32x4	cv::v_setzero_s32 ()

v_int64x2	cv::v_setzero_s64 ()

v_int8x16	cv::v_setzero_s8 ()

v_uint16x8	cv::v_setzero_u16 ()

v_uint32x4	cv::v_setzero_u32 ()

v_uint64x2	cv::v_setzero_u64 ()

v_uint8x16	cv::v_setzero_u8 ()

Init with value
Create new vector with elements set to a specific value
v_float32x4	cv::v_setall_f32 (float val)

v_float64x2	cv::v_setall_f64 (double val)

v_int16x8	cv::v_setall_s16 (short val)

v_int32x4	cv::v_setall_s32 (int val)

v_int64x2	cv::v_setall_s64 (int64 val)

v_int8x16	cv::v_setall_s8 (schar val)

v_uint16x8	cv::v_setall_u16 (ushort val)

v_uint64x2	cv::v_setall_u64 (uint64 val)

v_uint8x16	cv::v_setall_u8 (uchar val)

Variables
static const int	cv::__cv_rvv_e16m1_nlanes = vsetvlmax_e16m1()

static const int	cv::__cv_rvv_e16m2_nlanes = vsetvlmax_e16m2()

static const int	cv::__cv_rvv_e16m4_nlanes = vsetvlmax_e16m4()

static const int	cv::__cv_rvv_e16m8_nlanes = vsetvlmax_e16m8()

static const int	cv::__cv_rvv_e32m1_nlanes = vsetvlmax_e32m1()

static const int	cv::__cv_rvv_e32m2_nlanes = vsetvlmax_e32m2()

static const int	cv::__cv_rvv_e32m4_nlanes = vsetvlmax_e32m4()

static const int	cv::__cv_rvv_e32m8_nlanes = vsetvlmax_e32m8()

static const int	cv::__cv_rvv_e64m1_nlanes = vsetvlmax_e64m1()

static const int	cv::__cv_rvv_e64m2_nlanes = vsetvlmax_e64m2()

static const int	cv::__cv_rvv_e64m4_nlanes = vsetvlmax_e64m4()

static const int	cv::__cv_rvv_e64m8_nlanes = vsetvlmax_e64m8()

static const int	cv::__cv_rvv_e8m1_nlanes = vsetvlmax_e8m1()

static const int	cv::__cv_rvv_e8m2_nlanes = vsetvlmax_e8m2()

static const int	cv::__cv_rvv_e8m4_nlanes = vsetvlmax_e8m4()

static const int	cv::__cv_rvv_e8m8_nlanes = vsetvlmax_e8m8()

static uint64_t	cv::idx_interleave_pairs []

static uint64_t	cv::idx_interleave_quads []

static const unsigned char	cv::popCountTable [256]

Macro Definition Documentation

◆ CV_RVV_MAX_VLEN

#define CV_RVV_MAX_VLEN 1024

◆ CV_SIMD_SCALABLE

#define CV_SIMD_SCALABLE 1

◆ CV_SIMD_SCALABLE_64F

#define CV_SIMD_SCALABLE_64F 1

◆ OPENCV_HAL_IMPL_RVV_ABS

#define OPENCV_HAL_IMPL_RVV_ABS	(	_Tprvec,
		_Tpvec,
		suffix
	)

Value:

inline _Tprvec v_abs(const _Tpvec& a) \
{ \
    return v_absdiff(a, v_setzero_##suffix()); \
}

◆ OPENCV_HAL_IMPL_RVV_ABSDIFF

#define OPENCV_HAL_IMPL_RVV_ABSDIFF	(	_Tpvec,
		abs
	)

Value:

inline _Tpvec v_##abs(const _Tpvec& a, const _Tpvec& b) \
{ \
    return v_sub(v_max(a, b), v_min(a, b)); \
}

◆ OPENCV_HAL_IMPL_RVV_ABSDIFF_S

#define OPENCV_HAL_IMPL_RVV_ABSDIFF_S	(	_Tpvec,
		_rTpvec,
		width
	)

Value:

inline _rTpvec v_absdiff(const _Tpvec& a, const _Tpvec& b) \
{ \
    return vnclipu(vreinterpret_u##width##m2(vwsub_vv(v_max(a, b), v_min(a, b), VTraits<_Tpvec>::vlanes())), 0, VTraits<_Tpvec>::vlanes()); \
}

◆ OPENCV_HAL_IMPL_RVV_BIN_FUNC

#define OPENCV_HAL_IMPL_RVV_BIN_FUNC	(	_Tpvec,
		func,
		intrin,
		vl
	)

Value:

inline _Tpvec func(const _Tpvec& a, const _Tpvec& b) \
{ \
    return intrin(a, b, vl); \
}

◆ OPENCV_HAL_IMPL_RVV_BIN_MADD

#define OPENCV_HAL_IMPL_RVV_BIN_MADD	(	_Tpvec,
		rvv_add
	)

Value:

template<typename... Args> \
inline _Tpvec v_add(const _Tpvec& f1, const _Tpvec& f2, const Args&... vf) { \
    return v_add(rvv_add(f1, f2, VTraits<_Tpvec>::vlanes()), vf...); \
}

◆ OPENCV_HAL_IMPL_RVV_BIN_MMUL

#define OPENCV_HAL_IMPL_RVV_BIN_MMUL	(	_Tpvec,
		rvv_mul
	)

Value:

template<typename... Args> \
inline _Tpvec v_mul(const _Tpvec& f1, const _Tpvec& f2, const Args&... vf) { \
    return v_mul(rvv_mul(f1, f2, VTraits<_Tpvec>::vlanes()), vf...); \
}

◆ OPENCV_HAL_IMPL_RVV_BIN_OP

#define OPENCV_HAL_IMPL_RVV_BIN_OP	(	_Tpvec,
		ocv_intrin,
		rvv_intrin
	)

Value:

inline _Tpvec v_##ocv_intrin(const _Tpvec& a, const _Tpvec& b) \
{ \
    return rvv_intrin(a, b, VTraits<_Tpvec>::vlanes()); \
}

◆ OPENCV_HAL_IMPL_RVV_BROADCAST

#define OPENCV_HAL_IMPL_RVV_BROADCAST	(	_Tpvec,
		suffix
	)

Value:

template<int s = 0> inline _Tpvec v_broadcast_element(_Tpvec v, int i = s) \
{ \
    return v_setall_##suffix(v_extract_n(v, i)); \
} \
inline _Tpvec v_broadcast_highest(_Tpvec v) \
{ \
    return v_setall_##suffix(v_extract_n(v, VTraits<_Tpvec>::vlanes()-1)); \
}

◆ OPENCV_HAL_IMPL_RVV_CHECK_ALLANY

#define OPENCV_HAL_IMPL_RVV_CHECK_ALLANY	(	_Tpvec,
		vl
	)

Value:

inline bool v_check_all(const _Tpvec& a) \
{ \
    return (int)vcpop(vmslt(a, 0, vl), vl) == vl; \
} \
inline bool v_check_any(const _Tpvec& a) \
{ \
    return (int)vcpop(vmslt(a, 0, vl), vl) != 0; \
}

◆ OPENCV_HAL_IMPL_RVV_EXPAND

#define OPENCV_HAL_IMPL_RVV_EXPAND	(	_Tp,
		_Tpwvec,
		_Tpwvec_m2,
		_Tpvec,
		width,
		suffix,
		suffix2,
		cvt
	)

Value:

inline void v_expand(const _Tpvec& a, _Tpwvec& b0, _Tpwvec& b1) \
{ \
    _Tpwvec_m2 temp = cvt(a, vsetvlmax_e##width##m1()); \
    b0 = vget_##suffix##m1(temp, 0); \
    b1 = vget_##suffix##m1(temp, 1); \
} \
inline _Tpwvec v_expand_low(const _Tpvec& a) \
{ \
    _Tpwvec_m2 temp = cvt(a, vsetvlmax_e##width##m1()); \
    return vget_##suffix##m1(temp, 0); \
} \
inline _Tpwvec v_expand_high(const _Tpvec& a) \
{ \
    _Tpwvec_m2 temp = cvt(a, vsetvlmax_e##width##m1()); \
    return vget_##suffix##m1(temp, 1); \
} \
inline _Tpwvec v_load_expand(const _Tp* ptr) \
{ \
    return cvt(vle##width##_v_##suffix2##mf2(ptr, vsetvlmax_e##width##m1()), vsetvlmax_e##width##m1()); \
}

◆ OPENCV_HAL_IMPL_RVV_EXTRACT

#define OPENCV_HAL_IMPL_RVV_EXTRACT	(	_Tpvec,
		_Tp,
		vl
	)

Value:

inline _Tp v_extract_highest(_Tpvec v) \
{ \
    return v_extract_n(v, vl-1); \
}

◆ OPENCV_HAL_IMPL_RVV_EXTRACT_FP

#define OPENCV_HAL_IMPL_RVV_EXTRACT_FP	(	_Tpvec,
		_Tp,
		suffix,
		vl
	)

Value:

template <int s = 0> \
inline _Tpvec v_extract(const _Tpvec& a, const _Tpvec& b, int i = s) \
{ \
    return vslideup(vslidedown(v_setzero_##suffix(), a, i, vl), b, VTraits<_Tpvec>::vlanes() - i, vl); \
} \
template<int s = 0> inline _Tp v_extract_n(_Tpvec v, int i = s) \
{ \
    return vfmv_f(vslidedown(v_setzero_##suffix(), v, i, vl)); \
}

◆ OPENCV_HAL_IMPL_RVV_EXTRACT_INTEGER

#define OPENCV_HAL_IMPL_RVV_EXTRACT_INTEGER	(	_Tpvec,
		_Tp,
		suffix,
		vl
	)

Value:

template <int s = 0> \
inline _Tpvec v_extract(const _Tpvec& a, const _Tpvec& b, int i = s) \
{ \
    return vslideup(vslidedown(v_setzero_##suffix(), a, i, vl), b, VTraits<_Tpvec>::vlanes() - i, vl); \
} \
template<int s = 0> inline _Tp v_extract_n(_Tpvec v, int i = s) \
{ \
    return vmv_x(vslidedown(v_setzero_##suffix(), v, i, vl)); \
}

◆ OPENCV_HAL_IMPL_RVV_FLOAT_CMP

#define OPENCV_HAL_IMPL_RVV_FLOAT_CMP	(	_Tpvec,
		suffix,
		vl
	)

Value:

OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP(_Tpvec, eq, vmfeq, suffix, vl) \
OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP(_Tpvec, ne, vmfne, suffix, vl) \
OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP(_Tpvec, lt, vmflt, suffix, vl) \
OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP(_Tpvec, gt, vmfgt, suffix, vl) \
OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP(_Tpvec, le, vmfle, suffix, vl) \
OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP(_Tpvec, ge, vmfge, suffix, vl)

◆ OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP

#define OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP	(	_Tpvec,
		op,
		intrin,
		suffix,
		vl
	)

Value:

inline _Tpvec v_##op (const _Tpvec& a, const _Tpvec& b) \
{ \
    union { uint64 u; double d; } ones; ones.u = -1; \
    return _Tpvec(vfmerge(intrin(a, b, vl), vfmv_v_f_##suffix##m1(0, vl), ones.d, vl)); \
}

◆ OPENCV_HAL_IMPL_RVV_FLT64_BIT_OP

#define OPENCV_HAL_IMPL_RVV_FLT64_BIT_OP ( intrin )

Value:

inline v_float64 intrin (const v_float64& a, const v_float64& b) \
{ \
    return vreinterpret_f64m1(intrin(vreinterpret_i64m1(a), vreinterpret_i64m1(b))); \
}

◆ OPENCV_HAL_IMPL_RVV_FLT_BIT_OP

#define OPENCV_HAL_IMPL_RVV_FLT_BIT_OP ( intrin )

Value:

inline v_float32 intrin (const v_float32& a, const v_float32& b) \
{ \
    return vreinterpret_f32m1(intrin(vreinterpret_i32m1(a), vreinterpret_i32m1(b))); \
}

◆ OPENCV_HAL_IMPL_RVV_GRT0_INT

#define OPENCV_HAL_IMPL_RVV_GRT0_INT	(	_Tpvec,
		_Tp
	)

Value:

inline _Tp v_get0(const v_##_Tpvec& v) \
{ \
    return vmv_x(v); \
}

◆ OPENCV_HAL_IMPL_RVV_HADD

#define OPENCV_HAL_IMPL_RVV_HADD	(	_Tpvec,
		_Tpvec2,
		_Tm2,
		width,
		width2,
		suffix,
		add
	)

Value:

static inline _Tpvec2 v_hadd(_Tpvec a) { \
    vuint##width2##m1_t oneX2 = vmv_v_x_u##width2##m1(1, VTraits<v_uint##width2>::vlanes()); \
    vuint##width##m1_t one = vreinterpret_u##width##m1(oneX2); \
    _Tm2 res = add(a, vslide1down(a, 0, VTraits<v_uint##width>::vlanes()), VTraits<v_uint##width>::vlanes()); \
    return vget_##suffix##m1(vcompress(vmseq(one, 1, VTraits<v_uint##width>::vlanes()), res, res, VTraits<v_uint##width>::vlanes()), 0); \
}

◆ OPENCV_HAL_IMPL_RVV_INIT_FP

#define OPENCV_HAL_IMPL_RVV_INIT_FP	(	_Tpv,
		_Tp,
		suffix,
		vl
	)

Value:

inline v_##_Tpv v_setzero_##suffix() \
{ \
    return vfmv_v_f_##suffix##m1(0, vl); \
} \
inline v_##_Tpv v_setall_##suffix(_Tp v) \
{ \
    return vfmv_v_f_##suffix##m1(v, vl); \
}

◆ OPENCV_HAL_IMPL_RVV_INIT_INTEGER

#define OPENCV_HAL_IMPL_RVV_INIT_INTEGER	(	_Tpvec,
		_Tp,
		suffix1,
		suffix2,
		vl
	)

Value:

inline v_##_Tpvec v_setzero_##suffix1() \
{ \
    return vmv_v_x_##suffix2##m1(0, vl); \
} \
inline v_##_Tpvec v_setall_##suffix1(_Tp v) \
{ \
    return vmv_v_x_##suffix2##m1(v, vl); \
}

◆ OPENCV_HAL_IMPL_RVV_INT_CMP_OP

#define OPENCV_HAL_IMPL_RVV_INT_CMP_OP	(	_Tpvec,
		op,
		intrin,
		suffix,
		vl
	)

Value:

inline _Tpvec v_##op(const _Tpvec& a, const _Tpvec& b) \
{ \
    uint64_t ones = -1; \
    return vmerge(intrin(a, b, vl), vmv_v_x_##suffix##m1(0, vl), ones, vl); \
}

◆ OPENCV_HAL_IMPL_RVV_INTERLEAVED

#define OPENCV_HAL_IMPL_RVV_INTERLEAVED	(	_Tpvec,
		_Tp,
		suffix,
		width,
		hwidth,
		vl
	)

◆ OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ

#define OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ	(	_Tpvec,
		width,
		vzext_vfx,
		func
	)

Value:

inline _Tpvec v_interleave_##func(const _Tpvec& vec) { \
    CV_CheckLE(VTraits<_Tpvec>::vlanes(), VTraits<_Tpvec>::max_nlanes, "RVV implementation only supports VLEN in the range [128, 1024]"); \
    vuint##width##m1_t vidx = vundefined_u##width##m1();\
    vidx = vget_u##width##m1(vzext_vfx(vreinterpret_u8m1(vle64_v_u64m1(idx_interleave_##func, 16)), VTraits<v_uint8>::vlanes()), 0); \
    return vrgather(vec, vidx, VTraits<_Tpvec>::vlanes()); \
}

◆ OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ_NOEXPEND

#define OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ_NOEXPEND	(	_Tpvec,
		func
	)

Value:

inline _Tpvec v_interleave_##func(const _Tpvec& vec) { \
    CV_CheckLE(VTraits<_Tpvec>::vlanes(), VTraits<_Tpvec>::max_nlanes, "RVV implementation only supports VLEN in the range [128, 1024]"); \
    vuint8m1_t vidx = vundefined_u8m1();\
    vidx = vreinterpret_u8m1(vle64_v_u64m1(idx_interleave_##func, 16)); \
    return vrgather(vec, vidx, VTraits<v_uint8>::vlanes()); \
}

◆ OPENCV_HAL_IMPL_RVV_LOADSTORE_OP

#define OPENCV_HAL_IMPL_RVV_LOADSTORE_OP	(	_Tpvec,
		_nTpvec,
		_Tp,
		hvl,
		vl,
		width,
		suffix,
		vmv
	)

◆ OPENCV_HAL_IMPL_RVV_LOGIC_OP

#define OPENCV_HAL_IMPL_RVV_LOGIC_OP	(	_Tpvec,
		vl
	)

Value:

inline _Tpvec v_and(const _Tpvec& a, const _Tpvec& b) \
{ \
    return vand(a, b, vl); \
} \
inline _Tpvec v_or(const _Tpvec& a, const _Tpvec& b) \
{ \
    return vor(a, b, vl); \
} \
inline _Tpvec v_xor(const _Tpvec& a, const _Tpvec& b) \
{ \
    return vxor(a, b, vl); \
} \
inline _Tpvec v_not (const _Tpvec& a) \
{ \
    return vnot(a, vl); \
}

◆ OPENCV_HAL_IMPL_RVV_LUT

#define OPENCV_HAL_IMPL_RVV_LUT	(	_Tpvec,
		_Tp,
		suffix
	)

Value:

inline _Tpvec v_lut(const _Tp* tab, const int* idx) \
{ \
    vuint32##suffix##_t vidx = vmul(vreinterpret_u32##suffix(vle32_v_i32##suffix(idx, VTraits<_Tpvec>::vlanes())), sizeof(_Tp), VTraits<_Tpvec>::vlanes()); \
    return vloxei32(tab, vidx, VTraits<_Tpvec>::vlanes()); \
} \
inline _Tpvec v_lut_pairs(const _Tp* tab, const int* idx) \
{ \
    std::vector<uint> idx_; \
    for (int i = 0; i < VTraits<v_int16>::vlanes(); ++i) { \
        idx_.push_back(idx[i]); \
        idx_.push_back(idx[i]+1); \
    } \
    vuint32##suffix##_t vidx = vmul(vle32_v_u32##suffix(idx_.data(), VTraits<_Tpvec>::vlanes()), sizeof(_Tp), VTraits<_Tpvec>::vlanes()); \
    return vloxei32(tab, vidx, VTraits<_Tpvec>::vlanes()); \
} \
inline _Tpvec v_lut_quads(const _Tp* tab, const int* idx) \
{ \
    std::vector<uint> idx_; \
    for (int i = 0; i < VTraits<v_int32>::vlanes(); ++i) { \
        idx_.push_back(idx[i]); \
        idx_.push_back(idx[i]+1); \
        idx_.push_back(idx[i]+2); \
        idx_.push_back(idx[i]+3); \
    } \
    vuint32##suffix##_t vidx = vmul(vle32_v_u32##suffix(idx_.data(), VTraits<_Tpvec>::vlanes()), sizeof(_Tp), VTraits<_Tpvec>::vlanes()); \
    return vloxei32(tab, vidx, VTraits<_Tpvec>::vlanes()); \
}

◆ OPENCV_HAL_IMPL_RVV_LUT_VEC

#define OPENCV_HAL_IMPL_RVV_LUT_VEC	(	_Tpvec,
		_Tp
	)

Value:

inline _Tpvec v_lut(const _Tp* tab, const v_int32& vidx) \
{ \
    v_uint32 vidx_ = vmul(vreinterpret_u32m1(vidx), sizeof(_Tp), VTraits<v_int32>::vlanes()); \
    return vloxei32(tab, vidx_, VTraits<_Tpvec>::vlanes()); \
}

◆ OPENCV_HAL_IMPL_RVV_MUL_EXPAND

#define OPENCV_HAL_IMPL_RVV_MUL_EXPAND	(	_Tpvec,
		_Tpwvec,
		_TpwvecM2,
		suffix,
		wmul
	)

Value:

inline void v_mul_expand(const _Tpvec& a, const _Tpvec& b, _Tpwvec& c, _Tpwvec& d) \
{ \
    _TpwvecM2 temp = wmul(a, b, VTraits<_Tpvec>::vlanes()); \
    c = vget_##suffix##m1(temp, 0); \
    d = vget_##suffix##m1(temp, 1); \
}

◆ OPENCV_HAL_IMPL_RVV_MUL_SAT

#define OPENCV_HAL_IMPL_RVV_MUL_SAT	(	_Tpvec,
		_clip,
		_wmul
	)

Value:

inline _Tpvec v_mul(const _Tpvec& a, const _Tpvec& b) \
{ \
    return _clip(_wmul(a, b, VTraits<_Tpvec>::vlanes()), 0, VTraits<_Tpvec>::vlanes()); \
} \
template<typename... Args> \
inline _Tpvec v_mul(const _Tpvec& a1, const _Tpvec& a2, const Args&... va) { \
    return v_mul(_clip(_wmul(a1, a2, VTraits<_Tpvec>::vlanes()), 0, VTraits<_Tpvec>::vlanes()), va...); \
}

◆ OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET

#define OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET	(	_Tpvec1,
		_Tpvec2,
		suffix1,
		suffix2,
		nsuffix1,
		nsuffix2
	)

Value:

inline v_##_Tpvec1 v_reinterpret_as_##suffix1(const v_##_Tpvec2& v) \
{ \
    return v_##_Tpvec1(vreinterpret_v_##nsuffix2##m1_##nsuffix1##m1(v));\
} \
inline v_##_Tpvec2 v_reinterpret_as_##suffix2(const v_##_Tpvec1& v) \
{ \
    return v_##_Tpvec2(vreinterpret_v_##nsuffix1##m1_##nsuffix2##m1(v));\
}

◆ OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET

#define OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET	(	_Tpvec1,
		suffix1
	)

Value:

inline v_##_Tpvec1 v_reinterpret_as_##suffix1(const v_##_Tpvec1& v) \
{ \
    return v;\
}

◆ OPENCV_HAL_IMPL_RVV_PACK

#define OPENCV_HAL_IMPL_RVV_PACK	(	_Tpvec,
		_Tp,
		_wTpvec,
		hwidth,
		hsuffix,
		suffix,
		rshr,
		shr
	)

Value:

inline _Tpvec v_pack(const _wTpvec& a, const _wTpvec& b) \
{ \
    return shr(vset(vlmul_ext_##suffix##m2(a), 1, b), 0, VTraits<_Tpvec>::vlanes()); \
} \
inline void v_pack_store(_Tp* ptr, const _wTpvec& a) \
{ \
    vse##hwidth##_v_##hsuffix##mf2(ptr, shr(a, 0, VTraits<_Tpvec>::vlanes()), VTraits<_wTpvec>::vlanes()); \
} \
template<int n = 0> inline \
_Tpvec v_rshr_pack(const _wTpvec& a, const _wTpvec& b, int N = n) \
{ \
    return rshr(vset(vlmul_ext_##suffix##m2(a), 1, b), N, VTraits<_Tpvec>::vlanes()); \
} \
template<int n = 0> inline \
void v_rshr_pack_store(_Tp* ptr, const _wTpvec& a, int N = n) \
{ \
    vse##hwidth##_v_##hsuffix##mf2(ptr, rshr(a, N, VTraits<_Tpvec>::vlanes()), VTraits<_wTpvec>::vlanes()); \
}

◆ OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS

#define OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS	(	_Tpvec,
		v_trunc
	)

Value:

inline _Tpvec v_pack_triplets(const _Tpvec& vec) { \
    size_t vl = vsetvlmax_e8m1(); \
    vuint32m1_t one = vmv_v_x_u32m1(1, vl/4); \
    vuint8m1_t zero = vmv_v_x_u8m1(0, vl); \
    vuint8m1_t mask = vreinterpret_u8m1(one); \
    return vcompress(vmseq(v_trunc(vslideup(zero, mask, 3, vl)), 0, vl), vec, vec, VTraits<_Tpvec>::vlanes()); \
}

◆ OPENCV_HAL_IMPL_RVV_PACK_U

#define OPENCV_HAL_IMPL_RVV_PACK_U	(	_Tpvec,
		_Tp,
		_wTpvec,
		_wTp,
		hwidth,
		width,
		hsuffix,
		suffix,
		rshr,
		cast,
		hvl,
		vl
	)

Value:

inline _Tpvec v_pack_u(const _wTpvec& a, const _wTpvec& b) \
{ \
    return vnclipu(cast(vmax(vset(vlmul_ext_##suffix##m2(a), 1, b), 0, vl)), 0, vl); \
} \
inline void v_pack_u_store(_Tp* ptr, const _wTpvec& a) \
{ \
    vse##hwidth##_v_##hsuffix##mf2(ptr, vnclipu(vreinterpret_u##width##m1(vmax(a, 0, vl)), 0, vl), hvl); \
} \
template<int N = 0> inline \
_Tpvec v_rshr_pack_u(const _wTpvec& a, const _wTpvec& b, int n = N) \
{ \
    return vnclipu(cast(vmax(vset(vlmul_ext_##suffix##m2(a), 1, b), 0, vl)), n, vl); \
} \
template<int N = 0> inline \
void v_rshr_pack_u_store(_Tp* ptr, const _wTpvec& a, int n = N) \
{ \
    vse##hwidth##_v_##hsuffix##mf2(ptr, vnclipu(vreinterpret_u##width##m1(vmax(a, 0, vl)), n, vl), hvl); \
}

◆ OPENCV_HAL_IMPL_RVV_REDUCE

#define OPENCV_HAL_IMPL_RVV_REDUCE	(	_Tpvec,
		func,
		scalartype,
		suffix,
		vl,
		red
	)

Value:

inline scalartype v_reduce_##func(const _Tpvec& a)  \
{ \
    _Tpvec res = _Tpvec(v##red(a, a, a, vl)); \
    return (scalartype)v_get0(res); \
}

◆ OPENCV_HAL_IMPL_RVV_REDUCE_SAD

#define OPENCV_HAL_IMPL_RVV_REDUCE_SAD	(	_Tpvec,
		scalartype
	)

Value:

inline scalartype v_reduce_sad(const _Tpvec& a, const _Tpvec& b) \
{ \
    return v_reduce_sum(v_absdiff(a, b)); \
}

◆ OPENCV_HAL_IMPL_RVV_REDUCE_SUM

#define OPENCV_HAL_IMPL_RVV_REDUCE_SUM	(	_Tpvec,
		_wTpvec,
		_nwTpvec,
		scalartype,
		wsuffix,
		vl,
		red
	)

Value:

inline scalartype v_reduce_sum(const _Tpvec& a)  \
{ \
    _nwTpvec zero = vmv_v_x_##wsuffix##m1(0, vl); \
    _nwTpvec res = vmv_v_x_##wsuffix##m1(0, vl); \
    res = v##red(res, a, zero, vl); \
    return (scalartype)v_get0(res); \
}

◆ OPENCV_HAL_IMPL_RVV_REDUCE_SUM_FP

#define OPENCV_HAL_IMPL_RVV_REDUCE_SUM_FP	(	_Tpvec,
		_wTpvec,
		_nwTpvec,
		scalartype,
		wsuffix,
		vl
	)

Value:

inline scalartype v_reduce_sum(const _Tpvec& a)  \
{ \
    _nwTpvec zero = vfmv_v_f_##wsuffix##m1(0, vl); \
    _nwTpvec res = vfmv_v_f_##wsuffix##m1(0, vl); \
    res = vfredosum(res, a, zero, vl); \
    return (scalartype)v_get0(res); \
}

◆ OPENCV_HAL_IMPL_RVV_REVERSE

#define OPENCV_HAL_IMPL_RVV_REVERSE	(	_Tpvec,
		width
	)

Value:

inline _Tpvec v_reverse(const _Tpvec& a)  \
{ \
    vuint##width##m1_t vidx = vrsub(vid_v_u##width##m1(VTraits<_Tpvec>::vlanes()), VTraits<_Tpvec>::vlanes()-1, VTraits<_Tpvec>::vlanes()); \
    return vrgather(a, vidx, VTraits<_Tpvec>::vlanes()); \
}

◆ OPENCV_HAL_IMPL_RVV_ROTATE_FP

#define OPENCV_HAL_IMPL_RVV_ROTATE_FP	(	_Tpvec,
		suffix,
		vl
	)

Value:

template<int n> inline _Tpvec v_rotate_right(const _Tpvec& a) \
{ \
    return vslidedown(vfmv_v_f_##suffix##m1(0, vl), a, n, vl); \
} \
template<int n> inline _Tpvec v_rotate_left(const _Tpvec& a) \
{ \
    return vslideup(vfmv_v_f_##suffix##m1(0, vl), a, n, vl); \
} \
template<> inline _Tpvec v_rotate_left<0>(const _Tpvec& a) \
{ return a; } \
template<int n> inline _Tpvec v_rotate_right(const _Tpvec& a, const _Tpvec& b) \
{ \
    return vslideup(vslidedown(vfmv_v_f_##suffix##m1(0, vl), a, n, vl), b, VTraits<_Tpvec>::vlanes() - n, vl); \
} \
template<int n> inline _Tpvec v_rotate_left(const _Tpvec& a, const _Tpvec& b) \
{ \
    return vslideup(vslidedown(vfmv_v_f_##suffix##m1(0, vl), b, VTraits<_Tpvec>::vlanes() - n, vl), a, n, vl); \
} \
template<> inline _Tpvec v_rotate_left<0>(const _Tpvec& a, const _Tpvec& b) \
{ CV_UNUSED(b); return a; }

◆ OPENCV_HAL_IMPL_RVV_ROTATE_INTEGER

#define OPENCV_HAL_IMPL_RVV_ROTATE_INTEGER	(	_Tpvec,
		suffix,
		vl
	)

Value:

template<int n> inline _Tpvec v_rotate_right(const _Tpvec& a) \
{ \
    return vslidedown(vmv_v_x_##suffix##m1(0, vl), a, n, vl); \
} \
template<int n> inline _Tpvec v_rotate_left(const _Tpvec& a) \
{ \
    return vslideup(vmv_v_x_##suffix##m1(0, vl), a, n, vl); \
} \
template<> inline _Tpvec v_rotate_left<0>(const _Tpvec& a) \
{ return a; } \
template<int n> inline _Tpvec v_rotate_right(const _Tpvec& a, const _Tpvec& b) \
{ \
    return vslideup(vslidedown(vmv_v_x_##suffix##m1(0, vl), a, n, vl), b, VTraits<_Tpvec>::vlanes() - n, vl); \
} \
template<int n> inline _Tpvec v_rotate_left(const _Tpvec& a, const _Tpvec& b) \
{ \
    return vslideup(vslidedown(vmv_v_x_##suffix##m1(0, vl), b, VTraits<_Tpvec>::vlanes() - n, vl), a, n, vl); \
} \
template<> inline _Tpvec v_rotate_left<0>(const _Tpvec& a, const _Tpvec& b) \
{ CV_UNUSED(b); return a; }

◆ OPENCV_HAL_IMPL_RVV_SELECT

#define OPENCV_HAL_IMPL_RVV_SELECT	(	_Tpvec,
		vl
	)

Value:

inline _Tpvec v_select(const _Tpvec& mask, const _Tpvec& a, const _Tpvec& b) \
{ \
    return vmerge(vmsne(mask, 0, vl), b, a, vl); \
}

◆ OPENCV_HAL_IMPL_RVV_SIGNED_CMP

#define OPENCV_HAL_IMPL_RVV_SIGNED_CMP	(	_Tpvec,
		suffix,
		vl
	)

Value:

OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, eq, vmseq, suffix, vl) \
OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, ne, vmsne, suffix, vl) \
OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, lt, vmslt, suffix, vl) \
OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, gt, vmsgt, suffix, vl) \
OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, le, vmsle, suffix, vl) \
OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, ge, vmsge, suffix, vl)

◆ OPENCV_HAL_IMPL_RVV_SIGNED_SHIFT_OP

#define OPENCV_HAL_IMPL_RVV_SIGNED_SHIFT_OP	(	_Tpvec,
		vl
	)

Value:

template<int s = 0> inline _Tpvec v_shl(const _Tpvec& a, int n = s) \
{ \
    return _Tpvec(vsll(a, uint8_t(n), vl)); \
} \
template<int s = 0> inline _Tpvec v_shr(const _Tpvec& a, int n = s) \
{ \
    return _Tpvec(vsra(a, uint8_t(n), vl)); \
}

◆ OPENCV_HAL_IMPL_RVV_SIGNMASK_OP

#define OPENCV_HAL_IMPL_RVV_SIGNMASK_OP ( _Tpvec )

Value:

inline int v_signmask(const _Tpvec& a) \
{ \
    uint8_t ans[4] = {0}; \
    vsm(ans, vmslt(a, 0, VTraits<_Tpvec>::vlanes()), VTraits<_Tpvec>::vlanes()); \
    return *(reinterpret_cast<int*>(ans)) & (((__int128_t)1 << VTraits<_Tpvec>::vlanes()) - 1); \
} \
inline int v_scan_forward(const _Tpvec& a) \
{ \
    return (int)vfirst(vmslt(a, 0, VTraits<_Tpvec>::vlanes()), VTraits<_Tpvec>::vlanes()); \
}

◆ OPENCV_HAL_IMPL_RVV_TRAITS

#define OPENCV_HAL_IMPL_RVV_TRAITS	(	REG,
		TYP,
		SUF,
		SZ
	)

Value:

template <> \
struct VTraits<REG> \
{ \
    static inline int vlanes() { return __cv_rvv_##SUF##_nlanes; } \
    using lane_type = TYP; \
    static const int max_nlanes = CV_RVV_MAX_VLEN/SZ; \
};

◆ OPENCV_HAL_IMPL_RVV_TRANSPOSE4x4

#define OPENCV_HAL_IMPL_RVV_TRANSPOSE4x4	(	_Tpvec,
		suffix
	)

Value:

inline void v_transpose4x4(const _Tpvec& a0, const _Tpvec& a1, const _Tpvec& a2, const _Tpvec& a3, _Tpvec& b0, _Tpvec& b1, _Tpvec& b2, _Tpvec& b3) { \
    _Tpvec t0,t1,t2,t3; \
    v_zip4(a0, a2, t0, t2); \
    v_zip4(a1, a3, t1, t3); \
    v_zip4(t0, t1, b0, b1); \
    v_zip4(t2, t3, b2, b3); \
}

◆ OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET

#define OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET	(	_Tpvec1,
		_Tpvec2,
		suffix1,
		suffix2,
		nsuffix1,
		nsuffix2,
		width1,
		width2
	)

Value:

inline v_##_Tpvec1 v_reinterpret_as_##suffix1(const v_##_Tpvec2& v) \
{ \
    return vreinterpret_v_##nsuffix1##width2##m1_##nsuffix1##width1##m1(vreinterpret_v_##nsuffix2##width2##m1_##nsuffix1##width2##m1(v));\
} \
inline v_##_Tpvec2 v_reinterpret_as_##suffix2(const v_##_Tpvec1& v) \
{ \
    return vreinterpret_v_##nsuffix1##width2##m1_##nsuffix2##width2##m1(vreinterpret_v_##nsuffix1##width1##m1_##nsuffix1##width2##m1(v));\
}

◆ OPENCV_HAL_IMPL_RVV_UNPACKS

#define OPENCV_HAL_IMPL_RVV_UNPACKS	(	_Tpvec,
		width
	)

Value:

inline _Tpvec v_combine_low(const _Tpvec& a, const _Tpvec& b) \
{ \
    return vslideup(a, b, VTraits<_Tpvec>::vlanes()/2, VTraits<_Tpvec>::vlanes());\
} \
inline _Tpvec v_combine_high(const _Tpvec& a, const _Tpvec& b) \
{ \
    return vslideup( \
            vslidedown(a, a, VTraits<_Tpvec>::vlanes()/2, VTraits<_Tpvec>::vlanes()), \
            vslidedown(b, b, VTraits<_Tpvec>::vlanes()/2, VTraits<_Tpvec>::vlanes()), \
            VTraits<_Tpvec>::vlanes()/2, \
            VTraits<_Tpvec>::vlanes()); \
} \
inline void v_recombine(const _Tpvec& a, const _Tpvec& b, _Tpvec& c, _Tpvec& d) \
{ \
    c = v_combine_low(a, b); \
    d = v_combine_high(a, b); \
}

◆ OPENCV_HAL_IMPL_RVV_UNSIGNED_CMP

#define OPENCV_HAL_IMPL_RVV_UNSIGNED_CMP	(	_Tpvec,
		suffix,
		vl
	)

Value:

OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, eq, vmseq, suffix, vl) \
OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, ne, vmsne, suffix, vl) \
OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, lt, vmsltu, suffix, vl) \
OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, gt, vmsgtu, suffix, vl) \
OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, le, vmsleu, suffix, vl) \
OPENCV_HAL_IMPL_RVV_INT_CMP_OP(_Tpvec, ge, vmsgeu, suffix, vl)

◆ OPENCV_HAL_IMPL_RVV_UNSIGNED_SHIFT_OP

#define OPENCV_HAL_IMPL_RVV_UNSIGNED_SHIFT_OP	(	_Tpvec,
		vl
	)

Value:

template<int s = 0> inline _Tpvec v_shl(const _Tpvec& a, int n = s) \
{ \
    return _Tpvec(vsll(a, uint8_t(n), vl)); \
} \
template<int s = 0> inline _Tpvec v_shr(const _Tpvec& a, int n = s) \
{ \
    return _Tpvec(vsrl(a, uint8_t(n), vl)); \
}

◆ OPENCV_HAL_IMPL_RVV_ZIP

#define OPENCV_HAL_IMPL_RVV_ZIP	(	_Tpvec,
		_wTpvec,
		suffix,
		width,
		width2,
		convert2um2,
		convert2um1
	)

Value:

inline void v_zip(const _Tpvec& a0, const _Tpvec& a1, _Tpvec& b0, _Tpvec& b1) { \
    _wTpvec temp = vreinterpret_##suffix##m2(convert2um2( \
        vor(vzext_vf2(convert2um1(a0), VTraits<_Tpvec>::vlanes()*2), \
            vreinterpret_u##width2##m2(vslide1up(vreinterpret_u##width##m2(vzext_vf2(convert2um1(a1), VTraits<_Tpvec>::vlanes()*2)), 0, VTraits<_Tpvec>::vlanes()*2)), \
            VTraits<_Tpvec>::vlanes()))); \
    b0 = vget_##suffix##m1(temp, 0); \
    b1 = vget_##suffix##m1(temp, 1); \
}

◆ OPENCV_HAL_IMPL_RVV_ZIP4

#define OPENCV_HAL_IMPL_RVV_ZIP4	(	_Tpvec,
		_wTpvec,
		suffix,
		convert2u,
		convert
	)

Value:

inline void v_zip4(const _Tpvec& a0, const _Tpvec& a1, _Tpvec& b0, _Tpvec& b1) { \
    int vl = 4; \
    _wTpvec temp = vreinterpret_##suffix##m2(convert2u( \
        vor(vzext_vf2(convert(a0), vl), \
            vreinterpret_u64m2(vslide1up(vreinterpret_u32m2(vzext_vf2(convert(a1), vl)), 0, vl*2)), \
            vl))); \
    b0 = vget_##suffix##m1(temp, 0); \
    b1 = vget_##suffix##m1(vrgather(temp, vadd(vid_v_u32m2(vl), 4, vl)/*{4,5,6,7} */, vl) ,0); \
}

Classes

Namespaces

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ CV_RVV_MAX_VLEN

◆ CV_SIMD_SCALABLE

◆ CV_SIMD_SCALABLE_64F

◆ OPENCV_HAL_IMPL_RVV_ABS

◆ OPENCV_HAL_IMPL_RVV_ABSDIFF

◆ OPENCV_HAL_IMPL_RVV_ABSDIFF_S

◆ OPENCV_HAL_IMPL_RVV_BIN_FUNC

◆ OPENCV_HAL_IMPL_RVV_BIN_MADD

◆ OPENCV_HAL_IMPL_RVV_BIN_MMUL

◆ OPENCV_HAL_IMPL_RVV_BIN_OP

◆ OPENCV_HAL_IMPL_RVV_BROADCAST

◆ OPENCV_HAL_IMPL_RVV_CHECK_ALLANY

◆ OPENCV_HAL_IMPL_RVV_EXPAND

◆ OPENCV_HAL_IMPL_RVV_EXTRACT

◆ OPENCV_HAL_IMPL_RVV_EXTRACT_FP

◆ OPENCV_HAL_IMPL_RVV_EXTRACT_INTEGER

◆ OPENCV_HAL_IMPL_RVV_FLOAT_CMP

◆ OPENCV_HAL_IMPL_RVV_FLOAT_CMP_OP

◆ OPENCV_HAL_IMPL_RVV_FLT64_BIT_OP

◆ OPENCV_HAL_IMPL_RVV_FLT_BIT_OP

◆ OPENCV_HAL_IMPL_RVV_GRT0_INT

◆ OPENCV_HAL_IMPL_RVV_HADD

◆ OPENCV_HAL_IMPL_RVV_INIT_FP

◆ OPENCV_HAL_IMPL_RVV_INIT_INTEGER

◆ OPENCV_HAL_IMPL_RVV_INT_CMP_OP

◆ OPENCV_HAL_IMPL_RVV_INTERLEAVED

◆ OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ

◆ OPENCV_HAL_IMPL_RVV_INTERLEAVED_PQ_NOEXPEND

◆ OPENCV_HAL_IMPL_RVV_LOADSTORE_OP

◆ OPENCV_HAL_IMPL_RVV_LOGIC_OP

◆ OPENCV_HAL_IMPL_RVV_LUT

◆ OPENCV_HAL_IMPL_RVV_LUT_VEC

◆ OPENCV_HAL_IMPL_RVV_MUL_EXPAND

◆ OPENCV_HAL_IMPL_RVV_MUL_SAT

◆ OPENCV_HAL_IMPL_RVV_NATIVE_REINTERPRET

◆ OPENCV_HAL_IMPL_RVV_NOTHING_REINTERPRET

◆ OPENCV_HAL_IMPL_RVV_PACK

◆ OPENCV_HAL_IMPL_RVV_PACK_TRIPLETS

◆ OPENCV_HAL_IMPL_RVV_PACK_U

◆ OPENCV_HAL_IMPL_RVV_REDUCE

◆ OPENCV_HAL_IMPL_RVV_REDUCE_SAD

◆ OPENCV_HAL_IMPL_RVV_REDUCE_SUM

◆ OPENCV_HAL_IMPL_RVV_REDUCE_SUM_FP

◆ OPENCV_HAL_IMPL_RVV_REVERSE

◆ OPENCV_HAL_IMPL_RVV_ROTATE_FP

◆ OPENCV_HAL_IMPL_RVV_ROTATE_INTEGER

◆ OPENCV_HAL_IMPL_RVV_SELECT

◆ OPENCV_HAL_IMPL_RVV_SIGNED_CMP

◆ OPENCV_HAL_IMPL_RVV_SIGNED_SHIFT_OP

◆ OPENCV_HAL_IMPL_RVV_SIGNMASK_OP

◆ OPENCV_HAL_IMPL_RVV_TRAITS

◆ OPENCV_HAL_IMPL_RVV_TRANSPOSE4x4

◆ OPENCV_HAL_IMPL_RVV_TWO_TIMES_REINTERPRET

◆ OPENCV_HAL_IMPL_RVV_UNPACKS

◆ OPENCV_HAL_IMPL_RVV_UNSIGNED_CMP

◆ OPENCV_HAL_IMPL_RVV_UNSIGNED_SHIFT_OP

◆ OPENCV_HAL_IMPL_RVV_ZIP

◆ OPENCV_HAL_IMPL_RVV_ZIP4