public static object Power(BigInteger x, long y)
{
if ((int)y == y)
{
return(Power(x, (int)y));
}
else
{
if (y < 0)
{
return(FloatOps.Power(x.ToFloat64(), y));
}
if (x == BigInteger.Zero)
{
return(BigInteger.Zero);
}
else if (x == BigInteger.One)
{
return(BigInteger.One);
}
else
{
throw Ops.ValueError("Number too big");
}
}
}
public static object Power(BigInteger x, int y)
{
if (y < 0)
{
return(FloatOps.Power(x.ToFloat64(), y));
}
return(x.Power(y));
}
internal static object Power(int x, int power)
{
if (power == 0)
{
return(1);
}
if (power < 0)
{
if (x == 0)
{
throw Ops.ZeroDivisionError("0.0 cannot be raised to a negative power");
}
return(FloatOps.Power(x, power));
}
int factor = x;
int result = 1;
int savePower = power;
try {
checked {
while (power != 0) //??? this loop has redundant checks for exit condition
{
if ((power & 1) != 0)
{
result = result * factor;
}
if (power == 1)
{
break;
}
factor = factor * factor;
power >>= 1;
}
return(result);
}
} catch (OverflowException) {
return(LongOps.Power(BigInteger.Create(x), savePower));
}
}
public static object Power(long x, long exp)
{
if (exp == 0)
{
return(1);
}
if (exp == 1)
{
return(x);
}
if (exp < 0)
{
return(FloatOps.Power(x, exp));
}
long saveexp = exp;
long result = 1;
long factor = x;
try {
checked {
while (exp != 0)
{
if ((exp & 1) != 0)
{
result = result * factor;
}
if (exp == 1)
{
break; // save possible overflow in the multiply
}
factor = factor * factor;
exp >>= 1;
}
return(result);
}
} catch (OverflowException) {
return(LongOps.Power(BigInteger.Create(x), saveexp));
}
}
public static object Power(BigInteger x, double y)
{
return(FloatOps.Power(x.ToFloat64(), y));
}
public static object Power(int x, object other)
{
if (other is int)
{
return(Power(x, (int)other));
}
else if (other is BigInteger)
{
BigInteger lexp = (BigInteger)other;
int iexp;
if (lexp.AsInt32(out iexp))
{
return(Power(x, iexp));
}
else
{
if (x == 0)
{
return(0);
}
if (x == 1)
{
return(1);
}
throw Ops.ValueError("number too big");
}
}
else if (other is long)
{
long lexp = (long)other;
int iexp = (int)lexp;
if (lexp == iexp)
{
return(Power(x, iexp));
}
else
{
if (x == 0)
{
return(0);
}
if (x == 1)
{
return(1);
}
throw Ops.ValueError("Number too big");
}
}
else if (other is double)
{
return(FloatOps.Power(x, (double)other));
}
else if (other is bool)
{
return(Power(x, (bool)other ? 1 : 0));
}
else if (other is float)
{
return(FloatOps.Power(x, (float)other));
}
else if (other is Complex64)
{
return(ComplexOps.Power(x, other));
}
else if (other is byte)
{
return(Power(x, (int)(byte)other));
}
else if (other is ExtensibleInt)
{
return(Power(x, ((ExtensibleInt)other).value));
}
else if (other is ExtensibleFloat)
{
return(FloatOps.Power(x, ((ExtensibleFloat)other).value));
}
else if (other is ExtensibleComplex)
{
return(ComplexOps.Power(x, ((ExtensibleComplex)other).value));
}
return(Ops.NotImplemented);
}
private static object Power(long x, double y)
{
return(FloatOps.Power(x, y));
}
