STK_IArray2D.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2016  Serge Iovleff, Université Lille 1, Inria
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this program; if not, write to the
    Free Software Foundation, Inc.,
    59 Temple Place,
    Suite 330,
    Boston, MA 02111-1307
    USA
 
    Contact : S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
*/
 
/*
 * Project:  stkpp::Arrays
 * Purpose:  Define the Interface for the Array classes.
 * Author:   Serge Iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 *
 **/
 
#ifndef STK_IARRAY2D_H
#define STK_IARRAY2D_H
 
#include "STK_ArrayBase.h"
#include "STK_IContainer2D.h"
#include "STK_Array1D.h"
 
namespace STK
{
 
template < class Derived>
class IArray2D: protected IContainer2D<hidden::Traits<Derived>::sizeRows_, hidden::Traits<Derived>::sizeCols_>
              , public ArrayBase<Derived>
{
   // needed by merge
   template < class OtherDerived> friend class IArray2D;
 
  public:
    typedef typename hidden::Traits<Derived>::Type Type;
    typedef typename hidden::Traits<Derived>::TypeConst TypeConst;
 
    typedef typename hidden::Traits<Derived>::Row Row;
    typedef typename hidden::Traits<Derived>::Col Col;
    typedef typename hidden::Traits<Derived>::SubRow SubRow;
    typedef typename hidden::Traits<Derived>::SubCol SubCol;
    typedef typename hidden::Traits<Derived>::SubArray SubArray;
    // for 1D container
    typedef typename hidden::Traits<Derived>::SubVector SubVector;
 
    typedef typename hidden::Traits<Derived>::ColVector ColVector;
    typedef ColVector* PtrCol;
    typedef ColVector const* PtrColConst;
 
    enum
    {
      structure_ = hidden::Traits<Derived>::structure_,
      orient_    = hidden::Traits<Derived>::orient_,
      sizeRows_  = hidden::Traits<Derived>::sizeRows_,
      sizeCols_  = hidden::Traits<Derived>::sizeCols_,
      storage_   = hidden::Traits<Derived>::storage_
    };
    typedef TRange<sizeRows_> RowRange;
    typedef TRange<sizeCols_> ColRange;
    typedef IContainer2D<sizeRows_, sizeCols_ > Base2D;
    typedef MemAllocator<PtrCol, sizeCols_> Allocator;
    typedef ArrayBase<Derived> Base;
 
    using Base::elt;
    using Base2D::setCols;
    using Base2D::setRows;
 
  protected:
    IArray2D();
    IArray2D( Range const& I, Range const& J);
    IArray2D( IArray2D const& T, bool ref =false);
    template<class OtherDerived>
    IArray2D( IArray2D< OtherDerived> const& T, Range const& I, Range const& J);
    ~IArray2D();
 
  public:
    void clear();
    Derived& move(Derived const& T);
    void exchange(IArray2D &T);
 
    // getters
    inline bool isRef() const { return allocator_.isRef();}
    inline RowRange const& rowsImpl() const { return Base2D::rows();}
    inline ColRange const& colsImpl() const { return Base2D::cols();}
 
    inline RowRange const& rows() const { return Base2D::rows();}
    inline int beginRows() const { return Base2D::beginRows();}
    inline int endRows() const { return Base2D::endRows();}
    inline int sizeRows() const { return Base2D::sizeRows();}
 
    inline ColRange const& cols() const { return Base2D::cols();}
    inline int beginCols() const { return Base2D::beginCols();}
    inline int endCols() const { return Base2D::endCols();}
    inline int sizeCols() const { return Base2D::sizeCols();}
 
    inline int lastIdxCols() const { return Base2D::lastIdxCols();}
    inline int lastIdxRows() const { return Base2D::lastIdxRows();}
 
    inline bool empty() const { return Base2D::empty();}
 
    inline Allocator const& allocator() const { return allocator_;}
    inline PtrColConst ptr(int j) const { return allocator_.elt(j);}
    inline int availableCols() const { return allocator_.size();}
    inline int capacityCol(int col) const { return ptr(col) ? ptr(col)->capacity() : 0;}
    inline Array1D<Range, sizeCols_> const& rangeCols() const { return rangeCols_;}
    inline Range const& rangeCol(int col) const { return rangeCols_[col];}
 
    inline void setValueImpl( int j, TypeConst v)
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
      this->asDerived().setValue1D(j, v);
    }
    inline void setValueImpl( int i, int j, TypeConst v) { allocator_.elt(j)->setValue(i, v);}
 
    inline Type& elt2Impl( int i, int j) { return allocator_.elt(j)->elt(i);}
    inline TypeConst elt2Impl( int i, int j) const { return ptr(j)->elt(i);}
 
    // overloaded operators
    inline TypeConst operator()(int i, int j) const
    {
#ifdef STK_BOUNDS_CHECK
       if (beginRows() > i) { STKOUT_OF_RANGE_2ARG(IArray::elt, i, j, beginRows() > i);}
       if (endRows() <= i)  { STKOUT_OF_RANGE_2ARG(IArray::elt, i, j, endRows() <= i);}
       if (beginCols() > j) { STKOUT_OF_RANGE_2ARG(IArray::elt, i, j, beginCols() > j);}
       if (endCols() <= j)  { STKOUT_OF_RANGE_2ARG(IArray::elt, i, j, endCols() <= j);}
#endif
      return elt(i,j);
    }
    inline Type& operator()(int i, int j)
    {
#ifdef STK_BOUNDS_CHECK
       if (this->beginRows() > i) { STKOUT_OF_RANGE_2ARG(IArray2D::elt, i, j, beginRows() > i);}
       if (this->endRows() <= i)  { STKOUT_OF_RANGE_2ARG(IArray2D::elt, i, j, endRows() <= i);}
       if (this->beginCols() > j) { STKOUT_OF_RANGE_2ARG(IArray2D::elt, i, j, beginCols() > j);}
       if (this->endCols() <= j)  { STKOUT_OF_RANGE_2ARG(IArray2D::elt, i, j, endCols() <= j);}
#endif
      return elt(i,j);
    }
    inline TypeConst operator[](int i) const
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
#ifdef STK_BOUNDS_CHECK
      if (this->asDerived().begin() > i) { STKOUT_OF_RANGE_1ARG(IArray2D::elt, i, begin() > i);}
      if (this->asDerived().end() <= i)  { STKOUT_OF_RANGE_1ARG(IArray2D::elt, i, end() <= i);}
#endif
      return elt(i);
    }
    inline Type& operator[](int i)
    {
      STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
#ifdef STK_BOUNDS_CHECK
      if (this->asDerived().begin() > i) { STKOUT_OF_RANGE_1ARG(IArray2D::elt, i, begin() > i);}
      if (this->asDerived().end() <= i)  { STKOUT_OF_RANGE_1ARG(IArray2D::elt, i, end() <= i);}
#endif
      return elt(i);
    }
    inline TypeConst operator()() const { return elt();}
    inline Type& operator()() { return elt();}
 
    //slicing
    Col col( int j) const;
    SubCol col(Range const& I, int j) const;
    SubArray col(Range const& J) const;
    Row row( int i) const;
    SubRow row(int i, Range const& J) const;
    SubArray row(Range const& I) const;
    SubVector sub(Range const& J) const;
    SubArray sub(Range const& I, Range const& J) const;
    // overloaded operators for sub-arrays/vectors
    SubVector operator[](Range const& I) const;
    SubCol operator()(Range const& I, int j) const;
    SubRow operator()(int i, Range const& J) const;
    SubArray operator()(Range const& I, Range const& J) const;
    SubCol atCol(int j) const;
    Row atRow(int i) const;
 
    // modifiers
    void reserve(int sizeRows, int sizeCols);
    void reserveRows(int size);
    void reserveCols(int sizeCols);
 
    void shift( int rbeg, int cbeg);
    void shift( int beg);
    void shiftRows( int beg);
    void shiftCols(int cbeg);
 
    Derived& resize( Range const& I, Range const& J);
    Derived& resize( Range const& I);
 
    // rows
    void insertRows(int pos, int n =1);
    void eraseRows(int pos, int n=1);
    void pushFrontRows(int n =1);
    void pushBackRows( int n=1);
    void popFrontRows( int n = 1);
    void popBackRows( int n = 1);
    template<class Other>
    Derived& pushFrontRows(ExprBase<Other> const& other);
    template<class Other>
    Derived& pushBackRows(ExprBase<Other> const& other);
    // columns modifiers
    void insertCols(int pos, int n =1);
    void eraseCols(int pos, int n = 1);
    void pushFrontCols(int n =1);
    void pushBackCols(int n = 1);
    void popFrontCols( int n =1);
    void popBackCols( int n =1);
    template<class Other>
    Derived& pushFrontCols(ExprBase<Other> const& other);
    template<class Other>
    Derived& pushBackCols(IArray1D<Other> const& other);
 
    // modifiers, STL compatibility: for one dimension containers
    void push_front(Type const& v);
    void push_back(Type const& v);
    void insert( Range const& I, Type const& v);
    void erase(int pos, int n=1);
 
     // Useful
     void swapCols(int pos1, int pos2)
     {
 #ifdef STK_BOUNDS_CHECK
       if (this->beginCols() > pos1)
       { STKOUT_OF_RANGE_2ARG(IArray2D::swapCols,pos1, pos2,beginCols() >pos1);}
       if (this->endCols() <= pos1)
       { STKOUT_OF_RANGE_2ARG(IArray2D::swapCols,pos1, pos2,endCols() <= pos1);}
       if (this->beginCols() > pos2)
       { STKOUT_OF_RANGE_2ARG(IArray2D::swapCols,pos1, pos2,beginCols() >pos2);}
       if (this->endCols() <= pos2)
       { STKOUT_OF_RANGE_2ARG(IArray2D::swapCols,pos1, pos2,endCols() <=pos2);}
 #endif
       allocator_.swap(pos1, pos2);
       rangeCols_.swap(pos1,pos2);
     }
     void swap(int i, int  j)
     {
       STK_STATIC_ASSERT_ONE_DIMENSION_ONLY(Derived);
       std::swap(elt(i), elt(j));
     }
     template<class OtherDerived>
     void merge(IArray2D< OtherDerived> const& other)
     {
       //checks
       if (isRef())
       { STKRUNTIME_ERROR_NO_ARG(IArray2D::merge(other),*this is a reference.);}
       if (other.isRef())
       { STKRUNTIME_ERROR_NO_ARG(IArray2D::merge(other),other is a reference.);}
       // if there is no columns, we can safely modify the vertical range
       if (this->sizeCols() <= 0) setRows(other.rows());
       if (this->rows() != other.rows())
       { STKRUNTIME_ERROR_NO_ARG(IArray2D::merge(other),this->rows() != other.rows());}
 
       // break const reference
       IArray2D< OtherDerived>& Tref = const_cast<IArray2D< OtherDerived>&>(other);
       // compute horizontal range of the container after insertion
       Range cols(this->cols());
 
       // save first index of the first column added before modification of cols
       const int first = cols.end();
       // reallocate memory for the columns
       cols.incLast(Tref.sizeCols());
       reallocCols(cols);
 
       // copy data from other
       Tref.shiftCols(first); // easiest like that
       for (int j=first; j< cols.end(); j++)
       { transferCol(Tref, j);}
 
       // delete and set view on the data
       Tref.allocator().free();
       Tref.allocator().setPtr(allocator_.p_data(), Tref.cols(), true);
     }
     template<class OtherDerived>
     void merge(IArray1D<OtherDerived> const& other)
     {
       // checks
       if (isRef())
       { STKRUNTIME_ERROR_NO_ARG(IArray2D::merge(IArray1D),*this is a reference.);}
       if (other.isRef())
       { STKRUNTIME_ERROR_NO_ARG(IArray2D::merge(IArray1D),other is a reference.);}
       // if there is no columns, we can safely modify the vertical range
       if (this->sizeCols() <= 0) setRows(other.range());
       if (this->rows() != other.range())
       { STKRUNTIME_ERROR_NO_ARG(IArray2D::merge(IArray1D),this->rows() != other.range());}
 
       // compute horizontal range of the container after insertion
       Range cols(this->cols());
 
       // reallocate memory for the columns
       cols.incLast(1);
       reallocCols(cols);
 
       // set column
       allocator_.elt(cols.lastIdx()) = const_cast<OtherDerived*>(other.asPtrDerived());
       rangeCols_[cols.lastIdx()] = other.range();
 
       // set other as reference
       other.setRef(true);
     }
     void update(Range const& J)
     {
 #ifdef STK_BOUNDS_CHECK
       if (beginCols() > J.begin())
       { STKOUT_OF_RANGE_1ARG(IArray2D::update,J,beginCols() > J.begin());}
       if (endCols() < J.end())
       { STKOUT_OF_RANGE_1ARG(IArray2D::update,J,endCols() < J.end());}
 #endif
       for ( int icol = J.begin(); icol < J.end() ; ++icol)
       { update(icol);}
     }
     void update(int col)
     {
 #ifdef STK_BOUNDS_CHECK
       if (beginCols() > col)
       { STKOUT_OF_RANGE_1ARG(IArray2D::update,col,beginCols() > col);}
       if (this->lastIdxCols() < col)
       { STKOUT_OF_RANGE_1ARG(IArray2D::update,col,lastIdxCols() < col);}
 #endif
       if (this->rangeRowsInCol(col) != rangeCols_[col])
       { resizeRowCol(col, this->rangeRowsInCol(col));}
     }
 
  protected:
    Allocator allocator_;
    Array1D<Range, sizeCols_> rangeCols_;
 
    inline Allocator& allocator() { return allocator_;}
 
    void transferCol( int pos1, int pos2)
    {
      // copy by address pointer on column pos2 of T in pos1 of this
      allocator_.elt(pos1) = allocator_.elt(pos2);
      rangeCols_[pos1] = rangeCols_[pos2];
    }
    void reallocCols(Range const& J);
 
    void nullCols(ColRange const& J);
 
  private:
    void freeMem();
    void mallocCols(ColRange const& J);
    void initializeCols(Range const& J);
    void freeCols(Range const& J);
    void reserveRowsCols(Range const& J, int size);
    // single column methods
    void copyCol(IArray2D const& src, int j);
    template<class OtherDerived>
    void transferCol( IArray2D< OtherDerived>& T, int pos)
    {
      allocator_.elt(pos) = T.allocator_.elt(pos);
      rangeCols_[pos]     = T.rangeCols_[pos];
      T.nullCol(pos);
    }
    void nullCol(int col);
    void initializeCol(int col, Range const& I);
    void freeCol(int col);
    // modifiers
    void shiftRowCol( int col, int beg);
    void resizeRowCol( int col, Range const& I);
    void reserveRowCol( int col, int size);
    void insertRowsCol( int col, int pos, int n);
    void eraseRowsCol( int col, int pos, int n);
};
 
/* Default constructor */
template < class  Derived  >
IArray2D<Derived>::IArray2D(): Base2D(), Base()
                             , allocator_()
                             , rangeCols_()
{ mallocCols(this->cols());}
template < class  Derived  >
IArray2D<Derived>::IArray2D( Range const& I, Range const& J)
                           : Base2D(I,J), Base()
                           , allocator_()
                           , rangeCols_()
{  mallocCols(this->cols()); initializeCols(J);}
/* Copy constructor
 *  @param T the array to copy
 *  @param ref true if we wrap T
 **/
template < class  Derived  >
IArray2D<Derived>::IArray2D( IArray2D const& T, bool ref)
                           : Base2D(T), Base()
                           , allocator_(T.allocator_, ref)
                           , rangeCols_(T.rangeCols_, false) //  have to be created again, in case T is a temporary
{
  if (!ref)
  {
    initializeCols(T.cols()); // initialize the Columns
    for (int j=T.beginCols(); j<T.endCols(); j++)
    { copyCol(T, j);}
  }
}
/* constructor by reference, ref_=1.
 *  @param T the array to copy
 *  @param I,J ranges of the rows and columns to wrap
 **/
template < class  Derived  >
template<class OtherDerived>
IArray2D<Derived>::IArray2D( IArray2D<OtherDerived> const& T, Range const& I, Range const& J)
                           : Base2D(I,J), Base()
                           , allocator_(T.allocator_, J, true)  // a reference
                           , rangeCols_(T.rangeCols_, J, false) //  have to be created again, in case T is a temporary
                                          // T.rangeCols_ is itself a temporary that will be deleted
                                          // Tref(T.sub(J), true) for example
{
  for (int j=J.begin(); j<J.end(); j++)
  { rangeCols_[j] = inf(I, T.rangeCols()[j]);}
}
/* destructor.
 *  free the vertically allocated memory (the columns). The horizontally
 *  allocated memory is handled by the Allocator class.
 **/
template < class  Derived  >
IArray2D<Derived>::~IArray2D() { if (!isRef()) freeCols(cols());}
 
/* clear the object.
 *  This will free all allocated memory and reset all range to Range().
 *  (while freeMem() does not modify rows range (rows_)
 **/
template < class  Derived  >
void IArray2D<Derived>::clear()
{
  // Nothing to do for reference
  if (isRef()) return;
  freeMem();
  this->setRanges();
}
/* move T to this.
 *  @note : T is not modified but just set as a reference of the data it was responsible.
 *  @param T the array to move.
 **/
template < class  Derived  >
Derived& IArray2D<Derived>::move(Derived const& T)
{
  if (this->asPtrDerived() == &T) return this->asDerived();
  if (!isRef()) { freeCols(cols());}
  // move Base part
  allocator_.move(T.allocator_); // T become a reference
  rangeCols_.move(T.rangeCols_);
  // Set IContainer2D part
  setCols(T.cols());
  setRows(T.rows());
  return this->asDerived();
}
/* exchange this container with T.
 *  @param T the container to exchange with this
 **/
template < class  Derived  >
void IArray2D<Derived>::exchange(IArray2D &T)
{
  // swap MemAllocator part
  allocator_.exchange(T.allocator_);
  Base2D::exchange(T);
  rangeCols_.exchange(T.rangeCols_);
}
 
/* @brief Internal method for memory deallocation.
 *  This method clear all allocated memory and reset ranges to default value.
 *  Do nothing if this is a reference
 *  Range of the columns is set to default.
 *  Range of the rows (rows_) remains unmodified.
 **/
template< class Derived>
void IArray2D< Derived>::freeMem()
{
  if (isRef()) return;
  freeCols(cols());
  // free memory allocated in allocator.
  // For fixed size arrays, the size remain the same
  allocator_.free();
  setCols(allocator_.range());
  // clear arrays
  rangeCols_.resize(cols());
}
/* Method for memory allocation and initialization of the horizontal
 *  range of the container.
 *  The vertical range is not set in this method. If an
 *  error occur, we set the cols_ of the container to default.
 *  @param J horizontal range
 **/
template< class Derived>
void IArray2D< Derived>::mallocCols(ColRange const& J)
{
  // try to allocate memory
  try
  {
    if (J.size() > availableCols())
    {
      // compute the necessary size
      int size= Arrays::evalSizeCapacity(J.size());
      allocator_.malloc(Range(J.begin(), size)); // allocate memory for the columns
    }
    else
    { allocator_.shift(J.begin());}
    rangeCols_.resize(J);
  }
  catch (Exception const& error)   // if an error occur
  {
    Base2D::setCols();      // set default range
    rangeCols_.clear();     // clear this->rangeCols_
    allocator_.free();      // initialize with zero
    allocator_.setValue(0); // initialize with zero
    throw error;            // throw the error
  }
  allocator_.setValue(0); // initialize with zero
}
/* @brief Internal method for memory allocation and initialization of a range of columns.
 *  The capacity for the rows have to be set before calling this method.
 *  @param J vertical range of the Columns to initialize
 **/
template< class Derived>
void IArray2D< Derived>::initializeCols(Range const& J)
{
#ifdef STK_BOUNDS_CHECK
if (beginCols() > J.begin())
{ STKOUT_OF_RANGE_1ARG(IArray2D::initializeCols, J, beginCols() > J.begin());}
if (endCols() < J.end())
{ STKOUT_OF_RANGE_1ARG(IArray2D::initializeCols, J, endCols() < J.end());}
#endif
  for (int j=J.begin(); j<J.end(); j++)
  {
    try
    { initializeCol(j, this->rangeRowsInCol(j));}
    catch (Exception const& error) // if an error occur
    {
      // free each column allocated and throw exception
      for (int k=J.begin(); k<j; k++) freeCol(k);
      throw error;
    }
  }
}
/* @brief Internal method for releasing memory in a given range of columns.
 *  @param J range of columns to liberate.
 **/
template< class Derived>
void IArray2D< Derived>::freeCols(Range const& J)
{ for (int j=J.begin(); j<J.end(); j++) { freeCol(j);}}
/* copy column j of src into column j of this
 *  @param src source to copy
 *  @param j index of the columns to copy
 **/
template< class Derived>
void IArray2D< Derived>::copyCol(IArray2D const& src, int j)
{
  PtrCol dp =allocator_.elt(j), sp =src.allocator_.elt(j);
  dp->assign(*sp);
}
 
/* Method for memory reallocation and initialization of the horizontal
 *  range of the container.
 *  The vertical range is not set in this method. If an
 *  error occur, we set the cols_ of the container to default.
 *  @param J horizontal range
 **/
template< class Derived>
void IArray2D< Derived>::reallocCols(Range const& J)
{
  Range oldRange(cols());
  // try to allocate memory
  if (J.size() > availableCols())
  {
    int size= Arrays::evalSizeCapacity(J.size());
    Range newRange(J.begin(), size);
    allocator_.realloc( newRange ); // reallocate memory for the columns
  }
  rangeCols_.resize(J);        // initialize this->rangeCols_
  setCols(J);
}
 
/* Internal method for initializing to default values (null pointer and null range)
 *  to a range of columns.
 *  @param J horizontal range
 **/
template< class Derived>
void IArray2D< Derived>::nullCols(ColRange const& J)
{
#ifdef STK_BOUNDS_CHECK
  if (beginCols() > J.begin())
  { STKOUT_OF_RANGE_1ARG(IArray2D::nullCols, J, beginCols() > J.begin());}
  if (endCols() < J.end())
  { STKOUT_OF_RANGE_1ARG(IArray2D::nullCols, J, endCols() < J.end());}
#endif
  for (int j=J.begin(); j<J.end(); ++j) { nullCol(j);}
}
/* Internal method setting default parameters and dimension to a column of the container.
 *  @param col the position of the column to initialize to a default value.
 *  @note if data is allocated, it will be lost
 **/
template< class Derived>
void IArray2D< Derived>::nullCol(int col)
{
  allocator_.elt(col) = 0;
  rangeCols_[col] = Range();
}
 
/* @brief Internal method for initializing a column.
 *  Method for the the allocation of memory of the column col with range I.
 *  @param col,I index and range of the column to initialize
 **/
template< class Derived>
void IArray2D< Derived>::initializeCol(int col, Range const& I)
{
#ifdef STK_DEBUG_ARRAY2D
  stk_cout << _T("Entering initializeCol\n");
  stk_cout << _T("Initialize col=") << col <<_T(", I=") << I <<_T("\n");
#endif
  if (I.size() <=0)
  {
    allocator_.elt(col) = 0;
    rangeCols_[col] = I;
    return;
  }
  // try to allocate memory
  try
  { allocator_.elt(col) = new ColVector(I);}
  catch (std::bad_alloc & error)  // if an alloc error occur
  {
    allocator_.elt(col) = 0;
    rangeCols_[col] = Range();
    STKRUNTIME_ERROR_2ARG(IArray2D::initializeCol,col, I,memory allocation failed.);
  }
  rangeCols_[col] = I;
}
/* @brief Internal method for memory deallocation.
 *  @param col the number of the column to free
 **/
template< class Derived>
void IArray2D< Derived>::freeCol(int col)
{
#ifdef STK_DEBUG_ARRAY2D
  stk_cout << _T("Entering freeCol\n");
  stk_cout << _T("Deleting col=") << col <<_T(", rangeCols_[col]=") << rangeCols_[col] <<_T("\n");
  stk_cout << _T("allocator_.elt(col)=") << allocator_.elt(col) <<_T("\n");
#endif
  if (allocator_.elt(col)) // if there is a column at this position
  {
    delete allocator_.elt(col);
    allocator_.elt(col) =0;
    rangeCols_[col] = Range();
  }
}
 
} // namespace STK
 
#endif
// STK_IARRAY2D_H