pythonio.h File Reference

#include "../include/pythonincludes.h"
#include "../../c/bamg/bamgobjects.h"
#include "../../c/classes/classes.h"
#include "../../c/shared/shared.h"

Go to the source code of this file.

Functions
void	WriteData (PyObject *py_tuple, int index, double *matrix, int M, int N)
void	WriteData (PyObject *py_tuple, int index, int *matrix, int M, int N)
void	WriteData (PyObject *py_tuple, int index, bool *matrix, int M, int N)
void	WriteData (PyObject *py_tuple, int index, int integer)
void	WriteData (PyObject *py_tuple, int index, double *vector, int M)
void	WriteData (PyObject *py_tuple, int index, short *vector, int M)
void	WriteData (PyObject *py_tuple, int index, int *vector, int M)
void	WriteData (PyObject *py_tuple, int index, char *string)
void	WriteData (PyObject *py_tuple, int index)
void	WriteData (PyObject *py_tuple, int index, IssmDenseMat< double > *matrix)
void	WriteData (PyObject *py_tuple, int index, IssmSeqVec< double > *vector)
void	WriteData (PyObject *py_tuple, int index, BamgGeom *bamggeom)
void	WriteData (PyObject *py_tuple, int index, BamgMesh *bamgmesh)
void	WriteData (PyObject *py_tuple, int index, RiftStruct *riftstruct)
void	FetchData (double **pmatrix, int *pM, int *pN, PyObject *py_array)
void	FetchData (int **pmatrix, int *pM, int *pN, PyObject *py_matrix)
void	FetchData (bool **pmatrix, int *pM, int *pN, PyObject *py_matrix)
void	FetchData (double **pvector, int *pM, PyObject *py_ref)
void	FetchData (float **pvector, int *pM, PyObject *dataref)
void	FetchData (int **pvector, int *pM, PyObject *py_ref)
void	FetchData (bool **pvector, int *pM, PyObject *py_ref)
void	FetchData (char **pstring, PyObject *py_unicode)
void	FetchData (double *pscalar, PyObject *py_float)
void	FetchData (short *pscalar, PyObject *py_float)
void	FetchData (int *pscalar, PyObject *py_long)
void	FetchData (bool *pbool, PyObject *py_boolean)
void	FetchData (BamgGeom **bamggeom, PyObject *py_dict)
void	FetchData (BamgMesh **bamgmesh, PyObject *py_dict)
void	FetchData (BamgOpts **bamgopts, PyObject *py_dict)
void	FetchData (Options **poptions, int istart, int nrhs, PyObject *py_tuple)
void	FetchData (Contours **pcontours, PyObject *py_list)
void	FetchChacoData (int *pnvtxs, int **padjacency, int **pstart, float **pewgts, PyObject *A_IN, PyObject *EWGTS_IN)
void	pyGetJc (double *a, int nvtxs, int *Jc)
void	pyGetIr (double *a, int nvtxs, int nzmax, int *Ir)
int	CheckNumPythonArguments (PyObject *inputs, int NRHS, void(*function)(void))
PyObject *	PyArrayFromCopiedData (int dims[2], double *data)
PyObject *	PyArrayFromCopiedData (int dimi, int dimj, double *data)
PyObject *	PyArrayFromCopiedData (int dimi, int dimj, int *data)
PyObject *	PyArrayFromCopiedData (int dimi, int dimj, bool *data)
void	ApiPrintf (const char *string)

Function Documentation

WriteData() [1/14]

void WriteData	(	PyObject *	py_tuple,
		int	index,
		double *	matrix,
		int	M,
		int	N
	)

Definition at line 35 of file WritePythonData.cpp.

                                                                       {
 
   npy_intp dims[2]={0,0};
   PyObject* array=NULL;
 
   /*copy matrix: */
   double* matrix_python=xNew<double>(M*N);
   memcpy(matrix_python,matrix,M*N*sizeof(double));
 
   dims[0]=(npy_intp)M;
   dims[1]=(npy_intp)N;
   array=PyArray_SimpleNewFromData(2,dims,NPY_DOUBLE,matrix_python);
 
   PyTuple_SetItem(tuple, index, array);
}/*}}}*/

WriteData() [2/14]

void WriteData	(	PyObject *	py_tuple,
		int	index,
		int *	matrix,
		int	M,
		int	N
	)

Definition at line 51 of file WritePythonData.cpp.

                                                                    {
 
   npy_intp dims[2]={0,0};
   PyObject* array=NULL;
 
   /*transform into long matrix: */
   long* lmatrix=xNew<long>(M*N);
   for(int i=0;i<M*N;i++)lmatrix[i]=(long)matrix[i];
 
   dims[0]=(npy_intp)M;
   dims[1]=(npy_intp)N;
   array=PyArray_SimpleNewFromData(2,dims,NPY_INT64,lmatrix);
 
   PyTuple_SetItem(tuple, index, array);
}/*}}}*/

WriteData() [3/14]

void WriteData	(	PyObject *	py_tuple,
		int	index,
		bool *	matrix,
		int	M,
		int	N
	)

Definition at line 67 of file WritePythonData.cpp.

                                                                     {
 
   npy_intp dims[2]={0,0};
   PyObject* array=NULL;
 
   /*copy matrix: */
   bool* matrix_python=xNew<bool>(M*N);
   memcpy(matrix_python,matrix,M*N*sizeof(bool));
 
   dims[0]=(npy_intp)M;
   dims[1]=(npy_intp)N;
   array=PyArray_SimpleNewFromData(2,dims,NPY_BOOL,matrix_python);
 
   PyTuple_SetItem(tuple, index, array);
}/*}}}*/

WriteData() [4/14]

void WriteData	(	PyObject *	py_tuple,
		int	index,
		int	integer
	)

Definition at line 19 of file WritePythonData.cpp.

                                                          {
 
   #if _PYTHON_MAJOR_ >= 3
   PyTuple_SetItem(py_tuple, index, PyLong_FromSsize_t((Py_ssize_t)integer));
   #else
   PyTuple_SetItem(py_tuple, index, PyInt_FromSsize_t((Py_ssize_t)integer));
   #endif
 
}/*}}}*/

WriteData() [5/14]

void WriteData	(	PyObject *	py_tuple,
		int	index,
		double *	vector,
		int	M
	)

Definition at line 83 of file WritePythonData.cpp.

                                                                    {
 
   npy_intp  dim   = 10;
   PyObject *array = NULL;
 
 
   /*copy vector: */
   double* vector_python=xNew<double>(M);
   memcpy(vector_python,vector,M*sizeof(double));
 
   dim=(npy_intp)M;
   array=PyArray_SimpleNewFromData(1,&dim,NPY_DOUBLE,vector_python);
 
   PyTuple_SetItem(py_tuple, index, array);
 
}/*}}}*/

WriteData() [6/14]

void WriteData	(	PyObject *	py_tuple,
		int	index,
		short *	vector,
		int	M
	)

Definition at line 100 of file WritePythonData.cpp.

                                                                  {
 
   long* lvector=NULL;
   npy_intp dim=10;
   PyObject* array=NULL;
 
   /*transform into long matrix: */
   lvector=xNew<long>(M);
   for(int i=0;i<M;i++)lvector[i]=(long)vector[i];
 
   dim=(npy_intp)M;
   array=PyArray_SimpleNewFromData(1,&dim,NPY_INT64,lvector);
 
   PyTuple_SetItem(py_tuple, index, array);
 
}/*}}}*/

WriteData() [7/14]

void WriteData	(	PyObject *	py_tuple,
		int	index,
		int *	vector,
		int	M
	)

Definition at line 117 of file WritePythonData.cpp.

                                                                 {
 
   long* lvector=NULL;
   npy_intp dim=10;
   PyObject* array=NULL;
 
   /*transform into long matrix: */
   lvector=xNew<long>(M);
   for(int i=0;i<M;i++)lvector[i]=(long)vector[i];
 
   dim=(npy_intp)M;
   array=PyArray_SimpleNewFromData(1,&dim,NPY_INT64,lvector);
 
   PyTuple_SetItem(py_tuple, index, array);
 
}/*}}}*/

WriteData() [8/14]

void WriteData	(	PyObject *	py_tuple,
		int	index,
		char *	string
	)

Definition at line 29 of file WritePythonData.cpp.

                                                           {
 
   PyTuple_SetItem(py_tuple, index, PyUnicode_FromString(string));
 
}/*}}}*/

WriteData() [9/14]

void WriteData	(	PyObject *	py_tuple,
		int	index
	)

Definition at line 134 of file WritePythonData.cpp.

                                             {
 
   PyTuple_SetItem(py_tuple, index, Py_None);
 
}/*}}}*/

WriteData() [10/14]

void WriteData	(	PyObject *	py_tuple,
		int	index,
		IssmDenseMat< double > *	matrix
	)

Definition at line 187 of file WritePythonData.cpp.

                                                                         {
 
   int M,N;
   double* buffer=NULL;
   npy_intp dims[2]={0,0};
   PyObject* array=NULL;
 
   matrix->GetSize(&M,&N);
   buffer=matrix->ToSerial();
 
   dims[0]=(npy_intp)M;
   dims[1]=(npy_intp)N;
   array=PyArray_SimpleNewFromData(2,dims,NPY_DOUBLE,buffer);
 
   PyTuple_SetItem(py_tuple, index, array);
 
}/*}}}*/

WriteData() [11/14]

void WriteData	(	PyObject *	py_tuple,
		int	index,
		IssmSeqVec< double > *	vector
	)

Definition at line 205 of file WritePythonData.cpp.

                                                                       {
 
   int M;
   double* buffer=NULL;
   npy_intp dim=10;
   PyObject* array=NULL;
 
   vector->GetSize(&M);
   buffer=vector->ToMPISerial();
 
   dim=(npy_intp)M;
   array=PyArray_SimpleNewFromData(1,&dim,NPY_DOUBLE,buffer);
 
   PyTuple_SetItem(py_tuple, index, array);
}

WriteData() [12/14]

void WriteData	(	PyObject *	py_tuple,
		int	index,
		BamgGeom *	bamggeom
	)

Definition at line 142 of file WritePythonData.cpp.

                                                               {
 
   PyObject* dict=NULL;
 
   dict=PyDict_New();
 
   PyDict_SetItemString(dict,"Vertices",PyArrayFromCopiedData(bamggeom->VerticesSize,bamggeom->Vertices));
   PyDict_SetItemString(dict,"Edges",PyArrayFromCopiedData(bamggeom->EdgesSize,bamggeom->Edges));
   PyDict_SetItemString(dict,"TangentAtEdges",PyArrayFromCopiedData(bamggeom->TangentAtEdgesSize,bamggeom->TangentAtEdges));
   PyDict_SetItemString(dict,"Corners",PyArrayFromCopiedData(bamggeom->CornersSize,bamggeom->Corners));
   PyDict_SetItemString(dict,"RequiredVertices",PyArrayFromCopiedData(bamggeom->RequiredVerticesSize,bamggeom->RequiredVertices));
   PyDict_SetItemString(dict,"RequiredEdges",PyArrayFromCopiedData(bamggeom->RequiredEdgesSize,bamggeom->RequiredEdges));
   PyDict_SetItemString(dict,"CrackedEdges",PyArrayFromCopiedData(bamggeom->CrackedEdgesSize,bamggeom->CrackedEdges));
   PyDict_SetItemString(dict,"SubDomains",PyArrayFromCopiedData(bamggeom->SubDomainsSize,bamggeom->SubDomains));
 
   PyTuple_SetItem(py_tuple, index, dict);
}

WriteData() [13/14]

void WriteData	(	PyObject *	py_tuple,
		int	index,
		BamgMesh *	bamgmesh
	)

Definition at line 161 of file WritePythonData.cpp.

                                                               {
 
   PyObject* dict=NULL;
 
   dict=PyDict_New();
 
   PyDict_SetItemString(dict,"Vertices",PyArrayFromCopiedData(bamgmesh->VerticesSize,bamgmesh->Vertices));
   PyDict_SetItemString(dict,"Edges",PyArrayFromCopiedData(bamgmesh->EdgesSize,bamgmesh->Edges));
   PyDict_SetItemString(dict,"Triangles",PyArrayFromCopiedData(bamgmesh->TrianglesSize,bamgmesh->Triangles));
   PyDict_SetItemString(dict,"IssmEdges",PyArrayFromCopiedData(bamgmesh->IssmEdgesSize,bamgmesh->IssmEdges));
   PyDict_SetItemString(dict,"IssmSegments",PyArrayFromCopiedData(bamgmesh->IssmSegmentsSize,bamgmesh->IssmSegments));
   PyDict_SetItemString(dict,"VerticesOnGeomVertex",PyArrayFromCopiedData(bamgmesh->VerticesOnGeomVertexSize,bamgmesh->VerticesOnGeomVertex));
   PyDict_SetItemString(dict,"VerticesOnGeomEdge",PyArrayFromCopiedData(bamgmesh->VerticesOnGeomEdgeSize,bamgmesh->VerticesOnGeomEdge));
   PyDict_SetItemString(dict,"EdgesOnGeomEdge",PyArrayFromCopiedData(bamgmesh->EdgesOnGeomEdgeSize,bamgmesh->EdgesOnGeomEdge));
   PyDict_SetItemString(dict,"SubDomains",PyArrayFromCopiedData(bamgmesh->SubDomainsSize,bamgmesh->SubDomains));
   PyDict_SetItemString(dict,"SubDomainsFromGeom",PyArrayFromCopiedData(bamgmesh->SubDomainsFromGeomSize,bamgmesh->SubDomainsFromGeom));
   PyDict_SetItemString(dict,"ElementConnectivity",PyArrayFromCopiedData(bamgmesh->ElementConnectivitySize,bamgmesh->ElementConnectivity));
   PyDict_SetItemString(dict,"NodalConnectivity",PyArrayFromCopiedData(bamgmesh->NodalConnectivitySize,bamgmesh->NodalConnectivity));
   PyDict_SetItemString(dict,"NodalElementConnectivity",PyArrayFromCopiedData(bamgmesh->NodalElementConnectivitySize,bamgmesh->NodalElementConnectivity));
   PyDict_SetItemString(dict,"CrackedVertices",PyArrayFromCopiedData(bamgmesh->CrackedVerticesSize,bamgmesh->CrackedVertices));
   PyDict_SetItemString(dict,"CrackedEdges",PyArrayFromCopiedData(bamgmesh->CrackedEdgesSize,bamgmesh->CrackedEdges));
 
   PyTuple_SetItem(py_tuple, index, dict);
}

WriteData() [14/14]

void WriteData	(	PyObject *	py_tuple,
		int	index,
		RiftStruct *	riftstruct
	)

Definition at line 222 of file WritePythonData.cpp.

                                                                   {
 
   int i;
   PyObject* list=NULL;
   PyObject* dict=NULL;
 
   list=PyList_New((Py_ssize_t)0);
 
   for (i=0; i<riftstruct->numrifts; i++) {
      dict=PyDict_New();
 
      #if _PYTHON_MAJOR_ >= 3
      PyDict_SetItemString(dict,"numsegs"          ,PyLong_FromSsize_t((Py_ssize_t)riftstruct->riftsnumsegments[i]));
      PyDict_SetItemString(dict,"fill"             ,PyUnicode_FromString("Ice"));
      PyDict_SetItemString(dict,"friction"         ,PyLong_FromSsize_t((Py_ssize_t)0));
      #else
      PyDict_SetItemString(dict,"numsegs"          ,PyInt_FromSsize_t((Py_ssize_t)riftstruct->riftsnumsegments[i]));
      PyDict_SetItemString(dict,"fill"             ,PyString_FromString("Ice"));
      PyDict_SetItemString(dict,"friction"         ,PyInt_FromSsize_t((Py_ssize_t)0));
      #endif
 
      PyDict_SetItemString(dict,"segments"         ,PyArrayFromCopiedData(riftstruct->riftsnumsegments[i]    ,3,riftstruct->riftssegments[i]));
      PyDict_SetItemString(dict,"pairs"            ,PyArrayFromCopiedData(riftstruct->riftsnumpairs[i]       ,2,riftstruct->riftspairs[i]));
      PyDict_SetItemString(dict,"tips"             ,PyArrayFromCopiedData(1                                  ,2,&riftstruct->riftstips[2*i]));
      PyDict_SetItemString(dict,"penaltypairs"     ,PyArrayFromCopiedData(riftstruct->riftsnumpenaltypairs[i],7,riftstruct->riftspenaltypairs[i]));
      PyDict_SetItemString(dict,"fraction"         ,PyFloat_FromDouble(0.));
      PyDict_SetItemString(dict,"fractionincrement",PyFloat_FromDouble(0.1));
      PyDict_SetItemString(dict,"state"            ,PyArrayFromCopiedData(riftstruct->riftsnumpenaltypairs[i],1,riftstruct->state[i]));
 
      PyList_Append(list, dict);
   }
 
   PyTuple_SetItem(py_tuple, index, list);
}

FetchData() [1/17]

void FetchData	(	double **	pmatrix,
		int *	pM,
		int *	pN,
		PyObject *	py_array
	)

Definition at line 178 of file FetchPythonData.cpp.

                                                                    {
 
   /*output: */
   double* dmatrix=NULL;
   double* matrix=NULL;
   int M=0;
   int N=0;
   int ndim;
   npy_intp*  dims=NULL;
 
   /*intermediary:*/
   long* lmatrix=NULL;
   bool* bmatrix=NULL;
   int i;
   PyObject* py_matrix2=NULL;
 
   if (PyArray_Check((PyArrayObject*)py_matrix)) {
      /*retrieve dimensions: */
      ndim=PyArray_NDIM((const PyArrayObject*)py_matrix);
      if (ndim==2) {
         dims=PyArray_DIMS((PyArrayObject*)py_matrix);
         M=dims[0]; N=dims[1];
      }
      else if (ndim==1) {
         dims=PyArray_DIMS((PyArrayObject*)py_matrix);
         M=dims[0]; N=1;
      }
      else
         _error_("expecting an MxN matrix or M vector in input!");
 
      if (M && N) {
         if (!PyArray_ISCONTIGUOUS((PyArrayObject*)py_matrix)) {
            py_matrix2=PyArray_ContiguousFromAny(py_matrix,NPY_DOUBLE,ndim,ndim);
            py_matrix=py_matrix2;
         }
 
         if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_DOUBLE) {
            /*retrieve internal value: */
            dmatrix=(double*)PyArray_DATA((PyArrayObject*)py_matrix);
 
            /*copy matrix: */
            matrix=xNew<double>(M*N);
            memcpy(matrix,dmatrix,(M*N)*sizeof(double));
         }
 
         else if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_LONG) {
            /*retrieve internal value: */
            lmatrix=(long*)PyArray_DATA((PyArrayObject*)py_matrix);
 
            /*transform into double matrix: */
            matrix=xNew<double>(M*N);
            for(i=0;i<M*N;i++)matrix[i]=(double)lmatrix[i];
         }
 
         else if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_BOOL) {
            /*retrieve internal value: */
            bmatrix=(bool*)PyArray_DATA((PyArrayObject*)py_matrix);
 
            /*transform into double matrix: */
            matrix=xNew<double>(M*N);
            for(i=0;i<M*N;i++)matrix[i]=(double)bmatrix[i];
         }
 
         else
            _error_("unrecognized double pyarray type in input!");
 
         //if (py_matrix2) delete(py_matrix2); Not doing this for now, seems to  be creating a segfault!
      }
      else
         matrix=NULL;
   }
   else if (PyList_Check(py_matrix)) {
      /*retrieve dimensions: */
      M=(int)PyList_Size(py_matrix);
      N=1;
      if (M) {
         matrix=xNew<double>(M);
         for (int index = 0; index < M; index++) {
            PyObject *item;
            item = PyList_GetItem(py_matrix, index);
            if ((int)PyList_Size(item)>1)
               _error_("2D lists are not suported");
            FetchData(&(matrix[index]),item);
         }
      }
      //if (py_matrix2) delete(py_matrix2); Not doing this for now, seems to  be creating a segfault!
      else
         matrix=NULL;
   }
   else if (PyTuple_Check(py_matrix)) {
      /*retrieve dimensions: */
      M=(int)PyTuple_Size(py_matrix);
      N=1;
      if (M) {
         matrix=xNew<double>(M);
         for (int index = 0; index < M; index++) {
            PyObject *item;
            item = PyTuple_GetItem(py_matrix, index);
            if ((int)PyTuple_Size(item)>1)
               _error_("2D tuple are not suported");
            FetchData(&(matrix[index]),item);
         }
      }
      //if (py_matrix2) delete(py_matrix2); Not doing this for now, seems to  be creating a segfault!
      else
         matrix=NULL;
   }
 
   else {
      M=1;
      N=1;
      matrix=xNew<double>(M*N);
      FetchData(&(matrix[0]),py_matrix);
   }
 
   /*output: */
   if(pM)*pM=M;
   if(pN)*pN=N;
   if(pmatrix)*pmatrix=matrix;
}

FetchData() [2/17]

void FetchData	(	int **	pmatrix,
		int *	pM,
		int *	pN,
		PyObject *	py_matrix
	)

Definition at line 300 of file FetchPythonData.cpp.

                                                                 {
 
   /*output: */
   int* matrix=NULL;
   int M=0;
   int N=0;
   int ndim;
   npy_intp*  dims=NULL;
 
   /*intermediary:*/
   double* dmatrix=NULL;
   long* lmatrix=NULL;
   bool* bmatrix=NULL;
   int i;
   PyObject* py_matrix2=NULL;
 
   if     (PyArray_Check((PyArrayObject*)py_matrix)) {
      /*retrieve dimensions: */
      ndim=PyArray_NDIM((const PyArrayObject*)py_matrix);
      if      (ndim==2) {
         dims=PyArray_DIMS((PyArrayObject*)py_matrix);
         M=dims[0]; N=dims[1];
      }
      else if (ndim==1) {
         dims=PyArray_DIMS((PyArrayObject*)py_matrix);
         M=dims[0]; N=1;
      }
      else
         _error_("expecting an MxN matrix or M vector in input!");
 
      if (M && N) {
         if (!PyArray_ISCONTIGUOUS((PyArrayObject*)py_matrix)) {
            py_matrix2=PyArray_ContiguousFromAny(py_matrix,NPY_LONG,ndim,ndim);
            py_matrix=py_matrix2;
         }
 
         if      (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_DOUBLE) {
            /*retrieve internal value: */
            dmatrix=(double*)PyArray_DATA((PyArrayObject*)py_matrix);
 
            /*transform into integer matrix: */
            matrix=xNew<int>(M*N);
            for(i=0;i<M*N;i++)matrix[i]=(int)dmatrix[i];
         }
 
         else if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_LONG) {
            /*retrieve internal value: */
            lmatrix=(long*)PyArray_DATA((PyArrayObject*)py_matrix);
 
            /*transform into integer matrix: */
            matrix=xNew<int>(M*N);
            for(i=0;i<M*N;i++)matrix[i]=(int)lmatrix[i];
         }
 
         else if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_BOOL) {
            /*retrieve internal value: */
            bmatrix=(bool*)PyArray_DATA((PyArrayObject*)py_matrix);
 
            /*transform into integer matrix: */
            matrix=xNew<int>(M*N);
            for(i=0;i<M*N;i++)matrix[i]=(int)bmatrix[i];
         }
 
         else
            _error_("unrecognized int pyarray type in input!");
 
         /* These lines are causing a segfault
         if (py_matrix2)
            delete(py_matrix2);
         */
      }
      else
         matrix=NULL;
   }
   else if (PyList_Check(py_matrix)) {
      /*retrieve dimensions: */
      M=(int)PyList_Size(py_matrix);
      N=1;
      if (M) {
         matrix=xNew<int>(M);
         for (int index = 0; index < M; index++) {
            PyObject *item;
            item = PyList_GetItem(py_matrix, index);
            if ((int)PyList_Size(item)>1)
               _error_("2D lists are not suported");
            FetchData(&(matrix[index]),item);
         }
      }
      else
         matrix=NULL;
   }
   else if (PyTuple_Check(py_matrix)) {
      /*retrieve dimensions: */
      M=(int)PyTuple_Size(py_matrix);
      N=1;
      if (M) {
         matrix=xNew<int>(M);
         for (int index = 0; index < M; index++) {
            PyObject *item;
            item = PyTuple_GetItem(py_matrix, index);
            if ((int)PyTuple_Size(item)>1)
               _error_("2D tuple are not suported");
            FetchData(&(matrix[index]),item);
         }
      }
      //if (py_matrix2) delete(py_matrix2); Not doing this for now, seems to  be creating a segfault!
      else
         matrix=NULL;
   }
 
   else {
      M=1;
      N=1;
      matrix=xNew<int>(M*N);
      FetchData(&(matrix[0]),py_matrix);
   }
 
   /*output: */
   if(pM)*pM=M;
   if(pN)*pN=N;
   if(pmatrix)*pmatrix=matrix;
}

FetchData() [3/17]

void FetchData	(	bool **	pmatrix,
		int *	pM,
		int *	pN,
		PyObject *	py_matrix
	)

Definition at line 424 of file FetchPythonData.cpp.

                                                                  {
 
   /*output: */
   bool* bmatrix=NULL;
   bool* matrix=NULL;
   int M=0;
   int N=0;
   int ndim;
   npy_intp*  dims=NULL;
 
   /*intermediary:*/
   double* dmatrix=NULL;
   long* lmatrix=NULL;
   int i;
   PyObject* py_matrix2=NULL;
 
   if     (PyArray_Check((PyArrayObject*)py_matrix)) {
      /*retrieve dimensions: */
      ndim=PyArray_NDIM((const PyArrayObject*)py_matrix);
      if      (ndim==2) {
         dims=PyArray_DIMS((PyArrayObject*)py_matrix);
         M=dims[0]; N=dims[1];
      }
      else if (ndim==1) {
         dims=PyArray_DIMS((PyArrayObject*)py_matrix);
         M=dims[0]; N=1;
      }
      else
         _error_("expecting an MxN matrix or M vector in input!");
 
      if (M && N) {
         if (!PyArray_ISCONTIGUOUS((PyArrayObject*)py_matrix)) {
            py_matrix2=PyArray_ContiguousFromAny(py_matrix,NPY_BOOL,ndim,ndim);
            py_matrix=py_matrix2;
         }
 
         if      (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_DOUBLE) {
            /*retrieve internal value: */
            dmatrix=(double*)PyArray_DATA((PyArrayObject*)py_matrix);
 
            /*transform into bool matrix: */
            matrix=xNew<bool>(M*N);
            for(i=0;i<M*N;i++)matrix[i]=(bool)dmatrix[i];
         }
 
         else if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_LONG) {
            /*retrieve internal value: */
            lmatrix=(long*)PyArray_DATA((PyArrayObject*)py_matrix);
 
            /*transform into bool matrix: */
            matrix=xNew<bool>(M*N);
            for(i=0;i<M*N;i++)matrix[i]=(bool)lmatrix[i];
         }
 
         else if (PyArray_TYPE((PyArrayObject*)py_matrix) == NPY_BOOL) {
            /*retrieve internal value: */
            bmatrix=(bool*)PyArray_DATA((PyArrayObject*)py_matrix);
 
            /*copy matrix: */
            matrix=xNew<bool>(M*N);
            memcpy(matrix,bmatrix,(M*N)*sizeof(bool));
         }
 
         else
            _error_("unrecognized bool pyarray type in input!");
 
         if (py_matrix2)
            delete(py_matrix2);
      }
      else
         matrix=NULL;
   }
      //if (py_matrix2) delete(py_matrix2); Not doing this for now, seems to  be creating a segfault!
 
   else if (PyList_Check(py_matrix)) {
      /*retrieve dimensions: */
      M=(int)PyList_Size(py_matrix);
      N=1;
      if (M) {
         matrix=xNew<bool>(M);
         for (int index = 0; index < M; index++) {
            PyObject *item;
            item = PyList_GetItem(py_matrix, index);
            if ((int)PyList_Size(item)>1)
               _error_("2D lists are not suported");
            FetchData(&(matrix[index]),item);
         }
      }
      else
         matrix=NULL;
   }
   else if (PyTuple_Check(py_matrix)) {
      /*retrieve dimensions: */
      M=(int)PyTuple_Size(py_matrix);
      N=1;
      if (M) {
         matrix=xNew<bool>(M);
         for (int index = 0; index < M; index++) {
            PyObject *item;
            item = PyTuple_GetItem(py_matrix, index);
            if ((int)PyTuple_Size(item)>1)
               _error_("2D tuples are not suported");
            FetchData(&(matrix[index]),item);
         }
      }
      //if (py_matrix2) delete(py_matrix2); Not doing this for now, seems to  be creating a segfault!
      else
         matrix=NULL;
   }
 
   else {
      M=1;
      N=1;
      matrix=xNew<bool>(M*N);
      FetchData(&(matrix[0]),py_matrix);
   }
 
   /*output: */
   if(pM)*pM=M;
   if(pN)*pN=N;
   if(pmatrix)*pmatrix=matrix;
}

FetchData() [4/17]

void FetchData	(	double **	pvector,
		int *	pM,
		PyObject *	py_ref
	)

Definition at line 548 of file FetchPythonData.cpp.

                                                            {
 
   /*output: */
   double* dvector=NULL;
   double* vector=NULL;
   int M=0;
   int ndim;
   npy_intp*  dims=NULL;
 
   /*intermediary:*/
   long* lvector=NULL;
   bool* bvector=NULL;
   int i;
   PyObject* py_vector2=NULL;
 
   if     (PyArray_Check((PyArrayObject*)py_vector)) {
      /*retrieve dimensions: */
      ndim=PyArray_NDIM((const PyArrayObject*)py_vector);
      if      (ndim==1) {
         dims=PyArray_DIMS((PyArrayObject*)py_vector);
         M=dims[0];
      }
      else if (ndim==2) {
         dims=PyArray_DIMS((PyArrayObject*)py_vector);
         if (dims[1]==1)
            M=dims[0];
         else
            _error_("expecting an Mx1 matrix or M vector in input!");
      }
      else
         _error_("expecting an Mx1 matrix or M vector in input!");
 
      if (M) {
         if (!PyArray_ISCONTIGUOUS((PyArrayObject*)py_vector)) {
            py_vector2=PyArray_ContiguousFromAny(py_vector,NPY_DOUBLE,ndim,ndim);
            py_vector=py_vector2;
         }
 
         if      (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
            /*retrieve internal value: */
            dvector=(double*)PyArray_DATA((PyArrayObject*)py_vector);
 
            /*copy vector: */
            vector=xNew<double>(M);
            memcpy(vector,dvector,(M)*sizeof(double));
         }
 
         else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_LONG) {
            /*retrieve internal value: */
            lvector=(long*)PyArray_DATA((PyArrayObject*)py_vector);
 
            /*transform into double vector: */
            vector=xNew<double>(M);
            for(i=0;i<M;i++)vector[i]=(double)lvector[i];
         }
 
         else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_BOOL) {
            /*retrieve internal value: */
            bvector=(bool*)PyArray_DATA((PyArrayObject*)py_vector);
 
            /*transform into double vector: */
            vector=xNew<double>(M);
            for(i=0;i<M;i++)vector[i]=(double)bvector[i];
         }
 
         else
            _error_("unrecognized double pyarray type in input!");
 
         /* Causing a seg fault.
         if (py_vector2)
            delete(py_vector2);
         */
      }
      else
         vector=NULL;
   }
   else if (PyList_Check(py_vector)) {
      /*retrieve dimensions: */
      M=(int)PyList_Size(py_vector);
 
      if (M) {
         vector=xNew<double>(M);
         for (int index = 0; index < M; index++) {
            PyObject *item;
            item = PyList_GetItem(py_vector, index);
            FetchData(&(vector[index]),item);
         }
      }
      else
         vector=NULL;
   }
   else if (PyTuple_Check(py_vector)) {
      /*retrieve dimensions: */
      M=(int)PyTuple_Size(py_vector);
 
      if (M) {
         vector=xNew<double>(M);
         for (int index = 0; index < M; index++) {
            PyObject *item;
            item = PyTuple_GetItem(py_vector, index);
            FetchData(&(vector[index]),item);
         }
      }
      //if (py_matrix2) delete(py_matrix2); Not doing this for now, seems to  be creating a segfault!
      else
         vector=NULL;
   }
 
   else {
      M=1;
      vector=xNew<double>(M);
      FetchData(&(vector[0]),py_vector);
   }
 
   /*output: */
   if(pM)*pM=M;
   if(pvector)*pvector=vector;
}

FetchData() [5/17]

void FetchData	(	float **	pvector,
		int *	pM,
		PyObject *	dataref
	)

Definition at line 668 of file FetchPythonData.cpp.

                                                           {
 
   /*output: */
   float* vector=NULL;
   int M=0;
   int ndim;
   npy_intp*  dims=NULL;
 
   /*intermediary:*/
   long*   lvector=NULL;
   bool*   bvector=NULL;
   double* dvector=NULL;
   int i;
   PyObject* py_vector2=NULL;
 
   if     (PyArray_Check((PyArrayObject*)py_vector)) {
      /*retrieve dimensions: */
      ndim=PyArray_NDIM((const PyArrayObject*)py_vector);
      if      (ndim==1) {
         dims=PyArray_DIMS((PyArrayObject*)py_vector);
         M=dims[0];
      }
      else if (ndim==2) {
         dims=PyArray_DIMS((PyArrayObject*)py_vector);
         if (dims[1]==1)
          M=dims[0];
         else
          _error_("expecting an Mx1 matrix or M vector in input!");
      }
      else
       _error_("expecting an Mx1 matrix or M vector in input!");
 
      if (M) {
         if (!PyArray_ISCONTIGUOUS((PyArrayObject*)py_vector)) {
            py_vector2=PyArray_ContiguousFromAny(py_vector,NPY_LONG,ndim,ndim);
            py_vector=py_vector2;
         }
 
         if      (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
            /*retrieve internal value: */
            dvector=(double*)PyArray_DATA((PyArrayObject*)py_vector);
 
            /*transform into int vector: */
            vector=xNew<float>(M);
            for(i=0;i<M;i++)vector[i]=(float)dvector[i];
         }
 
         else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_LONG) {
            /*retrieve internal value: */
            lvector=(long*)PyArray_DATA((PyArrayObject*)py_vector);
 
            /*transform into int vector: */
            vector=xNew<float>(M);
            for(i=0;i<M;i++)vector[i]=(float)lvector[i];
         }
 
         else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_BOOL) {
            /*retrieve internal value: */
            bvector=(bool*)PyArray_DATA((PyArrayObject*)py_vector);
 
            /*transform into int vector: */
            vector=xNew<float>(M);
            for(i=0;i<M;i++)vector[i]=(float)bvector[i];
         }
 
         else
          _error_("unrecognized int pyarray type in input!");
 
         if(py_vector2) delete(py_vector2);
      }
      else
         vector=NULL;
   }
   else if (PyList_Check(py_vector)) {
      /*retrieve dimensions: */
      M=(int)PyList_Size(py_vector);
 
      if (M) {
         vector=xNew<float>(M);
         for (int index = 0; index < M; index++) {
            PyObject *item;
            item = PyList_GetItem(py_vector, index);
            FetchData(&(vector[index]),item);
         }
      }
      else
         vector=NULL;
   }
 
   else if (PyTuple_Check(py_vector)) {
      /*retrieve dimensions: */
      M=(int)PyTuple_Size(py_vector);
 
      if (M) {
         vector=xNew<float>(M);
         for (int index = 0; index < M; index++) {
            PyObject *item;
            item = PyTuple_GetItem(py_vector, index);
            FetchData(&(vector[index]),item);
         }
      }
      //if (py_matrix2) delete(py_matrix2); Not doing this for now, seems to  be creating a segfault!
      else
         vector=NULL;
   }
 
   else{
      M=1;
      vector=xNew<float>(M);
      FetchData(&(vector[0]),py_vector);
   }
 
   /*output: */
   if(pM)*pM=M;
   if(pvector)*pvector=vector;
}

FetchData() [6/17]

void FetchData	(	int **	pvector,
		int *	pM,
		PyObject *	py_ref
	)

Definition at line 786 of file FetchPythonData.cpp.

                                                         {
 
   /*output: */
   int* vector=NULL;
   int M=0;
   int ndim;
   npy_intp*  dims=NULL;
 
   /*intermediary:*/
   long*   lvector=NULL;
   bool*   bvector=NULL;
   double* dvector=NULL;
   int i;
   PyObject* py_vector2=NULL;
 
   if     (PyArray_Check((PyArrayObject*)py_vector)) {
      /*retrieve dimensions: */
      ndim=PyArray_NDIM((const PyArrayObject*)py_vector);
      if      (ndim==1) {
         dims=PyArray_DIMS((PyArrayObject*)py_vector);
         M=dims[0];
      }
      else if (ndim==2) {
         dims=PyArray_DIMS((PyArrayObject*)py_vector);
         if (dims[1]==1)
            M=dims[0];
         else
            _error_("expecting an Mx1 matrix or M vector in input!");
      }
      else
         _error_("expecting an Mx1 matrix or M vector in input!");
 
      if (M) {
         if (!PyArray_ISCONTIGUOUS((PyArrayObject*)py_vector)) {
            py_vector2=PyArray_ContiguousFromAny(py_vector,NPY_LONG,ndim,ndim);
            py_vector=py_vector2;
         }
 
         if      (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
            /*retrieve internal value: */
            dvector=(double*)PyArray_DATA((PyArrayObject*)py_vector);
 
            /*transform into int vector: */
            vector=xNew<int>(M);
            for(i=0;i<M;i++)vector[i]=(int)dvector[i];
         }
 
         else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_LONG) {
            /*retrieve internal value: */
            lvector=(long*)PyArray_DATA((PyArrayObject*)py_vector);
 
            /*transform into int vector: */
            vector=xNew<int>(M);
            for(i=0;i<M;i++)vector[i]=(int)lvector[i];
         }
 
         else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_BOOL) {
            /*retrieve internal value: */
            bvector=(bool*)PyArray_DATA((PyArrayObject*)py_vector);
 
            /*transform into int vector: */
            vector=xNew<int>(M);
            for(i=0;i<M;i++)vector[i]=(int)bvector[i];
         }
 
         else
          _error_("unrecognized int pyarray type in input!");
 
         if (py_vector2)
            delete(py_vector2);
      }
      else
         vector=NULL;
   }
 
   else if (PyList_Check(py_vector)) {
      /*retrieve dimensions: */
      M=(int)PyList_Size(py_vector);
 
      if (M) {
         vector=xNew<int>(M);
         for (int index = 0; index < M; index++) {
            PyObject *item;
            item = PyList_GetItem(py_vector, index);
            FetchData(&(vector[index]),item);
         }
      }
      else
         vector=NULL;
   }
 
   else if (PyTuple_Check(py_vector)) {
      /*retrieve dimensions: */
      M=(int)PyTuple_Size(py_vector);
 
      if (M) {
         vector=xNew<int>(M);
         for (int index = 0; index < M; index++) {
            PyObject *item;
            item = PyTuple_GetItem(py_vector, index);
            FetchData(&(vector[index]),item);
         }
      }
      //if (py_matrix2) delete(py_matrix2); Not doing this for now, seems to  be creating a segfault!
      else
         vector=NULL;
   }
 
   else {
      M=1;
      vector=xNew<int>(M);
      FetchData(&(vector[0]),py_vector);
   }
 
   /*output: */
   if(pM)*pM=M;
   if(pvector)*pvector=vector;
}

FetchData() [7/17]

void FetchData	(	bool **	pvector,
		int *	pM,
		PyObject *	py_ref
	)

Definition at line 906 of file FetchPythonData.cpp.

                                                          {
 
   /*output: */
   bool* bvector=NULL;
   bool* vector=NULL;
   int M=0;
   int ndim;
   npy_intp*  dims=NULL;
 
   /*intermediary:*/
   double* dvector=NULL;
   long* lvector=NULL;
   int i;
   PyObject* py_vector2=NULL;
 
   if     (PyArray_Check((PyArrayObject*)py_vector)) {
      /*retrieve dimensions: */
      ndim=PyArray_NDIM((const PyArrayObject*)py_vector);
      if      (ndim==1) {
         dims=PyArray_DIMS((PyArrayObject*)py_vector);
         M=dims[0];
      }
      else if (ndim==2) {
         dims=PyArray_DIMS((PyArrayObject*)py_vector);
         if (dims[1]==1)
            M=dims[0];
         else
            _error_("expecting an Mx1 matrix or M vector in input!");
      }
      else
         _error_("expecting an Mx1 matrix or M vector in input!");
 
      if (M) {
         if (!PyArray_ISCONTIGUOUS((PyArrayObject*)py_vector)) {
            py_vector2=PyArray_ContiguousFromAny(py_vector,NPY_BOOL,ndim,ndim);
            py_vector=py_vector2;
         }
 
         if      (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_DOUBLE) {
            /*retrieve internal value: */
            dvector=(double*)PyArray_DATA((PyArrayObject*)py_vector);
 
            /*transform into bool vector: */
            vector=xNew<bool>(M);
            for(i=0;i<M;i++)vector[i]=(bool)dvector[i];
         }
 
         else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_LONG) {
            /*retrieve internal value: */
            lvector=(long*)PyArray_DATA((PyArrayObject*)py_vector);
 
            /*transform into bool vector: */
            vector=xNew<bool>(M);
            for(i=0;i<M;i++)vector[i]=(bool)lvector[i];
         }
 
         else if (PyArray_TYPE((PyArrayObject*)py_vector) == NPY_BOOL) {
            /*retrieve internal value: */
            bvector=(bool*)PyArray_DATA((PyArrayObject*)py_vector);
 
            /*copy vector: */
            vector=xNew<bool>(M);
            memcpy(vector,bvector,(M)*sizeof(bool));
         }
 
         else
            _error_("unrecognized bool pyarray type in input!");
 
         if (py_vector2)
            delete(py_vector2);
      }
      else
         vector=NULL;
   }
   else if (PyList_Check(py_vector)) {
      /*retrieve dimensions: */
      M=(int)PyList_Size(py_vector);
      if (M) {
         vector=xNew<bool>(M);
         for (int index = 0; index < M; index++) {
            PyObject *item;
            item = PyList_GetItem(py_vector, index);
            FetchData(&(vector[index]),item);
         }
      }
      else
         vector=NULL;
   }
 
   else if (PyTuple_Check(py_vector)) {
      /*retrieve dimensions: */
      M=(int)PyTuple_Size(py_vector);
 
      if (M) {
         vector=xNew<bool>(M);
         for (int index = 0; index < M; index++) {
            PyObject *item;
            item = PyTuple_GetItem(py_vector, index);
            FetchData(&(vector[index]),item);
         }
      }
      //if (py_matrix2) delete(py_matrix2); Not doing this for now, seems to  be creating a segfault!
      else
         vector=NULL;
   }
 
   else {
      M=1;
      vector=xNew<bool>(M);
      FetchData(&(vector[0]),py_vector);
   }
 
   /*output: */
   if(pM)*pM=M;
   if(pvector)*pvector=vector;
}

FetchData() [8/17]

void FetchData	(	char **	pstring,
		PyObject *	py_unicode
	)

Definition at line 1296 of file FetchPythonData.cpp.

                                                  {
 
   /*extract internal string: */
   #if _PYTHON_MAJOR_ == 3
   const char* string=PyUnicode_AsUTF8(py_string);
   #else
   char* string=PyString_AsString(py_string);
   #endif
   /*copy string (note strlen does not include trailing NULL): */
   *pstring=xNew<char>(strlen(string)+1);
   memcpy(*pstring,string,(strlen(string)+1)*sizeof(char));
}

FetchData() [9/17]

void FetchData	(	double *	pscalar,
		PyObject *	py_float
	)

Definition at line 19 of file FetchPythonData.cpp.

                                                  {
 
   double dscalar;
 
   /*return internal value: */
   #if _PYTHON_MAJOR_ == 3
   if (PyFloat_Check(py_float))
      dscalar=PyFloat_AsDouble(py_float);
   else if (PyLong_Check(py_float))
      dscalar=(double)PyLong_AsLong(py_float);
   else if (PyBool_Check(py_float))
      dscalar=(double)PyLong_AsLong(py_float);
   else if (PyTuple_Check(py_float) && (int)PyTuple_Size(py_float)==1)
      FetchData(&dscalar,PyTuple_GetItem(py_float,(Py_ssize_t)0));
   else if (PyList_Check(py_float) && (int)PyList_Size(py_float)==1)
      FetchData(&dscalar,PyList_GetItem(py_float,(Py_ssize_t)0));
   else
      _error_("unrecognized float type py3 in input!");
 
   #else
   if (PyFloat_Check(py_float))
      dscalar=PyFloat_AsDouble(py_float);
   else if (PyLong_Check(py_float))
      dscalar=PyLong_AsDouble(py_float);
   else if (PyInt_Check(py_float))
      dscalar=(double)PyInt_AsLong(py_float);
   else if (PyBool_Check(py_float))
      dscalar=(double)PyLong_AsLong(py_float);
   else if (PyTuple_Check(py_float) && (int)PyTuple_Size(py_float)==1)
      FetchData(&dscalar,PyTuple_GetItem(py_float,(Py_ssize_t)0));
   else if (PyList_Check(py_float) && (int)PyList_Size(py_float)==1)
      FetchData(&dscalar,PyList_GetItem(py_float,(Py_ssize_t)0));
   else
      _error_("unrecognized float type in py2 input!");
   #endif
   /*output: */
   *pscalar=dscalar;
}

FetchData() [10/17]

void FetchData	(	short *	pscalar,
		PyObject *	py_float
	)

FetchData() [11/17]

void FetchData	(	int *	pscalar,
		PyObject *	py_long
	)

Definition at line 98 of file FetchPythonData.cpp.

                                               {
 
   int iscalar;
 
   /*return internal value: */
   #if _PYTHON_MAJOR_ == 3
   if (PyLong_Check(py_long))
      iscalar=(int)PyLong_AsLong(py_long);
   else if (PyFloat_Check(py_long))
      iscalar=(int)PyFloat_AsDouble(py_long);
   else if (PyBool_Check(py_long))
      iscalar=(int)PyLong_AsLong(py_long);
   else if (PyTuple_Check(py_long) && (int)PyTuple_Size(py_long)==1)
      FetchData(&iscalar,PyTuple_GetItem(py_long,(Py_ssize_t)0));
   else if (PyList_Check(py_long) && (int)PyList_Size(py_long)==1)
      FetchData(&iscalar,PyList_GetItem(py_long,(Py_ssize_t)0));
   else
      _error_("unrecognized long type in input!");
 
   #else
   if (PyLong_Check(py_long))
      iscalar=(int)PyLong_AsLong(py_long);
   else if (PyInt_Check(py_long))
      iscalar=(int)PyInt_AsLong(py_long);
   else if (PyFloat_Check(py_long))
      iscalar=(int)PyFloat_AsDouble(py_long);
   else if (PyBool_Check(py_long))
      iscalar=(int)PyLong_AsLong(py_long);
   else if (PyTuple_Check(py_long) && (int)PyTuple_Size(py_long)==1)
      FetchData(&iscalar,PyTuple_GetItem(py_long,(Py_ssize_t)0));
   else if (PyList_Check(py_long) && (int)PyList_Size(py_long)==1)
      FetchData(&iscalar,PyList_GetItem(py_long,(Py_ssize_t)0));
   else
      _error_("unrecognized long type in input!");
   #endif
   /*output: */
   *pscalar=iscalar;
}

FetchData() [12/17]

void FetchData	(	bool *	pbool,
		PyObject *	py_boolean
	)

Definition at line 138 of file FetchPythonData.cpp.

                                                  {
 
   bool bscalar;
 
   /*return internal value: */
   #if _PYTHON_MAJOR_ == 3
   if (PyBool_Check(py_boolean))
      bscalar=(bool)PyLong_AsLong(py_boolean);
   else if (PyLong_Check(py_boolean))
      bscalar=(bool)PyLong_AsLong(py_boolean);
   else if (PyLong_Check(py_boolean))
      bscalar=(bool)PyLong_AsLong(py_boolean);
   else if (PyTuple_Check(py_boolean) && (int)PyTuple_Size(py_boolean)==1)
      FetchData(&bscalar,PyTuple_GetItem(py_boolean,(Py_ssize_t)0));
   else if (PyList_Check(py_boolean) && (int)PyList_Size(py_boolean)==1)
      FetchData(&bscalar,PyList_GetItem(py_boolean,(Py_ssize_t)0));
   else
      _error_("unrecognized boolean type in input!");
 
   #else
   if      (PyBool_Check(py_boolean))
      bscalar=(bool)PyLong_AsLong(py_boolean);
   else if (PyLong_Check(py_boolean))
      bscalar=(bool)PyLong_AsLong(py_boolean);
   else if (PyLong_Check(py_boolean))
      bscalar=(bool)PyLong_AsLong(py_boolean);
   else if (PyInt_Check(py_boolean))
      bscalar=(bool)PyInt_AsLong(py_boolean);
   else if (PyTuple_Check(py_boolean) && (int)PyTuple_Size(py_boolean)==1)
      FetchData(&bscalar,PyTuple_GetItem(py_boolean,(Py_ssize_t)0));
   else if (PyList_Check(py_boolean) && (int)PyList_Size(py_boolean)==1)
      FetchData(&bscalar,PyList_GetItem(py_boolean,(Py_ssize_t)0));
   else
      _error_("unrecognized boolean type in input!");
   #endif
   /*output: */
   *pscalar=bscalar;
}

FetchData() [13/17]

void FetchData	(	BamgGeom **	bamggeom,
		PyObject *	py_dict
	)

Definition at line 1026 of file FetchPythonData.cpp.

                                                      {
 
   /*Initialize output*/
   BamgGeom* bamggeom=new BamgGeom();
 
   /*Fetch all fields*/
   FetchData(&bamggeom->Vertices,&bamggeom->VerticesSize[0],&bamggeom->VerticesSize[1],PyDict_GetItemString(py_dict,"Vertices"));
   FetchData(&bamggeom->Edges, &bamggeom->EdgesSize[0], &bamggeom->EdgesSize[1], PyDict_GetItemString(py_dict,"Edges"));
   FetchData(&bamggeom->Corners, &bamggeom->CornersSize[0], &bamggeom->CornersSize[1], PyDict_GetItemString(py_dict,"Corners"));
   FetchData(&bamggeom->RequiredVertices,&bamggeom->RequiredVerticesSize[0],&bamggeom->RequiredVerticesSize[1],PyDict_GetItemString(py_dict,"RequiredVertices"));
   FetchData(&bamggeom->RequiredEdges, &bamggeom->RequiredEdgesSize[0], &bamggeom->RequiredEdgesSize[1], PyDict_GetItemString(py_dict,"RequiredEdges"));
   FetchData(&bamggeom->CrackedEdges,&bamggeom->CrackedEdgesSize[0],&bamggeom->CrackedEdgesSize[1],PyDict_GetItemString(py_dict,"CrackedEdges"));
   FetchData(&bamggeom->SubDomains,&bamggeom->SubDomainsSize[0],&bamggeom->SubDomainsSize[1],PyDict_GetItemString(py_dict,"SubDomains"));
 
   /*Assign output pointers:*/
   *pbamggeom=bamggeom;
}

FetchData() [14/17]

void FetchData	(	BamgMesh **	bamgmesh,
		PyObject *	py_dict
	)

Definition at line 1045 of file FetchPythonData.cpp.

                                                      {
 
   /*Initialize output*/
   BamgMesh* bamgmesh=new BamgMesh();
 
   /*Fetch all fields*/
   FetchData(&bamgmesh->Vertices,&bamgmesh->VerticesSize[0],&bamgmesh->VerticesSize[1],PyDict_GetItemString(py_dict,"Vertices"));
   FetchData(&bamgmesh->Edges, &bamgmesh->EdgesSize[0], &bamgmesh->EdgesSize[1], PyDict_GetItemString(py_dict,"Edges"));
   FetchData(&bamgmesh->Triangles, &bamgmesh->TrianglesSize[0], &bamgmesh->TrianglesSize[1], PyDict_GetItemString(py_dict,"Triangles"));
   FetchData(&bamgmesh->CrackedEdges,&bamgmesh->CrackedEdgesSize[0],&bamgmesh->CrackedEdgesSize[1],PyDict_GetItemString(py_dict,"CrackedEdges"));
   FetchData(&bamgmesh->VerticesOnGeomEdge,&bamgmesh->VerticesOnGeomEdgeSize[0],&bamgmesh->VerticesOnGeomEdgeSize[1],PyDict_GetItemString(py_dict,"VerticesOnGeomEdge"));
   FetchData(&bamgmesh->VerticesOnGeomVertex,&bamgmesh->VerticesOnGeomVertexSize[0],&bamgmesh->VerticesOnGeomVertexSize[1],PyDict_GetItemString(py_dict,"VerticesOnGeomVertex"));
   FetchData(&bamgmesh->EdgesOnGeomEdge, &bamgmesh->EdgesOnGeomEdgeSize[0], &bamgmesh->EdgesOnGeomEdgeSize[1], PyDict_GetItemString(py_dict,"EdgesOnGeomEdge"));
   FetchData(&bamgmesh->IssmSegments,&bamgmesh->IssmSegmentsSize[0],&bamgmesh->IssmSegmentsSize[1],PyDict_GetItemString(py_dict,"IssmSegments"));
 
   /*Assign output pointers:*/
   *pbamgmesh=bamgmesh;
}

FetchData() [15/17]

void FetchData	(	BamgOpts **	bamgopts,
		PyObject *	py_dict
	)

Definition at line 1065 of file FetchPythonData.cpp.

                                                      {
 
   /*Initialize output*/
   BamgOpts* bamgopts=new BamgOpts();
 
   /*Fetch all fields*/
   FetchData(&bamgopts->anisomax,PyDict_GetItemString(py_dict,"anisomax"));
   FetchData(&bamgopts->cutoff,PyDict_GetItemString(py_dict,"cutoff"));
   FetchData(&bamgopts->coeff,PyDict_GetItemString(py_dict,"coeff"));
   FetchData(&bamgopts->errg,PyDict_GetItemString(py_dict,"errg"));
   FetchData(&bamgopts->gradation,PyDict_GetItemString(py_dict,"gradation"));
   FetchData(&bamgopts->Hessiantype,PyDict_GetItemString(py_dict,"Hessiantype"));
   FetchData(&bamgopts->maxnbv,PyDict_GetItemString(py_dict,"maxnbv"));
   FetchData(&bamgopts->maxsubdiv,PyDict_GetItemString(py_dict,"maxsubdiv"));
   FetchData(&bamgopts->Metrictype,PyDict_GetItemString(py_dict,"Metrictype"));
   FetchData(&bamgopts->nbjacobi,PyDict_GetItemString(py_dict,"nbjacobi"));
   FetchData(&bamgopts->nbsmooth,PyDict_GetItemString(py_dict,"nbsmooth"));
   FetchData(&bamgopts->omega,PyDict_GetItemString(py_dict,"omega"));
   FetchData(&bamgopts->power,PyDict_GetItemString(py_dict,"power"));
   FetchData(&bamgopts->verbose,PyDict_GetItemString(py_dict,"verbose"));
 
   FetchData(&bamgopts->Crack,PyDict_GetItemString(py_dict,"Crack"));
   FetchData(&bamgopts->KeepVertices,PyDict_GetItemString(py_dict,"KeepVertices"));
   FetchData(&bamgopts->splitcorners,PyDict_GetItemString(py_dict,"splitcorners"));
 
   FetchData(&bamgopts->hmin,PyDict_GetItemString(py_dict,"hmin"));
   FetchData(&bamgopts->hmax,PyDict_GetItemString(py_dict,"hmax"));
   FetchData(&bamgopts->hminVertices,&bamgopts->hminVerticesSize[0],&bamgopts->hminVerticesSize[1],PyDict_GetItemString(py_dict,"hminVertices"));
   FetchData(&bamgopts->hmaxVertices,&bamgopts->hmaxVerticesSize[0],&bamgopts->hmaxVerticesSize[1],PyDict_GetItemString(py_dict,"hmaxVertices"));
   FetchData(&bamgopts->hVertices,&bamgopts->hVerticesLength,PyDict_GetItemString(py_dict,"hVertices"));
   FetchData(&bamgopts->metric,&bamgopts->metricSize[0],&bamgopts->metricSize[1],PyDict_GetItemString(py_dict,"metric"));
   FetchData(&bamgopts->field,&bamgopts->fieldSize[0],&bamgopts->fieldSize[1],PyDict_GetItemString(py_dict,"field"));
   FetchData(&bamgopts->err,&bamgopts->errSize[0],&bamgopts->errSize[1],PyDict_GetItemString(py_dict,"err"));
 
   /*Additional checks*/
   bamgopts->Check();
 
   /*Assign output pointers:*/
   *pbamgopts=bamgopts;
}

FetchData() [16/17]

void FetchData	(	Options **	poptions,
		int	istart,
		int	nrhs,
		PyObject *	py_tuple
	)

Definition at line 1107 of file FetchPythonData.cpp.

                                                                          {
 
   char   *name   = NULL;
   Option *option = NULL;
 
   /*Initialize output*/
   Options* options=new Options();
 
   /*Fetch all options*/
   for (int i=istart; i<nrhs; i=i+2){
      #if _PYTHON_MAJOR_ >= 3
      if (!PyUnicode_Check(PyTuple_GetItem(py_tuple,(Py_ssize_t)i))) _error_("Argument " << i+1 << " must be name of option");
      #else
      if (!PyString_Check(PyTuple_GetItem(py_tuple,(Py_ssize_t)i))) _error_("Argument " << i+1 << " must be name of option");
      #endif
 
      FetchData(&name,PyTuple_GetItem(py_tuple,(Py_ssize_t)i));
      if(i+1 == nrhs) _error_("Argument " << i+2 << " must exist and be value of option \"" << name << "\".");
 
      _printf0_("FetchData for Options not implemented yet, ignoring option \"" << name << "\"!\n");
 
//    option=(Option*)OptionParse(name,&PyTuple_GetItem(py_tuple,(Py_ssize_t)(i+1)));
//    options->AddOption(option);
//    option=NULL;
   }
 
   /*Assign output pointers:*/
   *poptions=options;
}

FetchData() [17/17]

void FetchData	(	Contours **	pcontours,
		PyObject *	py_list
	)

Definition at line 1138 of file FetchPythonData.cpp.

                                                      {
 
   int              numcontours,test1,test2;
   char            *contourname = NULL;
   Contours         *contours    = NULL;
   Contour<double> *contouri    = NULL;
   PyObject        *py_dicti    = NULL;
   PyObject        *py_item     = NULL;
 
   #if _PYTHON_MAJOR_ >= 3
   if (PyUnicode_Check(py_list)){
   #else
   if (PyString_Check(py_list)){
   #endif
      FetchData(&contourname,py_list);
      contours=ExpRead<double>(contourname);
   }
   else if(PyList_Check(py_list)){
 
      contours=new Contours();
      numcontours=(int)PyList_Size(py_list);
 
      for(int i=0;i<numcontours;i++){
 
         contouri=new Contour<double>();
         py_dicti=PyList_GetItem(py_list,(Py_ssize_t)i);
 
         py_item = PyDict_GetItemString(py_dicti,"nods");
         if(!py_item) _error_("input structure does not have a 'nods' field");
         FetchData(&contouri->nods,py_item);
 
         py_item = PyDict_GetItemString(py_dicti,"x");
         if(!py_item) _error_("input structure does not have a 'x' field");
         FetchData(&contouri->x,&test1,&test2,py_item);
         if(test1!=contouri->nods || test2!=1) _error_("field x should be of size ["<<contouri->nods<<" 1]");
 
         py_item = PyDict_GetItemString(py_dicti,"y");
         if(!py_item) _error_("input structure does not have a 'y' field");
         FetchData(&contouri->y,&test1,&test2,py_item);
         if(test1!=contouri->nods || test2!=1) _error_("field y should be of size ["<<contouri->nods<<" 1]");
 
         contours->AddObject(contouri);
      }
   }
   else{
      _error_("Contour is neither a string nor a structure and cannot be loaded");
   }
 
   /*clean-up and assign output pointer*/
   xDelete<char>(contourname);
   *pcontours=contours;
}

FetchChacoData()

void FetchChacoData	(	int *	pnvtxs,
		int **	padjacency,
		int **	pstart,
		float **	pewgts,
		PyObject *	A_IN,
		PyObject *	EWGTS_IN
	)

Definition at line 1191 of file FetchPythonData.cpp.

                                                                                                                {/*{{{*/
 
   double* a = ((double*)PyArray_DATA((PyArrayObject*)A_IN));
   int ndim  = PyArray_NDIM((PyArrayObject*)A_IN);
   int nzmax = PyArray_CountNonzero((PyArrayObject*)A_IN);
 
   /*Fetch adjacency matrix:*/
   int      nvtxs       = PyArray_DIMS((PyArrayObject*)A_IN)[1];
 
   int* mwstart = xNewZeroInit<int>(nvtxs+1);
   pyGetJc(a,nvtxs,mwstart);
 
   int* mwadjacency = xNewZeroInit<int>(nzmax);
   pyGetIr(a,nvtxs,nzmax,mwadjacency);
 
   int* start = xNew<int>(nvtxs+1);
   for(int i=0;i<nvtxs+1;i++) start[i]=(int)mwstart[i];
   int* adjacency = xNew<int>(nzmax);
   for(int i=0; i<nzmax; i++) adjacency[i]=(int)mwadjacency[i];
 
   /*Get edges weights*/
   int nedges = start[nvtxs];
   float* ewgts = NULL;
   int size = PyArray_SIZE((PyArrayObject*)EWGTS_IN);
   //size may be 1 and still be empty;
   //presumably size of edge_weights input will never be exactly 1
   if(size != 1 && size != 0){
      ewgts = xNewZeroInit<float>(nedges);
      for(int i = 0; i<nedges;i++){
         ewgts[i] = (float)a[i];
      }
   }
 
   /*Assign output pointers*/
   *pnvtxs     = nvtxs;
   *padjacency = adjacency;
   *pstart     = start;
   *pewgts     = ewgts;
}

pyGetJc()

void pyGetJc	(	double *	a,
		int	nvtxs,
		int *	Jc
	)

Definition at line 1232 of file FetchPythonData.cpp.

                                           {
/*{{{*/
   //get the number of non-zero elements in each row, adding to the prior number;
   //always starts with 0 and has length: number_of_rows_in(a)+1 == nvtxs+1
   // eg: 0, 1, 3, 6, 8, 13, ...
   // for: 1 in the first row, 2 in the second, 3 in the third, etc.
   int c = 0;
   Jc[c++] = 0;
 
   for(int i=0;i<nvtxs;i++){
      for(int j=0;j<nvtxs;j++){
         if ((int)a[i+(j*nvtxs)] != 0){
            Jc[c] += 1;
         }
      }
      c++;
      Jc[c] = Jc[c-1];
   }
   return;
}

pyGetIr()

void pyGetIr	(	double *	a,
		int	nvtxs,
		int	nzmax,
		int *	Ir
	)

Definition at line 1254 of file FetchPythonData.cpp.

                                                      {
/*{{{*/
   //get the row-wise position of each non-zero element;
   //has length: number_of_non_zero_elements_in(a) == nzmax
   // eg: 10, 24, 25, 4, ...
   // the 10th, 24th, and 25th elements in the first row, the 4th in the second row
   // using pyGetJc to determine which indices correspond to which row
   int r = 0;
 
   for(int i=0;i<nvtxs;i++){
      for(int j=0;j<nvtxs;j++){
         if ((int)a[i+(j*nvtxs)] != 0){
            Ir[r] = j;
            r++;
         }
      }
   }
   return;
}

CheckNumPythonArguments()

int CheckNumPythonArguments	(	PyObject *	inputs,
		int	NRHS,
		void(*)(void)	function
	)

Definition at line 11 of file CheckNumPythonArguments.cpp.

                                                                                {
 
   Py_ssize_t size=0;
 
   /*figure out size of tuple in input: */
   size=PyTuple_Size(inputs);
 
   /*check on requested size: */
   if (size==0){
      function();
      _error_("usage: see above");
   }
   else if (size!=NRHS ) {
      function(); 
      _error_("usage error.");
   }
   return 1;
}

PyArrayFromCopiedData() [1/4]

PyObject* PyArrayFromCopiedData	(	int	dims[2],
		double *	data
	)

Definition at line 260 of file WritePythonData.cpp.

                                                         {
 
   double* pydata;
   npy_intp pydims[2]={0,0};
 
   /*  note that PyArray_SimpleNewFromData does not copy the data, so that when the original
       object (e.g. bamggeom,bamgmesh) is deleted, the data is gone.  */
 
   pydims[0]=(npy_intp)dims[0];
   pydims[1]=(npy_intp)dims[1];
   pydata=xNew<IssmDouble>(dims[0]*dims[1]);
   memcpy(pydata,data,dims[0]*dims[1]*sizeof(double));
   return PyArray_SimpleNewFromData(2,pydims,NPY_DOUBLE,pydata);
}

PyArrayFromCopiedData() [2/4]

PyObject* PyArrayFromCopiedData	(	int	dimi,
		int	dimj,
		double *	data
	)

Definition at line 276 of file WritePythonData.cpp.

                                                               {
 
   double* pydata;
   npy_intp pydims[2]={0,0};
 
   /*  note that PyArray_SimpleNewFromData does not copy the data, so that when the original
       object (e.g. bamggeom,bamgmesh) is deleted, the data is gone.  */
 
   pydims[0]=(npy_intp)dimi;
   pydims[1]=(npy_intp)dimj;
   pydata=xNew<IssmDouble>(dimi*dimj);
   memcpy(pydata,data,dimi*dimj*sizeof(double));
   return PyArray_SimpleNewFromData(2,pydims,NPY_DOUBLE,pydata);
}

PyArrayFromCopiedData() [3/4]

PyObject* PyArrayFromCopiedData	(	int	dimi,
		int	dimj,
		int *	data
	)

Definition at line 292 of file WritePythonData.cpp.

                                                            {
 
   long* pydata;
   npy_intp pydims[2]={0,0};
 
   /*  note that PyArray_SimpleNewFromData does not copy the data, so that when the original
       object (e.g. bamggeom,bamgmesh) is deleted, the data is gone.  */
 
   pydims[0]=(npy_intp)dimi;
   pydims[1]=(npy_intp)dimj;
   pydata=xNew<long>(dimi*dimj);
   for(int i=0;i<dimi*dimj;i++) pydata[i]=(long)data[i];
   return PyArray_SimpleNewFromData(2,pydims,NPY_INT64,pydata);
}

PyArrayFromCopiedData() [4/4]

PyObject* PyArrayFromCopiedData	(	int	dimi,
		int	dimj,
		bool *	data
	)

Definition at line 308 of file WritePythonData.cpp.

                                                             {
 
   bool* pydata;
   npy_intp pydims[2]={0,0};
 
   /*  note that PyArray_SimpleNewFromData does not copy the data, so that when the original
       object (e.g. bamggeom,bamgmesh) is deleted, the data is gone.  */
 
   pydims[0]=(npy_intp)dimi;
   pydims[1]=(npy_intp)dimj;
   pydata=xNew<bool>(dimi*dimj);
   memcpy(pydata,data,dimi*dimj*sizeof(bool));
   return PyArray_SimpleNewFromData(2,pydims,NPY_BOOL,pydata);
}

ApiPrintf()

void ApiPrintf

(

const char *

string

)

Definition at line 13 of file ApiPrintf.cpp.

                                  {
   printf("%s",string);
}