cust_other.H

/* cust_other.H */
/* $Id: cust_other.H,v 1.8 2008/08/14 10:30:06 vlad Exp $ */
#ifdef __CubeStorage_H


/***********************************************************************
 * Setup new dimensions.
 */
template<class T>
void
CubeStorage<T>::new_size (int dim_n, int* dims, item_order_t itor)
{
  delete[] pDim;
  delete[] pStorage;

  nDim = dim_n;
  eItemOrder = itor;

  if(dim_n <= 0)
    Throw(ERROR__NON_POSITIVE_NUMBER);
  if(NULL == dims)
    Throw(ERROR__NULL);

  pDim = new int[nDim];
  /*iCur = new int[nDim];*/
  int   dim_i;
  int   mem_size = 1;
  for(dim_i = 0; dim_i < nDim; ++dim_i)
    {
      /*iCur[dim_i] = 0;*/
      pDim[dim_i] = dims[dim_i];
      if(dims[dim_i] <= 0)
    Throw(ERROR__NON_POSITIVE_NUMBER);
      mem_size *= dims[dim_i];
    }

  try{
    pStorage = new T[mem_size];
  }catch(...){
    pStorage = NULL;
    if(mem_size != 0)
      Throw(ERROR__ALLOC);
  }
}


/***********************************************************************
 * Compute linear index in cube array.
 */
template<class T>
int
CubeStorage<T>::lin_index (int i0, ...) const
{
  int   dim_i;
  int   *iCur = (int*) alloca(nDim);

  /* Translate int i0, ... to iCur[nDim] */
  iCur[0] = i0;
  va_list   val;
  va_start(val, i0);
  for(dim_i = 1; dim_i < nDim; ++dim_i)
    iCur[dim_i] = va_arg(val, int);
  va_end(val);

  return lin_index(iCur);
}


/***********************************************************************
 * Compute linear index in cube array.  Item order aware.
 */
template<class T>
int
CubeStorage<T>::lin_index (int* i) const
{
  int   dim_i, li = 0;

  switch(eItemOrder)
    {
    case AlaC:
      for(dim_i = 0; dim_i < nDim; ++dim_i)
    if(i[dim_i] < 0 || i[dim_i] >= pDim[dim_i])
      Throw(ERROR__DA_OUT_OF_RANGE);
    else if(nDim - 1 == dim_i)
      li += i[dim_i];
    else
      {
        li += i[dim_i];
        li *= pDim[dim_i + 1];
      }
      break;
    case AlaFortran:
      for(dim_i = nDim - 1; dim_i >= 0; --dim_i)
    if(i[dim_i] < 0 || i[dim_i] >= pDim[dim_i])
      Throw(ERROR__DA_OUT_OF_RANGE);
    else if(0 == dim_i)
      li += i[dim_i];
    else
      {
        li += i[dim_i];
        li *= pDim[dim_i - 1];
      }
      break;
    }
  return li;
}


/***********************************************************************
 * Compute total number of items in given cube.
 */
template<class T>
int
CubeStorage<T>::items_number (int dim_n, int* dims) const
{
  int   dim_i;
  int   mem_size = 1;

  if(0 == dim_n)
    return 0;

  for(dim_i = 0; dim_i < dim_n; ++dim_i)
    mem_size *= dims[dim_i];

  return mem_size;
}


template<class T>
void
CubeStorage<T>::clean ()
{
  memset(pStorage, 0, sizeof(T) * items_number(nDim, pDim));
}


template<class T>
void
CubeStorage<T>::fill (T v)
{
  int   i, n = items_number(nDim, pDim);
  for(i = 0; i < n; ++i)
    pStorage[i] = v;
}


#endif /* cust_other.H */