imat.cpp

Go to the documentation of this file.

#include "fvar.hpp"
#ifdef __TURBOC__
  #pragma hdrstop
#endif

void imatrix::rowshift(int min)
{
  if (m == nullptr)
  {
    cerr << "Warning -- Trying to row shift empty imatrix in "
         << "imatrix::rowshift(int).\n";
    return;
  }
  m = m + rowmin() - min;
  index_max += min - index_min;
  index_min = min;
}
imatrix::imatrix(int nrl, int nrh)
{
  allocate(nrl, nrh);
}

 imatrix imatrix::sub(int nrl,int nrh)
 {
   if (allocated(*this))
   {
     imatrix tmp(nrl,nrh);
     for (int i=nrl; i<=nrh; i++)
     {
       tmp[i].shallow_copy((*this)(i));
     }
     return tmp;
   }
   else
   {
     return *this;
   }
 }
imatrix::imatrix(int nrl, int nrh, int ncl, int nch)
{
  allocate(nrl, nrh, ncl, nch);
}
 imatrix::imatrix(const ad_integer& nrl,const ad_integer& nrh,
   const index_type& ncl,const index_type& nch)
 {
   allocate(nrl,nrh,ncl,nch);
 }
imatrix::imatrix(int nrl, int nrh, const ivector& column)
{
  allocate(nrl, nrh, column);
}
void imatrix::allocate(int nrl, int nrh, const ivector& column)
{
  allocate(nrl, nrh);
  for (int i = rowmin(); i <= rowmax(); ++i)
  {
    m[i].index_min = column.index_min;
    m[i].index_max = column.index_max;
    m[i].shape = column.shape;
    if (m[i].shape)
    {
      (m[i].shape->ncopies)++;
      m[i].v = column.v;
    }
  }
}
void imatrix::allocate(int nrl, int nrh, int ncl, int nch)
{
  allocate(nrl, nrh);
  ivector* pv = m + nrl;
  for (int i = nrl; i <= nrh; ++i)
  {
    pv->allocate(ncl, nch);
    ++pv;
  }
}
void imatrix::allocate()
{
  index_min = 1;
  index_max = 0;
  m = nullptr;
  shape = nullptr;
}
void imatrix::allocate(int nrl, int nrh, const ivector& ncl, const ivector& nch)
{
  allocate(nrl, nrh);
  ivector* pv = m + nrl;
  int* pncli = ncl.get_v() + nrl;
  int* pnchi = nch.get_v() + nrl;
  for (int i = nrl; i <= nrh; ++i)
  {
    pv->allocate(*pncli, *pnchi);
    ++pv;
    ++pncli;
    ++pnchi;
  }
}
void imatrix::allocate(int nrl, int nrh, int ncl, const ivector& nch)
{
  allocate(nrl, nrh);
  ivector* pv = m + nrl;
  int* pnchi = nch.get_v() + nrl;
  for (int i = nrl; i <= nrh; ++i)
  {
    pv->allocate(ncl, *pnchi);
    ++pv;
    ++pnchi;
  }
}
imatrix::imatrix(const imatrix& other)
{
  shallow_copy(other);
}
void imatrix::shallow_copy(const imatrix& other)
{
  if (other.shape)
  {
    shape = other.shape;
    ++(shape->ncopies);
    m = other.m;
    index_min = other.index_min;
    index_max = other.index_max;
  }
  else
  {
#ifdef DEBUG
    cerr << "Warning -- Unable to shallow copy an unallocated imatrix.\n";
#endif
    allocate();
  }
}

imatrix::imatrix(int nrl, int nrh, const ivector& ncl, const ivector& nch)
 {
   allocate(nrl,nrh,ncl,nch);
 }

imatrix::imatrix(int nrl, int nrh, int ncl, const ivector& nch)
 {
   allocate(nrl,nrh,ncl,nch);
 }

imatrix::imatrix()
{
  allocate();
}
imatrix::~imatrix()
{
  deallocate();
}
void imatrix::deallocate()
{
  if (shape)
  {
    if (shape->ncopies > 0)
    {
      --(shape->ncopies);
    }
    else
    {
      m = static_cast<ivector*>(shape->get_pointer());
      delete [] m;
      delete shape;
    }
    allocate();
  }
#if defined(DIAG)
  else
  {
    cerr << "Warning -- Unable to deallocate an unallocated imatrix.\n";
  }
#endif
}

void imatrix::allocate(int nrl, int nrh)
{
  if (nrl > nrh)
  {
    return allocate();
  }
  index_min = nrl;
  index_max = nrh;
  if ((m = new ivector[rowsize()]) == 0)
  {
    cerr << "Error: Unable to allocate m in imatrix::allocate(int, int).\n";
    ad_exit(1);
  }
  if ((shape = new mat_shapex(m)) == 0)
  {
    cerr << "Error: Unable to allocate shape in imatrix::allocate(int, int).\n";
    ad_exit(1);
  }
  m -= indexmin();
}