void set(const T& value, const Time& time = Clock::now()) { // If we're not inserting at the end of the time series, then // we have to reset the sparsification index. Given that // out-of-order insertion is a rare use-case. This is a simple way // to keep insertions O(log(n)). No need to figure out how to // adjust the truncation index. if (!values.empty() && time < values.rbegin()->first) { index = None(); } values[time] = value; truncate(); sparsify(); }
void svmwrite (double *v, int *r, int *c, int *rowindex, int *colindex, double *coefs, double *rho, int *compprob, double *probA, double *probB, int *nclasses, int *totnSV, int *labels, int *nSV, int *sparsemodel, int *svm_type, int *kernel_type, int *degree, double *gamma, double *coef0, char **filename) { struct svm_model m; int i; char *fname = *filename; /* set up model */ m.l = *totnSV; m.nr_class = *nclasses; m.sv_coef = (double **) malloc (m.nr_class * sizeof(double*)); for (i = 0; i < m.nr_class - 1; i++) { m.sv_coef[i] = (double *) malloc (m.l * sizeof (double)); memcpy (m.sv_coef[i], coefs + i*m.l, m.l * sizeof (double)); } if (*sparsemodel > 0) m.SV = transsparse(v, *r, rowindex, colindex); else m.SV = sparsify(v, *r, *c); m.rho = rho; m.label = labels; m.nSV = nSV; if (*compprob) { m.probA = probA; m.probB = probB; } else { m.probA = NULL; m.probB = NULL; } /* set up parameter */ m.param.svm_type = *svm_type; m.param.kernel_type = *kernel_type; m.param.degree = *degree; m.param.gamma = *gamma; m.param.coef0 = *coef0; m.free_sv = 1; /* write svm model */ svm_save_model(fname, &m); for (i = 0; i < m.nr_class - 1; i++) free(m.sv_coef[i]); free(m.sv_coef); for (i = 0; i < *r; i++) free (m.SV[i]); free (m.SV); }
void svmpredict (int *decisionvalues, int *probability, double *v, int *r, int *c, int *rowindex, int *colindex, double *coefs, double *rho, int *compprob, double *probA, double *probB, int *nclasses, int *totnSV, int *labels, int *nSV, int *sparsemodel, int *svm_type, int *kernel_type, int *degree, double *gamma, double *coef0, double *x, int *xr, int *xrowindex, int *xcolindex, int *sparsex, double *ret, double *dec, double *prob) { struct svm_model m; struct svm_node ** train; int i; /* set up model */ m.l = *totnSV; m.nr_class = *nclasses; m.sv_coef = (double **) malloc (m.nr_class * sizeof(double*)); for (i = 0; i < m.nr_class - 1; i++) { m.sv_coef[i] = (double *) malloc (m.l * sizeof (double)); memcpy (m.sv_coef[i], coefs + i*m.l, m.l * sizeof (double)); } if (*sparsemodel > 0) m.SV = transsparse(v, *r, rowindex, colindex); else m.SV = sparsify(v, *r, *c); m.rho = rho; m.probA = probA; m.probB = probB; m.label = labels; m.nSV = nSV; /* set up parameter */ m.param.svm_type = *svm_type; m.param.kernel_type = *kernel_type; m.param.degree = *degree; m.param.gamma = *gamma; m.param.coef0 = *coef0; m.param.probability = *compprob; m.free_sv = 1; /* create sparse training matrix */ if (*sparsex > 0) train = transsparse(x, *xr, xrowindex, xcolindex); else train = sparsify(x, *xr, *c); /* call svm-predict-function for each x-row, possibly using probability estimator, if requested */ if (*probability && svm_check_probability_model(&m)) { for (i = 0; i < *xr; i++) ret[i] = svm_predict_probability(&m, train[i], prob + i * *nclasses); } else { for (i = 0; i < *xr; i++) ret[i] = svm_predict(&m, train[i]); } /* optionally, compute decision values */ if (*decisionvalues) for (i = 0; i < *xr; i++) svm_predict_values(&m, train[i], dec + i * *nclasses * (*nclasses - 1) / 2); /* clean up memory */ for (i = 0; i < *xr; i++) free (train[i]); free (train); for (i = 0; i < *r; i++) free (m.SV[i]); free (m.SV); for (i = 0; i < m.nr_class - 1; i++) free(m.sv_coef[i]); free(m.sv_coef); }
void svmtrain (double *x, int *r, int *c, double *y, int *rowindex, int *colindex, int *svm_type, int *kernel_type, int *degree, double *gamma, double *coef0, double *cost, double *nu, int *weightlabels, double *weights, int *nweights, double *cache, double *tolerance, double *epsilon, int *shrinking, int *cross, int *sparse, int *probability, int *nclasses, int *nr, int *index, int *labels, int *nSV, double *rho, double *coefs, double *sigma, double *probA, double *probB, double *cresults, double *ctotal1, double *ctotal2, char **error) { struct svm_parameter par; struct svm_problem prob; struct svm_model *model = NULL; int i, ii; const char* s; /* set parameters */ par.svm_type = *svm_type; par.kernel_type = *kernel_type; par.degree = *degree; par.gamma = *gamma; par.coef0 = *coef0; par.cache_size = *cache; par.eps = *tolerance; par.C = *cost; par.nu = *nu; par.nr_weight = *nweights; if (par.nr_weight > 0) { par.weight = (double *) malloc (sizeof(double) * par.nr_weight); memcpy(par.weight, weights, par.nr_weight * sizeof(double)); par.weight_label = (int *) malloc (sizeof(int) * par.nr_weight); memcpy(par.weight_label, weightlabels, par.nr_weight * sizeof(int)); } par.p = *epsilon; par.shrinking = *shrinking; par.probability = *probability; /* set problem */ prob.l = *r; prob.y = y; if (*sparse > 0) prob.x = transsparse(x, *r, rowindex, colindex); else prob.x = sparsify(x, *r, *c); /* check parameters & copy error message */ s = svm_check_parameter(&prob, &par); if (s) { strcpy(*error, s); } else { /* call svm_train */ model = svm_train(&prob, &par); /* set up return values */ /* for (ii = 0; ii < model->l; ii++) for (i = 0; i < *r; i++) if (prob.x[i] == model->SV[ii]) index[ii] = i+1; */ svm_get_sv_indices(model, index); *nr = model->l; *nclasses = model->nr_class; memcpy (rho, model->rho, *nclasses * (*nclasses - 1)/2 * sizeof(double)); if (*probability && par.svm_type != ONE_CLASS) { if (par.svm_type == EPSILON_SVR || par.svm_type == NU_SVR) *sigma = svm_get_svr_probability(model); else { memcpy(probA, model->probA, *nclasses * (*nclasses - 1)/2 * sizeof(double)); memcpy(probB, model->probB, *nclasses * (*nclasses - 1)/2 * sizeof(double)); } } for (i = 0; i < *nclasses-1; i++) memcpy (coefs + i * *nr, model->sv_coef[i], *nr * sizeof (double)); if (*svm_type < 2) { memcpy (labels, model->label, *nclasses * sizeof(int)); memcpy (nSV, model->nSV, *nclasses * sizeof(int)); } /* Perform cross-validation, if requested */ if (*cross > 0) do_cross_validation (&prob, &par, *cross, cresults, ctotal1, ctotal2); /* clean up memory */ svm_free_and_destroy_model(&model); } /* clean up memory */ if (par.nr_weight > 0) { free(par.weight); free(par.weight_label); } for (i = 0; i < *r; i++) free (prob.x[i]); free (prob.x); }
int main(int argc, char *argv[]) { struct matrix_t *matrixA; struct sparse_matrix_t *sparseA; struct vector_t *x, *b; lsqr_input *input; lsqr_output *output; lsqr_work *work; /* zone temoraire de travail */ lsqr_func *func; /* func->mat_vec_prod -> APROD */ /* cmd line arg */ char *matrix_filename = NULL; char *vector_filename = NULL; char *sol_filename = NULL; int max_iter = -1; float damping = 0; if (argc != 4) { fprintf(stderr, "%s matrixfile vectorfile solutionfile\n", argv[0]); exit(1); } matrix_filename = strdup(argv[1]); vector_filename = strdup(argv[2]); sol_filename = strdup(argv[3]); /* read the matrix */ matrixA = read_matrix(matrix_filename); fprintf(stderr, "read*matrix: ok (size=%ldx%ld, %ld elements)\n", matrixA->nb_line, matrixA->nb_col, matrixA->nb_line * matrixA->nb_col); sparseA = sparsify(matrixA, SPARSE_COL_LINK); b = read_simple_vector(vector_filename); /*************************************************/ /* check compatibility between matrix and vector */ /*************************************************/ if (sparseA->nb_line != b->length) { fprintf(stderr, "Error, check your matrix/vector sizes (%ld/%ld)\n", sparseA->nb_line, b->length); exit(1); } /* init vector solution to zero */ x = new_vector(sparseA->nb_col); /* catch Ctrl-C signal */ signal(SIGINT, emergency_halt); /*************************************************************/ /* solve A.x = B */ /*************************************************************/ /* LSQR alloc */ alloc_lsqr_mem(&input, &output, &work, &func, sparseA->nb_line, sparseA->nb_col); fprintf(stderr, "alloc_lsqr_mem : ok\n"); /* defines the routine Mat.Vect to use */ func->mat_vec_prod = sparseMATRIXxVECTOR; /* Set the input parameters for LSQR */ input->num_rows = sparseA->nb_line; input->num_cols = sparseA->nb_col; input->rel_mat_err = .0; input->rel_rhs_err = .0; input->cond_lim = .0; input->lsqr_fp_out = stdout; input->rhs_vec = (dvec *) b; input->sol_vec = (dvec *) x; /* initial guess */ input->damp_val = damping; if (max_iter == -1) { input->max_iter = 4 * (sparseA->nb_col); } else { input->max_iter = max_iter; } /* resolution du systeme Ax=b */ lsqr(input, output, work, func, sparseA); write_vector((struct vector_t *) output->sol_vec, sol_filename); free_lsqr_mem(input, output, work, func); free_matrix(matrixA); /* check A^t.A */ /* * { struct sparse_matrix_t *AtA; AtA = AtransA (sparseA); * write_sparse_matrix(AtA, "AtA"); write_sparse_matrix(sparseA, * "A"); free_sparse_matrix (AtA); * * } */ free_sparse_matrix(sparseA); return (1); }
void SnoptInterface::init(const Dict& opts) { // Call the init method of the base class Nlpsol::init(opts); // Default: cold start Cold_ = 0; // Read user options for (auto&& op : opts) { if (op.first=="snopt") { opts_ = op.second; } else if (op.first=="start") { std::string start = op.second.to_string(); if (start=="cold") { Cold_ = 0; } else if (start=="warm") { Cold_ = 1; } else if (start=="hot") { Cold_ = 2; } else { casadi_error("Unknown start option: " + start); } } } // Get/generate required functions jac_f_fcn_ = create_function("nlp_jac_f", {"x", "p"}, {"f", "jac:f:x"}); jac_g_fcn_ = create_function("nlp_jac_g", {"x", "p"}, {"g", "jac:g:x"}); jacg_sp_ = jac_g_fcn_.sparsity_out(1); // prepare the mapping for constraints nnJac_ = nx_; nnObj_ = nx_; nnCon_ = ng_; // Here follows the core of the mapping // Two integer matrices are constructed: // one with gradF sparsity, and one with jacG sparsity // the integer values denote the nonzero locations into the original gradF/jacG // but with a special encoding: entries of gradF are encoded "-1-i" and // entries of jacG are encoded "1+i" // "0" is to be interpreted not as an index but as a literal zero IM mapping_jacG = IM(0, nx_); IM mapping_gradF = IM(jac_f_fcn_.sparsity_out(1), range(-1, -1-jac_f_fcn_.nnz_out(1), -1)); if (!jac_g_fcn_.is_null()) { mapping_jacG = IM(jacg_sp_, range(1, jacg_sp_.nnz()+1)); } // First, remap jacG A_structure_ = mapping_jacG; m_ = ng_; // Construct the linear objective row IM d = mapping_gradF(Slice(0), Slice()); std::vector<int> ii = mapping_gradF.sparsity().get_col(); for (int j = 0; j < nnObj_; ++j) { if (d.colind(j) != d.colind(j+1)) { int k = d.colind(j); d.nz(k) = 0; } } // Make it as sparse as you can d = sparsify(d); jacF_row_ = d.nnz() != 0; if (jacF_row_) { // We need an objective gradient row A_structure_ = vertcat(A_structure_, d); m_ +=1; } iObj_ = jacF_row_ ? (m_ - 1) : -1; // Is the A matrix completely empty? dummyrow_ = A_structure_.nnz() == 0; // Then we need a dummy row if (dummyrow_) { IM dummyrow = IM(1, nx_); dummyrow(0, 0) = 0; A_structure_ = vertcat(A_structure_, dummyrow); m_+=1; } // We don't need a dummy row if a linear objective row is present casadi_assert(!(dummyrow_ && jacF_row_)); // Allocate temporary memory alloc_w(nx_, true); // xk2_ alloc_w(ng_, true); // lam_gk_ alloc_w(nx_, true); // lam_xk_ alloc_w(ng_, true); // gk_ alloc_w(jac_f_fcn_.nnz_out(1), true); // jac_fk_ if (!jacg_sp_.is_null()) { alloc_w(jacg_sp_.nnz(), true); // jac_gk_ } }
int main(int argc, char* argv[]) { // Print help if necessary bool help = read_bool(argc, argv, "--help", false); if ((argc < 2) || (help)) { usage(argv); return 0; } // Use parameters struct for passing parameters to kernels efficiently parameters prm; // Parse inputs prm.matDims[0] = read_int(argc, argv, "--m", 2); prm.matDims[1] = read_int(argc, argv, "--k", 2); prm.matDims[2] = read_int(argc, argv, "--n", 2); prm.rank = read_int(argc, argv, "--rank", 7); prm.method = read_string(argc, argv, "--method", (char *)"als"); int maxIters = read_int(argc, argv, "--maxiters", 1000); int maxSecs = read_int(argc, argv, "--maxsecs", 1000); double tol = read_double(argc, argv, "--tol", 1e-8); int printItn = read_int(argc, argv, "--printitn", 0); double printTol = read_double(argc, argv, "--printtol", 1.0); int seed = read_int(argc, argv, "--seed", 0); int numSeeds = read_int(argc, argv, "--numseeds", 1); bool verbose = read_bool(argc, argv, "--verbose", false); prm.rnd_maxVal = read_double(argc,argv,"--maxval",1.0); prm.rnd_pwrOfTwo = read_int(argc,argv,"--pwrof2",0); bool roundFinal = read_bool(argc, argv, "--rndfin",false); prm.alpha = read_double(argc,argv, "--alpha", 0.1); int M = read_int(argc,argv, "--M", 0); if (M) { prm.M[0] = M; prm.M[1] = M; prm.M[2] = M; } else { prm.M[0] = read_int(argc, argv, "--M0", -1); prm.M[1] = read_int(argc, argv, "--M1", -1); prm.M[2] = read_int(argc, argv, "--M2", -1); } char * infile = read_string(argc, argv, "--input", NULL); char * outfile = read_string(argc, argv, "--output", NULL); if (verbose) { setbuf(stdout, NULL); printf("\n\n---------------------------------------------------------\n"); printf("PARAMETERS\n"); printf("dimensions = %d %d %d\n",prm.matDims[0],prm.matDims[1],prm.matDims[2]); printf("rank = %d\n",prm.rank); printf("method = %s\n",prm.method); if (infile) printf("input = %s\n",infile); else { if (numSeeds == 1) printf("input = seed %d\n",seed); else printf("inputs = seeds %d-%d\n",seed,seed+numSeeds-1); } if (outfile) printf("output = %s\n",outfile); else printf("output = none\n"); if (!strcmp(prm.method,"als")) { printf("tol = %1.2e\n",tol); printf("alpha = %1.2e\n",prm.alpha); printf("maval = %1.2e\n",prm.rnd_maxVal); printf("M's = (%d,%d,%d)\n",prm.M[0],prm.M[1],prm.M[2]); printf("maxiters = %d\n",maxIters); printf("maxsecs = %d\n",maxSecs); printf("printitn = %d\n",printItn); printf("printtol = %1.2e\n",printTol); } printf("---------------------------------------------------------\n"); } // Initialize other variables int i, j, k, numIters, mkn, tidx[3]; double err, errOld, errChange = 0.0, start_als, start_search, elapsed, threshold; // Compute tensor dimensions prm.dims[0] = prm.matDims[0]*prm.matDims[1]; prm.dims[1] = prm.matDims[1]*prm.matDims[2]; prm.dims[2] = prm.matDims[0]*prm.matDims[2]; // Compute tensor's nnz, total number of entries, and Frobenius norm mkn = prm.matDims[0]*prm.matDims[1]*prm.matDims[2]; prm.mkn2 = mkn*mkn; prm.xNorm = sqrt(mkn); // Compute number of columns in matricized tensors for (i = 0; i < 3; i++) prm.mtCols[i] = prm.mkn2 / prm.dims[i]; // Construct three matricizations of matmul tensor prm.X = (double**) malloc( 3 * sizeof(double*) ); for (i = 0; i < 3; i++) prm.X[i] = (double*) calloc( prm.mkn2, sizeof(double) ); for (int mm = 0; mm < prm.matDims[0]; mm++) for (int kk = 0; kk < prm.matDims[1]; kk++) for (int nn = 0; nn < prm.matDims[2]; nn++) { tidx[0] = mm + kk*prm.matDims[0]; tidx[1] = kk + nn*prm.matDims[1]; tidx[2] = mm + nn*prm.matDims[0]; prm.X[0][tidx[0]+prm.dims[0]*(tidx[1]+prm.dims[1]*tidx[2])] = 1; prm.X[1][tidx[1]+prm.dims[1]*(tidx[0]+prm.dims[0]*tidx[2])] = 1; prm.X[2][tidx[2]+prm.dims[2]*(tidx[0]+prm.dims[0]*tidx[1])] = 1; } // Allocate factor weights and matrices: working, initial, and model prm.lambda = (double*) malloc( prm.rank * sizeof(double) ); prm.U = (double**) malloc( 3 * sizeof(double*) ); double** U0 = (double**) malloc( 3 * sizeof(double*) ); prm.model = (double**) malloc( 3 * sizeof(double*) ); for (i = 0; i < 3; i++) { prm.U[i] = (double*) calloc( prm.mkn2, sizeof(double) ); U0[i] = (double*) calloc( prm.dims[i]*prm.rank, sizeof(double) ); prm.model[i] = (double*) calloc( prm.dims[i]*prm.rank, sizeof(double) ); } // Allocate coefficient matrix within ALS (Khatri-Rao product) int maxMatDim = prm.matDims[0]; if (maxMatDim < prm.matDims[1]) maxMatDim = prm.matDims[1]; if (maxMatDim < prm.matDims[2]) maxMatDim = prm.matDims[2]; prm.A = (double*) malloc( maxMatDim*mkn*prm.rank * sizeof(double) ); // Allocate workspaces prm.tau = (double*) malloc( mkn * sizeof(double) ); prm.lwork = maxMatDim*mkn*prm.rank; prm.work = (double*) malloc( prm.lwork * sizeof(double) ); prm.iwork = (int*) malloc( prm.mkn2 * sizeof(int) ); // Allocate matrices for normal equations int maxDim = prm.dims[0]; if (maxDim < prm.dims[1]) maxDim = prm.dims[1]; if (maxDim < prm.dims[2]) maxDim = prm.dims[2]; prm.NE_coeff = (double*) malloc( prm.rank*prm.rank * sizeof(double) ); prm.NE_rhs = (double*) malloc( maxDim*prm.rank * sizeof(double) ); prm.residual = (double*) malloc( prm.mkn2 * sizeof(double) ); //-------------------------------------------------- // Search Loop //-------------------------------------------------- int mySeed = seed, numGoodSeeds = 0, statusCnt = 0, status = 1; start_search = wall_time(); for (int seed_cnt = 0; seed_cnt < numSeeds; ++seed_cnt) { // Set starting point from random seed (match Matlab Tensor Toolbox) RandomMT cRMT(mySeed); for (i = 0; i < 3; i++) for (j = 0; j < prm.dims[i]; j++) for (k = 0; k < prm.rank; k++) U0[i][j+k*prm.dims[i]] = cRMT.genMatlabMT(); for (i = 0; i < prm.rank; i++) prm.lambda[i] = 1.0; // Copy starting point for (i = 0; i < 3; i++) cblas_dcopy(prm.dims[i]*prm.rank,U0[i],1,prm.U[i],1); // read from file if input is given if( infile ) read_input( infile, prm ); if (verbose) { printf("\nSTARTING POINT...\n"); for (i = 0; i < 3; i++) { printf("Factor matrix %d:\n",i); print_matrix(prm.U[i],prm.dims[i],prm.rank,prm.dims[i]); } printf("\n"); } //-------------------------------------------------- // Main ALS Loop //-------------------------------------------------- start_als = wall_time(); err = 1.0; threshold = 1e-4; for (numIters = 0; numIters < maxIters && (wall_time()-start_als) < maxSecs; numIters++) { errOld = err; if (!strcmp(prm.method,"als")) { // Perform an iteration of ALS using NE with Smirnov's penalty term err = als( prm ); } else if (!strcmp(prm.method,"sparsify")) { // print stats before sparsifying printf("Old residual: %1.2e\n",compute_residual(prm,2,true)); printf("Old nnz (larger than %1.1e): %d %d %d\n", threshold, nnz(prm.U[0],prm.dims[0]*prm.rank,threshold), nnz(prm.U[1],prm.dims[1]*prm.rank,threshold), nnz(prm.U[2],prm.dims[2]*prm.rank,threshold) ); // sparsify and return printf("\nSparsifying...\n\n"); sparsify( prm ); numIters = maxIters; // print stats after sparsifying printf("New residual: %1.2e\n",compute_residual(prm,2,true)); printf("New nnz (larger than %1.1e): %d %d %d\n", threshold, nnz(prm.U[0],prm.dims[0]*prm.rank,threshold), nnz(prm.U[1],prm.dims[1]*prm.rank,threshold), nnz(prm.U[2],prm.dims[2]*prm.rank,threshold) ); } else if (!strcmp(prm.method,"round")) { // print stats before rounding printf("Old residual: %1.2e\n",compute_residual(prm,2,true)); printf("Old nnz (larger than %1.1e): %d %d %d\n", threshold, nnz(prm.U[0],prm.dims[0]*prm.rank,threshold), nnz(prm.U[1],prm.dims[1]*prm.rank,threshold), nnz(prm.U[2],prm.dims[2]*prm.rank,threshold) ); // round and return for (i = 0; i < 3; i++) { capping(prm.U[i],prm.dims[i]*prm.rank,prm.rnd_maxVal); rounding(prm.U[i],prm.dims[i]*prm.rank,prm.rnd_pwrOfTwo); } numIters = maxIters; // print stats after rounding printf("New residual: %1.2e\n",compute_residual(prm,2,true)); printf("New nnz (larger than %1.1e): %d %d %d\n", threshold, nnz(prm.U[0],prm.dims[0]*prm.rank,threshold), nnz(prm.U[1],prm.dims[1]*prm.rank,threshold), nnz(prm.U[2],prm.dims[2]*prm.rank,threshold) ); } else die("Invalid method\n"); // Compute change in relative residual norm errChange = fabs(err - errOld); // Print info at current iteration if ((printItn > 0) && (((numIters + 1) % printItn) == 0)) { // print info printf ("Iter %d: residual = %1.5e change = %1.5e\n", numIters + 1, err, errChange); } // Check for convergence if ( numIters > 0 && errChange < tol ) break; } // If rounding, round final solution and re-compute residual if(roundFinal) { // normalize columns in A and B factors, put arbitrary weights into C normalize_model( prm, 2 ); // cap large values and round to nearest power of 2 for (i = 0; i < 3; i++) { capping(prm.U[i],prm.dims[i]*prm.rank,prm.rnd_maxVal); rounding(prm.U[i],prm.dims[i]*prm.rank,prm.rnd_pwrOfTwo); } err = compute_residual(prm,0,true); } // Print status if searching over many seeds statusCnt++; if (numSeeds > 1000 && statusCnt == numSeeds/10) { printf("...%d%% complete...\n",10*status); status++; statusCnt = 0; } // Print final info elapsed = wall_time() - start_als; if ((printItn > 0 || verbose) && !strcmp(prm.method,"als")) { if (infile) printf("\nInput %s ",infile); else printf("\nInitial seed %d ",mySeed); printf("achieved residual %1.3e in %d iterations and %1.3e seconds\n \t final residual change: %1.3e\n \t average time per iteration: %1.3e s\n", err, numIters, elapsed, errChange, elapsed/numIters); } if (verbose) { printf("\nSOLUTION...\n"); for (i = 0; i < 3; i++) { printf("Factor matrix %d:\n",i); if (roundFinal || !strcmp(prm.method,"round")) print_int_matrix(prm.U[i], prm.dims[i], prm.rank, prm.dims[i], prm.rnd_pwrOfTwo); else print_matrix(prm.U[i],prm.dims[i],prm.rank,prm.dims[i]); } if (err < printTol) numGoodSeeds++; } else if (err < printTol) { numGoodSeeds++; printf("\n\n***************************************\n"); if (infile) printf("Input %s: ",infile); else printf("Initial seed %d: ",mySeed); printf("after %d iterations, achieved residual %1.3e with final residual change of %1.3e\n", numIters, err, errChange); if (roundFinal) { for (i = 0; i < 3; i++) { printf("Factor matrix %d:\n",i); print_int_matrix(prm.U[i], prm.dims[i], prm.rank, prm.dims[i], prm.rnd_pwrOfTwo); } int count = 0; for (i = 0; i < 3; i++) count += nnz(prm.U[i],prm.dims[i]*prm.rank); printf("\ttotal nnz in solution: %d\n",count); printf("\tnaive adds/subs: %d\n",count - prm.dims[2] - 2*prm.rank); } printf("***************************************\n\n\n"); } // write to output if( outfile ) write_output( outfile, prm ); mySeed++; } // Final report of processor statistics elapsed = wall_time()-start_search; // Print stats if (!strcmp(prm.method,"als")) { printf("\n\n------------------------------------------------------------\n"); printf("Time elapsed: \t%1.1e\tseconds\n",elapsed); printf("Total number of seeds tried: \t%d\n",numSeeds); printf("Total number of good seeds: \t%d",numGoodSeeds); printf("\t(residual < %2.1e)\n",printTol); printf("------------------------------------------------------------\n"); } // free allocated memory for (i = 0; i < 3; i++) { free( prm.X[i] ); free( prm.U[i] ); free( U0[i] ); free( prm.model[i] ); } free( prm.X ); free( prm.U ); free( U0 ); free( prm.model ); free( prm.lambda ); free( prm.A ); free( prm.NE_coeff ); free( prm.NE_rhs ); free( prm.residual ); free( prm.tau ); free( prm.work ); free( prm.iwork ); return 0; }
sfb_cold_init( int unit, user_info_t *up) { sfb_softc_t *sfb; screen_softc_t sc = screen(unit); vm_offset_t base = tc_probe("sfb"); int hor_p, ver_p; boolean_t makes_sense; bcopy(&sfb_sw, &sc->sw, sizeof(sc->sw)); sc->flags |= COLOR_SCREEN; /* * I am confused here by the documentation. One document * sez there are three boards: * "PMAGB-BA" can do 1280x1024 @66Hz or @72Hz * "PMAGB-BC" can do 1024x864 @60Hz or 1280x1024 @72Hz * "PMAGB-BE" can do 1024x768 @72Hz or 1280x1024 @72Hz * Another document sez things differently: * "PMAGB-BB" can do 1024x768 @72Hz * "PMAGB-BD" can do 1024x864 @60Hz or 1280x1024 @72Hz * * I would be inclined to believe the first one, which came * with an actual piece of hardware attached (a PMAGB-BA). * But I could swear I got a first board (which blew up * instantly) and it was calling itself PMAGB-BB... * * Since I have not seen any other hardware I will make * this code as hypothetical as I can. Should work :-)) */ makes_sense = FALSE; { sfb_regs *regs; regs = (sfb_regs *) ((char *)base + SFB_OFFSET_REGS); hor_p = (regs->vhor_setup & 0x1ff) * 4; ver_p = regs->vvert_setup & 0x7ff; if (((hor_p == 1280) && (ver_p == 1024)) || ((hor_p == 1024) && (ver_p == 864)) || ((hor_p == 1024) && (ver_p == 768))) makes_sense = TRUE; } if (makes_sense) { sc->frame_scanline_width = hor_p; sc->frame_height = ver_p; sc->frame_visible_width = hor_p; sc->frame_visible_height = ver_p; } else { sc->frame_scanline_width = 1280; sc->frame_height = 1024; sc->frame_visible_width = 1280; sc->frame_visible_height = 1024; } pm_init_screen_params(sc,up); (void) screen_up(unit, up); sfb = pm_alloc( unit, sparsify(base + SFB_OFFSET_BT459), base + SFB_OFFSET_VRAM, -1); screen_default_colors(up); sfb_soft_reset(sc); /* * Clearing the screen at boot saves from scrolling * much, and speeds up booting quite a bit. */ screen_blitc( unit, 'C'-'@');/* clear screen */ }