mat_morph.cpp

Go to the documentation of this file.

#ifndef MAT_MORPH_IMPLEMENTATION
#define MAT_MORPH_IMPLEMENTATION

/*****************************************************************************\
*                                                                             *
*  Name   : mat_morph                                                         *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2003-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

// notes:
//   thanks to aaron buchanan for the insert_row and insert_column methods
// and for assorted clean-ups.

#include "amorph.cpp"
#include "mat_morph.h"

#include <basis/function.h>
#include <basis/guards.h>

#undef static_class_name
#define static_class_name() "mat_morph"
  // used in bounds_halt macro.

template <class contents>
mat_morph<contents>::mat_morph(int r, int c)
: amorph<contents>(r*c), _rows(r), _cols(c) {}

template <class contents>
const contents *mat_morph<contents>::get(int r, int c) const
{ return amorph<contents>::get(compute_index(r, c)); }

template <class contents>
contents *mat_morph<contents>::get(int row, int column)
{ return amorph<contents>::operator [] (compute_index(row, column)); }

template <class contents>
contents *mat_morph<contents>::acquire(int r, int c)
{ return amorph<contents>::acquire(compute_index(r, c)); }

template <class contents>
int mat_morph<contents>::compute_index(int row, int column) const
{ return column + row * _cols; }

template <class contents>
void mat_morph<contents>::reset(int rows_in, int columns_in)
{
  amorph<contents>::clear_all();
  amorph<contents>::reset(rows_in * columns_in);
  _rows = rows_in;
  _cols = columns_in;
}

template <class contents>
void mat_morph<contents>::redimension(int new_rows, int new_columns)
{
  if ( (_rows == new_rows) && (_cols == new_columns) ) return;
  mat_morph<contents> new_this(new_rows, new_columns);
  int min_rows = minimum(new_rows, rows());
  int min_cols = minimum(new_columns, columns());
  for (int r1 = 0; r1 < min_rows; r1++)
    for (int c1 = 0; c1 < min_cols; c1++) {
      new_this.put(r1, c1, amorph<contents>::acquire(compute_index(r1, c1)));
    }
  amorph<contents>::reset(new_rows * new_columns);
  _rows = new_rows;
  _cols = new_columns;
  for (int r2 = 0; r2 < min_rows; r2++) {
    for (int c2 = 0; c2 < min_cols; c2++) {
      amorph<contents>::put(compute_index(r2, c2), new_this.acquire(r2, c2));
    }
  }
}

template <class contents>
bool mat_morph<contents>::put(int row, int column, const contents *to_put)
{
  if ( (row >= rows()) || (column >= columns()) )
    return false;
  amorph<contents>::put(compute_index(row, column), to_put);
  return true;
}

template <class contents>
bool mat_morph<contents>::zap_row(int row_to_zap)
{
  FUNCDEF("zap_row");
  bounds_halt(row_to_zap, 0, rows() - 1, false);
  const int start = compute_index(row_to_zap, 0);
  // this is only safe because the indices are stored in row-major order (which
  // i hope means the right thing).  in any case, the order is like so:
  //   1 2 3 4
  //   5 6 7 8
  // thus we can whack a whole row contiguously.
  amorph<contents>::zap(start, start + columns() - 1);
  _rows--;
  return true;
}

template <class contents>
bool mat_morph<contents>::zap_column(int column_to_zap)
{
  FUNCDEF("zap_column");
  bounds_halt(column_to_zap, 0, columns() - 1, false);
  // this starts at the end, which keeps the indexes meaningful.  otherwise
  // the destruction interferes with finding the elements.
  for (int r = rows(); r >= 0; r--) {
    const int loc = compute_index(r, column_to_zap);
    amorph<contents>::zap(loc, loc);
  }
  _cols--;
  return true;
}

template <class contents>
bool mat_morph<contents>::insert_row(int position)
{
  FUNCDEF("insert_row");
  bounds_halt(position, 0, rows(), false);
  // see comment in zap_row for reasoning about the below.
  amorph<contents>::insert(compute_index(position, 0), columns());
  _rows++;
  return true;
}

template <class contents>
bool mat_morph<contents>::insert_column(int position)
{
  FUNCDEF("insert_column");
  bounds_halt(position, 0, columns(), false);
  // similarly to zap_column, we must iterate in reverse.
  for (int r = rows(); r >= 0; r--)
    amorph<contents>::insert(compute_index(r, position), 1);
  _cols++;
  return true;
}

#undef static_class_name

#endif

---