const Vector & DOF_Group::getDampingBetaForce(int mode, double beta) { // to return beta * M * phi(mode) const Matrix & mass = myNode->getMass(); const Matrix & eigenVectors = myNode->getEigenvectors(); int numDOF = eigenVectors.noRows(); Vector eigenvector(numDOF); for (int i=0; i<numDOF; i++) eigenvector(i) = eigenVectors(i,mode); unbalance->addMatrixVector(0.0, mass, eigenvector, -beta); return *unbalance; }
void FaceOffDriver::intersection_point( const std::vector<Vec3d>& triangle_normals, const std::vector<double>& triangle_plane_distances, const std::vector<double>& triangle_areas, const std::vector<size_t>& incident_triangles, Vec3d& out ) { std::vector< Vec3d > N; std::vector< double > W; std::vector< double > d; for ( size_t i = 0; i < incident_triangles.size(); ++i ) { size_t triangle_index = incident_triangles[i]; N.push_back( triangle_normals[triangle_index] ); W.push_back( triangle_areas[triangle_index] ); d.push_back( triangle_plane_distances[triangle_index] ); } Mat33d A(0,0,0,0,0,0,0,0,0); Vec3d b(0,0,0); compute_quadric_metric_tensor( triangle_normals, triangle_areas, incident_triangles, A ); for ( size_t i = 0; i < N.size(); ++i ) { b[0] += N[i][0] * W[i] * d[i]; b[1] += N[i][1] * W[i] * d[i]; b[2] += N[i][2] * W[i] * d[i]; } double eigenvalues[3]; double work[9]; int info = ~0, n = 3, lwork = 9; LAPACK::get_eigen_decomposition( &n, A.a, &n, eigenvalues, work, &lwork, &info ); if ( info != 0 ) { assert(0); } Vec3d displacement_vector(0,0,0); for ( unsigned int i = 0; i < 3; ++i ) { if ( eigenvalues[i] > G_EIGENVALUE_RANK_RATIO * eigenvalues[2] ) { Vec3d eigenvector( A(0,i), A(1,i), A(2,i) ); displacement_vector += dot(eigenvector, b) * eigenvector / eigenvalues[i]; } } out = displacement_vector; }
void DOF_Group::setEigenvector(int mode, const Vector &theVector) { if (myNode == 0) { opserr << "DOF_Group::setNodeAccel: 0 Node Pointer\n"; exit(-1); } Vector &eigenvector = *unbalance; int i; // get disp for the unconstrained dof for (i=0; i<numDOF; i++) { int loc = myID(i); if (loc >= 0) eigenvector(i) = theVector(loc); else eigenvector(i) = 0.0; } myNode->setEigenvector(mode, eigenvector); }
int main() { m_type u(10, 10), f(10, 10); u= 0.0; u(1, 1) = 1.0 ; v_type eigenvector(n); glas::random(eigenvector, seed); poisson_matvec()(u, f); return 0; }
/*! gts_vertex_principal_directions: * @v: a #WVertex. * @s: a #GtsSurface. * @Kh: mean curvature normal (a #Vec3r). * @Kg: Gaussian curvature (a real). * @e1: first principal curvature direction (direction of largest curvature). * @e2: second principal curvature direction. * * Computes the principal curvature directions at a point given @Kh and @Kg, the mean curvature normal and * Gaussian curvatures at that point, computed with gts_vertex_mean_curvature_normal() and * gts_vertex_gaussian_curvature(), respectively. * * Note that this computation is very approximate and tends to be unstable. Smoothing of the surface or the principal * directions may be necessary to achieve reasonable results. */ void gts_vertex_principal_directions(WVertex *v, Vec3r Kh, real Kg, Vec3r &e1, Vec3r &e2) { Vec3r N; real normKh; Vec3r basis1, basis2, d, eig; real ve2, vdotN; real aterm_da, bterm_da, cterm_da, const_da; real aterm_db, bterm_db, cterm_db, const_db; real a, b, c; real K1, K2; real *weights, *kappas, *d1s, *d2s; int edge_count; real err_e1, err_e2; int e; WVertex::incoming_edge_iterator itE; /* compute unit normal */ normKh = Kh.norm(); if (normKh > 0.0) { Kh.normalize(); } else { /* This vertex is a point of zero mean curvature (flat or saddle point). Compute a normal by averaging * the adjacent triangles */ N[0] = N[1] = N[2] = 0.0; for (itE = v->incoming_edges_begin(); itE != v->incoming_edges_end(); itE++) N = Vec3r(N + (*itE)->GetaFace()->GetNormal()); real normN = N.norm(); if (normN <= 0.0) return; N.normalize(); } /* construct a basis from N: */ /* set basis1 to any component not the largest of N */ basis1[0] = basis1[1] = basis1[2] = 0.0; if (fabs (N[0]) > fabs (N[1])) basis1[1] = 1.0; else basis1[0] = 1.0; /* make basis2 orthogonal to N */ basis2 = (N ^ basis1); basis2.normalize(); /* make basis1 orthogonal to N and basis2 */ basis1 = (N ^ basis2); basis1.normalize(); aterm_da = bterm_da = cterm_da = const_da = 0.0; aterm_db = bterm_db = cterm_db = const_db = 0.0; int nb_edges = v->GetEdges().size(); weights = (real *)malloc(sizeof(real) * nb_edges); kappas = (real *)malloc(sizeof(real) * nb_edges); d1s = (real *)malloc(sizeof(real) * nb_edges); d2s = (real *)malloc(sizeof(real) * nb_edges); edge_count = 0; for (itE = v->incoming_edges_begin(); itE != v->incoming_edges_end(); itE++) { WOEdge *e; WFace *f1, *f2; real weight, kappa, d1, d2; Vec3r vec_edge; if (!*itE) continue; e = *itE; /* since this vertex passed the tests in gts_vertex_mean_curvature_normal(), this should be true. */ //g_assert(gts_edge_face_number (e, s) == 2); /* identify the two triangles bordering e in s */ f1 = e->GetaFace(); f2 = e->GetbFace(); /* We are solving for the values of the curvature tensor * B = [ a b ; b c ]. * The computations here are from section 5 of [Meyer et al 2002]. * * The first step is to calculate the linear equations governing the values of (a,b,c). These can be computed * by setting the derivatives of the error E to zero (section 5.3). * * Since a + c = norm(Kh), we only compute the linear equations for dE/da and dE/db. (NB: [Meyer et al 2002] * has the equation a + b = norm(Kh), but I'm almost positive this is incorrect). * * Note that the w_ij (defined in section 5.2) are all scaled by (1/8*A_mixed). We drop this uniform scale * factor because the solution of the linear equations doesn't rely on it. * * The terms of the linear equations are xterm_dy with x in {a,b,c} and y in {a,b}. There are also const_dy * terms that are the constant factors in the equations. */ /* find the vector from v along edge e */ vec_edge = Vec3r(-1 * e->GetVec()); ve2 = vec_edge.squareNorm(); vdotN = vec_edge * N; /* section 5.2 - There is a typo in the computation of kappa. The edges should be x_j-x_i. */ kappa = 2.0 * vdotN / ve2; /* section 5.2 */ /* I don't like performing a minimization where some of the weights can be negative (as can be the case * if f1 or f2 are obtuse). To ensure all-positive weights, we check for obtuseness. */ weight = 0.0; if (!triangle_obtuse(v, f1)) { weight += ve2 * cotan(f1->GetNextOEdge(e->twin())->GetbVertex(), e->GetaVertex(), e->GetbVertex()) / 8.0; } else { if (angle_obtuse(v, f1)) { weight += ve2 * f1->getArea() / 4.0; } else { weight += ve2 * f1->getArea() / 8.0; } } if (!triangle_obtuse(v, f2)) { weight += ve2 * cotan (f2->GetNextOEdge(e)->GetbVertex(), e->GetaVertex(), e->GetbVertex()) / 8.0; } else { if (angle_obtuse(v, f2)) { weight += ve2 * f1->getArea() / 4.0; } else { weight += ve2 * f1->getArea() / 8.0; } } /* projection of edge perpendicular to N (section 5.3) */ d[0] = vec_edge[0] - vdotN * N[0]; d[1] = vec_edge[1] - vdotN * N[1]; d[2] = vec_edge[2] - vdotN * N[2]; d.normalize(); /* not explicit in the paper, but necessary. Move d to 2D basis. */ d1 = d * basis1; d2 = d * basis2; /* store off the curvature, direction of edge, and weights for later use */ weights[edge_count] = weight; kappas[edge_count] = kappa; d1s[edge_count] = d1; d2s[edge_count] = d2; edge_count++; /* Finally, update the linear equations */ aterm_da += weight * d1 * d1 * d1 * d1; bterm_da += weight * d1 * d1 * 2 * d1 * d2; cterm_da += weight * d1 * d1 * d2 * d2; const_da += weight * d1 * d1 * (-kappa); aterm_db += weight * d1 * d2 * d1 * d1; bterm_db += weight * d1 * d2 * 2 * d1 * d2; cterm_db += weight * d1 * d2 * d2 * d2; const_db += weight * d1 * d2 * (-kappa); } /* now use the identity (Section 5.3) a + c = |Kh| = 2 * kappa_h */ aterm_da -= cterm_da; const_da += cterm_da * normKh; aterm_db -= cterm_db; const_db += cterm_db * normKh; /* check for solvability of the linear system */ if (((aterm_da * bterm_db - aterm_db * bterm_da) != 0.0) && ((const_da != 0.0) || (const_db != 0.0))) { linsolve(aterm_da, bterm_da, -const_da, aterm_db, bterm_db, -const_db, &a, &b); c = normKh - a; eigenvector(a, b, c, eig); } else { /* region of v is planar */ eig[0] = 1.0; eig[1] = 0.0; } /* Although the eigenvectors of B are good estimates of the principal directions, it seems that which one is * attached to which curvature direction is a bit arbitrary. This may be a bug in my implementation, or just * a side-effect of the inaccuracy of B due to the discrete nature of the sampling. * * To overcome this behavior, we'll evaluate which assignment best matches the given eigenvectors by comparing * the curvature estimates computed above and the curvatures calculated from the discrete differential operators. */ gts_vertex_principal_curvatures(0.5 * normKh, Kg, &K1, &K2); err_e1 = err_e2 = 0.0; /* loop through the values previously saved */ for (e = 0; e < edge_count; e++) { real weight, kappa, d1, d2; real temp1, temp2; real delta; weight = weights[e]; kappa = kappas[e]; d1 = d1s[e]; d2 = d2s[e]; temp1 = fabs (eig[0] * d1 + eig[1] * d2); temp1 = temp1 * temp1; temp2 = fabs (eig[1] * d1 - eig[0] * d2); temp2 = temp2 * temp2; /* err_e1 is for K1 associated with e1 */ delta = K1 * temp1 + K2 * temp2 - kappa; err_e1 += weight * delta * delta; /* err_e2 is for K1 associated with e2 */ delta = K2 * temp1 + K1 * temp2 - kappa; err_e2 += weight * delta * delta; } free (weights); free (kappas); free (d1s); free (d2s); /* rotate eig by a right angle if that would decrease the error */ if (err_e2 < err_e1) { real temp = eig[0]; eig[0] = eig[1]; eig[1] = -temp; } e1[0] = eig[0] * basis1[0] + eig[1] * basis2[0]; e1[1] = eig[0] * basis1[1] + eig[1] * basis2[1]; e1[2] = eig[0] * basis1[2] + eig[1] * basis2[2]; e1.normalize(); /* make N,e1,e2 a right handed coordinate sytem */ e2 = N ^ e1; e2.normalize(); }
/** * gts_vertex_principal_directions: * @v: a #GtsVertex. * @s: a #GtsSurface. * @Kh: mean curvature normal (a #GtsVector). * @Kg: Gaussian curvature (a gdouble). * @e1: first principal curvature direction (direction of largest curvature). * @e2: second principal curvature direction. * * Computes the principal curvature directions at a point given @Kh * and @Kg, the mean curvature normal and Gaussian curvatures at that * point, computed with gts_vertex_mean_curvature_normal() and * gts_vertex_gaussian_curvature(), respectively. * * Note that this computation is very approximate and tends to be * unstable. Smoothing of the surface or the principal directions may * be necessary to achieve reasonable results. */ void gts_vertex_principal_directions (GtsVertex * v, GtsSurface * s, GtsVector Kh, gdouble Kg, GtsVector e1, GtsVector e2) { GtsVector N; gdouble normKh; GSList * i, * j; GtsVector basis1, basis2, d, eig; gdouble ve2, vdotN; gdouble aterm_da, bterm_da, cterm_da, const_da; gdouble aterm_db, bterm_db, cterm_db, const_db; gdouble a, b, c; gdouble K1, K2; gdouble *weights, *kappas, *d1s, *d2s; gint edge_count; gdouble err_e1, err_e2; int e; /* compute unit normal */ normKh = sqrt (gts_vector_scalar (Kh, Kh)); if (normKh > 0.0) { N[0] = Kh[0] / normKh; N[1] = Kh[1] / normKh; N[2] = Kh[2] / normKh; } else { /* This vertex is a point of zero mean curvature (flat or saddle * point). Compute a normal by averaging the adjacent triangles */ N[0] = N[1] = N[2] = 0.0; i = gts_vertex_faces (v, s, NULL); while (i) { gdouble x, y, z; gts_triangle_normal (GTS_TRIANGLE ((GtsFace *) i->data), &x, &y, &z); N[0] += x; N[1] += y; N[2] += z; i = i->next; } g_return_if_fail (gts_vector_norm (N) > 0.0); gts_vector_normalize (N); } /* construct a basis from N: */ /* set basis1 to any component not the largest of N */ basis1[0] = basis1[1] = basis1[2] = 0.0; if (fabs (N[0]) > fabs (N[1])) basis1[1] = 1.0; else basis1[0] = 1.0; /* make basis2 orthogonal to N */ gts_vector_cross (basis2, N, basis1); gts_vector_normalize (basis2); /* make basis1 orthogonal to N and basis2 */ gts_vector_cross (basis1, N, basis2); gts_vector_normalize (basis1); aterm_da = bterm_da = cterm_da = const_da = 0.0; aterm_db = bterm_db = cterm_db = const_db = 0.0; weights = g_malloc (sizeof (gdouble)*g_slist_length (v->segments)); kappas = g_malloc (sizeof (gdouble)*g_slist_length (v->segments)); d1s = g_malloc (sizeof (gdouble)*g_slist_length (v->segments)); d2s = g_malloc (sizeof (gdouble)*g_slist_length (v->segments)); edge_count = 0; i = v->segments; while (i) { GtsEdge * e; GtsFace * f1, * f2; gdouble weight, kappa, d1, d2; GtsVector vec_edge; if (! GTS_IS_EDGE (i->data)) { i = i->next; continue; } e = i->data; /* since this vertex passed the tests in * gts_vertex_mean_curvature_normal(), this should be true. */ g_assert (gts_edge_face_number (e, s) == 2); /* identify the two triangles bordering e in s */ f1 = f2 = NULL; j = e->triangles; while (j) { if ((! GTS_IS_FACE (j->data)) || (! gts_face_has_parent_surface (GTS_FACE (j->data), s))) { j = j->next; continue; } if (f1 == NULL) f1 = GTS_FACE (j->data); else { f2 = GTS_FACE (j->data); break; } j = j->next; } g_assert (f2 != NULL); /* We are solving for the values of the curvature tensor * B = [ a b ; b c ]. * The computations here are from section 5 of [Meyer et al 2002]. * * The first step is to calculate the linear equations governing * the values of (a,b,c). These can be computed by setting the * derivatives of the error E to zero (section 5.3). * * Since a + c = norm(Kh), we only compute the linear equations * for dE/da and dE/db. (NB: [Meyer et al 2002] has the * equation a + b = norm(Kh), but I'm almost positive this is * incorrect.) * * Note that the w_ij (defined in section 5.2) are all scaled by * (1/8*A_mixed). We drop this uniform scale factor because the * solution of the linear equations doesn't rely on it. * * The terms of the linear equations are xterm_dy with x in * {a,b,c} and y in {a,b}. There are also const_dy terms that are * the constant factors in the equations. */ /* find the vector from v along edge e */ gts_vector_init (vec_edge, GTS_POINT (v), GTS_POINT ((GTS_SEGMENT (e)->v1 == v) ? GTS_SEGMENT (e)->v2 : GTS_SEGMENT (e)->v1)); ve2 = gts_vector_scalar (vec_edge, vec_edge); vdotN = gts_vector_scalar (vec_edge, N); /* section 5.2 - There is a typo in the computation of kappa. The * edges should be x_j-x_i. */ kappa = 2.0 * vdotN / ve2; /* section 5.2 */ /* I don't like performing a minimization where some of the * weights can be negative (as can be the case if f1 or f2 are * obtuse). To ensure all-positive weights, we check for * obtuseness and use values similar to those in region_area(). */ weight = 0.0; if (! triangle_obtuse(v, f1)) { weight += ve2 * cotan (gts_triangle_vertex_opposite (GTS_TRIANGLE (f1), e), GTS_SEGMENT (e)->v1, GTS_SEGMENT (e)->v2) / 8.0; } else { if (angle_obtuse (v, f1)) { weight += ve2 * gts_triangle_area (GTS_TRIANGLE (f1)) / 4.0; } else { weight += ve2 * gts_triangle_area (GTS_TRIANGLE (f1)) / 8.0; } } if (! triangle_obtuse(v, f2)) { weight += ve2 * cotan (gts_triangle_vertex_opposite (GTS_TRIANGLE (f2), e), GTS_SEGMENT (e)->v1, GTS_SEGMENT (e)->v2) / 8.0; } else { if (angle_obtuse (v, f2)) { weight += ve2 * gts_triangle_area (GTS_TRIANGLE (f2)) / 4.0; } else { weight += ve2 * gts_triangle_area (GTS_TRIANGLE (f2)) / 8.0; } } /* projection of edge perpendicular to N (section 5.3) */ d[0] = vec_edge[0] - vdotN * N[0]; d[1] = vec_edge[1] - vdotN * N[1]; d[2] = vec_edge[2] - vdotN * N[2]; gts_vector_normalize (d); /* not explicit in the paper, but necessary. Move d to 2D basis. */ d1 = gts_vector_scalar (d, basis1); d2 = gts_vector_scalar (d, basis2); /* store off the curvature, direction of edge, and weights for later use */ weights[edge_count] = weight; kappas[edge_count] = kappa; d1s[edge_count] = d1; d2s[edge_count] = d2; edge_count++; /* Finally, update the linear equations */ aterm_da += weight * d1 * d1 * d1 * d1; bterm_da += weight * d1 * d1 * 2 * d1 * d2; cterm_da += weight * d1 * d1 * d2 * d2; const_da += weight * d1 * d1 * (- kappa); aterm_db += weight * d1 * d2 * d1 * d1; bterm_db += weight * d1 * d2 * 2 * d1 * d2; cterm_db += weight * d1 * d2 * d2 * d2; const_db += weight * d1 * d2 * (- kappa); i = i->next; } /* now use the identity (Section 5.3) a + c = |Kh| = 2 * kappa_h */ aterm_da -= cterm_da; const_da += cterm_da * normKh; aterm_db -= cterm_db; const_db += cterm_db * normKh; /* check for solvability of the linear system */ if (((aterm_da * bterm_db - aterm_db * bterm_da) != 0.0) && ((const_da != 0.0) || (const_db != 0.0))) { linsolve (aterm_da, bterm_da, -const_da, aterm_db, bterm_db, -const_db, &a, &b); c = normKh - a; eigenvector (a, b, c, eig); } else { /* region of v is planar */ eig[0] = 1.0; eig[1] = 0.0; } /* Although the eigenvectors of B are good estimates of the * principal directions, it seems that which one is attached to * which curvature direction is a bit arbitrary. This may be a bug * in my implementation, or just a side-effect of the inaccuracy of * B due to the discrete nature of the sampling. * * To overcome this behavior, we'll evaluate which assignment best * matches the given eigenvectors by comparing the curvature * estimates computed above and the curvatures calculated from the * discrete differential operators. */ gts_vertex_principal_curvatures (0.5 * normKh, Kg, &K1, &K2); err_e1 = err_e2 = 0.0; /* loop through the values previously saved */ for (e = 0; e < edge_count; e++) { gdouble weight, kappa, d1, d2; gdouble temp1, temp2; gdouble delta; weight = weights[e]; kappa = kappas[e]; d1 = d1s[e]; d2 = d2s[e]; temp1 = fabs (eig[0] * d1 + eig[1] * d2); temp1 = temp1 * temp1; temp2 = fabs (eig[1] * d1 - eig[0] * d2); temp2 = temp2 * temp2; /* err_e1 is for K1 associated with e1 */ delta = K1 * temp1 + K2 * temp2 - kappa; err_e1 += weight * delta * delta; /* err_e2 is for K1 associated with e2 */ delta = K2 * temp1 + K1 * temp2 - kappa; err_e2 += weight * delta * delta; } g_free (weights); g_free (kappas); g_free (d1s); g_free (d2s); /* rotate eig by a right angle if that would decrease the error */ if (err_e2 < err_e1) { gdouble temp = eig[0]; eig[0] = eig[1]; eig[1] = -temp; } e1[0] = eig[0] * basis1[0] + eig[1] * basis2[0]; e1[1] = eig[0] * basis1[1] + eig[1] * basis2[1]; e1[2] = eig[0] * basis1[2] + eig[1] * basis2[2]; gts_vector_normalize (e1); /* make N,e1,e2 a right handed coordinate sytem */ gts_vector_cross (e2, N, e1); gts_vector_normalize (e2); }
void Rotation_matrix(double **experiment_matrix,char base,double ** rotation_matrix) { int N; double ** strandard_matrix; double ** covariance_matrix; double ** symmetric_matrix; double * eigenvector_matrix; eigenvector_matrix=dvector(0,3); covariance_matrix=dmatrix(0,2,0,2); symmetric_matrix=dmatrix(0,3,0,3); // switch(base) { case 'A': N=9; strandard_matrix=dmatrix(0,N-1,0,3); for(int i=0; i<N; i++) { for(int j=0; j<3; j++) { strandard_matrix[i][j]=A_origin[i][j]; } } break; case 'C': N=6; strandard_matrix=dmatrix(0,N-1,0,3); for(int i=0; i<N; i++) { for(int j=0; j<3; j++) { strandard_matrix[i][j]=C_origin[i][j]; } } break; case 'G': N=9; strandard_matrix=dmatrix(0,N-1,0,3); for(int i=0; i<N; i++) { for(int j=0; j<3; j++) { strandard_matrix[i][j]=G_origin[i][j]; } } break; case 'T': N=6; strandard_matrix=dmatrix(0,N-1,0,3); for(int i=0; i<N; i++) { for(int j=0; j<3; j++) { strandard_matrix[i][j]=T_origin[i][j]; } } break; case 'U': N=6; strandard_matrix=dmatrix(0,N-1,0,3); for(int i=0; i<N; i++) { for(int j=0; j<3; j++) { strandard_matrix[i][j]=U_origin[i][j]; } } break; default: break; } //create the covariance matrix double s_sum_x=0,s_sum_y=0,s_sum_z=0; double e_sum_x=0,e_sum_y=0,e_sum_z=0; double ** se; double **siie; se=dmatrix(0,2,0,2); siie=dmatrix(0,2,0,2); for(int i=0; i<3; i++) { for(int j=0; j<3; j++) { se[i][j]=0; } } for(int m=0; m<3; m++) { for(int n=0; n<3; n++) { for(int t=0; t<N; t++) { se[m][n]+=(strandard_matrix[t][m]*experiment_matrix[t][n]); } // cout<<se[m][n]<<endl; } } for(int i=0; i<N; i++) { s_sum_x+=strandard_matrix[i][0]; //cout<<s_sum_x<<endl; s_sum_y+=strandard_matrix[i][1]; s_sum_z+=strandard_matrix[i][2]; e_sum_x+=experiment_matrix[i][0]; // cout<<e_sum_x<<endl; e_sum_y+=experiment_matrix[i][1]; e_sum_z+=experiment_matrix[i][2]; } siie[0][0]=s_sum_x*e_sum_x/N; //cout<<siie[0][0]<<endl; siie[0][1]=s_sum_x*e_sum_y/N; siie[0][2]=s_sum_x*e_sum_z/N; siie[1][0]=s_sum_y*e_sum_x/N; siie[1][1]=s_sum_y*e_sum_y/N; siie[1][2]=s_sum_y*e_sum_z/N; siie[2][0]=s_sum_z*e_sum_x/N; siie[2][1]=s_sum_z*e_sum_y/N; siie[2][2]=s_sum_z*e_sum_z/N; for(int i=0; i<3; i++) { for(int j=0; j<3; j++) { covariance_matrix[i][j]=(se[i][j]-siie[i][j])/(N-1); // cout<<covariance_matrix[i][j]<<endl; } } symmetric_matrix[0][0]=covariance_matrix[0][0]+covariance_matrix[1][1]+covariance_matrix[2][2]; symmetric_matrix[0][1]=covariance_matrix[1][2]-covariance_matrix[2][1]; symmetric_matrix[0][2]=covariance_matrix[2][0]-covariance_matrix[0][2]; symmetric_matrix[0][3]=covariance_matrix[0][1]-covariance_matrix[1][0]; symmetric_matrix[1][0]=covariance_matrix[1][2]-covariance_matrix[2][1]; symmetric_matrix[1][1]=covariance_matrix[0][0]-covariance_matrix[1][1]-covariance_matrix[2][2]; symmetric_matrix[1][2]=covariance_matrix[0][1]+covariance_matrix[1][0]; symmetric_matrix[1][3]=covariance_matrix[2][0]+covariance_matrix[0][2]; symmetric_matrix[2][0]=covariance_matrix[2][0]-covariance_matrix[0][2]; symmetric_matrix[2][1]=covariance_matrix[0][1]+covariance_matrix[1][0]; symmetric_matrix[2][2]=-covariance_matrix[0][0]+covariance_matrix[1][1]-covariance_matrix[2][2]; symmetric_matrix[2][3]=covariance_matrix[1][2]+covariance_matrix[2][1]; symmetric_matrix[3][0]=covariance_matrix[0][1]-covariance_matrix[1][0]; symmetric_matrix[3][1]=covariance_matrix[2][0]+covariance_matrix[0][2]; symmetric_matrix[3][2]=covariance_matrix[1][2]+covariance_matrix[2][1]; symmetric_matrix[3][3]=-covariance_matrix[0][0]-covariance_matrix[1][1]+covariance_matrix[2][2]; double eigenva=eigenvalue(symmetric_matrix,4); eigenvector(symmetric_matrix,4,eigenva,eigenvector_matrix); rotation_matrix[0][0]=eigenvector_matrix[0]*eigenvector_matrix[0]+eigenvector_matrix[1]*eigenvector_matrix[1]-eigenvector_matrix[2]*eigenvector_matrix[2]-eigenvector_matrix[3]*eigenvector_matrix[3]; rotation_matrix[0][1]=2*(eigenvector_matrix[1]*eigenvector_matrix[2]-eigenvector_matrix[0]*eigenvector_matrix[3]); rotation_matrix[0][2]=2*(eigenvector_matrix[1]*eigenvector_matrix[3]+eigenvector_matrix[0]*eigenvector_matrix[2]); rotation_matrix[1][0]=2*(eigenvector_matrix[2]*eigenvector_matrix[1]+eigenvector_matrix[0]*eigenvector_matrix[3]); rotation_matrix[1][1]=eigenvector_matrix[0]*eigenvector_matrix[0]-eigenvector_matrix[1]*eigenvector_matrix[1]+eigenvector_matrix[2]*eigenvector_matrix[2]-eigenvector_matrix[3]*eigenvector_matrix[3]; rotation_matrix[1][2]=2*(eigenvector_matrix[2]*eigenvector_matrix[3]-eigenvector_matrix[0]*eigenvector_matrix[1]); rotation_matrix[2][0]=2*(eigenvector_matrix[3]*eigenvector_matrix[1]-eigenvector_matrix[0]*eigenvector_matrix[2]); rotation_matrix[2][1]=2*(eigenvector_matrix[3]*eigenvector_matrix[2]+eigenvector_matrix[0]*eigenvector_matrix[1]); rotation_matrix[2][2]=eigenvector_matrix[0]*eigenvector_matrix[0]-eigenvector_matrix[1]*eigenvector_matrix[1]-eigenvector_matrix[2]*eigenvector_matrix[2]+eigenvector_matrix[3]*eigenvector_matrix[3]; }