i5arr.cpp

Go to the documentation of this file.

#include <fvar.hpp>
#include "admb_messages.h"

i5_array::i5_array()
{
  allocate();
}
i5_array::i5_array(const i5_array& other)
{
  shallow_copy(other);
}
void i5_array::shallow_copy(const i5_array& other)
{
  if (other.shape)
  {
    shape = other.shape;
    ++(shape->ncopies);
    t = other.t;
  }
  else
  {
#ifdef DEBUG
    cerr << "Warning -- Unable to shallow copy an unallocated i5_array.\n";
#endif
    allocate();
  }
}
i5_array::~i5_array()
{
  deallocate();
}
void i5_array::allocate()
{
  t = nullptr;
  shape = nullptr;
}
i5_array::i5_array(int hsl, int hsu)
{
  allocate(hsl,hsu);
}
void i5_array::allocate(int hsl, int hsu)
{
  if (hsl > hsu)
  {
    return allocate();
  }
  if ((t = new i4_array[static_cast<unsigned int>(hsu - hsl + 1)]) == 0)
  {
    cerr << " Error allocating memory in i5_array::allocate\n";
    ad_exit(1);
  }
  if ((shape = new vector_shapex(hsl, hsu, t)) == 0)
  {
    cerr << " Error allocating memory in i5_array::allocate\n";
    ad_exit(1);
  }
  t -= indexmin();
  for (int i = hsl; i <= hsu; ++i)
  {
    t[i].allocate();
  }
}
void i5_array::allocate(
  int hsl, int hsu,
  int sl, int sh,
  int nrl, int nrh,
  int ncl, int nch,
  int aa, int bb)
{
  allocate(hsl, hsu);
  for (int i = indexmin(); i <= indexmax(); ++i)
  {
    t[i].allocate(sl,sh,nrl,nrh,ncl,nch,aa,bb);
  }
}

 void i5_array::allocate(const ad_integer& hsl,const ad_integer& hsu,
   const index_type& sl,const index_type& sh,
   const index_type& nrl,const index_type& nrh,
   const index_type& ncl,const index_type& nch,
   const index_type& aa,const index_type& bb)
 {
  unsigned int ss =
    static_cast<unsigned int>(hsu < hsl ? 0 : hsu - hsl + 1);
   if (ss>0)
   {
     if ( (t = new i4_array[ss]) == 0)
     {
       cerr << " Error allocating memory in i5_array contructor\n";
       ad_exit(21);
     }
     if ( (shape=new vector_shapex(hsl,hsu,t)) == 0)
     {
       cerr << " Error allocating memory in i5_array contructor\n";
       ad_exit(21);
     }
     t -= indexmin();
     for (int i=hsl; i<=hsu; i++)
     {
       (*this)(i).allocate(ad_integer(sl),ad_integer(sh),nrl(i),nrh(i),
         ncl(i),nch(i),aa(i),bb(i));
     }
   }
   else
   {
     t=0;
     shape=0;
   }
 }
void i5_array::deallocate()
{
  if (shape)
  {
    if (shape->ncopies > 0)
    {
      --(shape->ncopies);
    }
    else
    {
      t = static_cast<i4_array*>(shape->get_truepointer());
      delete [] t;
      delete shape;
    }
    allocate();
  }
#if defined(DIAG)
  else
  {
    cerr << "Warning -- Unable to deallocate an unallocated i5_array.\n";
  }
#endif
}

#if !defined (OPT_LIB)

i4_array& i5_array::operator()(int i)
{
  return elem(i);
}
i4_array& i5_array::operator[](int i)
{
  return elem(i);
}
i3_array& i5_array::operator()(int i, int j)
{
  return elem(i)(j);
}
imatrix& i5_array::operator()(int i, int j, int k)
{
  return elem(i)(j, k);
}
ivector& i5_array::operator()(int i, int j, int k, int l)
{
  return elem(i)(j, k, l);
}
int& i5_array::operator()(int i, int j, int k, int l, int m)
{
  return elem(i)(j, k, l, m);
}
const i4_array& i5_array::operator()(int i) const
{
  return elem(i);
}
const i4_array& i5_array::operator[](int i) const
{
  return elem(i);
}
const i3_array& i5_array::operator()(int i, int j) const
{
  return elem(i)(j);
}
const imatrix& i5_array::operator()(int i, int j, int k) const
{
  return elem(i)(j, k);
}
const ivector& i5_array::operator()(int i, int j, int k, int l) const
{
  return elem(i)(j, k, l);
}
const int& i5_array::operator()(int i, int j, int k, int l, int m) const
{
  return elem(i)(j, k, l, m);
}
#endif
void i5_array::initialize()
{
  const int max = indexmax();
  for (int i5 = indexmin(); i5 <= max; ++i5)
  {
    elem(i5).initialize();
  }
}