public Complex_F32 minus(Complex_F32 a) { Complex_F32 ret = new Complex_F32(); ComplexMath_F32.minus(this, a, ret); return(ret); }
public override void get(int row, int col, Complex_F32 output) { int index = row * numCols * 2 + col * 2; output.real = data[index]; output.imaginary = data[index + 1]; }
public Complex_F32 divide(Complex_F32 a) { Complex_F32 ret = new Complex_F32(); ComplexMath_F32.divide(this, a, ret); return(ret); }
/** * <p> * Division: result = a / b * </p> * * @param a Complex number. Not modified. * @param b Complex number. Not modified. * @param result Storage for output */ public static void divide(Complex_F32 a, Complex_F32 b, Complex_F32 result) { float norm = b.getMagnitude2(); result.real = (a.real * b.real + a.imaginary * b.imaginary) / norm; result.imaginary = (a.imaginary * b.real - a.real * b.imaginary) / norm; }
public Complex_F32 times(Complex_F32 a) { Complex_F32 ret = new Complex_F32(); ComplexMath_F32.multiply(this, a, ret); return(ret); }
public Complex_F32 toStandard() { Complex_F32 ret = new Complex_F32(); ComplexMath_F32.convert(this, ret); return(ret); }
/** * Computes the N<sup>th</sup> root of a complex number. There are * N distinct N<sup>th</sup> roots. * * @param a Complex number * @param N The root's magnitude * @param k Specifies which root. 0 ≤ k < N * @param result Computed root */ public static void root(Complex_F32 a, int N, int k, Complex_F32 result) { float r = a.getMagnitude(); float theta = (float)Math.Atan2(a.imaginary, a.real); r = (float)Math.Pow(r, 1.0f / N); theta = (theta + 2.0f * k * UtilEjml.F_PI) / N; result.real = r * (float)Math.Cos(theta); result.imaginary = r * (float)Math.Sin(theta); }
/** * Computes the square root of the complex number. * * @param input Input complex number. * @param root Output. The square root of the input */ public static void sqrt(Complex_F32 input, Complex_F32 root) { float r = input.getMagnitude(); float a = input.real; root.real = (float)Math.Sqrt((r + a) / 2.0f); root.imaginary = (float)Math.Sqrt((r - a) / 2.0f); if (input.imaginary < 0) { root.imaginary = -root.imaginary; } }
public override void set(Matrix original) { reshape(original.getNumRows(), original.getNumCols()); CMatrix n = (CMatrix)original; Complex_F32 c = new Complex_F32(); for (int i = 0; i < numRows; i++) { for (int j = 0; j < numCols; j++) { n.get(i, j, c); set(i, j, c.real, c.imaginary); } } }
public void set(Complex_F32 a) { this.real = a.real; this.imaginary = a.imaginary; }
/** * Complex conjugate * @param input Input complex number * @param conj Complex conjugate of the input number */ public static void conj(Complex_F32 input, Complex_F32 conj) { conj.real = input.real; conj.imaginary = -input.imaginary; }
/** * <p> * Converts a complex number into polar notation. * </p> * * @param input Standard notation * @param output Polar notation */ public static void convert(Complex_F32 input, ComplexPolar_F32 output) { output.r = input.getMagnitude(); output.theta = (float)Math.Atan2(input.imaginary, input.real); }
/** * <p> * Multiplication: result = a * b * </p> * * @param a Complex number. Not modified. * @param b Complex number. Not modified. * @param result Storage for output */ public static void multiply(Complex_F32 a, Complex_F32 b, Complex_F32 result) { result.real = a.real * b.real - a.imaginary * b.imaginary; result.imaginary = a.real * b.imaginary + a.imaginary * b.real; }
/** * <p> * Subtraction: result = a - b * </p> * * @param a Complex number. Not modified. * @param b Complex number. Not modified. * @param result Storage for output */ public static void minus(Complex_F32 a, Complex_F32 b, Complex_F32 result) { result.real = a.real - b.real; result.imaginary = a.imaginary - b.imaginary; }
/** * <p> * Addition: result = a + b * </p> * * @param a Complex number. Not modified. * @param b Complex number. Not modified. * @param result Storage for output */ public static void plus(Complex_F32 a, Complex_F32 b, Complex_F32 result) { result.real = a.real + b.real; result.imaginary = a.imaginary + b.imaginary; }
public ComplexPolar_F32(Complex_F32 n) { ComplexMath_F32.convert(n, this); }
public abstract void get(int row, int col, Complex_F32 output);
/** * <p> * Converts a complex number in polar notation into standard notation. * </p> * * @param input Standard notation * @param output Polar notation */ public static void convert(ComplexPolar_F32 input, Complex_F32 output) { output.real = input.r * (float)Math.Cos(input.theta); output.imaginary = input.r * (float)Math.Sin(input.theta); }