forked from Qortal/Brooklyn
113 lines
2.9 KiB
C++
113 lines
2.9 KiB
C++
//
|
|
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
//
|
|
|
|
#include <catch.hpp>
|
|
#include <limits>
|
|
|
|
#include "MathUtils.hpp"
|
|
#include <iostream>
|
|
#include <numeric>
|
|
|
|
TEST_CASE("Test DotProductF32")
|
|
{
|
|
// Test Constants:
|
|
const int length = 6;
|
|
|
|
float inputA[] = { 1, 1, 1, 0, 0, 0 };
|
|
float inputB[] = { 0, 0, 0, 1, 1, 1 };
|
|
|
|
float dot_prod = MathUtils::DotProductF32(inputA, inputB, length);
|
|
float expectedResult = 0;
|
|
CHECK(dot_prod == expectedResult);
|
|
}
|
|
|
|
TEST_CASE("Test FFT32")
|
|
{
|
|
// Test Constants:
|
|
std::vector<float> input(32, 0);
|
|
std::vector<float> output(32);
|
|
std::vector<float> expectedResult(32, 0);
|
|
|
|
MathUtils::FftF32(input, output);
|
|
|
|
// To avoid common failed assertions due to rounding of near-zero values a small offset is added
|
|
transform(output.begin(), output.end(), output.begin(),
|
|
bind2nd(std::plus<double>(), 0.1));
|
|
|
|
transform(expectedResult.begin(), expectedResult.end(), expectedResult.begin(),
|
|
bind2nd(std::plus<double>(), 0.1));
|
|
|
|
for (int i = 0; i < output.size(); i++)
|
|
{
|
|
CHECK (expectedResult[i] == Approx(output[i]));
|
|
}
|
|
}
|
|
|
|
TEST_CASE("Test ComplexMagnitudeSquaredF32")
|
|
{
|
|
// Test Constants:
|
|
float input[] = { 0.0, 0.0, 0.5, 0.5,1,1 };
|
|
int inputLen = (sizeof(input)/sizeof(*input));
|
|
float expectedResult[] = { 0.0, 0.5, 2 };
|
|
int outputLen = inputLen/2;
|
|
float output[outputLen];
|
|
|
|
MathUtils::ComplexMagnitudeSquaredF32(input, inputLen, output, outputLen);
|
|
|
|
for (int i = 0; i < outputLen; i++)
|
|
{
|
|
CHECK (expectedResult[i] == Approx(output[i]));
|
|
}
|
|
}
|
|
|
|
TEST_CASE("Test VecLogarithmF32")
|
|
{
|
|
// Test Constants:
|
|
|
|
std::vector<float> input = { 1, 0.1e-10 };
|
|
std::vector<float> expectedResult = { 0, -25.328436 };
|
|
std::vector<float> output(input.size());
|
|
MathUtils::VecLogarithmF32(input,output);
|
|
|
|
for (int i = 0; i < input.size(); i++)
|
|
{
|
|
CHECK (expectedResult[i] == Approx(output[i]));
|
|
}
|
|
}
|
|
|
|
TEST_CASE("Test MeanF32")
|
|
{
|
|
// Test Constants:
|
|
float input[] = { 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 1.000 };
|
|
uint32_t inputLen = (sizeof(input)/sizeof(*input));
|
|
float output;
|
|
|
|
// Manually calculated mean of above array
|
|
float expectedResult = 0.100;
|
|
output = MathUtils::MeanF32(input, inputLen);
|
|
|
|
CHECK (expectedResult == Approx(output));
|
|
}
|
|
|
|
TEST_CASE("Test StdDevF32")
|
|
{
|
|
// Test Constants:
|
|
|
|
float input[] = { 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 1.000 };
|
|
|
|
uint32_t inputLen = (sizeof(input)/sizeof(*input));
|
|
|
|
// Calculate mean using std library to avoid dependency on MathUtils::MeanF32
|
|
float mean = (std::accumulate(input, input + inputLen, 0.0f))/float(inputLen);
|
|
|
|
float output = MathUtils::StdDevF32(input, inputLen, mean);
|
|
|
|
// Manually calculated standard deviation of above array
|
|
float expectedResult = 0.300;
|
|
|
|
CHECK (expectedResult == Approx(output));
|
|
}
|
|
|