f4arr.cpp

Go to the documentation of this file.

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

dvar4_array::dvar4_array(int nrl, int nrh)
{
  allocate(nrl, nrh);
}
dvar4_array::dvar4_array(const dvar4_array& other)
{
  shallow_copy(other);
}
void dvar4_array::shallow_copy(const dvar4_array& other)
{
  if (other.shape)
  {
    shape = other.shape;
    ++(shape->ncopies);
    t = other.t;
  }
  else
  {
#ifdef DEBUG
    cerr << "Warning -- Unable to shallow copy an unallocated dvar4_array.\n";
#endif
    allocate();
  }
}

 dvar4_array dvar4_array::sub(int nrl,int nrh)
 {
   if (allocated(*this))
   {
     dvar4_array tmp(nrl,nrh);
     for (int i=nrl; i<=nrh; i++)
     {
       tmp[i].shallow_copy((*this)(i));
     }
     return tmp;
   }
   else
   {
     return *this;
   }
 }
void dvar4_array::deallocate()
{
  if (shape)
  {
    if (shape->ncopies > 0)
    {
      --(shape->ncopies);
    }
    else
    {
      t += indexmin();
      delete [] t;
      delete shape;
    }
    allocate();
  }
#if defined(DIAG)
  else
  {
    cerr << "Warning -- Unable to deallocate an unallocated dvar4_array.\n";
  }
#endif
}

dvar4_array::~dvar4_array()
{
  deallocate();
}

#ifndef OPT_LIB

    dvar3_array& dvar4_array::operator ( ) (int i)
    {
      if (i < hslicemin() || i > hslicemax())
      {
        ADMB_ARRAY_BOUNDS_ERROR("hslice index out of bounds",
        "dvar3_array& dvar4_array::operator() (int i)",
        hslicemin(), hslicemax(), i);
      }
      return t[i];
    }

    dvar3_array& dvar4_array::operator [] (int i)
    {
      if (i < hslicemin() || i > hslicemax())
      {
        ADMB_ARRAY_BOUNDS_ERROR("hslice index out of bounds",
        "dvar3_array& dvar4_array::operator[] (int i)",
        hslicemin(), hslicemax(), i);
      }
      return t[i];
    }

dvar_matrix& dvar4_array::operator()(int i ,int j)
{
  if (i < hslicemin() || i > hslicemax())
  {
    ADMB_ARRAY_BOUNDS_ERROR("hslice index out of bounds",
      "dvar_matrix& dvar4_array::operator() (int i, int j)",
    hslicemin(), hslicemax(), i);
  }
  return (t + i)->operator()(j);
}

dvar_vector& dvar4_array::operator()(int i, int j, int k)
{
  if (i < hslicemin() || i > hslicemax())
  {
    ADMB_ARRAY_BOUNDS_ERROR("hslice index out of bounds",
      "dvar_vector& dvar4_array::operator() (int i, int j, int k)",
    hslicemin(), hslicemax(), i);
  }
  return (t + i)->operator()(j, k);
}

    prevariable dvar4_array::operator ( ) (int i,int j,int k,int l)
    {
      if (i < hslicemin() || i > hslicemax())
      {
        ADMB_ARRAY_BOUNDS_ERROR("hslice index out of bounds",
        "prevariable& dvar4_array::operator() (int i, int j, int k)",
        hslicemin(), hslicemax(), i);
      }
      return ( ((*this)(i,j,k))(l));
    }

const dvar3_array& dvar4_array::operator()(int i) const
    {
        if (i<hslicemin()||i>hslicemax())
        { cerr << "Error hslice index out of bounds in\n"
            "dvar3_array& dvar4_array::operator ( )" << endl;
          ad_exit(1);
        }
      return t[i];
    }

const dvar3_array& dvar4_array::operator[](int i) const
    {
        if (i<hslicemin()||i>hslicemax())
        { cerr << "Error hslice index out of bounds in\n"
            "dvar3_array& dvar4_array::operator ( )" << endl;
          ad_exit(1);
        }
      return t[i];
    }

const dvar_matrix& dvar4_array::operator()(int i, int j) const
{
  if (i<hslicemin()||i>hslicemax())
  { cerr << "Error hslice index out of bounds in\n"
            "dvarmatrix& dvar4_array::operator ( )" << endl;
    ad_exit(1);
  }
  return (t + i)->operator()(j);
}

const dvar_vector& dvar4_array::operator()(int i, int j, int k) const
{
  if (i<hslicemin()||i>hslicemax())
  { cerr << "Error hslice index out of bounds in\n"
            "dvarvector& dvar4_array::operator ( )" << endl;
    ad_exit(1);
  }
  return (t + i)->operator()(j, k);
}

const prevariable dvar4_array::operator()(int i, int j, int k, int l) const
{
  if (i<hslicemin()||i>hslicemax())
  { cerr << "Error hslice index out of bounds in\n"
            "double& dvar4_array::operator ( )"  << endl;
    ad_exit(1);
  }
  return (t + i)->operator()(j, k, l);
}
#endif

dvar4_array& dvar4_array::operator=(const d4_array& m)
{
  int mmin = hslicemin();
  int mmax = hslicemax();
#ifndef OPT_LIB
  if (mmin!=m.hslicemin() || mmax!=m.hslicemax())
  {
    cerr << "Incompatible bounds in dvar4_array& dvar4_array::operator=(const d4_array&)\n";
    ad_exit(1);
  }
#endif
  dvar3_array* pti = t + mmin;
  const d3_array* pmi = &m(mmin);
  for (int i=mmin; i<=mmax; ++i)
  {
    *pti = *pmi;
    ++pti;
    ++pmi;
  }
  return *this;
}

dvar4_array& dvar4_array::operator=(const dvar4_array& m)
{
  int mmin = hslicemin();
  int mmax = hslicemax();
#ifndef OPT_LIB
  if (mmin!=m.hslicemin() || mmax!=m.hslicemax())
  {
    cerr << "Incompatible bounds in dvar4_array& dvar4_array::operator=(const dvar4_array&)\n";
    ad_exit(1);
  }
#endif
  dvar3_array* pti = t + mmin;
  const dvar3_array* pmi = &m(mmin);
  for (int i=mmin; i<=mmax; ++i)
  {
    *pti = *pmi;
    ++pti;
    ++pmi;
  }
  return *this;
}

void dvar4_array::allocate(
  int hsl, int hsu,
  int sl, int sh,
  int nrl, int nrh,
  int ncl, int nch)
{
  if ((shape = new four_array_shape(hsl, hsu)) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  if ((t = new dvar3_array[hslicesize()]) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  t -= hsl;

  dvar3_array* pti = t + hsl;
  for (int i = hsl; i <= hsu; ++i)
  {
    pti->allocate(sl, sh, nrl, nrh, ncl, nch);
    ++pti;
  }
}
void dvar4_array::allocate(
  int hsl, int hsu,
  int sl, int sh,
  int nrl, int nrh,
  const ivector& ncl, const ivector& nch)
{
  if ((shape = new four_array_shape(hsl, hsu)) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  if ((t = new dvar3_array[hslicesize()]) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  t -= hsl;

  dvar3_array* pti = t + hsl;
  for (int i=hsl; i<=hsu; ++i)
  {
    pti->allocate(sl, sh, nrl, nrh, ncl, nch);
    ++pti;
  }
}

void dvar4_array::allocate(
  ad_integer hsl, 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)
{
  if ( (shape=new four_array_shape(hsl,hsu)) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  if ((t = new dvar3_array[hslicesize()]) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  int il = hsl;
  int iu = hsu;
  t -= il;

  dvar3_array* pti = t + il;
  for (int i = il; i <= iu; ++i)
  {
    pti->allocate(sl(i), sh(i), nrl(i), nrh(i), ncl(i), nch(i));
    ++pti;
  }
}
void dvar4_array::allocate(
  ad_integer hsl, ad_integer hsu,
  const index_type& sl, const index_type& sh,
  const index_type& nrl, const index_type& nrh)
{
  if ((shape = new four_array_shape(hsl, hsu)) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  if ((t = new dvar3_array[hslicesize()]) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  int il = hsl;
  int iu = hsu;
  t -= il;

  dvar3_array* pti = t + il;
  for (int i = il; i <= iu; ++i)
  {
    pti->allocate(sl(i), sh(i), nrl(i), nrh(i));
    ++pti;
  }
}
void dvar4_array::allocate(
  ad_integer hsl, ad_integer hsu,
  const index_type& sl, const index_type& sh)
{
  if ( (shape=new four_array_shape(hsl,hsu)) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  if ( (t = new dvar3_array[hslicesize()]) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  int il=hsl;
  int iu=hsu;
  t -= il;

  dvar3_array* pti = t + il;
  for (int i = il; i <= iu; ++i)
  {
    pti->allocate(sl(i), sh(i));
    ++pti;
  }
}
void dvar4_array::allocate(ad_integer hsl, ad_integer hsu)
{
  if ((shape = new four_array_shape(hsl, hsu)) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  if ((t = new dvar3_array[hslicesize()]) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  int il = hsl;
  int iu = hsu;
  t -= il;

  dvar3_array* pti = t + il;
  for (int i = il; i <= iu; ++i)
  {
    pti->allocate();
    ++pti;
  }
}
void dvar4_array::allocate(
  int hsl, int hsu,
  int sl, int sh,
  const ivector& nrl, const ivector& nrh,
  const ivector& ncl, const ivector& nch)
{
  if ((shape = new four_array_shape(hsl, hsu)) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  if ((t = new dvar3_array[hslicesize()]) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  t -= hsl;
  dvar3_array* pti = t + hsl;
  for (int i = hsl; i <= hsu; ++i)
  {
    pti->allocate(sl, sh, nrl(i), nrh(i), ncl(i), nch(i));
    ++pti;
  }
}
 dvar4_array::dvar4_array(int hsl,int hsu,int sl,int sh,int nrl,
   int nrh,int ncl,int nch)
 {
   allocate(hsl,hsu,sl,sh,nrl,nrh,ncl,nch);
 }

 dvar4_array::dvar4_array(ad_integer hsl,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)
 {
   allocate(hsl,hsu,sl,sh,nrl,nrh,ncl,nch);
 }

 dvar4_array::dvar4_array(int hsl,int hsu, int sl,int sh,ivector nrl,
   ivector nrh,ivector ncl,ivector nch)
 {
   allocate(hsl,hsu,sl,sh,nrl,nrh,ncl,nch);
 }

void dvar4_array::initialize()
{
  if (!(!(*this)))  // only initialize allocated objects
  {
    int min = hslicemin();
    int max = hslicemax();
    dvar3_array* pti = t + min;
    for (int i = min; i <= max; ++i)
    {
       pti->initialize();
       ++pti;
    }
  }
}

dvar4_array::dvar4_array(int hsl, int hsu, int sl, const ivector& sh,
  int nrl, const imatrix& nrh, int ncl, int nch)
 {
   allocate(hsl,hsu,sl,sh,nrl,nrh,ncl,nch);
 }

void dvar4_array::allocate(
  int hsl, int hsu,
  int sl, const ivector& sh,
  int nrl, const imatrix& nrh,
  int ncl, int nch)
{
  //int rmin=nrh.rowmin();
  //int cmin=nrh(rmin).indexmin();
  if ((shape = new four_array_shape(hsl, hsu)) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  if ((t = new dvar3_array[hslicesize()]) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  t -= hsl;

  dvar3_array* pti = t + hsl;
  for (int i = hsl; i <= hsu; ++i)
  {
    pti->allocate(sl,sh(i),nrl,nrh(i),ncl,nch);
    ++pti;
  }
}

dvar4_array::dvar4_array(const d4_array& m1)
{
  allocate(m1);
  int min = hslicemin();
  int max = hslicemax();

  dvar3_array* pti = t + min;
  const d3_array* pm1i = &m1(min);
  for (int i = min; i <= max; ++i)
  {
    *pti = *pm1i;

    ++pti;
    ++pm1i;
  }
}

void dvar4_array::allocate(const d4_array& m1)
{
  int min = m1.hslicemin();
  int max = m1.hslicemax();
  if ((shape = new four_array_shape(min, max)) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  if ((t = new dvar3_array[hslicesize()]) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  t -= min;

  dvar3_array* pti = t + min;
  const d3_array* pm1i = &m1(min);
  for (int i = min; i <= max; ++i)
  {
    pti->allocate(*pm1i);
    ++pti;
    ++pm1i;
  }
}
void dvar4_array::allocate(const dvar4_array& m1)
{
  int min = m1.hslicemin();
  int max = m1.hslicemax();
  if ((shape = new four_array_shape(min, max)) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  if ((t = new dvar3_array[hslicesize()]) == 0)
  {
    cerr << " Error: dvar4_array unable to allocate memory in "
         << __FILE__ << ':' << __LINE__ << '\n';
    ad_exit(1);
  }
  t -= min;

  dvar3_array* pti = t + min;
  const dvar3_array* pm1i = &m1(min);
  for (int i = min; i <= max; ++i)
  {
    pti->allocate(*pm1i);
    ++pti;
    ++pm1i;
  }
}

/*
dvar4_array::dvar4_array(int hsl,int hsu, int sl, const ivector& sh,int nrl,
    const imatrix& nrh,int ncl,int nch)
  {
    allocate(hsl,hsu,sl,sh,nrl,nrh,ncl,nch);
  }

  void dvar4_array::allocate(int hsl,int hsu, int sl, const ivector& sh,int nrl,
    const imatrix& nrh,int ncl,int nch)
  {
   int rmin=nrh.rowmin();
   int cmin=nrh(nrh.rowmin()).indexmin;
   if ( (shape=new four_array_shape(hsl,hsu)) == 0)
   {
     cerr << " Error allocating memory in dvar4_array contructor\n";
   }
   int ss=hslicesize();
   if ( (t = new dvar3_array[ss]) == 0)
   {
     cerr << " Error allocating memory in dvar3_array contructor\n";
     ad_exit(21);
   }
   t -= hslicemin();
   for (int i=hsl; i<=hsu; i++)
   {
     (*this)(i).allocate(sl,sh(i),nrl,nrh(i),ncl,nch(i));
   }
 }
*/