svmc_wrap.c

LIBSVM is an integrated software for support vector classification. LIBSVM provides a simple interfa

      if (_t) {
	if (strcmp(_t,_c)) { 
	  if (!SwigPtrSort) {
	    qsort((void *) SwigPtrTable, SwigPtrN, sizeof(SwigPtrType), swigsort); 
	    for (i = 0; i < 256; i++) {
	      SwigStart[i] = SwigPtrN;
	    }
	    for (i = SwigPtrN-1; i >= 0; i--) {
	      SwigStart[(int) (SwigPtrTable[i].name[1])] = i;
	    }
	    for (i = 255; i >= 1; i--) {
	      if (SwigStart[i-1] > SwigStart[i])
		SwigStart[i-1] = SwigStart[i];
	    }
	    SwigPtrSort = 1;
	    for (i = 0; i < SWIG_CACHESIZE; i++)  
	      SwigCache[i].stat = 0;
	  }
	  
	  /* First check cache for matches.  Uses last cache value as starting point */
	  cache = &SwigCache[SwigLastCache];
	  for (i = 0; i < SWIG_CACHESIZE; i++) {
	    if (cache->stat) {
	      if (strcmp(_t,cache->name) == 0) {
		if (strcmp(_c,cache->mapped) == 0) {
		  cache->stat++;
		  *ptr = (void *) _p;
		  if (cache->tp->cast) *ptr = (*(cache->tp->cast))(*ptr);
		  return (char *) 0;
		}
	      }
	    }
	    SwigLastCache = (SwigLastCache+1) & SWIG_CACHEMASK;
	    if (!SwigLastCache) cache = SwigCache;
	    else cache++;
	  }
	  /* We have a type mismatch.  Will have to look through our type
	     mapping table to figure out whether or not we can accept this datatype */

	  start = SwigStart[(int) _t[1]];
	  end = SwigStart[(int) _t[1]+1];
	  sp = &SwigPtrTable[start];
	  while (start < end) {
	    if (swigcmp(_t,sp) == 0) break;
	    sp++;
	    start++;
	  }
	  if (start >= end) sp = 0;
	  /* Try to find a match for this */
	  if (sp) {
	    while (swigcmp(_t,sp) == 0) {
	      name = sp->name;
	      len = sp->len;
	      tp = sp->next;
	      /* Try to find entry for our given datatype */
	      while(tp) {
		if (tp->len >= 255) {
		  return _c;
		}
		strcpy(temp_type,tp->name);
		strncat(temp_type,_t+len,255-tp->len);
		if (strcmp(_c,temp_type) == 0) {
		  
		  strcpy(SwigCache[SwigCacheIndex].mapped,_c);
		  strcpy(SwigCache[SwigCacheIndex].name,_t);
		  SwigCache[SwigCacheIndex].stat = 1;
		  SwigCache[SwigCacheIndex].tp = tp;
		  SwigCacheIndex = SwigCacheIndex & SWIG_CACHEMASK;
		  
		  /* Get pointer value */
		  *ptr = (void *) _p;
		  if (tp->cast) *ptr = (*(tp->cast))(*ptr);
		  return (char *) 0;
		}
		tp = tp->next;
	      }
	      sp++;
	      /* Hmmm. Didn't find it this time */
	    }
	  }
	  /* Didn't find any sort of match for this data.  
	     Get the pointer value and return the received type */
	  *ptr = (void *) _p;
	  return _c;
	} else {
	  /* Found a match on the first try.  Return pointer value */
	  *ptr = (void *) _p;
	  return (char *) 0;
	}
      } else {
	/* No type specified.  Good luck */
	*ptr = (void *) _p;
	return (char *) 0;
      }
  } else {
    if (strcmp (_c, "NULL") == 0) {
	*ptr = (void *) 0;
	return (char *) 0;
    }
    *ptr = (void *) 0;	
    return _c;
  }
}

/* Compatibility mode */

#define _swig_get_hex  SWIG_GetPtr

#define SWIG_init    initsvmc

#define SWIG_name    "svmc"

#include "svm.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, 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); return NULL

#include <limits.h>

/* Create a new integer array */

  static int *int_array(int size) {
#ifdef __cplusplus
    return new int[size];
#else
    return (int *) malloc(size*sizeof(int));
#endif
  }

  /* Destroy an integer array */

  static void int_destroy(int *array) {
    if (array) {
#ifdef __cplusplus
      delete array;
#else
      free(array);
#endif
    }
  }

  /* Return an element */

  static int int_get(int *array, int index) {
    if (array) {
      return array[index];
    } else {
      return INT_MIN;
    }
  }
   
  /* Set an element */
  
  static int int_set(int *array, int index, int value) {
    if (array) {
      return (array[index] = value);
    } else {
      return INT_MIN;
    }
  }


  #include <float.h>

  /* Create a new float array */

  static float *float_array(int size) {
#ifdef __cplusplus
    return new float[size];
#else
    return (float *) malloc(size*sizeof(float));
#endif
  }

  /* Destroy an array */

  static void float_destroy(float *array) {
    if (array) {
#ifdef __cplusplus
      delete array;
#else
      free(array);
#endif
    }
  }

  /* Return an element */

  static float float_get(float *array, int index) {
    if (array) {
      return array[index];
    } else {
      return FLT_MIN;
    }
  }
   
  /* Set an element */
  
  static float float_set(float *array, int index, float value) {
    if (array) {
      return (array[index] = value);
    } else {
      return FLT_MIN;
    }
  }

  /* Create a new double array */

  static double *double_array(int size) {
#ifdef __cplusplus
    return new double[size];
#else
    return (double *) malloc(size*sizeof(double));
#endif
  }

  /* Destroy an array */

  static void double_destroy(double *array) {
    if (array) {
#ifdef __cplusplus
      delete array;
#else
      free(array);
#endif
    }
  }

  /* Return an element */

  static double double_get(double *array, int index) {
    if (array) {
      return array[index];
    } else {
      return FLT_MIN;
    }
  }
   
  /* Set an element */
  
  static double double_set(double *array, int index, double value) {
    if (array) {
      return (array[index] = value);
    } else {
      return FLT_MIN;
    }
  }


/* Create character string arrays */

static char **string_array(int size) {
  char **a;
  int i;
#ifdef __cplusplus
  a = new char *[size];
#else
  a = (char **) malloc(size*sizeof(char *));
#endif
  for (i = 0; i < size; i++)
    a[i] = 0;
  return a;
}

/* Destroy a string array */

static void string_destroy(char **array) {
  int i = 0;
  if (array) {
      while (array[i]) {
#ifdef __cplusplus
            delete array[i];
#else
            free(array[i]);
#endif
            i++;
      }          	
#ifdef __cplusplus
     delete array;
#else
     free(array);
#endif
   }      
}

/* Get an element */

static char *string_get(char **array_string, int index) {
  if (array_string) 
    if (array_string[index]) return (array_string[index]);
    else return "";
  else 
    return "";
}

/* Set an element */

static char *string_set(char **array_string, int index, char * val) {
  if (array_string) {
    if (array_string[index]) {
#ifdef __cplusplus
	delete array_string[index];
#else
        free(array_string[index]);
#endif
    }	
    if (strlen(val) > 0) {
#ifdef __cplusplus
      array_string[index] = new char[strlen(val)+1];
#else
      array_string[index] = (char *) malloc(strlen(val)+1);
#endif
      strcpy(array_string[index],val);
      return array_string[index];
    } else {
      array_string[index] = 0;
      return val;
    }
  } else return val;
}


struct svm_node *svm_node_array(int size)
{
	return (struct svm_node *)malloc(sizeof(struct svm_node)*size);
}

void svm_node_array_set(struct svm_node *array, int i, int index, double value)
{
	array[i].index = index;
	array[i].value = value;
}

void svm_node_array_destroy(struct svm_node *array)
{
	free(array);
}

struct svm_node **svm_node_matrix(int size)
{
	return (struct svm_node **)malloc(sizeof(struct svm_node *)*size);	
}

void svm_node_matrix_set(struct svm_node **matrix, int i, struct svm_node* array)
{
	matrix[i] = array;
}

void svm_node_matrix_destroy(struct svm_node **matrix)
{
	free(matrix);
}

static PyObject *_wrap_svm_train(PyObject *self, PyObject *args) {
    PyObject * _resultobj;
    struct svm_model * _result;
    struct svm_problem * _arg0;
    struct svm_parameter * _arg1;
    char * _argc0 = 0;
    char * _argc1 = 0;
    char _ptemp[128];

    self = self;
    if(!PyArg_ParseTuple(args,"ss:svm_train",&_argc0,&_argc1)) 
        return NULL;
    if (_argc0) {
        if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_struct_svm_problem_p")) {
            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of svm_train. Expected _struct_svm_problem_p.");
        return NULL;
        }
    }
    if (_argc1) {
        if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_struct_svm_parameter_p")) {
            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of svm_train. Expected _struct_svm_parameter_p.");
        return NULL;
        }
    }
    _result = (struct svm_model *)svm_train(_arg0,_arg1);
    SWIG_MakePtr(_ptemp, (char *) _result,"_struct_svm_model_p");
    _resultobj = Py_BuildValue("s",_ptemp);
    return _resultobj;
}

static PyObject *_wrap_svm_save_model(PyObject *self, PyObject *args) {
    PyObject * _resultobj;
    int  _result;
    char * _arg0;
    struct svm_model * _arg1;
    char * _argc1 = 0;

    self = self;
    if(!PyArg_ParseTuple(args,"ss:svm_save_model",&_arg0,&_argc1))