oct_object_convert.cpp

Go to the documentation of this file.
00001 /******************************************************************************/
00002 /*                                                                            */
00003 /*    oct_object_convert.cpp                                                  */
00004 /*    source file that implements the data object conversion                  */
00005 /*                                                                            */
00006 /*    Copyright (C)                                                           */
00007 /*    Innovative Computing Laboratory (ICL)                                   */
00008 /*    Univesity of Tennessee, Knoxville                                       */
00009 /*                                                                            */
00010 /*    Feburary 22, 2007                                                       */
00011 /******************************************************************************/
00012 
00013 
00014 #include <string>
00015 using namespace std;
00016 
00017 #include <oct.h>
00018 #include "grpc.h"
00019 #include "gs_oct.h"
00020 
00021 
00022 int verify_allocation(void *ptr) {
00023     if (ptr == NULL) {
00024         perror("malloc");
00025         return -1;
00026     }
00027 
00028     return 0;
00029 }
00030 
00031 
00032 int is_sparse_index_or_pointer(gs_argument_t *argp, gs_problem_t *pd) {
00033     int is_index_or_pointer = 0;
00034     gs_argument_t* arg_attr;
00035     
00036     for (arg_attr = pd->arglist; arg_attr != NULL; arg_attr = arg_attr->next)
00037         if ((arg_attr->objecttype == GS_SPARSEMATRIX)  &&
00038            (!strcmp(argp->name, arg_attr->sparse_attr.indices) ||
00039             !strcmp(argp->name, arg_attr->sparse_attr.pointer))) {
00040             is_index_or_pointer = 1;
00041             break;
00042     }
00043 
00044     return is_index_or_pointer;
00045 }
00046 
00047 
00048 int process_gs_out_arguments(gs_problem_t* pd) {
00049     gs_argument_t *argp;
00050     gs_argument_t *arg_indices;
00051     gs_argument_t *arg_pointer;
00052     void *v;
00053     int nrows, ncolumns;
00054     char buf[256];
00055     int fd;
00056     int nfiles;
00057     char **fnames;
00058 
00059 
00060     for (argp = pd->arglist; argp != NULL; argp = argp->next) {
00061         if (argp->inout != GS_OUT && argp->inout != GS_VAROUT) continue;
00062         if (is_sparse_index_or_pointer(argp, pd)) continue;
00063 
00064         switch (argp->objecttype) {
00065             case GS_MATRIX:
00066                 if (argp->inout == GS_OUT) {
00067                     nrows = argp->rows;
00068                     ncolumns = argp->cols;
00069                     argp->data = (void *) malloc(gs_datatype_sizeof(
00070                         argp->datatype) * nrows * ncolumns);
00071                     if (verify_allocation(argp->data) < 0) return -1;
00072                 }
00073                 else if (argp->inout == GS_VAROUT) {
00074                     argp->data = (char **) malloc(sizeof(char *));
00075                 }
00076                 break;
00077             case GS_SPARSEMATRIX:
00078                 if (argp->inout == GS_VAROUT) {
00079                     fprintf(stderr, "VAROUT SPARSEMATRIX arguments are not supported\n");
00080                     return -1;
00081                 }
00082                 arg_indices = gs_arg_lookup_by_name(argp->sparse_attr.indices, pd->arglist);
00083                 arg_pointer = gs_arg_lookup_by_name(argp->sparse_attr.pointer, pd->arglist);
00084                 if (arg_indices == NULL || arg_pointer == NULL) return -1;
00085                 arg_indices->data = malloc(sizeof(int) * argp->sparse_attr.nnz);
00086                 if (verify_allocation(arg_indices->data) < 0) return -1;
00087                 arg_pointer->data = malloc(sizeof(int) * 
00088                     (argp->sparse_attr.cols_val_saved + 1));
00089                 if (verify_allocation(arg_pointer->data) < 0) return -1;
00090                 argp->data = (void *) malloc(argp->sparse_attr.nnz *
00091                     gs_datatype_sizeof(argp->datatype));
00092                 if (verify_allocation(argp->data) < 0) return -1;
00093                 break;
00094             case GS_VECTOR:
00095                 if (argp->inout == GS_OUT) {
00096                     nrows = argp->rows;
00097                     argp->data = (void *) malloc(gs_datatype_sizeof(argp->datatype) * nrows);
00098                     if (verify_allocation(argp->data) < 0) return -1;
00099                 }
00100                 else if (argp->inout == GS_VAROUT) {
00101                     argp->data = (char **) malloc(sizeof(char *));
00102                 }
00103                 break;
00104             case GS_SCALAR:
00105                 if (argp->inout == GS_OUT) {
00106                     argp->data = &(argp->scalar_val);
00107                 }
00108                 else if (argp->inout == GS_VAROUT) {
00109                     fprintf(stderr, "VAROUT SCALAR arguments are not supported\n");
00110                     return -1;
00111                 }
00112                 break;
00113             case GS_FILE:
00114                 sprintf(buf, "%s_%s_OUT", pd->name, argp->name);
00115                 fd =  open(buf, O_WRONLY | O_CREAT | O_TRUNC, 0600);
00116                 if(fd < 0) {
00117                     fprintf(stderr, "Could not open file '%s'\n", buf);
00118                     return -1;
00119                 }
00120                 close(fd);
00121                 argp->data = strdup(buf);
00122                 if (argp->data == NULL) return -1;
00123                 break;
00124             case GS_PACKEDFILE:
00125                 nfiles = argp->rows * argp->cols;
00126                 fnames = (char **) malloc(sizeof(char *) * nfiles);
00127                 for (int i = 0; i < nfiles; i++) {
00128                     sprintf(buf, "%s_%s_%d_OUT", pd->name, argp->name, i + 1);
00129                     fd = open(buf, O_WRONLY | O_CREAT | O_TRUNC, 0600);
00130                     if(fd < 0) {
00131                         fprintf(stderr, "Could not open file '%s'\n", buf);
00132                         return -1;
00133                     }
00134                     close(fd);
00135                     fnames[i] = strdup(buf);
00136                     if (fnames[i] == NULL) return -1;
00137                 }
00138                 argp->data = fnames;
00139                 break;
00140             default:
00141                 break;
00142         }
00143     }
00144 }
00145 
00146 
00147 int convert_octave_arguments(gs_problem_t* pd, octave_value_list oct_args) {
00148     gs_argument_t *argp;
00149 
00150     int i = 1;
00151     //first process scalar input arguments
00152     for (argp = pd->arglist; argp != NULL; argp = argp->next) {
00153 
00154         if (argp->inout == GS_OUT ||
00155             argp->inout == GS_VAROUT ||
00156             argp->inout == GS_WORKSPACE) continue;
00157         if (is_sparse_index_or_pointer(argp, pd)) continue;
00158 
00159         if (argp->objecttype == GS_SCALAR) {
00160             if (convert_scalar(argp, oct_args, i) < 0) return -1;
00161         }
00162         i++;
00163     }
00164     
00165     //compute the size of each nonscalar input arguments
00166     if (gs_receiver_compute_arg_sizes(pd, GS_IN) < 0) {
00167         fprintf(stderr, "Failure to compute argument sizes\n");
00168         return -1;
00169     }
00170 
00171     i = 1;
00172     //then process nonscalar input arguments
00173     for (argp = pd->arglist; argp != NULL; argp = argp->next) {
00174         if (argp->inout == GS_OUT ||
00175             argp->inout == GS_VAROUT ||
00176             argp->inout == GS_WORKSPACE) continue;
00177 
00178         if (is_sparse_index_or_pointer(argp, pd)) {
00179             continue;
00180         }
00181 
00182         switch (argp->objecttype) {
00183             case GS_MATRIX:
00184                 if (convert_matrix(argp, oct_args, i) < 0) return -1;
00185                 break;
00186             case GS_SPARSEMATRIX:
00187                 if (convert_sparse_matrix(pd, argp, oct_args, i) < 0) return -1;
00188                 break;
00189             case GS_VECTOR:
00190                 if (convert_vector(argp, oct_args, i) < 0) return -1;
00191                 break;
00192             case GS_SCALAR:
00193                 //Nothing to do here
00194                 break;
00195             case GS_FILE:
00196                 if (convert_file_argument(argp, oct_args, i) < 0) return -1;
00197                 break;
00198             case GS_PACKEDFILE:
00199                 if (convert_packed_file_argument(argp, oct_args, i) < 0) return -1;
00200                 break;
00201             default:
00202                 break;
00203         }
00204 
00205         i++;
00206     }
00207     
00208     //last, process GS_OUT arguments
00209     process_gs_out_arguments(pd);
00210 }
00211 
00212 
00213 int convert_matrix(gs_argument_t *argp, octave_value_list octval, int index) {
00214     int nrows, ncolumns;
00215     double *pr, *pi;
00216     int *imat;
00217     float *fmat;
00218     double *dmat;
00219     gs_scomplex *scmat;
00220     gs_dcomplex *dcmat;
00221     char *cmat;
00222 
00223 
00224     nrows = octval(index).rows();
00225     ncolumns = octval(index).columns();
00226 
00227     if (argp->datatype == GS_CHAR) {
00228         if (!octval(index).is_string()) {
00229             fprintf(stderr, "Input argument %d should be a string\n", index);
00230             return -1;
00231         }
00232 
00233         cmat = (char *) malloc(gs_datatype_sizeof(
00234             argp->datatype) * (nrows * ncolumns + 1));
00235         if (verify_allocation(cmat) < 0) return -1;
00236         for (int j = 0; j < ncolumns; j++) {
00237             for (int i = 0; i < nrows; i++) {
00238                 cmat[i + j * nrows] = (char) (octval(index).char_matrix_value())(i, j);
00239             }
00240         }
00241         cmat[nrows * ncolumns] = '\0';
00242         argp->data = cmat;
00243         return 0;
00244     } else {
00245         pr = oct_GetPr(octval(index));
00246         pi = oct_GetPi(octval(index));
00247     }
00248 
00249     switch (argp->datatype) {
00250         case GS_INT:
00251             imat = (int *) malloc(gs_datatype_sizeof(argp->datatype) * nrows * ncolumns);
00252             if (verify_allocation(imat) < 0) return -1;
00253             for (int i = 0; i < nrows * ncolumns; i++) {
00254                 imat[i] = (int) pr[i];
00255             }
00256             argp->data = imat;
00257             break;
00258         case GS_FLOAT:
00259             fmat = (float *) malloc(gs_datatype_sizeof(argp->datatype) * nrows * ncolumns);
00260             if (verify_allocation(fmat) < 0) return -1;
00261             for (int i = 0; i < nrows * ncolumns; i++) {
00262                 fmat[i] = (float) pr[i];
00263             }
00264             argp->data = fmat;
00265             break;
00266         case GS_DOUBLE:
00267             dmat = (double *) malloc(gs_datatype_sizeof(argp->datatype) * nrows * ncolumns);
00268             if (verify_allocation(dmat) < 0) return -1;
00269             for (int i = 0; i < nrows * ncolumns; i++) {
00270                 dmat[i] = pr[i];
00271             }
00272             argp->data = dmat;
00273             break;
00274         case GS_SCOMPLEX:
00275             scmat = (gs_scomplex *) malloc(gs_datatype_sizeof(argp->datatype) * nrows * ncolumns);
00276             if (verify_allocation(scmat) < 0) return -1;
00277             for (int i = 0; i < nrows * ncolumns; i++) {
00278                 scmat[i].r = (float) pr[i];
00279                 scmat[i].i = (float) pi[i];
00280             }
00281             argp->data = scmat;
00282             break;
00283         case GS_DCOMPLEX:
00284             dcmat = (gs_dcomplex *) malloc(gs_datatype_sizeof(argp->datatype) * nrows * ncolumns);
00285             if (verify_allocation(dcmat) < 0) return -1;
00286             for (int i = 0; i < nrows * ncolumns; i++) {
00287                 dcmat[i].r = pr[i];
00288                 dcmat[i].i = pi[i];
00289             }
00290             argp->data = dcmat;
00291             break;
00292         case GS_CHAR:
00293             break;
00294         case GS_BAD_DTYPE:
00295             break;
00296     }
00297     
00298     return 0;
00299 }
00300 
00301 
00302 int convert_sparse_matrix(gs_problem_t *pd, gs_argument_t *argp, 
00303     octave_value_list octval, int index) {
00304     gs_argument_t *arg_indices;
00305     gs_argument_t *arg_pointer;
00306     int nrows, ncolumns, nnz;
00307     int *ir, *jc;
00308     double *pr, *pi;
00309     int *imat;
00310     float *fmat;
00311     double *dmat;
00312     gs_scomplex *scmat;
00313     gs_dcomplex *dcmat;
00314     char *cmat;
00315     
00316 
00317     nrows = octval(index).rows();
00318     ncolumns = octval(index).columns();
00319 
00320     if (argp->datatype == GS_CHAR) {
00321         if (!octval(index).is_string()) {
00322             fprintf(stderr, "Input argument %d should be a string\n", index);
00323             return -1;
00324         }
00325 
00326         cmat = (char *) malloc(gs_datatype_sizeof(
00327             argp->datatype) * (nrows * ncolumns + 1));
00328         if (verify_allocation(cmat) < 0) return -1;
00329         for (int j = 0; j < ncolumns; j++) {
00330             for (int i = 0; i < nrows; i++) {
00331                 cmat[i + j * nrows] = (char) (octval(index).char_matrix_value())(i, j);
00332             }
00333         }
00334         cmat[nrows * ncolumns] = '\0';
00335         argp->data = cmat;
00336         return 0;
00337     } else {
00338         ir = oct_GetSparseIr(octval(index).matrix_value());
00339         jc = oct_GetSparseJc(octval(index).matrix_value());
00340         nnz = *(jc + ncolumns);
00341         pr = oct_GetSparsePr(octval(index).matrix_value());
00342         pi = oct_GetSparsePi(octval(index).matrix_value());
00343     }
00344 
00345     arg_indices = gs_arg_lookup_by_name(argp->sparse_attr.indices, pd->arglist);
00346     arg_pointer = gs_arg_lookup_by_name(argp->sparse_attr.pointer, pd->arglist);
00347     if (arg_indices == NULL || arg_pointer == NULL) return -1;
00348     arg_indices->data = ir;
00349     arg_pointer->data = jc;
00350 
00351     switch (argp->datatype) {
00352         case GS_INT:
00353             imat = (int *) malloc(gs_datatype_sizeof(argp->datatype) * nnz);
00354             if (verify_allocation(imat) < 0) return -1;
00355             for (int i = 0; i < nnz; i++) {
00356                 imat[i] = (int) pr[i];
00357             }
00358             argp->data = imat;
00359             break;
00360         case GS_FLOAT:
00361             fmat = (float *) malloc(gs_datatype_sizeof(argp->datatype) * nnz);
00362             if (verify_allocation(fmat) < 0) return -1;
00363             for (int i = 0; i < nnz; i++) {
00364                 fmat[i] = (float) pr[i];
00365             }
00366             argp->data = fmat;
00367             break;
00368         case GS_DOUBLE:
00369             dmat = (double *) malloc(gs_datatype_sizeof(argp->datatype) * nnz);
00370             if (verify_allocation(dmat) < 0) return -1;
00371             for (int i = 0; i < nnz; i++) {
00372                 dmat[i] = pr[i];
00373             }
00374             argp->data = dmat;
00375             break;
00376         case GS_SCOMPLEX:
00377             scmat = (gs_scomplex *) malloc(gs_datatype_sizeof(argp->datatype) * nnz);
00378             if (verify_allocation(scmat) < 0) return -1;
00379             for (int i = 0; i < nnz; i++) {
00380                 scmat[i].r = (float) pr[i];
00381                 scmat[i].i = (float) pi[i];
00382             }
00383             argp->data = scmat;
00384             break;
00385         case GS_DCOMPLEX:
00386             dcmat = (gs_dcomplex *) malloc(gs_datatype_sizeof(argp->datatype) * nnz);
00387             if (verify_allocation(dcmat) < 0) return -1;
00388             for (int i = 0; i < nnz; i++) {
00389                 dcmat[i].r = pr[i];
00390                 dcmat[i].i = pi[i];
00391             }
00392             argp->data = dcmat;
00393             break;
00394         case GS_CHAR:
00395             break;
00396         case GS_BAD_DTYPE:
00397             break;
00398     }
00399     
00400     return 0;
00401 }
00402 
00403 
00404 int convert_vector(gs_argument_t *argp, octave_value_list octval, int index) {
00405     int nrows, ncolumns, nelems;
00406     double *pr, *pi;
00407     int *ivec;
00408     float *fvec;
00409     double *dvec;
00410     gs_scomplex *scvec;
00411     gs_dcomplex *dcvec;
00412     char *cvec;
00413 
00414 
00415     nrows = octval(index).rows();
00416     ncolumns = octval(index).columns();
00417 
00418     if (nrows != 1 && ncolumns != 1) {
00419         printf("Input argument %d should be a vector (1xN or Nx1)\n", index);
00420         return -1;
00421     }
00422     
00423     nelems = (nrows == 1) ? ncolumns : nrows;
00424 
00425     if (argp->datatype == GS_CHAR) {
00426         if (!octval(index).is_string()) {
00427             fprintf(stderr, "Input argument %d should be a string\n", index);
00428             return -1;
00429         }
00430 
00431         cvec = (char *) malloc(gs_datatype_sizeof(
00432             argp->datatype) * (nelems + 1));
00433         if (verify_allocation(cvec) < 0) return -1;
00434         for (int i = 0; i < nelems; i++) {
00435             cvec[i] = (char) (octval(index).string_value())[i];
00436         }
00437         cvec[nelems] = '\0';
00438         argp->data = cvec;
00439         return 0;
00440     } else {
00441         pr = oct_GetPr(octval(index));
00442         pi = oct_GetPi(octval(index));
00443     }
00444 
00445     switch (argp->datatype) {
00446         case GS_INT:
00447             ivec = (int *) malloc(gs_datatype_sizeof(argp->datatype) * nelems);
00448             if (verify_allocation(ivec) < 0) return -1;
00449             for (int i = 0; i < nelems; i++) {
00450                 ivec[i] = (int) pr[i];
00451             }
00452             argp->data = ivec;
00453             break;
00454         case GS_FLOAT:
00455             fvec = (float *) malloc(gs_datatype_sizeof(argp->datatype) * nelems);
00456             if (verify_allocation(fvec) < 0) return -1;
00457             for (int i = 0; i < nelems; i++) {
00458                 fvec[i] = (float) pr[i];
00459             }
00460             argp->data = fvec;
00461             break;
00462         case GS_DOUBLE:
00463             dvec = (double *) malloc(gs_datatype_sizeof(argp->datatype) * nelems);
00464             if (verify_allocation(dvec) < 0) return -1;
00465             for (int i = 0; i < nelems; i++) {
00466                 dvec[i] = pr[i];
00467             }
00468             argp->data = dvec;
00469             break;
00470         case GS_SCOMPLEX:
00471             scvec = (gs_scomplex *) malloc(gs_datatype_sizeof(argp->datatype) * nelems);
00472             if (verify_allocation(scvec) < 0) return -1;
00473             for (int i = 0; i < nelems; i++) {
00474                 scvec[i].r = (float) pr[i];
00475                 scvec[i].i = (float) pi[i];
00476             }
00477             argp->data = scvec;
00478             break;
00479         case GS_DCOMPLEX:
00480             dcvec = (gs_dcomplex *) malloc(gs_datatype_sizeof(argp->datatype) * nelems);
00481             if (verify_allocation(dcvec) < 0) return -1;
00482             for (int i = 0; i < nelems; i++) {
00483                 dcvec[i].r = pr[i];
00484                 dcvec[i].i = pi[i];
00485             }
00486             argp->data = dcvec;
00487             break;
00488         case GS_CHAR:
00489             break;
00490         case GS_BAD_DTYPE:
00491             break;
00492     }
00493     
00494     return 0;
00495 }
00496 
00497 
00498 int convert_scalar(gs_argument_t *argp, octave_value_list octval, int index) {
00499     int nrows, ncolumns;
00500     double *pr, *pi;
00501 
00502 
00503     nrows = octval(index).rows();
00504     ncolumns = octval(index).columns();
00505 
00506     if (nrows != 1 || ncolumns != 1) {
00507         printf("Input argument %d should be a scalar\n", index);
00508         return -1;
00509     }
00510 
00511     if (argp->datatype == GS_CHAR) {
00512         argp->scalar_val.char_val = (char) (octval(index).string_value())[0];
00513         argp->data = &(argp->scalar_val);
00514         return 0;
00515     } else {
00516         pr = oct_GetPr(octval(index));
00517         pi = oct_GetPi(octval(index));
00518     }
00519 
00520     switch (argp->datatype) {
00521         case GS_INT:
00522             argp->scalar_val.int_val = (int) pr[0];
00523             break;
00524         case GS_FLOAT:
00525             argp->scalar_val.float_val = (float) pr[0];
00526             break;
00527         case GS_DOUBLE:
00528             argp->scalar_val.double_val = pr[0];
00529             break;
00530         case GS_SCOMPLEX:
00531             argp->scalar_val.scomplex_val.r = (float) pr[0];
00532             argp->scalar_val.scomplex_val.i = (float) pi[0];
00533             break;
00534         case GS_DCOMPLEX:
00535             argp->scalar_val.dcomplex_val.r = pr[0];
00536             argp->scalar_val.dcomplex_val.i = pi[0];
00537             break;
00538         case GS_CHAR:
00539             break;
00540         case GS_BAD_DTYPE:
00541             break;
00542     }
00543 
00544     argp->data = &(argp->scalar_val);
00545     
00546     return 0;
00547 }
00548 
00549 
00550 int convert_file_argument(gs_argument_t *argp, octave_value_list octval, int index) {
00551     if (!octval(index).is_string()) {
00552         fprintf(stderr, "Input argument %d should be a file name (string)\n");
00553         return -1;
00554     }
00555 
00556     int nrows = octval(index).rows();
00557     int ncolumns = octval(index).columns();
00558     
00559     char *fname = (char *) malloc(gs_datatype_sizeof(
00560         argp->datatype) * (nrows * ncolumns + 1));
00561     if (verify_allocation(fname) < 0) return -1;
00562 
00563     for (int j = 0; j < ncolumns; j++) {
00564         for (int i = 0; i < nrows; i++) {
00565             fname[i + j * nrows] = (char) (octval(index).char_matrix_value())(i, j);
00566         }
00567     }
00568     fname[nrows * ncolumns] = '\0';
00569     argp->data = fname;
00570 
00571     return 0;
00572 }
00573 
00574 
00575 int convert_packed_file_argument(gs_argument_t *argp, octave_value_list octval, int index) {
00576     if (!octval(index).is_string()) {
00577         fprintf(stderr, "Input argument %d should be a file name (string)\n");
00578         return -1;
00579     }
00580 
00581     int nrows = octval(index).rows();
00582     int ncolumns = octval(index).columns();
00583 
00584     if (nrows != argp->rows) {
00585         fprintf(stderr, "Bad string vector dimension for input packed file names\n");
00586         return -1;
00587     }
00588 
00589     char **fnames = (char **) malloc(sizeof(char *) * nrows);
00590     if (verify_allocation(fnames) < 0) return -1;
00591     for (int i = 0; i < nrows; i++) {
00592         fnames[i] = (char *) malloc(sizeof(char) * (ncolumns + 1));
00593         if (verify_allocation(fnames[i]) < 0) return -1;
00594         for (int j = 0; j < ncolumns; j++) {
00595             fnames[i][j] = (char) (octval(index).char_matrix_value())(i, j);
00596         }
00597         fnames[i][ncolumns] = '\0';
00598     }
00599 
00600     argp->data = fnames;
00601 
00602     return 0;
00603 }
00604 
00605 
00606 int convert_output_objects(gs_problem_t* pd, octave_value_list &retvals) {
00607     gs_argument_t *argp;
00608 
00609     for (argp = pd->arglist; argp != NULL; argp = argp->next) {
00610         //for input or workspace arguments, do nothing
00611         if (argp->inout == GS_IN || argp->inout == GS_WORKSPACE) continue;
00612         if (is_sparse_index_or_pointer(argp, pd)) continue;
00613 
00614         switch (argp->objecttype) {
00615             case GS_MATRIX:
00616                 if (fill_matrix(argp, retvals) < 0) return -1;
00617                 break;
00618             case GS_SPARSEMATRIX:
00619                 if (fill_sparse_matrix(pd, argp, retvals) < 0) return -1;
00620                 break;
00621             case GS_VECTOR:
00622                 if (fill_vector(argp, retvals) < 0) return -1;
00623                 break;
00624             case GS_SCALAR:
00625                 if (fill_scalar(argp, retvals) < 0) return -1;
00626                 break;
00627             case GS_FILE:
00628                 if (fill_file_argument(argp, retvals) < 0) return -1;
00629                 break;
00630             case GS_PACKEDFILE:
00631                 if (fill_packed_file_argument(argp, retvals) < 0) return -1;
00632                 break;
00633             default:
00634                 break;
00635         }
00636     }
00637 }
00638 
00639 
00640 int fill_matrix(gs_argument_t *argp, octave_value_list& retval) {
00641     int nrows, ncolumns;
00642 
00643     nrows = argp->rows;
00644     ncolumns = argp->cols;
00645     Matrix mat = Matrix(nrows, ncolumns);
00646     ComplexMatrix cmat = ComplexMatrix(nrows, ncolumns);
00647     charMatrix chmat = charMatrix(nrows, ncolumns);
00648 
00649     switch (argp->datatype) {
00650         case GS_INT:
00651             for (int i = 0; i < mat.columns(); i++) {
00652                 for (int j = 0; j < mat.rows(); j++) {
00653                     if (argp->inout == GS_VAROUT) {
00654                         mat(j, i) = (int) (*(int **) argp->data)[i * mat.rows() + j];
00655                     } else {
00656                         mat(j, i) = (int) ((int *) argp->data)[i * mat.rows() + j];
00657                     }
00658                 }
00659             }
00660             retval.append(octave_value(mat));
00661             free(argp->data);
00662             break;
00663         case GS_FLOAT:
00664             for (int i = 0; i < mat.columns(); i++) {
00665                 for (int j = 0; j < mat.rows(); j++) {
00666                     if (argp->inout == GS_VAROUT) {
00667                         mat(j, i) = (float) (*(float **) argp->data)[i * mat.rows() + j];
00668                     } else {
00669                         mat(j, i) = (float) ((float *) argp->data)[i * mat.rows() + j];
00670                     }
00671                 }
00672             }
00673             retval.append(octave_value(mat));
00674             free(argp->data);
00675             break;
00676         case GS_DOUBLE:
00677             for (int i = 0; i < mat.columns(); i++) {
00678                 for (int j = 0; j < mat.rows(); j++) {
00679                     if (argp->inout == GS_VAROUT) {
00680                         mat(j, i) = (double) (*(double **) argp->data)[i * mat.rows() + j];
00681                     } else {
00682                         mat(j, i) = (double) ((double *) argp->data)[i * mat.rows() + j];
00683                     }
00684                 }
00685             }
00686             retval.append(octave_value(mat));
00687             free(argp->data);
00688             break;
00689         case GS_SCOMPLEX:
00690             for (int i = 0; i < cmat.columns(); i++) {
00691                 for (int j = 0; j < cmat.rows(); j++) {
00692                     int index = i * cmat.rows() + j;
00693                     if (argp->inout == GS_VAROUT) {
00694                         cmat(j, i) = Complex((*(gs_scomplex **) argp->data)[index].r,
00695                         (*(gs_scomplex **) argp->data)[index].i);
00696                     } else {
00697                         cmat(j, i) = Complex(((gs_scomplex *) argp->data)[index].r,
00698                         ((gs_scomplex *) argp->data)[index].i);
00699                     }
00700                 }
00701             }
00702             retval.append(octave_value(cmat));
00703             free(argp->data);
00704             break;
00705         case GS_DCOMPLEX:
00706             for (int i = 0; i < cmat.columns(); i++) {
00707                 for (int j = 0; j < cmat.rows(); j++) {
00708                     int index = i * cmat.rows() + j;
00709                     if (argp->inout == GS_VAROUT) {
00710                         cmat(j, i) = Complex((*(gs_dcomplex **) argp->data)[index].r,
00711                         (*(gs_dcomplex **) argp->data)[index].i);
00712                     } else {
00713                         cmat(j, i) = Complex(((gs_dcomplex *) argp->data)[index].r,
00714                         ((gs_dcomplex *) argp->data)[index].i);
00715                     }
00716                 }
00717             }
00718             retval.append(octave_value(cmat));
00719             free(argp->data);
00720             break;
00721         case GS_CHAR:
00722             for (int i = 0; i < mat.columns(); i++) {
00723                 for (int j = 0; j < mat.rows(); j++) {
00724                     if (argp->inout == GS_VAROUT) {
00725                         mat(j, i) = (char) (*(char **) argp->data)[i * mat.rows() + j];
00726                     } else {
00727                         mat(j, i) = (char) ((char *) argp->data)[i * mat.rows() + j];
00728                     }
00729                 }
00730             }
00731             retval.append(octave_value(mat));
00732             free(argp->data);
00733             break;
00734         case GS_BAD_DTYPE:
00735             break;
00736     }
00737 
00738     return 0;
00739 }
00740 
00741 
00742 int fill_sparse_matrix(gs_problem_t *pd, gs_argument_t *argp, octave_value_list& retval) {
00743     gs_argument_t *arg_pointer;
00744     gs_argument_t *arg_indices;
00745     int nnz, nrows, ncolumns;
00746     int *ir, *jc;
00747     Matrix mat;
00748     ComplexMatrix cmat;
00749     charMatrix chmat;
00750 
00751 
00752     nnz = argp->sparse_attr.nnz;
00753     nrows = argp->sparse_attr.rows_val_saved;
00754     ncolumns = argp->sparse_attr.cols_val_saved;;
00755     arg_indices = gs_arg_lookup_by_name(argp->sparse_attr.indices, pd->arglist);
00756     arg_pointer = gs_arg_lookup_by_name(argp->sparse_attr.pointer, pd->arglist);
00757     if (arg_indices == NULL || arg_pointer == NULL) return -1;
00758     ir = (int *) arg_indices->data;
00759     jc = (int *) arg_pointer->data;
00760 
00761     switch (argp->datatype) {
00762         case GS_INT:
00763             mat = Matrix(nrows, ncolumns);
00764             for (int i = 0; i < nrows; i++)
00765                 for (int j = 0; j < ncolumns; j++)
00766                     mat(i, j) = 0;
00767 
00768             for (int j; j < ncolumns; j++)
00769                 for( int k = *(jc + j); k < *(jc + j + 1); k++)
00770                     mat(*(ir + k), j) = (int) *((int *) argp->data + k);
00771 
00772             retval.append(SparseMatrix(mat));
00773             break;
00774         case GS_FLOAT:
00775             mat = Matrix(nrows, ncolumns);
00776             for (int i = 0; i < nrows; i++)
00777                 for (int j = 0; j < ncolumns; j++)
00778                     mat(i, j) = 0.0;
00779 
00780             for (int j; j < ncolumns; j++)
00781                 for( int k = *(jc + j); k < *(jc + j + 1); k++)
00782                     mat(*(ir + k), j) = (float) *((float *) argp->data + k);
00783 
00784             retval.append(SparseMatrix(mat));
00785             break;
00786         case GS_DOUBLE:
00787             mat = Matrix(nrows, ncolumns);
00788             for (int i = 0; i < nrows; i++)
00789                 for (int j = 0; j < ncolumns; j++)
00790                     mat(i, j) = 0.00;
00791 
00792             for (int j; j < ncolumns; j++)
00793                 for( int k = *(jc + j); k < *(jc + j + 1); k++)
00794                     mat(*(ir + k), j) = (double) *((double *) argp->data + k);
00795 
00796             retval.append(SparseMatrix(mat));
00797             break;
00798         case GS_SCOMPLEX:
00799             cmat = ComplexMatrix(nrows, ncolumns);
00800             for (int i = 0; i < nrows; i++) 
00801                 for (int j = 0; j < ncolumns; j++)
00802                     cmat(i, j) = 0;
00803 
00804             for (int j; j < ncolumns; j++)
00805                 for( int k = *(jc + j); k < *(jc + j + 1); k++)
00806                     cmat(*(ir + k), j) = Complex(
00807                         ((gs_scomplex) *((gs_scomplex *) argp->data + k)).r,
00808                         ((gs_scomplex) *((gs_scomplex *) argp->data + k)).i);
00809 
00810             retval.append(SparseComplexMatrix(cmat));
00811             break;
00812         case GS_DCOMPLEX:
00813             cmat = ComplexMatrix(nrows, ncolumns);
00814             for (int i = 0; i < nrows; i++) 
00815                 for (int j = 0; j < ncolumns; j++)
00816                     cmat(i, j) = 0;
00817 
00818             for (int j; j < ncolumns; j++)
00819                 for( int k = *(jc + j); k < *(jc + j + 1); k++)
00820                     cmat(*(ir + k), j) = Complex(
00821                         ((gs_dcomplex) *((gs_dcomplex *) argp->data + k)).r,
00822                         ((gs_dcomplex) *((gs_dcomplex *) argp->data + k)).i);
00823 
00824             retval.append(SparseComplexMatrix(cmat));
00825             break;
00826     }
00827 
00828     return 0;
00829 }
00830 
00831 
00832 int fill_vector(gs_argument_t *argp, octave_value_list& retval) {
00833     int nrows, ncolumns, nelems;
00834     int major;
00835     Matrix mat;
00836     ComplexMatrix cmat;
00837     charMatrix chmat;
00838     
00839 
00840     nrows = argp->rows;
00841     ncolumns = argp->cols;
00842 
00843     if (nrows == 1) {
00844         mat = Matrix(1, ncolumns);
00845         cmat = ComplexMatrix(1, ncolumns);
00846         chmat = charMatrix(1, ncolumns);
00847         nelems = ncolumns;
00848         major = 0;
00849     }
00850     else if (ncolumns == 1) {
00851         mat = Matrix(nrows, 1);
00852         cmat = ComplexMatrix(nrows, 1);
00853         chmat = charMatrix(nrows, 1);
00854         nelems = nrows;
00855         major = 1;
00856     }
00857 
00858     switch (argp->datatype) {
00859         case GS_INT:
00860             for (int i = 0; i < nelems; i++) {
00861                 if (argp->inout == GS_VAROUT) {
00862                     if (major == 0)
00863                         mat(0, i) = (int) (*(int **) argp->data)[i];
00864                     else 
00865                         mat(i, 0) = (int) (*(int **) argp->data)[i];
00866                 } else {
00867                     if (major == 0)
00868                         mat(0, i) = (int) ((int *) argp->data)[i];
00869                     else 
00870                         mat(i, 0) = (int) ((int *) argp->data)[i];
00871                 }
00872             }
00873             free(argp->data);
00874             retval.append(octave_value(mat));
00875             break;
00876         case GS_FLOAT:
00877             for (int i = 0; i < nelems; i++) {
00878                 if (argp->inout == GS_VAROUT) {
00879                     if (major == 0)
00880                         mat(0, i) = (float) (*(float **) argp->data)[i];
00881                     else 
00882                         mat(i, 0) = (float) (*(float **) argp->data)[i];
00883                 } else {
00884                     if (major == 0)
00885                         mat(0, i) = (float) ((float *) argp->data)[i];
00886                     else 
00887                         mat(i, 0) = (float) ((float *) argp->data)[i];
00888                 }
00889             }
00890             free(argp->data);
00891             retval.append(octave_value(mat));
00892             break;
00893         case GS_DOUBLE:
00894             for (int i = 0; i < nelems; i++) {
00895                 if (argp->inout == GS_VAROUT) {
00896                     if (major == 0)
00897                         mat(0, i) = (double) (*(double **) argp->data)[i];
00898                     else 
00899                         mat(i, 0) = (double) (*(double **) argp->data)[i];
00900                 } else {
00901                     if (major == 0)
00902                         mat(0, i) = (double) ((double *) argp->data)[i];
00903                     else 
00904                         mat(i, 0) = (double) ((double *) argp->data)[i];
00905                 }
00906             }
00907             free(argp->data);
00908             retval.append(octave_value(mat));
00909             break;
00910         case GS_SCOMPLEX:
00911             for (int i = 0; i < nelems; i++) {
00912                 if (argp->inout == GS_VAROUT) {
00913                     if (major == 0)
00914                         cmat(0, i) = Complex((*(gs_scomplex **) argp->data)[i].r,
00915                         (*(gs_scomplex **) argp->data)[i].i);
00916                     else 
00917                         cmat(i, 0) = Complex((*(gs_scomplex **) argp->data)[i].r,
00918                         (*(gs_scomplex **) argp->data)[i].i);
00919                 } else {
00920                     if (major == 0)
00921                         cmat(0, i) = Complex(((gs_scomplex *) argp->data)[i].r,
00922                         ((gs_scomplex *) argp->data)[i].i);
00923                     else 
00924                         cmat(i, 0) = Complex(((gs_scomplex *) argp->data)[i].r,
00925                         ((gs_scomplex *) argp->data)[i].i);
00926                 }
00927             }
00928             free(argp->data);
00929             retval.append(octave_value(cmat));
00930             break;
00931         case GS_DCOMPLEX:
00932             for (int i = 0; i < nelems; i++) {
00933                 if (argp->inout == GS_VAROUT) {
00934                     if (major == 0)
00935                         cmat(0, i) = Complex((*(gs_dcomplex **) argp->data)[i].r,
00936                         (*(gs_dcomplex **) argp->data)[i].i);
00937                     else
00938                         cmat(i, 0) = Complex((*(gs_dcomplex **) argp->data)[i].r,
00939                         (*(gs_dcomplex **) argp->data)[i].i);
00940                 } else {
00941                     if (major == 0)
00942                         cmat(0, i) = Complex(((gs_dcomplex *) argp->data)[i].r,
00943                         ((gs_dcomplex *) argp->data)[i].i);
00944                     else 
00945                         cmat(i, 0) = Complex(((gs_dcomplex *) argp->data)[i].r,
00946                         ((gs_dcomplex *) argp->data)[i].i);
00947                 }
00948             }
00949             free(argp->data);
00950             retval.append(octave_value(cmat));
00951             break;
00952         case GS_CHAR:
00953             if (argp->inout == GS_VAROUT) {
00954                 char *str = strdup(*((char **) argp->data));
00955                 retval.append(string_vector(str));
00956                 free(*((char **) argp->data));
00957                 free(argp->data);
00958             } else {
00959                 char *str = strdup((char *) argp->data);
00960                 retval.append(string_vector(str));
00961                 free(argp->data);
00962             }
00963             break;
00964         case GS_BAD_DTYPE:
00965             break;
00966     }
00967 
00968     return 0;
00969 }
00970 
00971 
00972 int fill_scalar(gs_argument_t *argp, octave_value_list& retval) {
00973     if (argp->rows != 1 || argp->cols != 1) return -1;
00974     Matrix mat = Matrix(1, 1);
00975     ComplexMatrix cmat = ComplexMatrix(1, 1);
00976     charMatrix chmat = charMatrix(1, 1);
00977     
00978     switch (argp->datatype) {
00979         case GS_DOUBLE:
00980             mat(0, 0) = argp->scalar_val.double_val;
00981             retval.append(octave_value(mat));
00982             break;
00983         case GS_INT:
00984             mat(0, 0) = argp->scalar_val.int_val;
00985             retval.append(octave_value(mat));
00986             break;
00987         case GS_FLOAT:
00988             mat(0, 0) = argp->scalar_val.float_val;
00989             retval.append(octave_value(mat));
00990             break;
00991         case GS_SCOMPLEX:
00992             cmat(0, 0) = Complex(argp->scalar_val.scomplex_val.r,
00993                 argp->scalar_val.scomplex_val.i);
00994             retval.append(octave_value(cmat));
00995             break;
00996         case GS_DCOMPLEX:
00997             cmat(0, 0) = Complex(argp->scalar_val.dcomplex_val.r,
00998                 argp->scalar_val.dcomplex_val.i);
00999             retval.append(octave_value(cmat));
01000             break;
01001         case GS_CHAR:
01002             mat(0, 0) = (int) argp->scalar_val.char_val;
01003             retval.append(octave_value(mat));
01004             break;
01005     }
01006     
01007     return 0;
01008 }
01009 
01010 
01011 int fill_file_argument(gs_argument_t *argp, octave_value_list& retval) {
01012     char *str = strdup((char *) argp->data);
01013     retval.append(string_vector(str));
01014     free(argp->data);
01015     return 0;
01016 }
01017 
01018 
01019 int fill_packed_file_argument(gs_argument_t *argp, octave_value_list& retval) {
01020     int ncolumns = 0;
01021     for (int i = 0; i < argp->rows; i++) {
01022         if (strlen(((char **) argp->data)[i]) > ncolumns);
01023             ncolumns = strlen(((char **) argp->data)[i]);
01024     }
01025 
01026     charMatrix ret_packed_file_names = charMatrix(argp->rows, ncolumns);
01027     for (int i = 0; i < argp->rows; i++) {
01028         char *str = strdup(((char **) argp->data)[i]);
01029         for (int j = 0; j < strlen(str); j++)
01030             ret_packed_file_names.insert(str + j, i, j);
01031         free(((char **) argp->data)[i]);
01032     }
01033     free(argp->data);
01034     retval.append(ret_packed_file_names);
01035     return 0;
01036 }