#/*$Id: Wurst.xs,v 1.10 2008/03/14 15:43:31 mmundry Exp $ */

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#include "align_i.h"
#include "altscores.h"
#include "bad_angle.h"
#include "class_model.h"
#include "classifyStructure.h"
#include "cmp_dmat_i.h"
#include "compound.h"
#include "coord.h"
#include "coord_i.h"
#include "coordinfo_i.h"
#include "geo_gap.h"
#include "lsqf.h"
#include "model.h"
#include "multialign.h"
#include "pair_set_chim.h"
#include "pair_set_i.h"
#include "pair_set_p_i.h"
#include "param_fx_i.h"
#include "pdbin_i.h"
#include "pdbout_i.h"
#include "prob_vec_i.h"
#include "read_ac.h"
#include "read_ac_i.h"
#include "read_ac_strct.h"
#include "read_ac_strct_i.h"
#include "read_blst.h"
#include "read_mat.h"
#include "read_sec_i.h"
#include "read_seq_i.h"
#include "rescore.h"
#include "score_fx_i.h"
#include "score_mat_i.h"
#include "score_probvec.h"
#include "score_sec_i.h"
#include "score_smat.h"
#include "scratch.h"
#include "sec_s_i.h"
#include "silly.h"
#include "scor_set.h"
#include "scor_set_i.h"
#include "seq.h"


static double
constant(char *name, int len, int arg)
{
    errno = 0;
    if (strEQ(name + 0, "WURST_H")) {    /*  removed */
#       ifdef WURST_H
        return WURST_H;
#       else
        errno = ENOENT;
        return 0;
#       endif
    }
    errno = EINVAL;
    return 0;
}

typedef struct aa_clssfcn       Aa_clssfcn;
typedef struct aa_strct_clssfcn Aa_strct_clssfcn ;
typedef struct prob_vec         Prob_vec;
typedef struct sec_s_data       Sec_s_data;
typedef struct seq              Seq;
typedef struct seq_array        Seq_array;
typedef struct sub_mat          Sub_mat;
typedef struct score_mat        Score_mat;
typedef struct pair_set         Pair_set;
typedef struct coord            Coord;
typedef void                    Param;
typedef struct FXParam          FXParam;
typedef float                   RSParam;
typedef struct seqprof          Seqprof;
typedef struct scor_set         Scor_set;
typedef struct clssfcn          Clssfcn;

MODULE = Wurst        PACKAGE = Wurst
PROTOTYPES: ENABLE

double
constant(sv,arg)
    PREINIT:
    STRLEN        len;
    INPUT:
    SV *        sv
    char *        s = SvPV(sv, len);
    int        arg
    CODE:
    RETVAL = constant(s,len,arg);
    OUTPUT:
    RETVAL


#/* ---------------- Sec struct data --------------------------- */

Sec_s_data *
sec_s_data_read (fname)
    char *fname;

char *
sec_s_data_string (sec_s_data)
    Sec_s_data *sec_s_data;

MODULE = Wurst        PACKAGE = Sec_s_dataPtr PREFIX = sec_s_data_

void
sec_s_data_DESTROY (sec_s_data)
        Sec_s_data *sec_s_data
    CODE:
        sec_s_data_destroy (sec_s_data);

MODULE = Wurst        PACKAGE = Wurst
#/* ---------------- Sequences  -------------------------------- */
Seq *
seq_read(fname)
    char *fname;

Seq *
seq_from_string (s)
        char *s;

Seq *
seq_get_1 ( ps_a, n)
       Seq_array **ps_a
       size_t n;

size_t
seq_num ( ps_a)
        Seq_array **ps_a;

size_t
seq_size ( seq)
        Seq *seq;


char *
seq_print ( seq )
        Seq *seq

Seq_array **
seq_read_many (fname, s_a = NULL)
        const char *fname
        Seq_array **s_a;

char *
seq_print_many (ps_a)
        Seq_array **ps_a


MODULE = Wurst       PACKAGE = SeqPtr  PREFIX = seq_

void
seq_DESTROY(seq)
       Seq *seq
    CODE:
        seq_destroy (seq);

MODULE = Wurst       PACKAGE = Seq_arrayPtrPtr PREFIX = seq_arrayPtr_

void
seq_arrayPtr_DESTROY(s_a)
        Seq_array **s_a
    CODE:
        seq_array_destroy (s_a);


MODULE = Wurst        PACKAGE = Wurst

#/* ---------------- sub_mat -----------------------------------
# */

Sub_mat *
sub_mat_read (fname)
    const char *fname

char *
sub_mat_string(s_m)
    Sub_mat *s_m

Sub_mat *
sub_mat_shift (s_m, x)
    Sub_mat *s_m
    float x;

void
sub_mat_scale (s_m, bot, top)
    Sub_mat *s_m
    int bot
    int top

float
sub_mat_get_by_i (s_m, ndx1, ndx2)
    Sub_mat *s_m
    int ndx1
    int ndx2

float
sub_mat_get_by_c (s_m, ndx1, ndx2)
    Sub_mat *s_m
    char ndx1
    char ndx2

int
sub_mat_set_by_i (s_m, ndx1, ndx2, f)
        Sub_mat *s_m
        int ndx1
        int ndx2
        float f
    CODE:
        RETVAL = sub_mat_set_by_i (s_m, ndx1, ndx2, f);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL

int
sub_mat_set_by_c (s_m, ndx1, ndx2, f)
        Sub_mat *s_m
        char ndx1
        char ndx2
        float f
    CODE:
        RETVAL = sub_mat_set_by_c (s_m, ndx1, ndx2, f);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL

MODULE = Wurst       PACKAGE = Sub_matPtr PREFIX = sub_mat_

void
sub_mat_DESTROY (s_m)
        Sub_mat *s_m
    CODE:
        sub_mat_destroy (s_m);


#/* ---------------- coord   -----------------------------------
# */

MODULE = Wurst PACKAGE = Wurst

int
coord_2_bin (c, fname)
        Coord *c;
        const char *fname;
    CODE:
        RETVAL = coord_2_bin (c, fname);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL

char *
coord_name (c)
    Coord *c;

size_t
coord_size (c)
    Coord *c;

Coord *
coord_read ( fname )
    const char *fname;

Seq *
coord_get_seq (c)
        Coord *c;

int
coord_has_sec_s (c)
        Coord *c;

char *
coord_get_sec_s(c)
        Coord *c;

int
coord_2_pdb ( fname, c, seq = NULL)
        const char *fname
        Coord *c
        Seq   *seq;
    CODE:
        RETVAL = coord_2_pdb (fname, c, seq);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL

int
coord_2_spdb ( fname, c, scorset, seq = NULL)
     const char *fname;
     Coord *c
     Scor_set *scorset
     Seq   *seq;
    CODE:
        RETVAL = coord_2_spdb (fname, c, seq, scorset);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL

float
coord_c_n_dist (c, i, j, sqrt_flag)
        Coord *c
        unsigned int i
        unsigned int j
        unsigned int sqrt_flag


void
coord_calc_psi (c)
        Coord *c


void
coord_calc_phi (c)
        Coord *c


float
coord_psi (c, j, shift_min);
        Coord *c
        const size_t j
        const float shift_min
      CODE:
       RETVAL = coord_psi (c, j, shift_min);
       if (RETVAL == BAD_ANGLE)
           XSRETURN_UNDEF;
      OUTPUT:
        RETVAL


float
coord_phi (c, j, shift_min);
        Coord *c
        const size_t j
        const float shift_min
      CODE:
       RETVAL = coord_phi (c, j, shift_min);
       if (RETVAL == BAD_ANGLE)
           XSRETURN_UNDEF;
      OUTPUT:
        RETVAL

void
coord_geo_gap (IN Coord *c, \
               OUTLIST float quad, OUTLIST float linear, \
               OUTLIST float logistic, OUTLIST unsigned int num_gap, \
               IN float scale, IN float max)
    PROTOTYPE: $$$

    CODE:
        {
            int i;
            i = coord_geo_gap (c, &quad, &linear, &logistic, \
                               &num_gap, scale, max);
            if (i == EXIT_FAILURE)
                XSRETURN_EMPTY;
        }

int
dme_thresh (frac, c1, c2, thresh)
        float frac = NO_INIT
        Coord *c1
        Coord *c2
        float thresh;
    CODE:
        RETVAL = dme_thresh (&frac, c1, c2, thresh);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        frac
        RETVAL

Coord *
pdb_read ( fname, acq_c, chain)
    const char *fname
    const char *acq_c
    const char chain;


MODULE = Wurst  PACKAGE = CoordPtr  PREFIX = coord_

void
coord_DESTROY (c)
        Coord *c
    CODE:
        coord_destroy (c);

MODULE = Wurst  PACKAGE = Wurst
#/* ---------------- make_model --------------------------------
# */

Coord *
make_model (p, seq, coord)
        Pair_set *p
        Seq      *seq
        Coord    *coord

int
model_pdb_num ( mdl, resnum)
        Coord    *mdl
        int resnum;
     CODE:
        RETVAL = model_pdb_num(mdl, resnum);
        if (RETVAL == -99999)
            XSRETURN_UNDEF;
     OUTPUT:
        RETVAL

int
model_res_num ( mdl, mnum)
        Coord    *mdl
        int   mnum;
     CODE:
        RETVAL = model_res_num(mdl, mnum);
        if (RETVAL == -1)
          XSRETURN_UNDEF;
    OUTPUT:
        RETVAL

float *
coord_2_pnlty (c, f)
        Coord *c
        float f


#/* ---------------- scoring routines --------------------------
# */
MODULE = Wurst PACKAGE = Wurst

Score_mat *
score_mat_new (n_rows, n_cols)
    size_t n_rows
    size_t n_cols

Score_mat *
score_mat_read (fname)
    const char *fname

Score_mat *
score_mat_add (mat1, mat2, scale, shift = 0.0)
        Score_mat *mat1
        Score_mat *mat2
        float scale
        float shift;

void
score_mat_info (IN Score_mat *mat, \
                OUTLIST float min, OUTLIST float max, OUTLIST float av, \
                OUTLIST float std_dev)
    PROTOTYPE: $
    CODE:
        score_mat_info (mat, &min, &max, &av, &std_dev);

Score_mat *
score_mat_scale (mat, scale)
        Score_mat *mat
        const float scale;

Score_mat *
score_mat_shift (mat1, shift)
        Score_mat *mat1
        const float shift;

int
score_mat_write ( mat1, fname)
        Score_mat *mat1
        const char *fname;
    CODE:
        RETVAL = score_mat_write (mat1, fname);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL


int
score_mat_write_gnuplot( smat, fname, protA, protB )
            Score_mat  *smat
            const char *fname
            const char *protA
            const char *protB;

void
score_mat_diag_wipe( pair_set, smat )
            Pair_set *pair_set
            Score_mat *smat;

Score_mat *
score_mat_double_matrix ( smat )
            Score_mat *smat;


int
score_prof_prof (score_mat, sp1, sp2, subst_matrix)
        Score_mat *score_mat
        Seqprof *sp1
        Seqprof *sp2
        Sub_mat *subst_matrix;
    CODE:
        RETVAL = score_prof_prof (score_mat, sp1, sp2, subst_matrix);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL

int
score_smat (score_mat, seq1, seq2, subst_matrix)
        Score_mat *score_mat
        Seq *seq1
        Seq *seq2
        Sub_mat *subst_matrix;
    CODE:
        RETVAL = score_smat (score_mat, seq1, seq2, subst_matrix);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL

int
score_sprof (score_mat, s_p, seq, subst_matrix)
        Score_mat *score_mat
        Seqprof *s_p
        Seq *seq
        Sub_mat *subst_matrix;
    CODE:
        RETVAL = score_sprof (score_mat, s_p, seq, subst_matrix);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL


int
score_fx (score_mat, seq, coord, param)
        Score_mat *score_mat
        Seq *seq
        Coord *coord
        FXParam *param
    CODE:
        RETVAL = score_fx (score_mat, seq, coord, param);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL

int
score_fx_prof (score_mat, s_p, coord, param)
        Score_mat *score_mat
        Seqprof *s_p
        Coord *coord
        FXParam *param
    CODE:
        RETVAL = score_fx_prof (score_mat, s_p, coord, param);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL


int
score_sec (score_mat, sec_s, coord)
        Score_mat *score_mat
        Sec_s_data *sec_s
        Coord *coord
    CODE:
        RETVAL = score_sec (score_mat, sec_s, coord);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL

RSParam *
param_rs_read(fname)
    const char *fname;

float
score_rs (coord, params)
    Coord *coord
    RSParam *params;


FXParam *
param_fx_read (fname)
   const char *fname


MODULE = Wurst  PACKAGE = RSParamPtr  PREFIX = RSParam_
void
RSParam_DESTROY (p)
        RSParam *p
    CODE:
        param_rs_destroy (p);


MODULE = Wurst  PACKAGE = FXParamPtr  PREFIX = FXParam_

void
FXParam_DESTROY (f)
        FXParam *f
    CODE:
        FXParam_destroy(f);

MODULE = Wurst PACKAGE = Wurst

char *
score_mat_string (scores, seq0, seq1)
    Score_mat *scores
    Seq *seq0
    Seq *seq1;


Pair_set *
score_mat_sum_full (rmat, scores, pgap_open, pgap_widen, qgap_open, qgap_widen,p_mult, q_mult, align_type, bias_set = NULL)
        Score_mat * &rmat = NO_INIT
        Score_mat *scores
        float pgap_open
        float pgap_widen
        float qgap_open
        float qgap_widen
        float *p_mult
        float *q_mult
        int align_type
        Pair_set *bias_set
    OUTPUT:
        rmat
        RETVAL


MODULE = Wurst    PACKAGE = floatPtr     PREFIX = float_
void
float_DESTROY (f)
       float *f
    CODE:
       if (f)
           free (f);

MODULE = Wurst    PACKAGE = Score_matPtr PREFIX = score_mat_
void
score_mat_DESTROY (s)
        Score_mat *s
    CODE:
        score_mat_destroy (s);

#/* ---------------- pair_set ---------------------------------
#/* This is very messy. We want to return a list with two strings
#/* on it. Current versions of xsubpp let us use the nicer IN/OUT
#/* keywords. Older versions require us to PPCODE and dork around
#/* in the return stack explicitly.
# */
MODULE = Wurst PACKAGE = Wurst

char *
pair_set_chimera (s, c1, c2)
        Pair_set *s
        Coord *c1
        Coord *c2


void
pair_set_coverage (s, n1, n2)
        Pair_set *s
        size_t n1
        size_t n2
    PPCODE:
    {
        char *c1, *c2;
        if (pair_set_coverage (s, n1, n2, &c1, &c2) ==  EXIT_FAILURE) {
            free (c1);
            free (c2);
            XSRETURN_UNDEF;
        }
        EXTEND(SP, 2);
        PUSHs(sv_2mortal(newSVpv (c1, 0)));
        PUSHs(sv_2mortal(newSVpv (c2, 0)));
        free (c1);
        free (c2);
    }

void
pair_set_gap (IN Pair_set *s, \
              OUTLIST float open_cost, OUTLIST float widen_cost, \
              IN float open_scale, IN float widen_scale)

    PROTOTYPE: $$$

    CODE:
        {
            int i;
            i = pair_set_gap (s, &open_cost, &widen_cost, \
                              open_scale, widen_scale);

            if (i == EXIT_FAILURE)
                XSRETURN_EMPTY;
        }

char *
pair_set_string (s, seq0, seq1)
        Pair_set *s
        Seq *seq0
        Seq *seq1;

char *
multal_string (s)
        Pair_set *s;

char *
pair_set_pretty_string (s, seq0, seq1, sec_s_data = NULL, c2 = NULL)
        Pair_set *s
        Seq *seq0
        Seq *seq1
        Sec_s_data *sec_s_data
        Coord *c2;

void
pair_set_get_alignment_indices (IN Pair_set *p_s, IN int sequencenumber,\
                              OUTLIST int start, OUTLIST int stop)
         PROTOTYPE: $$
         CODE:
                   pair_set_get_alignment_indices (p_s, sequencenumber, &start, &stop);

int
get_seq_id_simple (  Pair_set *pair_set, Seq *s1, Seq *s2 );

void
pair_set_score(IN Pair_set *s, \
               OUTLIST float score, OUTLIST float score_smpl)

    PROTOTYPE: $

    CODE:
        {
            int i;
            i = pair_set_score (s, &score, &score_smpl);
 
            if (i == EXIT_FAILURE)
                XSRETURN_EMPTY;
        }

int
pair_set_extend(s, n0, n1, ext_len)
        Pair_set *s
        size_t n0
        size_t n1
        int ext_len;

MODULE = Wurst  PACKAGE = Pair_setPtr  PREFIX = pair_set_

void
pair_set_DESTROY (s)
        Pair_set *s
    CODE:
        pair_set_destroy (s);

MODULE = Wurst PACKAGE = Wurst
int
func_int ( )

float
func_float ()

char *
func_char ()

char *
funcs1_char (in)
        char *in;

char *
funcs2_char ()

#/* ---------------- clean_up   --------------------------------
void
free_scratch ()

#/* ---------------- blast checkpoint files --------------------
# */

Seqprof *
blst_chk_read (f)
        const char *f;

char *
seqprof_str (p)
        Seqprof *p;

Seq *
seqprof_get_seq (c)
        Seqprof *c;


MODULE = Wurst PACKAGE = SeqprofPtr PREFIX = seqprof_
void
seqprof_DESTROY (p)
        Seqprof *p
    CODE:
        seqprof_destroy (p);

#/* -------------------- scor_set routines ---------------
# */

MODULE = Wurst PACKAGE = Wurst

void
scor_set_fromvec ( dblvec )
    AV *dblvec;
    PREINIT:
       size_t s=0;
       size_t t;
       SV **d_el, *ssv;
       Scor_set *ss=NULL;
       double *dv;
    PPCODE:
       t = 1+av_len(dblvec);
       if (t>0) {
         dv = malloc(sizeof(*dv)*t); /* vector passed to C function */
         while (s<t) {
           d_el=av_fetch(dblvec, s, 0);
           if (d_el && (SvNIOK(*d_el)))
             /* copy the values from the perl array */
             dv[s] = SvNV( *d_el );
           else
             dv[s] = 0.0; /* and do not complain if */
                         /* we're given garbage   */
           s++;
         }
         ss = scor_set_fromvec( t, dv);
         free(dv);
       }
       if (ss) {
           ssv = sv_newmortal();
           sv_setref_pv(ssv, "Scor_setPtr", (void *)ss);
           EXTEND(SP,1);
           PUSHs(ssv);
       } else {
           XSRETURN_UNDEF;
       }


MODULE = Wurst PACKAGE = Wurst

AV*
scor_set_to_vec ( scoreset )
       Scor_set *scoreset;

       PREINIT:
          AV *av=Nullav;
          SV *a_el;
          size_t i=0;

       CODE:
          if (scoreset!=NULL) {
             av = newAV();
             av_unshift(av, scoreset->n);
             while (i<scoreset->n) {
                a_el = sv_newref(newSVnv(scoreset->scores[i]));
                if (av_store(av, i, a_el)==NULL)
                     croak("scor_set_to_vec: av_store returned null - \
 where is my array ???");

                i++;
             }
           }
           RETVAL = av;
        OUTPUT:
           RETVAL


Scor_set *
scor_set_simpl ( pairset, scoremat)
        Pair_set *pairset
        Score_mat *scoremat;

int
scor_set_scale  ( scorset, scale )
        Scor_set *scorset
        float     scale;
    CODE:
        RETVAL = scor_set_scale( scorset, scale);
        if (RETVAL == EXIT_FAILURE)
          XSRETURN_UNDEF;
        else
          RETVAL = 1;
    OUTPUT:
        RETVAL


MODULE = Wurst PACKAGE = Scor_setPtr PREFIX = scor_set_

void
scor_set_DESTROY (p)
        Scor_set *p
    CODE:
        scor_set_destroy (p);

#/* ---------------- class probability vectors -----------------
# */
MODULE = Wurst PACKAGE = Wurst

char *
prob_vec_info (pvec)
    Prob_vec *pvec;

#Prob_vec *
#seq_2_prob_vec ( seq, ac )
#    Seq *seq
#    Aa_clssfcn *ac;

int
score_pvec (score_mat, pvec1, pvec2)
    Score_mat *score_mat
    Prob_vec *pvec1
    Prob_vec *pvec2
    CODE:
        RETVAL = score_pvec (score_mat, pvec1, pvec2);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL

size_t
prob_vec_size(pvec);
    Prob_vec * pvec;

size_t
prob_vec_length(pvec);
    Prob_vec * pvec;

Prob_vec *
prob_vec_copy(pvec);
    Prob_vec * pvec;

int
prob_vec_write (pvec, fname)
    Prob_vec *pvec
    const char *fname
    CODE:
        RETVAL = prob_vec_write (pvec, fname);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL

Prob_vec *
prob_vec_read (fname)
    const char *fname


MODULE = Wurst   PACKAGE = Prob_vecPtr PREFIX = prob_vec_
void
prob_vec_DESTROY (pvec)
        Prob_vec *pvec
    CODE:
        prob_vec_destroy (pvec);

#/* ---------------- amino acid + structure classification -----
# */
MODULE=Wurst PACKAGE = Wurst

Aa_strct_clssfcn *
aa_strct_clssfcn_read (fname, error)
    const char *fname
    const float error

void
aa_strct_dump (ac)
    Aa_strct_clssfcn *ac

size_t
aa_strct_nclass (ac)
    Aa_strct_clssfcn *ac

size_t
aa_strct_size (ac)
    Aa_strct_clssfcn *ac

Prob_vec *
strct_2_prob_vec (structure, cmodel, norm = 1)
    Coord * structure
    Aa_strct_clssfcn * cmodel
    int norm


Prob_vec *
aa_strct_2_prob_vec (structure, cmodel, norm = 1)
    Coord * structure
    Aa_strct_clssfcn * cmodel
    int norm

Prob_vec *
prof_aa_strct_2_prob_vec (structure, s_p, cmodel, norm = 1)
    Coord * structure
    Seqprof * s_p
    Aa_strct_clssfcn * cmodel
    int norm

Prob_vec *
aa_2_prob_vec (seq, cmodel, norm = 1)
    Seq * seq
    Aa_strct_clssfcn * cmodel
    int norm

Prob_vec *
prof_aa_2_prob_vec (s_p, cmodel, norm = 1);
    Seqprof * s_p
    Aa_strct_clssfcn * cmodel
    int norm;

MODULE = Wurst   PACKAGE = Aa_strct_clssfcnPtr PREFIX = aa_strct_clssfcn_

void
aa_strct_clssfcn_DESTROY (aa)
        Aa_strct_clssfcn *aa
    CODE:
        aa_strct_clssfcn_destroy (aa);


#/* ---------------- amino acid classification------------------
# */
MODULE = Wurst PACKAGE = Wurst

Aa_clssfcn *
ac_read (fname)
    const char *fname

size_t
ac_size (ac)
    Aa_clssfcn *ac

size_t
ac_nclass (ac)
    Aa_clssfcn *ac

void
ac_dump (ac)
    Aa_clssfcn *ac

int
computeMembershipAAProf (mship, s_p, ac)
        float ** mship
        Seqprof * s_p
        Aa_clssfcn * ac
    CODE:
        RETVAL = computeMembershipAAProf (mship, s_p, ac);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL

int
computeMembershipAA (mship, seq, ac)
    float ** mship
    Seq * seq
    Aa_clssfcn * ac
    CODE:
        RETVAL = computeMembershipAA (mship, seq, ac);
        if (RETVAL == EXIT_FAILURE)
            XSRETURN_UNDEF;
        else
            RETVAL = 1;
    OUTPUT:
        RETVAL

Prob_vec *
seq_2_prob_vec (seq, ac)
    Seq *seq
    Aa_clssfcn *ac

MODULE = Wurst   PACKAGE = Aa_clssfcnPtr PREFIX = aa_clssfcn_
void
aa_clssfcn_DESTROY (aa)
        Aa_clssfcn *aa
    CODE:
        aa_clssfcn_destroy (aa);

#/* ---------------- alternative scores routines  --------------------
# */
MODULE = Wurst PACKAGE = Wurst


float
find_alt_path_score_simple (Score_mat *score_mat, Pair_set *pair_set);


#/* ---------------- bayesian fragments routines  --------------------
# */
MODULE = Wurst PACKAGE = Wurst

#Prob_vec *
#struct_2_prob_vec(structure, cmodel);
#    Coord * structure
#    Clssfcn * cmodel;

Clssfcn *
get_clssfcn(influence_report_filename, abs_error);
    const char * influence_report_filename
    float abs_error;

float *
computeMembership(mship, test_vec, cmodel);
    float * mship
    float * test_vec
    Clssfcn * cmodel;


MODULE = Wurst   PACKAGE = ClssfcnPtr PREFIX = clssfcn_
void
clssfcn_DESTROY (c)
        Clssfcn *c
    CODE:
        clssfcn_destroy (c);

#/* ---------------- multiple alignments ------------------
# */
MODULE = Wurst PACKAGE = Wurst

Pair_set *
merge_alignments (align1, align2, alignment);
        Pair_set * align1
        Pair_set * align2
        Pair_set * alignment;


Prob_vec *
pvec_avg (p_vec1, p_vec2, p_set, cur_step);
        Prob_vec * p_vec1
        Prob_vec * p_vec2
		Pair_set * p_set
		int cur_step;

Pair_set *
remove_seq (pairset, index);
		Pair_set * pairset
		int index;

Pair_set *
split_multal (pairset, a, b);
		Pair_set * pairset
		int a
		int b;

#/* ---------------- superimposing structures, RMSD ------------------
# */
MODULE = Wurst PACKAGE = Wurst

void
coord_rmsd ( IN Pair_set *pair_set, IN Coord *coord1, IN Coord *coord2, \
            IN int sub_flag,\
            OUTLIST float rmsd, OUTLIST Coord *c1_new, OUTLIST Coord *c2_new)
    PROTOTYPE: $$$$
    CODE:
        {
            int i;
            i = coord_rmsd(pair_set, coord1, coord2, sub_flag, &rmsd, &c1_new, &c2_new);
            if (i == EXIT_FAILURE)
                XSRETURN_EMPTY;
        }

void
get_rmsd(IN Pair_set *pairset, IN Coord *r1, \
         IN Coord *r2, OUTLIST float rmsd, OUTLIST int count)
    PROTOTYPE: $$$
    CODE:
        {
            int i;
            i = get_rmsd(pairset, r1, r2, &rmsd, &count);
            if (i == EXIT_FAILURE)
                XSRETURN_EMPTY;
        }

#/* ------------ accessing compound info ----------------------------
#*/

char *
get_compound_coord(c)
    Coord * c;

char *
get_compound_vec(v)
    Prob_vec * v;