DMatrix.h

Go to the documentation of this file.

// -*- mode: c++; indent-tabs-mode: nil; c-basic-offset: 4; coding: iso-8859-1; -*-

/*
ACT-CV - Machine Vision for Cognitive Modeling
Copyright (c) 2008 Marc Halbruegge

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 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/


#ifndef __DMATRIX_H
#define __DMATRIX_H

#include <iostream>
#include <cmath>

template<unsigned int zeilen, unsigned int spalten>
class DMatrix;
template<unsigned int dims>
double Len(const DMatrix<dims, 1> &p);


template<unsigned int zeilen, unsigned int spalten>
class DMatrix {
public:
    double x[zeilen][spalten];
    
    DMatrix() {}
    
    explicit DMatrix(double d) {
        x[0][0]=d;
    }

    explicit DMatrix(double d0, double d1) {
        x[0][0]=d0;
        x[1][0]=d1;
    }

    void Zero() {
        for (unsigned int i=0;i<zeilen;i++)
            for (unsigned int j=0;j<spalten;j++)
                x[i][j]=0.0;
    }

    void Normalize() {
        double len=Len(*this);
        if (len>0.0) *this /= len;
    }

    DMatrix<zeilen,spalten>& operator = (const DMatrix<zeilen,spalten> &m) {
        for (unsigned int i=0;i<zeilen;i++)
            for (unsigned int j=0;j<spalten;j++)
                x[i][j]=m.x[i][j];
        return *this;
    }

    DMatrix<zeilen,spalten>& operator += (const DMatrix<zeilen,spalten> &m) {
        for (unsigned int i=0;i<zeilen;i++)
            for (unsigned int j=0;j<spalten;j++)
                x[i][j]+=m.x[i][j];
        return *this;
    }

    DMatrix<zeilen,spalten>& operator -= (const DMatrix<zeilen,spalten> &m) {
        for (unsigned int i=0;i<zeilen;i++)
            for (unsigned int j=0;j<spalten;j++)
                x[i][j]-=m.x[i][j];
        return *this;
    }

    DMatrix<zeilen,spalten> operator * (double d) const {
        DMatrix<zeilen,spalten> result;
        for (unsigned int i=0;i<zeilen;i++)
            for (unsigned int j=0;j<spalten;j++)
                result.x[i][j]=x[i][j]*d;
        return result;
    }


    DMatrix<zeilen,spalten>& operator *= (double d) {
        for (unsigned int i=0;i<zeilen;i++)
            for (unsigned int j=0;j<spalten;j++)
                x[i][j]*=d;
        return *this;
    }

    DMatrix<zeilen,spalten> operator / (double d) const {
        DMatrix<zeilen,spalten> result;
        for (unsigned int i=0;i<zeilen;i++)
            for (unsigned int j=0;j<spalten;j++)
                result.x[i][j]=x[i][j]/d;
        return result;
    }

    DMatrix<zeilen,spalten>& operator /= (double d) {
        for (unsigned int i=0;i<zeilen;i++)
            for (unsigned int j=0;j<spalten;j++)
                x[i][j]/=d;
        return *this;
    }


    DMatrix<zeilen,spalten> operator + (const DMatrix<zeilen,spalten> &m) const {
        DMatrix<zeilen,spalten> result;
        for (unsigned int i=0;i<zeilen;i++)
            for (unsigned int j=0;j<spalten;j++)
                result.x[i][j]=x[i][j]+m.x[i][j];
        return result;
    }

    DMatrix<zeilen,spalten> operator - (const DMatrix<zeilen,spalten> &m) const {
        DMatrix<zeilen,spalten> result;
        for (unsigned int i=0;i<zeilen;i++)
            for (unsigned int j=0;j<spalten;j++)
                result.x[i][j]=x[i][j]-m.x[i][j];
        return result;
    }

    double* operator[](unsigned int row) {
        return x[row];
    }

#if 1
    const double* operator[](unsigned int row) const {
        return x[row];
    }
#endif

    DMatrix<spalten,zeilen> T() const {
        DMatrix<spalten,zeilen> result;
        for (unsigned int i=0;i<zeilen;i++)
            for (unsigned int j=0;j<spalten;j++)
                result[j][i] = x[i][j];
        return result;
    }
};

// unary minus
template<unsigned int zeilen, unsigned int spalten>
DMatrix<zeilen,spalten> operator - (const DMatrix<zeilen,spalten> &m) {
    DMatrix<zeilen,spalten> result;
    for (unsigned int i=0;i<zeilen;i++)
        for (unsigned int j=0;j<spalten;j++)
            result[i][j]=-m[i][j];
    return result;
}

template<unsigned int zeilen, unsigned int spalten>
std::ostream& operator << (std::ostream &o, const DMatrix<zeilen,spalten> &m) {
    for (unsigned int i=0;i<zeilen;i++) {
        for (unsigned int j=0;j<spalten;j++) {
            o << m[i][j];
            if (i+1<zeilen || j+1<spalten) o << " ";
        }
        //o << endl;
    }
    return o;
}

template<unsigned int zeilen, unsigned int spalten>
std::istream& operator >> (std::istream &in, DMatrix<zeilen,spalten> &m) {
    for (unsigned int i=0;i<zeilen;i++) {
        for (unsigned int j=0;j<spalten;j++) {
            in >> m.x[i][j];
        }
    }
    return in;
}

template<unsigned int l, unsigned int m, unsigned int n>
DMatrix<l,n> operator * (const DMatrix<l,m> &a, const DMatrix<m,n> &b) {
    DMatrix<l,n> result;
    for (unsigned int i=0;i<l;i++) {
        for (unsigned int j=0;j<n;j++) {
            result.x[i][j]=0;
            for (unsigned int k=0;k<m;k++){
                result.x[i][j]+=a.x[i][k]*b.x[k][j];
            }
        }
    }
    return result;
}

// vc6 - Workaround
template<unsigned int l, unsigned int m, unsigned int n>
DMatrix<l,n> Multiply (const DMatrix<l,m> &a, const DMatrix<m,n> &b) {
    DMatrix<l,n> result;
    for (unsigned int i=0;i<l;i++) {
        for (unsigned int j=0;j<n;j++) {
            result.x[i][j]=0;
            for (unsigned int k=0;k<m;k++){
                result.x[i][j]+=a.x[i][k]*b.x[k][j];
            }
        }
    }
    return result;
}


template<unsigned int dims>
double Len(const DMatrix<dims, 1> &p) {
    double result=0;
    for (unsigned int i=0;i<dims;i++) {
        result+=p[i][0]*p[i][0];
    }
    return std::sqrt(result);
}


template<unsigned int dims>
double ScalProd(const DMatrix<dims, 1> &p1, const DMatrix<dims, 1> &p2) {
    double result=0;
    for (unsigned int i=0;i<dims;i++) {
        result+=p1[i][0]*p2[i][0];
    }
    return result;
}


// for statistiken.h
template<unsigned int zeilen, unsigned int spalten>
void InitZero(DMatrix<zeilen,spalten> &x) {
    x.Zero();
};


template<class _t> class SquareOperation;

template<unsigned int zeilen>
class SquareOperation<DMatrix<zeilen, 1> > {
public:
    typedef DMatrix<zeilen, zeilen> sq_t;

    static sq_t square(const DMatrix<zeilen, 1> &x) {
        return x * x.T();
    }
};

#endif