示例#1
0
        /// <summary>
        /// Raises a complex number to an integer power.
        /// </summary>
        /// <param name="z">The argument.</param>
        /// <param name="n">The power.</param>
        /// <returns>The value of z<sup>n</sup>.</returns>
        public static Complex Pow(Complex z, int n)
        {
            if (n < 0)
            {
                return(1.0 / Pow(z, -n));
            }

            switch (n)
            {
            case 0:
                // We follow convention that 0^0 = 1
                return(1.0);

            case 1:
                return(z);

            case 2:
                // 1 multiply
                return(Sqr(z));

            case 3:
                // 2 multiplies
                return(Sqr(z) * z);

            case 4: {
                // 2 multiplies
                Complex z2 = Sqr(z);
                return(Sqr(z2));
            }

            case 5: {
                // 3 multiplies
                Complex z2 = Sqr(z);
                return(Sqr(z2) * z);
            }

            case 6: {
                // 3 multiplies
                Complex z2 = Sqr(z);
                return(Sqr(z2) * z2);
            }

            case 7: {
                // 4 multiplies
                Complex z3 = Sqr(z) * z;
                return(Sqr(z3) * z);
            }

            case 8: {
                // 3 multiplies
                Complex z2 = Sqr(z);
                Complex z4 = Sqr(z2);
                return(Sqr(z4));
            }

            case 9: {
                // 4 multiplies
                Complex z3 = Sqr(z) * z;
                return(Sqr(z3) * z3);
            }

            case 10: {
                // 4 multiplies
                Complex z2 = Sqr(z);
                Complex z4 = Sqr(z2);
                return(Sqr(z4) * z2);
            }

            case 12: {
                // 4 multiplies
                Complex z3 = Sqr(z) * z;
                Complex z6 = Sqr(z3);
                return(Sqr(z6));
            }

            case 16: {
                // 4 multiplies
                Complex z2 = Sqr(z);
                Complex z4 = Sqr(z2);
                Complex z8 = Sqr(z4);
                return(Sqr(z8));
            }

            // that's all the cases do-able in 4 or fewer complex multiplies
            default:
                return(ComplexMath.Pow(z, (double)n));
            }
        }
示例#2
0
        /// <summary>
        /// Raises a complex number to an integer power.
        /// </summary>
        /// <param name="z">The argument.</param>
        /// <param name="n">The power.</param>
        /// <returns>The value of z<sup>n</sup>.</returns>
        public static Complex Pow(Complex z, int n)
        {
            // this is a straight-up copy of MoreMath.Pow with x -> z, double -> Complex

            if (n < 0)
            {
                return(1.0 / Pow(z, -n));
            }

            switch (n)
            {
            case 0:
                // we follow convention that 0^0 = 1
                return(1.0);

            case 1:
                return(z);

            case 2:
                // 1 multiply
                return(z * z);

            case 3:
                // 2 multiplies
                return(z * z * z);

            case 4: {
                // 2 multiplies
                Complex z2 = z * z;
                return(z2 * z2);
            }

            case 5: {
                // 3 multiplies
                Complex z2 = z * z;
                return(z2 * z2 * z);
            }

            case 6: {
                // 3 multiplies
                Complex z2 = z * z;
                return(z2 * z2 * z2);
            }

            case 7: {
                // 4 multiplies
                Complex z3 = z * z * z;
                return(z3 * z3 * z);
            }

            case 8: {
                // 3 multiplies
                Complex z2 = z * z;
                Complex z4 = z2 * z2;
                return(z4 * z4);
            }

            case 9: {
                // 4 multiplies
                Complex z3 = z * z * z;
                return(z3 * z3 * z3);
            }

            case 10: {
                // 4 multiplies
                Complex z2 = z * z;
                Complex z4 = z2 * z2;
                return(z4 * z4 * z2);
            }

            default:
                return(ComplexMath.Pow(z, (double)n));
            }
        }