mld_representation.cc

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

/*
	HYSDEL
	Copyright (C) 1999-2002  Fabio D. Torrisi

	This file is part of HYSDEL.
    
	HYSDEL 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.

	HYSDEL 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 library; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

	CONTACT INFORMATION
	===================
	Fabio D. Torrisi
	ETH Zentrum
	Physikstrasse. 3 ETL,
	CH-8032 Zurich
	Switzerland
	mailto:[e-mail] (preferred)
*/

#include <stdio.h>
#include "MLD_representation.h"
#include "Matrix.h"
#include "Symbol_table.h"
#include "Var_symbol.h"
#include "Neg_expr.h"
#include "Minus_expr.h"
#include "Plus_expr.h"
#include "Cmd_options.h"
#include "Globals.h"
#include "Row_information.h"
#include "Var_symbol.h"

//const int MLD_representation::NOF_EQ_MAT=12;
//const int MLD_representation::NOF_INEQ_MAT=7;


MLD_representation::MLD_representation(const Globals * glob) {
	globals = glob;

	A_rr = new Matrix();
	A_br = new Matrix();
	A_rb = new Matrix();
	A_bb = new Matrix();
	B1_rr = new Matrix();
	B1_br = new Matrix();
	B1_rb = new Matrix();
	B1_bb = new Matrix();
	B3_rr = new Matrix();
	B3_br = new Matrix();
	B2_rb = new Matrix();
	B2_bb = new Matrix();
	B5_r = new Matrix();
	B5_b = new Matrix();

	C_rr = new Matrix();
	C_br = new Matrix();
	C_rb = new Matrix();
	C_bb = new Matrix();
	D1_rr = new Matrix();
	D1_br = new Matrix();
	D1_rb = new Matrix();
	D1_bb = new Matrix();
	D3_rr = new Matrix();
	D3_br = new Matrix();
	D2_rb = new Matrix();
	D2_bb = new Matrix();
	D5_r = new Matrix();
	D5_b = new Matrix();

	E1_c = new Matrix();
	E1_d = new Matrix();
	E3 = new Matrix();
	E2 = new Matrix();
	E4_c = new Matrix();
	E4_d = new Matrix();
	E5 = new Matrix();

	nof_ineq = 0;
}

MLD_representation::~MLD_representation() {
	info_iter iter;

	delete A_rr;
	delete A_br;
	delete A_rb;
	delete A_bb;
	delete B1_rr;
	delete B1_br;
	delete B1_rb;
	delete B1_bb;
	delete B3_rr;
	delete B3_br;
	delete B2_rb;
	delete B2_bb;
	delete B5_r;
	delete B5_b;

	delete C_rr;
	delete C_br;
	delete C_rb;
	delete C_bb;
	delete D1_rr;
	delete D1_br;
	delete D1_rb;
	delete D1_bb;
	delete D3_rr;
	delete D3_br;
	delete D2_rb;;
	delete D2_bb;;
	delete D5_r;
	delete D5_b;

	delete E1_c;
	delete E1_d;
	delete E3;
	delete E2;
	delete E4_c;
	delete E4_d;
	delete E5;

	for (iter = state_upd_info.begin(); iter != state_upd_info.end();
		iter++)delete(* iter).second;
	state_upd_info.clear();
	for (iter = output_info.begin(); iter != output_info.end(); iter++)
		delete(* iter).second;
	output_info.clear();
	for (iter = ineq_info.begin(); iter != ineq_info.end(); iter++)
		delete(* iter).second;
	ineq_info.clear();
}


void MLD_representation::check_dims() const {
	//cout << "checking dims" << endl; cout.flush();
	A_rr->check_dim(globals->symbol_table->count_symbols(STATE_KIND, REAL_TYPE),
		globals->symbol_table->count_symbols(STATE_KIND, REAL_TYPE));
	A_rb->check_dim(globals->symbol_table->count_symbols(STATE_KIND, REAL_TYPE),
		globals->symbol_table->count_symbols(STATE_KIND, BOOL_TYPE));
	A_br->check_dim(globals->symbol_table->count_symbols(STATE_KIND, BOOL_TYPE),
		globals->symbol_table->count_symbols(STATE_KIND, REAL_TYPE));
	A_bb->check_dim(globals->symbol_table->count_symbols(STATE_KIND, BOOL_TYPE),
		globals->symbol_table->count_symbols(STATE_KIND, BOOL_TYPE));
	B1_rr->check_dim(globals->symbol_table->count_symbols(STATE_KIND, REAL_TYPE),
		globals->symbol_table->count_symbols(INPUT_KIND, REAL_TYPE));
	B1_rb->check_dim(globals->symbol_table->count_symbols(STATE_KIND, REAL_TYPE),
		globals->symbol_table->count_symbols(INPUT_KIND, BOOL_TYPE));
	B1_br->check_dim(globals->symbol_table->count_symbols(STATE_KIND, BOOL_TYPE),
		globals->symbol_table->count_symbols(INPUT_KIND, REAL_TYPE));
	B1_bb->check_dim(globals->symbol_table->count_symbols(STATE_KIND, BOOL_TYPE),
		globals->symbol_table->count_symbols(INPUT_KIND, BOOL_TYPE));
	B2_rb->check_dim(globals->symbol_table->count_symbols(STATE_KIND, REAL_TYPE),
		globals->symbol_table->count_symbols(AUX_KIND, BOOL_TYPE));
	B2_bb->check_dim(globals->symbol_table->count_symbols(STATE_KIND, BOOL_TYPE),
		globals->symbol_table->count_symbols(AUX_KIND, BOOL_TYPE));
	B3_rr->check_dim(globals->symbol_table->count_symbols(STATE_KIND, REAL_TYPE),
		globals->symbol_table->count_symbols(AUX_KIND, REAL_TYPE));
	B3_br->check_dim(globals->symbol_table->count_symbols(STATE_KIND, BOOL_TYPE),
		globals->symbol_table->count_symbols(AUX_KIND, REAL_TYPE));
	B5_r->check_dim(globals->symbol_table->count_symbols(STATE_KIND, REAL_TYPE), 1);
	B5_b->check_dim(globals->symbol_table->count_symbols(STATE_KIND, BOOL_TYPE), 1);


	C_rr->check_dim(globals->symbol_table->count_symbols(OUTPUT_KIND, REAL_TYPE),
		globals->symbol_table->count_symbols(STATE_KIND, REAL_TYPE));
	C_rb->check_dim(globals->symbol_table->count_symbols(OUTPUT_KIND, REAL_TYPE),
		globals->symbol_table->count_symbols(STATE_KIND, BOOL_TYPE));
	C_br->check_dim(globals->symbol_table->count_symbols(OUTPUT_KIND, BOOL_TYPE),
		globals->symbol_table->count_symbols(STATE_KIND, REAL_TYPE));
	C_bb->check_dim(globals->symbol_table->count_symbols(OUTPUT_KIND, BOOL_TYPE),
		globals->symbol_table->count_symbols(STATE_KIND, BOOL_TYPE));
	D1_rr->check_dim(globals->symbol_table->count_symbols(OUTPUT_KIND, REAL_TYPE),
		globals->symbol_table->count_symbols(INPUT_KIND, REAL_TYPE));
	D1_rb->check_dim(globals->symbol_table->count_symbols(OUTPUT_KIND, REAL_TYPE),
		globals->symbol_table->count_symbols(INPUT_KIND, BOOL_TYPE));
	D1_br->check_dim(globals->symbol_table->count_symbols(OUTPUT_KIND, BOOL_TYPE),
		globals->symbol_table->count_symbols(INPUT_KIND, REAL_TYPE));
	D1_bb->check_dim(globals->symbol_table->count_symbols(OUTPUT_KIND, BOOL_TYPE),
		globals->symbol_table->count_symbols(INPUT_KIND, BOOL_TYPE));
	D2_rb->check_dim(globals->symbol_table->count_symbols(OUTPUT_KIND, REAL_TYPE),
		globals->symbol_table->count_symbols(AUX_KIND, BOOL_TYPE));
	D2_bb->check_dim(globals->symbol_table->count_symbols(OUTPUT_KIND, BOOL_TYPE),
		globals->symbol_table->count_symbols(AUX_KIND, BOOL_TYPE));
	D3_rr->check_dim(globals->symbol_table->count_symbols(OUTPUT_KIND, REAL_TYPE),
		globals->symbol_table->count_symbols(AUX_KIND, REAL_TYPE));
	D3_br->check_dim(globals->symbol_table->count_symbols(OUTPUT_KIND, BOOL_TYPE),
		globals->symbol_table->count_symbols(AUX_KIND, REAL_TYPE));
	D5_r->check_dim(globals->symbol_table->count_symbols(OUTPUT_KIND, REAL_TYPE), 1);
	D5_b->check_dim(globals->symbol_table->count_symbols(OUTPUT_KIND, BOOL_TYPE), 1);

	check_ineqs();
}

string MLD_representation::preamble() const {
	string res;

	res += string("S.name = '") + globals->system_name + string("';\n");
	res += string("S.MLDisvalid = 1;\n");
	res += string("S.MLDstructver = 2;\n");

	if (globals->cmd_options->print_symtable())
		res += string("S.MLDsymtable = 1;\n"); else
		res += string("S.MLDsymtable = 0;\n");

	if (globals->cmd_options->print_rowinfo())
		res += string("S.MLDrowinfo = 1;\n"); else
		res += string("S.MLDrowinfo = 0;\n");

	return res;
}

string MLD_representation::to_matlab(bool sparse = false) const {
	string res;
	Matrix * tmp;

	check_dims();

	res += preamble();

	//cout << "output"; cout.flush();
	res += "S.Arr = ";
	res += A_rr->to_matlab();
	res += "S.Arb = ";
	res += A_rb->to_matlab();
	res += "S.Abr = ";
	res += A_br->to_matlab();
	res += "S.Abb = ";
	res += A_bb->to_matlab();
	res += string("\n");

	res += "S.B1rr = ";
	res += B1_rr->to_matlab();
	res += "S.B1rb = ";
	res += B1_rb->to_matlab();
	res += "S.B1br = ";
	res += B1_br->to_matlab();
	res += "S.B1bb = ";
	res += B1_bb->to_matlab();
	res += string("\n");

	res += "S.B2rb = ";
	res += B2_rb->to_matlab();
 	res += "S.B2bb = ";
	res += B2_bb->to_matlab();
	res += string("\n");

	res += "S.B3rr = ";
	res += B3_rr->to_matlab();
	res += "S.B3br = ";
	res += B3_br->to_matlab();
	res += string("\n");

	if (globals->cmd_options->consts_in_eq_as_B5D5()) {
		res += "S.B5r = ";
		res += B5_r->to_matlab();
		res += "S.B5b = ";
		res += B5_b->to_matlab();
		res += string("\n");
	}

	res += "S.Crr = ";
	res += C_rr->to_matlab();
	res += "S.Crb = ";
	res += C_rb->to_matlab();
	res += "S.Cbr = ";
	res += C_br->to_matlab();
	res += "S.Cbb = ";
	res += C_bb->to_matlab();
	res += string("\n");

	res += "S.D1rr = ";
	res += D1_rr->to_matlab();
	res += "S.D1rb = ";
	res += D1_rb->to_matlab();
	res += "S.D1br = ";
	res += D1_br->to_matlab();
	res += "S.D1bb = ";
	res += D1_bb->to_matlab();
	res += string("\n");

	res += "S.D2rb = ";
	res += D2_rb->to_matlab();
	res += "S.D2bb = ";
	res += D2_bb->to_matlab();
	res += string("\n");

	res += "S.D3rr = ";
	res += D3_rr->to_matlab();
	res += "S.D3br = ";
	res += D3_br->to_matlab();
	res += string("\n");

	if (globals->cmd_options->consts_in_eq_as_B5D5()) {
		res += "S.D5r = ";
		res += D5_r->to_matlab();
		res += "S.D5b = ";
		res += D5_b->to_matlab();
		res += string("\n");
	}

	tmp = E1_c->clone();
	tmp->concat_x(E1_d->clone());
	res += "S.E1 = ";
	res += tmp->to_matlab();
	res += "S.E2 = ";
	res += E2->to_matlab();
	res += "S.E3 = ";
	res += E3->to_matlab();

	tmp = E4_c->clone();
	tmp->concat_x(E4_d->clone());
	res += "S.E4 = ";
	res += tmp->to_matlab();
	res += "S.E5 = ";
	res += E5->to_matlab();


	  res += "S.A = [S.Arr, S.Arb; S.Abr, S.Abb];\n";
	  res += "S.B1 = [S.B1rr, S.B1rb; S.B1br, S.B1bb];\n";
	  res += "S.B2 = [S.B2rb; S.B2bb];\n";
	  res += "S.B3 = [S.B3rr; S.B3br];\n";
	  if (globals->cmd_options->consts_in_eq_as_B5D5())
	    res += "S.B5 = [S.B5r; S.B5b];\n";
	  res += "\nS.C = [S.Crr, S.Crb; S.Cbr, S.Cbb];\n";
	  res += "S.D1 = [S.D1rr, S.D1rb; S.D1br, S.D1bb];\n";
	  res += "S.D2 = [S.D2rb; S.D2bb];\n";
	  res += "S.D3 = [S.D3rr; S.D3br];\n";
	  if (globals->cmd_options->consts_in_eq_as_B5D5())
	    res += "S.D5 = [S.D5r; S.D5b];\n";

	if (globals->cmd_options->print_rowinfo()) res += info();

	return res;
}

string MLD_representation::info() const {
	string res, prefix;
	const_info_iter iter;
	char buf[100];


	//cout << "writing info" << endl; cout.flush();
	for (iter = state_upd_info.begin(); iter != state_upd_info.end();
		iter++) {
			sprintf(buf, "S.rowinfo.state_upd{%d}",
				(* iter).first + 1);
			prefix = string(buf);
			res += (* iter).second->to_matlab(prefix);
	}
	for (iter = output_info.begin(); iter != output_info.end(); iter++) {
		sprintf(buf, "S.rowinfo.output{%d}", (* iter).first + 1);
		prefix = string(buf);
		res += (* iter).second->to_matlab(prefix);
	}
	for (iter = ineq_info.begin(); iter != ineq_info.end(); iter++) {
		sprintf(buf, "S.rowinfo.ineq{%d}", (* iter).first + 1);
		prefix = string(buf);
		res += (* iter).second->to_matlab(prefix);
	}
	//cout << res;

	sprintf(buf, "S.ne = %d;\n", nof_ineq);
	res += buf;


	return res;
}

void MLD_representation::check_ineqs() const {
	E1_c->check_dim(nof_ineq,
		globals->symbol_table->count_symbols(INPUT_KIND, REAL_TYPE));
	E1_d->check_dim(nof_ineq,
		globals->symbol_table->count_symbols(INPUT_KIND, BOOL_TYPE));
	E2->check_dim(nof_ineq, globals->symbol_table->count_symbols(AUX_KIND, BOOL_TYPE));
	E3->check_dim(nof_ineq, globals->symbol_table->count_symbols(AUX_KIND, REAL_TYPE));
	E4_c->check_dim(nof_ineq,
		globals->symbol_table->count_symbols(STATE_KIND, REAL_TYPE));
	E4_d->check_dim(nof_ineq,
		globals->symbol_table->count_symbols(STATE_KIND, BOOL_TYPE));
	E5->check_dim(nof_ineq, 1);
}

int MLD_representation::new_ineq() {
	return nof_ineq++;
}