seqaln.h

Go to the documentation of this file.

/* declarations common to all dynamic programming molecular biology modules */
#ifndef SEQALN_H
#define SEQALN_H

#ifndef MAXLINE
#define MAXLINE 512
#endif

#ifndef MAXPATH
#define MAXPATH 2000
#endif

#ifndef MAXSEQNAME
#define MAXSEQNAME 1024
#endif

#ifndef stdout
#include <stdio.h>  // there are pure C programs not C++
#endif

static char *SEQALN_VERSION="1.20";

/* the type of file, for a file used for input   */
typedef enum { SEQ, MAT, PRO, DIS, DB, PIPE, SOCKET } SEQALN_FTYPE;

/* the type of database, for a sequence file used for input 
 * file format*/
typedef enum { UNKNOWN, GENBANK, NEWAT, FASTA, PIR, SWISSPROT }
   SEQALN_DBTYPE;

/* the io struct holds input/output information */
struct SEQALN_IO {
   FILE *STDIN;          /* Place to obtain terminal input */
   FILE *STDOUT;         /* Place to put stdout output.    */
   FILE *STDERR;         /* Place to put stderr output.    */
};

/* type SEQALN_TRACE is used for tracebacks; a node */
typedef struct SEQALN_LSTRUCT { struct SEQALN_LSTRUCT *next; int i,j; }
   SEQALN_TRACE;

/* holds (i,j) pairs for multiple locations of one score */
typedef struct { int score, i, j; } SEQALN_SIJ;

/*
   Sequences begin in position 1 in seq[] and code[]; 
        position 0 corresponds to row or column zero in the scoring matrix,
        which holds initial gap scores.
   To print a sequence, use for example `printf("%s\n",&seq->seq[1]);'
*/
struct SEQALN_SEQUENCE {
   int  len;             /* Sequence length       */
   char name[MAXSEQNAME];/* Sequence name         */
   int reverse;          /* The sequence has been reversed   */
   int complement;       /* The sequence has been complemented  */
   int revcomp;   /* This is the reverse complement of the real seq   */
   int xlated;    /* Whether nucleotide->protein translation was done */
   char *seq;     /* To hold letters of the sequence len+2 size       */
   char *code;    /* To hold letter numbers [0..26] of the sequence   */
   int  bstart, bend; /* Start, stop locations of band sequence (for band)*/
   int  fstart, fend; /* Start, stop locations of ORF      */
   double *freq;  /* Frequency distribution of letters (for p-value)  */
   char *fname;   /* File name, where we obtain the sequence(s)       */
   FILE *fptr;    /* Pointer to current location in database          */
   long fposn;    /* Offset from start of file for next sequence      */
   SEQALN_FTYPE ftype; /*Type of file from which input is obtained */
   SEQALN_DBTYPE dbtype; /* Type of database, if one is used for input*/
   int  maxlen;   /* Length allocated for this buffer (max seq len)   */
   int  resized;  /* Denotes whether maxlen changed for last seq read */
 };

/* type prorow is used for profiles */
typedef int SEQALN_PROROW[26];

/*
   A profile is an array of 26 columns and `len' rows.
*/
struct SEQALN_PROFILE {
   int len;
   char name[MAXSEQNAME]; /* Profile name */
   SEQALN_PROROW *profile;
   int alpha,beta;
   char *fname;           /* Name of file containing profile */
   FILE *fptr;            /* Offset into profile file [not used] */
 };

enum PTYPE { GLOBAL, FIT, OVER, LOCAL };  /* Program type    */
enum STYPE { MATRIX, NONMATRIX, PROFILE };  /* Score function type  */
enum MTYPE { DISTANCE, SIMILARITY };
          /* Full / self-repeat / tandem-repeat / band matrix    */
enum BTYPE { FULL, SELF, TANDEM, BAND };
enum MEMUSE { LINEAR, SQUARE };/* How much memory we use           */
enum STATS {NONE, PVALUE };     /* Type of statistics to compute    */

/*
   These are all the scoring constants used by the software;
        once established for comparing two sequences, they are expected to
        remain unchanged.
*/
struct SEQALN_CONSTANTS {
   int alpha, beta;      /* Gap score parameters, positive */
   int csub;     /* Limit for printing conservative substitutions */
   int revcomp;   /* 0: seq1 is normal; 1: use seq1's reverse compl. */
   int cutoff;    /* Minimum score when reporting multiple scores   */
   int naligns;   /* No. of multiple alignments requested             */
   int rptalign;  /* Whether to report alignment                      */
   int rptmat;     /* Whether to report scoring matrix dump            */
   int rptscore;  /* Whether to report score                          */
   int rptptable; /* Table of score/obs. prob/est. prob for p-value   */
   int rpttrace;  /* Whether to report traceback list                 */
   int rptboth;   /* Whether to perform both upper & lower tracebacks */
   int verbose;   /* Whether to print in verbose mode                 */
   int width;           /* No. of chars in a line of seq. alignment         */
        /* problem for C++ compiler used for pdelta(int, char, void*)*/
   int (*deltafn)(); /* used for delta(a,b) scoring of 2 chars  */
   int traceupper;   /* Preference to take in tracebacks */
                     /* 0 ==> lower envelope; non-0 ==> upper envelope*/
   int envelope;  /* =1 if tracing upper & lower alignment envelopes  */
   int flip;            /* To flip (toggle) traceupper                      */
   int showmmatch; /* Print '*' (mismatch) in align., not '|' (match) */
   /* Profile specific */
   int palpha, pbeta;    /* Gap scores for indels in a profile */
   /* Overlap specific */
   int overout;     /* Types of overlap alignments to output: */
                  /*  0:highest score; 1:last row; 2:last col. 3:both */
   /* P-value specific */
   int nsims;      /* # of simulations to perform  */
   int ndeclumps;        /* # of declumps for each simulation  */
   int allscores;  /* 1: use all simulation scores; 0: use middle 80% */
   double gamma;   /* Value of gamma           */
   double p;       /* Value of p               */
   char *randfile; /* File with GFSR random number generator state */
   /* Non-matrix specific */
   int match, mismatch;  /*Match/mismatch non-matrix score parameters*/
   /* Matrix specific */
   int xmatrix[32][32]; /*Scoring matrix; use 26x26 */
   int offset;                /* Offset for elements of matrix */
   /* Tandem repeat specific */
   int window;           /* Pattern stride for wraparound local similarity */
   /* Band specific */
   int center, Delta1, Delta2;  /* center & Delta on each side for 2nd seq.  */
   /* Miscellaneous paramters */
   int Debug;            /* Debug flag, for debugging output                 */
        enum PTYPE ptype;
        enum STYPE stype;
        enum MTYPE mtype;
        enum BTYPE btype;
        enum MEMUSE memuse;
        enum STATS stats;
};

/*
   This structure holds intermediate and final results of scoring.
*/
struct SEQALN_RESULTS {
   int **S;              /* Scoring matrix size=colxrow                     */
        int S_size;  // maximum allocated size of S 2d-array
        //int S_size;  /* max(seq1len)*max(seq2len) so far */
   int *E;               /* Indels from one direction, only for declumping   */
   int *F;               /* Indels from other direction                      */
   int *best;  /* Best score limit for any row or column           */
   int bestS;   /* Maximum score                                    */
   int bestSi, bestSj;   /* Coordinates in S of maxS    */
   int naligns;  /* No. of multiple alignments left, when requested  */
   int jstart;  /* Starting location in scoring matrix, for band    */
   int jmax;   /* Ending location in scoring matrix, for band      */
   int maxentry;  /* High score for each match                        */
   SEQALN_TRACE *trace;  /* Current traceback list                   */
   char **aligned; /* For reporting multiple alignments -- need 1 bit */
   char *linbits; /* For reporting multiple alignments with wrapping  */
   SEQALN_SIJ *listsij; /* For holding (i,j) pairs for multiple alignments  */
   int listcount;        /* Count of multiple alignments              */
   struct SEQALN_PVALUE *pvalue; /*holding p-value related information*/
   /* Information for alignment outputs. */
   int start1,start2; /*Starting positions of alignment in seq1, seq2 */
   char *align0;  /* Alignment string for match/mismatch of seqs      */
   char *align1;  /* Alignment string for 1st sequence                */
   char *align2;  /* Alignment string for 2nd sequence                */
   int align_len; /* Length of each of the above 3 alignment strings  */
        int nogap_len; 
        int max_align_len;
        int collen;  /* current length of column */
        int rowlen;  /* intented to save the allocation deallocation */
        /* the next four is for looking at the distribution of the match */
        int match_freq1[26]; // residue frequence in the matched region
        int match_freq2[26]; // [Residue_char - 'A'] is the index number
        int iden_count;  // identical residues
        int siml_count;  // similar residue counts
        int end1, end2;    /*end position of align in each sequence */
};

/*
   This structure holds intermediate and final results unique to p-value
   software, so the results data structure doesn't have to hold them if
   p-value software is not used.
*/
struct SEQALN_PVALUE {
   double p;             /* value for p in lambda = gamma * m * n * p^t      */
   double gamma;         /* value for gamma  in lambda = gamma * m * n * p^t */
   double pvalue;        /* value for p-value                                */
   double lambda;        /* lambda = gamma * seq1len * seq2len * p^score     */
   double coeff;         /* if -0.99 < coeff < 0.99, unreliable parameters   */
   int nsims;            /* number of simulations requested                  */
   int ndeclumps;        /* number of declumps for each simulation           */
   int sims2go;          /* simulations left to perform                      */
   int declumps2go;      /* declumps left to perform for this simulation     */
   int seq1len;          /* length to use for `m', the size of sequence 1    */
   double seq1dist[26];  /* letter frequency distribution of sequence 1      */
   int seq2len;          /* length to use for `n', the size of sequence 2    */
   double seq2dist[26];  /* letter frequency distribution of sequence 2      */
   int *hist;            /* histogram of scores, for linear regression       */
   int nhist;            /* number of elements in histogram                  */
   int npvals;           /* number of p-values computed w/ declumping so far */
};

#ifdef __STDC__
#if __STDC__==1
#define INLINE inline
#else
#define INLINE
#endif
#endif

/* The Makefile-supplied definition overrides the compiler's default */

#ifdef HAS_INLINE
#if HAS_INLINE==1
#define INLINE inline
#else
#define INLINE
#endif
#endif

/* For non-ANSI cc compiler, don't expect `inline' support */

#ifndef INLINE
#define INLINE
#endif

#endif