---

mmatrix.cpp

Go to the documentation of this file.

#include "mmatrix.h"

MMatrix::MMatrix (int m, int n) {
    if ((dimN > 4) || (dimM > 4)) {
    dimN = 0;
    dimM = 0;
    } else {
        dimN = n;
    dimM = m;
    };
    
    for (int x = 1; x <= MAX_MMATRIX_M; x++) {
    for (int y = 1; y <= MAX_MMATRIX_N; y++) {
        mat[x][y] = 0;
    };
    };
    
    return;
};

MMatrix::~MMatrix () {
};

int MMatrix::getM () {
    return dimM;
};

int MMatrix::getN () {
    return dimN;
};

void MMatrix::set (int m, int n, float val) {
    if ((m < 1) || (m > MAX_MMATRIX_M) || (n < 1) || (y > MAX_MMATRIX_N)) return;
    
    mat[m][n] = val;
};

float MMatrix::get (int m, int n) {
    if ((m < 1) || (m > MAX_MMATRIX_M) || (n < 1) || (y > MAX_MMATRIX_N)) return 0.0;
    
    return mat[m][n];
};

MMatrix MMatrix::trans () {
    MMatrix tmp(dimN, dimM);
    
    for (int x = 1; x <= dimN; x++) {
    for (int y = 1; y <= dimM; y++) {
        tmp.set (x, y, mat[y][x]);
    };
    };
    
    return tmp;
};
        
MMatrix MMatrix::operator+ (MMatrix m) {
    MMatrix tmp(dimM, dimN);
    
    if ((m.getN () != dimN) || (m.getM () != dimM)) return tmp;
    
    for (int x = 1; x <= dimM; x ++) {
    for (int y = 1; y <= dimN; y++) {
        tmp.set (x, y, (mat[x][y] + m.get (x, y)));
    };
    };
    
    return tmp;
};

MMatrix MMatrix::operator- (MMatrix m) {
    MMatrix tmp(dimM, dimN);
    
    if ((m.getN () != dimN) || (m.getM () != dimM)) return tmp;
    
    for (int x = 1; x <= dimM; x ++) {
    for (int y = 1; y <= dimN; y++) {
        tmp.set (x, y, (mat[x][y] - m.get (x, y)));
    };
    };
    
    return tmp;
};

MMatrix MMatrix::operator* (MMatrix m) {
    MMatrix tmp(m.getN (), dimM);
    float      f;
    
    if (dimN != m.getM ()) return tmp;
    
    for (int x = 1; x <= m.getM (); x ++) {
    for (int y = 1; y <= dimN; y++) {
        f = 0;
        for (int z = 1; z <= dimM; z++) {
        f += mat[z][y] * m.get (x, z);
        };
                
        tmp.set (x, y, f);
    };
    };
    
    return tmp;
};

MMatrix MMatrix::operator* (float f) {
    MMatrix tmp(dimM, dimN);
    
    for (int x = 1; x <= dimM; x ++) {
    for (int y = 1; y <= dimN; y++) {
        tmp.set (x, y, (mat[x][y] * f));
    };
    };
    
    return tmp;
};

void MMatrix::operator= (Vector v) {
    dimM = 1;
    dimN = 3;

    mat[1][1] = v.x;
    mat[2][1] = v.y;
    mat[3][1] = v.z;
};
    
MMatrix MMatrix::homogen () {
    if ((dimN < MAX_MMATRIX_N) && (dimM < MAX_MMATRIX_M)) {
    MMatrix tmp (dimM + 1, dimN + 1);
    
    for (int x = 1; x <= dimM; x++) {
        for (int y = 1; y <= dimN; y++) {
        tmp.set (x, y, mat[x][y]);
        };
    };
    
    tmp.set (dimM +1, dimN +1, 1);
    return tmp;
    } else {
    MMatrix tmp;
    return tmp;
    };
};

MMatrix MMatrix::reduce () {
    if ((dimM > 1) && (dimN > 1)) {
    MMatrix tmp (dimM - 1, dimN - 1);
    
    for (int x = 1; x < dimM; x++) {
        for (int y = 1; y < dimN; y++) {
        tmp.set (x, y, mat[x][y]);
        };
    };
    
    return tmp;
    } else {
    MMatrix tmp;
    return tmp;
    };
};

---