/****************************************************************************************/
/*                                                                                      */
/*  Project     :  1D-BRNN                                                              */
/*  Release     :  3.3                                                                  */
/*                                                                                      */
/*  File        :  Sequence.cpp                                                         */
/*  Description :  Sequence data and model predictions for the sequence                 */
/*                                                                                      */
/*  Author(s)   :  Christophe Magnan  (2013) - New generic version                      */
/*              :  Jianlin Cheng      (2003) - New custom version for SCRATCH           */
/*              :  Gianluca Pollastri (2001) - Customized version for SCRATCH           */
/*              :  Paolo Frasconi     (1997) - Initial generic version                  */
/*                                                                                      */
/*  Copyright   :  Institute for Genomics and Bioinformatics                            */
/*                 University of California, Irvine                                     */
/*                                                                                      */
/*  Modified    :  2015/07/01                                                           */
/*                                                                                      */
/****************************************************************************************/

#include "Sequence.h"

/*******************************************/
/*                Interface                */
/*******************************************/

// Constructor
Sequence::Sequence() :
  Num_Positions(-1),Num_Classes(-1),Classes(NULL),
  Targets(NULL),Features(NULL),Predictions(NULL),
  Outputs_MAIN(NULL),Outputs_FWD(NULL),Outputs_BWD(NULL),
  BackProp_FWD(NULL),BackProp_BWD(NULL){}

// Destructor
Sequence::~Sequence()
{
  for(int p=0;p<Num_Positions;p++){ delete[] Targets[p];
  delete[] Features[p]; delete[] Outputs_MAIN[p];
  delete[] Outputs_FWD[p]; delete[] Outputs_BWD[p]; }
  delete[] Classes; delete[] Targets; delete[] Features;
  delete[] Predictions; delete[] Outputs_MAIN;
  delete[] Outputs_FWD; delete[] Outputs_BWD;
  if((BackProp_FWD!=NULL)&&(BackProp_BWD!=NULL)){
  for(int p=0;p<Num_Positions;p++){
  delete[] BackProp_FWD[p]; delete[] BackProp_BWD[p]; }
  delete[] BackProp_FWD; delete[] BackProp_BWD; }
}

// Load sequence
void Sequence::load(istream& is,int feat,int cl)
{
  is >> Num_Positions; Num_Classes=cl;
  Classes=new int[Num_Positions];
  Targets=new float*[Num_Positions];
  Features=new float*[Num_Positions];
  for(int p=0;p<Num_Positions;p++)
  { is >> Classes[p];
    Targets[p]=new float[Num_Classes];
    for(int c=0;c<Num_Classes;c++){
    Targets[p][c]=(c==Classes[p]?1:0); }
    Features[p]=new float[feat];
    for(int f=0;f<feat;f++){
    is >> Features[p][f]; } }
  check_viability();
}

// Allocate memory for propagation
void Sequence::alloc_propagation(int out_fwd,int out_bwd)
{
  Predictions=new int[Num_Positions]; Outputs_MAIN=new float*[Num_Positions];
  Outputs_FWD=new float*[Num_Positions]; Outputs_BWD=new float*[Num_Positions];
  for(int p=0;p<Num_Positions;p++){ Outputs_MAIN[p]=new float[Num_Classes];
  Outputs_FWD[p]=new float[out_fwd]; Outputs_BWD[p]=new float[out_bwd]; }
}

// Allocate memory for back-propagation
void Sequence::alloc_backpropagation(int out_fwd,int out_bwd)
{
  BackProp_FWD=new float*[Num_Positions];
  BackProp_BWD=new float*[Num_Positions];
  for(int p=0;p<Num_Positions;p++){
  BackProp_FWD[p]=new float[out_fwd];
  BackProp_BWD[p]=new float[out_bwd]; }
}

// Reset back-propagation values
void Sequence::reset_backpropagation(int out_fwd,int out_bwd)
{
  for(int p=0;p<Num_Positions;p++){
  for(int i=0;i<out_fwd;i++){ BackProp_FWD[p][i]=0.0; }
  for(int i=0;i<out_bwd;i++){ BackProp_BWD[p][i]=0.0; } }
}

// Write the model predictions in a file
void Sequence::write_predictions(ostream& os)
{
  os << Num_Positions << "\n"; for(int i=0;i<Num_Positions;i++){
  os << "in " << Classes[i] << " out " << Predictions[i] << " pb";
  for(int j=0;j<Num_Classes;j++){ os << " " << Outputs_MAIN[i][j]; }
  os << "\n"; }
}

// Return the last predictions error for a given position
float Sequence::prediction_error(int pos)
{
  float error=0.0; for(int c=0;c<Num_Classes;c++){
  if((Targets[pos][c])&&(Outputs_MAIN[pos][c])){
  error-=Targets[pos][c]*(float)log(Outputs_MAIN[pos][c]);
  } } return error;
}

// Check the viability of the sequence
void Sequence::check_viability()
{
  if(Num_Positions<=0){ cerr << "\n\nERROR : empty sequence found\n"; exit(1); }
  for(int p=0;p<Num_Positions;p++){ if((Classes[p]<0)||(Classes[p]>=Num_Classes)){
  cerr << "\n\nERROR: incorrect class found: " << Classes[p] << "\n"; exit(1); } }
}