EVSL  1.1.0
EigenValues Slicing Library
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros
Data Structures | Macros | Typedefs | Functions
cs.h File Reference
#include <stdlib.h>
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <complex.h>
#include "SuiteSparse_config.h"
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  cs_di_sparse
 
struct  cs_di_symbolic
 
struct  cs_di_numeric
 
struct  cs_di_dmperm_results
 
struct  cs_dl_sparse
 
struct  cs_dl_symbolic
 
struct  cs_dl_numeric
 
struct  cs_dl_dmperm_results
 
struct  cs_ci_sparse
 
struct  cs_ci_symbolic
 
struct  cs_ci_numeric
 
struct  cs_ci_dmperm_results
 
struct  cs_cl_sparse
 
struct  cs_cl_symbolic
 
struct  cs_cl_numeric
 
struct  cs_cl_dmperm_results
 

Macros

#define cs_complex_t   double _Complex
 
#define CS_VER   3 /* CXSparse Version */
 
#define CS_SUBVER   1
 
#define CS_SUBSUB   9
 
#define CS_DATE   "May 4, 2016" /* CXSparse release date */
 
#define CS_COPYRIGHT   "Copyright (c) Timothy A. Davis, 2006-2016"
 
#define CXSPARSE
 
#define cs_long_t   SuiteSparse_long
 
#define cs_long_t_id   SuiteSparse_long_id
 
#define cs_long_t_max   SuiteSparse_long_max
 
#define CS_INT   int
 
#define CS_INT_MAX   INT_MAX
 
#define CS_ID   "%d"
 
#define CS_ENTRY   double
 
#define CS_NAME(nm)   cs_di ## nm
 
#define cs   cs_di
 
#define CS_REAL(x)   (x)
 
#define CS_IMAG(x)   (0.)
 
#define CS_CONJ(x)   (x)
 
#define CS_ABS(x)   fabs(x)
 
#define CS_MAX(a, b)   (((a) > (b)) ? (a) : (b))
 
#define CS_MIN(a, b)   (((a) < (b)) ? (a) : (b))
 
#define CS_FLIP(i)   (-(i)-2)
 
#define CS_UNFLIP(i)   (((i) < 0) ? CS_FLIP(i) : (i))
 
#define CS_MARKED(w, j)   (w [j] < 0)
 
#define CS_MARK(w, j)   { w [j] = CS_FLIP (w [j]) ; }
 
#define CS_CSC(A)   (A && (A->nz == -1))
 
#define CS_TRIPLET(A)   (A && (A->nz >= 0))
 
#define cs_add   CS_NAME (_add)
 
#define cs_cholsol   CS_NAME (_cholsol)
 
#define cs_dupl   CS_NAME (_dupl)
 
#define cs_entry   CS_NAME (_entry)
 
#define cs_lusol   CS_NAME (_lusol)
 
#define cs_gaxpy   CS_NAME (_gaxpy)
 
#define cs_multiply   CS_NAME (_multiply)
 
#define cs_qrsol   CS_NAME (_qrsol)
 
#define cs_transpose   CS_NAME (_transpose)
 
#define cs_compress   CS_NAME (_compress)
 
#define cs_norm   CS_NAME (_norm)
 
#define cs_print   CS_NAME (_print)
 
#define cs_load   CS_NAME (_load)
 
#define cs_calloc   CS_NAME (_calloc)
 
#define cs_free   CS_NAME (_free)
 
#define cs_realloc   CS_NAME (_realloc)
 
#define cs_spalloc   CS_NAME (_spalloc)
 
#define cs_spfree   CS_NAME (_spfree)
 
#define cs_sprealloc   CS_NAME (_sprealloc)
 
#define cs_malloc   CS_NAME (_malloc)
 
#define css   CS_NAME (s)
 
#define csn   CS_NAME (n)
 
#define csd   CS_NAME (d)
 
#define cs_amd   CS_NAME (_amd)
 
#define cs_chol   CS_NAME (_chol)
 
#define cs_dmperm   CS_NAME (_dmperm)
 
#define cs_droptol   CS_NAME (_droptol)
 
#define cs_dropzeros   CS_NAME (_dropzeros)
 
#define cs_happly   CS_NAME (_happly)
 
#define cs_ipvec   CS_NAME (_ipvec)
 
#define cs_lsolve   CS_NAME (_lsolve)
 
#define cs_ltsolve   CS_NAME (_ltsolve)
 
#define cs_lu   CS_NAME (_lu)
 
#define cs_permute   CS_NAME (_permute)
 
#define cs_pinv   CS_NAME (_pinv)
 
#define cs_pvec   CS_NAME (_pvec)
 
#define cs_qr   CS_NAME (_qr)
 
#define cs_schol   CS_NAME (_schol)
 
#define cs_sqr   CS_NAME (_sqr)
 
#define cs_symperm   CS_NAME (_symperm)
 
#define cs_usolve   CS_NAME (_usolve)
 
#define cs_utsolve   CS_NAME (_utsolve)
 
#define cs_updown   CS_NAME (_updown)
 
#define cs_sfree   CS_NAME (_sfree)
 
#define cs_nfree   CS_NAME (_nfree)
 
#define cs_dfree   CS_NAME (_dfree)
 
#define cs_counts   CS_NAME (_counts)
 
#define cs_cumsum   CS_NAME (_cumsum)
 
#define cs_dfs   CS_NAME (_dfs)
 
#define cs_etree   CS_NAME (_etree)
 
#define cs_fkeep   CS_NAME (_fkeep)
 
#define cs_house   CS_NAME (_house)
 
#define cs_invmatch   CS_NAME (_invmatch)
 
#define cs_maxtrans   CS_NAME (_maxtrans)
 
#define cs_post   CS_NAME (_post)
 
#define cs_scc   CS_NAME (_scc)
 
#define cs_scatter   CS_NAME (_scatter)
 
#define cs_tdfs   CS_NAME (_tdfs)
 
#define cs_reach   CS_NAME (_reach)
 
#define cs_spsolve   CS_NAME (_spsolve)
 
#define cs_ereach   CS_NAME (_ereach)
 
#define cs_randperm   CS_NAME (_randperm)
 
#define cs_leaf   CS_NAME (_leaf)
 
#define cs_dalloc   CS_NAME (_dalloc)
 
#define cs_done   CS_NAME (_done)
 
#define cs_idone   CS_NAME (_idone)
 
#define cs_ndone   CS_NAME (_ndone)
 
#define cs_ddone   CS_NAME (_ddone)
 

Typedefs

typedef struct cs_di_sparse cs_di
 
typedef struct cs_di_symbolic cs_dis
 
typedef struct cs_di_numeric cs_din
 
typedef struct cs_di_dmperm_results cs_did
 
typedef struct cs_dl_sparse cs_dl
 
typedef struct cs_dl_symbolic cs_dls
 
typedef struct cs_dl_numeric cs_dln
 
typedef struct cs_dl_dmperm_results cs_dld
 
typedef struct cs_ci_sparse cs_ci
 
typedef struct cs_ci_symbolic cs_cis
 
typedef struct cs_ci_numeric cs_cin
 
typedef struct cs_ci_dmperm_results cs_cid
 
typedef struct cs_cl_sparse cs_cl
 
typedef struct cs_cl_symbolic cs_cls
 
typedef struct cs_cl_numeric cs_cln
 
typedef struct cs_cl_dmperm_results cs_cld
 

Functions

cs_di * cs_di_add (const cs_di *A, const cs_di *B, double alpha, double beta)
 
int cs_di_cholsol (int order, const cs_di *A, double *b)
 
int cs_di_dupl (cs_di *A)
 
int cs_di_entry (cs_di *T, int i, int j, double x)
 
int cs_di_lusol (int order, const cs_di *A, double *b, double tol)
 
int cs_di_gaxpy (const cs_di *A, const double *x, double *y)
 
cs_di * cs_di_multiply (const cs_di *A, const cs_di *B)
 
int cs_di_qrsol (int order, const cs_di *A, double *b)
 
cs_di * cs_di_transpose (const cs_di *A, int values)
 
cs_di * cs_di_compress (const cs_di *T)
 
double cs_di_norm (const cs_di *A)
 
int cs_di_print (const cs_di *A, int brief)
 
cs_di * cs_di_load (FILE *f)
 
void * cs_di_calloc (int n, size_t size)
 
void * cs_di_free (void *p)
 
void * cs_di_realloc (void *p, int n, size_t size, int *ok)
 
cs_di * cs_di_spalloc (int m, int n, int nzmax, int values, int t)
 
cs_di * cs_di_spfree (cs_di *A)
 
int cs_di_sprealloc (cs_di *A, int nzmax)
 
void * cs_di_malloc (int n, size_t size)
 
int * cs_di_amd (int order, const cs_di *A)
 
cs_din * cs_di_chol (const cs_di *A, const cs_dis *S)
 
cs_did * cs_di_dmperm (const cs_di *A, int seed)
 
int cs_di_droptol (cs_di *A, double tol)
 
int cs_di_dropzeros (cs_di *A)
 
int cs_di_happly (const cs_di *V, int i, double beta, double *x)
 
int cs_di_ipvec (const int *p, const double *b, double *x, int n)
 
int cs_di_lsolve (const cs_di *L, double *x)
 
int cs_di_ltsolve (const cs_di *L, double *x)
 
cs_din * cs_di_lu (const cs_di *A, const cs_dis *S, double tol)
 
cs_di * cs_di_permute (const cs_di *A, const int *pinv, const int *q, int values)
 
int * cs_di_pinv (const int *p, int n)
 
int cs_di_pvec (const int *p, const double *b, double *x, int n)
 
cs_din * cs_di_qr (const cs_di *A, const cs_dis *S)
 
cs_dis * cs_di_schol (int order, const cs_di *A)
 
cs_dis * cs_di_sqr (int order, const cs_di *A, int qr)
 
cs_di * cs_di_symperm (const cs_di *A, const int *pinv, int values)
 
int cs_di_usolve (const cs_di *U, double *x)
 
int cs_di_utsolve (const cs_di *U, double *x)
 
int cs_di_updown (cs_di *L, int sigma, const cs_di *C, const int *parent)
 
cs_dis * cs_di_sfree (cs_dis *S)
 
cs_din * cs_di_nfree (cs_din *N)
 
cs_did * cs_di_dfree (cs_did *D)
 
int * cs_di_counts (const cs_di *A, const int *parent, const int *post, int ata)
 
double cs_di_cumsum (int *p, int *c, int n)
 
int cs_di_dfs (int j, cs_di *G, int top, int *xi, int *pstack, const int *pinv)
 
int * cs_di_etree (const cs_di *A, int ata)
 
int cs_di_fkeep (cs_di *A, int(*fkeep)(int, int, double, void *), void *other)
 
double cs_di_house (double *x, double *beta, int n)
 
int * cs_di_maxtrans (const cs_di *A, int seed)
 
int * cs_di_post (const int *parent, int n)
 
cs_did * cs_di_scc (cs_di *A)
 
int cs_di_scatter (const cs_di *A, int j, double beta, int *w, double *x, int mark, cs_di *C, int nz)
 
int cs_di_tdfs (int j, int k, int *head, const int *next, int *post, int *stack)
 
int cs_di_leaf (int i, int j, const int *first, int *maxfirst, int *prevleaf, int *ancestor, int *jleaf)
 
int cs_di_reach (cs_di *G, const cs_di *B, int k, int *xi, const int *pinv)
 
int cs_di_spsolve (cs_di *L, const cs_di *B, int k, int *xi, double *x, const int *pinv, int lo)
 
int cs_di_ereach (const cs_di *A, int k, const int *parent, int *s, int *w)
 
int * cs_di_randperm (int n, int seed)
 
cs_did * cs_di_dalloc (int m, int n)
 
cs_di * cs_di_done (cs_di *C, void *w, void *x, int ok)
 
int * cs_di_idone (int *p, cs_di *C, void *w, int ok)
 
cs_din * cs_di_ndone (cs_din *N, cs_di *C, void *w, void *x, int ok)
 
cs_did * cs_di_ddone (cs_did *D, cs_di *C, void *w, int ok)
 
cs_dl * cs_dl_add (const cs_dl *A, const cs_dl *B, double alpha, double beta)
 
cs_long_t cs_dl_cholsol (cs_long_t order, const cs_dl *A, double *b)
 
cs_long_t cs_dl_dupl (cs_dl *A)
 
cs_long_t cs_dl_entry (cs_dl *T, cs_long_t i, cs_long_t j, double x)
 
cs_long_t cs_dl_lusol (cs_long_t order, const cs_dl *A, double *b, double tol)
 
cs_long_t cs_dl_gaxpy (const cs_dl *A, const double *x, double *y)
 
cs_dl * cs_dl_multiply (const cs_dl *A, const cs_dl *B)
 
cs_long_t cs_dl_qrsol (cs_long_t order, const cs_dl *A, double *b)
 
cs_dl * cs_dl_transpose (const cs_dl *A, cs_long_t values)
 
cs_dl * cs_dl_compress (const cs_dl *T)
 
double cs_dl_norm (const cs_dl *A)
 
cs_long_t cs_dl_print (const cs_dl *A, cs_long_t brief)
 
cs_dl * cs_dl_load (FILE *f)
 
void * cs_dl_calloc (cs_long_t n, size_t size)
 
void * cs_dl_free (void *p)
 
void * cs_dl_realloc (void *p, cs_long_t n, size_t size, cs_long_t *ok)
 
cs_dl * cs_dl_spalloc (cs_long_t m, cs_long_t n, cs_long_t nzmax, cs_long_t values, cs_long_t t)
 
cs_dl * cs_dl_spfree (cs_dl *A)
 
cs_long_t cs_dl_sprealloc (cs_dl *A, cs_long_t nzmax)
 
void * cs_dl_malloc (cs_long_t n, size_t size)
 
cs_long_t * cs_dl_amd (cs_long_t order, const cs_dl *A)
 
cs_dln * cs_dl_chol (const cs_dl *A, const cs_dls *S)
 
cs_dld * cs_dl_dmperm (const cs_dl *A, cs_long_t seed)
 
cs_long_t cs_dl_droptol (cs_dl *A, double tol)
 
cs_long_t cs_dl_dropzeros (cs_dl *A)
 
cs_long_t cs_dl_happly (const cs_dl *V, cs_long_t i, double beta, double *x)
 
cs_long_t cs_dl_ipvec (const cs_long_t *p, const double *b, double *x, cs_long_t n)
 
cs_long_t cs_dl_lsolve (const cs_dl *L, double *x)
 
cs_long_t cs_dl_ltsolve (const cs_dl *L, double *x)
 
cs_dln * cs_dl_lu (const cs_dl *A, const cs_dls *S, double tol)
 
cs_dl * cs_dl_permute (const cs_dl *A, const cs_long_t *pinv, const cs_long_t *q, cs_long_t values)
 
cs_long_t * cs_dl_pinv (const cs_long_t *p, cs_long_t n)
 
cs_long_t cs_dl_pvec (const cs_long_t *p, const double *b, double *x, cs_long_t n)
 
cs_dln * cs_dl_qr (const cs_dl *A, const cs_dls *S)
 
cs_dls * cs_dl_schol (cs_long_t order, const cs_dl *A)
 
cs_dls * cs_dl_sqr (cs_long_t order, const cs_dl *A, cs_long_t qr)
 
cs_dl * cs_dl_symperm (const cs_dl *A, const cs_long_t *pinv, cs_long_t values)
 
cs_long_t cs_dl_usolve (const cs_dl *U, double *x)
 
cs_long_t cs_dl_utsolve (const cs_dl *U, double *x)
 
cs_long_t cs_dl_updown (cs_dl *L, cs_long_t sigma, const cs_dl *C, const cs_long_t *parent)
 
cs_dls * cs_dl_sfree (cs_dls *S)
 
cs_dln * cs_dl_nfree (cs_dln *N)
 
cs_dld * cs_dl_dfree (cs_dld *D)
 
cs_long_t * cs_dl_counts (const cs_dl *A, const cs_long_t *parent, const cs_long_t *post, cs_long_t ata)
 
double cs_dl_cumsum (cs_long_t *p, cs_long_t *c, cs_long_t n)
 
cs_long_t cs_dl_dfs (cs_long_t j, cs_dl *G, cs_long_t top, cs_long_t *xi, cs_long_t *pstack, const cs_long_t *pinv)
 
cs_long_t * cs_dl_etree (const cs_dl *A, cs_long_t ata)
 
cs_long_t cs_dl_fkeep (cs_dl *A, cs_long_t(*fkeep)(cs_long_t, cs_long_t, double, void *), void *other)
 
double cs_dl_house (double *x, double *beta, cs_long_t n)
 
cs_long_t * cs_dl_maxtrans (const cs_dl *A, cs_long_t seed)
 
cs_long_t * cs_dl_post (const cs_long_t *parent, cs_long_t n)
 
cs_dld * cs_dl_scc (cs_dl *A)
 
cs_long_t cs_dl_scatter (const cs_dl *A, cs_long_t j, double beta, cs_long_t *w, double *x, cs_long_t mark, cs_dl *C, cs_long_t nz)
 
cs_long_t cs_dl_tdfs (cs_long_t j, cs_long_t k, cs_long_t *head, const cs_long_t *next, cs_long_t *post, cs_long_t *stack)
 
cs_long_t cs_dl_leaf (cs_long_t i, cs_long_t j, const cs_long_t *first, cs_long_t *maxfirst, cs_long_t *prevleaf, cs_long_t *ancestor, cs_long_t *jleaf)
 
cs_long_t cs_dl_reach (cs_dl *G, const cs_dl *B, cs_long_t k, cs_long_t *xi, const cs_long_t *pinv)
 
cs_long_t cs_dl_spsolve (cs_dl *L, const cs_dl *B, cs_long_t k, cs_long_t *xi, double *x, const cs_long_t *pinv, cs_long_t lo)
 
cs_long_t cs_dl_ereach (const cs_dl *A, cs_long_t k, const cs_long_t *parent, cs_long_t *s, cs_long_t *w)
 
cs_long_t * cs_dl_randperm (cs_long_t n, cs_long_t seed)
 
cs_dld * cs_dl_dalloc (cs_long_t m, cs_long_t n)
 
cs_dl * cs_dl_done (cs_dl *C, void *w, void *x, cs_long_t ok)
 
cs_long_t * cs_dl_idone (cs_long_t *p, cs_dl *C, void *w, cs_long_t ok)
 
cs_dln * cs_dl_ndone (cs_dln *N, cs_dl *C, void *w, void *x, cs_long_t ok)
 
cs_dld * cs_dl_ddone (cs_dld *D, cs_dl *C, void *w, cs_long_t ok)
 
cs_ci * cs_ci_add (const cs_ci *A, const cs_ci *B, cs_complex_t alpha, cs_complex_t beta)
 
int cs_ci_cholsol (int order, const cs_ci *A, cs_complex_t *b)
 
int cs_ci_dupl (cs_ci *A)
 
int cs_ci_entry (cs_ci *T, int i, int j, cs_complex_t x)
 
int cs_ci_lusol (int order, const cs_ci *A, cs_complex_t *b, double tol)
 
int cs_ci_gaxpy (const cs_ci *A, const cs_complex_t *x, cs_complex_t *y)
 
cs_ci * cs_ci_multiply (const cs_ci *A, const cs_ci *B)
 
int cs_ci_qrsol (int order, const cs_ci *A, cs_complex_t *b)
 
cs_ci * cs_ci_transpose (const cs_ci *A, int values)
 
cs_ci * cs_ci_compress (const cs_ci *T)
 
double cs_ci_norm (const cs_ci *A)
 
int cs_ci_print (const cs_ci *A, int brief)
 
cs_ci * cs_ci_load (FILE *f)
 
void * cs_ci_calloc (int n, size_t size)
 
void * cs_ci_free (void *p)
 
void * cs_ci_realloc (void *p, int n, size_t size, int *ok)
 
cs_ci * cs_ci_spalloc (int m, int n, int nzmax, int values, int t)
 
cs_ci * cs_ci_spfree (cs_ci *A)
 
int cs_ci_sprealloc (cs_ci *A, int nzmax)
 
void * cs_ci_malloc (int n, size_t size)
 
int * cs_ci_amd (int order, const cs_ci *A)
 
cs_cin * cs_ci_chol (const cs_ci *A, const cs_cis *S)
 
cs_cid * cs_ci_dmperm (const cs_ci *A, int seed)
 
int cs_ci_droptol (cs_ci *A, double tol)
 
int cs_ci_dropzeros (cs_ci *A)
 
int cs_ci_happly (const cs_ci *V, int i, double beta, cs_complex_t *x)
 
int cs_ci_ipvec (const int *p, const cs_complex_t *b, cs_complex_t *x, int n)
 
int cs_ci_lsolve (const cs_ci *L, cs_complex_t *x)
 
int cs_ci_ltsolve (const cs_ci *L, cs_complex_t *x)
 
cs_cin * cs_ci_lu (const cs_ci *A, const cs_cis *S, double tol)
 
cs_ci * cs_ci_permute (const cs_ci *A, const int *pinv, const int *q, int values)
 
int * cs_ci_pinv (const int *p, int n)
 
int cs_ci_pvec (const int *p, const cs_complex_t *b, cs_complex_t *x, int n)
 
cs_cin * cs_ci_qr (const cs_ci *A, const cs_cis *S)
 
cs_cis * cs_ci_schol (int order, const cs_ci *A)
 
cs_cis * cs_ci_sqr (int order, const cs_ci *A, int qr)
 
cs_ci * cs_ci_symperm (const cs_ci *A, const int *pinv, int values)
 
int cs_ci_usolve (const cs_ci *U, cs_complex_t *x)
 
int cs_ci_utsolve (const cs_ci *U, cs_complex_t *x)
 
int cs_ci_updown (cs_ci *L, int sigma, const cs_ci *C, const int *parent)
 
cs_cis * cs_ci_sfree (cs_cis *S)
 
cs_cin * cs_ci_nfree (cs_cin *N)
 
cs_cid * cs_ci_dfree (cs_cid *D)
 
int * cs_ci_counts (const cs_ci *A, const int *parent, const int *post, int ata)
 
double cs_ci_cumsum (int *p, int *c, int n)
 
int cs_ci_dfs (int j, cs_ci *G, int top, int *xi, int *pstack, const int *pinv)
 
int * cs_ci_etree (const cs_ci *A, int ata)
 
int cs_ci_fkeep (cs_ci *A, int(*fkeep)(int, int, cs_complex_t, void *), void *other)
 
cs_complex_t cs_ci_house (cs_complex_t *x, double *beta, int n)
 
int * cs_ci_maxtrans (const cs_ci *A, int seed)
 
int * cs_ci_post (const int *parent, int n)
 
cs_cid * cs_ci_scc (cs_ci *A)
 
int cs_ci_scatter (const cs_ci *A, int j, cs_complex_t beta, int *w, cs_complex_t *x, int mark, cs_ci *C, int nz)
 
int cs_ci_tdfs (int j, int k, int *head, const int *next, int *post, int *stack)
 
int cs_ci_leaf (int i, int j, const int *first, int *maxfirst, int *prevleaf, int *ancestor, int *jleaf)
 
int cs_ci_reach (cs_ci *G, const cs_ci *B, int k, int *xi, const int *pinv)
 
int cs_ci_spsolve (cs_ci *L, const cs_ci *B, int k, int *xi, cs_complex_t *x, const int *pinv, int lo)
 
int cs_ci_ereach (const cs_ci *A, int k, const int *parent, int *s, int *w)
 
int * cs_ci_randperm (int n, int seed)
 
cs_cid * cs_ci_dalloc (int m, int n)
 
cs_ci * cs_ci_done (cs_ci *C, void *w, void *x, int ok)
 
int * cs_ci_idone (int *p, cs_ci *C, void *w, int ok)
 
cs_cin * cs_ci_ndone (cs_cin *N, cs_ci *C, void *w, void *x, int ok)
 
cs_cid * cs_ci_ddone (cs_cid *D, cs_ci *C, void *w, int ok)
 
cs_cl * cs_cl_add (const cs_cl *A, const cs_cl *B, cs_complex_t alpha, cs_complex_t beta)
 
cs_long_t cs_cl_cholsol (cs_long_t order, const cs_cl *A, cs_complex_t *b)
 
cs_long_t cs_cl_dupl (cs_cl *A)
 
cs_long_t cs_cl_entry (cs_cl *T, cs_long_t i, cs_long_t j, cs_complex_t x)
 
cs_long_t cs_cl_lusol (cs_long_t order, const cs_cl *A, cs_complex_t *b, double tol)
 
cs_long_t cs_cl_gaxpy (const cs_cl *A, const cs_complex_t *x, cs_complex_t *y)
 
cs_cl * cs_cl_multiply (const cs_cl *A, const cs_cl *B)
 
cs_long_t cs_cl_qrsol (cs_long_t order, const cs_cl *A, cs_complex_t *b)
 
cs_cl * cs_cl_transpose (const cs_cl *A, cs_long_t values)
 
cs_cl * cs_cl_compress (const cs_cl *T)
 
double cs_cl_norm (const cs_cl *A)
 
cs_long_t cs_cl_print (const cs_cl *A, cs_long_t brief)
 
cs_cl * cs_cl_load (FILE *f)
 
void * cs_cl_calloc (cs_long_t n, size_t size)
 
void * cs_cl_free (void *p)
 
void * cs_cl_realloc (void *p, cs_long_t n, size_t size, cs_long_t *ok)
 
cs_cl * cs_cl_spalloc (cs_long_t m, cs_long_t n, cs_long_t nzmax, cs_long_t values, cs_long_t t)
 
cs_cl * cs_cl_spfree (cs_cl *A)
 
cs_long_t cs_cl_sprealloc (cs_cl *A, cs_long_t nzmax)
 
void * cs_cl_malloc (cs_long_t n, size_t size)
 
cs_long_t * cs_cl_amd (cs_long_t order, const cs_cl *A)
 
cs_cln * cs_cl_chol (const cs_cl *A, const cs_cls *S)
 
cs_cld * cs_cl_dmperm (const cs_cl *A, cs_long_t seed)
 
cs_long_t cs_cl_droptol (cs_cl *A, double tol)
 
cs_long_t cs_cl_dropzeros (cs_cl *A)
 
cs_long_t cs_cl_happly (const cs_cl *V, cs_long_t i, double beta, cs_complex_t *x)
 
cs_long_t cs_cl_ipvec (const cs_long_t *p, const cs_complex_t *b, cs_complex_t *x, cs_long_t n)
 
cs_long_t cs_cl_lsolve (const cs_cl *L, cs_complex_t *x)
 
cs_long_t cs_cl_ltsolve (const cs_cl *L, cs_complex_t *x)
 
cs_cln * cs_cl_lu (const cs_cl *A, const cs_cls *S, double tol)
 
cs_cl * cs_cl_permute (const cs_cl *A, const cs_long_t *pinv, const cs_long_t *q, cs_long_t values)
 
cs_long_t * cs_cl_pinv (const cs_long_t *p, cs_long_t n)
 
cs_long_t cs_cl_pvec (const cs_long_t *p, const cs_complex_t *b, cs_complex_t *x, cs_long_t n)
 
cs_cln * cs_cl_qr (const cs_cl *A, const cs_cls *S)
 
cs_cls * cs_cl_schol (cs_long_t order, const cs_cl *A)
 
cs_cls * cs_cl_sqr (cs_long_t order, const cs_cl *A, cs_long_t qr)
 
cs_cl * cs_cl_symperm (const cs_cl *A, const cs_long_t *pinv, cs_long_t values)
 
cs_long_t cs_cl_usolve (const cs_cl *U, cs_complex_t *x)
 
cs_long_t cs_cl_utsolve (const cs_cl *U, cs_complex_t *x)
 
cs_long_t cs_cl_updown (cs_cl *L, cs_long_t sigma, const cs_cl *C, const cs_long_t *parent)
 
cs_cls * cs_cl_sfree (cs_cls *S)
 
cs_cln * cs_cl_nfree (cs_cln *N)
 
cs_cld * cs_cl_dfree (cs_cld *D)
 
cs_long_t * cs_cl_counts (const cs_cl *A, const cs_long_t *parent, const cs_long_t *post, cs_long_t ata)
 
double cs_cl_cumsum (cs_long_t *p, cs_long_t *c, cs_long_t n)
 
cs_long_t cs_cl_dfs (cs_long_t j, cs_cl *G, cs_long_t top, cs_long_t *xi, cs_long_t *pstack, const cs_long_t *pinv)
 
cs_long_t * cs_cl_etree (const cs_cl *A, cs_long_t ata)
 
cs_long_t cs_cl_fkeep (cs_cl *A, cs_long_t(*fkeep)(cs_long_t, cs_long_t, cs_complex_t, void *), void *other)
 
cs_complex_t cs_cl_house (cs_complex_t *x, double *beta, cs_long_t n)
 
cs_long_t * cs_cl_maxtrans (const cs_cl *A, cs_long_t seed)
 
cs_long_t * cs_cl_post (const cs_long_t *parent, cs_long_t n)
 
cs_cld * cs_cl_scc (cs_cl *A)
 
cs_long_t cs_cl_scatter (const cs_cl *A, cs_long_t j, cs_complex_t beta, cs_long_t *w, cs_complex_t *x, cs_long_t mark, cs_cl *C, cs_long_t nz)
 
cs_long_t cs_cl_tdfs (cs_long_t j, cs_long_t k, cs_long_t *head, const cs_long_t *next, cs_long_t *post, cs_long_t *stack)
 
cs_long_t cs_cl_leaf (cs_long_t i, cs_long_t j, const cs_long_t *first, cs_long_t *maxfirst, cs_long_t *prevleaf, cs_long_t *ancestor, cs_long_t *jleaf)
 
cs_long_t cs_cl_reach (cs_cl *G, const cs_cl *B, cs_long_t k, cs_long_t *xi, const cs_long_t *pinv)
 
cs_long_t cs_cl_spsolve (cs_cl *L, const cs_cl *B, cs_long_t k, cs_long_t *xi, cs_complex_t *x, const cs_long_t *pinv, cs_long_t lo)
 
cs_long_t cs_cl_ereach (const cs_cl *A, cs_long_t k, const cs_long_t *parent, cs_long_t *s, cs_long_t *w)
 
cs_long_t * cs_cl_randperm (cs_long_t n, cs_long_t seed)
 
cs_cld * cs_cl_dalloc (cs_long_t m, cs_long_t n)
 
cs_cl * cs_cl_done (cs_cl *C, void *w, void *x, cs_long_t ok)
 
cs_long_t * cs_cl_idone (cs_long_t *p, cs_cl *C, void *w, cs_long_t ok)
 
cs_cln * cs_cl_ndone (cs_cln *N, cs_cl *C, void *w, void *x, cs_long_t ok)
 
cs_cld * cs_cl_ddone (cs_cld *D, cs_cl *C, void *w, cs_long_t ok)
 
cs_di * cs_i_real (cs_ci *A, int real)
 
cs_ci * cs_i_complex (cs_di *A, int real)
 
cs_dl * cs_l_real (cs_cl *A, cs_long_t real)
 
cs_cl * cs_l_complex (cs_dl *A, cs_long_t real)
 

Macro Definition Documentation

#define cs   cs_di

Definition at line 637 of file cs.h.

Referenced by cs_add(), cs_amd(), cs_chol(), cs_compress(), cs_counts(), cs_dmperm(), cs_load(), cs_lu(), cs_maxtrans(), cs_multiply(), cs_permute(), cs_qr(), cs_qrsol(), cs_scc(), cs_schol(), cs_spalloc(), cs_spfree(), cs_sqr(), cs_symperm(), and cs_transpose().

#define CS_ABS (   x)    fabs(x)

Definition at line 650 of file cs.h.

Referenced by cs_house(), cs_lu(), cs_norm(), and cs_updown().

#define cs_add   CS_NAME (_add)

Definition at line 664 of file cs.h.

#define cs_amd   CS_NAME (_amd)

Definition at line 692 of file cs.h.

#define cs_calloc   CS_NAME (_calloc)

Definition at line 679 of file cs.h.

#define cs_chol   CS_NAME (_chol)

Definition at line 693 of file cs.h.

#define cs_cholsol   CS_NAME (_cholsol)

Definition at line 665 of file cs.h.

#define cs_complex_t   double _Complex

Definition at line 41 of file cs.h.

Referenced by ASIGMABSolDirect(), cs_i_complex(), cs_i_real(), cs_l_complex(), cs_l_real(), cs_updown(), and SetupASIGMABSolDirect().

#define cs_compress   CS_NAME (_compress)

Definition at line 673 of file cs.h.

#define CS_CONJ (   x)    (x)

Definition at line 649 of file cs.h.

Referenced by cs_chol(), cs_happly(), cs_house(), cs_ltsolve(), cs_symperm(), cs_transpose(), cs_updown(), and cs_utsolve().

#define CS_COPYRIGHT   "Copyright (c) Timothy A. Davis, 2006-2016"

Definition at line 49 of file cs.h.

Referenced by cs_print().

#define cs_counts   CS_NAME (_counts)

Definition at line 719 of file cs.h.

#define CS_CSC (   A)    (A && (A->nz == -1))

Definition at line 659 of file cs.h.

Referenced by cs_add(), cs_amd(), cs_chol(), cs_cholsol(), cs_counts(), cs_dfs(), cs_dmperm(), cs_dupl(), cs_ereach(), cs_etree(), cs_fkeep(), cs_gaxpy(), cs_happly(), cs_lsolve(), cs_ltsolve(), cs_lu(), cs_lusol(), cs_maxtrans(), cs_multiply(), cs_norm(), cs_permute(), cs_qr(), cs_qrsol(), cs_reach(), cs_scatter(), cs_scc(), cs_schol(), cs_sprealloc(), cs_spsolve(), cs_sqr(), cs_symperm(), cs_transpose(), cs_updown(), cs_usolve(), and cs_utsolve().

#define cs_cumsum   CS_NAME (_cumsum)

Definition at line 720 of file cs.h.

#define cs_dalloc   CS_NAME (_dalloc)

Definition at line 738 of file cs.h.

#define CS_DATE   "May 4, 2016" /* CXSparse release date */

Definition at line 48 of file cs.h.

Referenced by cs_print().

#define cs_ddone   CS_NAME (_ddone)

Definition at line 742 of file cs.h.

#define cs_dfree   CS_NAME (_dfree)

Definition at line 716 of file cs.h.

#define cs_dfs   CS_NAME (_dfs)

Definition at line 721 of file cs.h.

#define cs_dmperm   CS_NAME (_dmperm)

Definition at line 694 of file cs.h.

#define cs_done   CS_NAME (_done)

Definition at line 739 of file cs.h.

#define cs_droptol   CS_NAME (_droptol)

Definition at line 695 of file cs.h.

#define cs_dropzeros   CS_NAME (_dropzeros)

Definition at line 696 of file cs.h.

#define cs_dupl   CS_NAME (_dupl)

Definition at line 666 of file cs.h.

#define CS_ENTRY   double

Definition at line 635 of file cs.h.

Referenced by cs_add(), cs_chol(), cs_cholsol(), cs_compress(), cs_dupl(), cs_fkeep(), cs_gaxpy(), cs_happly(), cs_house(), cs_lsolve(), cs_ltsolve(), cs_lu(), cs_lusol(), cs_multiply(), cs_norm(), cs_permute(), cs_print(), cs_qr(), cs_qrsol(), cs_scatter(), cs_spalloc(), cs_sprealloc(), cs_spsolve(), cs_symperm(), cs_transpose(), cs_updown(), cs_usolve(), and cs_utsolve().

#define cs_entry   CS_NAME (_entry)

Definition at line 667 of file cs.h.

#define cs_ereach   CS_NAME (_ereach)

Definition at line 733 of file cs.h.

#define cs_etree   CS_NAME (_etree)

Definition at line 722 of file cs.h.

#define cs_fkeep   CS_NAME (_fkeep)

Definition at line 723 of file cs.h.

#define CS_FLIP (   i)    (-(i)-2)

Definition at line 655 of file cs.h.

Referenced by cs_amd().

#define cs_free   CS_NAME (_free)

Definition at line 680 of file cs.h.

#define cs_gaxpy   CS_NAME (_gaxpy)

Definition at line 669 of file cs.h.

#define cs_happly   CS_NAME (_happly)

Definition at line 697 of file cs.h.

#define cs_house   CS_NAME (_house)

Definition at line 724 of file cs.h.

#define CS_ID   "%d"

Definition at line 629 of file cs.h.

#define cs_idone   CS_NAME (_idone)

Definition at line 740 of file cs.h.

#define CS_IMAG (   x)    (0.)

Definition at line 648 of file cs.h.

Referenced by cs_chol(), and cs_print().

#define CS_INT   int

Definition at line 627 of file cs.h.

Referenced by cs_add(), cs_amd(), cs_chol(), cs_cholsol(), cs_compress(), cs_counts(), cs_cumsum(), cs_dalloc(), cs_dfs(), cs_dmperm(), cs_dupl(), cs_ereach(), cs_etree(), cs_fkeep(), cs_gaxpy(), cs_happly(), cs_house(), cs_idone(), cs_ipvec(), cs_leaf(), cs_load(), cs_lsolve(), cs_ltsolve(), cs_lu(), cs_lusol(), cs_maxtrans(), cs_multiply(), cs_norm(), cs_permute(), cs_pinv(), cs_post(), cs_print(), cs_pvec(), cs_qr(), cs_qrsol(), cs_randperm(), cs_reach(), cs_scatter(), cs_scc(), cs_schol(), cs_spalloc(), cs_sprealloc(), cs_spsolve(), cs_sqr(), cs_symperm(), cs_tdfs(), cs_transpose(), cs_updown(), cs_usolve(), and cs_utsolve().

#define CS_INT_MAX   INT_MAX

Definition at line 628 of file cs.h.

#define cs_invmatch   CS_NAME (_invmatch)

Definition at line 725 of file cs.h.

#define cs_ipvec   CS_NAME (_ipvec)

Definition at line 698 of file cs.h.

#define cs_leaf   CS_NAME (_leaf)

Definition at line 735 of file cs.h.

#define cs_load   CS_NAME (_load)

Definition at line 676 of file cs.h.

#define cs_long_t   SuiteSparse_long

Definition at line 53 of file cs.h.

Referenced by cs_l_complex(), and cs_l_real().

#define cs_long_t_id   SuiteSparse_long_id

Definition at line 54 of file cs.h.

#define cs_long_t_max   SuiteSparse_long_max

Definition at line 55 of file cs.h.

#define cs_lsolve   CS_NAME (_lsolve)

Definition at line 699 of file cs.h.

#define cs_ltsolve   CS_NAME (_ltsolve)

Definition at line 700 of file cs.h.

#define cs_lu   CS_NAME (_lu)

Definition at line 701 of file cs.h.

#define cs_lusol   CS_NAME (_lusol)

Definition at line 668 of file cs.h.

#define cs_malloc   CS_NAME (_malloc)

Definition at line 685 of file cs.h.

#define CS_MARK (   w,
  j 
)    { w [j] = CS_FLIP (w [j]) ; }

Definition at line 658 of file cs.h.

Referenced by cs_dfs(), cs_ereach(), cs_reach(), and cs_scc().

#define CS_MARKED (   w,
  j 
)    (w [j] < 0)

Definition at line 657 of file cs.h.

Referenced by cs_dfs(), cs_ereach(), cs_reach(), and cs_scc().

#define CS_MAX (   a,
  b 
)    (((a) > (b)) ? (a) : (b))

Definition at line 653 of file cs.h.

Referenced by cs_amd(), cs_calloc(), cs_entry(), cs_malloc(), cs_norm(), cs_realloc(), cs_spalloc(), cs_sprealloc(), and cs_symperm().

#define cs_maxtrans   CS_NAME (_maxtrans)

Definition at line 726 of file cs.h.

#define CS_MIN (   a,
  b 
)    (((a) < (b)) ? (a) : (b))

Definition at line 654 of file cs.h.

Referenced by cs_amd(), cs_maxtrans(), cs_symperm(), and cs_updown().

#define cs_multiply   CS_NAME (_multiply)

Definition at line 670 of file cs.h.

#define CS_NAME (   nm)    cs_di ## nm

Definition at line 636 of file cs.h.

#define cs_ndone   CS_NAME (_ndone)

Definition at line 741 of file cs.h.

#define cs_nfree   CS_NAME (_nfree)

Definition at line 715 of file cs.h.

#define cs_norm   CS_NAME (_norm)

Definition at line 674 of file cs.h.

#define cs_permute   CS_NAME (_permute)

Definition at line 702 of file cs.h.

#define cs_pinv   CS_NAME (_pinv)

Definition at line 703 of file cs.h.

#define cs_post   CS_NAME (_post)

Definition at line 727 of file cs.h.

#define cs_print   CS_NAME (_print)

Definition at line 675 of file cs.h.

#define cs_pvec   CS_NAME (_pvec)

Definition at line 704 of file cs.h.

#define cs_qr   CS_NAME (_qr)

Definition at line 705 of file cs.h.

#define cs_qrsol   CS_NAME (_qrsol)

Definition at line 671 of file cs.h.

#define cs_randperm   CS_NAME (_randperm)

Definition at line 734 of file cs.h.

#define cs_reach   CS_NAME (_reach)

Definition at line 731 of file cs.h.

#define CS_REAL (   x)    (x)

Definition at line 647 of file cs.h.

Referenced by cs_chol(), cs_house(), and cs_print().

#define cs_realloc   CS_NAME (_realloc)

Definition at line 681 of file cs.h.

#define cs_scatter   CS_NAME (_scatter)

Definition at line 729 of file cs.h.

#define cs_scc   CS_NAME (_scc)

Definition at line 728 of file cs.h.

#define cs_schol   CS_NAME (_schol)

Definition at line 706 of file cs.h.

#define cs_sfree   CS_NAME (_sfree)

Definition at line 714 of file cs.h.

#define cs_spalloc   CS_NAME (_spalloc)

Definition at line 682 of file cs.h.

#define cs_spfree   CS_NAME (_spfree)

Definition at line 683 of file cs.h.

#define cs_sprealloc   CS_NAME (_sprealloc)

Definition at line 684 of file cs.h.

#define cs_spsolve   CS_NAME (_spsolve)

Definition at line 732 of file cs.h.

#define cs_sqr   CS_NAME (_sqr)

Definition at line 707 of file cs.h.

#define CS_SUBSUB   9

Definition at line 47 of file cs.h.

Referenced by cs_print().

#define CS_SUBVER   1

Definition at line 46 of file cs.h.

Referenced by cs_print().

#define cs_symperm   CS_NAME (_symperm)

Definition at line 708 of file cs.h.

#define cs_tdfs   CS_NAME (_tdfs)

Definition at line 730 of file cs.h.

#define cs_transpose   CS_NAME (_transpose)

Definition at line 672 of file cs.h.

#define CS_TRIPLET (   A)    (A && (A->nz >= 0))

Definition at line 660 of file cs.h.

Referenced by cs_compress(), cs_entry(), and cs_sprealloc().

#define CS_UNFLIP (   i)    (((i) < 0) ? CS_FLIP(i) : (i))

Definition at line 656 of file cs.h.

Referenced by cs_dfs().

#define cs_updown   CS_NAME (_updown)

Definition at line 711 of file cs.h.

#define cs_usolve   CS_NAME (_usolve)

Definition at line 709 of file cs.h.

#define cs_utsolve   CS_NAME (_utsolve)

Definition at line 710 of file cs.h.

#define CS_VER   3 /* CXSparse Version */

Definition at line 45 of file cs.h.

Referenced by cs_print().

#define csd   CS_NAME (d)

Definition at line 690 of file cs.h.

Referenced by cs_dalloc(), cs_dfree(), cs_dmperm(), and cs_scc().

#define csn   CS_NAME (n)

Definition at line 689 of file cs.h.

Referenced by cs_chol(), cs_cholsol(), cs_lu(), cs_lusol(), cs_nfree(), cs_qr(), and cs_qrsol().

#define css   CS_NAME (s)

Definition at line 688 of file cs.h.

Referenced by cs_cholsol(), cs_lusol(), cs_qrsol(), cs_schol(), cs_sfree(), and cs_sqr().

#define CXSPARSE

Definition at line 50 of file cs.h.

Typedef Documentation

typedef struct cs_ci_sparse cs_ci
typedef struct cs_ci_dmperm_results cs_cid
typedef struct cs_ci_numeric cs_cin
typedef struct cs_ci_symbolic cs_cis
typedef struct cs_cl_sparse cs_cl
typedef struct cs_cl_dmperm_results cs_cld
typedef struct cs_cl_numeric cs_cln
typedef struct cs_cl_symbolic cs_cls
typedef struct cs_di_sparse cs_di
typedef struct cs_di_dmperm_results cs_did
typedef struct cs_di_numeric cs_din
typedef struct cs_di_symbolic cs_dis
typedef struct cs_dl_sparse cs_dl
typedef struct cs_dl_dmperm_results cs_dld
typedef struct cs_dl_numeric cs_dln
typedef struct cs_dl_symbolic cs_dls

Function Documentation

cs_ci* cs_ci_add ( const cs_ci *  A,
const cs_ci *  B,
cs_complex_t  alpha,
cs_complex_t  beta 
)
int* cs_ci_amd ( int  order,
const cs_ci *  A 
)
void* cs_ci_calloc ( int  n,
size_t  size 
)
cs_cin* cs_ci_chol ( const cs_ci *  A,
const cs_cis *  S 
)
int cs_ci_cholsol ( int  order,
const cs_ci *  A,
cs_complex_t *  b 
)
cs_ci* cs_ci_compress ( const cs_ci *  T)
int* cs_ci_counts ( const cs_ci *  A,
const int *  parent,
const int *  post,
int  ata 
)
double cs_ci_cumsum ( int *  p,
int *  c,
int  n 
)
cs_cid* cs_ci_dalloc ( int  m,
int  n 
)
cs_cid* cs_ci_ddone ( cs_cid *  D,
cs_ci *  C,
void *  w,
int  ok 
)
cs_cid* cs_ci_dfree ( cs_cid *  D)
int cs_ci_dfs ( int  j,
cs_ci *  G,
int  top,
int *  xi,
int *  pstack,
const int *  pinv 
)
cs_cid* cs_ci_dmperm ( const cs_ci *  A,
int  seed 
)
cs_ci* cs_ci_done ( cs_ci *  C,
void *  w,
void *  x,
int  ok 
)
int cs_ci_droptol ( cs_ci *  A,
double  tol 
)
int cs_ci_dropzeros ( cs_ci *  A)
int cs_ci_dupl ( cs_ci *  A)
int cs_ci_entry ( cs_ci *  T,
int  i,
int  j,
cs_complex_t  x 
)
int cs_ci_ereach ( const cs_ci *  A,
int  k,
const int *  parent,
int *  s,
int *  w 
)
int* cs_ci_etree ( const cs_ci *  A,
int  ata 
)
int cs_ci_fkeep ( cs_ci *  A,
int(*)(int, int, cs_complex_t, void *)  fkeep,
void *  other 
)
void* cs_ci_free ( void *  p)
int cs_ci_gaxpy ( const cs_ci *  A,
const cs_complex_t *  x,
cs_complex_t *  y 
)
int cs_ci_happly ( const cs_ci *  V,
int  i,
double  beta,
cs_complex_t *  x 
)
cs_complex_t cs_ci_house ( cs_complex_t *  x,
double *  beta,
int  n 
)
int* cs_ci_idone ( int *  p,
cs_ci *  C,
void *  w,
int  ok 
)
int cs_ci_ipvec ( const int *  p,
const cs_complex_t *  b,
cs_complex_t *  x,
int  n 
)

Referenced by ASIGMABSolDirect().

Here is the caller graph for this function:

int cs_ci_leaf ( int  i,
int  j,
const int *  first,
int *  maxfirst,
int *  prevleaf,
int *  ancestor,
int *  jleaf 
)
cs_ci* cs_ci_load ( FILE *  f)
int cs_ci_lsolve ( const cs_ci *  L,
cs_complex_t *  x 
)

Referenced by ASIGMABSolDirect().

Here is the caller graph for this function:

int cs_ci_ltsolve ( const cs_ci *  L,
cs_complex_t *  x 
)
cs_cin* cs_ci_lu ( const cs_ci *  A,
const cs_cis *  S,
double  tol 
)

Referenced by SetupASIGMABSolDirect().

Here is the caller graph for this function:

int cs_ci_lusol ( int  order,
const cs_ci *  A,
cs_complex_t *  b,
double  tol 
)
void* cs_ci_malloc ( int  n,
size_t  size 
)
int* cs_ci_maxtrans ( const cs_ci *  A,
int  seed 
)
cs_ci* cs_ci_multiply ( const cs_ci *  A,
const cs_ci *  B 
)
cs_cin* cs_ci_ndone ( cs_cin *  N,
cs_ci *  C,
void *  w,
void *  x,
int  ok 
)
cs_cin* cs_ci_nfree ( cs_cin *  N)

Referenced by FreeASIGMABSolDirect().

Here is the caller graph for this function:

double cs_ci_norm ( const cs_ci *  A)
cs_ci* cs_ci_permute ( const cs_ci *  A,
const int *  pinv,
const int *  q,
int  values 
)
int* cs_ci_pinv ( const int *  p,
int  n 
)
int* cs_ci_post ( const int *  parent,
int  n 
)
int cs_ci_print ( const cs_ci *  A,
int  brief 
)
int cs_ci_pvec ( const int *  p,
const cs_complex_t *  b,
cs_complex_t *  x,
int  n 
)
cs_cin* cs_ci_qr ( const cs_ci *  A,
const cs_cis *  S 
)
int cs_ci_qrsol ( int  order,
const cs_ci *  A,
cs_complex_t *  b 
)
int* cs_ci_randperm ( int  n,
int  seed 
)
int cs_ci_reach ( cs_ci *  G,
const cs_ci *  B,
int  k,
int *  xi,
const int *  pinv 
)
void* cs_ci_realloc ( void *  p,
int  n,
size_t  size,
int *  ok 
)
int cs_ci_scatter ( const cs_ci *  A,
int  j,
cs_complex_t  beta,
int *  w,
cs_complex_t *  x,
int  mark,
cs_ci *  C,
int  nz 
)
cs_cid* cs_ci_scc ( cs_ci *  A)
cs_cis* cs_ci_schol ( int  order,
const cs_ci *  A 
)
cs_cis* cs_ci_sfree ( cs_cis *  S)

Referenced by FreeASIGMABSolDirect().

Here is the caller graph for this function:

cs_ci* cs_ci_spalloc ( int  m,
int  n,
int  nzmax,
int  values,
int  t 
)

Referenced by cs_i_complex().

Here is the caller graph for this function:

cs_ci* cs_ci_spfree ( cs_ci *  A)
int cs_ci_sprealloc ( cs_ci *  A,
int  nzmax 
)
int cs_ci_spsolve ( cs_ci *  L,
const cs_ci *  B,
int  k,
int *  xi,
cs_complex_t *  x,
const int *  pinv,
int  lo 
)
cs_cis* cs_ci_sqr ( int  order,
const cs_ci *  A,
int  qr 
)

Referenced by SetupASIGMABSolDirect().

Here is the caller graph for this function:

cs_ci* cs_ci_symperm ( const cs_ci *  A,
const int *  pinv,
int  values 
)
int cs_ci_tdfs ( int  j,
int  k,
int *  head,
const int *  next,
int *  post,
int *  stack 
)
cs_ci* cs_ci_transpose ( const cs_ci *  A,
int  values 
)
int cs_ci_updown ( cs_ci *  L,
int  sigma,
const cs_ci *  C,
const int *  parent 
)
int cs_ci_usolve ( const cs_ci *  U,
cs_complex_t *  x 
)

Referenced by ASIGMABSolDirect().

Here is the caller graph for this function:

int cs_ci_utsolve ( const cs_ci *  U,
cs_complex_t *  x 
)
cs_cl* cs_cl_add ( const cs_cl *  A,
const cs_cl *  B,
cs_complex_t  alpha,
cs_complex_t  beta 
)
cs_long_t* cs_cl_amd ( cs_long_t  order,
const cs_cl *  A 
)
void* cs_cl_calloc ( cs_long_t  n,
size_t  size 
)
cs_cln* cs_cl_chol ( const cs_cl *  A,
const cs_cls *  S 
)
cs_long_t cs_cl_cholsol ( cs_long_t  order,
const cs_cl *  A,
cs_complex_t *  b 
)
cs_cl* cs_cl_compress ( const cs_cl *  T)
cs_long_t* cs_cl_counts ( const cs_cl *  A,
const cs_long_t *  parent,
const cs_long_t *  post,
cs_long_t  ata 
)
double cs_cl_cumsum ( cs_long_t *  p,
cs_long_t *  c,
cs_long_t  n 
)
cs_cld* cs_cl_dalloc ( cs_long_t  m,
cs_long_t  n 
)
cs_cld* cs_cl_ddone ( cs_cld *  D,
cs_cl *  C,
void *  w,
cs_long_t  ok 
)
cs_cld* cs_cl_dfree ( cs_cld *  D)
cs_long_t cs_cl_dfs ( cs_long_t  j,
cs_cl *  G,
cs_long_t  top,
cs_long_t *  xi,
cs_long_t *  pstack,
const cs_long_t *  pinv 
)
cs_cld* cs_cl_dmperm ( const cs_cl *  A,
cs_long_t  seed 
)
cs_cl* cs_cl_done ( cs_cl *  C,
void *  w,
void *  x,
cs_long_t  ok 
)
cs_long_t cs_cl_droptol ( cs_cl *  A,
double  tol 
)
cs_long_t cs_cl_dropzeros ( cs_cl *  A)
cs_long_t cs_cl_dupl ( cs_cl *  A)
cs_long_t cs_cl_entry ( cs_cl *  T,
cs_long_t  i,
cs_long_t  j,
cs_complex_t  x 
)
cs_long_t cs_cl_ereach ( const cs_cl *  A,
cs_long_t  k,
const cs_long_t *  parent,
cs_long_t *  s,
cs_long_t *  w 
)
cs_long_t* cs_cl_etree ( const cs_cl *  A,
cs_long_t  ata 
)
cs_long_t cs_cl_fkeep ( cs_cl *  A,
cs_long_t(*)(cs_long_t, cs_long_t, cs_complex_t, void *)  fkeep,
void *  other 
)
void* cs_cl_free ( void *  p)
cs_long_t cs_cl_gaxpy ( const cs_cl *  A,
const cs_complex_t *  x,
cs_complex_t *  y 
)
cs_long_t cs_cl_happly ( const cs_cl *  V,
cs_long_t  i,
double  beta,
cs_complex_t *  x 
)
cs_complex_t cs_cl_house ( cs_complex_t *  x,
double *  beta,
cs_long_t  n 
)
cs_long_t* cs_cl_idone ( cs_long_t *  p,
cs_cl *  C,
void *  w,
cs_long_t  ok 
)
cs_long_t cs_cl_ipvec ( const cs_long_t *  p,
const cs_complex_t *  b,
cs_complex_t *  x,
cs_long_t  n 
)
cs_long_t cs_cl_leaf ( cs_long_t  i,
cs_long_t  j,
const cs_long_t *  first,
cs_long_t *  maxfirst,
cs_long_t *  prevleaf,
cs_long_t *  ancestor,
cs_long_t *  jleaf 
)
cs_cl* cs_cl_load ( FILE *  f)
cs_long_t cs_cl_lsolve ( const cs_cl *  L,
cs_complex_t *  x 
)
cs_long_t cs_cl_ltsolve ( const cs_cl *  L,
cs_complex_t *  x 
)
cs_cln* cs_cl_lu ( const cs_cl *  A,
const cs_cls *  S,
double  tol 
)
cs_long_t cs_cl_lusol ( cs_long_t  order,
const cs_cl *  A,
cs_complex_t *  b,
double  tol 
)
void* cs_cl_malloc ( cs_long_t  n,
size_t  size 
)
cs_long_t* cs_cl_maxtrans ( const cs_cl *  A,
cs_long_t  seed 
)
cs_cl* cs_cl_multiply ( const cs_cl *  A,
const cs_cl *  B 
)
cs_cln* cs_cl_ndone ( cs_cln *  N,
cs_cl *  C,
void *  w,
void *  x,
cs_long_t  ok 
)
cs_cln* cs_cl_nfree ( cs_cln *  N)
double cs_cl_norm ( const cs_cl *  A)
cs_cl* cs_cl_permute ( const cs_cl *  A,
const cs_long_t *  pinv,
const cs_long_t *  q,
cs_long_t  values 
)
cs_long_t* cs_cl_pinv ( const cs_long_t *  p,
cs_long_t  n 
)
cs_long_t* cs_cl_post ( const cs_long_t *  parent,
cs_long_t  n 
)
cs_long_t cs_cl_print ( const cs_cl *  A,
cs_long_t  brief 
)
cs_long_t cs_cl_pvec ( const cs_long_t *  p,
const cs_complex_t *  b,
cs_complex_t *  x,
cs_long_t  n 
)
cs_cln* cs_cl_qr ( const cs_cl *  A,
const cs_cls *  S 
)
cs_long_t cs_cl_qrsol ( cs_long_t  order,
const cs_cl *  A,
cs_complex_t *  b 
)
cs_long_t* cs_cl_randperm ( cs_long_t  n,
cs_long_t  seed 
)
cs_long_t cs_cl_reach ( cs_cl *  G,
const cs_cl *  B,
cs_long_t  k,
cs_long_t *  xi,
const cs_long_t *  pinv 
)
void* cs_cl_realloc ( void *  p,
cs_long_t  n,
size_t  size,
cs_long_t *  ok 
)
cs_long_t cs_cl_scatter ( const cs_cl *  A,
cs_long_t  j,
cs_complex_t  beta,
cs_long_t *  w,
cs_complex_t *  x,
cs_long_t  mark,
cs_cl *  C,
cs_long_t  nz 
)
cs_cld* cs_cl_scc ( cs_cl *  A)
cs_cls* cs_cl_schol ( cs_long_t  order,
const cs_cl *  A 
)
cs_cls* cs_cl_sfree ( cs_cls *  S)
cs_cl* cs_cl_spalloc ( cs_long_t  m,
cs_long_t  n,
cs_long_t  nzmax,
cs_long_t  values,
cs_long_t  t 
)

Referenced by cs_l_complex().

Here is the caller graph for this function:

cs_cl* cs_cl_spfree ( cs_cl *  A)
cs_long_t cs_cl_sprealloc ( cs_cl *  A,
cs_long_t  nzmax 
)
cs_long_t cs_cl_spsolve ( cs_cl *  L,
const cs_cl *  B,
cs_long_t  k,
cs_long_t *  xi,
cs_complex_t *  x,
const cs_long_t *  pinv,
cs_long_t  lo 
)
cs_cls* cs_cl_sqr ( cs_long_t  order,
const cs_cl *  A,
cs_long_t  qr 
)
cs_cl* cs_cl_symperm ( const cs_cl *  A,
const cs_long_t *  pinv,
cs_long_t  values 
)
cs_long_t cs_cl_tdfs ( cs_long_t  j,
cs_long_t  k,
cs_long_t *  head,
const cs_long_t *  next,
cs_long_t *  post,
cs_long_t *  stack 
)
cs_cl* cs_cl_transpose ( const cs_cl *  A,
cs_long_t  values 
)
cs_long_t cs_cl_updown ( cs_cl *  L,
cs_long_t  sigma,
const cs_cl *  C,
const cs_long_t *  parent 
)
cs_long_t cs_cl_usolve ( const cs_cl *  U,
cs_complex_t *  x 
)
cs_long_t cs_cl_utsolve ( const cs_cl *  U,
cs_complex_t *  x 
)
cs_di* cs_di_add ( const cs_di *  A,
const cs_di *  B,
double  alpha,
double  beta 
)
int* cs_di_amd ( int  order,
const cs_di *  A 
)
void* cs_di_calloc ( int  n,
size_t  size 
)
cs_din* cs_di_chol ( const cs_di *  A,
const cs_dis *  S 
)

Referenced by SetupBSolDirect().

Here is the caller graph for this function:

int cs_di_cholsol ( int  order,
const cs_di *  A,
double *  b 
)
cs_di* cs_di_compress ( const cs_di *  T)
int* cs_di_counts ( const cs_di *  A,
const int *  parent,
const int *  post,
int  ata 
)
double cs_di_cumsum ( int *  p,
int *  c,
int  n 
)
cs_did* cs_di_dalloc ( int  m,
int  n 
)
cs_did* cs_di_ddone ( cs_did *  D,
cs_di *  C,
void *  w,
int  ok 
)
cs_did* cs_di_dfree ( cs_did *  D)
int cs_di_dfs ( int  j,
cs_di *  G,
int  top,
int *  xi,
int *  pstack,
const int *  pinv 
)
cs_did* cs_di_dmperm ( const cs_di *  A,
int  seed 
)
cs_di* cs_di_done ( cs_di *  C,
void *  w,
void *  x,
int  ok 
)
int cs_di_droptol ( cs_di *  A,
double  tol 
)
int cs_di_dropzeros ( cs_di *  A)
int cs_di_dupl ( cs_di *  A)
int cs_di_entry ( cs_di *  T,
int  i,
int  j,
double  x 
)
int cs_di_ereach ( const cs_di *  A,
int  k,
const int *  parent,
int *  s,
int *  w 
)
int* cs_di_etree ( const cs_di *  A,
int  ata 
)
int cs_di_fkeep ( cs_di *  A,
int(*)(int, int, double, void *)  fkeep,
void *  other 
)
void* cs_di_free ( void *  p)
int cs_di_gaxpy ( const cs_di *  A,
const double *  x,
double *  y 
)
int cs_di_happly ( const cs_di *  V,
int  i,
double  beta,
double *  x 
)
double cs_di_house ( double *  x,
double *  beta,
int  n 
)
int* cs_di_idone ( int *  p,
cs_di *  C,
void *  w,
int  ok 
)
int cs_di_ipvec ( const int *  p,
const double *  b,
double *  x,
int  n 
)

Referenced by BSolDirect().

Here is the caller graph for this function:

int cs_di_leaf ( int  i,
int  j,
const int *  first,
int *  maxfirst,
int *  prevleaf,
int *  ancestor,
int *  jleaf 
)
cs_di* cs_di_load ( FILE *  f)
int cs_di_lsolve ( const cs_di *  L,
double *  x 
)

Referenced by BSolDirect().

Here is the caller graph for this function:

int cs_di_ltsolve ( const cs_di *  L,
double *  x 
)

Referenced by BSolDirect(), and LTSolDirect().

Here is the caller graph for this function:

cs_din* cs_di_lu ( const cs_di *  A,
const cs_dis *  S,
double  tol 
)
int cs_di_lusol ( int  order,
const cs_di *  A,
double *  b,
double  tol 
)
void* cs_di_malloc ( int  n,
size_t  size 
)
int* cs_di_maxtrans ( const cs_di *  A,
int  seed 
)
cs_di* cs_di_multiply ( const cs_di *  A,
const cs_di *  B 
)
cs_din* cs_di_ndone ( cs_din *  N,
cs_di *  C,
void *  w,
void *  x,
int  ok 
)
cs_din* cs_di_nfree ( cs_din *  N)

Referenced by FreeBSolDirectData().

Here is the caller graph for this function:

double cs_di_norm ( const cs_di *  A)
cs_di* cs_di_permute ( const cs_di *  A,
const int *  pinv,
const int *  q,
int  values 
)
int* cs_di_pinv ( const int *  p,
int  n 
)
int* cs_di_post ( const int *  parent,
int  n 
)
int cs_di_print ( const cs_di *  A,
int  brief 
)
int cs_di_pvec ( const int *  p,
const double *  b,
double *  x,
int  n 
)

Referenced by BSolDirect(), and LTSolDirect().

Here is the caller graph for this function:

cs_din* cs_di_qr ( const cs_di *  A,
const cs_dis *  S 
)
int cs_di_qrsol ( int  order,
const cs_di *  A,
double *  b 
)
int* cs_di_randperm ( int  n,
int  seed 
)
int cs_di_reach ( cs_di *  G,
const cs_di *  B,
int  k,
int *  xi,
const int *  pinv 
)
void* cs_di_realloc ( void *  p,
int  n,
size_t  size,
int *  ok 
)
int cs_di_scatter ( const cs_di *  A,
int  j,
double  beta,
int *  w,
double *  x,
int  mark,
cs_di *  C,
int  nz 
)
cs_did* cs_di_scc ( cs_di *  A)
cs_dis* cs_di_schol ( int  order,
const cs_di *  A 
)

Referenced by SetupBSolDirect().

Here is the caller graph for this function:

cs_dis* cs_di_sfree ( cs_dis *  S)

Referenced by FreeBSolDirectData().

Here is the caller graph for this function:

cs_di* cs_di_spalloc ( int  m,
int  n,
int  nzmax,
int  values,
int  t 
)

Referenced by cs_i_real().

Here is the caller graph for this function:

cs_di* cs_di_spfree ( cs_di *  A)

Referenced by SetupBSolDirect().

Here is the caller graph for this function:

int cs_di_sprealloc ( cs_di *  A,
int  nzmax 
)
int cs_di_spsolve ( cs_di *  L,
const cs_di *  B,
int  k,
int *  xi,
double *  x,
const int *  pinv,
int  lo 
)
cs_dis* cs_di_sqr ( int  order,
const cs_di *  A,
int  qr 
)
cs_di* cs_di_symperm ( const cs_di *  A,
const int *  pinv,
int  values 
)
int cs_di_tdfs ( int  j,
int  k,
int *  head,
const int *  next,
int *  post,
int *  stack 
)
cs_di* cs_di_transpose ( const cs_di *  A,
int  values 
)
int cs_di_updown ( cs_di *  L,
int  sigma,
const cs_di *  C,
const int *  parent 
)
int cs_di_usolve ( const cs_di *  U,
double *  x 
)
int cs_di_utsolve ( const cs_di *  U,
double *  x 
)
cs_dl* cs_dl_add ( const cs_dl *  A,
const cs_dl *  B,
double  alpha,
double  beta 
)
cs_long_t* cs_dl_amd ( cs_long_t  order,
const cs_dl *  A 
)
void* cs_dl_calloc ( cs_long_t  n,
size_t  size 
)
cs_dln* cs_dl_chol ( const cs_dl *  A,
const cs_dls *  S 
)
cs_long_t cs_dl_cholsol ( cs_long_t  order,
const cs_dl *  A,
double *  b 
)
cs_dl* cs_dl_compress ( const cs_dl *  T)
cs_long_t* cs_dl_counts ( const cs_dl *  A,
const cs_long_t *  parent,
const cs_long_t *  post,
cs_long_t  ata 
)
double cs_dl_cumsum ( cs_long_t *  p,
cs_long_t *  c,
cs_long_t  n 
)
cs_dld* cs_dl_dalloc ( cs_long_t  m,
cs_long_t  n 
)
cs_dld* cs_dl_ddone ( cs_dld *  D,
cs_dl *  C,
void *  w,
cs_long_t  ok 
)
cs_dld* cs_dl_dfree ( cs_dld *  D)
cs_long_t cs_dl_dfs ( cs_long_t  j,
cs_dl *  G,
cs_long_t  top,
cs_long_t *  xi,
cs_long_t *  pstack,
const cs_long_t *  pinv 
)
cs_dld* cs_dl_dmperm ( const cs_dl *  A,
cs_long_t  seed 
)
cs_dl* cs_dl_done ( cs_dl *  C,
void *  w,
void *  x,
cs_long_t  ok 
)
cs_long_t cs_dl_droptol ( cs_dl *  A,
double  tol 
)
cs_long_t cs_dl_dropzeros ( cs_dl *  A)
cs_long_t cs_dl_dupl ( cs_dl *  A)
cs_long_t cs_dl_entry ( cs_dl *  T,
cs_long_t  i,
cs_long_t  j,
double  x 
)
cs_long_t cs_dl_ereach ( const cs_dl *  A,
cs_long_t  k,
const cs_long_t *  parent,
cs_long_t *  s,
cs_long_t *  w 
)
cs_long_t* cs_dl_etree ( const cs_dl *  A,
cs_long_t  ata 
)
cs_long_t cs_dl_fkeep ( cs_dl *  A,
cs_long_t(*)(cs_long_t, cs_long_t, double, void *)  fkeep,
void *  other 
)
void* cs_dl_free ( void *  p)
cs_long_t cs_dl_gaxpy ( const cs_dl *  A,
const double *  x,
double *  y 
)
cs_long_t cs_dl_happly ( const cs_dl *  V,
cs_long_t  i,
double  beta,
double *  x 
)
double cs_dl_house ( double *  x,
double *  beta,
cs_long_t  n 
)
cs_long_t* cs_dl_idone ( cs_long_t *  p,
cs_dl *  C,
void *  w,
cs_long_t  ok 
)
cs_long_t cs_dl_ipvec ( const cs_long_t *  p,
const double *  b,
double *  x,
cs_long_t  n 
)
cs_long_t cs_dl_leaf ( cs_long_t  i,
cs_long_t  j,
const cs_long_t *  first,
cs_long_t *  maxfirst,
cs_long_t *  prevleaf,
cs_long_t *  ancestor,
cs_long_t *  jleaf 
)
cs_dl* cs_dl_load ( FILE *  f)
cs_long_t cs_dl_lsolve ( const cs_dl *  L,
double *  x 
)
cs_long_t cs_dl_ltsolve ( const cs_dl *  L,
double *  x 
)
cs_dln* cs_dl_lu ( const cs_dl *  A,
const cs_dls *  S,
double  tol 
)
cs_long_t cs_dl_lusol ( cs_long_t  order,
const cs_dl *  A,
double *  b,
double  tol 
)
void* cs_dl_malloc ( cs_long_t  n,
size_t  size 
)
cs_long_t* cs_dl_maxtrans ( const cs_dl *  A,
cs_long_t  seed 
)
cs_dl* cs_dl_multiply ( const cs_dl *  A,
const cs_dl *  B 
)
cs_dln* cs_dl_ndone ( cs_dln *  N,
cs_dl *  C,
void *  w,
void *  x,
cs_long_t  ok 
)
cs_dln* cs_dl_nfree ( cs_dln *  N)
double cs_dl_norm ( const cs_dl *  A)
cs_dl* cs_dl_permute ( const cs_dl *  A,
const cs_long_t *  pinv,
const cs_long_t *  q,
cs_long_t  values 
)
cs_long_t* cs_dl_pinv ( const cs_long_t *  p,
cs_long_t  n 
)
cs_long_t* cs_dl_post ( const cs_long_t *  parent,
cs_long_t  n 
)
cs_long_t cs_dl_print ( const cs_dl *  A,
cs_long_t  brief 
)
cs_long_t cs_dl_pvec ( const cs_long_t *  p,
const double *  b,
double *  x,
cs_long_t  n 
)
cs_dln* cs_dl_qr ( const cs_dl *  A,
const cs_dls *  S 
)
cs_long_t cs_dl_qrsol ( cs_long_t  order,
const cs_dl *  A,
double *  b 
)
cs_long_t* cs_dl_randperm ( cs_long_t  n,
cs_long_t  seed 
)
cs_long_t cs_dl_reach ( cs_dl *  G,
const cs_dl *  B,
cs_long_t  k,
cs_long_t *  xi,
const cs_long_t *  pinv 
)
void* cs_dl_realloc ( void *  p,
cs_long_t  n,
size_t  size,
cs_long_t *  ok 
)
cs_long_t cs_dl_scatter ( const cs_dl *  A,
cs_long_t  j,
double  beta,
cs_long_t *  w,
double *  x,
cs_long_t  mark,
cs_dl *  C,
cs_long_t  nz 
)
cs_dld* cs_dl_scc ( cs_dl *  A)
cs_dls* cs_dl_schol ( cs_long_t  order,
const cs_dl *  A 
)
cs_dls* cs_dl_sfree ( cs_dls *  S)
cs_dl* cs_dl_spalloc ( cs_long_t  m,
cs_long_t  n,
cs_long_t  nzmax,
cs_long_t  values,
cs_long_t  t 
)

Referenced by cs_l_real().

Here is the caller graph for this function:

cs_dl* cs_dl_spfree ( cs_dl *  A)
cs_long_t cs_dl_sprealloc ( cs_dl *  A,
cs_long_t  nzmax 
)
cs_long_t cs_dl_spsolve ( cs_dl *  L,
const cs_dl *  B,
cs_long_t  k,
cs_long_t *  xi,
double *  x,
const cs_long_t *  pinv,
cs_long_t  lo 
)
cs_dls* cs_dl_sqr ( cs_long_t  order,
const cs_dl *  A,
cs_long_t  qr 
)
cs_dl* cs_dl_symperm ( const cs_dl *  A,
const cs_long_t *  pinv,
cs_long_t  values 
)
cs_long_t cs_dl_tdfs ( cs_long_t  j,
cs_long_t  k,
cs_long_t *  head,
const cs_long_t *  next,
cs_long_t *  post,
cs_long_t *  stack 
)
cs_dl* cs_dl_transpose ( const cs_dl *  A,
cs_long_t  values 
)
cs_long_t cs_dl_updown ( cs_dl *  L,
cs_long_t  sigma,
const cs_dl *  C,
const cs_long_t *  parent 
)
cs_long_t cs_dl_usolve ( const cs_dl *  U,
double *  x 
)
cs_long_t cs_dl_utsolve ( const cs_dl *  U,
double *  x 
)
cs_ci* cs_i_complex ( cs_di *  A,
int  real 
)

Definition at line 28 of file cs_convert.c.

References cs_ci_spalloc(), cs_complex_t, cs_di_sparse::i, cs_ci_sparse::i, cs_di_sparse::m, cs_di_sparse::n, cs_di_sparse::nz, cs_ci_sparse::nz, cs_di_sparse::nzmax, cs_di_sparse::p, cs_ci_sparse::p, cs_di_sparse::x, and cs_ci_sparse::x.

Here is the call graph for this function:

cs_di* cs_i_real ( cs_ci *  A,
int  real 
)

Definition at line 5 of file cs_convert.c.

References cs_complex_t, cs_di_spalloc(), cs_di_sparse::i, cs_ci_sparse::i, cs_ci_sparse::m, cs_ci_sparse::n, cs_di_sparse::nz, cs_ci_sparse::nz, cs_ci_sparse::nzmax, cs_di_sparse::p, cs_ci_sparse::p, cs_di_sparse::x, and cs_ci_sparse::x.

Here is the call graph for this function:

cs_cl* cs_l_complex ( cs_dl *  A,
cs_long_t  real 
)

Definition at line 74 of file cs_convert.c.

References cs_cl_spalloc(), cs_complex_t, cs_long_t, cs_dl_sparse::i, cs_cl_sparse::i, cs_dl_sparse::m, cs_dl_sparse::n, cs_dl_sparse::nz, cs_cl_sparse::nz, cs_dl_sparse::nzmax, cs_dl_sparse::p, cs_cl_sparse::p, cs_dl_sparse::x, and cs_cl_sparse::x.

Here is the call graph for this function:

cs_dl* cs_l_real ( cs_cl *  A,
cs_long_t  real 
)

Definition at line 51 of file cs_convert.c.

References cs_complex_t, cs_dl_spalloc(), cs_long_t, cs_dl_sparse::i, cs_cl_sparse::i, cs_cl_sparse::m, cs_cl_sparse::n, cs_dl_sparse::nz, cs_cl_sparse::nz, cs_cl_sparse::nzmax, cs_dl_sparse::p, cs_cl_sparse::p, cs_dl_sparse::x, and cs_cl_sparse::x.

Here is the call graph for this function:

Generated by   doxygen 1.8.6