CMSIS-DSP: Scalar version of Levinson Durbin algorithms.

f32, f16 and q31.
pull/19/head
Christophe Favergeon 5 years ago
parent 2074a3b291
commit e9a8ba6255

@ -279,6 +279,23 @@ arm_status arm_sqrt_q15(
* @} end of SQRT group
*/
/**
@brief Fixed point division
@param[in] numerator Numerator
@param[in] denominator Denominator
@param[out] quotient Quotient value normalized between -1.0 and 1.0
@param[out] shift Shift left value to get the unnormalized quotient
@return error status
When dividing by 0, an error ARM_MATH_NANINF is returned. And the quotient is forced
to the saturated negative or positive value.
*/
arm_status arm_divide_q15(q15_t numerator,
q15_t denominator,
q15_t *quotient,
int16_t *shift);
#ifdef __cplusplus
}

@ -33,6 +33,7 @@
#include "dsp/utils.h"
#include "dsp/support_functions.h"
#include "dsp/fast_math_functions.h"
#ifdef __cplusplus
extern "C"
@ -2432,8 +2433,33 @@ void arm_correlate_fast_q31(
}
/**
@brief Levinson Durbin
@param[in] phi autocovariance vector starting with lag 0 (length is nbCoefs + 1)
@param[out] a autoregressive coefficients
@param[out] err prediction error (variance)
@param[in] nbCoefs number of autoregressive coefficients
@return none
*/
void arm_levinson_durbin_f32(const float32_t *phi,
float32_t *a,
float32_t *err,
int nbCoefs);
/**
@brief Levinson Durbin
@param[in] phi autocovariance vector starting with lag 0 (length is nbCoefs + 1)
@param[out] a autoregressive coefficients
@param[out] err prediction error (variance)
@param[in] nbCoefs number of autoregressive coefficients
@return none
*/
void arm_levinson_durbin_q31(const q31_t *phi,
q31_t *a,
q31_t *err,
int nbCoefs);
#ifdef __cplusplus
}
#endif

@ -214,6 +214,20 @@ extern "C"
uint32_t srcBLen,
float16_t * pDst);
/**
@brief Levinson Durbin
@param[in] phi autocovariance vector starting with lag 0 (length is nbCoefs + 1)
@param[out] a autoregressive coefficients
@param[out] err prediction error (variance)
@param[in] nbCoefs number of autoregressive coefficients
@return none
*/
void arm_levinson_durbin_f16(const float16_t *phi,
float16_t *a,
float16_t *err,
int nbCoefs);
#endif /*defined(ARM_FLOAT16_SUPPORTED)*/
#ifdef __cplusplus
}

@ -53,6 +53,8 @@ target_sources(CMSISDSPFastMath PRIVATE arm_vexp_f16.c)
target_sources(CMSISDSPFastMath PRIVATE arm_vinverse_f16.c)
endif()
target_sources(CMSISDSPFastMath PRIVATE arm_divide_q15.c)
### Includes
target_include_directories(CMSISDSPFastMath PUBLIC "${DSP}/Include")

@ -58,4 +58,5 @@
#include "arm_sqrt_q31.c"
#include "arm_vexp_f32.c"
#include "arm_vlog_f32.c"
#include "arm_divide_q15.c"

@ -0,0 +1,110 @@
/* ----------------------------------------------------------------------
* Project: CMSIS DSP Library
* Title: arm_cos_q15.c
* Description: Fast cosine calculation for Q15 values
*
* $Date: 18. March 2019
* $Revision: V1.6.0
*
* Target Processor: Cortex-M cores
* -------------------------------------------------------------------- */
/*
* Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dsp/fast_math_functions.h"
#include "arm_common_tables.h"
#include <stdlib.h>
/**
@ingroup groupFastMath
*/
/**
@defgroup divide Fixed point division
*/
/**
@addtogroup divide
@{
*/
/**
@brief Fixed point division
@param[in] numerator Numerator
@param[in] denominator Denominator
@param[out] quotient Quotient value normalized between -1.0 and 1.0
@param[out] shift Shift left value to get the unnormalized quotient
@return error status
When dividing by 0, an error ARM_MATH_NANINF is returned. And the quotient is forced
to the saturated negative or positive value.
*/
arm_status arm_divide_q15(q15_t numerator,
q15_t denominator,
q15_t *quotient,
int16_t *shift)
{
int16_t sign=0;
q31_t temp;
int16_t shiftForNormalizing;
*shift = 0;
sign = (numerator>>15) ^ (denominator>>15);
if (denominator == 0)
{
if (sign)
{
*quotient = 0x8000;
}
else
{
*quotient = 0x7FFF;
}
return(ARM_MATH_NANINF);
}
numerator = abs(numerator);
denominator = abs(denominator);
temp = ((q31_t)numerator << 15) / ((q31_t)denominator);
shiftForNormalizing= 17 - __CLZ(temp);
if (shiftForNormalizing > 0)
{
*shift = shiftForNormalizing;
temp = temp >> shiftForNormalizing;
}
if (sign)
{
temp = -temp;
}
*quotient=temp;
return(ARM_MATH_SUCCESS);
}
/**
@} end of divide group
*/

@ -122,6 +122,8 @@ target_sources(CMSISDSPFiltering PRIVATE arm_lms_norm_q15.c)
target_sources(CMSISDSPFiltering PRIVATE arm_lms_norm_q31.c)
target_sources(CMSISDSPFiltering PRIVATE arm_lms_q15.c)
target_sources(CMSISDSPFiltering PRIVATE arm_lms_q31.c)
target_sources(CMSISDSPFiltering PRIVATE arm_levinson_durbin_f32.c)
target_sources(CMSISDSPFiltering PRIVATE arm_levinson_durbin_q31.c)
if ((NOT ARMAC5) AND (NOT DISABLEFLOAT16))
target_sources(CMSISDSPFiltering PRIVATE arm_fir_f16.c)
@ -133,6 +135,7 @@ target_sources(CMSISDSPFiltering PRIVATE arm_biquad_cascade_df2T_init_f16.c)
target_sources(CMSISDSPFiltering PRIVATE arm_biquad_cascade_stereo_df2T_f16.c)
target_sources(CMSISDSPFiltering PRIVATE arm_biquad_cascade_stereo_df2T_init_f16.c)
target_sources(CMSISDSPFiltering PRIVATE arm_correlate_f16.c)
target_sources(CMSISDSPFiltering PRIVATE arm_levinson_durbin_f16.c)
endif()
### Includes

@ -131,3 +131,6 @@
#include "arm_lms_norm_q31.c"
#include "arm_lms_q15.c"
#include "arm_lms_q31.c"
#include "arm_levinson_durbin_f32.c"
#include "arm_levinson_durbin_q31.c"

@ -33,3 +33,4 @@
#include "arm_biquad_cascade_stereo_df2T_f16.c"
#include "arm_biquad_cascade_stereo_df2T_init_f16.c"
#include "arm_correlate_f16.c"
#include "arm_levinson_durbin_f16.c"

@ -0,0 +1,110 @@
/* ----------------------------------------------------------------------
* Project: CMSIS DSP Library
* Title: arm_levinson_durbin_f16.c
* Description: f16 version of Levinson Durbin algorithm
*
*
* -------------------------------------------------------------------- */
/*
* Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dsp/filtering_functions_f16.h"
/**
@ingroup groupFilters
*/
/**
@defgroup LD Levinson Durbin Algorithm
*/
/**
@addtogroup LD
@{
*/
/**
@brief Levinson Durbin
@param[in] phi autocovariance vector starting with lag 0 (length is nbCoefs + 1)
@param[out] a autoregressive coefficients
@param[out] err prediction error (variance)
@param[in] nbCoefs number of autoregressive coefficients
@return none
*/
#if defined(ARM_FLOAT16_SUPPORTED)
void arm_levinson_durbin_f16(const float16_t *phi,
float16_t *a,
float16_t *err,
int nbCoefs)
{
float16_t e;
a[0] = phi[1] / phi[0];
e = phi[0] - phi[1] * a[0];
for(int p=1; p < nbCoefs; p++)
{
float16_t suma=0.0f16;
float16_t sumb=0.0f16;
float16_t k;
int nb,j;
for(int i=0; i < p; i++)
{
suma += a[i] * phi[p - i];
sumb += a[i] * phi[i + 1];
}
k = (phi[p+1]-suma)/(phi[0] - sumb);
nb = p >> 1;
j=0;
for(int i =0;i < nb ; i++)
{
float16_t x,y;
x=a[j] - k * a[p-1-j];
y=a[p-1-j] - k * a[j];
a[j] = x;
a[p-1-j] = y;
j++;
}
nb = p & 1;
if (nb)
{
a[j]=a[j]- k * a[p-1-j];
}
a[p] = k;
e = e * (1 - k*k);
}
*err = e;
}
#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */
/**
@} end of LD group
*/

@ -0,0 +1,107 @@
/* ----------------------------------------------------------------------
* Project: CMSIS DSP Library
* Title: arm_levinson_durbin_f32.c
* Description: f32 version of Levinson Durbin algorithm
*
*
* -------------------------------------------------------------------- */
/*
* Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dsp/filtering_functions.h"
/**
@ingroup groupFilters
*/
/**
@defgroup LD Levinson Durbin Algorithm
*/
/**
@addtogroup LD
@{
*/
/**
@brief Levinson Durbin
@param[in] phi autocovariance vector starting with lag 0 (length is nbCoefs + 1)
@param[out] a autoregressive coefficients
@param[out] err prediction error (variance)
@param[in] nbCoefs number of autoregressive coefficients
@return none
*/
void arm_levinson_durbin_f32(const float32_t *phi,
float32_t *a,
float32_t *err,
int nbCoefs)
{
float32_t e;
a[0] = phi[1] / phi[0];
e = phi[0] - phi[1] * a[0];
for(int p=1; p < nbCoefs; p++)
{
float32_t suma=0.0f;
float32_t sumb=0.0f;
float32_t k;
int nb,j;
for(int i=0; i < p; i++)
{
suma += a[i] * phi[p - i];
sumb += a[i] * phi[i + 1];
}
k = (phi[p+1]-suma)/(phi[0] - sumb);
nb = p >> 1;
j=0;
for(int i =0;i < nb ; i++)
{
float32_t x,y;
x=a[j] - k * a[p-1-j];
y=a[p-1-j] - k * a[j];
a[j] = x;
a[p-1-j] = y;
j++;
}
nb = p & 1;
if (nb)
{
a[j]=a[j]- k * a[p-1-j];
}
a[p] = k;
e = e * (1 - k*k);
}
*err = e;
}
/**
@} end of LD group
*/

@ -0,0 +1,214 @@
/* ----------------------------------------------------------------------
* Project: CMSIS DSP Library
* Title: arm_levinson_durbin_q31.c
* Description: q31 version of Levinson Durbin algorithm
*
*
* -------------------------------------------------------------------- */
/*
* Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dsp/filtering_functions.h"
#define ONE_Q31 0x7FFFFFFFL
#define TWO_Q30 0x7FFFFFFFL
#define HALF_Q31 0x00008000L
#define ONE_Q15 0x7FFF
#define HALF_Q15 0x3FFF
#define LOWPART_MASK 0x07FFF
#include <stdio.h>
#define FQ31(X) (1.0*(X) / ONE_Q31)
#define FQ15(X) (1.0*(X) / ONE_Q15)
#define PQ31(X) \
if ((X)>=0) \
{ \
printf("%08X (%f)",(X),FQ31(X)); \
} \
else \
{ \
printf("-%08X (%f)",-(X),FQ31(X));\
}
#define PQ15(X) \
if ((X)>=0) \
{ \
printf("%04X (%f)",(X),FQ15(X)); \
} \
else \
{ \
printf("-%04X (%f)",-(X),FQ15(X));\
}
__STATIC_FORCEINLINE q31_t mul32x16(q31_t a, q15_t b)
{
q31_t r = ((q63_t)a * (q63_t)b) >> 15;
return(r);
}
__STATIC_FORCEINLINE q31_t mul32x32(q31_t a, q31_t b)
{
//q31_t r = __SSAT(((q63_t)a * b) >> 31,31);
q31_t r = ((q63_t)a * b) >> 31;
return(r);
}
__STATIC_FORCEINLINE q31_t divide(q31_t n, q31_t d)
{
arm_status status;
int16_t shift;
q15_t inverse;
q31_t r;
// We are computing:
// n / d = n / (h + l) where h and l are the high end and low end part.
// 1 / (h + l) = 1 / h (1 - l / h)
// Our division algorithm has a shift. So it is returning a scaled value sh.
// So we need a << shift to convert 1/ sh to 1/h.
// In below code, we are organizing the computation differently. Instead of computing:
// 1 / h (1 - l / h)
// we are computing
// 1 / h (2 - (l + h) / h)
// 1 / h (2 - d / h)
// Also, we are not computing 1/h in Q15 but in Q14.
// 2 is expressed in Q30.
// So at the end of all computation we need a << 2
// Result is in Q14 because of use of HALF_Q15 instead of ONE_Q15.
status=arm_divide_q15(HALF_Q15,d>>16,&inverse,&shift);
// d is used instead of l
// So we will need to substract to 2 instead of 1.
r = mul32x16(d,inverse);
r = TWO_Q30 - (r << shift);
r = mul32x16(r, inverse);
r = mul32x32(r,n) ;
r = r << (shift + 2);
return(r);
}
/**
@ingroup groupFilters
*/
/**
@defgroup LD Levinson Durbin Algorithm
*/
/**
@addtogroup LD
@{
*/
/**
@brief Levinson Durbin
@param[in] phi autocovariance vector starting with lag 0 (length is nbCoefs + 1)
@param[out] a autoregressive coefficients
@param[out] err prediction error (variance)
@param[in] nbCoefs number of autoregressive coefficients
@return none
*/
void arm_levinson_durbin_q31(const q31_t *phi,
q31_t *a,
q31_t *err,
int nbCoefs)
{
q31_t e;
//a[0] = phi[1] / phi[0];
a[0] = divide(phi[1], phi[0]);
//printf("%08X %08X\n",phi[1],phi[0]);
//printf("%f / %f = %f\n",FQ31(phi[1]),FQ31(phi[0]),FQ31(a[0]));
//e = phi[0] - phi[1] * a[0];
e = phi[0] - mul32x32(phi[1],a[0]);
for(int p=1; p < nbCoefs; p++)
{
q63_t suma=0;
q63_t sumb=0;
q31_t k;
int nb,j;
for(int i=0; i < p; i++)
{
suma += ((q63_t)a[i] * phi[p - i]);
sumb += ((q63_t)a[i] * phi[i + 1]);
}
suma = suma >> 31;
sumb = sumb >> 31;
//printf("suma = %08X, sumb=%08X\n",(q31_t)(suma & 0x0FFFFFFFF),(q31_t)(sumb & 0x0FFFFFFFF));
//k = (phi[p+1]-suma)/(phi[0] - sumb);
k = divide(phi[p+1]-(q31_t)suma,phi[0] - (q31_t)sumb);
nb = p >> 1;
j=0;
for(int i =0;i < nb ; i++)
{
q31_t x,y;
//x = a[j] - k * a[p-1-j];
x = a[j] - mul32x32(k,a[p-1-j]);
//y = a[p-1-j] - k * a[j];
y = a[p-1-j] - mul32x32(k , a[j]);
a[j] = x;
a[p-1-j] = y;
j++;
}
nb = p & 1;
if (nb)
{
//a[j] = a[j]- k * a[p-1-j];
a[j] = a[j] - mul32x32(k,a[p-1-j]);
}
a[p] = k;
// e = e * (1 - k*k);
e = mul32x32(e,ONE_Q31 - mul32x32(k,k));
}
*err = e;
}
/**
@} end of LD group
*/

@ -14,10 +14,17 @@ class FastMathQ15:public Client::Suite
Client::Pattern<q15_t> input;
Client::Pattern<q15_t> numerator;
Client::Pattern<q15_t> denominator;
Client::LocalPattern<q15_t> output;
Client::LocalPattern<int16_t> shift;
// Reference patterns are not loaded when we are in dump mode
Client::RefPattern<q15_t> ref;
Client::RefPattern<int16_t> refShift;
};

@ -16,11 +16,12 @@ class MISCF16:public Client::Suite
Client::Pattern<float16_t> inputB;
Client::LocalPattern<float16_t> output;
Client::LocalPattern<float16_t> tmp;
// Reference patterns are not loaded when we are in dump mode
Client::RefPattern<float16_t> ref;
int nba,nbb;
int nba,nbb,errOffset;
};

@ -16,11 +16,12 @@ class MISCF32:public Client::Suite
Client::Pattern<float32_t> inputB;
Client::LocalPattern<float32_t> output;
Client::LocalPattern<float32_t> tmp;
// Reference patterns are not loaded when we are in dump mode
Client::RefPattern<float32_t> ref;
int nba,nbb;
int nba,nbb,errOffset;
};

@ -20,7 +20,7 @@ class MISCQ31:public Client::Suite
// Reference patterns are not loaded when we are in dump mode
Client::RefPattern<q31_t> ref;
int nba,nbb;
int nba,nbb,errOffset;
};

@ -307,11 +307,11 @@ def generatePatterns():
configq15=Tools.Config(PATTERNDIR,PARAMDIR,"q15")
configq7=Tools.Config(PATTERNDIR,PARAMDIR,"q7")
configf32.setOverwrite(False)
configf16.setOverwrite(False)
configq31.setOverwrite(False)
configq15.setOverwrite(False)
configq7.setOverwrite(False)
#configf32.setOverwrite(False)
#configf16.setOverwrite(False)
#configq31.setOverwrite(False)
#configq15.setOverwrite(False)
#configq7.setOverwrite(False)
writeTests(configf32,0)
writeTests(configf16,16)

@ -2,6 +2,7 @@ import os.path
import numpy as np
import itertools
import Tools
import statsmodels.tsa.stattools
# Those patterns are used for tests and benchmarks.
# For tests, there is the need to add tests for saturation
@ -12,7 +13,14 @@ def cartesian(*somelists):
r.append(element)
return(r)
def autocorr(x):
result = np.correlate(x, x, mode='full')
return result[result.size//2:]
def writeTests(config,format):
config.setOverwrite(False)
NBSAMPLES=128
inputsA=np.random.randn(NBSAMPLES)
@ -76,6 +84,43 @@ def writeTests(config,format):
config.writeReference(nbTest, ref)
nbTest = nbTest + 1
# Levinson durbin tests
config.setOverwrite(True)
a = [Tools.loopnb(format,Tools.TAILONLY),
Tools.loopnb(format,Tools.BODYONLY),
Tools.loopnb(format,Tools.BODYANDTAIL),
]
a = list(np.unique(np.array(a)))
#a = [3]
# Errors of each levinson durbin test
err=[]
errTestID = nbTest
for na in a:
s = np.random.randn(na+1)
s = Tools.normalize(s)
phi = autocorr(s)
phi = Tools.normalize(phi)
config.writeInput(nbTest, phi,"InputPhi")
sigmav,arcoef,pacf,sigma,phi=statsmodels.tsa.stattools.levinson_durbin(phi,nlags=na,isacov=True)
err.append(sigmav)
config.writeReference(nbTest, arcoef)
nbTest = nbTest + 1
config.writeReference(errTestID, err,"LDErrors")
@ -88,8 +133,7 @@ def generatePatterns():
configq31=Tools.Config(PATTERNDIR,PARAMDIR,"q31")
configq15=Tools.Config(PATTERNDIR,PARAMDIR,"q15")
configq7=Tools.Config(PATTERNDIR,PARAMDIR,"q7")
writeTests(configf32,0)
writeTests(configf16,16)

@ -10,9 +10,46 @@ import math
# For benchmarks
NBSAMPLES=256
def cartesian(*somelists):
r=[]
for element in itertools.product(*somelists):
r.append(element)
return(r)
# Fixed point division should not be called with a denominator of zero.
# But if it is, it should return a saturated result.
def divide(f,r):
e = 0
if f == Tools.Q31:
e = 1.0 / (1<<31)
if f == Tools.Q15:
e = 1.0 / (1<<15)
if f == Tools.Q7:
e = 1.0 / (1<<7)
a,b=r
if b == 0.0:
if a >= 0.0:
return(1.0,0)
else:
return(-1.0,0)
k = 0
while abs(a) > abs(b):
a = a / 2.0
k = k + 1
# In C code we don't saturate but instead generate the right value
# with a shift of 1.
# So this test is to ease the comparison between the Python reference
# and the output of the division algorithm in C
if abs(a/b) > 1 - e:
a = a / 2.0
k = k + 1
return(a/b,k)
def writeTests(config,format):
config.setOverwrite(False)
a1=np.array([0,math.pi/4,math.pi/2,3*math.pi/4,math.pi,5*math.pi/4,3*math.pi/2,2*math.pi-1e-6])
a2=np.array([-math.pi/4,-math.pi/2,-3*math.pi/4,-math.pi,-5*math.pi/4,-3*math.pi/2,-2*math.pi-1e-6])
a3 = a1 + 2*math.pi
@ -42,8 +79,31 @@ def writeTests(config,format):
samples = np.abs(Tools.normalize(samples))
config.writeInput(1, samples,"Samples")
config.setOverwrite(True)
numerator=np.linspace(-0.9,0.9)
denominator=np.linspace(-0.9,0.9)
samples=cartesian(numerator,denominator)
numerator=[x[0] for x in samples]
denominator=[x[1] for x in samples]
result=[divide(format,x) for x in samples]
resultValue=[x[0] for x in result]
resultShift=[x[1] for x in result]
config.writeInput(1, numerator,"Numerator")
config.writeInput(1, denominator,"Denominator")
config.writeReference(1, resultValue,"DivisionValue")
config.writeReferenceS16(1, resultShift,"DivisionShift")
config.setOverwrite(False)
def writeTestsFloat(config,format):
config.setOverwrite(False)
writeTests(config,format)
data1 = np.random.randn(20)
@ -69,6 +129,8 @@ def writeTestsFloat(config,format):
v = 1.0 / samples
config.writeReference(1, v,"Inverse")
config.setOverwrite(True)
@ -83,9 +145,9 @@ def generatePatterns():
configq15=Tools.Config(PATTERNDIR,PARAMDIR,"q15")
writeTestsFloat(configf32,0)
writeTestsFloat(configf16,16)
writeTests(configq31,31)
#writeTestsFloat(configf32,0)
#writeTestsFloat(configf16,16)
#writeTests(configq31,31)
writeTests(configq15,15)

File diff suppressed because it is too large Load Diff

@ -0,0 +1,514 @@
W
256
// 20.570269
0x41a48fe9
// 3.005693
0x40405d46
// 3.437678
0x405c02ed
// 2.341757
0x4015df57
// 1.925240
0x3ff66e44
// 18.457429
0x4193a8d1
// 8.929507
0x410edf42
// 2.305135
0x40138755
// 14.539475
0x4168a1b0
// 2.456871
0x401d3d60
// 2.437063
0x401bf8d9
// 1.721858
0x3fdc65d8
// 4.718444
0x4096fd7d
// 121.336098
0x42f2ac15
// 23.022341
0x41b82dc1
// 2.322810
0x4014a8ed
// 12.718834
0x414b8058
// 2.097547
0x40063e38
// 1.862629
0x3fee6a9e
// 2.812624
0x40340209
// 7.250490
0x40e80404
// 4.659403
0x409519d5
// 10.814125
0x412d06a8
// 7.629272
0x40f42300
// 1.679974
0x3fd70963
// 3.334551
0x40556947
// 5.070294
0x40a23fda
// 3.762428
0x4070cb9d
// 4.942038
0x409e252d
// 3.277423
0x4051c14b
// 4.761575
0x40985ed3
// 1.210259
0x3f9ae9c2
// 5.901642
0x40bcda41
// 1.561545
0x3fc7e0b4
// 19.666190
0x419d545c
// 11.062809
0x41310144
// 2.527127
0x4021bc72
// 2.583651
0x40255a8b
// 3.636987
0x4068c464
// 3.987334
0x407f307d
// 16.594990
0x4184c28a
// 7.928754
0x40fdb85b
// 16.915488
0x418752ec
// 10.636075
0x412a2d5d
// 2.597557
0x40263e5e
// 4.780230
0x4098f7a4
// 3.815592
0x407432aa
// 50.184726
0x4248bd29
// 5.107157
0x40a36dd5
// 6.325569
0x40ca6b0f
// 1.526713
0x3fc36b58
// 9.160831
0x411292c4
// 1.731258
0x3fdd99de
// 1.704192
0x3fda22f7
// 2.979842
0x403eb5ba
// 2.039999
0x40028f58
// 8.640898
0x410a411e
// 7.606463
0x40f36824
// 11.418855
0x4136b3a1
// 5.960287
0x40bebaac
// 20.890517
0x41a71fc8
// 3.026111
0x4041abcc
// 3.175259
0x404b3771
// 2.291118
0x4012a1ac
// 3.989908
0x407f5aa9
// 23.183256
0x41b9774f
// 9.830255
0x411d48ba
// 4.279814
0x4088f43d
// 1.716108
0x3fdba971
// 4.440618
0x408e198b
// 2.388560
0x4018de2b
// 4.310129
0x4089ec94
// 25.813316
0x41ce81ac
// 5.230998
0x40a76456
// 9.500647
0x411802a6
// 2.694507
0x402c72d0
// 7.036071
0x40e1277e
// 7.276525
0x40e8d94a
// 14.822915
0x416d2aa9
// 6.552798
0x40d1b086
// 5.465099
0x40aee217
// 8.451957
0x41073b38
// 6.083568
0x40c2ac98
// 1.648533
0x3fd30325
// 54.874447
0x425b7f6f
// 3.135390
0x4048aa3b
// 7.481891
0x40ef6ba8
// 3.262985
0x4050d4c1
// 22.851160
0x41b6cf2d
// 2.097006
0x40063558
// 2.158489
0x400a24af
// 5.878407
0x40bc1be8
// 4.018069
0x40809406
// 6.637228
0x40d4642c
// 1.489058
0x3fbe9974
// 7.728825
0x40f75289
// 3.576841
0x4064eaf6
// 22.934050
0x41b778ef
// 11.681107
0x413ae5d1
// 3.170489
0x404ae94b
// 172.024771
0x432c0657
// 3.824911
0x4074cb59
// 22.048196
0x41b062b4
// 2.526739
0x4021b616
// 18.267509
0x419223dc
// 19.202240
0x41999e30
// 2.935572
0x403be06b
// 4.751640
0x40980d6e
// 3.821299
0x4074902b
// 3.184288
0x404bcb62
// 6.752807
0x40d816ff
// 12.431812
0x4146e8b4
// 11.272466
0x41345c05
// 4.462909
0x408ed027
// 13.627851
0x415a0bad
// 1.591648
0x3fcbbb21
// 4.850340
0x409b35fd
// 3.470798
0x405e218e
// 2.573153
0x4024ae8b
// 3.149276
0x40498dbc
// 10.792172
0x412cacbd
// 1.745680
0x3fdf7270
// 68.933748
0x4289de14
// 43.788234
0x422f2727
// 30.308857
0x41f2788a
// 2.308416
0x4013bd18
// 2.493770
0x401f99ed
// 1.798934
0x3fe6437b
// 13.602725
0x4159a4c3
// 4.480936
0x408f63d5
// 2.086906
0x40058fdf
// 10.947474
0x412f28da
// 8.339189
0x41056d51
// 3.258398
0x40508999
// 15.789865
0x417ca34a
// 9.171636
0x4112bf06
// 5.375292
0x40ac0264
// 2.453997
0x401d0e4c
// 3.525489
0x4061a19c
// 6.824319
0x40da60d3
// 2.778720
0x4031d68b
// 2.694566
0x402c73c5
// 4.693339
0x40962fd6
// 9.711562
0x411b628f
// 4.724762
0x40973141
// 2.121839
0x4007cc38
// 9.424363
0x4116ca31
// 3.918836
0x407ace35
// 2.643620
0x40293113
// 7.891364
0x40fc860f
// 41.260098
0x42250a57
// 3.699858
0x406cca79
// 6.970714
0x40df1017
// 9.108116
0x4111bad8
// 3.797920
0x40731120
// 842.005168
0x44528055
// 2.256493
0x40106a60
// 2.110276
0x40070ec3
// 3.004739
0x40404da6
// 1.000000
0x3f800000
// 3.783553
0x407225ba
// 16.077177
0x41809e0f
// 6.193861
0x40c6341d
// 13.707780
0x415b5311
// 15.740147
0x417bd7a4
// 5.308331
0x40a9ddd9
// 2.760697
0x4030af44
// 1.837510
0x3feb338a
// 17.976566
0x418fd002
// 2.972724
0x403e411b
// 4.052418
0x4081ad69
// 1.544025
0x3fc5a29b
// 11.443291
0x413717b8
// 3.364977
0x40575bc7
// 5.689392
0x40b60f7f
// 2.441200
0x401c3c9f
// 25.469961
0x41cbc27b
// 3.364070
0x40574cec
// 3.692493
0x406c51cf
// 2.543971
0x4022d06c
// 3.709176
0x406d6324
// 2.359784
0x401706b2
// 5.452130
0x40ae77d9
// 1.656920
0x3fd415f5
// 7.692280
0x40f62728
// 1.874125
0x3fefe357
// 4.974378
0x409f2e1c
// 13.481223
0x4157b317
// 3.726303
0x406e7bc0
// 1.242396
0x3f9f06d2
// 1.258574
0x3fa118f2
// 5.303500
0x40a9b646
// 4.718018
0x4096fa00
// 9.910969
0x411e9354
// 4.788856
0x40993e4f
// 2.025906
0x4001a872
// 3.531266
0x40620042
// 3.098257
0x404649d7
// 3.021634
0x40416273
// 7.282199
0x40e907c6
// 6.205568
0x40c69404
// 4.899776
0x409ccaf8
// 2.244027
0x400f9e23
// 26.419982
0x41d35c1f
// 5.186435
0x40a5f747
// 3.828633
0x40750852
// 4.959429
0x409eb3a5
// 7.505960
0x40f030d3
// 5.476953
0x40af4334
// 24.651866
0x41c53705
// 1.994351
0x3fff46e6
// 155.825558
0x431bd358
// 4.404009
0x408ceda4
// 10.425794
0x4126d00e
// 4.414924
0x408d470f
// 11.248382
0x4133f95f
// 2.528079
0x4021cc0b
// 7.260178
0x40e85361
// 2.937711
0x403c0377
// 1.238676
0x3f9e8cf1
// 14.325252
0x4165343b
// 1.609379
0x3fce0024
// 5.950032
0x40be66aa
// 4.802752
0x4099b024
// 8.033420
0x410088e4
// 5.600093
0x40b333f6
// 16.086995
0x4180b22a
// 8.875806
0x410e034d
// 5.432866
0x40adda0a
// 4.458170
0x408ea953
// 4.272062
0x4088b4bc
// 1.904025
0x3ff3b718
// 1.813126
0x3fe81487
// 4.886573
0x409c5ece
// 4.032567
0x40810ac9
// 1.157807
0x3f943301
// 8.454507
0x410745a9
// 17.379962
0x418b0a29
// 4.148946
0x4084c42a
// 17.617618
0x418cf0e2
// 5.360786
0x40ab8b8e
// 13.352384
0x4155a35e
// 10.378240
0x41260d46
// 2.289473
0x401286bb
// 29.359213
0x41eadfab
// 4.597539
0x40931f0a
// 3.974980
0x407e6614
// 3.964185
0x407db536
// 10.086740
0x4121634a
// 21.905825
0x41af3f21
// 13.690601
0x415b0cb3
// 4.005201
0x40802a9b
// 7.403674
0x40eceae6
// 2.761065
0x4030b549
// 13.284111
0x41548bb8
// 5.122628
0x40a3ec92

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

@ -0,0 +1,18 @@
H
8
// 1.000000
0x3c00
// 0.084269
0x2d65
// 0.122910
0x2fde
// -0.104210
0xaeab
// -0.173688
0xb18f
// -0.180963
0xb1ca
// -0.031055
0xa7f3
// -0.028420
0xa747

@ -0,0 +1,36 @@
H
17
// 1.000000
0x3c00
// -0.067679
0xac55
// -0.061840
0xabea
// -0.221057
0xb313
// -0.221339
0xb315
// 0.241258
0x33b8
// -0.035354
0xa886
// 0.245027
0x33d7
// -0.202251
0xb279
// 0.067432
0x2c51
// -0.021831
0xa597
// -0.095021
0xae15
// 0.159722
0x311c
// -0.109238
0xaefe
// -0.102164
0xae8a
// -0.054454
0xaaf8
// -0.001745
0x9725

@ -0,0 +1,50 @@
H
24
// 1.000000
0x3c00
// 0.169799
0x316f
// 0.132187
0x303b
// 0.040562
0x2931
// 0.103776
0x2ea4
// 0.081020
0x2d2f
// 0.196579
0x324a
// 0.069136
0x2c6d
// -0.019050
0xa4e0
// 0.280195
0x347c
// 0.054010
0x2aea
// 0.098889
0x2e54
// 0.038659
0x28f3
// -0.012279
0xa249
// -0.046439
0xa9f2
// -0.071067
0xac8c
// -0.109370
0xaf00
// -0.119334
0xafa3
// 0.183069
0x31dc
// 0.068908
0x2c69
// 0.044674
0x29b8
// -0.054628
0xaafe
// 0.024462
0x2643
// -0.036323
0xa8a6

@ -0,0 +1,8 @@
H
3
// 0.916287
0x3b55
// 0.656471
0x3940
// 0.747773
0x39fb

@ -0,0 +1,16 @@
H
7
// 0.047237
0x2a0c
// 0.134360
0x304d
// -0.091821
0xade0
// -0.171842
0xb180
// -0.132384
0xb03c
// 0.025423
0x2682
// -0.022365
0xa5ba

@ -0,0 +1,34 @@
H
16
// 0.043576
0x2994
// -0.210346
0xb2bb
// -0.150672
0xb0d2
// -0.292342
0xb4ad
// 0.268498
0x344c
// -0.173765
0xb18f
// 0.293842
0x34b4
// -0.246877
0xb3e6
// 0.315742
0x350d
// -0.167505
0xb15c
// 0.004615
0x1cba
// -0.064459
0xac20
// 0.024428
0x2641
// -0.337624
0xb567
// 0.067784
0x2c57
// -0.148212
0xb0be

@ -0,0 +1,48 @@
H
23
// 0.143559
0x3098
// 0.082917
0x2d4f
// -0.039893
0xa91b
// 0.099564
0x2e5f
// 0.016650
0x2443
// 0.234491
0x3381
// 0.015372
0x23df
// -0.106077
0xaeca
// 0.290971
0x34a8
// -0.051719
0xaa9f
// 0.056740
0x2b43
// -0.005241
0x9d5e
// -0.123025
0xafe0
// 0.006735
0x1ee5
// -0.160815
0xb125
// -0.128852
0xb020
// -0.078808
0xad0b
// 0.142607
0x3090
// 0.103144
0x2e9a
// -0.008509
0xa05b
// -0.022917
0xa5de
// 0.104124
0x2eaa
// -0.020573
0xa544

@ -0,0 +1,10 @@
W
4
// 1.000000
0x3f800000
// -0.010884
0xbc325142
// 0.096305
0x3dc53bc3
// -0.008937
0xbc126c9c

@ -0,0 +1,20 @@
W
9
// 1.000000
0x3f800000
// -0.318817
0xbea33bfb
// -0.437391
0xbedff1ae
// 0.357260
0x3eb6eac1
// 0.138060
0x3e0d5fad
// -0.082711
0xbda96491
// -0.064698
0xbd84808a
// 0.068744
0x3d8cc977
// 0.009212
0x3c16ec8b

@ -0,0 +1,26 @@
W
12
// 1.000000
0x3f800000
// 0.386401
0x3ec5d65b
// 0.216204
0x3e5d64b1
// 0.173751
0x3e31ebce
// -0.075858
0xbd9b5b79
// -0.067150
0xbd8985e8
// -0.425022
0xbed99c7d
// -0.252156
0xbe811a8d
// -0.107421
0xbddbffbc
// -0.165004
0xbe28f6ce
// -0.043703
0xbd330242
// -0.040663
0xbd268e1f

@ -0,0 +1,8 @@
W
3
// 0.990580
0x3f7d96a4
// 0.429362
0x3edbd552
// 0.601255
0x3f19ebd2

@ -0,0 +1,8 @@
W
3
// -0.009162
0xbc161e18
// 0.096129
0x3dc4df7d
// -0.007008
0xbbe5a6b2

@ -0,0 +1,18 @@
W
8
// -0.744180
0xbf3e829c
// -0.788571
0xbf49dfd2
// 0.009003
0x3c138245
// 0.383815
0x3ec4836c
// 0.682720
0x3f2ec6c4
// 0.438035
0x3ee04620
// 0.250370
0x3e80308b
// -0.015389
0xbc7c2075

@ -0,0 +1,24 @@
W
11
// 0.445124
0x3ee3e73b
// -0.074864
0xbd995240
// 0.295995
0x3e978cb7
// -0.295007
0xbe970b27
// 0.227024
0x3e68791b
// -0.569417
0xbf11c549
// 0.194917
0x3e479844
// -0.037702
0xbd1a6d8c
// 0.103722
0x3dd46c45
// -0.135716
0xbe0af921
// 0.033453
0x3d0905b8

@ -0,0 +1,18 @@
H
8
// 1.000000
0x7FFF
// -0.154665
0xEC34
// -0.259579
0xDEC6
// -0.047624
0xF9E7
// -0.300325
0xD98F
// 0.278120
0x2399
// 0.137547
0x119B
// -0.062621
0xF7FC

@ -0,0 +1,36 @@
H
17
// 1.000000
0x7FFF
// 0.164669
0x1514
// 0.007967
0x0105
// 0.235642
0x1E2A
// -0.158333
0xEBBC
// 0.016525
0x021D
// -0.084518
0xF52E
// -0.147111
0xED2B
// 0.266185
0x2212
// 0.168624
0x1595
// -0.008391
0xFEED
// 0.187352
0x17FB
// 0.058708
0x0784
// 0.051920
0x06A5
// 0.063627
0x0825
// -0.033680
0xFBB0
// 0.017964
0x024D

@ -0,0 +1,50 @@
H
24
// 1.000000
0x7FFF
// -0.042499
0xFA8F
// -0.039920
0xFAE4
// 0.077983
0x09FB
// -0.054238
0xF90F
// -0.130065
0xEF5A
// 0.170944
0x15E1
// 0.069938
0x08F4
// 0.080148
0x0A42
// 0.008983
0x0126
// 0.009068
0x0129
// -0.092787
0xF420
// -0.080738
0xF5AA
// 0.204741
0x1A35
// 0.023210
0x02F9
// 0.159038
0x145B
// -0.012244
0xFE6F
// -0.110975
0xF1CC
// 0.072869
0x0954
// 0.084277
0x0ACA
// -0.141179
0xEDEE
// 0.102607
0x0D22
// 0.038688
0x04F4
// -0.063916
0xF7D2

@ -0,0 +1,8 @@
H
3
// 0.662809
0x54D7
// 0.675606
0x567A
// 0.801815
0x66A2

@ -0,0 +1,16 @@
H
7
// -0.316500
0xD77D
// -0.511452
0xBE89
// -0.297813
0xD9E1
// -0.517063
0xBDD1
// -0.012510
0xFE66
// -0.079361
0xF5D8
// -0.006429
0xFF2D

@ -0,0 +1,34 @@
H
16
// 0.315092
0x2855
// -0.182225
0xE8AD
// 0.418184
0x3587
// -0.376447
0xCFD1
// 0.249313
0x1FE9
// -0.393377
0xCDA6
// 0.159169
0x1460
// 0.075497
0x09AA
// 0.323378
0x2964
// -0.247556
0xE050
// 0.201452
0x19C9
// -0.161519
0xEB53
// 0.200824
0x19B5
// -0.082502
0xF571
// 0.174305
0x1650
// -0.134008
0xEED9

@ -0,0 +1,48 @@
H
23
// -0.022022
0xFD2E
// -0.000207
0xFFF9
// 0.093661
0x0BFD
// -0.032431
0xFBD9
// -0.164869
0xEAE6
// 0.147975
0x12F1
// 0.053129
0x06CD
// 0.141177
0x1212
// -0.020146
0xFD6C
// 0.003053
0x0064
// -0.066565
0xF77B
// -0.121699
0xF06C
// 0.232749
0x1DCB
// 0.053489
0x06D9
// 0.155337
0x13E2
// -0.094058
0xF3F6
// -0.083841
0xF545
// 0.144245
0x1277
// 0.076570
0x09CD
// -0.092832
0xF41E
// -0.045493
0xFA2D
// -0.010378
0xFEAC
// -0.023512
0xFCFE

@ -0,0 +1,10 @@
W
4
// 1.000000
0x7FFFFFFF
// -0.193651
0xE736755B
// -0.312591
0xD7FD03C4
// 0.010891
0x0164DFB7

@ -0,0 +1,20 @@
W
9
// 1.000000
0x7FFFFFFF
// -0.312959
0xD7F0F394
// 0.208655
0x1AB5324C
// 0.171221
0x15EA91DE
// -0.268596
0xDD9EA99C
// 0.410268
0x3483A634
// -0.124219
0xF0199596
// 0.022287
0x02DA4E61
// -0.001000
0xFFDF3984

@ -0,0 +1,26 @@
W
12
// 1.000000
0x7FFFFFFF
// 0.300708
0x267D9923
// 0.192333
0x189E5CE5
// 0.437222
0x37F6E1A7
// -0.041425
0xFAB2984D
// 0.174676
0x165BC654
// 0.372392
0x2FAA8AAD
// 0.127017
0x10421578
// 0.237575
0x1E68DBAD
// 0.176821
0x16A20F75
// -0.054374
0xF90A49B9
// -0.046781
0xFA031238

@ -0,0 +1,8 @@
W
3
// 0.810983
0x67CE4AAB
// 0.683134
0x5770EC70
// 0.555542
0x471BFC5B

@ -0,0 +1,8 @@
W
3
// -0.325974
0xD6467AB7
// -0.408665
0xCBB0E0A6
// -0.170144
0xEA38BA29

@ -0,0 +1,18 @@
W
8
// -0.234971
0xE1EC76AF
// 0.243049
0x1F1C386C
// 0.208509
0x1AB06D8F
// -0.189689
0xE7B844BB
// 0.309209
0x27942C10
// 0.151322
0x135E85C1
// -0.103858
0xF2B4C845
// -0.219087
0xE3F4F726

@ -0,0 +1,24 @@
W
11
// 0.377404
0x304EC702
// -0.101221
0xF30B2CEF
// 0.510756
0x416077F1
// -0.469597
0xC3E43AF8
// 0.294308
0x25ABE048
// 0.055170
0x070FD164
// 0.174906
0x16634DB7
// 0.014438
0x01D91B16
// -0.006841
0xFF1FD36A
// -0.062808
0xF7F5EAFB
// -0.168158
0xEA79CBB8

@ -0,0 +1,34 @@
B
16
// 1.000000
0x7F
// -0.298566
0xDA
// -0.156446
0xEC
// 0.004797
0x01
// -0.021298
0xFD
// 0.379068
0x31
// -0.286485
0xDB
// -0.068159
0xF7
// 0.083920
0x0B
// 0.056118
0x07
// 0.044344
0x06
// -0.096364
0xF4
// -0.108972
0xF2
// 0.044991
0x06
// 0.027953
0x04
// 0.001166
0x00

@ -0,0 +1,68 @@
B
33
// 1.000000
0x7F
// -0.018014
0xFE
// 0.241464
0x1F
// -0.047878
0xFA
// 0.051743
0x07
// 0.011405
0x01
// -0.213039
0xE5
// 0.261741
0x22
// -0.020973
0xFD
// 0.187691
0x18
// 0.032847
0x04
// 0.225001
0x1D
// 0.014761
0x02
// 0.174604
0x16
// -0.026021
0xFD
// 0.204819
0x1A
// 0.066105
0x08
// 0.042037
0x05
// 0.027969
0x04
// -0.096768
0xF4
// 0.058540
0x07
// -0.205054
0xE6
// 0.197638
0x19
// 0.035008
0x04
// 0.176720
0x17
// 0.089992
0x0C
// 0.102071
0x0D
// 0.114371
0x0F
// -0.119828
0xF1
// -0.007614
0xFF
// -0.054266
0xF9
// 0.047273
0x06
// -0.008312
0xFF

@ -0,0 +1,98 @@
B
48
// 1.000000
0x7F
// -0.148362
0xED
// -0.235879
0xE2
// -0.056167
0xF9
// 0.002933
0x00
// -0.004322
0xFF
// 0.000080
0x00
// 0.304016
0x27
// -0.183449
0xE9
// -0.101231
0xF3
// 0.015357
0x02
// -0.019344
0xFE
// -0.054982
0xF9
// 0.119577
0x0F
// 0.113052
0x0E
// -0.028713
0xFC
// -0.122360
0xF0
// -0.031116
0xFC
// 0.145762
0x13
// -0.193327
0xE7
// 0.155058
0x14
// 0.139182
0x12
// -0.067666
0xF7
// -0.201940
0xE6
// 0.041790
0x05
// 0.179673
0x17
// -0.131950
0xEF
// 0.104085
0x0D
// 0.048692
0x06
// -0.053206
0xF9
// -0.064882
0xF8
// 0.126866
0x10
// -0.024864
0xFD
// -0.028241
0xFC
// 0.066674
0x09
// 0.008763
0x01
// -0.064378
0xF8
// -0.048487
0xFA
// 0.118464
0x0F
// -0.001812
0x00
// -0.091927
0xF4
// 0.049613
0x06
// 0.046273
0x06
// -0.030074
0xFC
// -0.059684
0xF8
// 0.061619
0x08
// 0.014547
0x02
// -0.018425
0xFE

@ -0,0 +1,8 @@
B
3
// 0.655764
0x54
// 0.604798
0x4D
// 0.630697
0x51

@ -0,0 +1,32 @@
B
15
// -0.391171
0xCE
// -0.306347
0xD9
// -0.076860
0xF6
// -0.019203
0xFE
// 0.355907
0x2E
// -0.093075
0xF4
// 0.011081
0x01
// 0.027254
0x03
// 0.091961
0x0C
// -0.061385
0xF8
// -0.013224
0xFE
// -0.215519
0xE4
// -0.166579
0xEB
// -0.119101
0xF1
// -0.005227
0xFF

@ -0,0 +1,66 @@
B
32
// 0.103783
0x0D
// 0.158025
0x14
// -0.131433
0xEF
// 0.085947
0x0B
// 0.063721
0x08
// -0.397395
0xCD
// 0.424610
0x36
// -0.029567
0xFC
// -0.046004
0xFA
// 0.221800
0x1C
// 0.133603
0x11
// -0.189210
0xE8
// 0.390523
0x32
// -0.212792
0xE5
// 0.083189
0x0B
// 0.193463
0x19
// -0.030987
0xFC
// -0.155454
0xEC
// 0.159022
0x14
// -0.266461
0xDE
// -0.056885
0xF9
// 0.157094
0x14
// -0.045825
0xFA
// -0.017249
0xFE
// 0.165507
0x15
// -0.113469
0xF1
// 0.085427
0x0B
// -0.034557
0xFC
// -0.108958
0xF2
// 0.041399
0x05
// 0.081506
0x0A
// -0.057431
0xF9

@ -0,0 +1,96 @@
B
47
// -0.165310
0xEB
// -0.314187
0xD8
// -0.177025
0xE9
// -0.101686
0xF3
// 0.022292
0x03
// -0.058707
0xF8
// 0.257582
0x21
// -0.197482
0xE7
// -0.025300
0xFD
// -0.041725
0xFB
// -0.132141
0xEF
// -0.026362
0xFD
// 0.085996
0x0B
// 0.014449
0x02
// 0.120857
0x0F
// -0.011848
0xFE
// -0.062113
0xF8
// 0.139745
0x12
// -0.164331
0xEB
// 0.108165
0x0E
// 0.100639
0x0D
// 0.034127
0x04
// -0.074945
0xF6
// 0.063403
0x08
// 0.080518
0x0A
// 0.017488
0x02
// 0.067366
0x09
// 0.069433
0x09
// 0.127530
0x10
// 0.077447
0x0A
// 0.139264
0x12
// -0.031988
0xFC
// 0.120276
0x0F
// -0.028649
0xFC
// 0.032945
0x04
// -0.018304
0xFE
// 0.070435
0x09
// -0.006031
0xFF
// 0.097056
0x0C
// -0.106452
0xF2
// 0.075513
0x0A
// -0.034634
0xFC
// 0.004772
0x01
// 0.001304
0x00
// -0.012288
0xFE
// -0.019603
0xFD
// 0.069824
0x09

@ -4,6 +4,7 @@
#include "Test.h"
#define SNR_THRESHOLD 70
/*
@ -13,6 +14,29 @@ a double precision computation.
*/
#define ABS_ERROR ((q15_t)10)
void FastMathQ15::test_division_q15()
{
const q15_t *nump = numerator.ptr();
const q15_t *denp = denominator.ptr();
q15_t *outp = output.ptr();
int16_t *shiftp = shift.ptr();
arm_status status;
for(unsigned long i=0; i < ref.nbSamples(); i++)
{
status = arm_divide_q15(nump[i],denp[i],&outp[i],&shiftp[i]);
}
ASSERT_SNR(ref,output,(float32_t)SNR_THRESHOLD);
ASSERT_NEAR_EQ(ref,output,ABS_ERROR);
ASSERT_EQ(refShift,shift);
}
void FastMathQ15::test_cos_q15()
{
const q15_t *inp = input.ptr();
@ -95,6 +119,20 @@ a double precision computation.
}
break;
case FastMathQ15::TEST_DIVISION_Q15_4:
{
numerator.reload(FastMathQ15::NUMERATOR_Q15_ID,mgr);
denominator.reload(FastMathQ15::DENOMINATOR_Q15_ID,mgr);
ref.reload(FastMathQ15::DIVISION_VALUE_Q15_ID,mgr);
refShift.reload(FastMathQ15::DIVISION_SHIFT_S16_ID,mgr);
output.create(ref.nbSamples(),FastMathQ15::OUT_Q15_ID,mgr);
shift.create(ref.nbSamples(),FastMathQ15::SHIFT_S16_ID,mgr);
}
break;
}
}

@ -13,6 +13,8 @@ a double precision computation.
*/
#define ABS_ERROR ((q31_t)2200)
void FastMathQ31::test_cos_q31()
{
const q31_t *inp = input.ptr();

@ -13,6 +13,35 @@ a double precision computation.
#define REL_ERROR (1.0e-4)
#define ABS_ERROR (1.0e-3)
/*
For tests of the error value of the Levinson Durbin algorithm
*/
#define SNR_LD_THRESHOLD 59
#define REL_LD_ERROR (1.0e-3)
#define ABS_LD_ERROR (1.0e-3)
void MISCF16::test_levinson_durbin_f16()
{
const float16_t *inpA=inputA.ptr();
const float16_t *errs=inputB.ptr();
float16_t *outp=output.ptr();
float16_t err;
float16_t refError=errs[this->errOffset];
arm_levinson_durbin_f16(inpA,outp,&err,this->nba);
ASSERT_EMPTY_TAIL(output);
ASSERT_SNR(ref,output,(float16_t)SNR_LD_THRESHOLD);
ASSERT_CLOSE_ERROR(ref,output,ABS_LD_ERROR,REL_LD_ERROR);
ASSERT_CLOSE_ERROR(refError,err,ABS_LD_ERROR,REL_LD_ERROR);
}
void MISCF16::test_correlate_f16()
{
const float16_t *inpA=inputA.ptr();
@ -694,10 +723,46 @@ a double precision computation.
break;
#endif
case MISCF16::TEST_LEVINSON_DURBIN_F16_41:
{
this->nba = 7;
inputA.reload(MISCF16::INPUTPHI_A_F16_ID,mgr);
this->errOffset=0;
inputB.reload(MISCF16::INPUT_ERRORS_F16_ID,mgr);
ref.reload(MISCF16::REF81_F16_ID,mgr);
}
break;
case MISCF16::TEST_LEVINSON_DURBIN_F16_42:
{
this->nba = 16;
inputA.reload(MISCF16::INPUTPHI_B_F16_ID,mgr);
this->errOffset=1;
inputB.reload(MISCF16::INPUT_ERRORS_F16_ID,mgr);
ref.reload(MISCF16::REF82_F16_ID,mgr);
}
break;
case MISCF16::TEST_LEVINSON_DURBIN_F16_43:
{
this->nba = 23;
inputA.reload(MISCF16::INPUTPHI_C_F16_ID,mgr);
this->errOffset=2;
inputB.reload(MISCF16::INPUT_ERRORS_F16_ID,mgr);
ref.reload(MISCF16::REF83_F16_ID,mgr);
}
break;
}
inputA.reload(MISCF16::INPUTA_F16_ID,mgr,nba);
inputB.reload(MISCF16::INPUTB_F16_ID,mgr,nbb);
if (id < TEST_LEVINSON_DURBIN_F16_41)
{
inputA.reload(MISCF16::INPUTA_F16_ID,mgr,nba);
inputB.reload(MISCF16::INPUTB_F16_ID,mgr,nbb);
}
output.create(ref.nbSamples(),MISCF16::OUT_F16_ID,mgr);

@ -15,6 +15,34 @@ a double precision computation.
#define REL_ERROR (1.0e-6)
#define ABS_ERROR (1.0e-5)
/*
For tests of the error value of the Levinson Durbin algorithm
*/
#define REL_LD_ERROR (1.0e-6)
#define ABS_LD_ERROR (1.0e-6)
void MISCF32::test_levinson_durbin_f32()
{
const float32_t *inpA=inputA.ptr();
const float32_t *errs=inputB.ptr();
float32_t *outp=output.ptr();
float32_t err;
float32_t refError=errs[this->errOffset];
arm_levinson_durbin_f32(inpA,outp,&err,this->nba);
ASSERT_EMPTY_TAIL(output);
ASSERT_SNR(ref,output,(float32_t)SNR_THRESHOLD);
ASSERT_CLOSE_ERROR(ref,output,ABS_LD_ERROR,REL_LD_ERROR);
ASSERT_CLOSE_ERROR(refError,err,ABS_LD_ERROR,REL_LD_ERROR);
}
void MISCF32::test_correlate_f32()
{
const float32_t *inpA=inputA.ptr();
@ -693,11 +721,47 @@ a double precision computation.
}
break;
case MISCF32::TEST_LEVINSON_DURBIN_F32_81:
{
this->nba = 3;
inputA.reload(MISCF32::INPUTPHI_A_F32_ID,mgr);
this->errOffset=0;
inputB.reload(MISCF32::INPUT_ERRORS_F32_ID,mgr);
ref.reload(MISCF32::REF81_F32_ID,mgr);
}
break;
case MISCF32::TEST_LEVINSON_DURBIN_F32_82:
{
this->nba = 8;
inputA.reload(MISCF32::INPUTPHI_B_F32_ID,mgr);
this->errOffset=1;
inputB.reload(MISCF32::INPUT_ERRORS_F32_ID,mgr);
ref.reload(MISCF32::REF82_F32_ID,mgr);
}
break;
case MISCF32::TEST_LEVINSON_DURBIN_F32_83:
{
this->nba = 11;
inputA.reload(MISCF32::INPUTPHI_C_F32_ID,mgr);
this->errOffset=2;
inputB.reload(MISCF32::INPUT_ERRORS_F32_ID,mgr);
ref.reload(MISCF32::REF83_F32_ID,mgr);
}
break;
}
inputA.reload(MISCF32::INPUTA_F32_ID,mgr,nba);
inputB.reload(MISCF32::INPUTB_F32_ID,mgr,nbb);
if (id < TEST_LEVINSON_DURBIN_F32_81)
{
inputA.reload(MISCF32::INPUTA_F32_ID,mgr,nba);
inputB.reload(MISCF32::INPUTB_F32_ID,mgr,nbb);
}
output.create(ref.nbSamples(),MISCF32::OUT_F32_ID,mgr);

@ -14,6 +14,34 @@ a double precision computation.
*/
#define ABS_ERROR_Q31 ((q31_t)2)
/*
For tests of the error value of the Levinson Durbin algorithm
*/
#define ABS_LD_ERROR ((q31_t)30)
void MISCQ31::test_levinson_durbin_q31()
{
const q31_t *inpA=inputA.ptr();
const q31_t *errs=inputB.ptr();
q31_t *outp=output.ptr();
q31_t err;
q31_t refError=errs[this->errOffset];
arm_levinson_durbin_q31(inpA,outp,&err,this->nba);
ASSERT_EMPTY_TAIL(output);
ASSERT_SNR(ref,output,(q31_t)SNR_THRESHOLD);
ASSERT_NEAR_EQ(ref,output,ABS_LD_ERROR);
ASSERT_NEAR_EQ(refError,err,ABS_LD_ERROR);
}
void MISCQ31::test_correlate_q31()
{
const q31_t *inpA=inputA.ptr();
@ -693,10 +721,46 @@ a double precision computation.
}
break;
case MISCQ31::TEST_LEVINSON_DURBIN_Q31_81:
{
this->nba = 3;
inputA.reload(MISCQ31::INPUTPHI_A_Q31_ID,mgr);
this->errOffset=0;
inputB.reload(MISCQ31::INPUT_ERRORS_Q31_ID,mgr);
ref.reload(MISCQ31::REF81_Q31_ID,mgr);
}
break;
case MISCQ31::TEST_LEVINSON_DURBIN_Q31_82:
{
this->nba = 8;
inputA.reload(MISCQ31::INPUTPHI_B_Q31_ID,mgr);
this->errOffset=1;
inputB.reload(MISCQ31::INPUT_ERRORS_Q31_ID,mgr);
ref.reload(MISCQ31::REF82_Q31_ID,mgr);
}
break;
case MISCQ31::TEST_LEVINSON_DURBIN_Q31_83:
{
this->nba = 11;
inputA.reload(MISCQ31::INPUTPHI_C_Q31_ID,mgr);
this->errOffset=2;
inputB.reload(MISCQ31::INPUT_ERRORS_Q31_ID,mgr);
ref.reload(MISCQ31::REF83_Q31_ID,mgr);
}
break;
}
inputA.reload(MISCQ31::INPUTA_Q31_ID,mgr,nba);
inputB.reload(MISCQ31::INPUTB_Q31_ID,mgr,nbb);
if (id < TEST_LEVINSON_DURBIN_Q31_81)
{
inputA.reload(MISCQ31::INPUTA_Q31_ID,mgr,nba);
inputB.reload(MISCQ31::INPUTB_Q31_ID,mgr,nbb);
}
output.create(ref.nbSamples(),MISCQ31::OUT_Q31_ID,mgr);

@ -1329,6 +1329,7 @@ group Root {
Pattern COS1_Q31_ID : Cos1_q31.txt
Pattern SIN1_Q31_ID : Sin1_q31.txt
Pattern SQRT1_Q31_ID : Sqrt1_q31.txt
Output OUT_Q31_ID : Output
@ -1349,12 +1350,20 @@ group Root {
Pattern SIN1_Q15_ID : Sin1_q15.txt
Pattern SQRT1_Q15_ID : Sqrt1_q15.txt
Pattern NUMERATOR_Q15_ID : Numerator1_q15.txt
Pattern DENOMINATOR_Q15_ID : Denominator1_q15.txt
Pattern DIVISION_VALUE_Q15_ID : DivisionValue1_q15.txt
Pattern DIVISION_SHIFT_S16_ID : DivisionShift1_s16.txt
Output OUT_Q15_ID : Output
Output SHIFT_S16_ID : Output
Functions {
test_cos_q15:test_cos_q15
test_sin_q15:test_sin_q15
test_sqrt_q15:test_sqrt_q15
test_division_q15:test_division_q15
}
}
}
@ -1598,6 +1607,12 @@ group Root {
Pattern INPUTA_F32_ID : InputsA1_f32.txt
Pattern INPUTB_F32_ID : InputsB1_f32.txt
Pattern INPUTPHI_A_F32_ID : InputPhi81_f32.txt
Pattern INPUTPHI_B_F32_ID : InputPhi82_f32.txt
Pattern INPUTPHI_C_F32_ID : InputPhi83_f32.txt
Pattern INPUT_ERRORS_F32_ID : LDErrors81_f32.txt
Pattern REF1_F32_ID : Reference1_f32.txt
Pattern REF2_F32_ID : Reference2_f32.txt
Pattern REF3_F32_ID : Reference3_f32.txt
@ -1678,9 +1693,13 @@ group Root {
Pattern REF78_F32_ID : Reference78_f32.txt
Pattern REF79_F32_ID : Reference79_f32.txt
Pattern REF80_F32_ID : Reference80_f32.txt
Pattern REF81_F32_ID : Reference81_f32.txt
Pattern REF82_F32_ID : Reference82_f32.txt
Pattern REF83_F32_ID : Reference83_f32.txt
Output OUT_F32_ID : Output
Output TMP_F32_ID : Temp
Functions {
arm_correlate_f32 nba=4 nbb=1:test_correlate_f32
@ -1763,6 +1782,9 @@ group Root {
arm_conv_f32 nba=13 nbb=3:test_conv_f32
arm_conv_f32 nba=13 nbb=8:test_conv_f32
arm_conv_f32 nba=13 nbb=11:test_conv_f32
arm_levinson_durbin_f32 n=3:test_levinson_durbin_f32
arm_levinson_durbin_f32 n=8:test_levinson_durbin_f32
arm_levinson_durbin_f32 n=11:test_levinson_durbin_f32
}
}
@ -1774,6 +1796,12 @@ group Root {
Pattern INPUTA_Q31_ID : InputsA1_q31.txt
Pattern INPUTB_Q31_ID : InputsB1_q31.txt
Pattern INPUTPHI_A_Q31_ID : InputPhi81_q31.txt
Pattern INPUTPHI_B_Q31_ID : InputPhi82_q31.txt
Pattern INPUTPHI_C_Q31_ID : InputPhi83_q31.txt
Pattern INPUT_ERRORS_Q31_ID : LDErrors81_q31.txt
Pattern REF1_Q31_ID : Reference1_q31.txt
Pattern REF2_Q31_ID : Reference2_q31.txt
Pattern REF3_Q31_ID : Reference3_q31.txt
@ -1854,6 +1882,9 @@ group Root {
Pattern REF78_Q31_ID : Reference78_q31.txt
Pattern REF79_Q31_ID : Reference79_q31.txt
Pattern REF80_Q31_ID : Reference80_q31.txt
Pattern REF81_Q31_ID : Reference81_q31.txt
Pattern REF82_Q31_ID : Reference82_q31.txt
Pattern REF83_Q31_ID : Reference83_q31.txt
Output OUT_Q31_ID : Output
@ -1939,6 +1970,9 @@ group Root {
arm_conv_q31 nba=13 nbb=3:test_conv_q31
arm_conv_q31 nba=13 nbb=8:test_conv_q31
arm_conv_q31 nba=13 nbb=11:test_conv_q31
arm_levinson_durbin_q31 n=3:test_levinson_durbin_q31
arm_levinson_durbin_q31 n=8:test_levinson_durbin_q31
arm_levinson_durbin_q31 n=11:test_levinson_durbin_q31
}
}

@ -519,6 +519,12 @@ group Root {
Pattern INPUTA_F16_ID : InputsA1_f16.txt
Pattern INPUTB_F16_ID : InputsB1_f16.txt
Pattern INPUTPHI_A_F16_ID : InputPhi81_f16.txt
Pattern INPUTPHI_B_F16_ID : InputPhi82_f16.txt
Pattern INPUTPHI_C_F16_ID : InputPhi83_f16.txt
Pattern INPUT_ERRORS_F16_ID : LDErrors81_f16.txt
Pattern REF1_F16_ID : Reference1_f16.txt
Pattern REF2_F16_ID : Reference2_f16.txt
Pattern REF3_F16_ID : Reference3_f16.txt
@ -599,9 +605,13 @@ group Root {
Pattern REF78_F16_ID : Reference78_f16.txt
Pattern REF79_F16_ID : Reference79_f16.txt
Pattern REF80_F16_ID : Reference80_f16.txt
Pattern REF81_F16_ID : Reference81_f16.txt
Pattern REF82_F16_ID : Reference82_f16.txt
Pattern REF83_F16_ID : Reference83_f16.txt
Output OUT_F16_ID : Output
Output TMP_F16_ID : Temp
Functions {
arm_correlate_f16 nba=4 nbb=1:test_correlate_f16
@ -644,6 +654,9 @@ group Root {
arm_correlate_f16 nba=13 nbb=3:test_correlate_f16
arm_correlate_f16 nba=13 nbb=8:test_correlate_f16
arm_correlate_f16 nba=13 nbb=11:test_correlate_f16
arm_levinson_durbin_f16 n=7:test_levinson_durbin_f16
arm_levinson_durbin_f16 n=16:test_levinson_durbin_f16
arm_levinson_durbin_f16 n=23:test_levinson_durbin_f16
}
}

Loading…
Cancel
Save