ghmmwrapper_wrap.c

General Hidden Markov Model Library 一个通用的隐马尔科夫模型的C代码库

	obj = Py_None;
      }
      break;
    case SWIG_PY_POINTER:
      obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
      break;
    case SWIG_PY_BINARY:
      obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
      break;
    default:
      obj = 0;
      break;
    }
    if (obj) {
      PyDict_SetItemString(d,constants[i].name,obj);
      Py_DECREF(obj);
    }
  }
}

/* Fix SwigMethods to carry the callback ptrs when needed */
static void
SWIG_Python_FixMethods(PyMethodDef *methods,
		       swig_const_info *const_table,
		       swig_type_info **types,
		       swig_type_info **types_initial) {
  int i;
  for (i = 0; methods[i].ml_name; ++i) {
    char *c = methods[i].ml_doc;
    if (c && (c = strstr(c, "swig_ptr: "))) {
      int j;
      swig_const_info *ci = 0;
      char *name = c + 10;
      for (j = 0; const_table[j].type; j++) {
	if (strncmp(const_table[j].name, name, 
		    strlen(const_table[j].name)) == 0) {
	  ci = &(const_table[j]);
	  break;
	}
      }
      if (ci) {
	size_t shift = (ci->ptype) - types;
	swig_type_info *ty = types_initial[shift];
	size_t ldoc = (c - methods[i].ml_doc);
	size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
	char *ndoc = (char*)malloc(ldoc + lptr + 10);
	char *buff = ndoc;
	void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
	strncpy(buff, methods[i].ml_doc, ldoc);
	buff += ldoc;
	strncpy(buff, "swig_ptr: ", 10);
	buff += 10;
	SWIG_Python_PointerStr(buff, ptr, ty->name, lptr);
	methods[i].ml_doc = ndoc;
      }
    }
  }
}


/* -----------------------------------------------------------------------------
 * Lookup type pointer 
 * ----------------------------------------------------------------------------- */
#if PY_MAJOR_VERSION < 2
/* PyModule_AddObject function was introduced in Python 2.0.  The following function
is copied out of Python/modsupport.c in python version 2.3.4 */
static int
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
{
	PyObject *dict;
	if (!PyModule_Check(m)) {
		PyErr_SetString(PyExc_TypeError,
			    "PyModule_AddObject() needs module as first arg");
		return -1;
	}
	if (!o) {
		PyErr_SetString(PyExc_TypeError,
				"PyModule_AddObject() needs non-NULL value");
		return -1;
	}

	dict = PyModule_GetDict(m);
	if (dict == NULL) {
		/* Internal error -- modules must have a dict! */
		PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
			     PyModule_GetName(m));
		return -1;
	}
	if (PyDict_SetItemString(dict, name, o))
		return -1;
	Py_DECREF(o);
	return 0;
}
#endif
static PyMethodDef swig_empty_runtime_method_table[] = {
    {NULL, NULL, 0, NULL}        /* Sentinel */
};

static void
SWIG_Python_LookupTypePointer(swig_type_info ***type_list_handle) {
  PyObject *module, *pointer;
  void *type_pointer;

  /* first check if module already created */
  type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
  if (type_pointer) {
    *type_list_handle = (swig_type_info **) type_pointer;
  } else {
    PyErr_Clear();
    /* create a new module and variable */
    module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
    pointer = PyCObject_FromVoidPtr((void *) (*type_list_handle), NULL);
    if (pointer && module) {
      PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
    }
  }
}

#ifdef __cplusplus
}
#endif


/* -------- TYPES TABLE (BEGIN) -------- */

#define  SWIGTYPE_p_state swig_types[0] 
#define  SWIGTYPE_p_f_p_q_const__int_int__int swig_types[1] 
#define  SWIGTYPE_p_p_char swig_types[2] 
#define  SWIGTYPE_p_char swig_types[3] 
#define  SWIGTYPE_p_p_sdmodel swig_types[4] 
#define  SWIGTYPE_p_sdmodel swig_types[5] 
#define  SWIGTYPE_p_p_double swig_types[6] 
#define  SWIGTYPE_p_p_p_double swig_types[7] 
#define  SWIGTYPE_p_double swig_types[8] 
#define  SWIGTYPE_size_t swig_types[9] 
#define  SWIGTYPE_p_p_smodel swig_types[10] 
#define  SWIGTYPE_p_smodel swig_types[11] 
#define  SWIGTYPE_p_density_t swig_types[12] 
#define  SWIGTYPE_p_long swig_types[13] 
#define  SWIGTYPE_p_sdstate swig_types[14] 
#define  SWIGTYPE_p_sstate swig_types[15] 
#define  SWIGTYPE_p_gsl_rng swig_types[16] 
#define  SWIGTYPE_p_background_distributions swig_types[17] 
#define  SWIGTYPE_ptrdiff_t swig_types[18] 
#define  SWIGTYPE_p_scanner_t swig_types[19] 
#define  SWIGTYPE_p_smosqd_t swig_types[20] 
#define  SWIGTYPE_p_FILE swig_types[21] 
#define  SWIGTYPE_p_p_model swig_types[22] 
#define  SWIGTYPE_p_model swig_types[23] 
#define  SWIGTYPE_p_scluster_t swig_types[24] 
#define  SWIGTYPE_p_p_sequence_t swig_types[25] 
#define  SWIGTYPE_p_sequence_t swig_types[26] 
#define  SWIGTYPE_p_p_p_sequence_t swig_types[27] 
#define  SWIGTYPE_p_p_int swig_types[28] 
#define  SWIGTYPE_p_p_p_int swig_types[29] 
#define  SWIGTYPE_p_int swig_types[30] 
#define  SWIGTYPE_p_p_sequence_d_t swig_types[31] 
#define  SWIGTYPE_p_p_p_sequence_d_t swig_types[32] 
#define  SWIGTYPE_p_sequence_d_t swig_types[33] 
static swig_type_info *swig_types[35];

/* -------- TYPES TABLE (END) -------- */


/*-----------------------------------------------
              @(target):= _ghmmwrapper.so
  ------------------------------------------------*/
#define SWIG_init    init_ghmmwrapper

#define SWIG_name    "_ghmmwrapper"

#include <stdio.h>
#include <ghmm/ghmm.h>
#include <ghmm/vector.h>
#include <ghmm/sequence.h>
#include <ghmm/scanner.h>
#include <ghmm/smodel.h>
#include <ghmm/rng.h>
#include <ghmm/reestimate.h>
#include <ghmm/foba.h>
#include <ghmm/scluster.h>
#include <ghmm/mes.h>
#include <ghmm/gradescent.h>
#include <ghmm/kbest.h>
#include "sdclass_change.h"


#include <stdlib.h>


#define  SWIG_MemoryError    1
#define  SWIG_IOError        2
#define  SWIG_RuntimeError   3
#define  SWIG_IndexError     4
#define  SWIG_TypeError      5
#define  SWIG_DivisionByZero 6
#define  SWIG_OverflowError  7
#define  SWIG_SyntaxError    8
#define  SWIG_ValueError     9
#define  SWIG_SystemError   10
#define  SWIG_UnknownError  99


static void SWIG_exception_(int code, const char *msg) {
  switch(code) {
  case SWIG_MemoryError:
    PyErr_SetString(PyExc_MemoryError,msg);
    break;
  case SWIG_IOError:
    PyErr_SetString(PyExc_IOError,msg);
    break;
  case SWIG_RuntimeError:
    PyErr_SetString(PyExc_RuntimeError,msg);
    break;
  case SWIG_IndexError:
    PyErr_SetString(PyExc_IndexError,msg);
    break;
  case SWIG_TypeError:
    PyErr_SetString(PyExc_TypeError,msg);
    break;
  case SWIG_DivisionByZero:
    PyErr_SetString(PyExc_ZeroDivisionError,msg);
    break;
  case SWIG_OverflowError:
    PyErr_SetString(PyExc_OverflowError,msg);
    break;
  case SWIG_SyntaxError:
    PyErr_SetString(PyExc_SyntaxError,msg);
    break;
  case SWIG_ValueError:
    PyErr_SetString(PyExc_ValueError,msg);
    break;
  case SWIG_SystemError:
    PyErr_SetString(PyExc_SystemError,msg);
    break;
  default:
    PyErr_SetString(PyExc_RuntimeError,msg);
    break;
  }
}

#define SWIG_exception(a,b) { SWIG_exception_(a,b); SWIG_fail; }

extern gsl_rng *RNG;
void gsl_rng_init(void);
void gsl_rng_timeseed(gsl_rng *);

	void time_seed(){
		gsl_rng_timeseed(RNG);
	}

double **matrix_d_alloc(int,int);

#include <limits.h>


SWIGINTERN int
  SWIG_CheckLongInRange(long value, long min_value, long max_value,
			const char *errmsg)
{
  if (value < min_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError, 
		   "value %ld is less than '%s' minimum %ld", 
		   value, errmsg, min_value);
    }
    return 0;    
  } else if (value > max_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError,
		   "value %ld is greater than '%s' maximum %ld", 
		   value, errmsg, max_value);
    }
    return 0;
  }
  return 1;
}


SWIGINTERN int
  SWIG_AsVal_long(PyObject * obj, long* val)
{
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AS_LONG(obj);
    return 1;
  }
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return 1;
    } else {
      if (!val) PyErr_Clear();
      return 0;
    }
  }
  if (val) {
    SWIG_type_error("long", obj);
  }
  return 0;
 }


#if INT_MAX != LONG_MAX
SWIGINTERN int
  SWIG_AsVal_int(PyObject *obj, int *val)
{ 
  const char* errmsg = val ? "int" : (char*)0;
  long v;
  if (SWIG_AsVal_long(obj, &v)) {
    if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
      if (val) *val = (int)(v);
      return 1;
    } else {
      return 0;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;    
}
#else
SWIGINTERNSHORT int
  SWIG_AsVal_int(PyObject *obj, int *val)
{
  return SWIG_AsVal_long(obj,(long*)val);
}
#endif


SWIGINTERNSHORT int
SWIG_As_int(PyObject* obj)
{
  int v;
  if (!SWIG_AsVal_int(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(int));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_int(PyObject* obj)
{
  return SWIG_AsVal_int(obj, (int*)0);
}

double **matrix_d_alloc_copy(int,int,double **);
int matrix_d_free(double ***,int);

  /*@D:\\PROGRAM FILES\\SWIG\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
#define SWIG_From_int PyInt_FromLong
/*@@*/

int **matrix_i_alloc(int,int);
int matrix_i_free(int ***,long);

SWIGINTERNSHORT long
SWIG_As_long(PyObject* obj)
{
  long v;
  if (!SWIG_AsVal_long(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(long));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_long(PyObject* obj)
{
  return SWIG_AsVal_long(obj, (long*)0);
}

void matrix_d_print(FILE *,double **,int,int,char *,char *,char *);

/* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
{
  static swig_type_info* pchar_info = 0;
  char* vptr = 0;
  if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
  if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
    if (cptr) *cptr = vptr;
    if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
    return SWIG_OLDOBJ;
  } else {
    PyErr_Clear();
    if (PyString_Check(obj)) {
      if (cptr) {
	*cptr = PyString_AS_STRING(obj);
	if (psize) {
	  *psize = PyString_GET_SIZE(obj) + 1;
	}
      }
      return SWIG_PYSTR;
    }
  }
  if (cptr) {
    SWIG_type_error("char *", obj);
  }
  return 0;
}


SWIGINTERNSHORT int
SWIG_AsCharPtr(PyObject *obj, char **val)
{
  char* cptr = 0;
  if (SWIG_AsCharPtrAndSize(obj, &cptr, (size_t*)(0))) {
    if (val) *val = cptr;
    return 1;
  }
  if (val) {
    SWIG_type_error("char *", obj);
  }
  return 0;
}


  /*@D:\\PROGRAM FILES\\SWIG\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
#define SWIG_From_long PyInt_FromLong
/*@@*/


SWIGINTERN int
  SWIG_AsVal_double(PyObject *obj, double *val)
{
  if (PyFloat_Check(obj)) {
    if (val) *val = PyFloat_AS_DOUBLE(obj);
    return 1;
  }  
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AS_LONG(obj);
    return 1;
  }
  if (PyLong_Check(obj)) {
    double v = PyLong_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return 1;
    } else {
      if (!val) PyErr_Clear();
      return 0;
    }
  }
  if (val) {
    SWIG_type_error("double", obj);
  }
  return 0;
}


SWIGINTERNSHORT double
SWIG_As_double(PyObject* obj)
{
  double v;