Matrix Calculator

//matrix.h

#ifndef __MATRIX_H__
#define __MATRIX_H__

#include <vector>

using std::vector;

template <class T>
class MATRIX{
public:
    explicit MATRIX(): R(0), C(0), V(0){}

    MATRIX(int _R, int _C): R(_R), C(_C), V(_R){
        for (int i = 0; i < R; ++i)
            V[i].resize(C);
    }

    MATRIX(const MATRIX<T> &m){*this = m;}

    ~MATRIX(){V.clear();}

    void resize(int _R, int _C);
    bool push_back(const vector<T>& _V);
    void swap_row(int R1, int R2);
    //void swap_col(int C1, int C2);

    inline int rows() const{return R;}
    inline int cols() const{return C;}
    inline bool empty() const{return !R||!C;}
    inline bool square() const{return (!empty() && R == C);}

    inline T&operator ()(int i, int j){return V[i][j];}
    const vector<T>& operator[](int _R) const { return V[_R]; }
    vector<T>& operator[](int _R){ return V[_R]; }
protected:
    vector<vector<T> > V;
    int R, C;
};

template <class T>
void MATRIX<T>::resize(int _R, int _C){
    if (R == _R && C == _C)
        return;
    else if (R == _R && C != _C){
        for (int i = 0; i < R; ++i)
            V[i].resize(_C);
        C = _C;
    }
    else if (R != _R && C == _C){
        V.resize(_R);
        for (int i = R; i < _R; ++i)
            V[i].resize(C);
        R = _R;
    }
    else {
        V.resize(_R);
        for (int i = 0; i < _R; ++i)
            V[i].resize(_C);
        R = _R, C = _C;
    }
}


template <class T>
bool MATRIX<T>::push_back(const vector<T> &_V){
    if (!R || C == (int)_V.size())
        V.push_back(_V);
    else
        return false;
    return true;
}

template <class T>
void MATRIX<T>::swap_row(int R1, int R2){
    if (R1 != R2 && R1 > 0 && R1 <= R && R2 > 0 && R2 <= R){
        vector<T> t = V[R1];
        V[R1] = V[R2];
        V[R2] = t;
    }
}

template <class T>
const MATRIX<T> trans(const MATRIX<T> &m){
    MATRIX<T> ret;
    if (m.empty()) return ret;
    int R = m.cols();
    int C = m.rows();
    ret.resize(R, C);

    for (int i = 0; i < R; ++i)
        for (int j = 0; j < C; ++j)
            ret[i][j] = m[j][i];
    return ret;
}

inline static int max(int a, int b){
    return a > b ? a : b;
}

inline static int min(int a, int b){
    return a < b ? a : b;
}

class matrix:public MATRIX<double>{
public:
    matrix(): MATRIX<double>(){}
    matrix(int _C, int _R): MATRIX<double>(_C, _R){}
    matrix(const matrix &m){*this = m;}

    matrix &operator += (const matrix &m);
    matrix &operator -= (const matrix &m);
    matrix &operator *= (const matrix &m);
    matrix &operator *= (const double k);
    //const matrix &operator /= (const matrix &m);

    friend matrix operator ~ (const matrix &m);
    friend bool operator == (const matrix &m1, const matrix &m2);
    friend bool operator != (const matrix &m1, const matrix &m2);
    friend matrix operator + (const matrix &m1, const matrix & m2);
    friend matrix operator - (const matrix &m1, const matrix & m2);
    friend matrix operator * (const matrix &m1, const matrix & m2);
    friend matrix operator * (const matrix &m, const double k);
    friend matrix operator * (const double k, const matrix &m);
    //const matrix operator / (const matrix &m1, const matrix & m2);

    //matrix LU();
    double norm();
    matrix sub(int i, int j, int _R, int _C);
	matrix row(int _R);
    matrix col(int _C);
    double &maxelem();
    double &minelem();

    virtual bool input(int _R, int _C);
    virtual void output(int digit);
    virtual void output();
};

#include "matrix.cpp"

#endif

//calc.h

#ifndef __CALC_H__
#define __CALC_H__

#include <vector>
#include <cstring>

class STATPARSER{
public:
	STATPARSER(): ptr(0), stat(0){}
	STATPARSER(char STAT[]): ptr(0), stat(0){SetStatement(STAT);}
	~STATPARSER(){}

	void SetStatement(char STAT[]);
	bool InputFromKeybord();

	inline bool StatEnabled(){return stat.size();}

protected:
	//char stat[], *ptr;
	std::vector<char>::iterator ptr;
	std::vector<char> stat;
	//virtual int GetToken() = 0;
	//virtual bool TokenInSet() = 0;
};

template <class T>
class CALCULATOR:public STATPARSER{
public:
	CALCULATOR():STATPARSER(){memset(registered, 0, sizeof(registered));}

	T &Calc();
protected:
    T reg[30];		// T[0..25] for identifiers  // T[26..29] for register
	int token;
    bool registered[30];
    inline int id(char ch);
    inline int allocreg();
    inline int isreg(int __id);
    inline virtual int gettoken();
    virtual int generate() = 0;
};

#include "calc.cpp"

#endif

//matrix_calculator.h

#include "calc.h"
#include "matrix.h"

#define ID_DOUBLE		(0)
#define ID_MATRIX		(1)

class pan_matrix:public matrix{
public:
	pan_matrix():matrix(), f_val(0), id_val(ID_DOUBLE){}
	pan_matrix(const matrix &m):matrix(m), f_val(0), id_val(ID_MATRIX){}
	pan_matrix(const pan_matrix &m){*this = m;}

	pan_matrix(double _f_val):matrix(), f_val(_f_val), id_val(ID_DOUBLE){}
	pan_matrix(int _C, int _R):matrix(_C, _R), f_val(0), id_val(ID_MATRIX){}

	pan_matrix &operator += (const pan_matrix &m);
    pan_matrix &operator -= (const pan_matrix &m);
    pan_matrix &operator *= (const pan_matrix &m);
    pan_matrix &operator /= (const pan_matrix &m);
    //const matrix &operator /= (const matrix &m);

    friend pan_matrix operator ~ (const pan_matrix &m);
    friend bool operator == (const pan_matrix &m1, const pan_matrix &m2);
    friend bool operator != (const pan_matrix &m1, const pan_matrix &m2);
    friend pan_matrix operator + (const pan_matrix &m1, const pan_matrix & m2);
    friend pan_matrix operator - (const pan_matrix &m1, const pan_matrix & m2);
    friend pan_matrix operator * (const pan_matrix &m1, const pan_matrix & m2);
    friend pan_matrix operator / (const pan_matrix &m1, const pan_matrix & m2);

	double f_val;
	int id_val;

	virtual bool input();
    virtual void output(int digit);
    virtual void output();
};

class matrix_calculator:public CALCULATOR<pan_matrix>{
public:
	matrix_calculator():CALCULATOR<pan_matrix>(), AutoInit(0){}

	virtual inline void Print(char ch);
	virtual inline void Print();

	bool AutoInit;
protected:
    virtual int generate();
    virtual inline int gettoken();
	pan_matrix get_constant;
private:
    inline bool Assigned(int x){return ~(x);}
	inline void Reset(int &x){x = -1;}
	inline void Destroy(int x){if (isreg(x)) registered[x] = false;}
	inline void Free(int x){registered[x] = false;}
	inline void Reg(int x){registered[x] = true;}
	inline void RegNum(int x){reg[x] = get_constant; registered[x] = true;}
	inline int ZigZag(int &id_a, int &oper_1, int &id_b, int &oper_2, int id_c);
};

#include "matrix_calculator.cpp"

//main

#define MATRIX_EXCEPTION
#include "matrix_calculator.h"
#include <cstdio>

int main(){
	matrix_calculator C;
	C.AutoInit = true;
	while (1){
		C.InputFromKeybord();
		pan_matrix m = C.Calc();
		printf("Result = ");
		if (m.id_val == ID_DOUBLE){
			m.output(3);
		}
		else{
			m.output();
		}
		puts("--------------------");
	}
}