griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

ClangFormat: apply to source, most of intern

Browse Source 
Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat
This commit is contained in:
Campbell Barton
2019-04-17 06:17:24 +02:00
parent b3dabc200a
commit e12c08e8d1
4481 changed files with 1230080 additions and 1155401 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
intern/eigen/CMakeLists.txt
View File

@@ -19,25 +19,25 @@
# ***** END GPL LICENSE BLOCK *****
set(INC
.
.
)
set(INC_SYS
${EIGEN3_INCLUDE_DIRS}
${EIGEN3_INCLUDE_DIRS}
)
set(SRC
eigen_capi.h
eigen_capi.h
intern/eigenvalues.cc
intern/linear_solver.cc
intern/matrix.cc
intern/svd.cc
intern/eigenvalues.cc
intern/linear_solver.cc
intern/matrix.cc
intern/svd.cc
intern/eigenvalues.h
intern/linear_solver.h
intern/matrix.h
intern/svd.h
intern/eigenvalues.h
intern/linear_solver.h
intern/matrix.h
intern/svd.h
)
set(LIB

2
intern/eigen/eigen_capi.h
View File

@@ -25,4 +25,4 @@
#include "intern/matrix.h"
#include "intern/svd.h"
#endif /* __EIGEN_C_API_H__ */
#endif /* __EIGEN_C_API_H__ */

35
intern/eigen/intern/eigenvalues.cc
View File

@@ -32,32 +32,35 @@
using Eigen::SelfAdjointEigenSolver;
using Eigen::Map;
using Eigen::MatrixXf;
using Eigen::VectorXf;
using Eigen::Map;
using Eigen::Success;
bool EIG_self_adjoint_eigen_solve(const int size, const float *matrix, float *r_eigen_values, float *r_eigen_vectors)
bool EIG_self_adjoint_eigen_solve(const int size,
const float *matrix,
float *r_eigen_values,
float *r_eigen_vectors)
{
SelfAdjointEigenSolver<MatrixXf> eigen_solver;
SelfAdjointEigenSolver<MatrixXf> eigen_solver;
/* Blender and Eigen matrices are both column-major. */
eigen_solver.compute(Map<MatrixXf>((float *)matrix, size, size));
/* Blender and Eigen matrices are both column-major. */
eigen_solver.compute(Map<MatrixXf>((float *)matrix, size, size));
if (eigen_solver.info() != Success) {
return false;
}
if (eigen_solver.info() != Success) {
return false;
}
if (r_eigen_values) {
Map<VectorXf>(r_eigen_values, size) = eigen_solver.eigenvalues().transpose();
}
if (r_eigen_values) {
Map<VectorXf>(r_eigen_values, size) = eigen_solver.eigenvalues().transpose();
}
if (r_eigen_vectors) {
Map<MatrixXf>(r_eigen_vectors, size, size) = eigen_solver.eigenvectors();
}
if (r_eigen_vectors) {
Map<MatrixXf>(r_eigen_vectors, size, size) = eigen_solver.eigenvectors();
}
return true;
return true;
}
#endif /* __EIGEN3_EIGENVALUES_C_API_CC__ */
#endif /* __EIGEN3_EIGENVALUES_C_API_CC__ */

7
intern/eigen/intern/eigenvalues.h
View File

@@ -24,10 +24,13 @@
extern "C" {
#endif
bool EIG_self_adjoint_eigen_solve(const int size, const float *matrix, float *r_eigen_values, float *r_eigen_vectors);
bool EIG_self_adjoint_eigen_solve(const int size,
const float *matrix,
float *r_eigen_values,
float *r_eigen_vectors);
#ifdef __cplusplus
}
#endif
#endif /* __EIGEN3_EIGENVALUES_C_API_H__ */
#endif /* __EIGEN3_EIGENVALUES_C_API_H__ */

404
intern/eigen/intern/linear_solver.cc
View File

@@ -41,326 +41,318 @@ typedef Eigen::Triplet<double> EigenTriplet;
/* Linear Solver data structure */
struct LinearSolver
{
struct Coeff
{
Coeff()
{
index = 0;
value = 0.0;
}
struct LinearSolver {
struct Coeff {
Coeff()
{
index = 0;
value = 0.0;
}
int index;
double value;
};
int index;
double value;
};
struct Variable
{
Variable()
{
memset(value, 0, sizeof(value));
locked = false;
index = 0;
}
struct Variable {
Variable()
{
memset(value, 0, sizeof(value));
locked = false;
index = 0;
}
double value[4];
bool locked;
int index;
std::vector<Coeff> a;
};
double value[4];
bool locked;
int index;
std::vector<Coeff> a;
};
enum State
{
STATE_VARIABLES_CONSTRUCT,
STATE_MATRIX_CONSTRUCT,
STATE_MATRIX_SOLVED
};
enum State { STATE_VARIABLES_CONSTRUCT, STATE_MATRIX_CONSTRUCT, STATE_MATRIX_SOLVED };
LinearSolver(int num_rows_, int num_variables_, int num_rhs_, bool lsq_)
{
assert(num_variables_ > 0);
assert(num_rhs_ <= 4);
LinearSolver(int num_rows_, int num_variables_, int num_rhs_, bool lsq_)
{
assert(num_variables_ > 0);
assert(num_rhs_ <= 4);
state = STATE_VARIABLES_CONSTRUCT;
m = 0;
n = 0;
sparseLU = NULL;
num_variables = num_variables_;
num_rhs = num_rhs_;
num_rows = num_rows_;
least_squares = lsq_;
state = STATE_VARIABLES_CONSTRUCT;
m = 0;
n = 0;
sparseLU = NULL;
num_variables = num_variables_;
num_rhs = num_rhs_;
num_rows = num_rows_;
least_squares = lsq_;
variable.resize(num_variables);
}
variable.resize(num_variables);
}
~LinearSolver()
{
delete sparseLU;
}
~LinearSolver()
{
delete sparseLU;
}
State state;
State state;
int n;
int m;
int n;
int m;
std::vector<EigenTriplet> Mtriplets;
EigenSparseMatrix M;
EigenSparseMatrix MtM;
std::vector<EigenVectorX> b;
std::vector<EigenVectorX> x;
std::vector<EigenTriplet> Mtriplets;
EigenSparseMatrix M;
EigenSparseMatrix MtM;
std::vector<EigenVectorX> b;
std::vector<EigenVectorX> x;
EigenSparseLU *sparseLU;
EigenSparseLU *sparseLU;
int num_variables;
std::vector<Variable> variable;
int num_variables;
std::vector<Variable> variable;
int num_rows;
int num_rhs;
int num_rows;
int num_rhs;
bool least_squares;
bool least_squares;
};
LinearSolver *EIG_linear_solver_new(int num_rows, int num_columns, int num_rhs)
{
return new LinearSolver(num_rows, num_columns, num_rhs, false);
return new LinearSolver(num_rows, num_columns, num_rhs, false);
}
LinearSolver *EIG_linear_least_squares_solver_new(int num_rows, int num_columns, int num_rhs)
{
return new LinearSolver(num_rows, num_columns, num_rhs, true);
return new LinearSolver(num_rows, num_columns, num_rhs, true);
}
void EIG_linear_solver_delete(LinearSolver *solver)
{
delete solver;
delete solver;
}
/* Variables */
void EIG_linear_solver_variable_set(LinearSolver *solver, int rhs, int index, double value)
{
solver->variable[index].value[rhs] = value;
solver->variable[index].value[rhs] = value;
}
double EIG_linear_solver_variable_get(LinearSolver *solver, int rhs, int index)
{
return solver->variable[index].value[rhs];
return solver->variable[index].value[rhs];
}
void EIG_linear_solver_variable_lock(LinearSolver *solver, int index)
{
if (!solver->variable[index].locked) {
assert(solver->state == LinearSolver::STATE_VARIABLES_CONSTRUCT);
solver->variable[index].locked = true;
}
if (!solver->variable[index].locked) {
assert(solver->state == LinearSolver::STATE_VARIABLES_CONSTRUCT);
solver->variable[index].locked = true;
}
}
void EIG_linear_solver_variable_unlock(LinearSolver *solver, int index)
{
if (solver->variable[index].locked) {
assert(solver->state == LinearSolver::STATE_VARIABLES_CONSTRUCT);
solver->variable[index].locked = false;
}
if (solver->variable[index].locked) {
assert(solver->state == LinearSolver::STATE_VARIABLES_CONSTRUCT);
solver->variable[index].locked = false;
}
}
static void linear_solver_variables_to_vector(LinearSolver *solver)
{
int num_rhs = solver->num_rhs;
int num_rhs = solver->num_rhs;
for (int i = 0; i < solver->num_variables; i++) {
LinearSolver::Variable* v = &solver->variable[i];
if (!v->locked) {
for (int j = 0; j < num_rhs; j++)
solver->x[j][v->index] = v->value[j];
}
}
for (int i = 0; i < solver->num_variables; i++) {
LinearSolver::Variable *v = &solver->variable[i];
if (!v->locked) {
for (int j = 0; j < num_rhs; j++)
solver->x[j][v->index] = v->value[j];
}
}
}
static void linear_solver_vector_to_variables(LinearSolver *solver)
{
int num_rhs = solver->num_rhs;
int num_rhs = solver->num_rhs;
for (int i = 0; i < solver->num_variables; i++) {
LinearSolver::Variable* v = &solver->variable[i];
if (!v->locked) {
for (int j = 0; j < num_rhs; j++)
v->value[j] = solver->x[j][v->index];
}
}
for (int i = 0; i < solver->num_variables; i++) {
LinearSolver::Variable *v = &solver->variable[i];
if (!v->locked) {
for (int j = 0; j < num_rhs; j++)
v->value[j] = solver->x[j][v->index];
}
}
}
/* Matrix */
static void linear_solver_ensure_matrix_construct(LinearSolver *solver)
{
/* transition to matrix construction if necessary */
if (solver->state == LinearSolver::STATE_VARIABLES_CONSTRUCT) {
int n = 0;
/* transition to matrix construction if necessary */
if (solver->state == LinearSolver::STATE_VARIABLES_CONSTRUCT) {
int n = 0;
for (int i = 0; i < solver->num_variables; i++) {
if (solver->variable[i].locked)
solver->variable[i].index = ~0;
else
solver->variable[i].index = n++;
}
for (int i = 0; i < solver->num_variables; i++) {
if (solver->variable[i].locked)
solver->variable[i].index = ~0;
else
solver->variable[i].index = n++;
}
int m = (solver->num_rows == 0)? n: solver->num_rows;
int m = (solver->num_rows == 0) ? n : solver->num_rows;
solver->m = m;
solver->n = n;
solver->m = m;
solver->n = n;
assert(solver->least_squares || m == n);
assert(solver->least_squares || m == n);
/* reserve reasonable estimate */
solver->Mtriplets.clear();
solver->Mtriplets.reserve(std::max(m, n)*3);
/* reserve reasonable estimate */
solver->Mtriplets.clear();
solver->Mtriplets.reserve(std::max(m, n) * 3);
solver->b.resize(solver->num_rhs);
solver->x.resize(solver->num_rhs);
solver->b.resize(solver->num_rhs);
solver->x.resize(solver->num_rhs);
for (int i = 0; i < solver->num_rhs; i++) {
solver->b[i].setZero(m);
solver->x[i].setZero(n);
}
for (int i = 0; i < solver->num_rhs; i++) {
solver->b[i].setZero(m);
solver->x[i].setZero(n);
}
linear_solver_variables_to_vector(solver);
linear_solver_variables_to_vector(solver);
solver->state = LinearSolver::STATE_MATRIX_CONSTRUCT;
}
solver->state = LinearSolver::STATE_MATRIX_CONSTRUCT;
}
}
void EIG_linear_solver_matrix_add(LinearSolver *solver, int row, int col, double value)
{
if (solver->state == LinearSolver::STATE_MATRIX_SOLVED)
return;
if (solver->state == LinearSolver::STATE_MATRIX_SOLVED)
return;
linear_solver_ensure_matrix_construct(solver);
linear_solver_ensure_matrix_construct(solver);
if (!solver->least_squares && solver->variable[row].locked);
else if (solver->variable[col].locked) {
if (!solver->least_squares)
row = solver->variable[row].index;
if (!solver->least_squares && solver->variable[row].locked)
;
else if (solver->variable[col].locked) {
if (!solver->least_squares)
row = solver->variable[row].index;
LinearSolver::Coeff coeff;
coeff.index = row;
coeff.value = value;
solver->variable[col].a.push_back(coeff);
}
else {
if (!solver->least_squares)
row = solver->variable[row].index;
col = solver->variable[col].index;
LinearSolver::Coeff coeff;
coeff.index = row;
coeff.value = value;
solver->variable[col].a.push_back(coeff);
}
else {
if (!solver->least_squares)
row = solver->variable[row].index;
col = solver->variable[col].index;
/* direct insert into matrix is too slow, so use triplets */
EigenTriplet triplet(row, col, value);
solver->Mtriplets.push_back(triplet);
}
/* direct insert into matrix is too slow, so use triplets */
EigenTriplet triplet(row, col, value);
solver->Mtriplets.push_back(triplet);
}
}
/* Right hand side */
void EIG_linear_solver_right_hand_side_add(LinearSolver *solver, int rhs, int index, double value)
{
linear_solver_ensure_matrix_construct(solver);
linear_solver_ensure_matrix_construct(solver);
if (solver->least_squares) {
solver->b[rhs][index] += value;
}
else if (!solver->variable[index].locked) {
index = solver->variable[index].index;
solver->b[rhs][index] += value;
}
if (solver->least_squares) {
solver->b[rhs][index] += value;
}
else if (!solver->variable[index].locked) {
index = solver->variable[index].index;
solver->b[rhs][index] += value;
}
}
/* Solve */
bool EIG_linear_solver_solve(LinearSolver *solver)
{
/* nothing to solve, perhaps all variables were locked */
if (solver->m == 0 || solver->n == 0)
return true;
/* nothing to solve, perhaps all variables were locked */
if (solver->m == 0 || solver->n == 0)
return true;
bool result = true;
bool result = true;
assert(solver->state != LinearSolver::STATE_VARIABLES_CONSTRUCT);
assert(solver->state != LinearSolver::STATE_VARIABLES_CONSTRUCT);
if (solver->state == LinearSolver::STATE_MATRIX_CONSTRUCT) {
/* create matrix from triplets */
solver->M.resize(solver->m, solver->n);
solver->M.setFromTriplets(solver->Mtriplets.begin(), solver->Mtriplets.end());
solver->Mtriplets.clear();
if (solver->state == LinearSolver::STATE_MATRIX_CONSTRUCT) {
/* create matrix from triplets */
solver->M.resize(solver->m, solver->n);
solver->M.setFromTriplets(solver->Mtriplets.begin(), solver->Mtriplets.end());
solver->Mtriplets.clear();
/* create least squares matrix */
if (solver->least_squares)
solver->MtM = solver->M.transpose() * solver->M;
/* create least squares matrix */
if (solver->least_squares)
solver->MtM = solver->M.transpose() * solver->M;
/* convert M to compressed column format */
EigenSparseMatrix& M = (solver->least_squares)? solver->MtM: solver->M;
M.makeCompressed();
/* convert M to compressed column format */
EigenSparseMatrix &M = (solver->least_squares) ? solver->MtM : solver->M;
M.makeCompressed();
/* perform sparse LU factorization */
EigenSparseLU *sparseLU = new EigenSparseLU();
solver->sparseLU = sparseLU;
/* perform sparse LU factorization */
EigenSparseLU *sparseLU = new EigenSparseLU();
solver->sparseLU = sparseLU;
sparseLU->compute(M);
result = (sparseLU->info() == Eigen::Success);
sparseLU->compute(M);
result = (sparseLU->info() == Eigen::Success);
solver->state = LinearSolver::STATE_MATRIX_SOLVED;
}
solver->state = LinearSolver::STATE_MATRIX_SOLVED;
}
if (result) {
/* solve for each right hand side */
for (int rhs = 0; rhs < solver->num_rhs; rhs++) {
/* modify for locked variables */
EigenVectorX& b = solver->b[rhs];
if (result) {
/* solve for each right hand side */
for (int rhs = 0; rhs < solver->num_rhs; rhs++) {
/* modify for locked variables */
EigenVectorX &b = solver->b[rhs];
for (int i = 0; i < solver->num_variables; i++) {
LinearSolver::Variable *variable = &solver->variable[i];
for (int i = 0; i < solver->num_variables; i++) {
LinearSolver::Variable *variable = &solver->variable[i];
if (variable->locked) {
std::vector<LinearSolver::Coeff>& a = variable->a;
if (variable->locked) {
std::vector<LinearSolver::Coeff> &a = variable->a;
for (int j = 0; j < a.size(); j++)
b[a[j].index] -= a[j].value*variable->value[rhs];
}
}
for (int j = 0; j < a.size(); j++)
b[a[j].index] -= a[j].value * variable->value[rhs];
}
}
/* solve */
if (solver->least_squares) {
EigenVectorX Mtb = solver->M.transpose() * b;
solver->x[rhs] = solver->sparseLU->solve(Mtb);
}
else {
EigenVectorX& b = solver->b[rhs];
solver->x[rhs] = solver->sparseLU->solve(b);
}
/* solve */
if (solver->least_squares) {
EigenVectorX Mtb = solver->M.transpose() * b;
solver->x[rhs] = solver->sparseLU->solve(Mtb);
}
else {
EigenVectorX &b = solver->b[rhs];
solver->x[rhs] = solver->sparseLU->solve(b);
}
if (solver->sparseLU->info() != Eigen::Success)
result = false;
}
if (solver->sparseLU->info() != Eigen::Success)
result = false;
}
if (result)
linear_solver_vector_to_variables(solver);
}
if (result)
linear_solver_vector_to_variables(solver);
}
/* clear for next solve */
for (int rhs = 0; rhs < solver->num_rhs; rhs++)
solver->b[rhs].setZero(solver->m);
/* clear for next solve */
for (int rhs = 0; rhs < solver->num_rhs; rhs++)
solver->b[rhs].setZero(solver->m);
return result;
return result;
}
/* Debugging */
void EIG_linear_solver_print_matrix(LinearSolver *solver)
{
std::cout << "A:" << solver->M << std::endl;
std::cout << "A:" << solver->M << std::endl;
for (int rhs = 0; rhs < solver->num_rhs; rhs++)
std::cout << "b " << rhs << ":" << solver->b[rhs] << std::endl;
for (int rhs = 0; rhs < solver->num_rhs; rhs++)
std::cout << "b " << rhs << ":" << solver->b[rhs] << std::endl;
if (solver->MtM.rows() && solver->MtM.cols())
std::cout << "AtA:" << solver->MtM << std::endl;
if (solver->MtM.rows() && solver->MtM.cols())
std::cout << "AtA:" << solver->MtM << std::endl;
}

13
intern/eigen/intern/linear_solver.h
View File

@@ -34,15 +34,11 @@ extern "C" {
typedef struct LinearSolver LinearSolver;
LinearSolver *EIG_linear_solver_new(
int num_rows,
int num_columns,
int num_right_hand_sides);
LinearSolver *EIG_linear_solver_new(int num_rows, int num_columns, int num_right_hand_sides);
LinearSolver *EIG_linear_least_squares_solver_new(
int num_rows,
int num_columns,
int num_right_hand_sides);
LinearSolver *EIG_linear_least_squares_solver_new(int num_rows,
int num_columns,
int num_right_hand_sides);
void EIG_linear_solver_delete(LinearSolver *solver);
@@ -69,4 +65,3 @@ void EIG_linear_solver_print_matrix(LinearSolver *solver);
#ifdef __cplusplus
}
#endif

22
intern/eigen/intern/matrix.cc
View File

@@ -25,7 +25,7 @@
# pragma GCC diagnostic ignored "-Wlogical-op"
#endif
#ifdef __EIGEN3_MATRIX_C_API_CC__ /* quiet warning */
#ifdef __EIGEN3_MATRIX_C_API_CC__ /* quiet warning */
#endif
#include <Eigen/Core>
@@ -38,15 +38,15 @@ using Eigen::Matrix4f;
bool EIG_invert_m4_m4(float inverse[4][4], const float matrix[4][4])
{
Map<Matrix4f> M = Map<Matrix4f>((float*)matrix);
Matrix4f R;
bool invertible = true;
M.computeInverseWithCheck(R, invertible, 0.0f);
if (!invertible) {
R = R.Zero();
}
memcpy(inverse, R.data(), sizeof(float)*4*4);
return invertible;
Map<Matrix4f> M = Map<Matrix4f>((float *)matrix);
Matrix4f R;
bool invertible = true;
M.computeInverseWithCheck(R, invertible, 0.0f);
if (!invertible) {
R = R.Zero();
}
memcpy(inverse, R.data(), sizeof(float) * 4 * 4);
return invertible;
}
#endif /* __EIGEN3_MATRIX_C_API_CC__ */
#endif /* __EIGEN3_MATRIX_C_API_CC__ */

2
intern/eigen/intern/matrix.h
View File

@@ -30,4 +30,4 @@ bool EIG_invert_m4_m4(float inverse[4][4], const float matrix[4][4]);
}
#endif
#endif /* __EIGEN3_MATRIX_C_API_H__ */
#endif /* __EIGEN3_MATRIX_C_API_H__ */

32
intern/eigen/intern/svd.cc
View File

@@ -25,7 +25,7 @@
# pragma GCC diagnostic ignored "-Wlogical-op"
#endif
#ifdef __EIGEN3_SVD_C_API_CC__ /* quiet warning */
#ifdef __EIGEN3_SVD_C_API_CC__ /* quiet warning */
#endif
#include <Eigen/Core>
@@ -41,31 +41,31 @@ using Eigen::NoQRPreconditioner;
using Eigen::ComputeThinU;
using Eigen::ComputeThinV;
using Eigen::Map;
using Eigen::MatrixXf;
using Eigen::VectorXf;
using Eigen::Map;
using Eigen::Matrix4f;
void EIG_svd_square_matrix(const int size, const float *matrix, float *r_U, float *r_S, float *r_V)
{
/* Since our matrix is squared, we can use thinU/V. */
unsigned int flags = (r_U ? ComputeThinU : 0) | (r_V ? ComputeThinV : 0);
/* Since our matrix is squared, we can use thinU/V. */
unsigned int flags = (r_U ? ComputeThinU : 0) | (r_V ? ComputeThinV : 0);
/* Blender and Eigen matrices are both column-major. */
JacobiSVD<MatrixXf, NoQRPreconditioner> svd(Map<MatrixXf>((float *)matrix, size, size), flags);
/* Blender and Eigen matrices are both column-major. */
JacobiSVD<MatrixXf, NoQRPreconditioner> svd(Map<MatrixXf>((float *)matrix, size, size), flags);
if (r_U) {
Map<MatrixXf>(r_U, size, size) = svd.matrixU();
}
if (r_U) {
Map<MatrixXf>(r_U, size, size) = svd.matrixU();
}
if (r_S) {
Map<VectorXf>(r_S, size) = svd.singularValues();
}
if (r_S) {
Map<VectorXf>(r_S, size) = svd.singularValues();
}
if (r_V) {
Map<MatrixXf>(r_V, size, size) = svd.matrixV();
}
if (r_V) {
Map<MatrixXf>(r_V, size, size) = svd.matrixV();
}
}
#endif /* __EIGEN3_SVD_C_API_CC__ */
#endif /* __EIGEN3_SVD_C_API_CC__ */

5
intern/eigen/intern/svd.h
View File

@@ -24,10 +24,11 @@
extern "C" {
#endif
void EIG_svd_square_matrix(const int size, const float *matrix, float *r_U, float *r_S, float *r_V);
void EIG_svd_square_matrix(
const int size, const float *matrix, float *r_U, float *r_S, float *r_V);
#ifdef __cplusplus
}
#endif
#endif /* __EIGEN3_SVD_C_API_H__ */
#endif /* __EIGEN3_SVD_C_API_H__ */