示例#1
0
bool auswert_bool_MVar(BBBaumMatrixPoint *M1, BBBaumMatrixPoint *M2, BBBool::T_booloperator b)
{
	GridWerte v1, v2;
	double f;
	int ret1 = auswert_matrix(*M1, v1, f);
	int ret2 = auswert_matrix(*M2, v2, f);
	assert(ret1 && ret2);

	switch (b)
	{
	case BBBool::Gleich:
		return (v1.xanz == v2.xanz && v1.yanz == v2.yanz);
	case BBBool::Ungleich:
		return (v1.xanz != v2.xanz || v1.yanz != v2.yanz);
	case BBBool::Kleiner:
		return (v1.xanz < v2.xanz);
	case BBBool::Groesser:
		return (v1.xanz > v2.xanz);
	case BBBool::KleinerG:
		return (v1.xanz <= v2.xanz);
	case BBBool::GroesserG:		
		return (v1.xanz >= v2.xanz);
	}
	return false;
}
void ausfuehren_zuweisung(BBZuweisung& z)
{
	double f;
	if (z.typ == BBZuweisung::NoTyp)
		throw BBFehlerAusfuehren();
	switch(z.typ)
	{
	case BBZuweisung::FTyp:
		*(z.ZuVar.FVar->f) = auswert_float(*z.ZuArt.IF);
		break;
	case BBZuweisung::ITyp:
		*(z.ZuVar.IVar->i) = auswert_integer(*z.ZuArt.IF);
		break;
	case BBZuweisung::PTyp:
		if (!auswert_point(*z.ZuArt.MP, z.ZuVar.PVar->v, f))
			throw BBFehlerAusfuehren();
		break;
	case BBZuweisung::MTyp:
		if (!auswert_matrix(*z.ZuArt.MP, *(z.ZuVar.MVar->M), f))
			throw BBFehlerAusfuehren();
		break;
	case BBZuweisung::MIndex:
		{
			T_Point p;
			if (!auswert_point(*z.ZuVar.MatrixIndex.PVar, p, f))
				throw BBFehlerAusfuehren();
			
		//	z.ZuVar.MatrixIndex.MVar->M->Z[p.y][p.x] = auswert_float(*z.ZuArt.IF);

			(*z.ZuVar.MatrixIndex.MVar->M).Set_Value(p.x, p.y, auswert_float(*z.ZuArt.IF), true);

		}
		break;
	}
}
// ************ Matrix *******************
// Groesse von mret bestimmen !!
// Aufruf M = m+3*m2;  ?? 
bool auswert_matrix(BBBaumMatrixPoint& b, GridWerte& mret, double& fret)
{
	if (b.typ == BBBaumInteger::NoOp)
		throw BBFehlerAusfuehren();
	if (!b.isMatrix) // ?????
		throw BBFehlerAusfuehren();

	GridWerte m, m2;
	double f, f2;
	bool ret1, ret2;
	switch(b.typ)
	{
	case BBBaumMatrixPoint::BIOperator:
		switch (b.k.BiOperator.OpTyp)
		{
		case BBBaumMatrixPoint::BBKnoten::BBBiOperator::Plus:
			ret1 = auswert_matrix(*b.k.BiOperator.links, m, f);
			ret2 = auswert_matrix(*b.k.BiOperator.rechts, m2, f);
			assert(ret1 && ret2);
			
			mret = m;
			mret.getMem();


			if (!(m.xanz == m2.xanz &&
				m.yanz == m2.yanz &&
				mret.xanz == m2.xanz &&
				mret.yanz == m2.yanz ))
				throw BBFehlerMatrixNotEqual();
			{
				for (int i=0; i<m.yanz; i++)
					for (int j=0; j<m.xanz; j++)
						mret.Set_Value(j,i, m(j,i) + m2(j,i));
			}
			return true;
		case BBBaumMatrixPoint::BBKnoten::BBBiOperator::Minus:
			ret1 = auswert_matrix(*b.k.BiOperator.links, m, f);
			ret2= auswert_matrix(*b.k.BiOperator.rechts, m2, f);
			assert(ret1 && ret2);
			if (!(m.xanz == m2.xanz &&
				m.yanz == m2.yanz &&
				mret.xanz == m2.xanz &&
				mret.yanz == m2.yanz ))
				throw BBFehlerMatrixNotEqual();
			{
				for (int i=0; i<m.yanz; i++)
					for (int j=0; j<m.xanz; j++)
						mret.Set_Value(j,i, m(j,i) - m2(j,i));
			}
			return true;
		case BBBaumMatrixPoint::BBKnoten::BBBiOperator::Mal:
			ret1 = auswert_matrix(*b.k.BiOperator.links, m, f);
			ret2= auswert_matrix(*b.k.BiOperator.rechts, m2, f2);
			assert((ret1 && !ret2) || (!ret1 && ret2));
			if (ret1)
			{
				if (!(mret.xanz == m.xanz &&
					  mret.yanz == m.yanz))
					throw BBFehlerMatrixNotEqual();
				for (int i=0; i<m.yanz; i++)
					for (int j=0; j<m.xanz; j++)
						mret.Set_Value(j,i, m(j,i) * f2);
			}
			else 
			{
				if (!(mret.xanz == m2.xanz &&
					  mret.yanz == m2.yanz))
					throw BBFehlerMatrixNotEqual();
				for (int i=0; i<m2.yanz; i++)
					for (int j=0; j<m2.xanz; j++)
						mret.Set_Value(j,i, m2(j,i) * f);
			}
			return true;
		case BBBaumMatrixPoint::BBKnoten::BBBiOperator::Geteilt:
			ret1 = auswert_matrix(*b.k.BiOperator.links, m, f);
			ret2= auswert_matrix(*b.k.BiOperator.rechts, m2, f2);
			assert((ret1 && !ret2) || (!ret1 && ret2));
			if (ret1)
			{
				if (!(mret.xanz == m.xanz &&
					  mret.yanz == m.yanz))
					throw BBFehlerMatrixNotEqual();
				for (int i=0; i<m.yanz; i++)
					for (int j=0; j<m.xanz; j++)
						mret.Set_Value(j,i, m(j,i) / f2);
			}
			else 
			{
				if (!(mret.xanz == m2.xanz &&
					  mret.yanz == m2.yanz))
					throw BBFehlerMatrixNotEqual();
				for (int i=0; i<m2.yanz; i++)
					for (int j=0; j<m2.xanz; j++)
						mret.Set_Value(j,i, m2(j,i) / f);
			}
			return true;
		}
		break;
	case BBBaumMatrixPoint::UniOperator:
		switch (b.k.UniOperator.OpTyp)
		{
		case BBBaumMatrixPoint::BBKnoten::BBUniOperator::Plus:
			ret1 = auswert_matrix(*b.k.UniOperator.rechts, mret, f);
			assert(ret1);
			return true;
		case BBBaumMatrixPoint::BBKnoten::BBUniOperator::Minus:
			ret1 = auswert_matrix(*b.k.UniOperator.rechts, mret, f);
			assert(ret1);
			{
				for (int i=0; i<mret.yanz; i++)
					for (int j=0; j<mret.xanz; j++)
						mret.Set_Value(j,i, -mret(j,i));
			}
			return true;
		} 
		break;
	case BBBaumMatrixPoint::IFAusdruck:
		fret = auswert_float(*b.k.IntFloatAusdruck.b);
		return true; // ?????? false; 
	case BBBaumMatrixPoint::MVar:
		copyGrid(mret, *(b.k.M->M), true);
		return true;
		// ???? break;
	case BBBaumMatrixPoint::PVar:
		assert(false);
		return true;
	}
	assert(false);
	return false;
}