GNU Radio's BLOCKSTREAM Package
aff3ct::tools Namespace Reference

Typedefs

template<typename R >
using proto_max = R(*)(const R &a, const R &b)
 
template<typename R >
using proto_max_i = mipp::Reg< R >(*)(const mipp::Reg< R > a, const mipp::Reg< R > b)
 

Functions

template<typename T , class AT = std::allocator<T>>
__forceinline void rgemm (const int M, const int N, const int K, const std::vector< T, AT > &A, const std::vector< T, AT > &tB, std::vector< T, AT > &tC)
 
template<typename T >
__forceinline void rgemm (const int M, const int N, const int K, const T *A, const T *tB, T *tC)
 
template<typename T , class AT = std::allocator<T>>
__forceinline void cgemm (const int M, const int N, const int K, const std::vector< T, AT > &A, const std::vector< T, AT > &tB, std::vector< T, AT > &tC)
 
template<typename T >
__forceinline void cgemm (const int M, const int N, const int K, const T *A, const T *tB, T *tC)
 
template<typename T , class AT = std::allocator<T>>
__forceinline void cgemm_r (const int M, const int N, const int K, const std::vector< T, AT > &A, const std::vector< T, AT > &tB, std::vector< T, AT > &tC)
 
template<typename T >
__forceinline void cgemm_r (const int M, const int N, const int K, const T *A, const T *tB, T *tC)
 
template<typename T , class AT = std::allocator<T>>
__forceinline void real_transpose (const int M, const int N, const std::vector< T, AT > &A, std::vector< T, AT > &B)
 
template<typename T >
__forceinline void real_transpose (const int M, const int N, const T *A, T *B)
 
template<typename T , class AT = std::allocator<T>>
__forceinline void complex_transpose (const int M, const int N, const std::vector< T, AT > &A, std::vector< T, AT > &B)
 
template<typename T >
__forceinline void complex_transpose (const int M, const int N, const T *A, T *B)
 
template<typename R >
__forceinline R max (const R &a, const R &b)
 
template<typename R >
__forceinline R max_linear (const R &a, const R &b)
 
template<typename R >
__forceinline R max_star (const R &a, const R &b)
 
template<typename R >
__forceinline R max_star_safe (const R &a, const R &b)
 
template<typename R >
__forceinline mipp::Reg< Rmax_i (const mipp::Reg< R > a, const mipp::Reg< R > b)
 
template<typename R >
__forceinline mipp::Reg< Rmax_linear_i (const mipp::Reg< R > a, const mipp::Reg< R > b)
 
template<typename R >
__forceinline mipp::Reg< Rmax_star_i (const mipp::Reg< R > a, const mipp::Reg< R > b)
 
template<typename R >
R div2 (R val)
 
template<>
int32_t div2 (int32_t val)
 
template<>
int16_t div2 (int16_t val)
 
template<>
int8_t div2 (int8_t val)
 
template<typename R >
R div4 (R val)
 
template<>
int32_t div4 (int32_t val)
 
template<>
int16_t div4 (int16_t val)
 
template<>
int8_t div4 (int8_t val)
 
template<typename R >
R div8 (R val)
 
template<>
int32_t div8 (int32_t val)
 
template<>
int16_t div8 (int16_t val)
 
template<>
int8_t div8 (int8_t val)
 
template<typename R >
constexpr R init_LR ()
 
template<typename R >
constexpr R init_LLR ()
 
template<typename R >
constexpr R sat_val ()
 
template<>
constexpr double sat_val< double > ()
 
template<>
constexpr float sat_val< float > ()
 
template<>
constexpr int32_t sat_val< int32_t > ()
 
template<>
constexpr int16_t sat_val< int16_t > ()
 
template<>
constexpr int8_t sat_val< int8_t > ()
 
template<typename R >
constexpr std::pair< R, Rsat_vals ()
 
template<typename B >
constexpr B bit_init ()
 
template<typename T >
saturate (const T val, const T min, const T max)
 
template<typename T , class A = std::allocator<T>>
void saturate (std::vector< T, A > &array, const T min, const T max)
 
template<typename B , typename R >
B sgn (R val)
 
template<typename T >
constexpr bool is_power_of_2 (T x)
 
template<typename R , typename function_type >
R integral (function_type func, const R min, const R max, const int number_steps)
 

Typedef Documentation

template<typename R >
using aff3ct::tools::proto_max = typedef R (*)(const R& a, const R& b)
template<typename R >
using aff3ct::tools::proto_max_i = typedef mipp::Reg<R> (*)(const mipp::Reg<R> a, const mipp::Reg<R> b)

Function Documentation

template<typename B >
constexpr B aff3ct::tools::bit_init ( )
template<typename T , class AT = std::allocator<T>>
__forceinline void aff3ct::tools::cgemm ( const int  M,
const int  N,
const int  K,
const std::vector< T, AT > &  A,
const std::vector< T, AT > &  tB,
std::vector< T, AT > &  tC 
)
template<typename T >
__forceinline void aff3ct::tools::cgemm ( const int  M,
const int  N,
const int  K,
const T *  A,
const T *  tB,
T *  tC 
)
template<typename T , class AT = std::allocator<T>>
__forceinline void aff3ct::tools::cgemm_r ( const int  M,
const int  N,
const int  K,
const std::vector< T, AT > &  A,
const std::vector< T, AT > &  tB,
std::vector< T, AT > &  tC 
)
template<typename T >
__forceinline void aff3ct::tools::cgemm_r ( const int  M,
const int  N,
const int  K,
const T *  A,
const T *  tB,
T *  tC 
)
template<typename T , class AT = std::allocator<T>>
__forceinline void aff3ct::tools::complex_transpose ( const int  M,
const int  N,
const std::vector< T, AT > &  A,
std::vector< T, AT > &  B 
)
template<typename T >
__forceinline void aff3ct::tools::complex_transpose ( const int  M,
const int  N,
const T *  A,
T *  B 
)
template<typename R >
R aff3ct::tools::div2 ( R  val)
inline
template<>
int32_t aff3ct::tools::div2 ( int32_t  val)
inline
template<>
int16_t aff3ct::tools::div2 ( int16_t  val)
inline
template<>
int8_t aff3ct::tools::div2 ( int8_t  val)
inline
template<typename R >
R aff3ct::tools::div4 ( R  val)
inline
template<>
int32_t aff3ct::tools::div4 ( int32_t  val)
inline
template<>
int16_t aff3ct::tools::div4 ( int16_t  val)
inline
template<>
int8_t aff3ct::tools::div4 ( int8_t  val)
inline
template<typename R >
R aff3ct::tools::div8 ( R  val)
inline
template<>
int32_t aff3ct::tools::div8 ( int32_t  val)
inline
template<>
int16_t aff3ct::tools::div8 ( int16_t  val)
inline
template<>
int8_t aff3ct::tools::div8 ( int8_t  val)
inline
template<typename R >
constexpr R aff3ct::tools::init_LLR ( )
template<typename R >
constexpr R aff3ct::tools::init_LR ( )
template<typename R , typename function_type >
R aff3ct::tools::integral ( function_type  func,
const R  min,
const R  max,
const int  number_steps 
)
inline

References mipp::min().

template<typename T >
constexpr bool aff3ct::tools::is_power_of_2 ( x)
template<typename R >
__forceinline R aff3ct::tools::max ( const R a,
const R b 
)
template<typename R >
__forceinline mipp::Reg<R> aff3ct::tools::max_i ( const mipp::Reg< R a,
const mipp::Reg< R b 
)
template<typename R >
__forceinline R aff3ct::tools::max_linear ( const R a,
const R b 
)
template<typename R >
__forceinline mipp::Reg<R> aff3ct::tools::max_linear_i ( const mipp::Reg< R a,
const mipp::Reg< R b 
)
template<typename R >
__forceinline R aff3ct::tools::max_star ( const R a,
const R b 
)
template<typename R >
__forceinline mipp::Reg<R> aff3ct::tools::max_star_i ( const mipp::Reg< R a,
const mipp::Reg< R b 
)
template<typename R >
__forceinline R aff3ct::tools::max_star_safe ( const R a,
const R b 
)
template<typename T , class AT = std::allocator<T>>
__forceinline void aff3ct::tools::real_transpose ( const int  M,
const int  N,
const std::vector< T, AT > &  A,
std::vector< T, AT > &  B 
)
template<typename T >
__forceinline void aff3ct::tools::real_transpose ( const int  M,
const int  N,
const T *  A,
T *  B 
)
template<typename T , class AT = std::allocator<T>>
__forceinline void aff3ct::tools::rgemm ( const int  M,
const int  N,
const int  K,
const std::vector< T, AT > &  A,
const std::vector< T, AT > &  tB,
std::vector< T, AT > &  tC 
)
template<typename T >
__forceinline void aff3ct::tools::rgemm ( const int  M,
const int  N,
const int  K,
const T *  A,
const T *  tB,
T *  tC 
)
template<typename R >
constexpr R aff3ct::tools::sat_val ( )
template<>
constexpr double aff3ct::tools::sat_val< double > ( )
template<>
constexpr float aff3ct::tools::sat_val< float > ( )
template<>
constexpr int16_t aff3ct::tools::sat_val< int16_t > ( )
template<>
constexpr int32_t aff3ct::tools::sat_val< int32_t > ( )
template<>
constexpr int8_t aff3ct::tools::sat_val< int8_t > ( )
template<typename R >
constexpr std::pair<R, R> aff3ct::tools::sat_vals ( )
template<typename T >
T aff3ct::tools::saturate ( const T  val,
const T  min,
const T  max 
)
inline

References mipp::max(), and mipp::min().

template<typename T , class A = std::allocator<T>>
void aff3ct::tools::saturate ( std::vector< T, A > &  array,
const T  min,
const T  max 
)
inline
template<typename B , typename R >
B aff3ct::tools::sgn ( R  val)