saberbud/ceres-solver
1
0
Fork 0
mirror of https://github.com/ceres-solver/ceres-solver.git synced 2026-08-29 16:40:38 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
6b9a690009b3dbb878b2a31ab0ee24e1d7e49609
ceres-solver/internal/ceres/small_blas_test.cc
T
Sameer Agarwal 5a30cae583 Preparing for 2.2.0rc1 
1. Add a version history
2. Update copyright years across the code base
3. Run format_all.sh
4. Update version strings from 2.1.0 to 2.2.0 in the docs and
   elsewhere.

Change-Id: I46d8d479d54bd6002d532785e67342106e73c9ac
2023-09-21 11:23:38 -07:00

623 lines
23 KiB
C++
Raw Blame History

// Ceres Solver - A fast non-linear least squares minimizer
// Copyright 2023 Google Inc. All rights reserved.
// http://ceres-solver.org/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of Google Inc. nor the names of its contributors may be
// used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Author: keir@google.com (Keir Mierle)
#include "ceres/small_blas.h"
#include <limits>
#include <string>
#include "ceres/internal/eigen.h"
#include "gtest/gtest.h"
namespace ceres {
namespace internal {
const double kTolerance = 5.0 * std::numeric_limits<double>::epsilon();
// Static or dynamic problem types.
enum class DimType { Static, Dynamic };
// Constructs matrix functor type.
#define MATRIX_FUN_TY(FN) \
template <int kRowA, \
int kColA, \
int kRowB, \
int kColB, \
int kOperation, \
DimType kDimType> \
struct FN##Ty { \
void operator()(const double* A, \
const int num_row_a, \
const int num_col_a, \
const double* B, \
const int num_row_b, \
const int num_col_b, \
double* C, \
const int start_row_c, \
const int start_col_c, \
const int row_stride_c, \
const int col_stride_c) { \
if (kDimType == DimType::Static) { \
FN<kRowA, kColA, kRowB, kColB, kOperation>(A, \
num_row_a, \
num_col_a, \
B, \
num_row_b, \
num_col_b, \
C, \
start_row_c, \
start_col_c, \
row_stride_c, \
col_stride_c); \
} else { \
FN<Eigen::Dynamic, \
Eigen::Dynamic, \
Eigen::Dynamic, \
Eigen::Dynamic, \
kOperation>(A, \
num_row_a, \
num_col_a, \
B, \
num_row_b, \
num_col_b, \
C, \
start_row_c, \
start_col_c, \
row_stride_c, \
col_stride_c); \
} \
} \
};
MATRIX_FUN_TY(MatrixMatrixMultiply)
MATRIX_FUN_TY(MatrixMatrixMultiplyNaive)
MATRIX_FUN_TY(MatrixTransposeMatrixMultiply)
MATRIX_FUN_TY(MatrixTransposeMatrixMultiplyNaive)
#undef MATRIX_FUN_TY
// Initializes matrix entries.
static void initMatrix(Matrix& mat) {
for (int i = 0; i < mat.rows(); ++i) {
for (int j = 0; j < mat.cols(); ++j) {
mat(i, j) = i + j + 1;
}
}
}
template <int kRowA,
int kColA,
int kColB,
DimType kDimType,
template <int, int, int, int, int, DimType>
class FunctorTy>
struct TestMatrixFunctions {
void operator()() {
Matrix A(kRowA, kColA);
initMatrix(A);
const int kRowB = kColA;
Matrix B(kRowB, kColB);
initMatrix(B);
for (int row_stride_c = kRowA; row_stride_c < 3 * kRowA; ++row_stride_c) {
for (int col_stride_c = kColB; col_stride_c < 3 * kColB; ++col_stride_c) {
Matrix C(row_stride_c, col_stride_c);
C.setOnes();
Matrix C_plus = C;
Matrix C_minus = C;
Matrix C_assign = C;
Matrix C_plus_ref = C;
Matrix C_minus_ref = C;
Matrix C_assign_ref = C;
for (int start_row_c = 0; start_row_c + kRowA < row_stride_c;
++start_row_c) {
for (int start_col_c = 0; start_col_c + kColB < col_stride_c;
++start_col_c) {
C_plus_ref.block(start_row_c, start_col_c, kRowA, kColB) += A * B;
FunctorTy<kRowA, kColA, kRowB, kColB, 1, kDimType>()(A.data(),
kRowA,
kColA,
B.data(),
kRowB,
kColB,
C_plus.data(),
start_row_c,
start_col_c,
row_stride_c,
col_stride_c);
EXPECT_NEAR((C_plus_ref - C_plus).norm(), 0.0, kTolerance)
<< "C += A * B \n"
<< "row_stride_c : " << row_stride_c << "\n"
<< "col_stride_c : " << col_stride_c << "\n"
<< "start_row_c : " << start_row_c << "\n"
<< "start_col_c : " << start_col_c << "\n"
<< "Cref : \n"
<< C_plus_ref << "\n"
<< "C: \n"
<< C_plus;
C_minus_ref.block(start_row_c, start_col_c, kRowA, kColB) -= A * B;
FunctorTy<kRowA, kColA, kRowB, kColB, -1, kDimType>()(
A.data(),
kRowA,
kColA,
B.data(),
kRowB,
kColB,
C_minus.data(),
start_row_c,
start_col_c,
row_stride_c,
col_stride_c);
EXPECT_NEAR((C_minus_ref - C_minus).norm(), 0.0, kTolerance)
<< "C -= A * B \n"
<< "row_stride_c : " << row_stride_c << "\n"
<< "col_stride_c : " << col_stride_c << "\n"
<< "start_row_c : " << start_row_c << "\n"
<< "start_col_c : " << start_col_c << "\n"
<< "Cref : \n"
<< C_minus_ref << "\n"
<< "C: \n"
<< C_minus;
C_assign_ref.block(start_row_c, start_col_c, kRowA, kColB) = A * B;
FunctorTy<kRowA, kColA, kRowB, kColB, 0, kDimType>()(
A.data(),
kRowA,
kColA,
B.data(),
kRowB,
kColB,
C_assign.data(),
start_row_c,
start_col_c,
row_stride_c,
col_stride_c);
EXPECT_NEAR((C_assign_ref - C_assign).norm(), 0.0, kTolerance)
<< "C = A * B \n"
<< "row_stride_c : " << row_stride_c << "\n"
<< "col_stride_c : " << col_stride_c << "\n"
<< "start_row_c : " << start_row_c << "\n"
<< "start_col_c : " << start_col_c << "\n"
<< "Cref : \n"
<< C_assign_ref << "\n"
<< "C: \n"
<< C_assign;
}
}
}
}
}
};
template <int kRowA,
int kColA,
int kColB,
DimType kDimType,
template <int, int, int, int, int, DimType>
class FunctorTy>
struct TestMatrixTransposeFunctions {
void operator()() {
Matrix A(kRowA, kColA);
initMatrix(A);
const int kRowB = kRowA;
Matrix B(kRowB, kColB);
initMatrix(B);
for (int row_stride_c = kColA; row_stride_c < 3 * kColA; ++row_stride_c) {
for (int col_stride_c = kColB; col_stride_c < 3 * kColB; ++col_stride_c) {
Matrix C(row_stride_c, col_stride_c);
C.setOnes();
Matrix C_plus = C;
Matrix C_minus = C;
Matrix C_assign = C;
Matrix C_plus_ref = C;
Matrix C_minus_ref = C;
Matrix C_assign_ref = C;
for (int start_row_c = 0; start_row_c + kColA < row_stride_c;
++start_row_c) {
for (int start_col_c = 0; start_col_c + kColB < col_stride_c;
++start_col_c) {
C_plus_ref.block(start_row_c, start_col_c, kColA, kColB) +=
A.transpose() * B;
FunctorTy<kRowA, kColA, kRowB, kColB, 1, kDimType>()(A.data(),
kRowA,
kColA,
B.data(),
kRowB,
kColB,
C_plus.data(),
start_row_c,
start_col_c,
row_stride_c,
col_stride_c);
EXPECT_NEAR((C_plus_ref - C_plus).norm(), 0.0, kTolerance)
<< "C += A' * B \n"
<< "row_stride_c : " << row_stride_c << "\n"
<< "col_stride_c : " << col_stride_c << "\n"
<< "start_row_c : " << start_row_c << "\n"
<< "start_col_c : " << start_col_c << "\n"
<< "Cref : \n"
<< C_plus_ref << "\n"
<< "C: \n"
<< C_plus;
C_minus_ref.block(start_row_c, start_col_c, kColA, kColB) -=
A.transpose() * B;
FunctorTy<kRowA, kColA, kRowB, kColB, -1, kDimType>()(
A.data(),
kRowA,
kColA,
B.data(),
kRowB,
kColB,
C_minus.data(),
start_row_c,
start_col_c,
row_stride_c,
col_stride_c);
EXPECT_NEAR((C_minus_ref - C_minus).norm(), 0.0, kTolerance)
<< "C -= A' * B \n"
<< "row_stride_c : " << row_stride_c << "\n"
<< "col_stride_c : " << col_stride_c << "\n"
<< "start_row_c : " << start_row_c << "\n"
<< "start_col_c : " << start_col_c << "\n"
<< "Cref : \n"
<< C_minus_ref << "\n"
<< "C: \n"
<< C_minus;
C_assign_ref.block(start_row_c, start_col_c, kColA, kColB) =
A.transpose() * B;
FunctorTy<kRowA, kColA, kRowB, kColB, 0, kDimType>()(
A.data(),
kRowA,
kColA,
B.data(),
kRowB,
kColB,
C_assign.data(),
start_row_c,
start_col_c,
row_stride_c,
col_stride_c);
EXPECT_NEAR((C_assign_ref - C_assign).norm(), 0.0, kTolerance)
<< "C = A' * B \n"
<< "row_stride_c : " << row_stride_c << "\n"
<< "col_stride_c : " << col_stride_c << "\n"
<< "start_row_c : " << start_row_c << "\n"
<< "start_col_c : " << start_col_c << "\n"
<< "Cref : \n"
<< C_assign_ref << "\n"
<< "C: \n"
<< C_assign;
}
}
}
}
}
};
TEST(BLAS, MatrixMatrixMultiply_5_3_7) {
TestMatrixFunctions<5, 3, 7, DimType::Static, MatrixMatrixMultiplyTy>()();
}
TEST(BLAS, MatrixMatrixMultiply_5_3_7_Dynamic) {
TestMatrixFunctions<5, 3, 7, DimType::Dynamic, MatrixMatrixMultiplyTy>()();
}
TEST(BLAS, MatrixMatrixMultiply_1_1_1) {
TestMatrixFunctions<1, 1, 1, DimType::Static, MatrixMatrixMultiplyTy>()();
}
TEST(BLAS, MatrixMatrixMultiply_1_1_1_Dynamic) {
TestMatrixFunctions<1, 1, 1, DimType::Dynamic, MatrixMatrixMultiplyTy>()();
}
TEST(BLAS, MatrixMatrixMultiply_9_9_9) {
TestMatrixFunctions<9, 9, 9, DimType::Static, MatrixMatrixMultiplyTy>()();
}
TEST(BLAS, MatrixMatrixMultiply_9_9_9_Dynamic) {
TestMatrixFunctions<9, 9, 9, DimType::Dynamic, MatrixMatrixMultiplyTy>()();
}
TEST(BLAS, MatrixMatrixMultiplyNaive_5_3_7) {
TestMatrixFunctions<5,
3,
7,
DimType::Static,
MatrixMatrixMultiplyNaiveTy>()();
}
TEST(BLAS, MatrixMatrixMultiplyNaive_5_3_7_Dynamic) {
TestMatrixFunctions<5,
3,
7,
DimType::Dynamic,
MatrixMatrixMultiplyNaiveTy>()();
}
TEST(BLAS, MatrixMatrixMultiplyNaive_1_1_1) {
TestMatrixFunctions<1,
1,
1,
DimType::Static,
MatrixMatrixMultiplyNaiveTy>()();
}
TEST(BLAS, MatrixMatrixMultiplyNaive_1_1_1_Dynamic) {
TestMatrixFunctions<1,
1,
1,
DimType::Dynamic,
MatrixMatrixMultiplyNaiveTy>()();
}
TEST(BLAS, MatrixMatrixMultiplyNaive_9_9_9) {
TestMatrixFunctions<9,
9,
9,
DimType::Static,
MatrixMatrixMultiplyNaiveTy>()();
}
TEST(BLAS, MatrixMatrixMultiplyNaive_9_9_9_Dynamic) {
TestMatrixFunctions<9,
9,
9,
DimType::Dynamic,
MatrixMatrixMultiplyNaiveTy>()();
}
TEST(BLAS, MatrixTransposeMatrixMultiply_5_3_7) {
TestMatrixTransposeFunctions<5,
3,
7,
DimType::Static,
MatrixTransposeMatrixMultiplyTy>()();
}
TEST(BLAS, MatrixTransposeMatrixMultiply_5_3_7_Dynamic) {
TestMatrixTransposeFunctions<5,
3,
7,
DimType::Dynamic,
MatrixTransposeMatrixMultiplyTy>()();
}
TEST(BLAS, MatrixTransposeMatrixMultiply_1_1_1) {
TestMatrixTransposeFunctions<1,
1,
1,
DimType::Static,
MatrixTransposeMatrixMultiplyTy>()();
}
TEST(BLAS, MatrixTransposeMatrixMultiply_1_1_1_Dynamic) {
TestMatrixTransposeFunctions<1,
1,
1,
DimType::Dynamic,
MatrixTransposeMatrixMultiplyTy>()();
}
TEST(BLAS, MatrixTransposeMatrixMultiply_9_9_9) {
TestMatrixTransposeFunctions<9,
9,
9,
DimType::Static,
MatrixTransposeMatrixMultiplyTy>()();
}
TEST(BLAS, MatrixTransposeMatrixMultiply_9_9_9_Dynamic) {
TestMatrixTransposeFunctions<9,
9,
9,
DimType::Dynamic,
MatrixTransposeMatrixMultiplyTy>()();
}
TEST(BLAS, MatrixTransposeMatrixMultiplyNaive_5_3_7) {
TestMatrixTransposeFunctions<5,
3,
7,
DimType::Static,
MatrixTransposeMatrixMultiplyNaiveTy>()();
}
TEST(BLAS, MatrixTransposeMatrixMultiplyNaive_5_3_7_Dynamic) {
TestMatrixTransposeFunctions<5,
3,
7,
DimType::Dynamic,
MatrixTransposeMatrixMultiplyNaiveTy>()();
}
TEST(BLAS, MatrixTransposeMatrixMultiplyNaive_1_1_1) {
TestMatrixTransposeFunctions<1,
1,
1,
DimType::Static,
MatrixTransposeMatrixMultiplyNaiveTy>()();
}
TEST(BLAS, MatrixTransposeMatrixMultiplyNaive_1_1_1_Dynamic) {
TestMatrixTransposeFunctions<1,
1,
1,
DimType::Dynamic,
MatrixTransposeMatrixMultiplyNaiveTy>()();
}
TEST(BLAS, MatrixTransposeMatrixMultiplyNaive_9_9_9) {
TestMatrixTransposeFunctions<9,
9,
9,
DimType::Static,
MatrixTransposeMatrixMultiplyNaiveTy>()();
}
TEST(BLAS, MatrixTransposeMatrixMultiplyNaive_9_9_9_Dynamic) {
TestMatrixTransposeFunctions<9,
9,
9,
DimType::Dynamic,
MatrixTransposeMatrixMultiplyNaiveTy>()();
}
TEST(BLAS, MatrixVectorMultiply) {
for (int num_rows_a = 1; num_rows_a < 10; ++num_rows_a) {
for (int num_cols_a = 1; num_cols_a < 10; ++num_cols_a) {
Matrix A(num_rows_a, num_cols_a);
A.setOnes();
Vector b(num_cols_a);
b.setOnes();
Vector c(num_rows_a);
c.setOnes();
Vector c_plus = c;
Vector c_minus = c;
Vector c_assign = c;
Vector c_plus_ref = c;
Vector c_minus_ref = c;
Vector c_assign_ref = c;
// clang-format off
c_plus_ref += A * b;
MatrixVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
A.data(), num_rows_a, num_cols_a,
b.data(),
c_plus.data());
EXPECT_NEAR((c_plus_ref - c_plus).norm(), 0.0, kTolerance)
<< "c += A * b \n"
<< "c_ref : \n" << c_plus_ref << "\n"
<< "c: \n" << c_plus;
c_minus_ref -= A * b;
MatrixVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, -1>(
A.data(), num_rows_a, num_cols_a,
b.data(),
c_minus.data());
EXPECT_NEAR((c_minus_ref - c_minus).norm(), 0.0, kTolerance)
<< "c -= A * b \n"
<< "c_ref : \n" << c_minus_ref << "\n"
<< "c: \n" << c_minus;
c_assign_ref = A * b;
MatrixVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 0>(
A.data(), num_rows_a, num_cols_a,
b.data(),
c_assign.data());
EXPECT_NEAR((c_assign_ref - c_assign).norm(), 0.0, kTolerance)
<< "c = A * b \n"
<< "c_ref : \n" << c_assign_ref << "\n"
<< "c: \n" << c_assign;
// clang-format on
}
}
}
TEST(BLAS, MatrixTransposeVectorMultiply) {
for (int num_rows_a = 1; num_rows_a < 10; ++num_rows_a) {
for (int num_cols_a = 1; num_cols_a < 10; ++num_cols_a) {
Matrix A(num_rows_a, num_cols_a);
A.setRandom();
Vector b(num_rows_a);
b.setRandom();
Vector c(num_cols_a);
c.setOnes();
Vector c_plus = c;
Vector c_minus = c;
Vector c_assign = c;
Vector c_plus_ref = c;
Vector c_minus_ref = c;
Vector c_assign_ref = c;
// clang-format off
c_plus_ref += A.transpose() * b;
MatrixTransposeVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
A.data(), num_rows_a, num_cols_a,
b.data(),
c_plus.data());
EXPECT_NEAR((c_plus_ref - c_plus).norm(), 0.0, kTolerance)
<< "c += A' * b \n"
<< "c_ref : \n" << c_plus_ref << "\n"
<< "c: \n" << c_plus;
c_minus_ref -= A.transpose() * b;
MatrixTransposeVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, -1>(
A.data(), num_rows_a, num_cols_a,
b.data(),
c_minus.data());
EXPECT_NEAR((c_minus_ref - c_minus).norm(), 0.0, kTolerance)
<< "c -= A' * b \n"
<< "c_ref : \n" << c_minus_ref << "\n"
<< "c: \n" << c_minus;
c_assign_ref = A.transpose() * b;
MatrixTransposeVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 0>(
A.data(), num_rows_a, num_cols_a,
b.data(),
c_assign.data());
EXPECT_NEAR((c_assign_ref - c_assign).norm(), 0.0, kTolerance)
<< "c = A' * b \n"
<< "c_ref : \n" << c_assign_ref << "\n"
<< "c: \n" << c_assign;
// clang-format on
}
}
}
} // namespace internal
} // namespace ceres
Reference in New Issue View Git Blame Copy Permalink