ghmmwrapper.i

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

/* author       : Wasinee Rungsarityotin and Benjamin Georgi
 *  filename    : ghmmwrapper/ghmmwrapper.i
 *  created      : DATE: September, 2003
 *
 * $Id: ghmmwrapper.i 1062 2004-12-22 12:59:46Z igcf $
 */

/*
  __copyright__
*/

%module 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 carrays.i
%include cmalloc.i
%include cpointer.i
%include cstring.i
// %pointer_functions(int, intp)

%include constraints.i
%include exception.i    
%include typemaps.i

// Constraints on GHMM date types - no NULL pointers as function arguments
%apply Pointer NONNULL { model * };
%apply Pointer NONNULL { model ** };
%apply Pointer NONNULL { smodel * };
%apply Pointer NONNULL { smodel ** };
%apply Pointer NONNULL { state * };
%apply Pointer NONNULL { sstate * };
%apply Pointer NONNULL { sequence_t * };
%apply Pointer NONNULL { sequence_t ** };
%apply Pointer NONNULL { sequence_d_t * };
%apply Pointer NONNULL { sequence_d_t ** };
%apply Pointer NONNULL { scluster * };
 
// Constraints on general C data types - no NULL pointers as function arguments
// XXX certain arguments are supposed to be NULL
// %apply Pointer NONNULL { int *, double *, int **, double **, void * };


/*=============================================================================================
  =============================== Random Number Generator (RNG) ================================= */

/* The global RNG */
extern gsl_rng * RNG; 

/* Important! initialise rng  */
extern void gsl_rng_init(void);

/* Initialise random timeseed */
extern void gsl_rng_timeseed(gsl_rng * r);

%inline %{
	void time_seed(){
		gsl_rng_timeseed(RNG);
	}
%}
		
/*=============================================================================================
  ================= Utility functions: Matrix allocation and destruction  =====================*/

/*
  Allocation of a double matrix. 
  @return pointer to a matrix
  @param rows: number of rows
  @param columns: number of columns
  */
extern double** matrix_d_alloc(int rows, int columns);

/**
  Copying and allocation of a double matrix.
  @return pointer to a matrix
  @param rows: number of rows
  @param columns: number of columns
  @param copymatrix: matrix to copy 
  */
extern double** matrix_d_alloc_copy(int rows, int columns, double **copymatrix);

/**
  Free the memory of a double matrix.
  @return 0 for succes; -1 for error
  @param  matrix: matrix to free
  @param  rows: number of rows
  */
extern int matrix_d_free(double ***matrix,int row);

/**
  Allocation of a integer matrix.
  @return pointer to a matrix
  @param rows: number of rows
  @param columns: number of columns
  */
extern int** matrix_i_alloc(int rows, int columns);

/**
  Free the memory of a integer matrix.
  @return 0 for succes; -1 for error
  @param  matrix: matrix to free
  @param  rows: number of rows
  */
extern int matrix_i_free(int ***matrix, long rows); 

/**
  Writes a double matrix (without parenthesis).
  @param file:       output file
  @param matrix:     matrix to write
  @param rows:       number of rows
  @param columns:    number of columns
  @param tab:        format: leading tabs
  @param separator:  format: separator for columns
  @param ending:     format: end of a row  
  */
extern void matrix_d_print(FILE *file, double **matrix, int rows, int columns, 
		    char *tab, char *separator, char *ending);



				
/*=============================================================================================
  =============================== sequence.c  ============================================== */
		
		
/**@name sequences  (double and int) */
/*@{ (Doc++-Group: sequence) */
/** @name struct sequence_t
    Sequence structure for integer sequences. 
    Contains an array of sequences and corresponding
    data like sequence label, sequence weight, etc. Sequences may have different
    length.    
 */

struct sequence_t {
  /** sequence array. sequence[i] [j] = j-th symbol of i-th seq.
   */
  int **seq;
  /** matrix of state ids  */
  int **states;
  /** array of sequence length */
  int *seq_len;
  /**  array of sequence labels */
  long *seq_label;
  /**  array of sequence IDs*/
  double *seq_id;
  /** positiv! sequence weights.  default is 1 = no weight */
  double *seq_w;
  /** total number of sequences */
  long seq_number;
  /** sum of sequence weights */
  double total_w;
  
  /* matrix of state labels corresponding to seq */
  int **state_labels; 
  /* number of labels for each sequence */  
  int *state_labels_len;        
};
typedef struct sequence_t sequence_t;

%pointer_functions(sequence_t **, sequence_setPtr)

/** @name struct sequence_d_t
    Sequence structure for double sequences. 
    Contains an array of sequences and corresponding
    data like sequnce label, sequence weight, etc. Sequences may have different
    length.    
 */
struct sequence_d_t {
  /** sequence array. sequence[i] [j] = j-th symbol of i-th seq. */
  double **seq;
  /** array of sequence length */
  int *seq_len;
  /**  array of sequence labels */
  long *seq_label;
  /**  array of sequence IDs*/
  double *seq_id;
  /** positive! sequence weights.  default is 1 = no weight */
  double *seq_w;
  /** total number of sequences */
  long seq_number;
  /** sum of sequence weights */
  double total_w;  
};
typedef struct sequence_d_t sequence_d_t;

%pointer_functions(sequence_d_t **, sequence_d_setPtr)

/**
   Memory allocation for an integer sequence struct. Allocates arrays of lenght
   seq\_number. NO allocation for the actual sequence, since its length is 
   unknown.
   @param seq\_number:  number of sequences
   @return:     pointer of sequence struct
*/
extern sequence_t *sequence_calloc(long seq_number);


/**
   Memory allocation for a double  sequence struct. Allocates arrays of lenght
   seq\_number. NO allocation for the actual sequence, since its length is 
   unknown.
   @param seq\_number:  number of sequences
   @return:     pointer of sequence struct
*/
extern sequence_d_t *sequence_d_calloc(long seq_number);

/**
   Cleans integer sequence pointers in sequence struct. sets 
   seq\_number to zero.
   Differs from sequence\_free since memory is not freed here. 
   @param sq sequence structure
  */
extern void sequence_clean(sequence_t *sq);

/**
   Cleans integer sequence pointers in sequence struct. sets 
   seq\_number to zero.
   Differs from sequence\_free since memory is not freed here. 
   @param sq sequence structure
  */
extern void sequence_d_clean(sequence_d_t *sq);

/**
  Prints one array of integer sequences in a file.
  @param file       output file
  @param sequence    array of sequences
  */
void sequence_print(FILE *file, sequence_t *sequence);


/**
  copy one integer sequence. Memory for target has to be allocated outside.
  @param target  target sequence
  @param source source sequence
  @param len     length of source sequence
  */
void sequence_copy(int *target, int *source, int len);

/**
   Reads one or several arrays of double sequences. 
   Calls sequence\_read\_alloc, where reading
   and memory allocation is done. 
   @return pointer to sequence array
   @param filename    input filename
*/
sequence_d_t **sequence_d_read(const char *filename, int *sqd_number);

/**
  Adds all integer sequences, sequence lengths etc 
  from source to target. Memory allocation is done here.
  @param target target sequence structure
  @param source  source sequence structure
  @return -1 for error, 0 for success
  */
int sequence_add(sequence_t *target, sequence_t *source);

/**
  Adds all double sequences, sequence lengths etc 
  from source to target. Memory allocation is done here.
  @param target target sequence structure
  @param source  source sequence structure
  @return -1 for error, 0 for success
  */
extern int sequence_d_add(sequence_d_t *target, sequence_d_t *source);

/**
  Frees all memory in a given array of integer sequences.
  @param sq sequence  structure
  @return 0 for succes, -1 for error
  */
int sequence_free(sequence_t **sq);

/**
  Frees all memory in a given array of double sequences.
  @param sq sequence  structure
  @return 0 for succes, -1 for error
  */
int sequence_d_free(sequence_d_t **sq);

extern void sequence_d_print(FILE *file, sequence_d_t *sqd, int discrete);

/*** !!!!!!!! TO DO: Free functions for all types of pointers !!!!!!!!***/

%inline%{

  /* return a C-pointer to an integer sequence */
  int *get_onesequence(sequence_t *seqpt, int seqnumber) { 
    return (int *) seqpt->seq[seqnumber];
  }

  
  sequence_t *seq_read(char* filename ){
	  int i;
	  sequence_t** s;
	  //s = (sequence_d_t **) malloc(1*sizeof(sequence_d_t*));
	  s = sequence_read(filename, &i);
	  return s[0];
  }
  
  sequence_t* get_seq_ptr(sequence_t** array, int index){
	  return (sequence_t*) array[index];
  }
  
  /*** create and manipulate an array of pointers of pointers to sequence_d_t structs ***/
  sequence_d_t **sequence_d_t_array(int size) {
     int i;
	 sequence_d_t **s;
	 s = (sequence_d_t **) malloc(size*sizeof(sequence_d_t*));
	 for(i =0;i<size;i++){	
		 s[i] = NULL;
	 }
	 return s;	 
  }

  sequence_d_t* get_seq_d_ptr(sequence_d_t** array, int index){
	  return (sequence_d_t*) array[index];
  }	  
  
  void set_seq_d_array(sequence_d_t** array, int index,sequence_d_t* seq){
	array[index] = seq;
  }	
  
  void set_sequence_d_label(sequence_d_t* seq, int seq_num, long label){
	  seq->seq_label[seq_num] = label;
  }
  
  long get_sequence_d_label(sequence_d_t* seq, int seq_num ){
	  return seq->seq_label[seq_num];
  }	  
     
  sequence_d_t *seq_d_read(char* filename ){
	  int i;
      sequence_d_t** s;
	  //s = (sequence_d_t **) malloc(1*sizeof(sequence_d_t*));
	  s = sequence_d_read(filename, &i);
	  return *s;
  }

  void call_sequence_print(char* ch, sequence_t* seq){
    FILE* file_name;
    file_name = fopen(ch,"at");
    sequence_print(file_name,seq);
    fclose(file_name);
  }	  

  void call_sequence_d_print(char* ch,sequence_d_t* seq, int disc){
    FILE* file_name;
    file_name = fopen(ch,"at");
    sequence_d_print(file_name,seq, disc);
    fclose(file_name);
  }	  

   
%}

/*=============================================================================================
  =============================== model.c  ============================================== */

/** @name background_distributions
    A container for background distributions to be used in the reestimation. Model
    has an ID (== index) to be used for the arrays background_distributions.order
    and background_distributions.b
*/
struct background_distributions {
  /** Number of distributions */
  int n;
  /** Number of symbols in alphabet */
  int m;
  /** Order of the respective distribution */
  int* order;
  /** The probabilities */ 
  double **b;
};
typedef struct background_distributions background_distributions;


/** @name state
    The basic structure, keeps all parameters that belong to a state. 
*/
struct state {
  /** Initial probability */ 
  double pi;
  /** Output probability */
  double *b;
  int order;
  
  /** IDs of the following states */ 
  int *out_id;  
  /** IDs of the previous states */    
  int *in_id;

  /** transition probs to successor states. */
  double *out_a; 
  /** transition probs from predecessor states. */ 
  double *in_a;

  /** Transition probability to a successor 
      double *out_a; */
  /** Transition probablity to a precursor 
      double *in_a;*/

  /** Number of successor states */     
  int out_states; 
  /** Number of precursor states */
  int in_states;  
  /** if fix == 1 --> b stays fix during the training */
  int fix;

  int label;  
};
typedef struct state state;

/** @name model
    The complete HMM. Contains all parameters, that define a HMM.
*/
struct model {