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