#include <cmath>
#include <float.h>
#include <stdlib.h>
#include "opencv2/core/cvdef.h"
#include "opencv2/core/hal/intrin_cpp.hpp"

Classes
struct	cv::V_TypeTraits< _Tp >

struct	cv::V_TypeTraits< double >

struct	cv::V_TypeTraits< float >

struct	cv::V_TypeTraits< int64 >

struct	cv::V_TypeTraits< schar >

struct	cv::V_TypeTraits< short >

struct	cv::V_TypeTraits< uchar >

struct	cv::V_TypeTraits< uint64 >

struct	cv::V_TypeTraits< unsigned >

struct	cv::V_TypeTraits< ushort >

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

	cv::hal

	simd512

Macros
#define	CV_INTRIN_DEF_TYPE_TRAITS(type, int_type_, uint_type_, abs_type_, w_type_, q_type_, sum_type_)

#define	CV_INTRIN_DEF_TYPE_TRAITS_NO_Q_TYPE(type, int_type_, uint_type_, abs_type_, w_type_, sum_type_)

#define	CV_SIMD 1

#define	CV_SIMD_64F CV_SIMD512_64F

#define	CV_SIMD_FP16 CV_SIMD512_FP16

#define	CV_SIMD_WIDTH 64

#define	OPENCV_HAL_1ST(a, b) (a)

#define	OPENCV_HAL_ADD(a, b) ((a) + (b))

#define	OPENCV_HAL_AND(a, b) ((a) & (b))

#define	OPENCV_HAL_NOP(a) (a)

#define	VXPREFIX(func) v512##func

Typedefs
typedef v_float32x16	simd512::v_float32
	Maximum available vector register capacity 32-bit floating point values (single precision) More...

typedef v_float64x8	simd512::v_float64
	Maximum available vector register capacity 64-bit floating point values (double precision) More...

typedef v_int16x32	simd512::v_int16
	Maximum available vector register capacity 16-bit signed integer values. More...

typedef v_int32x16	simd512::v_int32
	Maximum available vector register capacity 32-bit signed integer values. More...

typedef v_int64x8	simd512::v_int64
	Maximum available vector register capacity 64-bit signed integer values. More...

typedef v_int8x64	simd512::v_int8
	Maximum available vector register capacity 8-bit signed integer values. More...

typedef v_uint16x32	simd512::v_uint16
	Maximum available vector register capacity 16-bit unsigned integer values. More...

typedef v_uint32x16	simd512::v_uint32
	Maximum available vector register capacity 32-bit unsigned integer values. More...

typedef v_uint64x8	simd512::v_uint64
	Maximum available vector register capacity 64-bit unsigned integer values. More...

typedef v_uint8x64	simd512::v_uint8
	Maximum available vector register capacity 8-bit unsigned integer values. More...

Enumerations
enum	cv::hal::StoreMode { cv::hal::STORE_UNALIGNED = 0, cv::hal::STORE_ALIGNED = 1, cv::hal::STORE_ALIGNED_NOCACHE = 2 }

Functions
void	simd512::vx_cleanup ()
	SIMD processing state cleanup call. More...

Wide init with value
Create maximum available capacity vector with elements set to a specific value
v_uint8	simd512::vx_setall_u8 (uchar v)

v_int8	simd512::vx_setall_s8 (schar v)

v_uint16	simd512::vx_setall_u16 (ushort v)

v_int16	simd512::vx_setall_s16 (short v)

v_int32	simd512::vx_setall_s32 (int v)

v_uint32	simd512::vx_setall_u32 (unsigned v)

v_float32	simd512::vx_setall_f32 (float v)

v_int64	simd512::vx_setall_s64 (int64 v)

v_uint64	simd512::vx_setall_u64 (uint64 v)

v_float64	simd512::vx_setall_f64 (double v)

Wide init with zero
Create maximum available capacity vector with elements set to zero
v_uint8	simd512::vx_setzero_u8 ()

v_int8	simd512::vx_setzero_s8 ()

v_uint16	simd512::vx_setzero_u16 ()

v_int16	simd512::vx_setzero_s16 ()

v_int32	simd512::vx_setzero_s32 ()

v_uint32	simd512::vx_setzero_u32 ()

v_float32	simd512::vx_setzero_f32 ()

v_int64	simd512::vx_setzero_s64 ()

v_uint64	simd512::vx_setzero_u64 ()

v_float64	simd512::vx_setzero_f64 ()

Wide load from memory
Load maximum available capacity register contents from memory
v_uint8	simd512::vx_load (const uchar *ptr)

v_int8	simd512::vx_load (const schar *ptr)

v_uint16	simd512::vx_load (const ushort *ptr)

v_int16	simd512::vx_load (const short *ptr)

v_int32	simd512::vx_load (const int *ptr)

v_uint32	simd512::vx_load (const unsigned *ptr)

v_float32	simd512::vx_load (const float *ptr)

v_int64	simd512::vx_load (const int64 *ptr)

v_uint64	simd512::vx_load (const uint64 *ptr)

v_float64	simd512::vx_load (const double *ptr)

Wide load from memory(aligned)
Load maximum available capacity register contents from memory(aligned)
v_uint8	simd512::vx_load_aligned (const uchar *ptr)

v_int8	simd512::vx_load_aligned (const schar *ptr)

v_uint16	simd512::vx_load_aligned (const ushort *ptr)

v_int16	simd512::vx_load_aligned (const short *ptr)

v_int32	simd512::vx_load_aligned (const int *ptr)

v_uint32	simd512::vx_load_aligned (const unsigned *ptr)

v_float32	simd512::vx_load_aligned (const float *ptr)

v_int64	simd512::vx_load_aligned (const int64 *ptr)

v_uint64	simd512::vx_load_aligned (const uint64 *ptr)

v_float64	simd512::vx_load_aligned (const double *ptr)

Wide load lower half from memory
Load lower half of maximum available capacity register from memory
v_uint8	simd512::vx_load_low (const uchar *ptr)

v_int8	simd512::vx_load_low (const schar *ptr)

v_uint16	simd512::vx_load_low (const ushort *ptr)

v_int16	simd512::vx_load_low (const short *ptr)

v_int32	simd512::vx_load_low (const int *ptr)

v_uint32	simd512::vx_load_low (const unsigned *ptr)

v_float32	simd512::vx_load_low (const float *ptr)

v_int64	simd512::vx_load_low (const int64 *ptr)

v_uint64	simd512::vx_load_low (const uint64 *ptr)

v_float64	simd512::vx_load_low (const double *ptr)

Wide load halfs from memory
Load maximum available capacity register contents from two memory blocks
v_uint8	simd512::vx_load_halves (const uchar ptr0, const uchar ptr1)

v_int8	simd512::vx_load_halves (const schar ptr0, const schar ptr1)

v_uint16	simd512::vx_load_halves (const ushort ptr0, const ushort ptr1)

v_int16	simd512::vx_load_halves (const short ptr0, const short ptr1)

v_int32	simd512::vx_load_halves (const int ptr0, const int ptr1)

v_uint32	simd512::vx_load_halves (const unsigned ptr0, const unsigned ptr1)

v_float32	simd512::vx_load_halves (const float ptr0, const float ptr1)

v_int64	simd512::vx_load_halves (const int64 ptr0, const int64 ptr1)

v_uint64	simd512::vx_load_halves (const uint64 ptr0, const uint64 ptr1)

v_float64	simd512::vx_load_halves (const double ptr0, const double ptr1)

Wide LUT of elements
Load maximum available capacity register contents with array elements by provided indexes
v_uint8	simd512::vx_lut (const uchar ptr, const int idx)

v_int8	simd512::vx_lut (const schar ptr, const int idx)

v_uint16	simd512::vx_lut (const ushort ptr, const int idx)

v_int16	simd512::vx_lut (const short ptr, const int idx)

v_int32	simd512::vx_lut (const int ptr, const int idx)

v_uint32	simd512::vx_lut (const unsigned ptr, const int idx)

v_float32	simd512::vx_lut (const float ptr, const int idx)

v_int64	simd512::vx_lut (const int64 ptr, const int idx)

v_uint64	simd512::vx_lut (const uint64 ptr, const int idx)

v_float64	simd512::vx_lut (const double ptr, const int idx)

Wide LUT of element pairs
Load maximum available capacity register contents with array element pairs by provided indexes
v_uint8	simd512::vx_lut_pairs (const uchar ptr, const int idx)

v_int8	simd512::vx_lut_pairs (const schar ptr, const int idx)

v_uint16	simd512::vx_lut_pairs (const ushort ptr, const int idx)

v_int16	simd512::vx_lut_pairs (const short ptr, const int idx)

v_int32	simd512::vx_lut_pairs (const int ptr, const int idx)

v_uint32	simd512::vx_lut_pairs (const unsigned ptr, const int idx)

v_float32	simd512::vx_lut_pairs (const float ptr, const int idx)

v_int64	simd512::vx_lut_pairs (const int64 ptr, const int idx)

v_uint64	simd512::vx_lut_pairs (const uint64 ptr, const int idx)

v_float64	simd512::vx_lut_pairs (const double ptr, const int idx)

Wide LUT of element quads
Load maximum available capacity register contents with array element quads by provided indexes
v_uint8	simd512::vx_lut_quads (const uchar ptr, const int idx)

v_int8	simd512::vx_lut_quads (const schar ptr, const int idx)

v_uint16	simd512::vx_lut_quads (const ushort ptr, const int idx)

v_int16	simd512::vx_lut_quads (const short ptr, const int idx)

v_int32	simd512::vx_lut_quads (const int ptr, const int idx)

v_uint32	simd512::vx_lut_quads (const unsigned ptr, const int idx)

v_float32	simd512::vx_lut_quads (const float ptr, const int idx)

Wide load with double expansion
Load maximum available capacity register contents from memory with double expand
v_uint16	simd512::vx_load_expand (const uchar *ptr)

v_int16	simd512::vx_load_expand (const schar *ptr)

v_uint32	simd512::vx_load_expand (const ushort *ptr)

v_int32	simd512::vx_load_expand (const short *ptr)

v_int64	simd512::vx_load_expand (const int *ptr)

v_uint64	simd512::vx_load_expand (const unsigned *ptr)

v_float32	simd512::vx_load_expand (const float16_t *ptr)

Wide load with quad expansion
Load maximum available capacity register contents from memory with quad expand
v_uint32	simd512::vx_load_expand_q (const uchar *ptr)

v_int32	simd512::vx_load_expand_q (const schar *ptr)

Macro Definition Documentation

◆ CV_INTRIN_DEF_TYPE_TRAITS

#define CV_INTRIN_DEF_TYPE_TRAITS	(	type,
		int_type_,
		uint_type_,
		abs_type_,
		w_type_,
		q_type_,
		sum_type_
	)

Value:

template<> struct V_TypeTraits<type> \
    { \
        typedef type value_type; \
        typedef int_type_ int_type; \
        typedef abs_type_ abs_type; \
        typedef uint_type_ uint_type; \
        typedef w_type_ w_type; \
        typedef q_type_ q_type; \
        typedef sum_type_ sum_type; \
    \
        static inline int_type reinterpret_int(type x) \
        { \
            union { type l; int_type i; } v; \
            v.l = x; \
            return v.i; \
        } \
    \
        static inline type reinterpret_from_int(int_type x) \
        { \
            union { type l; int_type i; } v; \
            v.i = x; \
            return v.l; \
        } \
    }

◆ CV_INTRIN_DEF_TYPE_TRAITS_NO_Q_TYPE

#define CV_INTRIN_DEF_TYPE_TRAITS_NO_Q_TYPE	(	type,
		int_type_,
		uint_type_,
		abs_type_,
		w_type_,
		sum_type_
	)

Value:

template<> struct V_TypeTraits<type> \
    { \
        typedef type value_type; \
        typedef int_type_ int_type; \
        typedef abs_type_ abs_type; \
        typedef uint_type_ uint_type; \
        typedef w_type_ w_type; \
        typedef sum_type_ sum_type; \
    \
        static inline int_type reinterpret_int(type x) \
        { \
            union { type l; int_type i; } v; \
            v.l = x; \
            return v.i; \
        } \
    \
        static inline type reinterpret_from_int(int_type x) \
        { \
            union { type l; int_type i; } v; \
            v.i = x; \
            return v.l; \
        } \
    }

◆ CV_SIMD

#define CV_SIMD 1

◆ CV_SIMD_64F

#define CV_SIMD_64F CV_SIMD512_64F

◆ CV_SIMD_FP16

#define CV_SIMD_FP16 CV_SIMD512_FP16

◆ CV_SIMD_WIDTH

#define CV_SIMD_WIDTH 64

◆ OPENCV_HAL_1ST

#define OPENCV_HAL_1ST	(	a,
		b
	)	(a)

◆ OPENCV_HAL_ADD

#define OPENCV_HAL_ADD	(	a,
		b
	)	((a) + (b))

◆ OPENCV_HAL_AND

#define OPENCV_HAL_AND	(	a,
		b
	)	((a) & (b))

◆ OPENCV_HAL_NOP

#define OPENCV_HAL_NOP ( a ) (a)

◆ VXPREFIX

#define VXPREFIX ( func ) v512##func

Classes

Namespaces

Macros

Typedefs

Enumerations

Functions