test: ztest: Port exponential math tests from CMock

Port exponential function tests from CMock/CMocka to Zephyr Ztest
framework. Migrates tests from
test/cmocka/src/math/arithmetic/exponential.c to
test/ztest/unit/math/advanced/functions/test_exponential_ztest.c.

Test coverage includes:
- sofm_exp_approx(): ULP-based validation of Q28 -> Q19 approximation
  (256 samples, range -8 to 8)
- sofm_exp_fixed(): Fixed-point exponential Q27 -> Q20
  - Full range: -16 to 16 (100 samples, coarse grid)
  - Middle range: -11.5 to 7.6245 (100 samples, fine grid)
- sofm_db2lin_fixed(): dB to linear conversion Q24 -> Q20
  (100 samples, range -128 to 128 dB)

Changes:
- Add test_exponential_ztest.c with 3 test functions (291 lines)
- Update CMakeLists.txt to build exp_fcn.c and exp_fcn_hifi.c
- Add comment noting exp_fcn_hifi.c is Xtensa HiFi-specific
- Update testcase.yaml tags: exponential, exp, db2lin
- Use Zephyr LOG_INF for diagnostic output instead of printf

All tests validate against reference implementations using absolute and
relative error tolerances appropriate for fixed-point arithmetic.

Signed-off-by: Tomasz Leman <tomasz.m.leman@intel.com>

Author: tmleman

test/ztest/unit/math/advanced/functions/CMakeLists.txt

@@ -30,8 +30,13 @@ target_compile_definitions(app PRIVATE
 target_sources(app PRIVATE
 	test_scalar_power_ztest.c
 	test_base2_logarithm_ztest.c
+	test_exponential_ztest.c
 	${SOF_ROOT}/src/math/power.c
 	${SOF_ROOT}/src/math/base2log.c
+	${SOF_ROOT}/src/math/exp_fcn.c
+	# Note: exp_fcn_hifi.c is conditionally compiled only for Xtensa HiFi platforms.
+	# TODO: Enable these tests on Xtensa platforms to also test HiFi-optimized code paths.
+	${SOF_ROOT}/src/math/exp_fcn_hifi.c
 )
 
 # Apply SOF relative path definitions for proper compilation

test/ztest/unit/math/advanced/functions/test_exponential_ztest.c

@@ -0,0 +1,294 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/*
+ * Copyright(c) 2022-2026 Intel Corporation.
+ *
+ * These contents may have been developed with support from one or more Intel-operated
+ * generative artificial intelligence solutions.
+ *
+ * Converted from CMock to Ztest
+ *
+ * Original test from sof/test/cmocka/src/math/arithmetic/exponential.c
+ *
+ * Author: Shriram Shastry <malladi.sastry@linux.intel.com>
+ *         Seppo Ingalsuo <seppo.ingalsuo@linux.intel.com>
+ */
+
+#include <zephyr/ztest.h>
+#include <zephyr/logging/log.h>
+#include <sof/math/exp_fcn.h>
+#include <sof/audio/format.h>
+#include <sof/common.h>
+#include <math.h>
+#include <rtos/string.h>
+
+LOG_MODULE_REGISTER(test_exponential, LOG_LEVEL_INF);
+
+#define ULP_TOLERANCE		1.0
+#define ULP_SCALE		1.9073e-06 /* For exp() output Q13.19, 1 / 2^19 */
+#define NUMTESTSAMPLES 256
+
+#define NUMTESTSAMPLES_TEST2 100
+#define ABS_DELTA_TOLERANCE_TEST2 2.0e-6
+#define REL_DELTA_TOLERANCE_TEST2 1000.0 /* rel. error is large with values near zero */
+#define NUMTESTSAMPLES_TEST3 100
+#define ABS_DELTA_TOLERANCE_TEST3 2.0e-6
+#define REL_DELTA_TOLERANCE_TEST3 10.0e-2
+#define SOFM_EXP_FIXED_ARG_MIN -11.5
+#define SOFM_EXP_FIXED_ARG_MAX 7.6245
+
+#define NUMTESTSAMPLES_TEST4 100
+#define ABS_DELTA_TOLERANCE_TEST4 2.5e-5
+#define REL_DELTA_TOLERANCE_TEST4 1000.0 /* rel. error is large with values near zero */
+
+/**
+ * Saturates input to 32 bits
+ * @param	x	Input value
+ * @return		Saturated output value
+ */
+static int32_t saturate32(int64_t x)
+{
+	if (x < INT32_MIN)
+		return INT32_MIN;
+	else if (x > INT32_MAX)
+		return INT32_MAX;
+
+	return x;
+}
+
+/**
+ * Generates linearly spaced values for a vector with end points and number points in
+ * desired fractional Q-format for 32 bit integer. If the test values exceed int32_t
+ * range, the values are saturated to INT32_MIN to INT32_MAX range.
+ *
+ * @param a		First value of test vector
+ * @param b		Last value of test vector
+ * @param step_count	Number of values in vector
+ * @param point		Calculate n-th point of vector 0 .. step_count - 1
+ * @param qformat	Number of fractional bits y in Qx.y format
+ * @param fout		Pointer to calculated test vector value, double
+ * @param iout		Pointer to calculated test vector value, int32_t
+ */
+static void gen_testvector_linspace_int32(double a, double b, int step_count, int point,
+					  int qformat, double *fout, int32_t *iout)
+{
+	double fstep = (b - a) / (step_count - 1);
+	double fvalue = a + fstep * point;
+	int64_t itmp;
+
+	itmp = (int64_t)round(fvalue * (double)(1 << qformat));
+	*iout = saturate32(itmp);
+	*fout = (double)*iout / (1 << qformat);
+}
+
+/**
+ * Calculate reference exponent value
+ * @param x		Input value
+ * @param qformat	Fractional bits y in Qx.y format
+ * @return		Saturated exponent value to match fractional format
+ */
+static double ref_exp(double x, int qformat)
+{
+	double yf;
+	int64_t yi;
+
+	yf = exp(x);
+	yi = yf * (1 << qformat);
+
+	if (yi > INT32_MAX)
+		yi = INT32_MAX;
+	else if (yi < INT32_MIN)
+		yi = INT32_MIN;
+
+	yf = (double)yi / (1 << qformat);
+	return yf;
+}
+
+/**
+ * Calculates test exponent function and compares result to reference exponent.
+ * @param ivalue		Fractional format input value Q5.27
+ * @param iexp_value		Fractional format output value Q12.20
+ * @param abs_delta_max		Calculated absolute error
+ * @param rel_delta_max		Calculated relative error
+ * @param abs_delta_tolerance	Tolerance for absolute error
+ * @param rel_delta_tolerance	Tolerance for relative error
+ */
+static void test_exp_with_input_value(int32_t ivalue, int32_t *iexp_value,
+				      double *abs_delta_max, double *rel_delta_max,
+				      double abs_delta_tolerance, double rel_delta_tolerance)
+{
+	double fvalue, fexp_value, ref_exp_value;
+	double rel_delta, abs_delta;
+	double eps = 1e-9;
+
+	*iexp_value = sofm_exp_fixed(ivalue);
+	fvalue = (double)ivalue / (1 << 27); /* Q5.27 */
+	fexp_value = (double)*iexp_value / (1 << 20); /* Q12.20 */
+	ref_exp_value = ref_exp(fvalue, 20);
+	abs_delta = fabs(ref_exp_value - fexp_value);
+	rel_delta = abs_delta / (ref_exp_value + eps);
+
+	if (abs_delta > *abs_delta_max)
+		*abs_delta_max = abs_delta;
+
+	if (rel_delta > *rel_delta_max)
+		*rel_delta_max = rel_delta;
+
+	zassert_true(abs_delta <= abs_delta_tolerance,
+		     "sofm_exp_fixed: Absolute error %g exceeds limit %g, input %g output %g",
+		     abs_delta, abs_delta_tolerance, fvalue, fexp_value);
+
+	zassert_true(rel_delta <= rel_delta_tolerance,
+		     "sofm_exp_fixed: Relative error %g exceeds limit %g, input %g output %g",
+		     rel_delta, rel_delta_tolerance, fvalue, fexp_value);
+}
+
+/**
+ * Reference function for dB to linear conversion
+ * @param x		Input value
+ * @param qformat	Fractional bits y in Qx.y format for saturation
+ * @return		Saturated linear value
+ */
+static double ref_db2lin(double x, int qformat)
+{
+	double fref;
+	int64_t iref;
+
+	fref = pow(10, x / 20);
+	iref = fref * (1 << qformat);
+	return (double)saturate32(iref) / (1 << qformat);
+}
+
+/**
+ * @brief Test sofm_exp_approx() function with ULP error validation
+ *
+ * This test validates the sofm_exp_approx() exponential approximation function
+ * against the C standard library exp() function. It tests 256 linearly spaced
+ * input values and checks that the ULP (Unit in the Last Place) error stays
+ * within acceptable tolerance.
+ *
+ * Input values: Q28 format, range -8 to 8
+ * Result: Q19 format
+ * Validation: ULP error < 1.0 ULP
+ */
+ZTEST(math_advanced_functions_suite, test_function_sofm_exp_approx)
+{
+	int32_t accum;
+	int i;
+	double a_i;
+	double max_ulp = 0;
+	double ulp;
+	double a_tmp = -8;
+	double b_tmp =  8;
+	int32_t b_i;
+
+	for (i = 0; i < NUMTESTSAMPLES; i++) {
+		gen_testvector_linspace_int32(a_tmp, b_tmp, NUMTESTSAMPLES, i, 28, &a_i, &b_i);
+		accum = sofm_exp_approx(b_i);
+		ulp = fabs(exp(a_i) - (double)accum / (1 << 19)) / ULP_SCALE;
+		if (ulp > max_ulp)
+			max_ulp = ulp;
+
+		zassert_true(ulp <= ULP_TOLERANCE,
+			    "sofm_exp_approx: ULP %.16f exceeds tolerance, value=%.16f, exp=%.16f",
+			    ulp, (double)b_i / (1 << 28), (double)accum / (1 << 19));
+	}
+
+	LOG_INF("Worst-case ULP: %g ULP_SCALE %g", max_ulp, ULP_SCALE);
+}
+
+/**
+ * @brief Test sofm_exp_fixed() function with absolute and relative error validation
+ *
+ * This test validates the sofm_exp_fixed() fixed-point exponential function
+ * against a reference implementation. It performs two sub-tests with different
+ * input ranges and tolerance requirements.
+ *
+ * Sub-test 1: Coarse grid across max range
+ * - Input values: Q27 format, range -16 to 16
+ * - Result: Q20 format
+ * - Tolerances: abs 2.0e-6, rel 1000.0
+ *
+ * Sub-test 2: Fine grid across typical range
+ * - Input values: Q27 format, range -11.5 to 7.6245
+ * - Result: Q20 format
+ * - Tolerances: abs 2.0e-6, rel 10.0e-2
+ */
+ZTEST(math_advanced_functions_suite, test_function_sofm_exp_fixed)
+{
+	double rel_delta_max, abs_delta_max;
+	double tmp;
+	int32_t ivalue, iexp_value;
+	int i;
+
+	/* Test max int32_t range with coarse grid */
+	rel_delta_max = 0;
+	abs_delta_max = 0;
+	for (i = 0; i < NUMTESTSAMPLES_TEST2; i++) {
+		gen_testvector_linspace_int32(-16, 16, NUMTESTSAMPLES_TEST2, i, 27, &tmp, &ivalue);
+		test_exp_with_input_value(ivalue, &iexp_value, &abs_delta_max, &rel_delta_max,
+					  ABS_DELTA_TOLERANCE_TEST2, REL_DELTA_TOLERANCE_TEST2);
+	}
+
+	LOG_INF("Absolute max error was %.6e (max range)", abs_delta_max);
+	LOG_INF("Relative max error was %.6e (max range)", rel_delta_max);
+
+	/* Test max int32_t middle range with fine grid */
+	rel_delta_max = 0;
+	abs_delta_max = 0;
+	for (i = 0; i < NUMTESTSAMPLES_TEST3; i++) {
+		gen_testvector_linspace_int32(SOFM_EXP_FIXED_ARG_MIN, SOFM_EXP_FIXED_ARG_MAX,
+					      NUMTESTSAMPLES_TEST3, i, 27, &tmp, &ivalue);
+		test_exp_with_input_value(ivalue, &iexp_value, &abs_delta_max, &rel_delta_max,
+					  ABS_DELTA_TOLERANCE_TEST3, REL_DELTA_TOLERANCE_TEST3);
+	}
+
+	LOG_INF("Absolute max error was %.6e (middle)", abs_delta_max);
+	LOG_INF("Relative max error was %.6e (middle)", rel_delta_max);
+}
+
+/**
+ * @brief Test sofm_db2lin_fixed() function for dB to linear conversion
+ *
+ * This test validates the sofm_db2lin_fixed() function that converts decibel
+ * values to linear scale using fixed-point arithmetic. It compares against
+ * a reference implementation using floating-point pow(10, x/20).
+ *
+ * Input values: Q24 format, range -128 to 128 dB
+ * Result: Q20 format
+ * Tolerances: abs 2.5e-5, rel 1000.0
+ */
+ZTEST(math_advanced_functions_suite, test_function_sofm_db2lin_fixed)
+{
+	double abs_delta, rel_delta, abs_delta_max, rel_delta_max;
+	double fin, fout, fref;
+	double eps = 1e-9;
+	int32_t iin, iout;
+	int i;
+
+	rel_delta_max = 0;
+	abs_delta_max = 0;
+	for (i = 0; i < NUMTESTSAMPLES_TEST4; i++) {
+		gen_testvector_linspace_int32(-128, 128, NUMTESTSAMPLES_TEST4, i, 24, &fin, &iin);
+		iout = sofm_db2lin_fixed(iin);
+		fout = (double)iout / (1 << 20);
+		fref = ref_db2lin(fin, 20);
+		abs_delta = fabs(fref - fout);
+		rel_delta = abs_delta / (fref + eps);
+		if (abs_delta > abs_delta_max)
+			abs_delta_max = abs_delta;
+
+		if (rel_delta > rel_delta_max)
+			rel_delta_max = rel_delta;
+
+		zassert_true(abs_delta <= ABS_DELTA_TOLERANCE_TEST4,
+			     "sofm_db2lin_fixed: Absolute error %g exceeds limit %g, input %g output %g",
+			     abs_delta, ABS_DELTA_TOLERANCE_TEST4, fin, fout);
+
+		zassert_true(rel_delta <= REL_DELTA_TOLERANCE_TEST4,
+			     "sofm_db2lin_fixed: Relative error %g exceeds limit %g, input %g output %g",
+			     rel_delta, REL_DELTA_TOLERANCE_TEST4, fin, fout);
+	}
+
+	LOG_INF("Absolute max error was %.6e", abs_delta_max);
+	LOG_INF("Relative max error was %.6e", rel_delta_max);
+}

test/ztest/unit/math/advanced/functions/testcase.yaml

@@ -10,7 +10,7 @@
 
 tests:
   sof.unit.math.advanced.functions:
-    tags: math advanced functions power logarithm base2
+    tags: math advanced functions power logarithm base2 exponential exp db2lin
     platform_allow: native_sim
     integration_platforms:
       - native_sim