private static void TestPow(Double a, Double b)
{
Int32 power = (Int32)System.Math.Round(100 * b);
String di = System.Math.Pow(a, power).ToString();
String ni = BigMath.Pow(a, power).ToString();
Console.WriteLine("{0,6} ^ {1,6} = {2,6} : {3,6} -> {4,6}", a, power, di, ni, di == ni ? "Pass" : "Fail");
}
private void Reduce()
{
BigNum one = _factory.Unity;
BigNum zer = _factory.Zero;
Operator op = _operatorStack.Peek();
switch (op)
{
case Operator.Add:
// Apply E := E + E
EnsureVal(2);
BigNum aa = _valueStack.Pop();
BigNum ab = _valueStack.Pop();
_valueStack.Push(aa + ab);
break;
case Operator.Sub:
// Apply E := E - E
EnsureVal(2);
BigNum sa = _valueStack.Pop();
BigNum sb = _valueStack.Pop();
_valueStack.Push(sb - sa);
break;
case Operator.Mul:
EnsureVal(2);
BigNum ma = _valueStack.Pop();
BigNum mb = _valueStack.Pop();
_valueStack.Push(ma * mb);
break;
case Operator.Div:
EnsureVal(2);
BigNum da = _valueStack.Pop();
BigNum db = _valueStack.Pop();
_valueStack.Push(db / da);
break;
case Operator.Neg:
EnsureVal(1);
BigNum na = _valueStack.Pop();
_valueStack.Push(-na);
break;
case Operator.Pow:
EnsureVal(2);
BigNum pa = _valueStack.Pop();
BigNum pb = _valueStack.Pop();
_valueStack.Push(BigMath.Pow(pb, pa));
//Int32 exponent = Int32.Parse( pa.ToString(), N.Integer | N.AllowExponent, Cult.InvariantCulture );
// _valueStack.Push( pb.Power( exponent ) );
break;
case Operator.PaR:
_operatorStack.Pop();
break;
case Operator.CoE:
case Operator.CoN:
case Operator.CoL:
case Operator.CLE:
case Operator.CoG:
case Operator.CGE:
EnsureVal(2);
BigNum ea = _valueStack.Pop();
BigNum eb = _valueStack.Pop();
Boolean eq = ea == eb;
Boolean lt = eb < ea;
Boolean gt = eb > ea;
if (op == Operator.CoE)
{
_valueStack.Push(eq ? one : zer);
}
else if (op == Operator.CoN)
{
_valueStack.Push(eq ? zer : one);
}
else if (op == Operator.CoL)
{
_valueStack.Push(lt ? one : zer);
}
else if (op == Operator.CLE)
{
_valueStack.Push(lt || eq ? one : zer);
}
else if (op == Operator.CoG)
{
_valueStack.Push(gt ? one : zer);
}
else if (op == Operator.CGE)
{
_valueStack.Push(gt || eq ? one : zer);
}
break;
case Operator.And:
case Operator.Or:
case Operator.Xor:
EnsureVal(2);
BigNum binA = _valueStack.Pop();
BigNum binB = _valueStack.Pop();
switch (op)
{
case Operator.And:
Boolean and = binA == one && binB == one;
_valueStack.Push(and ? one : zer);
break;
case Operator.Or:
Boolean or = binA == one || binB == one;
_valueStack.Push(or ? one : zer);
break;
case Operator.Xor:
Boolean xor = (binA == one && binB != one) || (binA != one && binB == one);
_valueStack.Push(xor ? one : zer);
break;
}
break;
case Operator.Not:
EnsureVal(1);
BigNum notA = _valueStack.Pop();
if (notA == one)
{
notA = zer;
}
else
{
notA = one;
}
_valueStack.Push(notA);
break;
// Else, ignore it. Do not throw an exception
}
_operatorStack.Pop();
}
