// file: $isip_ifc/class/numeric/Histogram/hist_06.cc
// version: $Id: hist_06.cc 10427 2006-02-13 19:33:54Z srinivas $
//

// isip include files
//
#include "Histogram.h"

// method: setBins
//
// arguments:
//  const Vector<TVector>& bins: (input) input bins
//
// return: bool8 value indicating status
//
// this method sets the bins defined by the user to be used for histograms.
// the counts are reset to zero
//
template <class TVector>
bool8 Histogram::setBins(const Vector<TVector>& bins_a) {
  // assign the bins and dimension and reset the counts
  //
  if (dim_d != bins_a.length()) {
    return Error::handle(name(), L"setBins", Error::ARG, __FILE__, __LINE__);
  }
  else {
    bins_d.setLength(dim_d);
  }

  int32 i, tot_num_bins = 1;
  for (i = 0; i < dim_d; i++) {
    bins_d(i).assign(bins_a(i));
    num_bins_d(i) = bins_d(i).length();
    if (mode_d == EDGES) {
      num_bins_d(i) = num_bins_d(i) - (int32)1;
    }
    tot_num_bins *= num_bins_d(i);
  }
  counts_d.setLength(tot_num_bins, false);
  counts_d.assign((int32)0);
  
  // initialize the block boundaries for index generation
  //
  computeBlockBoundaryIndex();
  
  // exit gracefully
  //
  return true;
}

// explicit instantiations
//
template bool8
Histogram::setBins<VectorByte>(const Vector<VectorByte>&);
template bool8
Histogram::setBins<VectorDouble>(const Vector<VectorDouble>&);
template bool8
Histogram::setBins<VectorFloat>(const Vector<VectorFloat>&);
template bool8
Histogram::setBins<VectorLlong>(const Vector<VectorLlong>&);
template bool8
Histogram::setBins<VectorLong>(const Vector<VectorLong>&);
template bool8
Histogram::setBins<VectorShort>(const Vector<VectorShort>&);
template bool8
Histogram::setBins<VectorUllong>(const Vector<VectorUllong>&);
template bool8
Histogram::setBins<VectorUlong>(const Vector<VectorUlong>&);
template bool8
Histogram::setBins<VectorUshort>(const Vector<VectorUshort>&);

// method: setBins
//
// arguments:
//  const TVector& bins: (input) input bins
//
// return: bool8 value indicating status
//
// this method sets the bins defined by the user to be used for histograms.
// uses same bins in all dimensions. the counts are reset to zero
// this method assumes that the dimension of the histogram is already set
//
template <class TVector>
bool8 Histogram::setBins(const TVector& bins_a) {

  // assign the bins (assuming dimension is already set) and
  // reset the counts
  //
  int32 i, tot_num_bins;
  if (mode_d == EDGES) {
    tot_num_bins = (int32)Integral::pow(bins_a.length() - 1, dim_d);
  }
  else {
    tot_num_bins = (int32)Integral::pow(bins_a.length(), dim_d);
  }

  if (bins_d.length() != dim_d) {
    bins_d.setLength(dim_d);
  }

  for (i = 0; i < dim_d; i++) {
    bins_d(i).assign(bins_a);
    num_bins_d(i) = bins_d(i).length();
    if (mode_d == EDGES) {
      num_bins_d(i) = num_bins_d(i) - (int32)1;
    }
  }
  counts_d.setLength(tot_num_bins, false);
  counts_d.assign((int32)0);

  // initialize the block boundaries for index generation
  //
  computeBlockBoundaryIndex();

  // exit gracefully
  //
  return true;
}

// explicit instantiations
//
template bool8
Histogram::setBins<VectorByte>(const VectorByte&);
template bool8
Histogram::setBins<VectorDouble>(const VectorDouble&);
template bool8
Histogram::setBins<VectorFloat>(const VectorFloat&);
template bool8
Histogram::setBins<VectorLlong>(const VectorLlong&);
template bool8
Histogram::setBins<VectorLong>(const VectorLong&);
template bool8
Histogram::setBins<VectorShort>(const VectorShort&);
template bool8
Histogram::setBins<VectorUllong>(const VectorUllong&);
template bool8
Histogram::setBins<VectorUlong>(const VectorUlong&);
template bool8
Histogram::setBins<VectorUshort>(const VectorUshort&);

// method: setBins
//
// arguments:
//  int32 num_bins: (input) number of bins to use
//  TIntegral min: (input) minimum of the histogram range
//  TIntegral max: (input) maximum of the histogram range
//
// return: bool8 value indicating status
//
// this method computes the bin locations from the min, max, num_bins
// and binning mode, and assigns the same binning to all dimensions
// it is assumed that the dimension of the histogram is already set
//
template <class TIntegral>
bool8 Histogram::setBins(int32 num_bins_a, TIntegral min_a, TIntegral max_a) {

  int32 i, j;
  float64 log_min_thr = (float64)(1.0 - 0.0001);
  
  // error checking
  //
  if ((num_bins_a <= 0) || (max_a < min_a)) {
    return Error::handle(name(), L"setBins", ERR_BINS, __FILE__, __LINE__);
  }

  if (bins_d.length() == 0) {
    setDim((int32)dim_d);
  }
  
  // set same bins for all dimensions
  //
  for (i = 0; i < dim_d; i++) {

    if (scale_d == LINEAR || scale_d == USER_DEFINED) {
      min_d(i) = (float64)min_a;
      max_d(i) = (float64)max_a;
    }

    else if (scale_d == LOG) {
      if ((float64)min_a < log_min_thr ) {
	return Error::handle(name(), L"setBins", ERR_BINS, __FILE__, __LINE__);
      }
      min_d(i) = (float64)Integral::log10(min_a);
      max_d(i) = (float64)Integral::log10(max_a);
    }

    else {
      return Error::handle(name(), L"setBins", ERR_BINS, __FILE__, __LINE__);
    }
    
    num_bins_d(i) = num_bins_a;
    delta_d(i) = (max_d(i) - min_d(i)) / num_bins_d(i);

    bins_d(i).setLength(num_bins_d(i) + (int32)1);
    for (j = 0; j <= num_bins_d(i); j++) {
      bins_d(i)(j) = min_d(i) + delta_d(i) * (float64)j;
    }

    if (scale_d == LOG) {
      bins_d(i).exp10();
    }
  }

  if (mode_d == CENTERS) {
    
    if (scale_d == LINEAR || scale_d == USER_DEFINED) {
      for (i = 0; i < dim_d; i++) {
	bins_d(i).add(delta_d(i) / 2.0);
	bins_d(i).setLength(bins_d(i).length() - (int32)1);
      }
    }
    
    else {
      for (i = 0; i < dim_d; i++) {
	for (j = 0; j < bins_d(i).length() - 1; j++) {
	  bins_d(i)(j) = (bins_d(i)(j) + bins_d(i)(j + 1)) / 2.0;
	}
	bins_d(i).setLength(bins_d(i).length() - (int32)1);
      }
    }
  }
  
  // initialize the count vector
  //
  int32 tot_num_bins = (int32)Integral::pow(num_bins_a, dim_d);
  counts_d.setLength(tot_num_bins, false);
  counts_d.assign((int32)0);

  // initialize the block boundaries for index generation
  //
  computeBlockBoundaryIndex();

  // exit gracefully
  //
  return true;
}

// explicit instantiations
//
template bool8
Histogram::setBins<byte8>(int32, byte8, byte8);
template bool8
Histogram::setBins<float64>(int32, float64, float64);
template bool8
Histogram::setBins<float32>(int32, float32, float32);
template bool8
Histogram::setBins<int64>(int32, int64, int64);
template bool8
Histogram::setBins<int32>(int32, int32, int32);
template bool8
Histogram::setBins<int16>(int32, int16, int16);
template bool8
Histogram::setBins<uint64>(int32, uint64, uint64);
template bool8
Histogram::setBins<uint32>(int32, uint32, uint32);
template bool8
Histogram::setBins<uint16>(int32, uint16, uint16);

// method: setBins
//
// arguments:
//  const VectorLong& num_bins: (input) number of bins to use
//  const TVector& min: (input) minimum of the histogram range
//  const TVector& max: (input) maximum of the histogram range
//
// return: bool8 value indicating status
//
// this method computes the bin locations from the min, max, num_bins values
// specified for each dimension and the binning mode
//
template <class TVector>
bool8 Histogram::setBins(const VectorLong& num_bins_a, const TVector& min_a, const TVector& max_a) {

  int32 i, j, tot_num_bins = (int32)1;
  float64 log_min_thr = (float64)(1.0 - 0.0001); 
  
  if (dim_d != num_bins_a.length()) {
    setDim(num_bins_a.length());
  }
    
  // error checking
  //
  if ((min_a.length() != dim_d) ||
      (max_a.length() != dim_d)) {
    return Error::handle(name(), L"setBins", ERR_BINS, __FILE__, __LINE__);
  }
      
  // set same bins for all dimensions
  //
  for (i = 0; i < dim_d; i++) {
    
    if (scale_d == LINEAR || scale_d == USER_DEFINED) {
      min_d(i) = (float64)min_a(i);
      max_d(i) = (float64)max_a(i);
    }
    
    else if (scale_d == LOG) {
      if ((float64)min_a(i) < (float64)log_min_thr) {
	return Error::handle(name(), L"setBins", ERR_BINS, __FILE__, __LINE__);
      }
      min_d(i) = (float64)Integral::log10(min_a(i));
      max_d(i) = (float64)Integral::log10(max_a(i));
    }
    
    else {
      return Error::handle(name(), L"setBins", ERR_BINS, __FILE__, __LINE__);
    }
    
    num_bins_d(i) = num_bins_a(i);
    delta_d(i) = (max_d(i) - min_d(i)) / num_bins_d(i);

    bins_d(i).setLength(num_bins_d(i) + (int32)1);
    for (int32 j = 0; j <= num_bins_d(i); j++) {
      bins_d(i)(j) = min_d(i) + delta_d(i) * (float64)j;
    }
    
    if (scale_d == LOG) {
      bins_d(i).exp10();
    }
    tot_num_bins *= num_bins_a(i);
  }
  
  if (mode_d == CENTERS) {

    if (scale_d == LINEAR || scale_d == USER_DEFINED) {
      for (i = 0; i < dim_d; i++) {
	bins_d(i).add(delta_d(i) / 2.0);
	bins_d(i).setLength(bins_d(i).length() - (int32)1, true);
      }
    }
    
    else {
      for (i = 0; i < dim_d; i++) {
	for (j = 0; j < bins_d(i).length(); j++) {
	  bins_d(i)(j) = (bins_d(i)(j) + bins_d(i)(j + 1)) / 2.0;
	}
      bins_d(i).setLength(bins_d(i).length() - (int32)1, true);
      }
    }
  }
  
  // initialize the count vector
  //
  counts_d.setLength(tot_num_bins, false);
  counts_d.assign((int32)0);
  
  // initialize the block boundaries for index generation
  //
  computeBlockBoundaryIndex();

  // exit gracefully
  //
  return true;
}

// explicit instantiations
//
template bool8
Histogram::setBins<VectorByte>(const VectorLong&, const VectorByte&, const VectorByte&);
template bool8
Histogram::setBins<VectorDouble>(const VectorLong&, const VectorDouble&, const VectorDouble&);
template bool8
Histogram::setBins<VectorFloat>(const VectorLong&, const VectorFloat&, const VectorFloat&);
template bool8
Histogram::setBins<VectorLlong>(const VectorLong&, const VectorLlong&, const VectorLlong&);
template bool8
Histogram::setBins<VectorLong>(const VectorLong&, const VectorLong&, const VectorLong&);
template bool8
Histogram::setBins<VectorShort>(const VectorLong&, const VectorShort&, const VectorShort&);
template bool8
Histogram::setBins<VectorUllong>(const VectorLong&, const VectorUllong&, const VectorUllong&);
template bool8
Histogram::setBins<VectorUlong>(const VectorLong&, const VectorUlong&, const VectorUlong&);
template bool8
Histogram::setBins<VectorUshort>(const VectorLong&, const VectorUshort&, const VectorUshort&);


// method: setCounts
//
// arguments:
//  const VectorLong& counts: (input) counts to initialize histogram with
//
// return: bool8 value indicating status
//
// this method sets the counts vector. the input vector must be the same
// length as the internal count vector
//
bool8 Histogram::setCounts(const VectorLong& counts_a) {

  // verify the input vector length
  //
  if (counts_a.length() != counts_d.length()) {
    return Error::handle(name(), L"setCounts", ERR_BINS, __FILE__, __LINE__);
  }

  // assign the counts vector
  //
  return (counts_d.assign(counts_a));
}