Beispiel #1
0
CSparseMatrix* NM_triplet_to_csr(CSparseMatrix* triplet)
{
#ifdef WITH_MKL_SPBLAS
  assert(triplet);
  CHECK_MKL(load_mkl_function("mkl_dcsrcoo", (void**)&mkl_dcsrcoo_p));
  if (triplet->m != triplet->n)
  {
    fprintf(stderr, "NM_triplet_to_csr :: the matrix has to be square\n");
    exit(EXIT_FAILURE);
  }
  CSparseMatrix* csr = cs_spalloc(NSM_NROW_CSR(triplet), NSM_NCOL_CSR(triplet), triplet->nz, 1, 0);
  assert(csr);
  csr->nz = -2;

  CS_INT n = csr->n;
  CS_INT job[6] = {0};
  CS_INT info = 0;
  job[0] = 2;
  (*mkl_dcsrcoo_p)(job, &n, csr->x, csr->i, csr->p, &(triplet->nz), triplet->x, triplet->i, triplet->p, &info);

  return csr;
#else
  fprintf(stderr, "NM_triplet_to_csr :: MKL not enabled\n");
  exit(EXIT_FAILURE);
#endif
}
Beispiel #2
0
/**
 * @brief Creates the penalty matrix D tilde of order k.
 * Returns the matrix Dk premultipied by a diagonal
 * matrix of weights.
 *
 * @param n                    number of observations
 * @param k                    order of the trendfilter
 * @param x                    locations of the responses
 * @return pointer to a csparse matrix
 * @see tf_calc_dktil
 */
cs * tf_calc_dktil (int n, int k, const double * x)
{
  cs * delta_k;
  cs * delta_k_cp;
  cs * Dk;
  cs * Dktil;

  int i;

  Dk = tf_calc_dk(n, k, x);

  /* Deal with k=0 separately */
  if(k == 0)
    return Dk;

  /* Construct diagonal matrix of differences: */
  delta_k = cs_spalloc(n-k, n-k, (n-k), 1, 1);
  for(i = 0; i < n - k; i++)
  {
    delta_k->p[i] = i;
    delta_k->i[i] = i;
    delta_k->x[i] = k / (x[k + i] - x[i]);
  }
  delta_k->nz = n-k;
  delta_k_cp = cs_compress(delta_k);
  Dktil = cs_multiply(delta_k_cp, Dk);

  cs_spfree(Dk);
  cs_spfree(delta_k);
  cs_spfree(delta_k_cp);

  return Dktil;
}
Beispiel #3
0
CSparseMatrix* NM_csr_to_csc(CSparseMatrix* csr)
{
#ifdef WITH_MKL_SPBLAS
  assert(csr);
  CHECK_MKL(load_mkl_function("mkl_dcsrcsc", (void**)&mkl_dcsrcsc_p));
  if (csr->m != csr->n)
  {
    fprintf(stderr, "NM_csr_to_csc :: the matrix has to be square\n");
    exit(EXIT_FAILURE);
  }
  assert(csr);
  CSparseMatrix* csc = cs_spalloc(csr->m, csr->n, csr->nzmax, 1, 0);
  assert(csc);

  CS_INT n = csr->n;
  CS_INT job[6] = {0};
  job[5] = 1;
  CS_INT info = 0;
  (*mkl_dcsrcsc_p)(job, &n, csr->x, csr->i, csr->p, csc->x, csc->i, csc->p, &info);

  return csc;
#else
  fprintf(stderr, "NM_csr_to_csc :: MKL not enabled\n");
  exit(EXIT_FAILURE);
#endif
}
Beispiel #4
0
CSparseMatrix* NM_csr_to_triplet(CSparseMatrix* csr)
{
#ifdef WITH_MKL_SPBLAS
  assert(csr);
  CHECK_MKL(load_mkl_function("mkl_dcsrcoo", (void**)&mkl_dcsrcoo_p));
  if (csr->m != csr->n)
  {
    fprintf(stderr, "NM_csr_to_triplet :: the matrix has to be square\n");
    exit(EXIT_FAILURE);
  }
  CSparseMatrix* triplet = cs_spalloc(csr->m, csr->n, csr->p[csr->m], 1, 1);
  assert(triplet);

  CS_INT n = csr->n;
  CS_INT job[6] = {0};
  job[4] = csr->p[csr->m];
  job[5] = 3;
  CS_INT info = 0;
  (*mkl_dcsrcoo_p)(job, &n, csr->x, csr->i, csr->p, &(csr->p[csr->m]), triplet->x, triplet->i, triplet->p, &info);
  triplet->nz = csr->p[csr->m];

  return triplet;
#else
  fprintf(stderr, "NM_csr_to_triplet :: MKL not enabled\n");
  exit(EXIT_FAILURE);
#endif
}
Beispiel #5
0
/* Calculates A*b + D (identity), for a square matrix
   A and scalar b */
cs * scalar_plus_diag (const cs * A, double b, double *D)
{
  int i;
  int j;
  cs * B;

  B = cs_spalloc(A->m, A->n, A->nzmax, 1, 0);

  for (j = 0; j < A->n; j++)
  {
    B->p[j] = A->p[j];
    for (i = A->p[j] ; i < A->p[j+1] ; i++)
    {
      if(A->i[i] == j)
      {
        B->x[i] = b * A->x[i] + D[j];
      } else {
        B->x[i] = b * A->x[i];
      }
      B->i[i] = A->i[i];
    }
  }
  B->p[j] = A->p[j];

  return B;
}
Beispiel #6
0
cs *cs_compress(const cs *T) {

	int m, n, nz, p, k, *Cp, *Ci, *w, *Ti, *Tj;
	double *Cx, *Tx;
	cs *C;
	if (!CS_TRIPLET (T))
		return (NULL); /* check inputs */
	m = T->m;
	n = T->n;
	Ti = T->i;
	Tj = T->p;
	Tx = T->x;
	nz = T->nz;
	C = cs_spalloc(m, n, nz, Tx != NULL, 0); /* allocate result */
	w = (int *) cs_calloc(n, sizeof(int)); /* get workspace */
	if (!C || !w)
		return (cs_done(C, w, NULL, 0)); /* out of memory */
	Cp = C->p;
	Ci = C->i;
	Cx = C->x;
	for (k = 0; k < nz; k++)
		w[Tj[k]]++; /* column counts */
	cs_cumsum(Cp, w, n); /* column pointers */
	for (k = 0; k < nz; k++) {
		Ci[p = w[Tj[k]]++] = Ti[k]; /* A(i,j) is the pth entry in C */
		if (Cx)
			Cx[p] = Tx[k];
	}
	return (cs_done(C, w, NULL, 1)); /* success; free w and return C */
}
Beispiel #7
0
returnValue ACADOcsparse::setMatrix(double *A_)
{
	int run1;
	int order = 0;

	if (dim <= 0)
		return ACADOERROR(RET_MEMBER_NOT_INITIALISED);
	if (nDense <= 0)
		return ACADOERROR(RET_MEMBER_NOT_INITIALISED);

	cs *C, *D;
	C = cs_spalloc(0, 0, 1, 1, 1);

	for (run1 = 0; run1 < nDense; run1++)
		cs_entry(C, index1[run1], index2[run1], A_[run1]);

	D = cs_compress(C);
	S = cs_sqr(order, D, 0);
	N = cs_lu(D, S, TOL);

	cs_spfree(C);
	cs_spfree(D);

	return SUCCESSFUL_RETURN;
}
Beispiel #8
0
cs *cs_transpose(const cs *A, int values) {

	int p, q, j, *Cp, *Ci, n, m, *Ap, *Ai, *w;
	double *Cx, *Ax;
	cs *C;
	if (!CS_CSC (A))
		return (NULL); /* check inputs */
	m = A->m;
	n = A->n;
	Ap = A->p;
	Ai = A->i;
	Ax = A->x;
	C = cs_spalloc(n, m, Ap[n], values && Ax, 0); /* allocate result */
	w = (int *) cs_calloc(m, sizeof(int)); /* get workspace */
	if (!C || !w)
		return (cs_done(C, w, NULL, 0)); /* out of memory */
	Cp = C->p;
	Ci = C->i;
	Cx = C->x;
	for (p = 0; p < Ap[n]; p++)
		w[Ai[p]]++; /* row counts */
	cs_cumsum(Cp, w, m); /* row pointers */
	for (j = 0; j < n; j++) {
		for (p = Ap[j]; p < Ap[j + 1]; p++) {
			Ci[q = w[Ai[p]]++] = j; /* place A(i,j) as entry C(j,i) */
			if (Cx)
				Cx[q] = Ax[p];
		}
	}
	return (cs_done(C, w, NULL, 1)); /* success; free w and return C */
}
/* C = A*B */
cs *cs_multiply (const cs *A, const cs *B)
{
    CS_INT p, j, nz = 0, anz, *Cp, *Ci, *Bp, m, n, bnz, *w, values, *Bi ;
    CS_ENTRY *x, *Bx, *Cx ;
    cs *C ;
    if (!CS_CSC (A) || !CS_CSC (B)) return (NULL) ;      /* check inputs */
    if (A->n != B->m) return (NULL) ;
    m = A->m ; anz = A->p [A->n] ;
    n = B->n ; Bp = B->p ; Bi = B->i ; Bx = B->x ; bnz = Bp [n] ;
    w = cs_calloc (m, sizeof (CS_INT)) ;                    /* get workspace */
    values = (A->x != NULL) && (Bx != NULL) ;
    x = values ? cs_malloc (m, sizeof (CS_ENTRY)) : NULL ; /* get workspace */
    C = cs_spalloc (m, n, anz + bnz, values, 0) ;        /* allocate result */
    if (!C || !w || (values && !x)) return (cs_done (C, w, x, 0)) ;
    Cp = C->p ;
    for (j = 0 ; j < n ; j++)
    {
        if (nz + m > C->nzmax && !cs_sprealloc (C, 2*(C->nzmax)+m))
        {
            return (cs_done (C, w, x, 0)) ;             /* out of memory */
        } 
        Ci = C->i ; Cx = C->x ;         /* C->i and C->x may be reallocated */
        Cp [j] = nz ;                   /* column j of C starts here */
        for (p = Bp [j] ; p < Bp [j+1] ; p++)
        {
            nz = cs_scatter (A, Bi [p], Bx ? Bx [p] : 1, w, x, j+1, C, nz) ;
        }
        if (values) for (p = Cp [j] ; p < nz ; p++) Cx [p] = x [Ci [p]] ;
    }
    Cp [n] = nz ;                       /* finalize the last column of C */
    cs_sprealloc (C, 0) ;               /* remove extra space from C */
    return (cs_done (C, w, x, 1)) ;     /* success; free workspace, return C */
}
Beispiel #10
0
cs *cs_rR(const cs *A, double nu, double nuR, const css *As, const cs *Roldinv, double Roldldet, const cs *pG){
    
	cs *Rnew, *Rnewinv, *Ainv;
	double Rnewldet, MH;
        int dimG = A->n;
	int cnt = 0;
	int i, j;
	
	Rnewinv = cs_spalloc (dimG, dimG, dimG*dimG, 1, 0);
	
	for (i = 0 ; i < dimG; i++){
	  Rnewinv->p[i] = i*dimG;
	  for (j = 0 ; j < dimG; j++){
		Rnewinv->i[cnt] = j;
		Rnewinv->x[cnt] = 0.0;
                A->x[i*dimG+j] -= pG->x[i*dimG+j];
 		cnt++;
	  }
	}
	Rnewinv->p[dimG] = dimG*dimG;
		
	cs_cov2cor(A);
	Ainv = cs_inv(A);
	
	Rnew = cs_rinvwishart(Ainv, nu, As);	
	cs_cov2cor(Rnew);
		
	Rnewldet = log(cs_invR(Rnew, Rnewinv));

/*****************************************************/
/*       From Eq A.4 in Liu and Daniels (2006)       */
/*       using \pi_{1} = Eq 6 in Barnard (2000)      */
/*  using \pi_{2} = Eq 3.4 in Liu and Daniels (2006) */
/*****************************************************/

        MH = Roldldet-Rnewldet;
 
	for (i = 0 ; i < dimG; i++){
          MH += log(Roldinv->x[i*dimG+i]);
          MH -= log(Rnewinv->x[i*dimG+i]);
	}

	MH *= 0.5*nuR;

	if(MH<log(runif(0.0,1.0)) || Rnewldet<log(Dtol)){
	  Rnewldet = cs_invR(Roldinv, Rnew);	// save old R	
        }

        for (i = 0 ; i < dimG; i++){
          for (j = 0 ; j < dimG; j++){
 	    Rnew->x[i*dimG+j] *= sqrt((pG->x[i*dimG+i])*(pG->x[j*dimG+j]));
          }
        }

        cs_spfree(Rnewinv);
        cs_spfree(Ainv);

    return (cs_done (Rnew, NULL, NULL, 1)) ;	/* success; free workspace, return C */

}
Beispiel #11
0
/* C = alpha*A + beta*B */
cs *cs_add (const cs *A, const cs *B, double alpha, double beta)
{
    int p, j, nz = 0, anz, *Cp, *Ci, *Bp, m, n, bnz, *w, values ;
    double *x, *Bx, *Cx ;
    cs *C ;
    if (!CS_CSC (A) || !CS_CSC (B)) return (NULL) ;         /* check inputs */
    if (A->m != B->m || A->n != B->n) return (NULL) ;
    m = A->m ; anz = A->p [A->n] ;
    n = B->n ; Bp = B->p ; Bx = B->x ; bnz = Bp [n] ;
    w = cs_calloc (m, sizeof (int)) ;                       /* get workspace */
    values = (A->x != NULL) && (Bx != NULL) ;
    x = values ? cs_malloc (m, sizeof (double)) : NULL ;    /* get workspace */
    C = cs_spalloc (m, n, anz + bnz, values, 0) ;           /* allocate result*/
    if (!C || !w || (values && !x)) return (cs_done (C, w, x, 0)) ;
    Cp = C->p ; Ci = C->i ; Cx = C->x ;
    for (j = 0 ; j < n ; j++)
    {
        Cp [j] = nz ;                   /* column j of C starts here */
        nz = cs_scatter (A, j, alpha, w, x, j+1, C, nz) ;   /* alpha*A(:,j)*/
        nz = cs_scatter (B, j, beta, w, x, j+1, C, nz) ;    /* beta*B(:,j) */
        if (values) for (p = Cp [j] ; p < nz ; p++) Cx [p] = x [Ci [p]] ;
    }
    Cp [n] = nz ;                       /* finalize the last column of C */
    cs_sprealloc (C, 0) ;               /* remove extra space from C */
    return (cs_done (C, w, x, 1)) ;     /* success; free workspace, return C */
}
Beispiel #12
0
void ppp_copy(cs * to, cs const * from)
{
  int j;
  if(!CS_CSC(to) || !CS_CSC(from)) REPORT_ERR(PPP_EOP);
  if(to->n != from->n || to->m != from->m) REPORT_ERR(PPP_EOP);
  cs * zero = cs_spalloc(from->m, from->n, 0, 1, 0);
  for(j=0;j<=zero->n;++j)
    zero->p[j] = 0;
  ppp_add(to, from, zero, 1);
  cs_spfree(zero);
}
Beispiel #13
0
/**
 * @brief Creates the admittance matrix.
 *
 *    @return 0 on success.
 */
static int econ_createGMatrix (void)
{
   int ret;
   int i, j;
   double R, Rsum;
   cs *M;
   StarSystem *sys;

   /* Create the matrix. */
   M = cs_spalloc( systems_nstack, systems_nstack, 1, 1, 1 );
   if (M == NULL)
      ERR("Unable to create CSparse Matrix.");

   /* Fill the matrix. */
   for (i=0; i < systems_nstack; i++) {
      sys   = &systems_stack[i];
      Rsum = 0.;

      /* Set some values. */
      for (j=0; j < sys->njumps; j++) {

         /* Get the resistances. */
         R     = econ_calcJumpR( sys, &systems_stack[sys->jumps[j]] );
         R     = 1./R; /* Must be inverted. */
         Rsum += R;

         /* Matrix is symetrical and non-diagonal is negative. */
         ret = cs_entry( M, i, sys->jumps[j], -R );
         if (ret != 1)
            WARN("Unable to enter CSparse Matrix Cell.");
         ret = cs_entry( M, sys->jumps[j], i, -R );
         if (ret != 1)
            WARN("Unable to enter CSparse Matrix Cell.");
      }

      /* Set the diagonal. */
      Rsum += 1./ECON_SELF_RES; /* We add a resistence for dampening. */
      cs_entry( M, i, i, Rsum );
   }

   /* Compress M matrix and put into G. */
   if (econ_G != NULL)
      cs_spfree( econ_G );
   econ_G = cs_compress( M );
   if (econ_G == NULL)
      ERR("Unable to create economy G Matrix.");

   /* Clean up. */
   cs_spfree(M);

   return 0;
}
Beispiel #14
0
/* load a triplet matrix from a file */
cs *cs_load (FILE *f)
{
    int i, j ;
    double x ;
    cs *T ;
    if (!f) return (NULL) ;                             /* check inputs */
    T = cs_spalloc (0, 0, 1, 1, 1) ;                    /* allocate result */
    while (fscanf (f, "%d %d %lg\n", &i, &j, &x) == 3)
    {
        if (!cs_entry (T, i, j, x)) return (cs_spfree (T)) ;
    }
    return (T) ;
}
Beispiel #15
0
/* cs_updown: sparse Cholesky update/downdate (rank-1 or multiple rank) */
void mexFunction
(
    int nargout,
    mxArray *pargout [ ],
    int nargin,
    const mxArray *pargin [ ]
)
{
    cs Lmatrix, *Lin, Cmatrix, *C, *L, Cvector, *Cvec ;
    int ignore, j, k, n, lnz, *parent, sigma = 1, cp [2] ;
    char sigma_string [20] ;

    if (nargout > 1 || nargin < 3 || nargin > 4)
    {
        mexErrMsgTxt ("Usage: L = cs_updown(L,C,parent,sigma)") ;
    }
    Lin = cs_mex_get_sparse (&Lmatrix, 1, 1, pargin [0]) ;  /* get input L */
    n = Lin->n ;
    if (nargin > 3 && mxIsChar (pargin [3]))
    {
        mxGetString (pargin [3], sigma_string, 8) ;
        sigma = (sigma_string [0] == '-') ? (-1) : 1 ;
    }
    /* make a copy of L (this can take more work than updating L itself) */
    lnz = Lin->p [n] ;
    L = cs_spalloc (n, n, lnz, 1, 0) ;
    for (j = 0 ; j <= n ; j++) L->p [j] = Lin->p [j] ;
    for (k = 0 ; k < lnz ; k++) L->i [k] = Lin->i [k] ;
    for (k = 0 ; k < lnz ; k++) L->x [k] = Lin->x [k] ;
    cs_mex_check (0, n, -1, 0, 1, 1, pargin [1]) ;         /* get C */
    C = cs_mex_get_sparse (&Cmatrix, 0, 1, pargin [1]) ;
    parent = cs_mex_get_int (n, pargin [2], &ignore, 0) ;  /* get parent */

    /* do the update one column at a time */
    Cvec = &Cvector ;
    Cvec->m = n ;
    Cvec->n = 1 ;
    Cvec->p = cp ;
    Cvec->nz = -1 ;
    cp [0] = 0 ;
    for (k = 0 ; k < C->n ; k++)
    {
        /* extract C(:,k) */ 
        cp [1] = C->p [k+1] - C->p [k] ;
        Cvec->nzmax = cp [1] ;
        Cvec->i = C->i + C->p [k] ;
        Cvec->x = C->x + C->p [k] ;
        cs_updown (L, sigma, Cvec, parent) ;               /* update/downdate */
    }
    pargout [0] = cs_mex_put_sparse (&L) ;                 /* return new L */ 
}
Beispiel #16
0
cs * formKKT(const AMatrix * A, const Settings * s) {
	/* ONLY UPPER TRIANGULAR PART IS STUFFED
	 * forms column compressed KKT matrix
	 * assumes column compressed form A matrix
	 *
	 * forms upper triangular part of [I A'; A -I]
	 */
	scs_int j, k, kk;
	cs * K_cs;
	/* I at top left */
	const scs_int Anz = A->p[A->n];
	const scs_int Knzmax = A->n + A->m + Anz;
	cs * K = cs_spalloc(A->m + A->n, A->m + A->n, Knzmax, 1, 1);

#if EXTRAVERBOSE > 0
	scs_printf("forming KKT\n");
#endif

	if (!K) {
		return NULL;
	}
	kk = 0;
	for (k = 0; k < A->n; k++) {
		K->i[kk] = k;
		K->p[kk] = k;
		K->x[kk] = s->rho_x;
		kk++;
	}
	/* A^T at top right : CCS: */
	for (j = 0; j < A->n; j++) {
		for (k = A->p[j]; k < A->p[j + 1]; k++) {
			K->p[kk] = A->i[k] + A->n;
			K->i[kk] = j;
			K->x[kk] = A->x[k];
			kk++;
		}
	}
	/* -I at bottom right */
	for (k = 0; k < A->m; k++) {
		K->i[kk] = k + A->n;
		K->p[kk] = k + A->n;
		K->x[kk] = -1;
		kk++;
	}
	/* assert kk == Knzmax */
	K->nz = Knzmax;
	K_cs = cs_compress(K);
	cs_spfree(K);
	return (K_cs);
}
Beispiel #17
0
/* create an empty triplet matrix, insert 2 elements, print and free */
int main()
{
  CSparseMatrix *m = cs_spalloc(0,0,0,0,1); /* coo format */
  
  int info1 = 1-cs_entry(m, 3, 4, 1.0);
  int info2 = 1-cs_entry(m, 1, 2, 2.0);

  int info3 = 1-cs_print(m, 0);

  m=cs_spfree(m);

  int info4 = 1-(m==NULL);

  return info1+info2+info3+info4;
}
Beispiel #18
0
CSparseMatrix* NM_csc_to_triplet(CSparseMatrix* csc)
{
  assert(csc);
  CSparseMatrix* triplet = cs_spalloc(csc->m, csc->n, csc->p[csc->n], 1, 1);

  CS_INT* Ap = csc->p;
  CS_INT* Ai = csc->i;
  double* val = csc->x;
  for (CS_INT j = 0; j < csc->n; ++j)
  {
    for (CS_INT i = Ap[j]; i < Ap[j+1]; ++i)
    {
      CSparseMatrix_zentry(triplet, Ai[i], j, val[i]);
    }
  }
  return triplet;
}
Beispiel #19
0
cs *cs_rinvwishart(const cs *A, double nu, const css *As){
    
    int m, i, j, cnt;
    cs *T, *IW, *C, *W, *tC;
    csn *U;
    m = A->n;

    T = cs_spalloc (m, m, m*(m+1)/2, 1, 0) ;	 
    if (!T ) return (cs_done (T, NULL, NULL, 0));   

    double df = nu;
    cnt = 0;

    for(i = 0; i<m; i++){
      T->p[i] = cnt;  
      T->i[cnt] = i;    
      T->x[cnt] = sqrt(rchisq(df));
      cnt++;
      for(j = i+1; j<m; j++){
        T->i[cnt] = j;
        T->x[cnt] = rnorm(0.0,1.0);
        cnt++;
      } 
      df--;
    }
    T->p[m] = m*(m+1)/2;
    U = cs_chol(A, As);  
    if(U==NULL){
      PutRNGstate();
      error("ill-conditioned cross-product: can't form Cholesky factor\n");
    }

    C = cs_multiply(U->L,T);              // t(T)%*%chol(A)
    tC = cs_transpose(C, TRUE);            // t(CI)
    W  = cs_multiply(C,tC);   
    IW = cs_inv(W);                       // crossprod(t(CI))
    cs_spfree(T);
    cs_nfree(U);
    cs_spfree(C);
    cs_spfree(tC);
    cs_spfree(W);

    return (cs_done (IW, NULL, NULL, 1)) ;	/* success; free workspace, return C */

}
Beispiel #20
0
cs *cs_symperm(const cs *A, const int *pinv, int values) {

	int i, j, p, q, i2, j2, n, *Ap, *Ai, *Cp, *Ci, *w;
	double *Cx, *Ax;
	cs *C;
	if (!CS_CSC (A))
		return (NULL); /* check inputs */
	n = A->n;
	Ap = A->p;
	Ai = A->i;
	Ax = A->x;
	C = cs_spalloc(n, n, Ap[n], values && (Ax != NULL), 0); /* alloc result*/
	w = (int *) cs_calloc(n, sizeof(int)); /* get workspace */
	if (!C || !w)
		return (cs_done(C, w, NULL, 0)); /* out of memory */
	Cp = C->p;
	Ci = C->i;
	Cx = C->x;
	for (j = 0; j < n; j++) /* count entries in each column of C */
	{
		j2 = pinv ? pinv[j] : j; /* column j of A is column j2 of C */
		for (p = Ap[j]; p < Ap[j + 1]; p++) {
			i = Ai[p];
			if (i > j)
				continue; /* skip lower triangular part of A */
			i2 = pinv ? pinv[i] : i; /* row i of A is row i2 of C */
			w[CS_MAX (i2, j2)]++; /* column count of C */
		}
	}
	cs_cumsum(Cp, w, n); /* compute column pointers of C */
	for (j = 0; j < n; j++) {
		j2 = pinv ? pinv[j] : j; /* column j of A is column j2 of C */
		for (p = Ap[j]; p < Ap[j + 1]; p++) {
			i = Ai[p];
			if (i > j)
				continue; /* skip lower triangular part of A*/
			i2 = pinv ? pinv[i] : i; /* row i of A is row i2 of C */
			Ci[q = w[CS_MAX (i2, j2)]++] = CS_MIN (i2, j2);
			if (Cx)
				Cx[q] = Ax[p];
		}
	}
	return (cs_done(C, w, NULL, 1)); /* success; free workspace, return C */
}
Beispiel #21
0
void NM_copy_to_sparse(const NumericsMatrix* const A, NumericsMatrix* B)
{
    assert(A);
    assert(B);
    B->size0 = A->size0;
    B->size1 = A->size1;

    assert(B->storageType == NM_SPARSE);
    if (!B->matrix2)
    {
        B->matrix2 = newNumericsSparseMatrix();
    }

    switch (A->storageType)
    {
    case NM_DENSE:
    {
        B->matrix2->triplet = cs_spalloc(0,0,1,1,1);
        NM_dense_to_sparse(A, B);
        break;
    }
    case NM_SPARSE_BLOCK:
    {
        // XXX this is suboptimal since the matrix A might have already been converted
        // to csc or triplet --xhub
        B->matrix1 = A->matrix1;
        B->storageType = NM_SPARSE_BLOCK;
        NM_triplet(B);
        B->matrix1 = NULL;
        B->storageType = NM_SPARSE;
        break;
    }
    case NM_SPARSE:
    {
        NM_copy(A, B);
        break;
    }
    default:
    {
        printf("NM_copy_to_sparse :: Unsupported storage type %d, exiting!\n", A->storageType);
        exit(EXIT_FAILURE);
    }
    }
}
Beispiel #22
0
void mexFunction
(
    int nargout,
    mxArray *pargout [ ],
    int nargin,
    const mxArray *pargin [ ]
)
{
    cs Umatrix, Bmatrix, *U, *B, *X ;
    double *x, *b ;
    int top, nz, p, *xi ;
    if (nargout > 1 || nargin != 2)
    {
        mexErrMsgTxt ("Usage: x = cs_usolve(U,b)") ;
    }
    U = cs_mex_get_sparse (&Umatrix, 1, 1, pargin [0]) ;    /* get U */
    if (mxIsSparse (pargin [1]))
    {
        B = cs_mex_get_sparse (&Bmatrix, 0, 1, pargin [1]) ;/* get sparse b */
        cs_mex_check (0, U->n, 1, 0, 1, 1, pargin [1]) ;
        xi = cs_malloc (2*U->n, sizeof (int)) ;             /* get workspace */
        x  = cs_malloc (U->n, sizeof (double)) ;
        top = cs_spsolve (U, B, 0, xi, x, NULL, 0) ;        /* x = U\b */
        X = cs_spalloc (U->n, 1, U->n-top, 1, 0) ;          /* create sparse x*/
        X->p [0] = 0 ;
        nz = 0 ;
        for (p = top ; p < U->n ; p++)
        {
            X->i [nz] = xi [p] ;
            X->x [nz++] = x [xi [p]] ;
        }
        X->p [1] = nz ;
        pargout [0] = cs_mex_put_sparse (&X) ;
        cs_free (x) ;
        cs_free (xi) ;
    }
    else
    {
        b = cs_mex_get_double (U->n, pargin [1]) ;          /* get full b */
        x = cs_mex_put_double (U->n, b, &(pargout [0])) ;   /* x = b */
        cs_usolve (U, x) ;                                  /* x = U\x */
    }
}
Beispiel #23
0
cs *cs_load(char *matrixFilename) {

	double i, j; /* use double for integers to avoid csi conflicts */
	double x;
	cs *T;
	FILE *matrixFilePtr;

	matrixFilePtr = fopen(matrixFilename, "r");
	if (matrixFilePtr == NULL) {

		fprintf(stderr, "Could not open output file %s for writing\n", matrixFilename);
		exit(EXIT_FAILURE);
	}

	T = cs_spalloc(0, 0, 1, 1, 1); /* allocate result */
	while (fscanf(matrixFilePtr, "%lg %lg %lg\n", &i, &j, &x) == 3) {
		if (!cs_entry(T, i, j, x))
			return (cs_spfree(T));
	}
	return (T);
}
Beispiel #24
0
cs* NN_subColumns_sp(cs* A, int c_left, int c_right)
{
    csi j,p,*Ap,*Ai;
    double *Ax;
    cs *T,*ret;

    Ap = A->p;
    Ai = A->i;
    Ax = A->x;
    if (!A) return (NULL) ;                             /* check inputs */
    T = cs_spalloc (0, 0, 1, 1, 1) ;                    /* allocate result */
    for(j=c_left; j<=c_right; j++) {
        for(p=Ap[j]; p<Ap[j+1]; p++) {
            if(!cs_entry(T, Ai[p], j-c_left, Ax[p])) return (cs_spfree(T));
        }
    }
    cs_entry(T,A->m-1,c_right-c_left,0.0);

    ret = cs_compress(T);
    cs_spfree(T);
    return ret;
}
Beispiel #25
0
void test_ppp_add(char const * A_file, char const * B_file, char const * C_file)
{
  cs * A = ppp_load_ccf(A_file);
  cs * B = ppp_load_ccf(B_file);
  cs *C = NULL, *D = NULL;
  if(C_file)
    C = ppp_load_ccf(C_file);

  cs *  R = cs_spalloc(A->m, A->n, A->p[A->n] + B->p[B->n], 1, 0); /* allocate result*/
  csi mn = A->n > A->m ? A->n : A->m;
  ppp_init_cs(mn);
 
  ppp_add(R, A, B, 1);
  
  /* Test equivalence */
  if(C_file){
  D = cs_add(C,R,1,-1);
  if(cs_norm(D) > cs_norm(C) * PPP_EPSILON){
    fprintf(stderr, "Diff found [%s + %s != %s]:\n", A_file, B_file, C_file);
    fprintf(stdout, "Diff found [%s + %s != %s]:\n", A_file, B_file, C_file);
    fprintf(stdout, "Expected:\n");
    cs_print(C,0);
    fprintf(stdout, "Obtained:\n");
    cs_print(R,0);
    fprintf(stdout, "Diff:\n");
    cs_print(D,0);
  }else{
    fprintf(stdout, "Success!\n");
  }
  }

  /* clean up*/
  cs_spfree(A);
  cs_spfree(B);
  cs_spfree(C);
  cs_spfree(R);
  cs_spfree(D);
  ppp_done();
}
Beispiel #26
0
cs *cs_permute (const cs *A, const int *pinv, const int *q, int values)
{
    int t, j, k, nz = 0, m, n, *Ap, *Ai, *Cp, *Ci ;
    double *Cx, *Ax ;
    cs *C ;
    if (!CS_CSC (A)) return (NULL) ;    /* check inputs */
    m = A->m ; n = A->n ; Ap = A->p ; Ai = A->i ; Ax = A->x ;
    C = cs_spalloc (m, n, Ap [n], values && Ax != NULL, 0) ;  /* alloc result */
    if (!C) return (cs_done (C, NULL, NULL, 0)) ;   /* out of memory */
    Cp = C->p ; Ci = C->i ; Cx = C->x ;
    for (k = 0 ; k < n ; k++)
    {
        Cp [k] = nz ;                   /* column k of C is column q[k] of A */
        j = q ? (q [k]) : k ;
        for (t = Ap [j] ; t < Ap [j+1] ; t++)
        {
            if (Cx) Cx [nz] = Ax [t] ;  /* row i of A is row pinv[i] of C */
            Ci [nz++] = pinv ? (pinv [Ai [t]]) : Ai [t] ;
        }
    }
    Cp [n] = nz ;                       /* finalize the last column of C */
    return (cs_done (C, NULL, NULL, 1)) ;
}
Beispiel #27
0
/* cs_droptol: remove small entries from A */
void mexFunction
(
    int nargout,
    mxArray *pargout [ ],
    int nargin,
    const mxArray *pargin [ ]
)
{
    cs Amatrix, *C, *A ;
    int j, k ;
    double tol ;
    if (nargout > 1 || nargin != 2)
    {
        mexErrMsgTxt ("Usage: C = cs_droptol(A,tol)") ;
    }
    A = cs_mex_get_sparse (&Amatrix, 0, 1, pargin [0]) ;    /* get A */
    tol = mxGetScalar (pargin [1]) ;                        /* get tol */
    C = cs_spalloc (A->m, A->n, A->nzmax, 1, 0) ;           /* C = A */
    for (j = 0 ; j <= A->n ; j++) C->p [j] = A->p [j] ;
    for (k = 0 ; k < A->nzmax ; k++) C->i [k] = A->i [k] ;
    for (k = 0 ; k < A->nzmax ; k++) C->x [k] = A->x [k] ;
    cs_droptol (C, tol) ;                                   /* drop from C */
    pargout [0] = cs_mex_put_sparse (&C) ;                  /* return C */
}
Beispiel #28
0
static
cs *cs_frand (csi n, csi nel, csi s)
{
    csi ss = s*s, nz = nel*ss, e, i, j, *P ;
    cs *A, *T = cs_spalloc (n, n, nz, 1, 1) ;
    if (!T) return (NULL) ;
    P = cs_malloc (s, sizeof (csi)) ;
    if (!P) return (cs_spfree (T)) ;
    for (e = 0 ; e < nel ; e++)
    {
        for (i = 0 ; i < s ; i++) P [i] = rand () % n ;
        for (j = 0 ; j < s ; j++)
        {
            for (i = 0 ; i < s ; i++)
            {
                cs_entry (T, P [i], P [j], rand () / (double) RAND_MAX) ;
            }
        }
    }
    for (i = 0 ; i < n ; i++) cs_entry (T, i, i, 1) ;
    A = cs_compress (T) ;
    cs_spfree (T) ;
    return (cs_dupl (A) ? A : cs_spfree (A)) ;
}
Beispiel #29
0
/* load a triplet matrix from a file */
cs *cs_load (FILE *f)
{
    CS_INT i, j ;
    double x ;
#ifdef CS_COMPLEX
    double xi ;
#endif
    cs *T ;
    if (!f) return (NULL) ;                             /* check inputs */
    T = cs_spalloc (0, 0, 1, 1, 1) ;                    /* allocate result */
#ifdef CS_COMPLEX
    while (fscanf (f, ""CS_ID" "CS_ID" %lg %lg\n", &i, &j, &x, &xi) == 4)
#else
    while (fscanf (f, ""CS_ID" "CS_ID" %lg\n", &i, &j, &x) == 3)
#endif
    {
#ifdef CS_COMPLEX
        if (!cs_entry (T, i, j, x + xi*I)) return (cs_spfree (T)) ;
#else
        if (!cs_entry (T, i, j, x)) return (cs_spfree (T)) ;
#endif
    }
    return (T) ;
}
Beispiel #30
0
void* eigs_dsdrv2_init_cs( int n, const void *data_A, const void *data_M,
                           const EigsOpts_t *opts, cs_fact_type_t type )
{
    const cs *A = (const cs*) data_A;
    (void) data_M;
    cs *C, *B, *T;
    int i, f;
    cs_fact_t *fact;

    if (opts->sigma == 0.) {
        C = (cs*) A;
        f = 0;
    }
    else {
        /* Create Temoporary B matrix as the identity. */
        B = cs_spalloc( n, n, n, 1, 1 );
        for (i=0; i<n; i++)
            cs_entry( B, i, i, 1 );
        T = B;
        B = cs_compress( T );
        cs_spfree( T );

        /* C = A - sigma B */
        C = cs_add( A, B, 1.0, -opts->sigma );
        cs_spfree( B );
        f = 1;
    }

    /* Factorize C and keep factorization. */
    fact = cs_fact_init_type( C, type );

    if (f)
        cs_spfree(C);

    return fact;
}