//b == Exp(a)
 //c == 1/Exp(a)
 public static void Exp(Complex a, out Complex b, out Complex c)
 {
     double d = Math.Exp(a.Real);
     Complex e = new Complex(Math.Cos(a.Imaginary), Math.Sin(a.Imaginary));
     b = e * d;
     c = b.Reciprocal();
 }

		public static Complex Tanh(Complex z)
		{
			double x = Math.Tanh(z.Re);
			double y = Math.Tan(z.Im);

			return new Complex(x, y) / new Complex(1, x * y);
		}

 public override void addOpperand(Calc calc,Complex c)
 {
     //calc.Opperand1=calc.Total;
     //calc.Opperand2=c;
     calc.Total=c;
     calc.CurrentState=OpperandEnteredState.Singleton;
 }

 public JuliaWithClouds(ulong IterCount, double LeftEdge, double RightEdge, double TopEdge, double BottomEdge, Complex ComplexConst,int MaxAmmountAtTrace=100,int AbcissStepSize=20,int OrdinateStepSize=20)
     : base(IterCount,LeftEdge,RightEdge,TopEdge,BottomEdge,ComplexConst)
 {
     _max_ammount_at_trace = MaxAmmountAtTrace;
     _abciss_step_length = AbcissStepSize;
     _ordinate_step_length = OrdinateStepSize;
 }

 public Hash(Complex[][] comData)
 {
     this.comData = comData;
     width = comData.Length;
     if (width != 0)
         height = 600;
 }

        public static void Start(Random rnd)
        {
            int length = 4096;
            var masComplex1 = new Complex[length];
            var masSimdComplex1 = new Vector2[length];
            var masComplex2 = new Complex[length];
            var masSimdComplex2 = new Vector2[length];
            for (int i = 0; i < length; i++)
            {
                float v1 = (float) rnd.NextDouble()*1000;
                float v2 = (float) rnd.NextDouble()*1000;
                masComplex1[i] = new Complex(v1, v2);
                masSimdComplex1[i] = new Vector2(v1,v2);

                v1 = (float)rnd.NextDouble() * 1000;
                v2 = (float)rnd.NextDouble() * 1000;
                masComplex2[i] = new Complex(v1, v2);
                masSimdComplex2[i] = new Vector2(v1, v2);
            }

            Extensions.TestTime(() =>
                TestWithoutSimd(masComplex1, masComplex2),
                "Время для complex       ");

            Extensions.TestTime(() =>
                TestWithSimd(masSimdComplex1, masSimdComplex2),
                "Время для complex(simd) ");
        }

        private static void VerifyFactoryMethod(double magnitude, double phase)
        {
            double m = magnitude;
            double p = phase;
            Complex c_new = Complex.FromPolarCoordinates(magnitude, phase);
            //Double.IsNaN(magnitude) is checked in the verifiation method.
            if (Double.IsNaN(phase) || Double.IsInfinity(phase))
            {
                magnitude = Double.NaN;
                phase = Double.NaN;
            }
            // Special check in Complex.Abs method
            else if (Double.IsInfinity(magnitude))
            {
                magnitude = Double.PositiveInfinity;
                phase = Double.NaN;
            }

            if (false == Support.VerifyMagnitudePhaseProperties(c_new, magnitude, phase))
            {
                Console.WriteLine("Error_89fdl!!! FromPolorCoordinates: ({0}, {1})", m, p);

                Assert.True(false, "Verification Failed");
            }
            else // if the first verification returns TrUe, do the second one!
            {
                Complex c_new_ctor = new Complex(c_new.Real, c_new.Imaginary);
                if (false == Support.VerifyMagnitudePhaseProperties(c_new_ctor, magnitude, phase))
                {
                    Console.WriteLine("Error_fs46!!! FromPolorCoordinates: ({0}, {1})", m, p);

                    Assert.True(false, "Verification Failed");
                }
            }
        }

 //---------------------------------------------------------------------------------------------
 /// <summary>
 ///   Clamp length (modulus) of the elements in the complex array
 /// </summary>
 /// <param name = "array"></param>
 /// <param name = "fMinimum"></param>
 /// <param name = "fMaximum"></param>
 public static void ClampLength(Complex[] array, double fMinimum, double fMaximum)
 {
     for (int i = 0; i < array.Length; i++)
     {
         array[i] = Complex.FromModulusArgument(Math.Max(fMinimum, Math.Min(fMaximum, array[i].GetModulus())), array[i].GetArgument());
     }
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="UserQR"/> class. This object will compute the
        /// QR factorization when the constructor is called and cache it's factorization.
        /// </summary>
        /// <param name="matrix">The matrix to factor.</param>
        /// <param name="method">The QR factorization method to use.</param>
        /// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <c>null</c>.</exception>
        public static UserQR Create(Matrix<Complex> matrix, QRMethod method = QRMethod.Full)
        {
            if (matrix.RowCount < matrix.ColumnCount)
            {
                throw Matrix.DimensionsDontMatch<ArgumentException>(matrix);
            }

            Matrix<Complex> q;
            Matrix<Complex> r;

            var minmn = Math.Min(matrix.RowCount, matrix.ColumnCount);
            var u = new Complex[minmn][];

            if (method == QRMethod.Full)
            {
                r = matrix.Clone();
                q = Matrix<Complex>.Build.SameAs(matrix, matrix.RowCount, matrix.RowCount);

                for (var i = 0; i < matrix.RowCount; i++)
                {
                    q.At(i, i, 1.0f);
                }

                for (var i = 0; i < minmn; i++)
                {
                    u[i] = GenerateColumn(r, i, i);
                    ComputeQR(u[i], r, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                }

                for (var i = minmn - 1; i >= 0; i--)
                {
                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.RowCount, Control.MaxDegreeOfParallelism);
                }
            }
            else
            {
                q = matrix.Clone();

                for (var i = 0; i < minmn; i++)
                {
                    u[i] = GenerateColumn(q, i, i);
                    ComputeQR(u[i], q, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                }

                r = q.SubMatrix(0, matrix.ColumnCount, 0, matrix.ColumnCount);
                q.Clear();

                for (var i = 0; i < matrix.ColumnCount; i++)
                {
                    q.At(i, i, 1.0f);
                }

                for (var i = minmn - 1; i >= 0; i--)
                {
                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                }
            }

            return new UserQR(q, r, method);
        }

        public static Complex operator +(Complex c1, Complex c2)
        {
            int cnt = c1.b * c2.b;
            int sum = c2.b * c1.a + c1.b * c2.a;
            if (cnt > sum)
            {
                for (int i = sum; i > 2; i--)
                {
                    if (cnt % i == 0 && sum % i == 0)
                    {
                        cnt = cnt / i;
                        sum = sum / i;
                        break;
                    }
                }
            }
            else
            {
                for (int i = cnt; i > 2; i--)
                {
                    if (cnt % i == 0 && sum % i == 0)
                    {
                        cnt = cnt / i;
                        sum = sum / i;
                        break;
                    }

                }
            }
            Complex c3 = new Complex(sum, cnt);
            return c3;
        }

        static void Main(string[] args)
        {
            Complex c1 = new Complex(1, 2);
            Complex c2 = new Complex(1, 2);
            Complex c3 = new Complex();

            Console.WriteLine(c1);
            Console.WriteLine(c2);
            Console.WriteLine(c3);

            Complex c4 = c1.Add(c2);
            Console.WriteLine(c4);

            Complex c5 = c2.Subtract(c1);
            Console.WriteLine(c5);

            Complex c6 = c1.Multiply(c2);
            Console.WriteLine(c6);

                      
            if(c1.Equals(c2))
                Console.WriteLine("c1 este egal cu c2");
            else
                Console.WriteLine("c1 nu este egal cu c2");

        }

 public void SetVar(string varname, Complex value)
 {
     var root = Root;
     if (root.m_variables == null)
         root.m_variables = new Dictionary<string, Complex>();
     root.m_variables[varname.ToLower()] = value;
 }

        public void ExecuteWithParamsTest()
        {
            var complex = new Complex(5, 2);
            var exp = new ComplexNumber(complex);

            Assert.Equal(complex, exp.Execute(null));
        }

        public void ExecuteTest()
        {
            var complex = new Complex(5, 2);
            var exp = new ComplexNumber(complex);

            Assert.Equal(complex, exp.Execute());
        }

        public void processData(ref Complex[][] res, ref int resLen)
        {
            resLen = 0;

            int channels = 2;
            int pbs = 4096*2*channels;

            for(int i = 0; i<len/pbs; i++)
            {

                comData = new Complex[10000];
                comLen = 0;

                for (int j = i*pbs, cur = 0; j < (i+1)*pbs; j+=2*channels, cur++)
                {
                    float sum = 0;
                    for (int k = 0; k < channels; k++)
                        sum += (buf[j + 2 * k + 1] << 8) | (buf[j + 2 * k]);
                    sum /= channels;
                    comData[comLen].X = sum;
                    comData[comLen].X *= (float)FastFourierTransform.HammingWindow(cur, 4096);
                    comData[comLen].Y = 0;
                    comLen++;
                }

                FastFourierTransform.FFT(true, 12, comData);

                res[resLen] = comData;
                resLen++;
            }
            resLen++;
            resLen--;
        }

        /// <summary>
        /// Gets the correlation.
        /// </summary>
        /// <param name="originalVector">The original vector.</param>
        /// <param name="correlationVector">The correlation vector.</param>
        /// <returns></returns>
        /// <exception cref="System.ArgumentException">Different length of vectors</exception>
        public static Complex[] GetCorrelation(Complex[] originalVector, Complex[] correlationVector)
        {
            if (originalVector.Length != correlationVector.Length)
            {
                throw new ArgumentException("Different length of vectors");
            }

            CorrelationComplexibility = 0;

            // ReSharper disable once InconsistentNaming
            var N = originalVector.Length;
            var result = new Complex[N];

            for (var i = 0; i < N; i++)
            {
                for (var j = 0; j < N; j++)
                {
                    if (i + j < N)
                    {
                        result[i] += originalVector[j] * correlationVector[i + j];
                        CorrelationComplexibility++;
                    }
                    else
                    {
                        result[i] += originalVector[j] * correlationVector[i + j - N];
                        CorrelationComplexibility++;
                    }
                }

                result[i] /= N;
            }

            return result;
        }

    }//multiply

    public cFloat divide(cFloat c1, cFloat c2){
      Complex comp1 = new Complex(c1.getReal(), c1.getImg());
      Complex comp2 = new Complex(c2.getReal(), c1.getImg());
      Complex comp3 = comp1 / comp2;

      return new cFloat((float)comp3.Real, (float)comp3.Imaginary);
    }//divide

        private static void VerifyBinaryMultiplyResult(Double realFirst, Double imgFirst, Double realSecond, Double imgSecond)
        {
            // calculate the expected results
            Double realExpectedResult = realFirst * realSecond - imgFirst * imgSecond;
            Double imaginaryExpectedResult = realFirst * imgSecond + imgFirst * realSecond;

            // Create complex numbers
            Complex cFirst = new Complex(realFirst, imgFirst);
            Complex cSecond = new Complex(realSecond, imgSecond);

            // arithmetic multiply (binary) operation
            Complex cResult = cFirst * cSecond;

            // verify the result
            if (false == Support.VerifyRealImaginaryProperties(cResult, realExpectedResult, imaginaryExpectedResult))
            {
                Console.WriteLine("ErRoR! Binary Multiply Error!");
                Console.WriteLine("Binary Multiply test = ({0}, {1}) * ({2}, {3})", realFirst, imgFirst, realSecond, imgSecond);
                Assert.True(false, "Verification Failed");
            }

            // arithmetic multiply (static) operation
            cResult = Complex.Multiply(cFirst, cSecond);

            // verify the result
            if (false == Support.VerifyRealImaginaryProperties(cResult, realExpectedResult, imaginaryExpectedResult))
            {
                Console.WriteLine("ErRoR! Multiply (Static) Error!");
                Console.WriteLine("Multiply (Static) test = ({0}, {1}) * ({2}, {3})", realFirst, imgFirst, realSecond, imgSecond);
                Assert.True(false, "Verification Failed");
            }
        }

 /// <summary>
 /// Clamp elements in the complex array to range [minimum,maximum]
 /// </summary>
 /// <param name="array"></param>
 /// <param name="minimum"></param>
 /// <param name="maximum"></param>
 public static void Clamp( Complex[] array, Complex minimum, Complex maximum )
 {
     for( int i = 0; i < array.Length; i ++ ) {
         array[i].Re	= Math.Min( Math.Max( array[ i ].Re, minimum.Re ), maximum.Re );
         array[i].Im	= Math.Min( Math.Max( array[ i ].Re, minimum.Im ), maximum.Im );
     }
 }

        private static void VerifySqrtWithRectangularForm(Double real, Double imaginary)
        {
            // sqrt(a+bi) = +- (sqrt(r + a) + i sqrt(r - a) sign(b)) sqrt(2) / 2, unless a=-r and y = 0
            Complex complex = new Complex(real, imaginary);

            Double expectedReal = 0.0;
            Double expectedImaginary = 0.0;

            if (0 == imaginary)
            {
                if (real == -complex.Magnitude)
                    expectedImaginary = Math.Sqrt(-real);
                else
                    expectedReal = Math.Sqrt(real);
            }
            else
            {
                Double scale = 1 / Math.Sqrt(2);
                expectedReal = scale * Math.Sqrt(complex.Magnitude + complex.Real);
                expectedImaginary = scale * Math.Sqrt(complex.Magnitude - complex.Real);
                if (complex.Imaginary < 0)
                {
                    expectedImaginary = -expectedImaginary;
                }
            }
            VerifySqrtWithRectangularForm(real, imaginary, expectedReal, expectedImaginary);
        }