// оператор + ____________________________________________________________________________________________ // оператор - ____________________________________________________________________________________________ public static Complex operator -(Complex FirstComplex, Complex SecondComplex) { if (FirstComplex.DNum != SecondComplex.DNum) { int Temp; Temp = FirstComplex.DNum; FirstComplex.UNum *= SecondComplex.DNum; FirstComplex.DNum *= SecondComplex.DNum; SecondComplex.DNum *= Temp; SecondComplex.UNum *= Temp; Complex TEMP = new Complex(FirstComplex.UNum - SecondComplex.UNum, FirstComplex.DNum); Console.WriteLine(FirstComplex.UNum); Console.WriteLine(SecondComplex.UNum); while (TEMP.DNum != 0 && TEMP.UNum != 0) { if (TEMP.DNum > TEMP.UNum) TEMP.DNum %= TEMP.UNum; else TEMP.UNum %= TEMP.DNum; } Complex Result = new Complex((FirstComplex.UNum - SecondComplex.UNum) / Math.Abs(TEMP.DNum + TEMP.UNum), FirstComplex.DNum / Math.Abs(TEMP.DNum + TEMP.UNum)); return Result; } Complex ResultElse = new Complex(FirstComplex.UNum - SecondComplex.UNum, FirstComplex.DNum); return ResultElse; }
public void SubtrachtTest() { calculator = new ComplexNumbers.Calculator(); Complex<double> actual = calculator.Subtracht(new Complex<double>(4, 5), new Complex<double>(6, 7)); Complex<double> expected = new Complex<double>(4 - 6, 5 - 7); Assert.True(actual.Equals(expected)); }
/// <summary> /// Initializes a new instance of the ComplexRational class, /// by directly referencing the two provided polynomial coefficients. /// </summary> public ComplexRational( Complex[] numeratorCoefficients, Complex[] denominatorCoefficients) { _numerator = new ComplexPolynomial(numeratorCoefficients); _denominator = new ComplexPolynomial(denominatorCoefficients); }
public void TestDivision() { // 0/1 Complex zeroDivOne = Complex.Zero / Complex.One; Assert.That(zeroDivOne.Real, Is.EqualTo(0), "Re{0/1} = 0"); Assert.That(zeroDivOne.Imag, Is.EqualTo(0), "Im{0/1} = 0"); // 1/0 // TODO: verify this is really what should happen Complex oneDivZero = Complex.One / Complex.Zero; Assert.That(oneDivZero.Real, Is.EqualTo(double.PositiveInfinity), "Re{1/0} = infty"); Assert.That(oneDivZero.Imag, Is.EqualTo(double.PositiveInfinity), "Im{1/0} = infty"); // (1+2I)/(3+4I) Complex onePlus2I = new Complex(1, 2); Complex threePlus4I = new Complex(3, 4); Complex onPlus2IDivthreePlus4I = onePlus2I / threePlus4I; Assert.That(onPlus2IDivthreePlus4I.Real, Is.EqualTo(11d / 25d), "Re{(1+2I)/(3+4I)} = 11/25"); Assert.That(onPlus2IDivthreePlus4I.Imag, Is.EqualTo(2d / 25d), "Im{(1+2I)/(3+4I)} = 2/25"); // (big+big*I)/(2*big+2*big*I) const double big1 = double.MaxValue / 4; const double big2 = double.MaxValue / 2; Complex big1PlusBig1I = new Complex(big1, big1); Complex big2PlusBig2I = new Complex(big2, big2); Complex big1PlusBig1IDivBig2PlusBig2I = big1PlusBig1I / big2PlusBig2I; Assert.That(big1PlusBig1IDivBig2PlusBig2I.Real, Is.EqualTo(0.5), "Re{(big+big*I)/(2*big+2*big*I)} = 0.5"); Assert.That(big1PlusBig1IDivBig2PlusBig2I.Imag, Is.EqualTo(0), "Im{((big+big*I)/(2*big+2*big*I)} = 0"); }
/// <summary> /// Returns are much larger the real or imaginary part of a complex number. /// If the ratio of real and imaginary parts of complex number are not so large /// returns the initial value. /// </summary> /// <param name="value">A complex number.</param> /// <param name="complexThreshold">An integer representing the complex threshold.</param> /// <returns> /// Are much larger the real or imaginary part of the value. /// If the ratio of real and imaginary parts of the value are not so large /// returns the value. /// </returns> /// <exception cref="System.ArgumentOutOfRangeException"> /// complexThreshold must be between 0 and 307. /// </exception> public static Complex ComplexThreshold(Complex value, int complexThreshold) { if (complexThreshold < 0 || complexThreshold > MaxComplexZeroThreshold) throw new ArgumentOutOfRangeException("complexThreshold", String.Format("Complex threshold must be between 0 and {0}.", MaxComplexZeroThreshold)); if (value.IsReal || value.IsImaginary) { return value; } double d = Math.Pow(10, complexThreshold); double reAbs = Math.Abs(value.Re); double imAbs = Math.Abs(value.Im); if ((reAbs > imAbs) && (reAbs / imAbs > d)) { return new Complex(value.Re, 0.0); } else if ((imAbs > reAbs) && (imAbs / reAbs > d)) { return new Complex(0.0, value.Im); } return value; }
public static double Compute(Complex a, Complex b) { Complex temp = a * ComplexMath.Conjugate(a); temp += (b * ComplexMath.Conjugate(b)); double ret = ComplexMath.Absolute(temp); return System.Math.Sqrt(ret); }
public void MultiplyTest() { calculator = new ComplexNumbers.Calculator(); Complex<double> actual = calculator.Multiply(new Complex<double>(4, 5), new Complex<double>(6, 7)); Complex<double> expected = new Complex<double>(4 * 6 - 5 * 7, 5 * 6 + 4 * 7); Assert.True(actual.Equals(expected)); }
private static bool IsConstant(string equation, int index, out string n, out Complex val) { var spi = Term.ExtractName(equation, index, false).ToLower(); if (cs.Contains(spi, StringComparer.OrdinalIgnoreCase)) { n = spi; var consts = typeof (Constants).GetProperties(BindingFlags.Public | BindingFlags.Static); if ( consts.Any( x => Attribute.IsDefined(x, typeof (MathConst)) && (Attribute.GetCustomAttribute(x, typeof (MathConst)) as MathConst).Name == spi.ToLower())) { var prop = consts.First( x => Attribute.IsDefined(x, typeof (MathConst)) && (Attribute.GetCustomAttribute(x, typeof (MathConst)) as MathConst).Name == spi.ToLower()); val = (Complex) (prop.GetValue(null, null)); return true; } else { val = double.NaN; return false; } } n = null; val = double.NaN; return false; }
/// <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(NumericsResources.ArgumentVectorsSameLength); } CommonParallel.For(0, y.Length, 4096, (a, b) => { for (int i = a; i < b; i++) { result[i] = x[i] + y[i]; } }); }
public override void FftKernel(Complex[] x, Complex[] y, int y0, int dy, int sign) { // all we have to do here is convolve (b x) with b-star // to do this convolution, we need to multiply the DFT of (b x) with the DFT of b-star, the IDFT the result back // we have already stored the DFT of b-star // create c = b x and transform it into Fourier space Complex[] c = new Complex[Nb]; if (sign > 0) { for (int i = 0; i < R; i++) c[i] = b[i] * x[i]; } else { for (int i = 0; i < R; i++) c[i] = b[i] * x[i].Conjugate; } Complex[] ct = ft.Transform(c); // multiply b-star and c = b x in Fourier space, and inverse transform the product back into configuration space for (int i = 0; i < Nb; i++) { ct[i] = ct[i] * bt[i]; } c = ft.InverseTransform(ct); // read off the result if (sign > 0) { for (int i = 0; i < R; i++) y[y0 + i * dy] = b[i] * c[i]; } else { for (int i = 0; i < R; i++) y[y0 + i * dy] = b[i].Conjugate * c[i].Conjugate; } // for the sign < 0 case, we have used the fact that the convolution of (b-star x) with b is // just the convolution of (b x-star) with b-star, starred }
public HComplex() { Value = new Complex(0, 0); Attributes.Add("real", new HassiumProperty("real", x => Real, (self, x) => Real = x[0].HDouble().Value)); Attributes.Add("imaginary", new HassiumProperty("imaginary", x => Imaginary, (self, x) => Imaginary = x[0].HDouble().Value)); Attributes.Add("imag", new HassiumProperty("imag", x => Imaginary, (self, x) => Imaginary = x[0].HDouble().Value)); Attributes.Add("module", new HassiumProperty("module", x => (double)Value.Module, null, true)); Attributes.Add("argument", new HassiumProperty("argument", x => (double)Value.Argument, null, true)); Attributes.Add("conjugate", new HassiumProperty("conjugate", x => (double)Value.Conjugate, null, true)); Attributes.Add("__add", new InternalFunction(Add, -1)); Attributes.Add("__substract", new InternalFunction(Substract, -1)); Attributes.Add("__multiply", new InternalFunction(Multiply, -1)); Attributes.Add("__divide", new InternalFunction(Divide, -1)); Attributes.Add("__compare", new InternalFunction(x => { var v = x[0].HComplex().Value; if (v > Value) return 1; if (v < Value) return -1; return 0; }, 1)); Attributes.Add("__pow", new InternalFunction(x => new HComplex(Functions.Pow(Value, x[0].HComplex().Value)), 1)); Attributes.Add("__root", new InternalFunction(x => new HComplex(Functions.NthRoot(Value, x[0].HComplex().Value)), 1)); Attributes.Add("negate", new InternalFunction(Negate, 0)); Attributes.Add("square", new InternalFunction(x => new HComplex(Value.Square()), 0)); }
public void AddTest() { calculator = new ComplexNumbers.Calculator(); Complex<double> actual = calculator.Add(new Complex<double>(4, 5), new Complex<double>(6, 7)); Complex<double> expected = new Complex<double>(4 + 6, 5 + 7); Assert.True(actual.Equals(expected)); }
static void Main() { //try //{ // string input; // while ((input = Console.ReadLine()) != "exit") // new Calculator(input); //} //catch (IndexOutOfRangeException) //{ // Console.WriteLine("Incorrect input"); //} string str; var matrix = new Complex[2][]; matrix[0] = new Complex[2]; matrix[1] = new Complex[2]; for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) { str = Console.ReadLine(); double a, b; double.TryParse(str, out a); str = Console.ReadLine(); double.TryParse(str, out b); matrix[i][j] = new Complex(a, b); } var m = new Matrix<Complex>(matrix); var result = m + m; result.Print(); }
Task CalculateMandelbrotAsync(BmpMaker bmpMaker) { return Task.Run(() => { for (int row = 0; row < pixelHeight; row++) { double y = center.Imaginary - size.Height / 2 + row * size.Height / pixelHeight; for (int col = 0; col < pixelWidth; col++) { double x = center.Real - size.Width / 2 + col * size.Width / pixelWidth; Complex c = new Complex(x, y); Complex z = 0; int iteration = 0; do { z = z * z + c; iteration++; } while (iteration < iterations && z.MagnitudeSquared < 4); bool isMandelbrotSet = iteration == iterations; bmpMaker.SetPixel(row, col, isMandelbrotSet ? Color.Black : Color.White); } } }); }
public static double[] padded_IFFT(ref Complex[] @in, bool doProperScaling=false) { Debug.Assert(@in.Length > 1); int originalLength = @in.Length; int n = (@in.Length - 1) * 2; int padded = n > 256 ? Util.NextLowPrimes(n) : n; Array.Resize<Complex>(ref @in, padded / 2 + 1); // prepare the input arrays var complexDouble = FFTUtils.ComplexToComplexDouble(@in); var fftwBackwardInput = new FFTW.ComplexArray(complexDouble); var fftwBackwardOutput = new FFTW.DoubleArray(padded); // this method needs that the backwards transform uses the output.length as it's N // i.e. FFTW.dft_c2r_1d(output.Length, input.Handle, output.Handle, Flags.Estimate); FFTW.BackwardTransform(fftwBackwardInput, fftwBackwardOutput); double[] @out = null; if (doProperScaling) { @out = fftwBackwardOutput.ValuesDivedByN; } else { // in the original method it wasn't scaled correctly (meaning ValuesDivedByN) @out = fftwBackwardOutput.Values; } Array.Resize<Complex>(ref @in, n / 2 + 1); // free up memory GC.Collect(); return @out; }
/// <summary> /// Initializes a new instance of the CEigenproblem class, computing /// the eigenvalues and optionally the right eigenvectors of a square complex matrix. /// </summary> /// <param name="matrix">A complex square matrix.</param> /// <param name="rightEigenvectors">A value that indicating whether the right eigenvectors will be computed.</param> public CEigenproblem(CMatrix matrix, bool rightEigenvectors) { if (!matrix.IsSquare) throw new MatrixSizeMismatchException("The matrix must be square."); var order = matrix.RowCount; // Initialize matrices for eigenvalues and eigenvectors var eigenVectors = new Complex[order * order]; var blockDiagonal = new Complex[order * order]; var eigenValues = new Complex[order]; new ManagedLinearAlgebraProvider().EigenDecomp(matrix.IsHermitian(), order, matrix.To1DimArray(), eigenVectors, eigenValues, blockDiagonal); _vals = eigenValues; _rightvecs = new CMatrix(matrix.RowCount, matrix.ColumnCount); for (int i = 0; i < matrix.RowCount; i++) { for (int j = 0; j < matrix.ColumnCount; j++) { _rightvecs[i, j] = eigenVectors[j * matrix.RowCount + i]; } } }
/// <summary> /// Вычисление ФФТ с переставленным массивом /// </summary> private static void _FFT(ref Complex[] revData, bool Reverse) { int Size = revData.Length; Complex W = new Complex(); double pi2 = -Math.PI * 2; if (Reverse) pi2 = -pi2; for (int N = 2; N <= Size; N <<= 1) { double dn = pi2 / N; for (int i = 0; i < N / 2; i++) { double x = i * dn; W = new Complex((float)Math.Cos(x), (float)Math.Sin(x)); //W = Complex.Exp(c01 * (pi2 * i / N)); for (int j = i, s = i + N / 2; j < Size; j += N, s += N) { Complex t = W * revData[s]; revData[s] = revData[j] - t; revData[j] = revData[j] + t; } } } if (Reverse) { for (int i = 0; i < Size; i++) { revData[i].re /= Size; revData[i].im /= Size; } } }
/// <summary> /// Initializes a new instance of the CSVD class, /// computing the Singular Value Decomposition of a general complex matrix, /// with the possibility of computing only the singular values. /// </summary> /// <param name="matrix">A general complex matrix.</param> /// <param name="singularValuesOnly">A value that indicating whether only the singular values will be computed.</param> public CSVD(CMatrix matrix, bool singularValuesOnly) { _m = matrix.RowCount; _n = matrix.ColumnCount; var nm = Math.Min(matrix.RowCount, matrix.ColumnCount); var s = new Complex[nm]; var u = new Complex[matrix.RowCount * matrix.RowCount]; var vt = new Complex[matrix.ColumnCount * matrix.ColumnCount]; new ManagedLinearAlgebraProvider().SingularValueDecomposition(!singularValuesOnly, matrix.To1DimArray(), matrix.RowCount, matrix.ColumnCount, s, u, vt); _s = s.ToArray().Select(x => x.Re).ToArray(); _u = new CMatrix(matrix.RowCount, matrix.RowCount); for (int i = 0; i < matrix.RowCount; i++) { for (int j = 0; j < matrix.RowCount; j++) { _u[i, j] = u[j * matrix.RowCount + i]; } } _vt = new CMatrix(matrix.ColumnCount, matrix.ColumnCount); for (int i = 0; i < matrix.ColumnCount; i++) { for (int j = 0; j < matrix.ColumnCount; j++) { _vt[i, j] = vt[j * matrix.ColumnCount + i]; } } }
public void DivideTest() { calculator = new ComplexNumbers.Calculator(); Complex<double> actual = calculator.Divide(new Complex<double>(4, 5), new Complex<double>(6, 7)); Complex<double> expected = new Complex<double>((4.0 * 6.0 + 5.0 * 7.0) / (6.0 * 6.0 + 7.0 * 7.0), (5.0 * 6.0 - 4.0 * 7.0) / (6.0 * 6.0 + 7.0 * 7.0)); Assert.True(actual.Equals(expected)); }
/// <summary> /// Returns a vector of approximate values of roots of a complex polynomial by companion matrix method. /// </summary> /// <param name="poly">A complex polynomial.</param> /// <returns>The approximate values of roots of poly.</returns> /// <exception cref="System.ArgumentException"> /// Number of elements in coeffs is less than 2 or more than 99. /// </exception> public static Complex[] CompanionMatrixRootsFinding(this CPolynomial poly) { // Remove zero elements standing at the end. int lidx = 0; int ridx = poly.Length - 1; while (ridx >= 0 && poly[ridx] == Complex.Zero) ridx--; while (lidx < poly.Length && poly[lidx] == Complex.Zero) lidx++; int length = ridx + 1; if (length < 2 || length > 99) throw new ArgumentException("Number of coefficients must be between 1 and 100."); int rootsCount = length - 1; Complex[] roots = new Complex[rootsCount]; int n = ridx - lidx; CMatrix companionMatrix = new CMatrix(n, n); for (int i = 1; i < n; i++) companionMatrix[i, i - 1] = Complex.One; for (int i = 0; i < n; i++) companionMatrix[i, n - 1] = -poly[lidx + i] / poly[ridx]; CMatrix eigenvals = CMatrix.Eigenvalues(companionMatrix); for (int i = 0; i < n; i++) roots[i] = eigenvals[i]; Array.Sort<Complex>(roots, new ComplexComparer()); return roots; }
public void Equals() { Complex<double> actual = new Complex<double>(1, 2); Complex<double> expected = new Complex<double>(2, 3); Assert.True(actual.Equals(actual)); Assert.AreEqual(actual.Equals(expected), expected.Equals(actual)); }
private void Draw() { Complex p = new Complex(0, 0, true); Complex q = new Complex(0, 0, true); double t = 2.0 * Math.PI / (fx / 1.25); Color pc, qc, c; int r = 0, g = 0, b = 0; for(int x = 0 ; x < fx ; x++) { p.cis(0.99, t * x); pc = Color.FromArgb(p.c); for(int y = 0 ; y < fy ; y++) { q.cis(0.99, t * y); qc = Color.FromArgb(q.c); //r = (int)(255.0 * ((pc.R / 255.0) * (qc.R / 255.0))); //g = (int)(255.0 * ((pc.G / 255.0) * (qc.G / 255.0))); //b = (int)(255.0 * ((pc.B / 255.0) * (qc.B / 255.0))); //r = (x > fx / 5 * 2) ? 0 : pc.R ^ qc.R; //g = (x < fx / 5 * 1 || x > fx / 5 * 4) ? 0 : pc.G ^ qc.G; //b = (x < fx / 5 * 3) ? 0 : pc.B ^ qc.B; r = pc.R ^ qc.R; g = pc.G ^ qc.G; b = pc.B ^ qc.B; c = Color.FromArgb(255, r, g, b); gi.SetPixel(x, y, c); } gf.DrawLine(new Pen(pc), x, 0, x, fy); } gf.DrawImage(gi, 0, 0); }
/// <summary> /// Applies the Discrete Fourier Transform to an input signal /// </summary> /// <param name="_inputSignal">The input signal of complex-valued amplitudes for each time sample</param> /// <param name="_outputSpectrum">The output complex-valued spectrum of amplitudes for each frequency. /// The spectrum of frequencies goes from [-N/2,N/2[ hertz, where N is the length of the input signal</param> /// <remarks>Throws an exception if signal and spectrum sizes mismatch and if their size are not a power of two!</remarks> public static void DFT_Forward( Complex[] _inputSignal, Complex[] _outputSpectrum ) { int size = _inputSignal.Length; if ( _outputSpectrum.Length != size ) throw new Exception( "Input signal and output spectrum sizes mismatch!" ); float fPOT = (float) (Math.Log( size ) / Math.Log( 2.0 )); int POT = (int) Math.Floor( fPOT ); if ( fPOT != POT ) throw new Exception( "Input signal length is not a Power Of Two!" ); int halfSize = size >> 1; double normalizer = 1.0 / size; for ( int frequencyIndex=0; frequencyIndex < size; frequencyIndex++ ) { double frequency = 2.0 * Math.PI * frequencyIndex; double normalizedFrequency = -frequency * normalizer; // Notice the - sign here! It's indicating the "division" by e^ix and the forward transform... // Accumulate (co)sine wave amplitude for specified frequency (i.e. computes how much the (co)sine wave matches to the signal at this frequency) double sumR = 0.0; double sumI = 0.0; for ( int i=0; i < size; i++ ) { double omega = i * normalizedFrequency; double c = Math.Cos( omega ); double s = Math.Sin( omega ); Complex v = _inputSignal[i]; sumR += c * v.r - s * v.i; sumI += s * v.r + c * v.i; } sumR *= normalizer; sumI *= normalizer; _outputSpectrum[frequencyIndex].Set( sumR, sumI ); } }
public Task<BitmapInfo> CalculateAsync(Complex Center, double width, double height, int pixelWidth, int pixelHeight, int iterations, IProgress<double> progress, CancellationToken cancelToken) { return Task.Run(() => { int[] iterationCounts = new int[pixelWidth * pixelHeight]; int index = 0; for (int row = 0; row < pixelHeight; row++) { progress.Report((double)row / pixelHeight); cancelToken.ThrowIfCancellationRequested(); double y = Center.Imaginary - height / 2 + row * height / pixelHeight; for (int col = 0; col < pixelWidth; col++) { double x = Center.Real - width / 2 + col * width / pixelWidth; Complex c = new Complex(x, y); if ((c - new Complex(-1, 0)).MagnitudeSquared < 1.0 / 16) { iterationCounts[index++] = -1; } // http://www.reenigne.org/blog/algorithm-for-mandelbrot-cardioid/ else if (c.MagnitudeSquared * (8 * c.MagnitudeSquared - 3) < 3.0 / 32 - c.Real) { iterationCounts[index++] = -1; } else { Complex z = 0; int iteration = 0; do { z = z * z + c; iteration++; } while (iteration < iterations && z.MagnitudeSquared < 4); if (iteration == iterations) { iterationCounts[index++] = -1; } else { iterationCounts[index++] = iteration; } } } } return new BitmapInfo(pixelWidth, pixelHeight, iterationCounts); }, cancelToken); }
public static void Test() { Complex cmplx = new Complex(); cmplx = Complex.Rect(3, 5); Console.WriteLine(cmplx.RealPart + ", " + cmplx.ImaginaryPart); Console.Read(); }
internal static int Compute( int m, int n, int k, Complex[] A, int lda, Complex[] tau ){ ArgumentCheck(m, n, k, A, lda, tau); if (tau.Length < System.Math.Max(1, k) ){ throw new ArgumentException("tau must be at least max(1,k)."); } return dna_lapack_zungqr(Configuration.BlockSize, m, n, k, A, lda, tau); }
/// <summary> /// Copies an array of <see cref="Complex" /> elements into an array of the real part values and an array of the imaginary part values. /// </summary> /// <param name="src">The source array.</param> /// <param name="destreal">The array where the real part values are stored into.</param> /// <param name="destimag">The destination array where the imaginary part values are stored into.</param> /// <param name="n">The number of elements to copy. The copying is done from index 0 to n-1.</param> public static void CopyFromComplexToSplittedArrays(Complex[] src, double[] destreal, double[] destimag, int n) { for(int i=0;i<n;i++) { destreal[i]=src[i].Re; destimag[i]=src[i].Im; } }
/// <summary> /// Copies two arrays with real and imaginary part values into an array of <see cref="Complex" /> values. /// </summary> /// <param name="srcreal">The source array containing the real part values.</param> /// <param name="srcimag">The source array containing the imaginary part values.</param> /// <param name="dest">The destination array.</param> /// <param name="n">The number of elements to copy. The copying is done from index 0 to n-1.</param> public static void CopyFromSplittedArraysToComplex(double[] srcreal, double[] srcimag, Complex[] dest, int n) { for(int i=0;i<n;i++) { dest[i].Re = srcreal[i]; dest[i].Im = srcimag[i]; } }
static void Main(string[] args) { Complex FirstPair = new Complex(1, 2); Complex SecondPair = new Complex(1, 4); Complex Res = FirstPair * SecondPair; Console.WriteLine(Res); Console.ReadKey(); }
public HMM() { State = new State(); Observed = new Observed(); InitialState = new InitialStateProbability(); Transition = new Transition(); Complex = new Complex(); }