---

mmatrix.h

/***************************************************************************
    copyright            : (C) 2000 by Marko Grönroos
    email                : magi@iki.fi
 ***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************
 *
 **/

#ifndef __MATRIX_H__
#define __MATRIX_H__

#include "magic/mobject.h"
#include "magic/mtable.h"

class Matrix : public PackTable<double> {
  public:
                    Matrix          () : PackTable<double> () {;}
                    Matrix          (int rows, int cols) : PackTable<double> (rows, cols) {}
                    Matrix          (const Matrix& o) : PackTable<double> (o) {;}
                    ~Matrix         () {}

    void            make            (int rs, int cs) {
        PackTable<double>::make (rs, cs);
        operator= (0.0);
    }

    void            load            (const String& filename);

    void            load            (FILE* in);

    void            save            (FILE* out) const;
    
    const Matrix&   transpose       ();
    const Matrix&   multiplyToSum   (double s);
    double          sum             () const;

    void            splitVertical   (Matrix& a, Matrix& b, int column) const;
    void            splitHorizontal (Matrix& a, Matrix& b, int column) const;

    Matrix          sub             (int row0, int row1, int col0, int col1) const;
    void            insertColumn    (int cols);
    
    enum iters {end=-1};

    void            joinVertical    (const Matrix& a, const Matrix& b);
    void            joinHorizontal  (const Matrix& a, const Matrix& b);
    
    const Matrix&   operator=       (double x);
    const Matrix&   operator+=      (const Matrix& other);
    const Matrix&   operator+       (const Matrix& other) const {return Matrix(*this)+=other;}
    const Matrix&   operator+=      (double k);
    const Matrix&   operator+       (double k) const {return Matrix(*this)+=k;}
    const Matrix&   operator*=      (const Matrix& other);
    const Matrix&   operator*       (const Matrix& other) const {return Matrix(*this)*=other;}
    const Matrix&   operator*=      (double k);
    const Matrix&   operator*       (double k) const {return Matrix(*this)*=k;}
    const Matrix&   operator/       (double k) const {return Matrix(*this)*=1/k;}
    const Matrix&   operator/=      (double k) {return operator *= (1/k);}

    void            operator>>      (OStream& out) const;
    const Matrix&   operator= (const Matrix& other);

  private:
};

inline Matrix transpose (const Matrix& m) {
    Matrix res = m;
    res.transpose ();
    return res;
}

/*
class SubMatrix : public Matrix {
    Matrix& matrix;
    int srow, scol, erow, ecol;
  public:
                    SubMatrix       (Matrix& m, int sr, int sc, int er, int ec) : matrix (m) {
                        ASSERT (sr<m.rows);
                        ASSERT (sc<m.cols);
                        ASSERT (er<m.rows);
                        ASSERT (ec<m.cols);
                        ASSERT (sr<=er);
                        ASSERT (sc<=ec);
                        srow=sr, scol=sc, erow=er, ecol=ec;
                        rows = erow-srow+1;
                        cols = ecol-scol+1;
                    }
    double&         get             (int row, int col);
};
*/

#endif

---