private static Expression ComplexConstant(Complex64 value) {
     if (value.Real != 0.0) {
         if (value.Imag != 0.0) {
             return Expression.Call(
                 typeof(Complex64).GetMethod("Make"),
                 Expression.Constant(value.Real),
                 Expression.Constant(value.Imag)
             );
         } else {
             return Expression.Call(
                 typeof(Complex64).GetMethod("MakeReal"),
                 Expression.Constant(value.Real)
             );
         }
     } else {
         return Expression.Call(
             typeof(Complex64).GetMethod("MakeImaginary"),
             Expression.Constant(value.Imag)
         );
     }
 }

 public static Complex64 Pow(Complex64 baseNumber, Complex64 index)
 {
     if (baseNumber == 0)
       {
     // this is really non-sensical, but the behavior is defined in the spec, so try follow it at least.
     if (index == 0)
     {
       return 1;
     }
     return 0;
       }
       return Exp(index * Log(baseNumber));
 }

 public static Complex64 Plus(Complex64 x) {
     return +x;
 }

 public static Complex64 Divide(Complex64 x, Complex64 y) {
     return x / y;
 }

 public static Complex64 Subtract(Complex64 x, Complex64 y) {
     return x - y;
 }

 public static Complex64 Pow(this Complex64 self, Complex64 power) {
     return self.Power(power);
 }

 public static Complex64 Atan(Complex64 z)
 {
   return i/2 * Log((i + z)/(i - z));
 }

        public static Complex64 Cos(Complex64 z)
        {
          Complex64 z1 = Exp(new Complex64(-z.imag, z.real));
          Complex64 z2 = Exp(new Complex64(z.imag, -z.real));

          return new Complex64(0.5 * (z1.real + z2.real), 0.5 * (z1.imag + z2.imag));
        }

 public static Complex64 Mod(Complex64 x, Complex64 y) {
     return x % y;
 }

        private static double GetAngle(Complex64 num) {
            if (IsNaN(num)) {
                return double.NaN;
            }

            if (double.IsPositiveInfinity(num.Real)) {
                if (double.IsPositiveInfinity(num.Imag)) {
                    return Math.PI * 0.25;
                } else if (double.IsNegativeInfinity(num.Imag)) {
                    return Math.PI * -0.25;
                } else {
                    return 0.0;
                }
            }

            if (double.IsNegativeInfinity(num.Real)) {
                if (double.IsPositiveInfinity(num.Imag)) {
                    return Math.PI * 0.75;
                } else if (double.IsNegativeInfinity(num.Imag)) {
                    return Math.PI * -0.75;
                } else {
                    return DoubleOps.Sign(num.Imag) * Math.PI;
                }
            }

            if (num.Real == 0.0) {
                if (num.Imag != 0.0) {
                    return Math.PI * 0.5 * Math.Sign(num.Imag);
                } else {
                    return (DoubleOps.IsPositiveZero(num.Real) ? 0.0 : Math.PI) * DoubleOps.Sign(GetImag(num));
                }
            }

            return Math.Atan2(num.Imag, num.Real);
        }

 private static double GetImag(Complex64 num) {
     return num.Imag;
 }

 private static bool IsNaN(Complex64 num) {
     return double.IsNaN(num.Real) || double.IsNaN(num.Imag);
 }

 private static bool IsInfinity(Complex64 num) {
     return double.IsInfinity(num.Real) || double.IsInfinity(num.Imag);
 }

 public static Complex64 Acos(Complex64 z)
 {
   return -i * Log(z + i * Sqrt(1 - Pow(z, 2)));
 }

        public static Complex64 Sinh(Complex64 z)
        {
          Complex64 z1 = Exp(z);
          Complex64 z2 = Exp(new Complex64(-z.real, -z.imag));

          return new Complex64(0.5 * (z1.real - z2.real), 0.5 * (z1.imag - z2.imag));
        }

 public static Complex64 Asin(Complex64 z)
 {
   return -i * Log(z * i + Sqrt(1 - Pow(z, 2)));
 }

 public static Complex64 Tan(Complex64 z)
 {
   return Sin(z) / Cos(z);
 }

 public static Complex64 Atanh(Complex64 z)
 {
   throw new NotImplementedException();
 }

 public static Complex64 Tanh(Complex64 z)
 {
   return Sinh(z) / Cosh(z);
 }

 StoreTyped(Complex64 value)
 {
     IntPtr ptr = this.allocator.Alloc((uint)Marshal.SizeOf(typeof(PyComplexObject)));
     CPyMarshal.WriteIntField(ptr, typeof(PyComplexObject), "ob_refcnt", 1);
     CPyMarshal.WritePtrField(ptr, typeof(PyComplexObject), "ob_type", this.PyComplex_Type);
     IntPtr cpxptr = CPyMarshal.GetField(ptr, typeof(PyComplexObject), "cval");
     CPyMarshal.WriteDoubleField(cpxptr, typeof(Py_complex), "real", value.Real);
     CPyMarshal.WriteDoubleField(cpxptr, typeof(Py_complex), "imag", value.Imag);
     this.map.Associate(ptr, value);
     return ptr;
 }