public void Simple() { var complexNumber1 = new ComplexNumber(1, 2); var complexNumber2 = new ComplexNumber(3, 4); var multiplyComplexNumber = complexNumber1.Multiply(complexNumber2); Assert.AreEqual(1 * 3 - 2 * 4, multiplyComplexNumber.Real); Assert.AreEqual(2 * 3 + 1 * 4, multiplyComplexNumber.Imaginary); multiplyComplexNumber = complexNumber1.Multiply(5); Assert.AreEqual(5 * 1, multiplyComplexNumber.Real); Assert.AreEqual(5 * 2, multiplyComplexNumber.Imaginary); multiplyComplexNumber = 6 * complexNumber1; Assert.AreEqual(6 * 1, multiplyComplexNumber.Real); Assert.AreEqual(6 * 2, multiplyComplexNumber.Imaginary); multiplyComplexNumber = complexNumber1 * 7; Assert.AreEqual(7 * 1, multiplyComplexNumber.Real); Assert.AreEqual(7 * 2, multiplyComplexNumber.Imaginary); complexNumber1 *= 1; Assert.AreEqual(1, complexNumber1.Real); Assert.AreEqual(2, complexNumber1.Imaginary); complexNumber1 *= 5; Assert.AreEqual(5, complexNumber1.Real); Assert.AreEqual(10, complexNumber1.Imaginary); complexNumber1 *= complexNumber2; Assert.AreEqual(5 * 3 - 10 * 4, complexNumber1.Real); Assert.AreEqual(10 * 3 + 5 * 4, complexNumber1.Imaginary); }
public void ExecuteWithParamsTest() { var complex = new Complex(5, 2); var exp = new ComplexNumber(complex); Assert.Equal(complex, exp.Execute(null)); }
public static void Main( string[] args ) { // declare two variables to store complex numbers // to be entered by user ComplexNumber x, y; // prompt the user to enter the first complex number Console.Write( "Enter the real part of complex number x: " ); double realPart = Convert.ToDouble( Console.ReadLine() ); Console.Write( "Enter the imaginary part of complex number x: " ); double imaginaryPart = Convert.ToDouble( Console.ReadLine() ); x = new ComplexNumber( realPart, imaginaryPart ); // prompt the user to enter the second complex number Console.Write( "\nEnter the real part of complex number y: " ); realPart = Convert.ToDouble( Console.ReadLine() ); Console.Write( "Enter the imaginary part of complex number y: " ); imaginaryPart = Convert.ToDouble( Console.ReadLine() ); y = new ComplexNumber( realPart, imaginaryPart ); // display the results of calculations with x and y Console.WriteLine(); Console.WriteLine( "{0} + {1} = {2}", x, y, x + y ); Console.WriteLine( "{0} - {1} = {2}", x, y, x - y ); Console.WriteLine( "{0} * {1} = {2}", x, y, x * y ); }
public void Simple1() { var complexNumber1 = new ComplexNumber(4, 3); var complexNumber2 = new ComplexNumber(6, 2); var complexNumber3 = new ComplexNumber(-2, -4); var complexNumber4 = new ComplexNumber(3, -8); var complexNumber5 = new ComplexNumber(8, 3); var resultComplexNumber = complexNumber1.Subtract(complexNumber2); Assert.AreEqual(1, resultComplexNumber.Imaginary); Assert.AreEqual(-2, resultComplexNumber.Real); resultComplexNumber = complexNumber1.Subtract(complexNumber3); Assert.AreEqual(7, resultComplexNumber.Imaginary); Assert.AreEqual(6, resultComplexNumber.Real); resultComplexNumber = complexNumber1.Subtract(complexNumber4); Assert.AreEqual(11, resultComplexNumber.Imaginary); Assert.AreEqual(1, resultComplexNumber.Real); resultComplexNumber = complexNumber1.Subtract(complexNumber5); Assert.AreEqual(0, resultComplexNumber.Imaginary); Assert.AreEqual(-4, resultComplexNumber.Real); }
public void Simple2() { var complexNumber1 = new ComplexNumber(4, 3); var complexNumber2 = new ComplexNumber(6, 2); var complexNumber3 = new ComplexNumber(-2, -4); var complexNumber4 = new ComplexNumber(3, -8); var complexNumber5 = new ComplexNumber(8, 3); var resultComplexNumber = complexNumber1 + complexNumber2; Assert.AreEqual(10, resultComplexNumber.Real); Assert.AreEqual(5, resultComplexNumber.Imaginary); resultComplexNumber = complexNumber1 + complexNumber3; Assert.AreEqual(2, resultComplexNumber.Real); Assert.AreEqual(-1, resultComplexNumber.Imaginary); resultComplexNumber = complexNumber1 + complexNumber4; Assert.AreEqual(7, resultComplexNumber.Real); Assert.AreEqual(-5, resultComplexNumber.Imaginary); resultComplexNumber = complexNumber1 + complexNumber5; Assert.AreEqual(12, resultComplexNumber.Real); Assert.AreEqual(6, resultComplexNumber.Imaginary); }
public void ExecuteTest() { var complex = new Complex(5, 2); var exp = new ComplexNumber(complex); Assert.Equal(complex, exp.Execute()); }
public void Simple() { var complexNumber = new ComplexNumber(5, 6); var copy = (ComplexNumber) complexNumber.Clone(); Assert.AreEqual(copy.Real, complexNumber.Real); Assert.AreEqual(copy.Imaginary, complexNumber.Imaginary); complexNumber = new ComplexNumber(-2, 3); copy = (ComplexNumber) complexNumber.Clone(); Assert.AreEqual(copy.Real, complexNumber.Real); Assert.AreEqual(copy.Imaginary, complexNumber.Imaginary); complexNumber = new ComplexNumber(5, -3); copy = (ComplexNumber) complexNumber.Clone(); Assert.AreEqual(copy.Real, complexNumber.Real); Assert.AreEqual(copy.Imaginary, complexNumber.Imaginary); complexNumber = new ComplexNumber(-9, -4); copy = (ComplexNumber) complexNumber.Clone(); Assert.AreEqual(copy.Real, complexNumber.Real); Assert.AreEqual(copy.Imaginary, complexNumber.Imaginary); }
public void Simple() { var complexNumber1 = new ComplexNumber(4, 5); var complexNumber2 = new ComplexNumber(-2, 4); var complexNumber3 = new ComplexNumber(1, -3); var complexNumber4 = new ComplexNumber(-6, -12); var resultComplexNumber = complexNumber1.Reciprocal; Assert.AreEqual(4d / 41d, resultComplexNumber.Real); Assert.AreEqual(-5d / 41d, resultComplexNumber.Imaginary); resultComplexNumber = complexNumber2.Reciprocal; Assert.AreEqual(-2d / 20d, resultComplexNumber.Real); Assert.AreEqual(-4d / 20d, resultComplexNumber.Imaginary); resultComplexNumber = complexNumber3.Reciprocal; Assert.AreEqual(1d / 10d, resultComplexNumber.Real); Assert.AreEqual(3d / 10d, resultComplexNumber.Imaginary); resultComplexNumber = complexNumber4.Reciprocal; Assert.AreEqual(-6d / 180d, resultComplexNumber.Real); Assert.AreEqual(12d / 180d, resultComplexNumber.Imaginary); }
public ComplexNumber CanAdd(ComplexNumber x, ComplexNumber y) { ComplexNumber result = x + y; Assert.AreEqual(x.Real + y.Real, result.Real); Assert.AreEqual(x.Imaginary + y.Imaginary, result.Imaginary); return result; }
public void EqualsTest() { var exp1 = new ComplexNumber(new Complex(5, 2)); var exp2 = new ComplexNumber(new Complex(5, 2)); Assert.True(exp1.Equals(exp2)); }
public void SumNumbers() { ComplexNumber n1 = new ComplexNumber(1,1); ComplexNumber n2 = new ComplexNumber(1,1); ComplexNumber result = n1 + n2; Assert.AreEqual(2, result.Real); Assert.AreEqual(2, result.Imaginary); }
public void MulNumbers() { ComplexNumber n1 = new ComplexNumber(3, 5); ComplexNumber n2 = new ComplexNumber(2, 3); ComplexNumber result = n1 * n2; Assert.AreEqual(6, result.Real); Assert.AreEqual(15, result.Imaginary); }
public void DivNumbers() { ComplexNumber n1 = new ComplexNumber(3, 15); ComplexNumber n2 = new ComplexNumber(2, 3); ComplexNumber result = n1 / n2; Assert.AreEqual(1.5, result.Real); Assert.AreEqual(5, result.Imaginary); }
public void DiffNumbers() { ComplexNumber n1 = new ComplexNumber(1, 1); ComplexNumber n2 = new ComplexNumber(1, 1); ComplexNumber result = n1 - n2; Assert.AreEqual(0, result.Real); Assert.AreEqual(0, result.Imaginary); }
private static int CalculateMandelbrotIterations(ComplexNumber current, ComplexNumber start, int iterations,int maxiterations) { if (iterations >= maxiterations) return maxiterations; if (current.LengthSquared() > 4f) return iterations; return CalculateMandelbrotIterations(current * current + start, start, ++iterations,maxiterations); }
public void ConjugateExample() { var complexNumber = new ComplexNumber(1, 2); var conjugateComplexNumber = complexNumber.Conjugate; Assert.AreEqual(conjugateComplexNumber.Real, 1); Assert.AreEqual(conjugateComplexNumber.Imaginary, -2); }
public void Simple3() { object complexNumber1 = new ComplexNumber(1, 2); var complexNumber2 = new object(); Assert.IsFalse(complexNumber1.Equals(complexNumber2)); Assert.IsFalse(complexNumber1.Equals(null)); }
public void AbsoluteValueExample() { var complexNumber = new ComplexNumber(4, -3); var result = complexNumber.AbsoluteValue; Assert.AreEqual(result, 5); }
public void AdditiveInverseExample() { var complexNumber1 = new ComplexNumber(4, -2); var result = complexNumber1.AdditiveInverse; Assert.AreEqual(result.Real, -4); Assert.AreEqual(result.Imaginary, 2); }
public void CloneExample() { var complexNumber = new ComplexNumber(5, 6); var clonedComplexNumber = (ComplexNumber)complexNumber.Clone(); // The clone will have the same Real and Imaginary numbers Assert.AreEqual(clonedComplexNumber.Real, 5); Assert.AreEqual(clonedComplexNumber.Imaginary, 6); }
public void AddExample() { var complexNumber1 = new ComplexNumber(4, 3); var complexNumber2 = new ComplexNumber(6, 2); var result = complexNumber1.Add(complexNumber2); Assert.AreEqual(result.Real, 10); Assert.AreEqual(result.Imaginary, 5); }
public void CanCompare() { const double real = 5.2; const double imaginary = -10.3; var x = new ComplexNumber(real, imaginary); var y = new ComplexNumber(real, imaginary); Assert.IsTrue(x == y); Assert.IsFalse(x != y); }
public void SumWithIntegers() { ComplexNumber n1 = new ComplexNumber(3, 15); ComplexNumber result = n1 + 5; ComplexNumber n2 = new ComplexNumber(2, 3); ComplexNumber result2 = 5 + n2; Assert.AreEqual(8, result.Real); Assert.AreEqual(15, result.Imaginary); Assert.AreEqual(7, result2.Real); Assert.AreEqual(3, result2.Imaginary); }
public void Simple() { var complexNumber1 = new ComplexNumber(-3, -4); var complexNumber2 = new ComplexNumber(-3, 4); var complexNumber3 = new ComplexNumber(3, -4); var complexNumber4 = new ComplexNumber(3, 4); Assert.AreEqual(5, complexNumber1.AbsoluteValue); Assert.AreEqual(5, complexNumber2.AbsoluteValue); Assert.AreEqual(5, complexNumber3.AbsoluteValue); Assert.AreEqual(5, complexNumber4.AbsoluteValue); }
public void Set() { var complexNumber = new ComplexNumber(5, 10); Assert.AreEqual(5, complexNumber.Real); Assert.AreEqual(10, complexNumber.Imaginary); complexNumber.Real = 6; complexNumber.Imaginary = 11; Assert.AreEqual(6, complexNumber.Real); Assert.AreEqual(11, complexNumber.Imaginary); }
public void Simple() { var complexNumber1 = new ComplexNumber(1, 2); var conjugateComplexNumber = complexNumber1.Conjugate; Assert.AreEqual(1, conjugateComplexNumber.Real); Assert.AreEqual(-2, conjugateComplexNumber.Imaginary); complexNumber1.Imaginary = -1; conjugateComplexNumber = complexNumber1.Conjugate; Assert.AreEqual(1, conjugateComplexNumber.Real); Assert.AreEqual(1, conjugateComplexNumber.Imaginary); }
/*public override MathEvaluator.MathOperations.Number Calculate(float real, float imaginary,float iterations) { ComplexNumber start = new ComplexNumber(real, imaginary); return CalculateMandelbrot(start,start, (int)iterations).Abs(); }*/ public override MathEvaluator.MathOperations.Number Calculate(float real, float imaginary, float maxiterations) { ComplexNumber start = new ComplexNumber(real, imaginary); ComplexNumber current = start; int iteration = 0; for (; iteration < (int)maxiterations; iteration++) { if (current.LengthSquared() > 4.0f) break; current = current * current + start; } return 3 - iteration / (float)((int)maxiterations); //return 3 - CalculateMandelbrotIterations(start, start, 0,(int)maxiterations)/(float)((int)maxiterations) ; }
public void Simple1() { object complexNumber1 = new ComplexNumber(1, 2); object complexNumber2 = new ComplexNumber(1, 2); object complexNumber3 = new ComplexNumber(1, 6); object complexNumber4 = new ComplexNumber(2, 2); object complexNumber5 = new ComplexNumber(3, 3); Assert.IsTrue(complexNumber1.Equals(complexNumber1)); Assert.IsTrue(complexNumber1.Equals(complexNumber2)); Assert.IsFalse(complexNumber1.Equals(complexNumber3)); Assert.IsFalse(complexNumber1.Equals(complexNumber4)); Assert.IsFalse(complexNumber1.Equals(complexNumber5)); }
public IterationValue ComputeIterationDepthFor(ComplexNumber z) { ComplexNumber c = z; for (int n = 0; n < _maxIterationDepth; n++) { z.MultiplyWith(z); z.Add(c); if (z.AbsoluteValueSquared >= _thresholdSquared) return new IterationValue(n + 1, z.AbsoluteValue); } return new IterationValue(_maxIterationDepth, double.MinValue); }
public void Simple() { var complexNumber1 = new ComplexNumber(4, -2); var complexNumber2 = new ComplexNumber(-2, 6); var resultComplexNumber = complexNumber1.AdditiveInverse; Assert.AreEqual(-4, resultComplexNumber.Real); Assert.AreEqual(2, resultComplexNumber.Imaginary); resultComplexNumber = complexNumber2.AdditiveInverse; Assert.AreEqual(2, resultComplexNumber.Real); Assert.AreEqual(-6, resultComplexNumber.Imaginary); }
public void Sum(ComplexNumber c2) { real += c2.real; img += c2.img; }
public override EvaluationResults EvaluateModelOnData(Converter <Leaf, SufficientStatistics> predictorMap, Converter <Leaf, SufficientStatistics> targetMap) { EvaluationResults evalResults; int[] fisherCounts = ModelScorer.PhyloTree.FisherCounts(predictorMap, targetMap); int[] realFisherCounts = fisherCounts; // for compatability when NAIVE_EQUILIBRIUM is set #if NAIVE_EQUILIBRIUM //USE THIS FOR BACKWARDS COMPATABILITY int[] tempCounts = ModelScorer.PhyloTree.CountsOfLeaves(targetMap); fisherCounts = tempCounts; #endif //MessageInitializerDiscrete nullMessageInitializer = MessageInitializerDiscrete.GetInstance(predictorMap, targetMap, NullDistn, fisherCounts, ModelScorer.PhyloTree.LeafCollection); //if (TryShortCutFromCounts(realFisherCounts, nullMessageInitializer, out evalResults)) //{ // return evalResults; //} //Score nullScore = ModelScorer.MaximizeLikelihood(nullMessageInitializer); bool isInvariant; Score nullScoreTarg = ComputeSingleVariableScore(predictorMap, targetMap, NullDistn, fisherCounts, out isInvariant); Score altScore = ComputeConditionalVariableScore(predictorMap, targetMap, nullScoreTarg, fisherCounts); //(realFisherCounts, nullScoreTarg, out evalResults)) //{ // return evalResults; //} //MessageInitializerDiscrete altMessageInitializer = MessageInitializerDiscrete.GetInstance(predictorMap, targetMap, (DistributionDiscreteConditional)AltDistn, nullScore.OptimizationParameters, ModelScorer.PhyloTree.LeafCollection); //Score condScore = ModelScorer.MaximizeLikelihood(altMessageInitializer); List <Score> nullScores = new List <Score>(); if (_includePredictorInScore) { int[] predFisherCounts = new int[] { realFisherCounts[0], realFisherCounts[2], realFisherCounts[1], realFisherCounts[3] }; Score predNullScore = ComputeSingleVariableScore(targetMap, predictorMap, NullDistn, predFisherCounts, out isInvariant); nullScores.Add(predNullScore); // conditional model altScore doesn't include predLL. If we're here, we want to add it to make it comparable to joint or reverseConditional altScore = Score.GetInstance(altScore.Loglikelihood + predNullScore.Loglikelihood, altScore.OptimizationParameters, altScore.Distribution); } nullScores.Add(nullScoreTarg); evalResults = EvaluationResultsDiscrete.GetInstance(this, nullScores, altScore, realFisherCounts, ChiSquareDegreesOfFreedom); #if DEBUG MessageInitializerDiscrete nullMessageInitializer = MessageInitializerDiscrete.GetInstance(predictorMap, targetMap, NullDistn, fisherCounts, ModelScorer.PhyloTree.LeafCollection); MessageInitializerDiscrete altMessageInitializer = MessageInitializerDiscrete.GetInstance(predictorMap, targetMap, (DistributionDiscreteConditional)AltDistn, nullScoreTarg.OptimizationParameters, ModelScorer.PhyloTree.LeafCollection); double nullLL = ModelScorer.ComputeLogLikelihoodModelGivenData(nullMessageInitializer, nullScoreTarg.OptimizationParameters); double altLL = ModelScorer.ComputeLogLikelihoodModelGivenData(altMessageInitializer, altScore.OptimizationParameters); if (_includePredictorInScore) { int[] predFisherCounts = new int[] { realFisherCounts[0], realFisherCounts[2], realFisherCounts[1], realFisherCounts[3] }; MessageInitializerDiscrete nullMessageInitializerPred = MessageInitializerDiscrete.GetInstance(targetMap, predictorMap, NullDistn, predFisherCounts, ModelScorer.PhyloTree.LeafCollection); double nullLLPred = ModelScorer.ComputeLogLikelihoodModelGivenData(nullMessageInitializerPred, nullScores[0].OptimizationParameters); altLL += nullLLPred; } EvaluationResults evalResults2 = EvaluateModelOnDataGivenParams(predictorMap, targetMap, evalResults); double eps = 1E-10; Debug.Assert(ComplexNumber.ApproxEqual(nullLL, nullScoreTarg.Loglikelihood, eps)); Debug.Assert(ComplexNumber.ApproxEqual(altLL, altScore.Loglikelihood, eps)); Debug.Assert(ComplexNumber.ApproxEqual(evalResults.NullLL, evalResults2.NullLL, eps) && ComplexNumber.ApproxEqual(evalResults.AltLL, evalResults2.AltLL, eps), "In ModelEvaluatorCond, results of maximizing LL and computing LL from same params are not the same."); #endif return(evalResults); }
public void Imaginary_part_of_a_purely_real_number() { var sut = new ComplexNumber(1, 0); Assert.Equal(0, sut.Imaginary); }
public void ComplexNumberOnlyImaginaryPartToStringTest() { var complex = new ComplexNumber(0, -2); Assert.Equal("-2i", complex.ToString(commoonFormatter)); }
[TestMethod] public void FracParse() => Test(@"3", ComplexNumber.Parse("3.000"));
public static ComplexNumber Comjugate(this ComplexNumber num) { return(new ComplexNumber(num.Real, -num.Imag)); }
public void ComplexNumberTwoNegativeToStringTest() { var complex = new ComplexNumber(-3, -2); Assert.Equal("-3-2i", complex.ToString(commoonFormatter)); }
public ComplexNumber Sub(ComplexNumber other) { return(new(Real() - other.Real(), Imaginary() - other.Imaginary())); }
static void Hometask1() { #region Testing all the classes related to Rectangle var top_left = (x : 0.0, y : 4.0); var bottom_right = (x : 7.0, y : 0.0); Console.WriteLine("Enter coordinates:"); try { Console.Write("X for the top left corner --> "); top_left.x = Convert.ToDouble(Console.ReadLine()); Console.Write("Y for the top left corner --> "); top_left.y = Convert.ToDouble(Console.ReadLine()); Console.Write("X for the bottom right corner --> "); bottom_right.x = Convert.ToDouble(Console.ReadLine()); Console.Write("Y for the bottom rigth corner --> "); bottom_right.y = Convert.ToDouble(Console.ReadLine()); Hometask1.Rectangle rec1 = new Hometask1.Rectangle(top_left, bottom_right); Console.WriteLine($"Testing Rectangle class:\nCoordinates:\n" + $"top left corner = {top_left}\n" + $"bottom rigth corner = {bottom_right}"); Console.WriteLine($"Area: {rec1.GetArea()}"); Console.WriteLine($"Perimeter: {rec1.GetPerimeter()}"); Rectangle_2 rec2 = new Rectangle_2(top_left, bottom_right); Console.WriteLine($"Testing Rectangle class wich have automated properties instead of methods:"); Console.WriteLine($"Area: {rec2.GetArea}"); Console.WriteLine($"Perimeter: {rec2.GetPerimeter}"); Console.WriteLine("Testing static Rectangle class:"); Console.WriteLine($"Area: {StaticRectangle.GetArea(top_left, bottom_right)}"); Console.WriteLine($"Perimeter: {StaticRectangle.GetPerimeter(top_left, bottom_right)}"); Console.WriteLine("Press any key to continue..."); Console.ReadKey(); } catch (FormatException e) { Console.WriteLine(e.Message); } #endregion #region Testing all the classes related to Circle Console.WriteLine("Testing Circle class:"); Console.Write("Input the radius --> "); try { double radius = Convert.ToDouble(Console.ReadLine()); Circle circle = new Circle(radius); Console.WriteLine($"Area: {circle.GetArea()}"); Console.WriteLine($"Length: {circle.GetLength()}"); Console.WriteLine("Testing static Circle class:"); Console.WriteLine($"Area: {StaticCircle.GetArea(radius)}"); Console.WriteLine($"Length: {StaticCircle.GetLength(radius)}"); Console.WriteLine("Press any key to continue..."); Console.ReadKey(); } catch (FormatException e) { Console.WriteLine(e.Message); } #endregion #region Testing ComplexNumber class try { Console.WriteLine("Testing ComplexNumber class:"); Console.Write("Enter the real part --> "); double real = Convert.ToDouble(Console.ReadLine()); Console.Write("Enter the imaginary part --> "); double imaginary = Convert.ToDouble(Console.ReadLine()); ComplexNumber ob1 = new ComplexNumber(real, imaginary); Console.WriteLine($"The first complex number: {ob1}"); Console.Write("Enter the real part --> "); real = Convert.ToDouble(Console.ReadLine()); Console.Write("Enter the imaginary part --> "); imaginary = Convert.ToDouble(Console.ReadLine()); ComplexNumber ob2 = new ComplexNumber(real, imaginary); Console.WriteLine($"The second complex number: {ob2}"); Console.WriteLine($"({ob1}) + ({ob2}) = {ob1 + ob2}"); Console.WriteLine($"({ob1}) - ({ob2}) = {ob1 - ob2}"); Console.WriteLine($"({ob1}) * ({ob2}) = {ob1 * ob2}"); Console.WriteLine($"({ob1}) / ({ob2}) = {ob1 / ob2}"); Console.WriteLine("Press any key to continue..."); Console.ReadKey(); } catch (FormatException e) { Console.WriteLine(e.Message); } #endregion }
public ComplexNumber Mul(ComplexNumber other) { return(new(Real() * other.Real() - Imaginary() * other.Imaginary(), Imaginary() * other.Real() + Real() * other.Imaginary())); }
public ComplexNumber Add(ComplexNumber other) { return(new(Real() + other.Real(), Imaginary() + other.Imaginary())); }
/// <summary> /// Creates a <see cref="Phasor"/> of the specified <paramref name="type"/> from the given <see cref="ComplexNumber"/>. /// </summary> /// <param name="type">Type of phasor, i.e., current or voltage.</param> /// <param name="z"><see cref="ComplexNumber"/> to be copied.</param> public Phasor(PhasorType type, ComplexNumber z) : this() { Type = type; Value = z; }
/// <summary> /// Creates a <see cref="Phasor"/> of the specified <paramref name="type"/> from the given polar values. /// </summary> /// <param name="type">Type of phasor, i.e., current or voltage.</param> /// <param name="angle">The <see cref="Angle"/> component, in radians, of the <see cref="ComplexNumber"/>.</param> /// <param name="magnitude">The magnitude (or absolute value) component of the <see cref="ComplexNumber"/>.</param> public Phasor(PhasorType type, Angle angle, double magnitude) : this() { Type = type; Value = new ComplexNumber(angle, magnitude); }
/// <summary> /// Creates a <see cref="Phasor"/> of the specified <paramref name="type"/> from the given rectangular values. /// </summary> /// <param name="type">Type of phasor, i.e., current or voltage.</param> /// <param name="real">The real component of the <see cref="ComplexNumber"/>.</param> /// <param name="imaginary">The imaginary component of the <see cref="ComplexNumber"/>.</param> public Phasor(PhasorType type, double real, double imaginary) : this() { Type = type; Value = new ComplexNumber(real, imaginary); }
public static ComplexNumber Sum( ComplexNumber c1, ComplexNumber c2) { return(new ComplexNumber(c1.real + c2.real, c1.img + c2.img)); }
/// <summary> /// Analyzes the specified expression. /// </summary> /// <param name="exp">The expression.</param> /// <returns> /// The result of analysis. /// </returns> /// <exception cref="System.NotSupportedException">Always.</exception> public virtual TResult Analyze(ComplexNumber exp) { throw new NotSupportedException(); }
public float R; //The coefficient in front of the exponential public ComplexExp(float r, ComplexNumber exp) { R = r; Exp = exp; }
public static ComplexNumber MulI(this ComplexNumber x) { return(new ComplexNumber(-x.Imaginary, x.Real)); }
public void ComplexNumberTwoPositiveToStringTest() { var complex = new ComplexNumber(3, 2); Assert.Equal("3+2i", complex.ToString(commoonFormatter)); }
public void Absolute_value_of_a_number_with_real_and_imaginary_part() { var sut = new ComplexNumber(3, 4); Assert.Equal(5, sut.Abs()); }
public void ComplexNumberOnlyRealPartToStringTest() { var complex = new ComplexNumber(-3, 0); Assert.Equal("-3", complex.ToString(commoonFormatter)); }
private static void DirectFFTWithStartTwiddle(ComplexNumber[] data, int index, int multiplier, int length, int prime, FFTRealConstants precision, ref ComplexNumber[] roots, ref ComplexNumber[] temp, ref ComplexNumber[] simpleRoots, ComplexNumber requiredPower) { if (roots == null || roots.Length < prime) { Array.Resize(ref roots, prime); } roots[1] = requiredPower; for (int i = 2; i < prime; i++) { roots[i] = roots[i >> 1] * roots[(i + 1) >> 1]; } for (; --length >= 0; index++) { switch (prime) { case 2: { var v0 = data[index]; var v1 = data[index + multiplier] * roots[1]; data[index] = v0 + v1; data[index + multiplier] = v0 - v1; } break; case 3: //w^2 = -1-w { ComplexNumber z0 = data[index], z1 = data[index + multiplier] * roots[1], z2 = data[index + 2 * multiplier] * roots[2]; ComplexNumber t1 = z1 + z2, t2 = z0 - (t1 >> 1), t3 = (z1 - z2).MulI() * precision.M_SQRT_3_4; data[index] = z0 + t1; data[index + multiplier] = t2 + t3; data[index + 2 * multiplier] = t2 - t3; } break; case 5: //http://www2.itap.physik.uni-stuttgart.de/lehre/vorlesungen/SS08/simmeth/fftalgorithms.pdf { ComplexNumber z0 = data[index], z1 = data[index + multiplier] * roots[1], z2 = data[index + 2 * multiplier] * roots[2], z3 = data[index + 3 * multiplier] * roots[3], z4 = data[index + 4 * multiplier] * roots[4]; ComplexNumber t1 = z1 + z4, t2 = z2 + z3, t3 = z1 - z4, t4 = z2 - z3, t5 = t1 + t2, t6 = (t1 - t2) * precision.M_ROOT5_C2, t7 = z0 - (t5 >> 2), t8 = t7 + t6, t9 = t7 - t6, t10 = (t3 * precision.M_ROOT5_C4 + t4 * precision.M_ROOT5_C3).MulI(), t11 = (t3 * precision.M_ROOT5_C3 - t4 * precision.M_ROOT5_C4).MulI(); data[index] = z0 + t5; data[index + multiplier] = t8 + t10; data[index + 2 * multiplier] = t9 + t11; data[index + 3 * multiplier] = t9 - t11; data[index + 4 * multiplier] = t8 - t10; } break; default: if (simpleRoots == null || simpleRoots.Length != prime) { Array.Resize(ref simpleRoots, prime); simpleRoots[1] = ComplexNumber.FromPolarAngle((precision.PI << 1) / prime); for (int i = 2; i < prime; i++) { simpleRoots[i] = simpleRoots[i >> 1] * simpleRoots[(i + 1) >> 1]; } } if (temp == null || temp.Length < prime) { Array.Resize(ref temp, prime); } var sum = temp[0] = data[index]; for (int i = prime; --i > 0;) { temp[i] = data[index + i * multiplier] * roots[i]; sum += temp[i]; } data[index] = sum; for (int i = prime; --i > 0;) { var result = temp[0]; for (int j = prime, k = 0; --j > 0;) { k -= i; k = k < 0 ? k + prime : k; //k = i * j mod prime. result += temp[j] * simpleRoots[k]; } data[index + i * multiplier] = result; } break; } } }
public void ComplexNumberNegativeIToStringTest() { var exp = new ComplexNumber(0, -1); Assert.Equal("-i", exp.ToString(commoonFormatter)); }
public static void FullForwardFFT(this ComplexNumber[] data, RealNumber[] temporaryArray = null) { int N = data.Length; int precisionDigits = 1; for (int i = data.Length; --i >= 0;) { precisionDigits = Math.Max(precisionDigits, data[i].GetPrecisionDigits()); } FFTRealConstants precision = new FFTRealConstants(precisionDigits); List <int> factors = FourierTransform235.GetSlowFactorization(N).OrderBy(x => x).ToList(); ComplexNumber[] roots = null; ComplexNumber[] temp = null; ComplexNumber[] simpleRoots = null; List <int> factorDigits = new List <int>(); List <int> decimalRepresentation = new List <int>(); List <ComplexNumber> incrementalProduct = new List <ComplexNumber>(); int totalProduct = 1; int N1 = N; int count = 1; foreach (int factor in factors) { int N2 = N1; N1 /= factor; totalProduct *= factor; factorDigits.Add(factor); incrementalProduct.Clear(); int partialProduct = totalProduct; for (int i = 0; i < factorDigits.Count; i++) { incrementalProduct.Add(ComplexNumber.FromPolarAngle((precision.PI << 1) / partialProduct)); partialProduct /= factorDigits[i]; } ComplexNumber[] exactProduct = new ComplexNumber[factorDigits.Count - 1]; if (factorDigits.Count > 1) { exactProduct[factorDigits.Count - 2] = incrementalProduct[factorDigits.Count - 2]; for (int i = factorDigits.Count - 2; --i >= 0;) { exactProduct[i] = exactProduct[i + 1] * (incrementalProduct[i] * incrementalProduct[i + 2].Conjugate); } } decimalRepresentation.Clear(); decimalRepresentation.AddRange(Enumerable.Repeat(0, factorDigits.Count - 1)); ComplexNumber exactPower = ComplexNumber.One; for (int i = 0; i < count; i++) { DirectFFTWithStartTwiddle(data, i * N2, N1, N1, factor, precision, ref roots, ref temp, ref simpleRoots, exactPower); getIncrement(ref exactPower, decimalRepresentation, factorDigits, exactProduct); } count = totalProduct; } if (temporaryArray == null || temporaryArray.Length < N * 2) { Array.Resize(ref temporaryArray, N * 2); } for (int i = N; --i >= 0;) { var number = data[i]; temporaryArray[i * 2] = number.Real; temporaryArray[i * 2 + 1] = number.Imaginary; } FourierTransform235.ReversedBaseIterate(factors, (i, reversed) => data[reversed] = new ComplexNumber(temporaryArray[i * 2], temporaryArray[i * 2 + 1])); }
[TestMethod] public void FloatZero() => Test(@"123.4561234567890", ComplexNumber.Parse("123.4561234567890"));
private void AssertEqual(int expectedReal, int expectedImage, ComplexNumber actual) { Assert.Equal(expectedReal, actual.Real); Assert.Equal(expectedImage, actual.Image); }
public static ComplexNumber DivI(this ComplexNumber x) { return(new ComplexNumber(x.Imaginary, -x.Real)); }
public void Imaginary_part_of_a_purely_imaginary_number() { var sut = new ComplexNumber(0, 1); Assert.Equal(1, sut.Imaginary); }
public void Imaginary_part_of_a_number_with_real_and_imaginary_part() { var sut = new ComplexNumber(1, 2); Assert.Equal(2, sut.Imaginary); }
///<summary> /// Returns specified <see cref="Phasor"/> raised to the specified power. ///</summary> ///<param name="z">Phasor to be raised to power <paramref name="y"/>.</param> ///<param name="y">Power to raise <see cref="Phasor"/> <paramref name="z"/>.</param> /// <returns>Phasor representing the result of the operation.</returns> public static Phasor Pow(Phasor z, double y) => new Phasor(z.Type, ComplexNumber.Pow(z.Value, y));