test-simd.C File Reference

#include "givaro/givinteger.h"
#include "givaro/modular.h"
#include "fflas-ffpack/fflas-ffpack-config.h"
#include "fflas-ffpack/fflas/fflas_simd.h"
#include "fflas-ffpack/utils/args-parser.h"
#include "fflas-ffpack/utils/test-utils.h"
#include "fflas-ffpack/utils/align-allocator.h"
#include <array>
#include <vector>
#include <random>
#include <string>
#include <functional>
#include <limits>
#include <type_traits>
#include <algorithm>

Data Structures
struct	ALL< true, v... >
struct	ALL< false, v... >
struct	ALL<>
struct	count_nonconst_lvalue_reference< T, O... >
struct	count_nonconst_lvalue_reference< T &, O... >
struct	count_nonconst_lvalue_reference< const T &, O... >
struct	count_nonconst_lvalue_reference<>
struct	is_all_same< T, Args... >
struct	is_all_same<>
struct	width< T >
struct	width< float >
struct	width< double >
class	TestOneMethod< Simd >
struct	ScalFunctionsBase< Element, typename enable_if< is_floating_point< Element >::value >::type >
class	ScalFunctionsBase< Element, typename enable_if< is_floating_point< Element >::value >::type >::FloatingPointTestDistribution
struct	ScalFunctionsBase< Element, typename enable_if< is_integral< Element >::value >::type >
struct	ScalFunctions< Element >
class	string
	STL class. More...
class	vector< T >
	STL class. More...
class	array< T >
	STL class. More...

Macros
#define	_TEST_ONE(K, f1, f2, r, n)
#define	TEST_ONE_OP(f)
#define	TEST_ONE_OP_WZ(f)
#define	TEST_IMPL(SIZE, Elt)

Functions
template<typename Element>
enable_if< is_integral< Element >::value, bool >::type	check_eq (Element x, Element y)
template<typename Element>
enable_if< is_floating_point< Element >::value, bool >::type	check_eq (Element x, Element y)
template<typename Element>
bool	cmp (vector< Element > out_scal, vector< Element > out_simd)
template<typename Ret, typename T>
Ret	eval_func_on_array (function< Ret()> f, array< T, 0 > &arr)
template<typename T, typename... TArgs>
void	eval_func_on_array (function< void(T, TArgs...)> f, array< typename decay< T >::type, sizeof...(TArgs)+1 > &arr)
template<typename Ret, typename T, typename... TArgs>
Ret	eval_func_on_array (function< Ret(T, TArgs...)> f, array< typename decay< T >::type, sizeof...(TArgs)+1 > &arr)
template<typename E>
std::ostream &	operator<< (std::ostream &o, const vector< E > &V)
template<typename Simd, typename Element>
enable_if< is_floating_point< Element >::value, bool >::type	test_impl_base ()
template<typename Simd, typename Element>
enable_if< is_integral< Element >::value, bool >::type	test_impl_base ()
template<typename Simd, typename Element>
bool	test_impl ()
int	main (int argc, char *argv[])

Macro Definition Documentation

_TEST_ONE

#define _TEST_ONE	(		K,
			f1,
			f2,
			r,
			n )

Value:

        do {     \
        K T(f1, f2, r, n);                  \
        bool b = T.writeResultLine();       \
        if (b == false)                     \
            T.writeDebugData();             \
        btest &= b;                         \
    } while (0)

TEST_ONE_OP

#define TEST_ONE_OP

(

f

)

Value:

        _TEST_ONE(TestOneMethod<Simd>,               \
        function<decltype(Simd::f)>(Simd::f),                       \
        function<decltype(Scal::f)>(Scal::f),                       \
        function<decltype(Scal::genInputs)>(Scal::genInputs), #f)

TEST_ONE_OP_WZ

#define TEST_ONE_OP_WZ

(

f

)

Value:

        _TEST_ONE(TestOneMethod<Simd>,                     \
        function<decltype(Simd::f)>(Simd::f),                                \
        function<decltype(Scal::f)>(Scal::f),                                \
        function<decltype(Scal::genInputsWithZero)>(Scal::genInputsWithZero),\
        #f " test with zero")

TEST_IMPL

#define TEST_IMPL	(		SIZE,
			Elt )

Value:

        do {       \
        pass &= test_impl<Simd##SIZE<Elt>, Elt>(); \
        cout << endl; \
    } while (0)

Function Documentation

check_eq() [1/2]

template<typename Element>

enable_if< is_integral< Element >::value, bool >::type check_eq	(	Element	x,
		Element	y )

check_eq() [2/2]

template<typename Element>

enable_if< is_floating_point< Element >::value, bool >::type check_eq	(	Element	x,
		Element	y )

cmp()

template<typename Element>

bool cmp	(	vector< Element >	out_scal,
		vector< Element >	out_simd )

eval_func_on_array() [1/3]

template<typename Ret, typename T>

Ret eval_func_on_array	(	function< Ret()>	f,
		array< T, 0 > &	arr )

eval_func_on_array() [2/3]

template<typename T, typename... TArgs>

void eval_func_on_array	(	function< void(T, TArgs...)>	f,
		array< typename decay< T >::type, sizeof...(TArgs)+1 > &	arr )

eval_func_on_array() [3/3]

template<typename Ret, typename T, typename... TArgs>

Ret eval_func_on_array	(	function< Ret(T, TArgs...)>	f,
		array< typename decay< T >::type, sizeof...(TArgs)+1 > &	arr )

operator<<()

template<typename E>

std::ostream & operator<<	(	std::ostream &	o,
		const vector< E > &	V )

test_impl_base() [1/2]

template<typename Simd, typename Element>

enable_if< is_floating_point< Element >::value, bool >::type test_impl_base

(

)

test_impl_base() [2/2]

template<typename Simd, typename Element>

enable_if< is_integral< Element >::value, bool >::type test_impl_base

(

)

test_impl()

template<typename Simd, typename Element>

bool test_impl

(

)

main()

int main	(	int	argc,
		char *	argv[] )