matrix.cpp

Go to the documentation of this file.

#ifndef MATRIX_IMPLEMENTATION
#define MATRIX_IMPLEMENTATION

/*****************************************************************************\
*                                                                             *
*  Name   : matrix                                                            *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1993-$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                               *
\*****************************************************************************/

#include "matrix.h"

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

//hmmm: the operations for zapping use extra memory.  they could easily
//      be done as in-place copies.

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

template <class contents>
matrix<contents>::matrix(int r, int c, contents *dat)
: array<contents>(r*c, dat), _rows(r), _cols(c) {}

template <class contents>
matrix<contents>::matrix(const matrix<contents> &to_copy)
: array<contents>(0), _rows(0), _cols(0)
{ *this = to_copy; }

template <class contents>
matrix<contents> &matrix<contents>::operator = (const matrix &to_copy)
{
  if (&to_copy == this) return *this;
  array<contents>::operator = (to_copy);
  _rows = to_copy._rows;
  _cols = to_copy._cols;
  return *this;
}

template <class contents>
contents *matrix<contents>::operator[] (int r)
{ return &array<contents>::operator [] (compute_index(r, 0)); }

template <class contents>
const contents *matrix<contents>::operator[] (int r) const
{ return &array<contents>::operator [] (compute_index(r, 0)); }

template <class contents>
const contents &matrix<contents>::get(int r, int c) const
{ return array<contents>::get(compute_index(r, c)); }

template <class contents>
contents &matrix<contents>::get(int row, int column)
{ return array<contents>::operator [] (compute_index(row, column)); }

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

template <class contents>
void matrix<contents>::reset(int rows_in, int columns_in)
{
  if ( (_rows == rows_in) && (_cols == columns_in) ) {
    // reuse space, but reset the objects to their initial state.
    for (int i = 0; i < array<contents>::length(); i++)
      array<contents>::operator [](i) = contents();
    return;
  }

  _rows = 0;
  _cols = 0;
  array<contents>::reset(0);

  this->insert(0, rows_in * columns_in);
  _rows = rows_in;
  _cols = columns_in;
}

template <class contents>
void matrix<contents>::redimension(int new_rows, int new_columns)
{
  if ( (_rows == new_rows) && (_cols == new_columns) ) return;
  matrix<contents> new_this(new_rows, new_columns);
  for (int r = 0; r < minimum(new_rows, rows()); r++)
    for (int c = 0; c < minimum(new_columns, columns()); c++)
      new_this[r][c] = (*this)[r][c];
  *this = new_this;
}

template <class contents>
bool matrix<contents>::put(int row, int column, const contents &to_put)
{
  if ( (row >= rows()) || (column >= columns()) )
    return false;
  (operator [](row))[column] = to_put;
  return true;
}

template <class contents>
matrix<contents> matrix<contents>::submatrix(int row, int column, int rows_in,
    int columns_in) const
{
  matrix<contents> to_return;
  submatrix(to_return, row, column, rows_in, columns_in);
  return to_return;
}

template <class contents>
void matrix<contents>::submatrix(matrix<contents> &sub, int row, int column,
    int rows_in, int columns_in) const
{
  sub.reset();
  if ( (row >= rows()) || (row + rows_in >= rows()) ) return;
  if ( (column >= columns()) || (column + columns_in >= columns()) ) return;
  sub.reset(rows_in, columns_in);
  for (int r = row; r < row + rows_in; r++)
    for (int c = column; c < column + columns_in; c++)
      sub[r - row][c - column] = (*this)[r][c];
}

template <class contents>
matrix<contents> matrix<contents>::transpose() const
{
  matrix<contents> to_return;
  transpose(to_return);
  return to_return;
}

template <class contents>
void matrix<contents>::transpose(matrix<contents> &resultant) const
{
  resultant.reset(columns(), rows());
  for (int i = 0; i < rows(); i++)
    for (int j = 0; j < columns(); j++)
      resultant[j][i] = (*this)[i][j];
}

template <class contents>
array<contents> matrix<contents>::get_row(int row)
{
  array<contents> to_return;
  if (row >= rows()) return to_return;
  to_return.reset(columns());
  for (int i = 0; i < columns(); i++)
    to_return[i] = get(row, i);
  return to_return;
}

template <class contents>
array<contents> matrix<contents>::get_column(int column)
{
  array<contents> to_return;
  if (column >= columns()) return to_return;
  to_return.reset(rows());
  for (int i = 0; i < rows(); i++)
    to_return[i] = get(i, column);
  return to_return;
}

template <class contents>
bool matrix<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.
  array<contents>::zap(start, start + columns() - 1);
  _rows--;
  return true;
}

template <class contents>
bool matrix<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);
    array<contents>::zap(loc, loc);
  }
  _cols--;
  return true;
}

template <class contents>
bool matrix<contents>::insert_row(int position)
{
  FUNCDEF("insert_row");
  bounds_halt(position, 0, rows(), false);
  // see comment in zap_row for reasoning about the below.
  array<contents>::insert(compute_index(position, 0), columns());
  _rows++;
  // clear out those spaces.
  for (int c = 0; c < columns(); c++)
    put(position, c, contents());
  return true;
}

template <class contents>
bool matrix<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--)
    array<contents>::insert(compute_index(r, position), 1);
  _cols++;
  // clear out those spaces.
  for (int r = 0; r < rows(); r++) 
    put(r, position, contents());
  return true;
}

#undef static_class_name

#endif

---