CMSIS-DSP: Added Helium version of quaternion functions.

pull/19/head
Christophe Favergeon 5 years ago
parent 4357c9e947
commit f81dccabf7

@ -71,6 +71,74 @@
</pre>
Rotation matrix is saved in row order : R00 R01 R02 R10 R11 R12 R20 R21 R22
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
#include "arm_helium_utils.h"
void arm_quaternion2rotation_f32(const float32_t *pInputQuaternions,
float32_t *pOutputRotations,
uint32_t nbQuaternions)
{
f32x4_t vec0,vec1, vec2 ,vec3;
float32_t q2q3, tmp1, tmp2 ;
for(uint32_t nb=0; nb < nbQuaternions; nb++)
{
// q0 q1 q2 q3
vec0 = vld1q(pInputQuaternions);
// q0^2 q1^2 q2^2 q3^2
vec1 = vmulq(vec0,vec0);
// q0^2 q1q0 q2q0 q3q0
vec2 = vmulq_n_f32(vec0, vgetq_lane(vec0,0));
// 2 (q0^2 q1q0 q2q0 q3q0)
vec2 = vmulq_n_f32(vec2, 2.0f);
// 2 q2q3
q2q3 = vgetq_lane(vec0,2) * vgetq_lane(vec0,3);
q2q3 = q2q3 * 2.0f;
// 2 (q0q1 q1^2 q2q1 q3q1)
vec3 = vmulq_n_f32(vec0, vgetq_lane(vec0,1));
vec3 = vmulq_n_f32(vec3, 2.0f);
vec0 = vsetq_lane(vgetq_lane(vec1,0) + vgetq_lane(vec1,1),vec0,0);
vec0 = vsetq_lane(vgetq_lane(vec0,0) - vgetq_lane(vec1,2),vec0,0);
vec0 = vsetq_lane(vgetq_lane(vec0,0) - vgetq_lane(vec1,3),vec0,0);
vec0 = vsetq_lane(vgetq_lane(vec3,2) - vgetq_lane(vec2,3),vec0,1);
vec0 = vsetq_lane(vgetq_lane(vec3,3) + vgetq_lane(vec2,2),vec0,2);
vec0 = vsetq_lane(vgetq_lane(vec3,2) + vgetq_lane(vec2,3),vec0,3);
vst1q(pOutputRotations, vec0);
pOutputRotations += 4;
tmp1 = vgetq_lane(vec1,0) - vgetq_lane(vec1,1);
tmp2 = vgetq_lane(vec1,2) - vgetq_lane(vec1,3);
vec0 = vsetq_lane(tmp1 + tmp2,vec0,0);
vec0 = vsetq_lane(q2q3 - vgetq_lane(vec2,1) ,vec0,1);
vec0 = vsetq_lane(vgetq_lane(vec3,3) - vgetq_lane(vec2,2),vec0,2);
vec0 = vsetq_lane(q2q3 + vgetq_lane(vec2,1) ,vec0,3);
vst1q(pOutputRotations, vec0);
pOutputRotations += 4;
*pOutputRotations = tmp1 - tmp2;
pOutputRotations ++;
pInputQuaternions += 4;
}
}
#else
void arm_quaternion2rotation_f32(const float32_t *pInputQuaternions,
float32_t *pOutputRotations,
uint32_t nbQuaternions)
@ -103,6 +171,7 @@ void arm_quaternion2rotation_f32(const float32_t *pInputQuaternions,
pOutputRotations[6 + nb * 9] = zx; pOutputRotations[7 + nb * 9] = zy; pOutputRotations[8 + nb * 9] = zz;
}
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
@} end of QuatRot group

@ -49,6 +49,32 @@
@param[in] nbQuaternions number of quaternions in each vector
@return none
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
#include "arm_helium_utils.h"
void arm_quaternion_conjugate_f32(const float32_t *pInputQuaternions,
float32_t *pConjugateQuaternions,
uint32_t nbQuaternions)
{
f32x4_t vec1;
for(uint32_t i=0; i < nbQuaternions; i++)
{
vec1 = vld1q(pInputQuaternions);
vec1 = vsetq_lane_f32(-vgetq_lane(vec1, 0),vec1,0);
vec1 = vnegq_f32(vec1);
vst1q(pConjugateQuaternions, vec1);
pInputQuaternions += 4;
pConjugateQuaternions += 4;
}
}
#else
void arm_quaternion_conjugate_f32(const float32_t *pInputQuaternions,
float32_t *pConjugateQuaternions,
uint32_t nbQuaternions)
@ -62,6 +88,7 @@ void arm_quaternion_conjugate_f32(const float32_t *pInputQuaternions,
pConjugateQuaternions[4 * i + 3] = -pInputQuaternions[4 * i + 3];
}
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
@} end of QuatConjugate group

@ -51,7 +51,39 @@
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
#include "arm_helium_utils.h"
void arm_quaternion_inverse_f32(const float32_t *pInputQuaternions,
float32_t *pInverseQuaternions,
uint32_t nbQuaternions)
{
f32x4_t vec1,vec2;
float32_t squaredSum;
for(uint32_t i=0; i < nbQuaternions; i++)
{
vec1 = vld1q(pInputQuaternions);
vec2 = vmulq(vec1,vec1);
squaredSum = vecAddAcrossF32Mve(vec2);
vec1 = vmulq_n_f32(vec1, 1.0f / squaredSum);
vec1 = vsetq_lane_f32(-vgetq_lane(vec1, 0),vec1,0);
vec1 = vnegq_f32(vec1);
vst1q(pInverseQuaternions, vec1);
pInputQuaternions += 4;
pInverseQuaternions += 4;
}
}
#else
void arm_quaternion_inverse_f32(const float32_t *pInputQuaternions,
float32_t *pInverseQuaternions,
uint32_t nbQuaternions)
@ -72,6 +104,7 @@ void arm_quaternion_inverse_f32(const float32_t *pInputQuaternions,
pInverseQuaternions[4 * i + 3] = -pInputQuaternions[4 * i + 3] / temp;
}
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
@} end of QuatInverse group

@ -51,6 +51,31 @@
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
#include "arm_helium_utils.h"
void arm_quaternion_norm_f32(const float32_t *pInputQuaternions,
float32_t *pNorms,
uint32_t nbQuaternions)
{
f32x4_t vec1;
float32_t squaredSum;
for(uint32_t i=0; i < nbQuaternions; i++)
{
vec1 = vld1q(pInputQuaternions);
vec1 = vmulq(vec1,vec1);
squaredSum = vecAddAcrossF32Mve(vec1);
arm_sqrt_f32(squaredSum,pNorms);
pInputQuaternions+= 4;
pNorms ++;
}
}
#else
void arm_quaternion_norm_f32(const float32_t *pInputQuaternions,
float32_t *pNorms,
@ -67,6 +92,7 @@ void arm_quaternion_norm_f32(const float32_t *pInputQuaternions,
pNorms[i] = sqrtf(temp);
}
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
@} end of QuatNorm group

@ -49,6 +49,34 @@
@param[in] nbQuaternions number of quaternions in each vector
@return none
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
#include "arm_helium_utils.h"
void arm_quaternion_normalize_f32(const float32_t *pInputQuaternions,
float32_t *pNormalizedQuaternions,
uint32_t nbQuaternions)
{
f32x4_t vec1,vec2;
float32_t squaredSum,norm;
for(uint32_t i=0; i < nbQuaternions; i++)
{
vec1 = vld1q(pInputQuaternions);
vec2 = vmulq(vec1,vec1);
squaredSum = vecAddAcrossF32Mve(vec2);
arm_sqrt_f32(squaredSum,&norm);
vec1 = vmulq_n_f32(vec1, 1.0f / norm);
vst1q(pNormalizedQuaternions, vec1);
pInputQuaternions += 4;
pNormalizedQuaternions += 4;
}
}
#else
void arm_quaternion_normalize_f32(const float32_t *pInputQuaternions,
float32_t *pNormalizedQuaternions,
uint32_t nbQuaternions)
@ -69,6 +97,7 @@ void arm_quaternion_normalize_f32(const float32_t *pInputQuaternions,
pNormalizedQuaternions[4 * i + 3] = pInputQuaternions[4 * i + 3] / temp;
}
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
@} end of QuatNormalized group

@ -46,10 +46,75 @@
@brief Floating-point elementwise product two quaternions.
@param[in] qa first array of quaternions
@param[in] qb second array of quaternions
@param[out] r elementwise product of quaternions
@param[out] qr elementwise product of quaternions
@param[in] nbQuaternions number of quaternions in the array
@return none
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
#include "arm_helium_utils.h"
void arm_quaternion_product_f32(const float32_t *qa,
const float32_t *qb,
float32_t *qr,
uint32_t nbQuaternions)
{
static uint32_t patternA[4] = { 0, 1, 0, 1 };
static uint32_t patternB[4] = { 3, 2, 3, 2 };
static uint32_t patternC[4] = { 3, 2, 1, 0 };
static float32_t signA[4] = { -1, -1, 1, 1 };
uint32x4_t vecA = vld1q_u32(patternA);
uint32x4_t vecB = vld1q_u32(patternB);
uint32x4_t vecC = vld1q_u32(patternC);
f32x4_t vecSignA = vld1q_f32(signA);
while (nbQuaternions > 0U)
{
f32x4_t vecTmpA, vecTmpB, vecAcc;
vecTmpA = vldrwq_gather_shifted_offset_f32(qa, vecA);
vecTmpB = vld1q(qb);
/*
* vcmul(r, [a1, a2, a1, a2], [b1, b2, b3, b4], 0)
*/
vecAcc = vcmulq(vecTmpA, vecTmpB);
/*
* vcmla(r, [a1, a2, a1, a2], [b1, b2, b3, b4], 90)
*/
vecAcc = vcmlaq_rot90(vecAcc, vecTmpA, vecTmpB);
vecTmpA = vldrwq_gather_shifted_offset_f32(qa, vecB);
vecTmpB = vldrwq_gather_shifted_offset_f32(qb, vecC);
/*
* build [-b4, -b3, b2, b1]
*/
vecTmpB = vecTmpB * vecSignA;
/*
* vcmla(r, [a4, a3, a4, a3], [-b4, -b3, b2, b1], 270)
*/
vecAcc = vcmlaq_rot270(vecAcc, vecTmpA, vecTmpB);
/*
* vcmla(r, [a4, a3, a4, a3], [-b4, -b3, b2, b1], 0)
*/
vecAcc = vcmlaq(vecAcc, vecTmpA, vecTmpB);
/*
* store accumulator
*/
vst1q_f32(qr, vecAcc);
/* move to next quaternion */
qa += 4;
qb += 4;
qr += 4;
nbQuaternions--;
}
}
#else
void arm_quaternion_product_f32(const float32_t *qa,
const float32_t *qb,
float32_t *r,
@ -64,6 +129,7 @@ void arm_quaternion_product_f32(const float32_t *qa,
r += 4;
}
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
@} end of QuatProd group

@ -46,9 +46,48 @@
@brief Floating-point product of two quaternions.
@param[in] qa first quaternion
@param[in] qb second quaternion
@param[out] r product of two quaternions
@param[out] qr product of two quaternions
@return none
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
#include "arm_helium_utils.h"
void arm_quaternion_product_single_f32(const float32_t *qa,
const float32_t *qb,
float32_t *qr)
{
static uint32_t patternA[4] = { 0, 1, 0, 1 };
static uint32_t patternB[4] = { 3, 2, 3, 2 };
static uint32_t patternC[4] = { 3, 2, 1, 0 };
static float32_t signA[4] = { -1, -1, 1, 1 };
uint32x4_t vecA = vld1q_u32(patternA);
uint32x4_t vecB = vld1q_u32(patternB);
uint32x4_t vecC = vld1q_u32(patternC);
f32x4_t vecSignA = vld1q_f32(signA);
f32x4_t vecTmpA, vecTmpB, vecAcc;
vecTmpA = vldrwq_gather_shifted_offset_f32(qa, vecA);
vecTmpB = vld1q_f32(qb);
vecAcc = vcmulq_f32(vecTmpA, vecTmpB);
vecAcc = vcmlaq_rot90_f32(vecAcc, vecTmpA, vecTmpB);
vecTmpA = vldrwq_gather_shifted_offset_f32(qa, vecB);
vecTmpB = vldrwq_gather_shifted_offset_f32(qb, vecC);
vecTmpB = vecTmpB * vecSignA;
vecAcc = vcmlaq_rot270_f32(vecAcc, vecTmpA, vecTmpB);
vecAcc = vcmlaq_f32(vecAcc, vecTmpA, vecTmpB);
vst1q_f32(qr, vecAcc);
}
#else
void arm_quaternion_product_single_f32(const float32_t *qa,
const float32_t *qb,
float32_t *r)
@ -58,6 +97,7 @@ void arm_quaternion_product_single_f32(const float32_t *qa,
r[2] = qa[0] * qb[2] + qa[2] * qb[0] + qa[3] * qb[1] - qa[1] * qb[3];
r[3] = qa[0] * qb[3] + qa[3] * qb[0] + qa[1] * qb[2] - qa[2] * qb[1];
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
@} end of QuatProdSingle group

@ -56,6 +56,110 @@
* account when using the output of this function.
*
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
#include "arm_helium_utils.h"
#define R00 vgetq_lane(q1,0)
#define R01 vgetq_lane(q1,1)
#define R02 vgetq_lane(q1,2)
#define R10 vgetq_lane(q1,3)
#define R11 vgetq_lane(q2,0)
#define R12 vgetq_lane(q2,1)
#define R20 vgetq_lane(q2,2)
#define R21 vgetq_lane(q2,3)
#define R22 ro22
void arm_rotation2quaternion_f32(const float32_t *pInputRotations,
float32_t *pOutputQuaternions,
uint32_t nbQuaternions)
{
float32_t ro22, trace;
f32x4_t q1,q2, q;
float32_t doubler;
float32_t s;
q = vdupq_n_f32(0.0f);
for(uint32_t nb=0; nb < nbQuaternions; nb++)
{
q1 = vld1q(pInputRotations);
pInputRotations += 4;
q2 = vld1q(pInputRotations);
pInputRotations += 4;
ro22 = *pInputRotations++;
trace = R00 + R11 + R22;
if (trace > 0)
{
(void)arm_sqrt_f32(trace + 1.0, &doubler) ; // invs=4*qw
doubler = 2*doubler;
s = 1.0 / doubler;
q1 = vmulq_n_f32(q1,s);
q2 = vmulq_n_f32(q2,s);
q[0] = 0.25 * doubler;
q[1] = R21 - R12;
q[2] = R02 - R20;
q[3] = R10 - R01;
}
else if ((R00 > R11) && (R00 > R22) )
{
(void)arm_sqrt_f32(1.0 + R00 - R11 - R22,&doubler); // invs=4*qx
doubler = 2*doubler;
s = 1.0 / doubler;
q1 = vmulq_n_f32(q1,s);
q2 = vmulq_n_f32(q2,s);
q[0] = R21 - R12;
q[1] = 0.25 * doubler;
q[2] = R01 + R10;
q[3] = R02 + R20;
}
else if (R11 > R22)
{
(void)arm_sqrt_f32(1.0 + R11 - R00 - R22,&doubler); // invs=4*qy
doubler = 2*doubler;
s = 1.0 / doubler;
q1 = vmulq_n_f32(q1,s);
q2 = vmulq_n_f32(q2,s);
q[0] = R02 - R20;
q[1] = R01 + R10;
q[2] = 0.25 * doubler;
q[3] = R12 + R21;
}
else
{
(void)arm_sqrt_f32(1.0 + R22 - R00 - R11,&doubler); // invs=4*qz
doubler = 2*doubler;
s = 1.0 / doubler;
q1 = vmulq_n_f32(q1,s);
q2 = vmulq_n_f32(q2,s);
q[0] = R10 - R01;
q[1] = R02 + R20;
q[2] = R12 + R21;
q[3] = 0.25 * doubler;
}
vst1q(pOutputQuaternions, q);
pOutputQuaternions += 4;
}
}
#else
void arm_rotation2quaternion_f32(const float32_t *pInputRotations,
float32_t *pOutputQuaternions,
uint32_t nbQuaternions)
@ -111,6 +215,7 @@ void arm_rotation2quaternion_f32(const float32_t *pInputRotations,
}
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
@} end of RotQuat group

@ -156,6 +156,7 @@ set (NNSRC
Source/Benchmarks/ComplexMathsBenchmarksF32.cpp
Source/Benchmarks/ComplexMathsBenchmarksQ31.cpp
Source/Benchmarks/ComplexMathsBenchmarksQ15.cpp
Source/Benchmarks/QuaternionMathsBenchmarksF32.cpp
Source/Benchmarks/BayesF32.cpp
Source/Benchmarks/SVMF32.cpp
Source/Benchmarks/DistanceF32.cpp

@ -0,0 +1,29 @@
#include "Test.h"
#include "Pattern.h"
#include "dsp/quaternion_math_functions.h"
class QuaternionMathsBenchmarksF32:public Client::Suite
{
public:
QuaternionMathsBenchmarksF32(Testing::testID_t id);
virtual void setUp(Testing::testID_t,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr);
virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
private:
#include "QuaternionMathsBenchmarksF32_decl.h"
Client::Pattern<float32_t> input1;
Client::Pattern<float32_t> input2;
Client::LocalPattern<float32_t> output;
Client::RefPattern<float32_t> ref;
int nb;
float32_t *inp1;
float32_t *inp2;
float32_t *outp;
float32_t *refp;
};

@ -0,0 +1,158 @@
#include "QuaternionMathsBenchmarksF32.h"
#include "Error.h"
void QuaternionMathsBenchmarksF32::test_quaternion_norm_f32()
{
arm_quaternion_norm_f32(this->inp1,this->outp,this->nb);
}
void QuaternionMathsBenchmarksF32::test_quaternion_inverse_f32()
{
arm_quaternion_inverse_f32(this->inp1,this->outp,this->nb);
}
void QuaternionMathsBenchmarksF32::test_quaternion_conjugate_f32()
{
arm_quaternion_conjugate_f32(this->inp1,this->outp,this->nb);
}
void QuaternionMathsBenchmarksF32::test_quaternion_normalize_f32()
{
arm_quaternion_normalize_f32(this->inp1,this->outp,this->nb);
}
void QuaternionMathsBenchmarksF32::test_quaternion_prod_single_f32()
{
for(int i=0; i < this->nb; i++)
{
arm_quaternion_product_single_f32(this->inp1,this->inp2,this->outp);
this->outp += 4;
this->inp1 += 4;
this->inp2 += 4;
}
}
void QuaternionMathsBenchmarksF32::test_quaternion_product_f32()
{
arm_quaternion_product_f32(this->inp1,this->inp2,outp,this->nb);
}
void QuaternionMathsBenchmarksF32::test_quaternion2rotation_f32()
{
arm_quaternion2rotation_f32(this->inp1,this->outp,this->nb);
}
void QuaternionMathsBenchmarksF32::test_rotation2quaternion_f32()
{
arm_rotation2quaternion_f32(this->inp1,this->outp,this->nb);
}
void QuaternionMathsBenchmarksF32::setUp(Testing::testID_t id,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr)
{
this->setForceInCache(true);
std::vector<Testing::param_t>::iterator it = params.begin();
this->nb = *it;
switch(id)
{
case QuaternionMathsBenchmarksF32::TEST_QUATERNION_NORM_F32_1:
input1.reload(QuaternionMathsBenchmarksF32::INPUT1_F32_ID,mgr,this->nb*4);
output.create(this->nb,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr);
this->inp1=input1.ptr();
this->outp=output.ptr();
break;
case QuaternionMathsBenchmarksF32::TEST_QUATERNION_INVERSE_F32_2:
input1.reload(QuaternionMathsBenchmarksF32::INPUT1_F32_ID,mgr,this->nb*4);
output.create(this->nb*4,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr);
this->inp1=input1.ptr();
this->outp=output.ptr();
break;
case QuaternionMathsBenchmarksF32::TEST_QUATERNION_CONJUGATE_F32_3:
input1.reload(QuaternionMathsBenchmarksF32::INPUT1_F32_ID,mgr,this->nb*4);
output.create(this->nb*4,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr);
this->inp1=input1.ptr();
this->outp=output.ptr();
break;
case QuaternionMathsBenchmarksF32::TEST_QUATERNION_NORMALIZE_F32_4:
input1.reload(QuaternionMathsBenchmarksF32::INPUT1_F32_ID,mgr,this->nb*4);
output.create(this->nb*4,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr);
this->inp1=input1.ptr();
this->outp=output.ptr();
break;
case QuaternionMathsBenchmarksF32::TEST_QUATERNION_PROD_SINGLE_F32_5:
input1.reload(QuaternionMathsBenchmarksF32::INPUT1_F32_ID,mgr,this->nb*4);
input2.reload(QuaternionMathsBenchmarksF32::INPUT2_F32_ID,mgr,this->nb*4);
output.create(this->nb*4,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr);
this->inp1=input1.ptr();
this->inp2=input2.ptr();
this->outp=output.ptr();
break;
case QuaternionMathsBenchmarksF32::TEST_QUATERNION_PRODUCT_F32_6:
input1.reload(QuaternionMathsBenchmarksF32::INPUT1_F32_ID,mgr,this->nb*4);
input2.reload(QuaternionMathsBenchmarksF32::INPUT2_F32_ID,mgr,this->nb*4);
output.create(this->nb*4,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr);
this->inp1=input1.ptr();
this->inp2=input2.ptr();
this->outp=output.ptr();
break;
case QuaternionMathsBenchmarksF32::TEST_QUATERNION2ROTATION_F32_7:
input1.reload(QuaternionMathsBenchmarksF32::INPUT1_F32_ID,mgr,this->nb*4);
output.create(this->nb*9,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr);
this->inp1=input1.ptr();
this->outp=output.ptr();
break;
case QuaternionMathsBenchmarksF32::TEST_ROTATION2QUATERNION_F32_8:
input1.reload(QuaternionMathsBenchmarksF32::INPUT_ROT_F32_ID,mgr,this->nb*9);
output.create(this->nb*4,QuaternionMathsBenchmarksF32::OUT_SAMPLES_F32_ID,mgr);
this->inp1=input1.ptr();
this->outp=output.ptr();
break;
}
}
void QuaternionMathsBenchmarksF32::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
{
}

@ -399,6 +399,43 @@ group Root {
}
}
group Quaternion Maths {
class = QuaternionBenchmarks
folder = QuaternionMaths
suite Quaternion Maths Benchmarks F32 {
class = QuaternionMathsBenchmarksF32
folder = QuaternionMathsF32
ParamList {
NB
Summary NB
Names "NB Samples"
Formula "NB"
}
Pattern INPUT1_F32_ID : Input1_f32.txt
Pattern INPUT2_F32_ID : Input2_f32.txt
Pattern INPUT_ROT_F32_ID : Input7_f32.txt
Output OUT_SAMPLES_F32_ID : Output
Params PARAM1_ID = {
A = [16,32,64,128]
}
Functions {
Quaternion Norm:test_quaternion_norm_f32
Quaternion inverse:test_quaternion_inverse_f32
Quaternion conjugate:test_quaternion_conjugate_f32
Quaternion normalization:test_quaternion_normalize_f32
Quaternion product:test_quaternion_prod_single_f32
Quaternion Elementwise product:test_quaternion_product_f32
Quaternion to rotation:test_quaternion2rotation_f32
Rotation to quaternion:test_rotation2quaternion_f32
} -> PARAM1_ID
}
}
group Filtering {
class = DSPFiltering
folder = Filtering

Loading…
Cancel
Save