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));
