int main (int argc, char **argv)
{
double xr, xz, xmin, xmax ;
double *Ax, *Az ;
Long nrow, ncol, mkind, skind, *Ap, *Ai, i, *Zp, *Zi, asize, mkind2, skind2,
znz, j, p, status, njumbled, nzeros, build_upper, zero_handling, fem,
xsize, nelnz, nnz, kk, anz ;
int ok ;
char title [73], key [9], mtype [4], mtype2 [4], *filename, s [100], *As ;
SuiteSparse_config config ;
config.malloc_memory = malloc ;
config.free_memory = free ;
/* test arg-handling for RB functions */
status = RBread (NULL, 0, 0, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL) ;
if (status != RBIO_ARG_ERROR)
{
printf ("RBtest failure (1)!\n") ;
return (1) ;
}
status = RBreadraw (NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) ;
if (status != RBIO_ARG_ERROR)
{
printf ("RBtest failure (2)\n") ;
return (1) ;
}
status = RBread ("no file", build_upper, zero_handling, title, key, mtype,
&nrow, &ncol, &mkind, &skind, &asize, &znz,
&Ap, &Ai, &Ax, &Az, &Zp, &Zi, &config) ;
if (status != RBIO_FILE_IOERROR)
{
printf ("RBtest failure (3)\n") ;
return (1) ;
}
status = RBreadraw ("no file", title, key, mtype, &nrow, &ncol, &nnz,
&nelnz, &mkind, &skind, &fem, &xsize, &Ap, &Ai, &Ax, NULL) ;
if (status != RBIO_FILE_IOERROR)
{
printf ("RBtest failure (4)\n") ;
return (1) ;
}
status = RBwrite (NULL, NULL, NULL, 1, 1, NULL, NULL, NULL, NULL,
NULL, NULL, 0, NULL, NULL) ;
if (status != RBIO_ARG_ERROR)
{
printf ("RBtest failure (5)\n") ;
return (1) ;
}
status = RBkind (1, 1, NULL, NULL, NULL, NULL, 0, NULL, NULL,
NULL, NULL, NULL, NULL, NULL) ;
if (status != RBIO_ARG_ERROR)
{
printf ("RBtest failure (6)\n") ;
return (1) ;
}
status = RBread ("matrices/m4.rb", 1, 2, title, key, mtype,
&nrow, &ncol, &mkind, &skind, &asize, &znz,
&Ap, &Ai, &Ax, NULL, &Zp, &Zi, &config) ;
if (status != 0)
{
SuiteSparse_free (Ap, &config) ;
SuiteSparse_free (Ai, &config) ;
SuiteSparse_free (Ax, &config) ;
SuiteSparse_free (Zp, &config) ;
SuiteSparse_free (Zi, &config) ;
printf ("RBread test failure (7) "ID"\n", status) ;
return (1) ;
}
/* mangle the matrix */
Ap [0] = 1 ;
status = RBwrite ("temp.rb", title, key, nrow, ncol, Ap, Ai, Ax,
NULL, Zp, Zi, mkind, mtype2, NULL) ;
if (status == RBIO_OK)
{
printf ("RBtest failure (8)\n") ;
return (1) ;
}
Ap [0] = 0 ;
Zp [0] = 1 ;
status = RBwrite ("temp.rb", title, key, nrow, ncol, Ap, Ai, Ax,
NULL, Zp, Zi, mkind, mtype2, NULL) ;
if (status == RBIO_OK)
{
printf ("RBtest failure (9)\n") ;
return (1) ;
}
Zp [0] = 0 ;
/* valid matrix */
status = RBwrite ("temp.rb", title, key, nrow, ncol, Ap, Ai, Ax,
NULL, Zp, Zi, mkind, NULL, NULL) ;
if (status != RBIO_OK)
{
printf ("RBtest failure (10) "ID"\n", status) ;
return (1) ;
}
/* valid matrix, different integer formats */
Ax [0] = 1e5 ;
for (kk = 0 ; kk < 10 ; kk++)
{
sprintf (s, "temp_" ID ".rb", kk) ;
status = RBwrite (s, title, key, nrow, ncol, Ap, Ai, Ax,
NULL, Zp, Zi, mkind, NULL, NULL) ;
if (status != RBIO_OK)
{
printf ("RBtest failure (11) "ID" "ID"\n", status, kk) ;
return (1) ;
}
Ax [0] *= 10 ;
}
/* valid matrix, but with a very large integer */
Ax [0] = 1e9 + 1 ;
status = RBwrite ("temp1.rb", title, key, nrow, ncol, Ap, Ai, Ax,
NULL, Zp, Zi, mkind, NULL, NULL) ;
if (status != RBIO_OK)
{
printf ("RBtest failure (12) "ID"\n", status) ;
return (1) ;
}
/* valid matrix, but with a very large real */
Ax [0] = 1e100 ;
status = RBwrite ("temp2.rb", title, key, nrow, ncol, Ap, Ai, Ax,
NULL, Zp, Zi, mkind, NULL, NULL) ;
if (status != RBIO_OK)
{
printf ("RBtest failure (13) "ID"\n", status) ;
return (1) ;
}
/* valid matrix, but with a Z that overlaps A */
Ax [0] = 1 ;
Zi [0] = 1 ;
status = RBwrite ("temp3.rb", title, key, nrow, ncol, Ap, Ai, Ax,
NULL, Zp, Zi, mkind, NULL, NULL) ;
if (status != RBIO_OK)
{
printf ("RBtest failure (14) "ID"\n", status) ;
return (1) ;
}
/* invalid file name */
status = RBwrite ("gunk/gunk.rb", title, key, nrow, ncol, Ap, Ai, Ax,
NULL, Zp, Zi, mkind, NULL, NULL) ;
if (status != RBIO_FILE_IOERROR)
{
printf ("RBtest failure (12) "ID"\n", status) ;
return (1) ;
}
/* cannot write a matrix with no entries */
for (j = 0 ; j <= ncol ; j++)
{
Ap [j] = 0 ;
Zp [j] = 0 ;
}
status = RBwrite ("temp.rb", title, key, nrow, ncol, Ap, Ai, Ax,
NULL, Zp, Zi, mkind, NULL, NULL) ;
if (status != RBIO_DIM_INVALID)
{
printf ("RBtest failure (13) "ID"\n", status) ;
return (1) ;
}
SuiteSparse_free (Ap, &config) ;
SuiteSparse_free (Ai, &config) ;
SuiteSparse_free (Ax, &config) ;
SuiteSparse_free (Zp, &config) ;
SuiteSparse_free (Zi, &config) ;
/* re-read a valid matrix */
status = RBread ("matrices/m4.rb", 1, 0, title, key, mtype,
&nrow, &ncol, &mkind, &skind, &asize, &znz,
&Ap, &Ai, &Ax, NULL, NULL, NULL, &config) ;
if (status != 0)
{
SuiteSparse_free (Ap, &config) ;
SuiteSparse_free (Ai, &config) ;
SuiteSparse_free (Ax, &config) ;
SuiteSparse_free (Zp, &config) ;
SuiteSparse_free (Zi, &config) ;
printf ("RBread test failure (14) "ID"\n", status) ;
return (1) ;
}
status = RBok (nrow, ncol, asize, Ap, Ai, Ax, Az, NULL, mkind,
&njumbled, &nzeros) ;
if (status != RBIO_OK)
{
printf ("RBread test failure (15) "ID"\n", status) ;
}
status = RBok (nrow, ncol, asize, Ap, Ai, Ax, Az, NULL, -1,
&njumbled, &nzeros) ;
if (status != RBIO_MKIND_INVALID)
{
printf ("RBread test failure (16) "ID"\n", status) ;
}
status = RBok (-1, ncol, asize, Ap, Ai, Ax, Az, NULL, mkind,
&njumbled, &nzeros) ;
if (status != RBIO_DIM_INVALID)
{
printf ("RBread test failure (17) "ID"\n", status) ;
}
i = Ap [1] ;
Ap [1] = 999999 ;
status = RBok (nrow, ncol, asize, Ap, Ai, Ax, Az, NULL, mkind,
&njumbled, &nzeros) ;
if (status != RBIO_CP_INVALID)
{
printf ("RBread test failure (18) "ID"\n", status) ;
}
Ap [1] = i ;
status = RBok (nrow, ncol, asize, Ap, NULL, Ax, Az, NULL, mkind,
&njumbled, &nzeros) ;
if (status != RBIO_ROW_INVALID)
{
printf ("RBread test failure (19) "ID"\n", status) ;
}
i = Ai [0] ;
Ai [0] = 999999 ;
status = RBok (nrow, ncol, asize, Ap, Ai, Ax, Az, NULL, mkind,
&njumbled, &nzeros) ;
if (status != RBIO_ROW_INVALID)
{
printf ("RBread test failure (20) "ID"\n", status) ;
}
Ai [0] = i ;
i = Ai [1] ;
Ai [1] = Ai [0] ;
status = RBok (nrow, ncol, asize, Ap, Ai, Ax, Az, NULL, mkind,
&njumbled, &nzeros) ;
if (status != RBIO_JUMBLED)
{
printf ("RBread test failure (21) "ID"\n", status) ;
}
Ai [1] = i ;
ok = 1 ;
As = (char *) SuiteSparse_malloc (asize, sizeof (char), &ok, &config) ;
for (i = 0 ; i < asize ; i++) As [i] = 1 ;
status = RBok (nrow, ncol, asize, Ap, Ai, Ax, Az, As, 1,
&njumbled, &nzeros) ;
if (status != RBIO_OK)
{
printf ("RBread test failure (22) "ID"\n", status) ;
}
SuiteSparse_free (As, &config) ;
printf ("RBtest OK\n") ;
return (0) ;
}
int main(int argc, char *argv[]) {
rb_tree tree = NULL,
tmp = NULL;
int cmd = 0;
printf("This is a demo for RBTree\n");
help();
while (cmd != EOF) {
int arg;
printf("$ ");
fflush(stdout);
/* Find the first non-whitespace character */
while (isspace((cmd = getchar()))) {
if (cmd == '\n') {
/* We delete up to end of line after the
* switch, so put the \n back on. */
ungetc(cmd, stdin);
break;
}
}
switch(cmd) {
case 'C':
case 'c':
/* If we already had a tree, we need to free up
* the memory. */
if (tree != NULL) {
printf("Tree already exists - clearing.\n");
RBfree(tree);
}
tree = RBcreate();
break;
case 'R':
case 'r':
tmp = RBread(READFILE);
/* If there was an error, just keep the tree we
* have. */
if (tmp != NULL) {
if (tree != NULL) {
printf("Non-empty tree - overwriting.\n");
RBfree(tree);
}
tree = tmp;
}
break;
case 'W':
case 'w':
if (tree == NULL) {
fprintf(stderr, "Error: no tree loaded, cannot write.\n");
} else {
RBwrite(tree);
}
break;
case 'I':
case 'i':
if (tree == NULL) {
printf("No tree loaded - creating empty one.\n");
tree = RBcreate();
}
if (scanf("%d", &arg) != 1) {
fprintf(stderr, "Error: must specify integer key to insert.\n");
} else {
RBinsert(tree, arg);
}
break;
case 'D':
case 'd':
if (tree == NULL) {
fprintf(stderr, "Error: no tree loaded, cannot delete.\n");
} else {
if (scanf("%d", &arg) != 1) {
fprintf(stderr, "Error: must specify integer key to delete.\n");
} else {
RBdelete(tree, arg);
}
}
break;
case 'P':
case 'p':
if (tree == NULL) {
fprintf(stderr, "Error: no tree loaded, cannot draw.\n");
} else {
RBdraw(tree, DRAWFILE);
}
break;
case 'H':
case 'h':
help();
break;
case EOF:
/* Make the shell not return on the same line */
putchar('\n');
case 'S':
case 's':
cmd = EOF;
break;
/* Corresponds to an empty command */
case '\n':
break;
default:
fprintf(stderr, "Error: unknown command `%c'.\n", cmd);
help();
break;
}
if (cmd != EOF) {
/* Delete the rest of the line. */
while ((cmd = getchar()) != '\n');
}
}
/* We need to free the tree. */
if (tree != NULL) {
RBfree(tree);
}
RBcleanup();
return 0;
}
void mexFunction
(
int nargout,
mxArray *pargout [ ],
int nargin,
const mxArray *pargin [ ]
)
{
Long *Ap, *Ai, *Zp, *Zi ;
double *Ax, *Az, *Zx ;
Long p, j, build_upper, zero_handling, nrow, ncol, mkind, skind, asize, znz,
status ;
char filename [LEN+1], title [73], key [9], mtype [4] ;
/* ---------------------------------------------------------------------- */
/* check inputs */
/* ---------------------------------------------------------------------- */
if (nargin != 1 || nargout > 5 || !mxIsChar (pargin [0]))
{
mexErrMsgTxt ("Usage: [A Z title key mtype] = RBread (filename)") ;
}
/* ---------------------------------------------------------------------- */
/* get filename */
/* ---------------------------------------------------------------------- */
if (mxGetString (pargin [0], filename, LEN) != 0)
{
mexErrMsgTxt ("filename too long") ;
}
/* ---------------------------------------------------------------------- */
/* read the matrix */
/* ---------------------------------------------------------------------- */
build_upper = TRUE ; /* always build upper tri. part */
zero_handling = (nargout > 1) ? 2 : 1 ; /* prune or extract zeros */
status = RBread (filename, build_upper, zero_handling, title, key, mtype,
&nrow, &ncol, &mkind, &skind, &asize, &znz,
&Ap, &Ai, &Ax, &Az, &Zp, &Zi) ;
if (status != RBIO_OK)
{
RBerror (status) ;
mexErrMsgTxt ("error reading file") ;
}
/* ---------------------------------------------------------------------- */
/* return A to MATLAB */
/* ---------------------------------------------------------------------- */
pargout [0] = mxCreateSparse (0, 0, 0, (mkind == 2) ? mxCOMPLEX : mxREAL) ;
mxFree (mxGetJc (pargout [0])) ;
mxFree (mxGetIr (pargout [0])) ;
mxFree (mxGetPr (pargout [0])) ;
if (mkind == 2) mxFree (mxGetPi (pargout [0])) ;
mxSetM (pargout [0], nrow) ;
mxSetN (pargout [0], ncol) ;
mxSetNzmax (pargout [0], asize) ;
mxSetJc (pargout [0], (mwIndex *) Ap) ;
mxSetIr (pargout [0], (mwIndex *) Ai) ;
mxSetPr (pargout [0], Ax) ;
if (mkind == 2) mxSetPi (pargout [0], Az) ;
/* ---------------------------------------------------------------------- */
/* return Z to MATLAB */
/* ---------------------------------------------------------------------- */
if (nargout > 1)
{
Zx = (double *) SuiteSparse_malloc (znz, sizeof (double)) ;
for (p = 0 ; p < znz ; p++)
{
Zx [p] = 1 ;
}
pargout [1] = mxCreateSparse (0, 0, 0, mxREAL) ;
mxFree (mxGetJc (pargout [1])) ;
mxFree (mxGetIr (pargout [1])) ;
mxFree (mxGetPr (pargout [1])) ;
mxSetM (pargout [1], nrow) ;
mxSetN (pargout [1], ncol) ;
mxSetNzmax (pargout [1], MAX (znz,1)) ;
mxSetJc (pargout [1], (mwIndex *) Zp) ;
mxSetIr (pargout [1], (mwIndex *) Zi) ;
mxSetPr (pargout [1], Zx) ;
}
/* ---------------------------------------------------------------------- */
/* return title */
/* ---------------------------------------------------------------------- */
if (nargout > 2)
{
pargout [2] = mxCreateString (title) ;
}
/* ---------------------------------------------------------------------- */
/* return key */
/* ---------------------------------------------------------------------- */
if (nargout > 3)
{
pargout [3] = mxCreateString (key) ;
}
/* ---------------------------------------------------------------------- */
/* return mtype */
/* ---------------------------------------------------------------------- */
if (nargout > 4)
{
pargout [4] = mxCreateString (mtype) ;
}
}
