blob: 04aed7017bdeba2d545a2911c468384b12b76ed1 [file] [log] [blame]
/*
* Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <complex>
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/modules/audio_processing/beamformer/matrix.h"
#include "webrtc/modules/audio_processing/beamformer/matrix_test_helpers.h"
namespace webrtc {
using std::complex;
TEST(MatrixTest, TestMultiplySameSize) {
const int kNumRows = 2;
const int kNumCols = 2;
const float kValuesLeft[kNumRows][kNumCols] = {{1.1f, 2.2f}, {3.3f, 4.4f}};
const float kValuesRight[kNumRows][kNumCols] = {{5.4f, 127.f},
{4600.f, -555.f}};
const float kValuesExpected[kNumRows][kNumCols] = {{10125.94f, -1081.3f},
{20257.82f, -2022.9f}};
Matrix<float> lh_mat(*kValuesLeft, kNumRows, kNumCols);
Matrix<float> rh_mat(*kValuesRight, kNumRows, kNumCols);
Matrix<float> expected_result(*kValuesExpected, kNumRows, kNumCols);
Matrix<float> actual_result(kNumRows, kNumCols);
actual_result.Multiply(lh_mat, rh_mat);
MatrixTestHelpers::ValidateMatrixEquality(expected_result, actual_result);
lh_mat.Multiply(rh_mat);
MatrixTestHelpers::ValidateMatrixEquality(lh_mat, actual_result);
}
TEST(MatrixTest, TestMultiplyDifferentSize) {
const int kNumRowsLeft = 2;
const int kNumColsLeft = 3;
const int kNumRowsRight = 3;
const int kNumColsRight = 2;
const int kValuesLeft[kNumRowsLeft][kNumColsLeft] = {{35, 466, -15},
{-3, 3422, 9}};
const int kValuesRight[kNumRowsRight][kNumColsRight] = {
{765, -42}, {0, 194}, {625, 66321}};
const int kValuesExpected[kNumRowsLeft][kNumColsRight] = {{17400, -905881},
{3330, 1260883}};
Matrix<int> lh_mat(*kValuesLeft, kNumRowsLeft, kNumColsLeft);
Matrix<int> rh_mat(*kValuesRight, kNumRowsRight, kNumColsRight);
Matrix<int> expected_result(*kValuesExpected, kNumRowsLeft, kNumColsRight);
Matrix<int> actual_result(kNumRowsLeft, kNumColsRight);
actual_result.Multiply(lh_mat, rh_mat);
MatrixTestHelpers::ValidateMatrixEquality(expected_result, actual_result);
lh_mat.Multiply(rh_mat);
MatrixTestHelpers::ValidateMatrixEquality(lh_mat, actual_result);
}
TEST(MatrixTest, TestTranspose) {
const int kNumInitialRows = 2;
const int kNumInitialCols = 4;
const int kNumResultRows = 4;
const int kNumResultCols = 2;
const float kValuesInitial[kNumInitialRows][kNumInitialCols] = {
{1.1f, 2.2f, 3.3f, 4.4f}, {5.5f, 6.6f, 7.7f, 8.8f}};
const float kValuesExpected[kNumResultRows][kNumResultCols] = {
{1.1f, 5.5f}, {2.2f, 6.6f}, {3.3f, 7.7f}, {4.4f, 8.8f}};
Matrix<float> initial_mat(*kValuesInitial, kNumInitialRows, kNumInitialCols);
Matrix<float> expected_result(
*kValuesExpected, kNumResultRows, kNumResultCols);
Matrix<float> actual_result(kNumResultRows, kNumResultCols);
actual_result.Transpose(initial_mat);
MatrixTestHelpers::ValidateMatrixEqualityFloat(expected_result,
actual_result);
initial_mat.Transpose();
MatrixTestHelpers::ValidateMatrixEqualityFloat(initial_mat, actual_result);
}
TEST(MatrixTest, TestScale) {
const int kNumRows = 3;
const int kNumCols = 3;
const int kScaleFactor = -9;
const int kValuesInitial[kNumRows][kNumCols] = {
{1, 20, 5000}, {-3, -29, 66}, {7654, 0, -23455}};
const int kValuesExpected[kNumRows][kNumCols] = {
{-9, -180, -45000}, {27, 261, -594}, {-68886, 0, 211095}};
Matrix<int> initial_mat(*kValuesInitial, kNumRows, kNumCols);
Matrix<int> expected_result(*kValuesExpected, kNumRows, kNumCols);
Matrix<int> actual_result;
actual_result.Scale(initial_mat, kScaleFactor);
MatrixTestHelpers::ValidateMatrixEquality(expected_result, actual_result);
initial_mat.Scale(kScaleFactor);
MatrixTestHelpers::ValidateMatrixEquality(initial_mat, actual_result);
}
TEST(MatrixTest, TestPointwiseAdd) {
const int kNumRows = 2;
const int kNumCols = 3;
const float kValuesLeft[kNumRows][kNumCols] = {{1.1f, 210.45f, -549.2f},
{11.876f, 586.7f, -64.35f}};
const float kValuesRight[kNumRows][kNumCols] = {{-50.4f, 1.f, 0.5f},
{460.f, -554.2f, 4566.f}};
const float kValuesExpected[kNumRows][kNumCols] = {
{-49.3f, 211.45f, -548.7f}, {471.876f, 32.5f, 4501.65f}};
Matrix<float> lh_mat(*kValuesLeft, kNumRows, kNumCols);
Matrix<float> rh_mat(*kValuesRight, kNumRows, kNumCols);
Matrix<float> expected_result(*kValuesExpected, kNumRows, kNumCols);
Matrix<float> actual_result;
actual_result.Add(lh_mat, rh_mat);
MatrixTestHelpers::ValidateMatrixEqualityFloat(expected_result,
actual_result);
lh_mat.Add(rh_mat);
MatrixTestHelpers::ValidateMatrixEqualityFloat(lh_mat, actual_result);
}
TEST(MatrixTest, TestPointwiseSubtract) {
const int kNumRows = 3;
const int kNumCols = 2;
const float kValuesLeft[kNumRows][kNumCols] = {
{1.1f, 210.45f}, {-549.2f, 11.876f}, {586.7f, -64.35f}};
const float kValuesRight[kNumRows][kNumCols] = {
{-50.4f, 1.f}, {0.5f, 460.f}, {-554.2f, 4566.f}};
const float kValuesExpected[kNumRows][kNumCols] = {
{51.5f, 209.45f}, {-549.7f, -448.124f}, {1140.9f, -4630.35f}};
Matrix<float> lh_mat(*kValuesLeft, kNumRows, kNumCols);
Matrix<float> rh_mat(*kValuesRight, kNumRows, kNumCols);
Matrix<float> expected_result(*kValuesExpected, kNumRows, kNumCols);
Matrix<float> actual_result;
actual_result.Subtract(lh_mat, rh_mat);
MatrixTestHelpers::ValidateMatrixEqualityFloat(expected_result,
actual_result);
lh_mat.Subtract(rh_mat);
MatrixTestHelpers::ValidateMatrixEqualityFloat(lh_mat, actual_result);
}
TEST(MatrixTest, TestPointwiseMultiply) {
const int kNumRows = 1;
const int kNumCols = 5;
const float kValuesLeft[kNumRows][kNumCols] = {
{1.1f, 6.4f, 0.f, -1.f, -88.3f}};
const float kValuesRight[kNumRows][kNumCols] = {
{53.2f, -210.45f, -549.2f, 99.99f, -45.2f}};
const float kValuesExpected[kNumRows][kNumCols] = {
{58.52f, -1346.88f, 0.f, -99.99f, 3991.16f}};
Matrix<float> lh_mat(*kValuesLeft, kNumRows, kNumCols);
Matrix<float> rh_mat(*kValuesRight, kNumRows, kNumCols);
Matrix<float> expected_result(*kValuesExpected, kNumRows, kNumCols);
Matrix<float> actual_result;
actual_result.PointwiseMultiply(lh_mat, rh_mat);
MatrixTestHelpers::ValidateMatrixEqualityFloat(expected_result,
actual_result);
lh_mat.PointwiseMultiply(rh_mat);
MatrixTestHelpers::ValidateMatrixEqualityFloat(lh_mat, actual_result);
}
TEST(MatrixTest, TestPointwiseDivide) {
const int kNumRows = 5;
const int kNumCols = 1;
const float kValuesLeft[kNumRows][kNumCols] = {
{1.1f}, {6.4f}, {0.f}, {-1.f}, {-88.3f}};
const float kValuesRight[kNumRows][kNumCols] = {
{53.2f}, {-210.45f}, {-549.2f}, {99.99f}, {-45.2f}};
const float kValuesExpected[kNumRows][kNumCols] = {
{0.020676691f}, {-0.03041102399f}, {0.f}, {-0.010001f}, {1.9535398f}};
Matrix<float> lh_mat(*kValuesLeft, kNumRows, kNumCols);
Matrix<float> rh_mat(*kValuesRight, kNumRows, kNumCols);
Matrix<float> expected_result(*kValuesExpected, kNumRows, kNumCols);
Matrix<float> actual_result;
actual_result.PointwiseDivide(lh_mat, rh_mat);
MatrixTestHelpers::ValidateMatrixEqualityFloat(expected_result,
actual_result);
lh_mat.PointwiseDivide(rh_mat);
MatrixTestHelpers::ValidateMatrixEqualityFloat(lh_mat, actual_result);
}
TEST(MatrixTest, TestPointwiseSquareRoot) {
const int kNumRows = 2;
const int kNumCols = 2;
const int kValues[kNumRows][kNumCols] = {{4, 9}, {16, 0}};
const int kValuesExpected[kNumRows][kNumCols] = {{2, 3}, {4, 0}};
Matrix<int> operand_mat(*kValues, kNumRows, kNumCols);
Matrix<int> expected_result(*kValuesExpected, kNumRows, kNumCols);
Matrix<int> actual_result;
actual_result.PointwiseSquareRoot(operand_mat);
MatrixTestHelpers::ValidateMatrixEquality(expected_result, actual_result);
operand_mat.PointwiseSquareRoot();
MatrixTestHelpers::ValidateMatrixEquality(operand_mat, actual_result);
}
TEST(MatrixTest, TestPointwiseSquareRootComplex) {
const int kNumRows = 1;
const int kNumCols = 3;
const complex<float> kValues[kNumRows][kNumCols] = {
{complex<float>(-4.f, 0), complex<float>(0, 9), complex<float>(3, -4)}};
const complex<float> kValuesExpected[kNumRows][kNumCols] = {
{complex<float>(0.f, 2.f), complex<float>(2.1213202f, 2.1213202f),
complex<float>(2.f, -1.f)}};
Matrix<complex<float> > operand_mat(*kValues, kNumRows, kNumCols);
Matrix<complex<float> > expected_result(*kValuesExpected, kNumRows, kNumCols);
Matrix<complex<float> > actual_result;
actual_result.PointwiseSquareRoot(operand_mat);
MatrixTestHelpers::ValidateMatrixEqualityComplexFloat(expected_result,
actual_result);
operand_mat.PointwiseSquareRoot();
MatrixTestHelpers::ValidateMatrixEqualityComplexFloat(operand_mat,
actual_result);
}
TEST(MatrixTest, TestPointwiseAbsoluteValue) {
const int kNumRows = 1;
const int kNumCols = 3;
const complex<float> kValues[kNumRows][kNumCols] = {
{complex<float>(-4.f, 0), complex<float>(0, 9), complex<float>(3, -4)}};
const complex<float> kValuesExpected[kNumRows][kNumCols] = {
{complex<float>(4.f, 0), complex<float>(9.f, 0), complex<float>(5.f, 0)}};
Matrix<complex<float> > operand_mat(*kValues, kNumRows, kNumCols);
Matrix<complex<float> > expected_result(*kValuesExpected, kNumRows, kNumCols);
Matrix<complex<float> > actual_result;
actual_result.PointwiseAbsoluteValue(operand_mat);
MatrixTestHelpers::ValidateMatrixEqualityComplexFloat(expected_result,
actual_result);
operand_mat.PointwiseAbsoluteValue();
MatrixTestHelpers::ValidateMatrixEqualityComplexFloat(operand_mat,
actual_result);
}
TEST(MatrixTest, TestPointwiseSquare) {
const int kNumRows = 1;
const int kNumCols = 3;
const float kValues[kNumRows][kNumCols] = {{2.4f, -4.f, 3.3f}};
const float kValuesExpected[kNumRows][kNumCols] = {{5.76f, 16.f, 10.89f}};
Matrix<float> operand_mat(*kValues, kNumRows, kNumCols);
Matrix<float> expected_result(*kValuesExpected, kNumRows, kNumCols);
Matrix<float> actual_result;
actual_result.PointwiseSquare(operand_mat);
MatrixTestHelpers::ValidateMatrixEqualityFloat(expected_result,
actual_result);
operand_mat.PointwiseSquare();
MatrixTestHelpers::ValidateMatrixEqualityFloat(operand_mat, actual_result);
}
TEST(MatrixTest, TestComplexOperations) {
const int kNumRows = 2;
const int kNumCols = 2;
const complex<float> kValuesLeft[kNumRows][kNumCols] = {
{complex<float>(1.f, 1.f), complex<float>(2.f, 2.f)},
{complex<float>(3.f, 3.f), complex<float>(4.f, 4.f)}};
const complex<float> kValuesRight[kNumRows][kNumCols] = {
{complex<float>(5.f, 5.f), complex<float>(6.f, 6.f)},
{complex<float>(7.f, 7.f), complex<float>(8.f, 8.f)}};
const complex<float> kValuesExpectedAdd[kNumRows][kNumCols] = {
{complex<float>(6.f, 6.f), complex<float>(8.f, 8.f)},
{complex<float>(10.f, 10.f), complex<float>(12.f, 12.f)}};
const complex<float> kValuesExpectedMultiply[kNumRows][kNumCols] = {
{complex<float>(0.f, 38.f), complex<float>(0.f, 44.f)},
{complex<float>(0.f, 86.f), complex<float>(0.f, 100.f)}};
const complex<float> kValuesExpectedPointwiseDivide[kNumRows][kNumCols] = {
{complex<float>(0.2f, 0.f), complex<float>(0.33333333f, 0.f)},
{complex<float>(0.42857143f, 0.f), complex<float>(0.5f, 0.f)}};
Matrix<complex<float> > lh_mat(*kValuesLeft, kNumRows, kNumCols);
Matrix<complex<float> > rh_mat(*kValuesRight, kNumRows, kNumCols);
Matrix<complex<float> > expected_result_add(
*kValuesExpectedAdd, kNumRows, kNumCols);
Matrix<complex<float> > expected_result_multiply(
*kValuesExpectedMultiply, kNumRows, kNumCols);
Matrix<complex<float> > expected_result_pointwise_divide(
*kValuesExpectedPointwiseDivide, kNumRows, kNumCols);
Matrix<complex<float> > actual_result_add;
Matrix<complex<float> > actual_result_multiply(kNumRows, kNumCols);
Matrix<complex<float> > actual_result_pointwise_divide;
actual_result_add.Add(lh_mat, rh_mat);
MatrixTestHelpers::ValidateMatrixEqualityComplexFloat(expected_result_add,
actual_result_add);
actual_result_multiply.Multiply(lh_mat, rh_mat);
MatrixTestHelpers::ValidateMatrixEqualityComplexFloat(
expected_result_multiply, actual_result_multiply);
actual_result_pointwise_divide.PointwiseDivide(lh_mat, rh_mat);
MatrixTestHelpers::ValidateMatrixEqualityComplexFloat(
expected_result_pointwise_divide, actual_result_pointwise_divide);
}
} // namespace webrtc