matrix.cc

由matlab开发的hybrid系统的描述语言

#include "Matrix.h"
#include <stdio.h>
#include "Plus_expr.h"


Matrix::Matrix() {
	dim_checked = false;
	use_sparse_output = false;
}

Matrix::~Matrix() {
	for (entries_iter iter = entries.begin(); iter != entries.end(); iter++)
		delete(* iter).second;
	entries.clear();
}

Matrix * Matrix::clone() const {
	Matrix * res;

	res = new Matrix();
	res->dim_checked = dim_checked;
	res->dim_x = dim_x;
	res->dim_y = dim_y;
	res->use_sparse_output = use_sparse_output;
	for (const_entries_iter iter = entries.begin(); iter != entries.end();
		iter++)res->set((* iter).first.get_y(), (* iter).first.get_x(),
			(* iter).second->clone());
	return res;
}


void Matrix::set(int y, int x, Expr * coeff) {
	Matrix_entry_key key = Matrix_entry_key(y, x);

	assert(y >= 0 && x >= 0); //fine

	entries[key] = coeff;
	if (!(dim_checked && x < dim_x && y < dim_y)) dim_checked = false;
}


Expr * Matrix::get(int y, int x) const {
	const_entries_iter iter;
	Matrix_entry_key key = Matrix_entry_key(y, x);

	assert(y >= 0 && x >= 0); //fine

	iter = entries.find(key);
	if (iter != entries.end()) return (* iter).second->clone(); else
		return NULL;
}


void Matrix::operator += (Matrix * add) {
	entries_iter found;
	Expr * tmp;

	if (dim_checked && add->dim_checked) {
		assert(dim_x == add->dim_x && dim_y == add->dim_y); //fine
		dim_checked = true;
	} else dim_checked = false;
	for (entries_iter iter = add->entries.begin(); iter != add->entries.end();
		iter++) {
			if ((found = entries.find((* iter).first)) !=
				entries.end()) {
					tmp = (* found).second;
					(* found).second =
						new Plus_expr(tmp,
						(* iter).second);
			} else entries[(* iter).first] = (* iter).second;
	}
	add->entries.clear();
	delete add; // ->shallow delete
}


string Matrix::to_matlab_sparse() const { return 0; }

string Matrix::to_matlab_full() const {
	string res;
	int x, y;
	const_entries_iter found;

	if (!is_zeros()) {
		res += "[\n";
		for (y = 0; y < dim_y; y++) {
			for (x = 0; x < dim_x; x++) {
				Matrix_entry_key key = Matrix_entry_key(y, x);
				found = entries.find(key);
				if (found != entries.end())
					res += (* found).second->to_matlab();
				else res += "0";
				res += " ";
			}
			res += ";\n";
		}
		res += "];\n";
	} else {
		char buf[100];
		sprintf(buf, "zeros(%d, %d);\n", dim_y, dim_x);
		res = string(buf);
	}

	return res;
}

string Matrix::to_matlab() const {
	assert(dim_checked); //fine

	if (use_sparse_output) return to_matlab_sparse(); else
		return to_matlab_full();
}


void Matrix::concat_y(Matrix * down) {
	entries_iter iter;
	if (!dim_checked && is_zeros() && !down->dim_checked &&
		down->is_zeros())return;
	assert(dim_checked && down->dim_checked); //fine
	assert(dim_x == down->dim_x); //fine

	for (iter = down->entries.begin(); iter != down->entries.end();
		iter++) {
			Matrix_entry_key key =
				Matrix_entry_key((* iter).first.get_y()
				+ dim_y, (* iter).first.get_x());
			entries[key] = (* iter).second;
	}
	dim_y += down->dim_y;
	down->entries.clear();
	delete down;
}

void Matrix::concat_x(Matrix * right) {
	entries_iter iter;
	if (!dim_checked && is_zeros() && !right->dim_checked &&
		right->is_zeros())return;
	assert(dim_checked && right->dim_checked); //fine
	assert(dim_y == right->dim_y); //fine

	for (iter = right->entries.begin(); iter != right->entries.end();
		iter++) {
			Matrix_entry_key key =
				Matrix_entry_key((* iter).first.get_y(),
				(* iter).first.get_x() + dim_x);
			entries[key] = (* iter).second;
	}
	dim_x += right->dim_x;
	right->entries.clear();
	delete right;
}


bool Matrix::is_zeros() const {
	return entries.empty();
}


void Matrix::check_dim(int y, int x) {
	entries_iter iter;

	for (iter = entries.begin(); iter != entries.end(); iter++) {
		assert((* iter).first.get_x() < x); //fine
		assert((* iter).first.get_y() < y); //fine
	}
	dim_y = y;
	dim_x = x;
	dim_checked = true;
}


int Matrix::get_dimy() {
	if (!dim_checked && is_zeros()) return 0;
	assert(dim_checked); //fine
	return dim_y;
}