void solve_direct_methods() { unsigned int dimension; #if DEBUG int k; #endif double *vector_temp = NULL; //printf("\n\nSolving (Forward/Backward) ...\n\n"); dimension = circuit_simulation.number_of_nodes + circuit_simulation.group2_elements; if (circuit_simulation.matrix_sparsity == SPARSE) { vector_temp = ( double * ) calloc( dimension, sizeof(double) ); if (vector_temp == NULL) { printf( "Could not allocate matrices.\n" ); printf( "Terminating.\n" ); exit( -1 ); } memcpy( vector_x, vector_b, dimension * sizeof(double) ); if (circuit_simulation.matrix_type == NONSPD) { /*Forward Backward LU*/ cs_di_ipvec( N->pinv, vector_x, vector_temp, dimension ); cs_di_lsolve( N->L, vector_temp ); cs_di_usolve( N->U, vector_temp ); cs_di_ipvec( S->q, vector_temp, vector_x, dimension ); } else {/*Forward Backward Cholesky*/ cs_di_ipvec( S->pinv, vector_x, vector_temp, dimension ); cs_di_lsolve( N->L, vector_temp ); cs_di_ltsolve( N->L, vector_temp ); cs_di_pvec( S->pinv, vector_temp, vector_x, dimension ); } free( vector_temp ); } else { forward_substitution(); backward_substitution(); } #if DEBUG printf("\nVector x:\n\n"); for(k = 0; k < dimension; k++) { printf("%12lf\n", vector_x[k]); } printf("\n\n"); #endif }
vec ls_solve(const mat &L, int p, const mat &U, int q, const vec &b) { vec x(L.rows()); forward_substitution(L, p, b, x); // Solve Ly=b, Here y=x backward_substitution(U, q, x, x); // Solve Ux=y, Here x=y return x; }
// simultaneous linear equation void solute_SLE_with_n_variables(double coefficient_matrix[N][N], double right_hand_vector[N], double solution_vector[N]){ double l_matrix[N][N] = {0}; double u_matrix[N][N] = {0}; double mid_solution_vector[N]; lu_decomposition(coefficient_matrix, l_matrix, u_matrix); forward_substitution(l_matrix, right_hand_vector, mid_solution_vector); backward_substitution(u_matrix, mid_solution_vector, solution_vector); }
void LU_solve(const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x) { DenseMatrix L = DenseMatrix(A.nrows(), A.ncols()); DenseMatrix U = DenseMatrix(A.nrows(), A.ncols()); DenseMatrix x_ = DenseMatrix(b.nrows(), b.ncols()); LU(A, L, U); forward_substitution(L, b, x_); back_substitution(U, x_, x); }
void fraction_free_LU_solve(const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x) { DenseMatrix LU = DenseMatrix(A.nrows(), A.ncols()); DenseMatrix x_ = DenseMatrix(b.nrows(), b.ncols()); fraction_free_LU(A, LU); forward_substitution(LU, b, x_); back_substitution(LU, x_, x); }
vec forward_substitution(const mat &L, int p, const vec &b) { void forward_substitution(const mat &L, int p, const vec &b, vec &x); int n = L.rows(); vec x(n); forward_substitution(L, p, b, x); return x; }
void pivoted_LU_solve(const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x) { DenseMatrix L = DenseMatrix(A.nrows(), A.ncols()); DenseMatrix U = DenseMatrix(A.nrows(), A.ncols()); DenseMatrix x_ = DenseMatrix(b); permutelist pl; pivoted_LU(A, L, U, pl); permuteFwd(x_, pl); forward_substitution(L, x_, x_); back_substitution(U, x_, x); }
void LDL_solve(const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x) { DenseMatrix L = DenseMatrix(A.nrows(), A.ncols()); DenseMatrix D = DenseMatrix(A.nrows(), A.ncols()); DenseMatrix x_ = DenseMatrix(b.nrows(), b.ncols()); if (not is_symmetric_dense(A)) throw SymEngineException("Matrix must be symmetric"); LDL(A, L, D); forward_substitution(L, b, x); diagonal_solve(D, x, x_); transpose_dense(L, D); back_substitution(D, x_, x); }
void LDL_solve(const DenseMatrix &A, const DenseMatrix &b, DenseMatrix &x) { DenseMatrix L = DenseMatrix(A.nrows(), A.ncols()); DenseMatrix D = DenseMatrix(A.nrows(), A.ncols()); DenseMatrix x_ = DenseMatrix(b.nrows(), 1); if (!is_symmetric_dense(A)) throw std::runtime_error("Matrix must be symmetric"); LDL(A, L, D); forward_substitution(L, b, x); diagonal_solve(D, x, x_); transpose_dense(L, D); back_substitution(D, x_, x); }
void inverse_LU(const DenseMatrix &A, DenseMatrix &B) { SYMENGINE_ASSERT(A.row_ == A.col_ and B.row_ == B.col_ and B.row_ == A.row_); unsigned n = A.row_, i; DenseMatrix L = DenseMatrix(n, n); DenseMatrix U = DenseMatrix(n, n); DenseMatrix e = DenseMatrix(n, 1); DenseMatrix x = DenseMatrix(n, 1); DenseMatrix x_ = DenseMatrix(n, 1); // Initialize matrices for (i = 0; i < n * n; i++) { L.m_[i] = zero; U.m_[i] = zero; B.m_[i] = zero; } for (i = 0; i < n; i++) { e.m_[i] = zero; x.m_[i] = zero; x_.m_[i] = zero; } LU(A, L, U); // We solve AX_{i} = e_{i} for i = 1, 2, .. n and combine the column vectors // X_{1}, X_{2}, ... X_{n} to form the inverse of A. Here, e_{i}'s are the // elements of the standard basis. for (unsigned j = 0; j < n; j++) { e.m_[j] = one; forward_substitution(L, e, x_); back_substitution(U, x_, x); for (i = 0; i < n; i++) B.m_[i * n + j] = x.m_[i]; e.m_[j] = zero; } }
int lu_solver( const matrix<T1,D1,A1>& A, matrix<T2,D2,A2>& x, const matrix<T3,D3,A3>& b ) { typedef matrix<T1,D1,A1> matrix_type; //typedef typename matrix_type::value_type value_type; typedef typename matrix_type::size_type size_type; assert( A.row() == A.col() ); assert( A.row() == b.row() ); assert( b.col() == 1 ); size_type const n = A.row(); matrix_type L, U; // if lu decomposition failed, return if ( lu_decomposition( A, L, U ) ) return 1; matrix_type Y; if( forward_substitution( L, Y, b ) ) return 1; // solve LY=b if( backward_substitution( U, x, Y )) return 1; //solve Ux=Y return 0; }
/*! The type of preconditioner is asked by the user at the runtime*/ void Iterative_Solver::BiCG_preconditioner(SparseMatrix & spm, Vector<double> & X, Vector <double> & B, int choice){ int number_of_iterations = 0; // cout << "Reached Here" << endl; Vector<double> Q; Q.set_size(X.get_size()); Q.initialize(); spm.multiply(X,Q); // Q = spm*X; Vector<double> r; r.set_size(X.get_size()); r.sub(B,Q); // r = B - Q; Vector<double> r_star; r_star.set_size(X.get_size()); r_star.copy_values(r); double beeta; double alpha = 1.0; double rho = 1.0; double omega = 1.0; // double p1 = 0.0; double error = 199; Vector<double> temp; temp.set_size(X.get_size()); temp.initialize(); Vector<double> p1; p1.set_size(X.get_size()); p1.initialize(); Vector<double> v; v.set_size(X.get_size()); v.initialize(); Vector<double> s; s.set_size(X.get_size()); s.initialize(); Vector<double> t; t.set_size(X.get_size()); t.initialize(); Vector<double> temp1; temp1.set_size(X.get_size()); temp1.initialize(); SparseMatrix M; // cout << "Reached Here" << endl; Vector<double> y; y.set_size(X.get_size()); Vector<double> z; z.set_size(X.get_size()); if (choice == 0){ M.initialize(X.get_size()); M.extractdiagonal(spm); } else if (choice == 1){ M.copy(spm); ILUDecomposition(M); } // cout << "Line 145" << endl; // cout << "Iterations started" << endl; while(error > pow(10.0,-6)){ temp.copy_values(X); // cout << "Line 148" << endl; double rho_1 = r_star*r; // cout << "Line 150" <<endl; beeta = (rho_1/rho)*(alpha/omega); // cout << "Line 151" << endl; temp1.add(p1,v,-omega); // p1 = r + (p1 - v*omega)*beeta; p1.add(r,temp1,beeta); if (choice == 0){ // y.multiply_dot(M,p1); M.multiply(p1,y); // y.display(); } else if(choice == 1){ Vector<double> temp_y; temp_y.set_size(X.get_size()); temp_y.initialize(); forward_substitution(M,temp_y,p1); backward_substitution(M,y,temp_y); } else if(choice == 2){ forward_substitution_Gauss_Siedel(spm,y,p1); } // y.display(); // cout << "Line 153"; spm.multiply(y,v); // v = spm*p1; // cout << "*******" << endl; // v.display(); alpha = rho_1/(r_star*v); // cout << "Line 159"; s.add(r,v,-alpha); // cout << "Line 161"; // s = r - v*alpha; if(choice == 0){ M.multiply(s,z); // z.multiply_dot(M,s); } else if (choice == 1){ Vector<double> temp_z; temp_z.set_size(X.get_size()); temp_z.initialize(); forward_substitution(M,temp_z,s); backward_substitution(M,z,temp_z); } else if(choice == 2){ forward_substitution_Gauss_Siedel(spm,z,s); } spm.multiply(z,t); // t.display(); // cout << "Line 164"; // t = spm*s; double tempval1 = t*s; double tempval2 = t*t; // t.display(); // cout << tempval1 << endl; // cout << tempval2 << endl; omega = (tempval1)/(tempval2); // cout << "Line 167" << endl; // temp1.initialize(); temp1.add(X,y,alpha); X.add(temp1,z,omega); // temp1.initialize(); // X = X + s*omega + p1*alpha; r.add(s,t,-omega); // r = s - t*omega; rho = rho_1; // cout << "Line 189" <<endl; error = cal_error(X,temp); number_of_iterations++; } cout << "number of iterations in BiCG" << number_of_iterations << endl; // M.del(); // cout << "Value from Itsolver" << endl; // B.display(); }
int main(){ int kadai; // 課題番号指定 while(1){ printf("課題番号: "); scanf("%d", &kadai); if (kadai < 1 || kadai > 8 || kadai == 7){ printf("1~8!!\n"); } else { break; } } if (kadai == 1){ double coefficient_mat[N][N] = {{1, 0, 0}, {3, 1, 0}, {-2, 2, 1}}; double right_hand_vec[N] = {2, 3, -1}; double solution_vec[N]; printf("--------------- L行列 ---------------\n"); print_array(coefficient_mat); printf("------------- 右辺ベクトル ------------\n"); print_vector(right_hand_vec); forward_substitution(coefficient_mat, right_hand_vec, solution_vec); printf("------------- 解ベクトル --------------\n"); print_vector(solution_vec); } else if (kadai == 2) { double coefficient_mat[N][N] = {{2, 1, -1}, {0, 3, 2}, {0, 0, -3}}; double right_hand_vec[N] = {2, -3, 9}; double solution_vec[N]; printf("--------------- U行列 ----------------\n"); print_array(coefficient_mat); printf("------------- 右辺ベクトル -------------\n"); print_vector(right_hand_vec); backward_substitution(coefficient_mat, right_hand_vec, solution_vec); printf("-------------- 解ベクトル -------------\n"); print_vector(solution_vec); } else if (kadai == 3) { double coefficient_mat[N][N]; double l_matrix[N][N] = {{1, 0, 0}, {3, 1, 0}, {-2, 2, 1}}; double u_matrix[N][N] = {{2, 1, -1}, {0, 3, 2}, {0, 0, -3}}; mat_mlt(l_matrix, u_matrix, coefficient_mat); printf("---------- 係数行列 ----------\n"); print_array(coefficient_mat); } else if (kadai == 4) { double coefficient_mat[N][N] = {{2, 1, -1}, {6, 6, -1}, {-4, 4, 3}}; double l_matrix[N][N] = {0}; double u_matrix[N][N] = {0}; lu_decomposition(coefficient_mat, l_matrix, u_matrix); printf("---------- L行列 ----------\n"); print_array(l_matrix); printf("---------- U行列 ----------\n"); print_array(u_matrix); } else if (kadai == 5) { double coefficient_mat[N][N] = {{2, 1, -1}, {6, 6, -1}, {-4, 4, 3}}; double right_hand_vec[N] = {2, 3, -1}; double solution_vec[N]; printf("---------- 係数行列 ----------\n"); print_array(coefficient_mat); printf("---------- 右辺ベクトル ----------\n"); print_vector(right_hand_vec); solute_SLE_with_n_variables(coefficient_mat, right_hand_vec, solution_vec); printf("---------- 解ベクトル ----------\n"); print_vector(solution_vec); } else if (kadai == 6) { double h_coefficient_mat[N][N]; double right_hand_vec[N]; double solution_vec[N]; int i, j; for (i = 0; i < N; i++){ for (j = 0; j < N; j++){ h_coefficient_mat[i][j] = pow(0.5, abs(i-j)); } } printf("--------------- 行列H ---------------\n"); print_array(h_coefficient_mat); for (i = 0; i < N; i++){ right_hand_vec[i] = 3 - pow(2, i-N+1) - pow(2, -i); } printf("------------- 右辺ベクトル -------------\n"); print_vector(right_hand_vec); solute_SLE_with_n_variables(h_coefficient_mat, right_hand_vec, solution_vec); printf("---------- 解ベクトル ----------\n"); print_vector(solution_vec); } else if (kadai == 8) { double h_mat[N][N]; double h_reverse_mat[N][N] = {0}; double solution_mat[N][N]; int i, j; for (i = 0; i < N; i++){ for (j = 0; j < N; j++){ h_mat[i][j] = pow(0.5, abs(i-j)); } } evaluate_reverse_matrix(h_mat, h_reverse_mat); mat_mlt(h_mat, h_reverse_mat, solution_mat); printf("--------------- 行列H ---------------\n"); print_array(h_mat); printf("------------ 行列Hの逆行列 ------------\n"); print_array(h_reverse_mat); printf("---------- 解行列 ----------\n"); print_array(solution_mat); } return 0; }
/* * LARS algorithm. * * * Suppose we expect a response variable to be determined by a linear * combination of a subset of potential covariates. Then the LARS * algorithm provides a means of producing an estimate of which * variables to include, as well as their coefficients. * * Instead of giving a vector result, the LARS solution consists of a * curve denoting the solution for each value of the L1 norm of the * parameter vector. The algorithm is similar to forward stepwise * regression, but instead of including variables at each step, the * estimated parameters are increased in a direction equiangular to * each one's correlations with the residual. * * * Parameters * ---------- * predictors are expected to be normalized * * X is (features, nsamples), b is (nsamples,1) * * beta is the returned array with the parameters of the regression * problem. * * b will be modified to store the current residual. * * TODO * ---- * The case when two vectors have equal correlation. * */ void lars_fit(double *X, double *b, double *beta, int *ind, double *L, int nfeatures, int nsamples, int stop) { /* temp variables. way too much */ double *dir = (double *) calloc(nsamples, sizeof(double)); double *dd = (double *) malloc(nfeatures * sizeof(double)); double *w = (double *) malloc(nfeatures * sizeof(double)); double *v = (double *) malloc(nsamples * sizeof(double)); /* TODO: we could use v and w as the same */ double gamma = 0, tgamma, temp, cov_max, Aa = 0; int i, j, k, sum_k=0, sign; struct dllist *unused, *used_indices, *cur; struct dllist *pmax; /* maximum covariance (current working variable) */ unused = (struct dllist *) malloc((nfeatures+2) * sizeof(struct dllist)); /* if stop == nfeatures: raise Exception */ /* create index table as a linked list */ for (i=0; i<=nfeatures; ++i) { unused[i].index = i-1; unused[i].next = unused + i + 1; unused[i].prev = unused + i - 1; } cur = unused + nfeatures; used_indices = cur->next; /* set sentinels */ used_indices->prev = NULL; cur->next = NULL; /* main loop, we iterate over the user-suplied number of iterations */ for (k=0; k < stop; ++k) { /* Update residual */ for (i=0, cur=used_indices; cur; cur=cur->prev, ++i) { temp = 0; for (j = 0; j<k; ++j) temp += X[i*nsamples + ind[j]] * beta[sum_k + j]; b[ind[i]] -= temp; } cov_max = 0; /* calculate covariances (c_hat), and get maximum covariance (C_hat)*/ for (cur = unused->next; cur; cur = cur->next) { temp = cblas_ddot (nsamples, X + cur->index, nfeatures, b, 1); cur->cov = temp; if (fabs(temp) > cov_max) { sign = copysign (1.0, temp); cov_max = fabs (temp); pmax = cur; } } /* add pmax to the active set */ pmax->prev->next = pmax->next; if (pmax->next) pmax->next->prev = pmax->prev; pmax->prev = used_indices; used_indices = pmax; /* * We compute some intermediate results that we will need to * compute the least-squares direction. */ for (i=k, cur=used_indices; cur; cur=cur->prev, --i) { /* * To update the cholesky decomposition, we need to calculate * * v = Xa' * cur * dd = Xa' * res * * where res is the current residual and cur is the last * vector to enter the active set. */ v[i] = sign * cblas_ddot(nsamples, X + cur->index, nfeatures, X + pmax->index, nfeatures); dd[i] = cur->cov; } /* * Compute least squares solution by the method of normal equations * (Golub & Van Loan, 1996) * * Update L: * ( L w ) * L -> ( ) , where w = (L^-1) v * ( 0 Ln ) * * And solve ... * * sum_k is the number such that L[sum_k] is the first * unwritten field in L. * */ sum_k = k * (k+1) / 2; back_substitution (L, v, L + sum_k, k); L[sum_k + k] = sqrt (cblas_dnrm2(nsamples, X + pmax->index, nfeatures) - \ cblas_dnrm2(k, L + sum_k, 1)); forward_substitution (L, dd, w, k + 1); back_substitution (L, w, dir, k + 1); /* dir is now the least squares direction */ /* * Compute gamma. * We iterate over unused indices. */ Aa = pmax->cov; gamma = INFINITY; for (cur = unused->next; cur; cur = cur->next) { temp = cblas_ddot(nsamples, X + cur->index, nfeatures, b, 1); tgamma = fmin_pos (cov_max - cur->cov / (Aa - temp), cov_max + cur->cov / (Aa + temp)); gamma = fmin (tgamma, gamma); } /* Set up return values */ ind[k] = pmax->index; for(i=0; i<k; ++i) { beta[sum_k + i] = beta[sum_k - k + i] + gamma * dir[i]; } beta[sum_k + k] = gamma * dir[k]; } free(v); free(dir); free(unused); }