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;
}
}
bool auswert_bool_PVar(BBBaumMatrixPoint *P1, BBBaumMatrixPoint *P2, BBBool::T_booloperator b)
{
T_Point v1, v2;
double f;
int ret1 = auswert_point(*P1, v1, f);
int ret2 = auswert_point(*P2, v2, f);
assert(ret1 && ret2);
switch (b)
{
case BBBool::Gleich:
return (v1.x == v2.x && v1.y == v2.y);
case BBBool::Ungleich:
return (v1.x != v2.x || v1.y != v2.y);
case BBBool::Kleiner:
return (v1.x < v2.x);
case BBBool::Groesser:
return (v1.x > v2.x);
case BBBool::KleinerG:
return (v1.x <= v2.x);
case BBBool::GroesserG:
return (v1.x >= v2.x);
}
return false;
}
// ************ Float *******************
double auswert_float(BBBaumInteger& b)
{
if (b.typ == BBBaumInteger::NoOp)
throw BBFehlerAusfuehren();
double f;
T_Point p;
switch(b.typ)
{
case BBBaumInteger::BIOperator:
switch(b.k.BiOperator.OpTyp)
{
case BBBaumInteger::BBKnoten::BBBiOperator::Plus:
return auswert_float(*b.k.BiOperator.links) +
auswert_float(*b.k.BiOperator.rechts);
case BBBaumInteger::BBKnoten::BBBiOperator::Minus:
return auswert_float(*b.k.BiOperator.links) -
auswert_float(*b.k.BiOperator.rechts);
case BBBaumInteger::BBKnoten::BBBiOperator::Mal:
return auswert_float(*b.k.BiOperator.links) *
auswert_float(*b.k.BiOperator.rechts);
case BBBaumInteger::BBKnoten::BBBiOperator::Geteilt:
return auswert_float(*b.k.BiOperator.links) /
auswert_float(*b.k.BiOperator.rechts);
case BBBaumInteger::BBKnoten::BBBiOperator::Hoch:
return pow( auswert_float(*b.k.BiOperator.links),
auswert_float(*b.k.BiOperator.rechts));
case BBBaumInteger::BBKnoten::BBBiOperator::Modulo:
return fmod( auswert_float(*b.k.BiOperator.links),
auswert_float(*b.k.BiOperator.rechts));
}
break;
case BBBaumInteger::UniOperator:
switch (b.k.UniOperator.OpTyp)
{
case BBBaumInteger::BBKnoten::BBUniOperator::Plus:
return auswert_float(*b.k.UniOperator.rechts);
case BBBaumInteger::BBKnoten::BBUniOperator::Minus:
return (- auswert_float(*b.k.UniOperator.rechts));
}
break;
case BBBaumInteger::MIndex:
if (b.k.MatrixIndex.P->isMatrix) //muss Point sein
{
assert(false);
break;
}
auswert_point(*b.k.MatrixIndex.P, p, f);
return (*b.k.MatrixIndex.M->M)(p.x,p.y);
//return b.k.MatrixIndex.M->M->Z[p.y][p.x];
case BBBaumInteger::IZahl:
return b.k.IZahl;
case BBBaumInteger::FZahl:
return b.k.FZahl;
case BBBaumInteger::Funktion:
if (b.k.func->f->ret.typ == BBArgumente::ITyp)
return auswert_funktion_integer(b.k.func);
else if (b.k.func->f->ret.typ == BBArgumente::FTyp)
return auswert_funktion_float(b.k.func);
else if (b.k.func->f->ret.typ == BBArgumente::NoOp)
{
auswert_funktion_integer(b.k.func);
return 0;
}
assert(false);
break;
case BBBaumInteger::IVar:
return *(b.k.IVar->i);
case BBBaumInteger::FVar:
return *(b.k.FVar->f);
}
assert(false);
return 0;
}
// ************ Point *******************
bool auswert_point(BBBaumMatrixPoint& b, T_Point& vret, double& fret)
{
if (b.typ == BBBaumInteger::NoOp)
throw BBFehlerAusfuehren();
if (b.isMatrix)
throw BBFehlerAusfuehren();
T_Point v, v2;
double f, f2;
bool ret1, ret2;
switch(b.typ)
{
case BBBaumMatrixPoint::BIOperator:
switch (b.k.BiOperator.OpTyp)
{
case BBBaumMatrixPoint::BBKnoten::BBBiOperator::Plus:
ret1 = auswert_point(*b.k.BiOperator.links, v, f);
ret2 = auswert_point(*b.k.BiOperator.rechts, v2, f);
assert(ret1 && ret2);
v.x += v2.x;
v.y += v2.y;
vret = v;
return true;
case BBBaumMatrixPoint::BBKnoten::BBBiOperator::Minus:
ret1 = auswert_point(*b.k.BiOperator.links, v, f);
ret2= auswert_point(*b.k.BiOperator.rechts, v2, f);
assert(ret1 && ret2);
v.x -= v2.x;
v.y -= v2.y;
vret = v;
return true;
case BBBaumMatrixPoint::BBKnoten::BBBiOperator::Mal:
ret1 = auswert_point(*b.k.BiOperator.links, v, f);
ret2= auswert_point(*b.k.BiOperator.rechts, v2, f2);
assert((ret1 && !ret2) || (!ret1 && ret2));
if (ret1)
{
v.x *= f2;
v.y *= f2;
}
else
{
v.x = v2.x * f;
v.y = v2.y * f;
}
vret = v;
return true;
case BBBaumMatrixPoint::BBKnoten::BBBiOperator::Geteilt:
ret1 = auswert_point(*b.k.BiOperator.links, v, f);
ret2= auswert_point(*b.k.BiOperator.rechts, v2, f2);
assert((ret1 && !ret2) || (!ret1 && ret2));
if (ret1)
{
v.x /= f2;
v.y /= f2;
}
else
{
v.x = v2.x / f;
v.y = v2.y / f;
}
vret = v;
return true;
}
break;
case BBBaumMatrixPoint::UniOperator:
switch (b.k.UniOperator.OpTyp)
{
case BBBaumMatrixPoint::BBKnoten::BBUniOperator::Plus:
ret1 = auswert_point(*b.k.UniOperator.rechts, v, f);
assert(ret1);
vret = v;
return true;
case BBBaumMatrixPoint::BBKnoten::BBUniOperator::Minus:
ret1 = auswert_point(*b.k.UniOperator.rechts, v, f);
assert(ret1);
vret.x = -v.x;
vret.y = -v.y;
return true;
}
break;
case BBBaumMatrixPoint::IFAusdruck:
fret = auswert_float(*b.k.IntFloatAusdruck.b);
return false;
case BBBaumMatrixPoint::MVar:
assert(false);
break;
case BBBaumMatrixPoint::PVar:
vret = b.k.P->v;
return true;
}
assert(false);
return false;
}
