コード例 #1
0
ファイル: dspUtils.c プロジェクト: ruohoruotsi/Riddim
////////////////////////////////////////////////////////////////////////
//
// create a MAT file from a double passed in
//
int createMAT(const char *file, 
	      double *data, 
	      int datalen) 
{
  MATFile *pmat;
  mxArray *pa1; 
  
  printf("Creating a .MAT file %s...\n", file);
  pmat = matOpen(file, "w");
  if (pmat == NULL) 
    {
      printf("Error creating file %s\n", file);
      printf("(do you have write permission in this directory?)\n");
      return(1);
    }
  
  pa1 = mxCreateDoubleMatrix(1,datalen,mxREAL);
  mxSetName(pa1, "iroro_debug_variable");

  memcpy((char *)(mxGetPr(pa1)),(char *)data, 1*datalen*sizeof(double));
  matPutArray(pmat, pa1);

  // clean up
  mxDestroyArray(pa1);

  
  if (matClose(pmat) != 0) {
    printf("Error closing file %s\n",file);
    return(1);
  }

  printf("Done\n");
  return(0);
}
コード例 #2
0
JNIEXPORT void JNICALL Java_JMatLink_engPutArrayNATIVE
   (JNIEnv *env, jobject obj, jint engine, jstring arrayS_JNI, jobjectArray valueDD_JNI)
{

    int i, j;

    const char *arrayS;    
    int   rowCount;
    jobject colPtr;
    int   colCount;
    double *tPtrR;  
    jdouble *arrayElements;

    // Check if engine pointer is within allowed region
    if (( engine < 1 ) || ( engine >= enginePMax ))
    {
        return; // Pointer is out of allowed region
    }


    arrayS    = (*env)->GetStringUTFChars(env, arrayS_JNI, 0);
    rowCount        = (*env)->GetArrayLength(env, valueDD_JNI);
    colPtr        = (*env)->GetObjectArrayElement(env, valueDD_JNI, 0);
    colCount        = (*env)->GetArrayLength(env, colPtr);
    //jboolean *isCopy;

    //double *arrayElements = (*env)->GetDoubleArrayElements(env, colPtr, isCopy);

    if (debugB) printf("engPutArray [][] %s %i %i\n", arrayS, rowCount, colCount);

    T = mxCreateDoubleMatrix(rowCount, colCount, mxREAL);
    mxSetName(T, arrayS);
    //printf("matrix created and name set\n");
    tPtrR = mxGetPr(T);

    for (i=0; i<rowCount; i++) {
    //printf("row %i\n",i);
        colPtr = (*env)->GetObjectArrayElement(env, valueDD_JNI, i);
        //printf("got colPtr %i\n",i);
        arrayElements = (*env)->GetDoubleArrayElements(env, colPtr, 0);
        //printf("got array Elements\n");
        for (j=0; j<colCount; j++) {
            //printf("col %i\n",j);
            tPtrR[i + j*rowCount] = arrayElements[j];
        }
    } // rows

    //printf("elements copied\n");

    engPutArray( engineP[ engine ], T );  /* send array to MATLAB */

    mxDestroyArray(T);

    (*env)->ReleaseStringUTFChars(env, arrayS_JNI, arrayS); // free memory
}
コード例 #3
0
ファイル: m2libpvme.c プロジェクト: JanaMa/psychophysics
/*-------------------------------------------------------------------*/
void m2pvme_upkarray_rest(int nlhs, mxArray *plhs[], int nrhs, mxArrayIn *prhs[]) {
/*-------------------------------------------------------------------*/

  MATFile *pmat;
  char fname[256];
  mxArray *array_ptr;

  plhs[1] = mxCreateDoubleMatrix(1,1,mxREAL);
  if((mxGetPr(plhs[1]))[0] = (double) pvme_upkarray_rest(&plhs[0],(char*)0)==1) {
  
    /* the data contains Matlab user defined objects! */

    /* save and load this mxArray so as it will be recognized as an object */

    /*
 object passing could be done by getting a default object from the workspace
 and then constructing the object in the workspace directly by using
 mxPutArray with each struct for each level...
	*/
	/*	
  array_ptr = mexGetArray("def","base");
  mxSetName(array_ptr, "defcopy");
  mexPutArray(array_ptr, "base");
  mxDestroyArray(array_ptr);
	*/
	  
    sprintf(fname,"%s/dp_%d.mat",TMP_LOC,pvm_mytid());
    /*printf(fname,"%s/dp_%d.mat",TMP_LOC,pvm_mytid());*/
  
    pmat = matOpen(fname, "w");
    if (pmat == NULL) {
      mexErrMsgTxt("m2libpvme:Error creating file for transferring object\n");
    }
    mxSetName(plhs[0], "objsl");
    
    if (matPutArray(pmat, plhs[0]) != 0) {
      mexErrMsgTxt("m2libpvme:m2pvme_upkarray_rest: Error saving temporary intermediate file for objects\n"); 
    } 
    
    if (matClose(pmat) != 0) {
      mexErrMsgTxt("m2libpvme:m2pvme_upkarray_rest:Error temporary intermediate file for object transfer\n");
    }
    
    
    /*  printf("class::::%s\n", mxGetClassName(plhs[0]));*/
    
    if ( !( plhs[0] = mxCreateString(fname) ) ) 
      mexErrMsgTxt("m2pvme_upkarray_rest(): mxCreateString() failed.\n");
    
  }
  return;
}
コード例 #4
0
ファイル: persistent2.c プロジェクト: JanaMa/psychophysics
static void
createVarInWS(char *var_name)
{
	mxArray	*var_ptr;

	var_ptr = mxCreateDoubleMatrix(0,0,mxREAL);
	mxSetName(var_ptr,var_name);
	if ( mexPutArray(var_ptr,"caller") ) {
		mexErrMsgTxt("createPersVarInWS(): mexPutArray() failed.\n");
	}

	return;
}
コード例 #5
0
ファイル: persistent2.c プロジェクト: JanaMa/psychophysics
static void
restoreVarInWS(int idx)
{
	mxArray *var_ptr;

	var_ptr = mxCreateDoubleMatrix(PERSVAR_DIMS[idx][0],
				       PERSVAR_DIMS[idx][1],
				       mxREAL);
   	mxSetName(var_ptr,PERSVAR_NAMES[idx]);
	memcpy(mxGetPr(var_ptr),PERSVAR_DATA[idx],
               PERSVAR_DIMS[idx][0] * PERSVAR_DIMS[idx][1] * sizeof(double));

	if ( mexPutArray(var_ptr,"caller") ) {
		mexErrMsgTxt("restorePersVarInWS(): mexPutArray() failed.\n");
	}

	return;
}
コード例 #6
0
ファイル: m2libpvme.c プロジェクト: JanaMa/psychophysics
/*-------------------------------------------------------------------*/
void m2pvme_pkarray(int nlhs, mxArray *plhs[], int nrhs, mxArrayIn *prhs[]) {
/*-------------------------------------------------------------------*/
        char *name;
        int  strl;
		  mxArray   *array_ptr;

        strl = mxGetN(prhs[1])+1;
        if ( !( name = (char*) mxCalloc(strl,sizeof(char)) ) )
                mexErrMsgTxt("m2pvme_pkarray(): mxCalloc() failed.\n");
        if ( mxGetString(prhs[1],name,strl))
                mexErrMsgTxt("m2pvme_pkarray(): mxGetString() failed.\n");

        plhs[0] = mxCreateDoubleMatrix(1,1,mxREAL);
		   array_ptr = (mxArray*) prhs[0];
		   mxSetName(array_ptr, name);

        (mxGetPr(plhs[0]))[0] = (double) pvme_pkarray(array_ptr);

        return;
}
コード例 #7
0
ファイル: mlabraw.cpp プロジェクト: ericjsolis/danapeerlab
PyObject * mlabraw_put(PyObject *, PyObject *args)
{
  char *lName;
  PyObject *lHandle;
  PyObject *lSource;
  mxArray *lArray = NULL;
  //FIXME should make these objects const
  if (! PyArg_ParseTuple(args, "OsO:put", &lHandle, &lName, &lSource)) return NULL;
  if (! PyCObject_Check(lHandle)) {
    PyErr_SetString(PyExc_TypeError, "Invalid object passed as mlabraw session handle");
    return NULL;
  }
  Py_INCREF(lSource);

  if (PyString_Check(lSource)) {
    lArray = char2mx(lSource);
  } else {
    lArray = numeric2mx(lSource);
  }
  Py_DECREF(lSource);

  if (lArray == NULL) {
    return NULL;   // Above converter already set error message
  }


// for matlab version >= 6.5 (FIXME UNTESTED)
#ifdef _V6_5_OR_LATER
  if (engPutVariable((Engine *)PyCObject_AsVoidPtr(lHandle), lName, lArray) != 0) {
#else
  mxSetName(lArray, lName);
  if (engPutArray((Engine *)PyCObject_AsVoidPtr(lHandle), lArray) != 0) {
#endif
    PyErr_SetString(mlabraw_error,
                   "Unable to put matrix into MATLAB(TM) workspace");
    mxDestroyArray(lArray);
    return NULL;
  }
  mxDestroyArray(lArray);
  Py_INCREF(Py_None);
  return Py_None;
}

static PyMethodDef MlabrawMethods[] = {
  { "open",       mlabraw_open,       METH_VARARGS, open_doc },
  { "close",      mlabraw_close,      METH_VARARGS, close_doc },
  { "oldeval",    mlabraw_oldeval,    METH_VARARGS, ""       },
  { "eval",       mlabraw_eval,       METH_VARARGS, eval_doc },  //FIXME doc
  { "get",        mlabraw_get,        METH_VARARGS, get_doc },
  { "put",        mlabraw_put,        METH_VARARGS, put_doc },
  { NULL,         NULL,               0           , NULL}, // sentinel
};

PyMODINIT_FUNC initmlabraw(void)
{
  PyObject *module =
    Py_InitModule4("mlabraw",
      MlabrawMethods,
"Mlabraw -- Low-level MATLAB(tm) Engine Interface\n"
"\n"
"  open  - Open a MATLAB(tm) engine session\n"
"  close - Close a MATLAB(tm) engine session\n"
"  eval  - Evaluates a string in the MATLAB(tm) session\n"
"  get   - Gets a matrix from the MATLAB(tm) session\n"
"  put   - Places a matrix into the MATLAB(tm) session\n"
"\n"



"The Numeric package must be installed for this module to be used.\n"
"\n"
"Copyright & Disclaimer\n"
"======================\n"
"Copyright (c) 2002-2007 Alexander Schmolck <*****@*****.**>\n"
"\n"
"Copyright (c) 1998,1999 Andrew Sterian. All Rights Reserved. mailto: [email protected]\n"
"\n"
"Copyright (c) 1998,1999 THE REGENTS OF THE UNIVERSITY OF MICHIGAN. ALL RIGHTS RESERVED \n"
"\n"
"Permission to use, copy, modify, and distribute this software and its\n"
"documentation for any purpose and without fee is hereby granted, provided\n"
"that the above copyright notices appear in all copies and that both these\n"
"copyright notices and this permission notice appear in supporting\n"
"documentation, and that the name of The University of Michigan not be used\n"
"in advertising or publicity pertaining to distribution of the software\n"
"without specific, written prior permission.\n"
"\n"
"THIS SOFTWARE IS PROVIDED AS IS, WITHOUT REPRESENTATION AS TO ITS FITNESS\n"
"FOR ANY PURPOSE, AND WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR\n"
"IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF\n"
"MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE REGENTS OF THE\n"
"UNIVERSITY OF MICHIGAN SHALL NOT BE LIABLE FOR ANY DAMAGES, INCLUDING\n"
"SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WITH RESPECT TO ANY\n"
"CLAIM ARISING OUT OF OR IN CONNECTION WITH THE USE OF THE SOFTWARE, EVEN IF\n"
"IT HAS BEEN OR IS HEREAFTER ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n"
"\n",
       0,
       PYTHON_API_VERSION);

  /* This macro, defined in arrayobject.h, loads the Numeric API interface */
  import_array();
  PyModule_AddStringConstant(module, "__version__", MLABRAW_VERSION);
  mlabraw_error = PyErr_NewException("mlabraw.error", NULL, NULL);
  Py_INCREF(mlabraw_error);
  PyModule_AddObject(module, "error", mlabraw_error);
}
コード例 #8
0
ファイル: matlab_link.c プロジェクト: NOAA-PMEL/Ferret
/*
 * JS Changed coord arguments to double as external function API changed
 */
int matlab_demo_(float *data,
		 double *xcoords, int *xsize,
		 double *ycoords, int *ysize,
		 float *bad_flag) {
  mxArray *T = NULL, *result = NULL;
  mxArray *mX = NULL, *mY = NULL;
  char buffer[BUFSIZE], cbuffer[BUFSIZE];
  double *ddata = 0, *mxData = 0, *myData = 0;;

				/* Open MATLAB engine */
  if (ep == 0){
    if (!(ep = engOpen("\0"))) {
      fprintf(stderr, "\nCan't start MATLAB engine\n");
      return EXIT_FAILURE;
    }
  }

  engOutputBuffer(ep, buffer, BUFSIZE);
				/* Convert from float->double */
  T = mxCreateDoubleMatrix(*xsize, *ysize, mxREAL);
  mxSetName(T, "FERRET_DATA");
  ddata = mxGetPr(T);

  mX = mxCreateDoubleMatrix(*xsize, 1, mxREAL);
  mxSetName(mX, "FERRET_XDATA");
  mxData = mxGetPr(mX);
  mY = mxCreateDoubleMatrix(*ysize, 1, mxREAL);
  mxSetName(mY, "FERRET_YDATA");
  myData = mxGetPr(mY);
  
  {
    int i;
    for (i=0; i < *xsize * *ysize; ++i){
      float theData = data[i];
      if (theData == *bad_flag){
	ddata[i] = NaN;
      } else {
	ddata[i] = data[i];
      }
    }

    memcpy(mxData, xcoords, sizeof(double)* *xsize);
    memcpy(myData, ycoords, sizeof(double)* *ysize);
  }

  /* Place the variables into the MATLAB workspace */
  engPutArray(ep, T);
  engPutArray(ep, mX);
  engPutArray(ep, mY);

  
  sprintf(cbuffer, "ferretdemo(FERRET_DATA', FERRET_XDATA', FERRET_YDATA');");
  engEvalString(ep, cbuffer);
  /*
   * Echo the output from the command.  First two characters are
   * always the double prompt (>>).
   */
  printf("%s", buffer+2);

  mxDestroyArray(T);
/*   engEvalString(ep, "close;"); */
/*   engClose(ep); */
	
  return EXIT_SUCCESS;
}
コード例 #9
0
ファイル: data2mat.c プロジェクト: jeremybarnes/Thesis
void main(int argc, char **argv)
{
    char *in_filename, *out_filename;
    FILE *in_file;
    MATFile_t *out_file;
    int rows, cols;
    mxArray_t *x, *y, *dimensions, *numcategories;

    printf("Text file to MAT file converter $Revision$\n");
    printf("Copyright Jeremy Barnes, 24/8/1999\n");

    argv0 = argv[0];

    /* Check that we have the right number of arguments... */
    if (argc != 3) {
	fprintf(stderr, "%s: invalid number of arguments (%d)\n", argv[0],
		argc);
	fprintf(stderr, "usage: %s <input_file> <output_file>\n",
		argv[0]);
	exit(1);
    }

    /* Get our filenames */
    in_filename = argv[1];
    out_filename = argv[2];

    printf("Converting %s ==> %s...", in_filename, out_filename);

    /* Check that we can open our input and output files */
    in_file = fopen(in_filename, "r");
    if (in_file == NULL) {
	perror(argv[0]);
	exit(1);
    }

    out_file = matOpen(out_filename, "w");
    if (out_file == NULL) {
	fprintf(stderr, "%s: error opening file %s for output\n",
		argv[0], out_filename);
	exit(1);
    }


    /* Read through the file once to work out how big we want our matrix
       to be */
    figure_out_size(in_file, &rows, &cols);


    /* Create our x and y arrays */
    x = mxCreateDoubleMatrix(rows, cols-1, mxREAL);
    if (x == NULL) {
	fprintf(stderr, "%s: error creating %d by %d matrix x\n",
		argv[0], rows, cols-1);
	exit(2);
    }
    mxSetName(x, "x");

    y = mxCreateDoubleMatrix(rows, 1, mxREAL);
    if (x == NULL) {
	fprintf(stderr, "%s: error creating %d by 1 matrix y\n",
		argv[0], rows);
	exit(2);
    }
    mxSetName(y, "y");


    /* Read through it again, this time getting the data out */
    read_data(in_file, x, y, rows, cols);


    /* Record the number of dimensions */
    dimensions = mxCreateDoubleMatrix(1, 1, mxREAL);
    if (dimensions == NULL) {
	fprintf(stderr, "%s: error creating 1 by 1 matrix dimensions\n",
		argv[0]);
	exit(2);
    }
    *(mxGetPr(dimensions)) = (double)(cols - 1);
    mxSetName(dimensions, "dimensions");


    /* Record the number of categories */
    numcategories = mxCreateDoubleMatrix(1, 1, mxREAL);
    if (numcategories == NULL) {
	fprintf(stderr, "%s: error creating 1 by 1 matrix numcategories\n",
		argv[0]);
	exit(2);
    }
    *(mxGetPr(numcategories)) = 2.0;
    mxSetName(numcategories, "numcategories");


    /* Write our file */
    matPutArray(out_file, x);
    matPutArray(out_file, y);
    matPutArray(out_file, dimensions);
    matPutArray(out_file, numcategories);

    printf(" done.\n");

    /* Clean up */
    mxDestroyArray(x);
    mxDestroyArray(y);
    mxDestroyArray(dimensions);
    mxDestroyArray(numcategories);

    fclose(in_file);
    matClose(out_file);
}