// TrainSet.cc
// Kevin Karplus
// 21 July 1997

#include "Utilities/Random.h"

#include "TrainSet.h"
#include "OneChain.h"
#include "NeuralNet.h"
#include "alignment.h"

TrainSet::TrainSet(void)
{   NumColumns=NumChains=AllocChains=0;
    Chains = 0;
    NN = 0;
    accumulate_counts=0;
    training_order=0;
    ReAlloc(4000);
}

TrainSet::~TrainSet(void)
{
    for (int c=NumChains-1; c>=0; c--)
        delete Chains[c];
    delete [] Chains;

    if (NN)
    {   for (int i=0; i<NN->num_layers(); ++i) 
	{   if (accumulate_counts[i])
            delete [] accumulate_counts[i];
	}
    }
    delete [] accumulate_counts;
    delete [] training_order;
}

void TrainSet::ReAlloc(int new_num_chains)
{
    assert(new_num_chains >= NumChains);
    typedef OneChain *OneChainPtr;
    OneChain **new_array = new OneChainPtr[new_num_chains];
    for (int c=NumChains-1; c>=0; c--)
	new_array[c] = Chains[c];
    delete [] Chains;
    Chains = new_array;
    AllocChains = new_num_chains;

    // Now realloc the training order array
    if (training_order) {delete [] training_order;}
    training_order = new int[new_num_chains];
    for (int j=0; j<new_num_chains; ++j) {training_order[j] = j;}
}

void TrainSet::clear(void)
{  for (int c=NumChains-1; c>=0; c--)
   { delete Chains[c];
     Chains[c]=0;
    }

    if (accumulate_counts)
    {   for (int i=NN->num_layers()-1; i>=0; i--)
    		delete [] accumulate_counts[i];
	delete [] accumulate_counts;
	accumulate_counts = NULL;
    }
    
    // Reset training_order
    for (int ch=0; ch<AllocChains; ch++)
    { training_order[ch]=ch;
    }
    NumColumns=NumChains=AllocChains=0;
}


void TrainSet::add_chain(OneChain *chain)
{
    if (NumChains>=AllocChains)
    {    ReAlloc(2*NumChains +50);
    }
    Chains[NumChains++] = chain;
    NumColumns += chain->num_cols();
}


const OneChain* TrainSet::get_chain(int k) const
{
  assert(k>=0 && k<NumChains);
  return Chains[k];
}


const OneChain* TrainSet::get_shuffled_chain(int k) const
{ assert(k>=0 && k<NumChains);
  int shuffled = training_order[k];
  return Chains[shuffled];
}


void TrainSet::shuffle_training_order(void) const
{   int interim;

    for (int i=0; i<NumChains; ++i)
    { unsigned int k = static_cast<unsigned int> (drandom()*NumChains);
      interim = training_order[i];
      training_order[i] = training_order[k];
      training_order[k] = interim;
    }
}


void TrainSet::initialize_accumulation(NeuralNet *newnet)
{   
    if (NN && newnet!=NN)
    {    clear();
    }
    NN= newnet;
    int layers_in_net=NN->num_layers();
    assert (layers_in_net >0);

    if (accumulate_counts)
    {   for (int i=0; i<layers_in_net; ++i) 
    		delete [] accumulate_counts[i];
	delete [] accumulate_counts;
	accumulate_counts = NULL;
    }
    
    typedef float* fp;    
    accumulate_counts = new fp[layers_in_net];
    
    // Reset accumulate_counts
         
    for (int i=0; i<layers_in_net; ++i) 
    {    if (NN->is_layer_hidden(i))
	 {   accumulate_counts[i] = NULL;
	 }
	 else
	 {   int num_out = NN->layer(i)->num_out();
	     assert (num_out >0);
	     accumulate_counts[i] = new float[num_out];
	     for (int j=0; j<num_out; j++)
		    accumulate_counts[i][j]= 1.0/num_out;
	 }
    }
}

// CHANGE LOG:
// 25 March 1999 Kevin Karplus
//	Replaced libg++ random number generators with drand48()
// 15 September 1999 Sugato Basu
//      Changed accumulate_counts from int to float, to support
//      output format of ALIGNMENT
// 01 June 2004 Sol Katzman
//      Replaced drand48() with utilities from ultimate library.