/// <summary>
        /// Does a point wise add of two arrays <c>z = x + y</c>. This can be used
        /// to add vectors or matrices.
        /// </summary>
        /// <param name="x">The array x.</param>
        /// <param name="y">The array y.</param>
        /// <param name="result">The result of the addition.</param>
        /// <remarks>There is no equivalent BLAS routine, but many libraries
        /// provide optimized (parallel and/or vectorized) versions of this
        /// routine.</remarks>
        public virtual void AddArrays(Complex[] x, Complex[] y, Complex[] result)
        {
            if (y == null)
            {
                throw new ArgumentNullException("y");
            }

            if (x == null)
            {
                throw new ArgumentNullException("x");
            }

            if (result == null)
            {
                throw new ArgumentNullException("result");
            }

            if (y.Length != x.Length || y.Length != result.Length)
            {
                throw new ArgumentException(Resources.ArgumentVectorsSameLength);
            }

            CommonParallel.For(0, y.Length, 4096, (a, b) =>
            {
                for (int i = a; i < b; i++)
                {
                    result[i] = x[i] + y[i];
                }
            });
        }

        public void BackwardReal(double[] spectrum, int n, FourierTransformScaling scaling)
        {
            // TODO: backport proper, optimized implementation from Iridium

            Complex[] data = new Complex[n];
            data[0] = new Complex(spectrum[0], 0d);
            for (int i = 1, j = 2; i < data.Length/2; i++)
            {
                data[i] = new Complex(spectrum[j++], spectrum[j++]);
                data[data.Length - i] = data[i].Conjugate();
            }
            if (n.IsEven())
            {
                data[data.Length/2] = new Complex(spectrum[n], 0d);
            }
            else
            {
                data[data.Length/2] = new Complex(spectrum[n-1], spectrum[n]);
                data[data.Length/2 + 1] = data[data.Length/2].Conjugate();
            }

            Backward(data, scaling);

            for (int i = 0; i < data.Length; i++)
            {
                spectrum[i] = data[i].Real;
            }
            spectrum[n] = 0d;
        }

        /// <summary>
        ///   Computes the absolute value of an array of complex numbers.
        /// </summary>
        /// 
        public static Complex[] Abs(this Complex[] x)
        {
            if (x == null) throw new ArgumentNullException("x");

            Complex[] r = new Complex[x.Length];
            for (int i = 0; i < x.Length; i++)
                r[i] = new Complex(x[i].Magnitude, 0);
            return r;
        }

        public CompilerOutput(string input, Tokens tokens, System.Numerics.Complex returnVal, ParseTree parseTree, 
			PostfixedTokens postFixedTokens, string output)
        {
            this.Input = input;
                this.Tokens = tokens;
                this.ReturnValue = returnVal;
                this.ParseTree = parseTree;
                this.PostFixedTokens = postFixedTokens;
                this.Output = output;
        }

        static int findRecurringCycleLength(int number)
        {
            //string numString = Decimal.Round((1 / (decimal)number), 28).ToString();
            string numString = (1 / (decimal)number).ToString();

            System.Numerics.Complex numerator = new System.Numerics.Complex(1, 1);
            System.Numerics.Complex denominator = new System.Numerics.Complex(number, number);

            System.Numerics.Complex muh = numerator / denominator;
            return 0;
        }

        /// <summary>
        ///   Elementwise multiplication of two complex vectors.
        /// </summary>
        /// 
        public static Complex[] Multiply(this Complex[] a, Complex[] b)
        {
            if (a == null) throw new ArgumentNullException("a");
            if (b == null) throw new ArgumentNullException("b");

            Complex[] r = new Complex[a.Length];
            for (int i = 0; i < a.Length; i++)
            {
                r[i] = Complex.Multiply(a[i], b[i]);
            }
            return r;
        }

        /// <summary>
        /// Generate the bluestein sequence for the provided problem size.
        /// </summary>
        /// <param name="n">Number of samples.</param>
        /// <returns>Bluestein sequence exp(I*Pi*k^2/N)</returns>
        private static Complex[] BluesteinSequence(int n)
        {
            double s = Constants.Pi / n;
            var sequence = new Complex[n];

            for (int k = 0; k < sequence.Length; k++)
            {
                double t = s * (k * k);
                sequence[k] = new Complex(Math.Cos(t), Math.Sin(t));
            }

            return sequence;
        }

        /// <summary>
        /// Rescale FFT-the resulting vector according to the provided convention options.
        /// </summary>
        /// <param name="options">Fourier Transform Convention Options.</param>
        /// <param name="samples">Sample Vector.</param>
        private static void ForwardScaleByOptions(FourierOptions options, Complex[] samples)
        {
            if ((options & FourierOptions.NoScaling) == FourierOptions.NoScaling ||
                (options & FourierOptions.AsymmetricScaling) == FourierOptions.AsymmetricScaling)
            {
                return;
            }

            var scalingFactor = Math.Sqrt(1.0 / samples.Length);
            for (int i = 0; i < samples.Length; i++)
            {
                samples[i] *= scalingFactor;
            }
        }

        /// <summary>
        /// Convolution with the bluestein sequence (Parallel Version).
        /// </summary>
        /// <param name="samples">Sample Vector.</param>
        private static void BluesteinConvolutionParallel(Complex[] samples)
        {
            int n = samples.Length;
            Complex[] sequence = BluesteinSequence(n);

            // Padding to power of two >= 2N–1 so we can apply Radix-2 FFT.
            int m = ((n << 1) - 1).CeilingToPowerOfTwo();
            Complex[] b = new Complex[m];
            Complex[] a = new Complex[m];

            CommonParallel.Invoke(
                () =>
                {
                    // Build and transform padded sequence b_k = exp(I*Pi*k^2/N)
                    for (int i = 0; i < n; i++)
                    {
                        b[i] = sequence[i];
                    }

                    for (int i = m - n + 1; i < b.Length; i++)
                    {
                        b[i] = sequence[m - i];
                    }

                    Radix2(b, -1);
                },
                () =>
                {
                    // Build and transform padded sequence a_k = x_k * exp(-I*Pi*k^2/N)
                    for (int i = 0; i < samples.Length; i++)
                    {
                        a[i] = sequence[i].Conjugate() * samples[i];
                    }

                    Radix2(a, -1);
                });

            for (int i = 0; i < a.Length; i++)
            {
                a[i] *= b[i];
            }

            Radix2Parallel(a, 1);

            var nbinv = 1.0 / m;
            for (int i = 0; i < samples.Length; i++)
            {
                samples[i] = nbinv * sequence[i].Conjugate() * a[i];
            }
        }

 public void Backward(Complex[] spectrum, FourierTransformScaling scaling)
 {
     switch (scaling)
     {
         case FourierTransformScaling.SymmetricScaling:
             Fourier.BluesteinInverse(spectrum, FourierOptions.Default);
             break;
         case FourierTransformScaling.BackwardScaling:
             Fourier.BluesteinInverse(spectrum, FourierOptions.AsymmetricScaling);
             break;
         default:
             Fourier.BluesteinInverse(spectrum, FourierOptions.NoScaling);
             break;
     }
 }

        /// <summary>
        /// Numerically stable hypotenuse of a right angle triangle, i.e. <code>(a,b) -> sqrt(a^2 + b^2)</code>
        /// </summary>
        /// <param name="a">The length of side a of the triangle.</param>
        /// <param name="b">The length of side b of the triangle.</param>
        /// <returns>Returns <code>sqrt(a<sup>2</sup> + b<sup>2</sup>)</code> without underflow/overflow.</returns>
        public static Complex Hypotenuse(Complex a, Complex b)
        {
            if (a.Magnitude > b.Magnitude)
            {
                var r = b.Magnitude / a.Magnitude;
                return a.Magnitude * Math.Sqrt(1 + (r * r));
            }

            if (b != 0.0)
            {
                // NOTE (ruegg): not "!b.AlmostZero()" to avoid convergence issues (e.g. in SVD algorithm)
                var r = a.Magnitude / b.Magnitude;
                return b.Magnitude * Math.Sqrt(1 + (r * r));
            }

            return 0d;
        }

        static void Main(string [] args)
        {
            using (Lua lua = new Lua())
             		{
             lua.DebugHook += DebugHook;
             lua.SetDebugHook (NLua.Event.EventMasks.LUA_MASKLINE, 0);
             var a = new System.Numerics.Complex (10, 0);
             var b = new System.Numerics.Complex (0, 3);
             var x = a + b;

            // lua.LoadCLRPackage ();
             lua ["a"] = a;
             lua ["b"] = 1;
             var res = lua.DoString (@"return a + b")[0];

             		}
        }

        /// <summary>
        /// Rescale the iFFT-resulting vector according to the provided convention options.
        /// </summary>
        /// <param name="options">Fourier Transform Convention Options.</param>
        /// <param name="samples">Sample Vector.</param>
        private static void InverseScaleByOptions(FourierOptions options, Complex[] samples)
        {
            if ((options & FourierOptions.NoScaling) == FourierOptions.NoScaling)
            {
                return;
            }

            var scalingFactor = 1.0 / samples.Length;
            if ((options & FourierOptions.AsymmetricScaling) != FourierOptions.AsymmetricScaling)
            {
                scalingFactor = Math.Sqrt(scalingFactor);
            }

            for (int i = 0; i < samples.Length; i++)
            {
                samples[i] *= scalingFactor;
            }
        }

        /// <summary>
        /// Bluestein generic FFT for arbitrary sized sample vectors.
        /// </summary>
        /// <param name="samples">Time-space sample vector.</param>
        /// <param name="exponentSign">Fourier series exponent sign.</param>
        internal static void Bluestein(Complex[] samples, int exponentSign)
        {
            int n = samples.Length;
            if (n.IsPowerOfTwo())
            {
                Radix2(samples, exponentSign);
                return;
            }

            if (exponentSign == 1)
            {
                SwapRealImaginary(samples);
            }

            BluesteinConvolutionParallel(samples);

            if (exponentSign == 1)
            {
                SwapRealImaginary(samples);
            }
        }

        /// <summary>
        /// Does a point wise add of two arrays <c>z = x + y</c>. This can be used 
        /// to add vectors or matrices.
        /// </summary>
        /// <param name="x">The array x.</param>
        /// <param name="y">The array y.</param>
        /// <param name="result">The result of the addition.</param>
        /// <remarks>There is no equivalent BLAS routine, but many libraries
        /// provide optimized (parallel and/or vectorized) versions of this
        /// routine.</remarks>
        public virtual void AddArrays(Complex[] x, Complex[] y, Complex[] result)
        {
            if (y == null)
            {
                throw new ArgumentNullException("y");
            }

            if (x == null)
            {
                throw new ArgumentNullException("x");
            }

            if (result == null)
            {
                throw new ArgumentNullException("result");
            }

            if (y.Length != x.Length || y.Length != result.Length)
            {
                throw new ArgumentException(Resources.ArgumentVectorsSameLength);
            }

            if (Control.ParallelizeOperation(x.Length))
            {
                CommonParallel.For(0, y.Length, 4096, (a, b) =>
                    {
                        for (int i = a; i < b; i++)
                        {
                            result[i] = x[i] + y[i];
                        }
                    });
            }
            else
            {
                for (var index = 0; index < x.Length; index++)
                {
                    result[index] = x[index] + y[index];
                }
            }
        }

        /// <summary>
        /// Naive generic DFT, useful e.g. to verify faster algorithms.
        /// </summary>
        /// <param name="samples">Time-space sample vector.</param>
        /// <param name="exponentSign">Fourier series exponent sign.</param>
        /// <returns>Corresponding frequency-space vector.</returns>
        internal static Complex[] Naive(Complex[] samples, int exponentSign)
        {
            var w0 = exponentSign*Constants.Pi2/samples.Length;
            var spectrum = new Complex[samples.Length];

            CommonParallel.For(0, samples.Length, (u, v) =>
                {
                    for (int i = u; i < v; i++)
                    {
                        var wk = w0*i;
                        var sum = Complex.Zero;
                        for (var n = 0; n < samples.Length; n++)
                        {
                            var w = n*wk;
                            sum += samples[n]*new Complex(Math.Cos(w), Math.Sin(w));
                        }

                        spectrum[i] = sum;
                    }
                });

            return spectrum;
        }

		public void TestOperatorNotEqual ()
		{
			using (Lua lua = new Lua ()) {
				var a = new System.Numerics.Complex (10, 0);
				var b = new System.Numerics.Complex (0, 3);
				var x = a != b;

				lua ["a"] = a;
				lua ["b"] = b;
				var res = lua.DoString (@"return a ~= b") [0];
				Assert.AreEqual (x, res);
			}
		}

 /// <summary>
 /// Bluestein inverse FFT for arbitrary sized sample vectors.
 /// </summary>
 /// <param name="samples">Sample vector, where the FFT is evaluated in place.</param>
 /// <param name="options">Fourier Transform Convention Options.</param>
 public void BluesteinInverse(Complex[] samples, FourierOptions options)
 {
     Bluestein(samples, -SignByOptions(options));
     InverseScaleByOptions(options, samples);
 }

 /// <summary>
 /// Naive forward DFT, useful e.g. to verify faster algorithms.
 /// </summary>
 /// <param name="timeSpace">Time-space sample vector.</param>
 /// <param name="options">Fourier Transform Convention Options.</param>
 /// <returns>Corresponding frequency-space vector.</returns>
 public Complex[] NaiveForward(Complex[] timeSpace, FourierOptions options)
 {
     var frequencySpace = Naive(timeSpace, SignByOptions(options));
     ForwardScaleByOptions(options, frequencySpace);
     return frequencySpace;
 }

 /// <summary>
 /// Swap the real and imaginary parts of each sample.
 /// </summary>
 /// <param name="samples">Sample Vector.</param>
 private static void SwapRealImaginary(Complex[] samples)
 {
     for (int i = 0; i < samples.Length; i++)
     {
         samples[i] = new Complex(samples[i].Imaginary, samples[i].Real);
     }
 }