Matrizen

rewe

Wie kann ich am einfachsten Matrizen speichern (in C++)?

Anfoderungen:
- beliebige Matrix speichern (m x n)
- Matrix element kann ebenfalls beliebig sein

Gibt's irgendwo eine Klasse im Inet die das kann?
Oder kann das eine Lib (Boost?)?

Oder muss ich selber eine Klasse dafür schreiben? Falls so, wie mache ich das?

Danke und Gruss

Hier mal auszüge meiner Version:

#ifndef MATRIX_H
#define MATRIX_H

template <class T> class Matrix;

#include <vector>
#include <fstream>
#include <iostream>
#include <string>
#include "Myerror.h"
#include "Vector.h"

using namespace std;

template <class T>
class Matrix {

  public:
    typedef T value_type;

  private:
    size_type _rows;
    size_type _cols;
    T* _data;
    void resize(size_type i, size_type j) {_rows=i; _cols=j;}
    T* data () { return (_data); }

  public:

    // constructors/destructors
    Matrix() : _rows (0), _cols (0), _data (0) {}
    Matrix(size_type& i, size_type& j) : _rows (i), _cols (j), _data (new T [size()]) {initialize((T)(0));}
    Matrix(int i, int j) : _rows (size_type(i)), _cols (size_type(j)), _data (new T [size()]) {}
    Matrix (size_type N, size_type M, const T& t=T()) : _rows (N), _cols (M), _data (new T [size()]) { initialize(t); }
    Matrix (const Matrix& X) : _rows (X.Rows()), _cols (X.Cols()), _data (new T [size()]) {
		for (int i = 0; i < Rows(); ++i)
			{for (int j = 0; j < Cols(); ++j)
				{operator()(i,j) = X(i,j);}
			}
		}
    ~Matrix () { delete [] _data; }

    // initialize Elements
    void initialize(const T& t) {
        for (int i = 0; i < Rows(); ++i)
	    {for (int j = 0; j < Cols(); ++j)
		{operator()(i,j) = t;}
	    }
	}

    // Matrix-dimensions
    inline size_type Rows() const { return _rows; }
    inline size_type Cols() const { return _cols; }
    inline size_type size() const { return _rows * _cols; }

    // Access to elements
    const T& operator() (const size_type& i, const size_type& j) const
	    { return _data [i*_cols + j]; }

    T& operator() (const size_type& i, const size_type& j)
	    { return _data [i*_cols + j]; }

    // Zugriff auf Zeilen,Spalten,Diagonale
    ...

    // Matrix-Matrix Operatoren

    Matrix<T> operator+(const Matrix& m) {
	if ((Rows()!=m.Rows())||(Cols()!=m.Cols())) {throw DimensionClash();}
        Matrix<T> res(m.Rows(),m.Cols());
	for (int i=0;i<m.Rows();i++) 
	    { for (int j=0;j<m.Cols();j++)
		{ res(i,j)=(operator()(i,j))+m(i,j); }
	    }
	return res;
	}
    ...

    // I/O - Operatoren/Methoden
    ostream& StoreASCII(ostream& ost) const {
	ost << _rows << 'x' << _cols << endl;
	for (int i = 0; i < Rows(); ++i)
	    {for (int j = 0; j < Cols(); ++j)
	         {ost << operator()(i,j) << ' ';}
	     ost << endl;
	    }
	return ost;
	}
    ...

    // Iteratoren
    iterator begin () { return _data; }
    ...

    }; // end of class Matrix<T>

Viel Spaß!

rewe

Ist dein Code komplett? Oder fehlt da noch Code?

Gibt es eine Art "Standard" Matrix Implementation, die sich durchgesetzt hat?

Fehlt einiges. Soll nur das Prinzip verdeutlichen.

#include "Myerror.h"
#include "Vector.h"

Die beiden Dateien hast du zum Beispiel nicht (sind nämlich von mir). Damit gibt es auch die DimensionClash-Exception nicht.

Gruß LIBS

rüdiger

Es gibt doch bereits zahlreiche fertige und von guten Entwicklern entworfene Librarys dazu. Warum nimmst du nicht einfach die

http://www.oonumerics.org/blitz/
http://www.boost.org/libs/numeric/ublas/doc/index.htm