affine_func.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 "Affine_func.h"
#include "Affine_addend.h"
#include "Expr.h"
#include "Div_expr.h"
#include "Plus_expr.h"
#include "Minus_expr.h"
#include "Neg_expr.h"
#include "Mult_expr.h"
#include "Number_expr.h"
#include "Var_symbol.h"
#include "Real_number.h"

Affine_func::Affine_func(const Globals * glob) {
	globals = glob;
}

Affine_func::Affine_func(Expr * c, const Globals * glob) {
	Affine_addend * aa;

	globals = glob;
	assert(c->is_const() && c->is_real()); //fine

	aa = new Affine_addend(c, NULL);
	addends.push_back(aa);
}

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

  res=new Affine_func(globals);
  for (const_addends_iter iter=addends.begin(); iter!=addends.end(); iter++)
    res->addends.push_back( (*iter)->clone() );
  return res;
}

Affine_func::Affine_func(const Var_symbol * var, const Globals * glob) {
	Affine_addend * aa;

	globals = glob;

	aa = new Affine_addend(new Number_expr(1.0, globals), var);
	addends.push_back(aa);
}

Affine_func::~Affine_func() {
	for (addends_iter iter = addends.begin(); iter != addends.end();
		iter++) {
			delete(* iter);
	}
	addends.clear();
}

void Affine_func::div_const(Expr * c) {
	addends_iter iter;
	Expr * div;

	assert(c->is_const() && c->is_real()); //fine

	for (iter = addends.begin(); iter != addends.end(); iter++) {
		div = new Div_expr((* iter)->get_coeff(), c->clone());
		(* iter)->set_coeff(div);
	}
	delete c;
}

void Affine_func::mult_const(Expr * c) {
	addends_iter iter;
	Expr * mult;

	assert(c->is_const() && c->is_real()); //fine

	for (iter = addends.begin(); iter != addends.end(); iter++) {
		mult = new Mult_expr(c->clone(), (* iter)->get_coeff());
		(* iter)->set_coeff(mult);
	}
	delete c;
}

void Affine_func::neg() {
	addends_iter iter;
	Expr * neg;

	for (iter = addends.begin(); iter != addends.end(); iter++) {
		neg = new Neg_expr((* iter)->get_coeff());
		(* iter)->set_coeff(neg);
	}
}


string Affine_func::to_string() const {
	string res;
	const_addends_iter iter, tmp;
	for (iter = addends.begin(); iter != addends.end(); iter++) {
		res += (* iter)->to_string();
		tmp = iter;
		tmp++;
		if (tmp != addends.end()) res += " + ";
	}
	return res;
}


void Affine_func::add(Affine_func * add) {
	addends_iter iter;
	Affine_addend * partner;
	Affine_addend * nv;
	Expr * e;

	for (iter = add->addends.begin(); iter != add->addends.end(); iter++) {
		partner = find_addend_nonconst((* iter)->get_var());
		if (partner) {
			e = new Plus_expr(partner->get_coeff(),
				(* iter)->get_coeff());
			partner->set_coeff(e);
		} else { // -> add new variable
			nv = new Affine_addend((* iter)->get_coeff(),
				(* iter)->get_var());
			addends.push_back(nv);
		}
	}
	add->addends.clear();
}

void Affine_func::sub(Affine_func * sub) {
	sub->neg();
	add(sub);
}


Affine_addend * Affine_func::find_addend_nonconst(const Var_symbol * var) {
	addends_iter iter;

	for (iter = addends.begin(); iter != addends.end(); iter++) {
		if ((* iter)->get_var() == var) return * iter;
	}
	return NULL;
}

const Affine_addend * Affine_func::find_addend(const Var_symbol * var) const {
	const_addends_iter iter;

	for (iter = addends.begin(); iter != addends.end(); iter++) {
		if ((* iter)->get_var() == var) return * iter;
	}
	return NULL;
}

Affine_addend * Affine_func::remove_const() {
	addends_iter iter;
	Affine_addend * cnst;

	for (iter = addends.begin(); iter != addends.end(); iter++) {
		if ((* iter)->get_var() == NULL) {
			cnst = * iter;
			addends.erase(iter);
			return cnst;
		}
	}
	return NULL;
}

Expr * Affine_func::to_expr() const {
	Expr * ret;
	const_addends_iter iter;

	ret = new Number_expr(0.0, globals); // an empty Expr
	for (iter = addends.begin(); iter != addends.end(); iter++) {
		ret = new Plus_expr(ret, (* iter)->to_expr());
	}
	return ret;
}

void Affine_func::simplify() {
	const Expr * c;
	for (addends_iter iter = addends.begin(); iter != addends.end(); ) {
		(* iter)->simplify();
		c = (* iter)->get_coeff();
		if (c->is_number() && ((Real_number *)
			(c->compute_number()))->is_zero()) {
				delete(* iter);
				addends.erase(iter);
		} else iter++;
	}
}