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;
}