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 */
}
