30 float r_eigen_values[3],
31 float r_eigen_vectors[3][3])
35 if ((m3[0][1] != m3[1][0]) || (m3[0][2] != m3[2][0]) || (m3[1][2] != m3[2][1])) {
41 reinterpret_cast<const float *
>(m3),
43 reinterpret_cast<float *
>(r_eigen_vectors));
46void BLI_svd_m3(
const float m3[3][3],
float r_U[3][3],
float r_S[3],
float r_V[3][3])
49 reinterpret_cast<const float *
>(m3),
50 reinterpret_cast<float *
>(r_U),
52 reinterpret_cast<float *
>(r_V));
62 const float *a,
const float *
b,
const float *c,
const float *d,
float *r_x,
const int count)
72 double *d1 = c1 + count;
75 double c_prev, d_prev, x_prev;
79 c1[0] = c_prev = double(c[0]) /
b[0];
80 d1[0] = d_prev = double(d[0]) /
b[0];
82 for (i = 1; i < count; i++) {
83 double denum =
b[i] - a[i] * c_prev;
85 c1[i] = c_prev = c[i] / denum;
86 d1[i] = d_prev = (d[i] - a[i] * d_prev) / denum;
92 r_x[--i] =
float(x_prev);
95 x_prev = d1[i] - c1[i] * x_prev;
96 r_x[i] =
float(x_prev);
101 return isfinite(x_prev);
105 const float *a,
const float *
b,
const float *c,
const float *d,
float *r_x,
const int count)
113 r_x[0] = d[0] / (a[0] +
b[0] + c[0]);
115 return isfinite(r_x[0]);
120 const float a2[2] = {0, a[1] + c[1]};
121 const float c2[2] = {a[0] + c[0], 0};
127 float a0 = a[0], cN = c[count - 1];
129 if (a0 == 0.0f && cN == 0.0f) {
133 size_t bytes =
sizeof(
float) *
uint(count);
138 float *b2 = tmp + count;
141 memcpy(b2,
b, bytes);
145 memset(tmp, 0, bytes);
155 float coeff = (r_x[0] + r_x[count - 1]) / (1.0f + tmp[0] + tmp[count - 1]);
157 for (
int i = 0; i < count; i++) {
158 r_x[i] -= coeff * tmp[i];
174 const float x_init[3],
177 float fdelta[3], fdeltav, next_fdeltav;
178 float jacobian[3][3],
step[3],
x[3], x_next[3];
184 func_delta(userdata,
x, fdelta);
188 printf(
"START (%g, %g, %g) %g %g\n",
x[0],
x[1],
x[2], fdeltav, epsilon);
191 for (
int i = 0; i == 0 || (i < max_iterations && fdeltav > epsilon); i++) {
193 func_jacobian(userdata,
x, jacobian);
203 if (func_correction) {
205 printf(
"%3d * (%g, %g, %g)\n", i, x_next[0], x_next[1], x_next[2]);
208 if (!func_correction(userdata,
x,
step, x_next)) {
213 func_delta(userdata, x_next, fdelta);
217 printf(
"%3d ? (%g, %g, %g) %g\n", i, x_next[0], x_next[1], x_next[2], next_fdeltav);
221 while (next_fdeltav > fdeltav && next_fdeltav > epsilon) {
222 float g0 =
sqrtf(fdeltav), g1 =
sqrtf(next_fdeltav);
224 float det = 2.0f * (g1 - g0 - g01);
225 float l = (det == 0.0f) ? 0.1f : -g01 / det;
231 func_delta(userdata, x_next, fdelta);
235 printf(
"%3d . (%g, %g, %g) %g\n", i, x_next[0], x_next[1], x_next[2], next_fdeltav);
240 fdeltav = next_fdeltav;
243 bool success = (fdeltav <= epsilon);
246 printf(
"%s (%g, %g, %g) %g\n", success ?
"OK " :
"FAIL",
x[0],
x[1],
x[2], fdeltav);
Read Blender memory allocation and freeing.
bool EIG_self_adjoint_eigen_solve(const int size, const float *matrix, float *r_eigen_values, float *r_eigen_vectors)
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
bool BLI_tridiagonal_solve_cyclic(const float *a, const float *b, const float *c, const float *d, float *r_x, int count)
Solve a possibly cyclic tridiagonal system using the Sherman-Morrison formula.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void(*) Newton3D_DeltaFunc(void *userdata, const float x[3], float r_delta[3])
MINLINE void copy_v3_v3(float r[3], const float a[3])
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
ATTR_WARN_UNUSED_RESULT const BMLoop * l
bool BLI_tridiagonal_solve(const float *a, const float *b, const float *c, const float *d, float *r_x, int count)
Solve a tridiagonal system of equations:
void BLI_svd_m3(const float m3[3][3], float r_U[3][3], float r_S[3], float r_V[3][3])
Compute the SVD (Singular Values Decomposition) of given 3D matrix (m3 = USV*).
MINLINE void mul_v3_fl(float r[3], float f)
MINLINE float len_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT
bool BLI_newton3d_solve(Newton3D_DeltaFunc func_delta, Newton3D_JacobianFunc func_jacobian, Newton3D_CorrectionFunc func_correction, void *userdata, float epsilon, int max_iterations, bool trace, const float x_init[3], float result[3])
Solve a generic f(x) = 0 equation using Newton's method.
bool BLI_eigen_solve_selfadjoint_m3(const float m3[3][3], float r_eigen_values[3], float r_eigen_vectors[3][3])
Compute the eigen values and/or vectors of given 3D symmetric (aka adjoint) matrix.
void(*) Newton3D_JacobianFunc(void *userdata, const float x[3], float r_jacobian[3][3])
bool(*) Newton3D_CorrectionFunc(void *userdata, const float x[3], float step[3], float x_next[3])
bool invert_m3(float mat[3][3])
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
MINLINE float len_squared_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
void mul_v3_m3v3(float r[3], const float M[3][3], const float a[3])
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
void EIG_svd_square_matrix(const int size, const float *matrix, float *r_U, float *r_S, float *r_V)