public static void RunTests_InvalidValues()
{
double realRandom = Support.GetRandomDoubleValue(false);
double imaginaryRandom = Support.GetRandomDoubleValue(false);
// Complex number with a valid real and an invalid imaginary part
foreach (double imaginaryInvalid in Support.doubleInvalidValues)
{
VerifyBinaryAbs(realRandom, imaginaryInvalid, Math.Abs(imaginaryInvalid));
}
// Complex number with an invalid real and an a real imaginary part
foreach (double realInvalid in Support.doubleInvalidValues)
{
VerifyBinaryAbs(realInvalid, realRandom, Math.Abs(realInvalid));
}
// Complex number with an invalid real and an invalid imaginary part
foreach (double realInvalid in Support.doubleInvalidValues)
{
foreach (double imaginaryInvalid in Support.doubleInvalidValues)
{
VerifyBinaryAbs(realInvalid, imaginaryInvalid, (double.IsInfinity(realInvalid) || double.IsInfinity(imaginaryInvalid)) ? double.PositiveInfinity : double.NaN);
}
}
//Regression test case for issue: Complex.Abs() is inconsistent on NaN / Complex.
VerifyBinaryAbs(double.NaN, 0, double.NaN);
}
public static void RunTests_InvalidValues()
{
double realRandom = Support.GetRandomDoubleValue(false);
double imaginaryRandom = Support.GetRandomDoubleValue(false);
// Complex number with a valid positive/negative real and an invalid imaginary part
foreach (double imaginaryInvalid in Support.doubleInvalidValues)
{
VerifyCtor(realRandom, imaginaryInvalid);
VerifyCtor(-realRandom, imaginaryInvalid);
}
// Complex number with an invalid real and an a positive/negative imaginary part
foreach (double realInvalid in Support.doubleInvalidValues)
{
VerifyCtor(realInvalid, imaginaryRandom);
VerifyCtor(realInvalid, -imaginaryRandom);
}
// Complex number with an invalid real and an invalid imaginary part
foreach (double realInvalid in Support.doubleInvalidValues)
{
foreach (double imaginaryInvalid in Support.doubleInvalidValues)
{
VerifyCtor(realInvalid, imaginaryInvalid);
}
}
}
public static void RunTests_Zero()
{
double real = Support.GetRandomDoubleValue(false);
double imaginary = Support.GetRandomDoubleValue(false);
VerifyBinaryPlusResult(0.0, 0.0, real, imaginary); // Verify 0+x=0
VerifyBinaryPlusResult(real, imaginary, 0.0, 0.0); // Verify 0+x=0
}
public static void RunTests_RandomValidValues()
{
// Verify test results with ComplexInFirstQuad
double real = Support.GetRandomDoubleValue(false);
double imaginary = Support.GetRandomDoubleValue(false);
Complex complexFirst = new Complex(real, imaginary);
VerifyToString(complexFirst);
// Verify test results with Small_ComplexInFirstQuad
real = Support.GetSmallRandomDoubleValue(false);
imaginary = Support.GetSmallRandomDoubleValue(false);
Complex complexFirstSmall = new Complex(real, imaginary);
VerifyToString(complexFirstSmall);
// Verify test results with ComplexInSecondQuad
real = Support.GetRandomDoubleValue(true);
imaginary = Support.GetRandomDoubleValue(false);
Complex complexSecond = new Complex(real, imaginary);
VerifyToString(complexSecond);
// Verify test results with Small_ComplexInSecondQuad
real = Support.GetSmallRandomDoubleValue(true);
imaginary = Support.GetSmallRandomDoubleValue(false);
Complex complexSecondSmall = new Complex(real, imaginary);
VerifyToString(complexSecondSmall);
// Verify test results with ComplexInThirdQuad
real = Support.GetRandomDoubleValue(true);
imaginary = Support.GetRandomDoubleValue(true);
Complex complexThird = new Complex(real, imaginary);
VerifyToString(complexThird);
// Verify test results with Small_ComplexInThirdQuad
real = Support.GetSmallRandomDoubleValue(true);
imaginary = Support.GetSmallRandomDoubleValue(true);
Complex complexThirdSmall = new Complex(real, imaginary);
VerifyToString(complexThirdSmall);
// Verify test results with ComplexInFourthQuad
real = Support.GetRandomDoubleValue(false);
imaginary = Support.GetRandomDoubleValue(true);
Complex complexFourth = new Complex(real, imaginary);
VerifyToString(complexFourth);
// Verify test results with Small_ComplexInFourthQuad
real = Support.GetSmallRandomDoubleValue(false);
imaginary = Support.GetSmallRandomDoubleValue(true);
Complex complexFourthSmall = new Complex(real, imaginary);
VerifyToString(complexFourthSmall);
}
public static void RunTests_InvalidValues()
{
// local variables
Double realRandom;
Double imaginaryRandom;
// Complex number with a valid positive real and an invalid imaginary part
foreach (double imaginaryInvalid in Support.doubleInvalidValues)
{
realRandom = Support.GetRandomDoubleValue(false);
Complex c = new Complex(realRandom, imaginaryInvalid);
VerifyToString(c);
}
// Complex number with a valid negative real and an invalid imaginary part
foreach (double imaginaryInvalid in Support.doubleInvalidValues)
{
realRandom = Support.GetRandomDoubleValue(true);
Complex c = new Complex(realRandom, imaginaryInvalid);
VerifyToString(c);
}
// Complex number with an invalid real and an a positive imaginary part
foreach (double realInvalid in Support.doubleInvalidValues)
{
imaginaryRandom = Support.GetRandomDoubleValue(false);
Complex c = new Complex(realInvalid, imaginaryRandom);
VerifyToString(c);
}
// Complex number with an invalid real and a negative imaginary part
foreach (double realInvalid in Support.doubleInvalidValues)
{
imaginaryRandom = Support.GetRandomDoubleValue(true);
Complex c = new Complex(realInvalid, imaginaryRandom);
VerifyToString(c);
}
// Complex number with an invalid real and an invalid imaginary part
foreach (double realInvalid in Support.doubleInvalidValues)
{
foreach (double imaginaryInvalid in Support.doubleInvalidValues)
{
imaginaryRandom = Support.GetRandomDoubleValue(true);
Complex c = new Complex(realInvalid, imaginaryInvalid);
VerifyToString(c);
}
}
}
public static void RunTests_BoundaryValues()
{
// local variables
Double real;
Double img;
// test with 'Max' - (Positive, Positive)
real = Support.GetRandomDoubleValue(false);
img = Support.GetRandomDoubleValue(false);
VerifyBinaryMinusResult(Double.MaxValue, Double.MaxValue, real, img);
// test with (Positive, Positive) - 'Max'
real = Support.GetRandomDoubleValue(false);
img = Support.GetRandomDoubleValue(false);
VerifyBinaryMinusResult(real, img, Double.MaxValue, Double.MaxValue);
// test with 'Max' - (Negative, Negative)
real = Support.GetRandomDoubleValue(true);
img = Support.GetRandomDoubleValue(true);
VerifyBinaryMinusResult(Double.MaxValue, Double.MaxValue, real, img);
// test with (Negative, Negative) - 'Max'
real = Support.GetRandomDoubleValue(true);
img = Support.GetRandomDoubleValue(true);
VerifyBinaryMinusResult(real, img, Double.MaxValue, Double.MaxValue);
// test with 'Min' - (Positive, Positive)
real = Support.GetRandomDoubleValue(false);
img = Support.GetRandomDoubleValue(false);
VerifyBinaryMinusResult(Double.MinValue, Double.MinValue, real, img);
// test with (Positive, Positive) - 'Min'
real = Support.GetRandomDoubleValue(false);
img = Support.GetRandomDoubleValue(false);
VerifyBinaryMinusResult(real, img, Double.MinValue, Double.MinValue);
// test with 'Min' - (Negative, Negative)
real = Support.GetRandomDoubleValue(true);
img = Support.GetRandomDoubleValue(true);
VerifyBinaryMinusResult(Double.MinValue, Double.MinValue, real, img);
// test with (Negative, Negative) - 'Min'
real = Support.GetRandomDoubleValue(true);
img = Support.GetRandomDoubleValue(true);
VerifyBinaryMinusResult(real, img, Double.MinValue, Double.MinValue);
}
public static void RunTests_InvalidRealValues()
{
// local variables
Double realFirst;
Double imgFirst;
Double realSecond;
Double imgSecond;
// Verify with (PositiveInfinity, valid) * (PositiveValid, valid)
realFirst = Double.PositiveInfinity;
imgFirst = Support.GetRandomDoubleValue(false);
realSecond = Support.GetRandomDoubleValue(false);
imgSecond = Support.GetRandomDoubleValue(false);
VerifyBinaryMultiplyResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify with (PositiveInfinity, valid) * (NegativeValid, valid)
realFirst = Double.PositiveInfinity;
imgFirst = Support.GetRandomDoubleValue(false);
realSecond = Support.GetRandomDoubleValue(true);
imgSecond = Support.GetRandomDoubleValue(false);
VerifyBinaryMultiplyResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify with (NegativeInfinity, valid) * (PositiveValid, valid)
realFirst = Double.NegativeInfinity;
imgFirst = Support.GetRandomDoubleValue(false);
realSecond = Support.GetRandomDoubleValue(false);
imgSecond = Support.GetRandomDoubleValue(false);
VerifyBinaryMultiplyResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify with (NegativeInfinity, valid) * (NegativeValid, valid)
realFirst = Double.NegativeInfinity;
imgFirst = Support.GetRandomDoubleValue(false);
realSecond = Support.GetRandomDoubleValue(true);
imgSecond = Support.GetRandomDoubleValue(false);
VerifyBinaryMultiplyResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify with (NaN, valid) * (valid, valid)
realFirst = Double.NaN;
imgFirst = Support.GetRandomDoubleValue(false);
realSecond = Support.GetRandomDoubleValue(false);
imgSecond = Support.GetRandomDoubleValue(false);
VerifyBinaryMultiplyResult(realFirst, imgFirst, realSecond, imgSecond);
}
public static void RunTests_RandomValidValues()
{
// Verify test results with ComlexInFirstQuad
Double real = Support.GetRandomDoubleValue(false);
Double imaginary = Support.GetRandomDoubleValue(false);
VerifyConjugate(real, imaginary);
// Verify test results with Small_ComlexInFirstQuad
real = Support.GetSmallRandomDoubleValue(false);
imaginary = Support.GetSmallRandomDoubleValue(false);
VerifyConjugate(real, imaginary);
// Verify test results with ComplexInSecondQuad
real = Support.GetRandomDoubleValue(true);
imaginary = Support.GetRandomDoubleValue(false);
VerifyConjugate(real, imaginary);
// Verify test results with Small_ComplexInSecondQuad
real = Support.GetSmallRandomDoubleValue(true);
imaginary = Support.GetSmallRandomDoubleValue(false);
VerifyConjugate(real, imaginary);
// Verify test results with ComplexInThirdQuad
real = Support.GetRandomDoubleValue(true);
imaginary = Support.GetRandomDoubleValue(true);
VerifyConjugate(real, imaginary);
// Verify test results with Small_ComplexInThirdQuad
real = Support.GetSmallRandomDoubleValue(true);
imaginary = Support.GetSmallRandomDoubleValue(true);
VerifyConjugate(real, imaginary);
// Verify test results with ComplexInFourthQuad
real = Support.GetRandomDoubleValue(true);
imaginary = Support.GetRandomDoubleValue(true);
VerifyConjugate(real, imaginary);
// Verify test results with Small_ComplexInFourthQuad
real = Support.GetSmallRandomDoubleValue(true);
imaginary = Support.GetSmallRandomDoubleValue(true);
VerifyConjugate(real, imaginary);
}
public static void RunTests_InvalidImaginaryValues()
{
// local variables
Double realFirst;
Double imgFirst;
Double realSecond;
Double imgSecond;
// Verify with (valid, PositiveInfinity) + (valid, PositiveValid)
realFirst = Support.GetRandomDoubleValue(false);
imgFirst = Double.PositiveInfinity;
realSecond = Support.GetRandomDoubleValue(false);
imgSecond = Support.GetRandomDoubleValue(false);
VerifyBinaryPlusResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify with (valid, PositiveInfinity) + (valid, NegativeValid)
realFirst = Support.GetRandomDoubleValue(false);
imgFirst = Double.PositiveInfinity;
realSecond = Support.GetRandomDoubleValue(false);
imgSecond = Support.GetRandomDoubleValue(true);
VerifyBinaryPlusResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify with (valid, NegativeInfinity) + (valid, PositiveValid)
realFirst = Support.GetRandomDoubleValue(false);
imgFirst = Double.NegativeInfinity;
realSecond = Support.GetRandomDoubleValue(false);
imgSecond = Support.GetRandomDoubleValue(false);
VerifyBinaryPlusResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify with (valid, NegativeInfinity) + (valid, NegativeValid)
realFirst = Support.GetRandomDoubleValue(false);
imgFirst = Double.NegativeInfinity;
realSecond = Support.GetRandomDoubleValue(false);
imgSecond = Support.GetRandomDoubleValue(true);
VerifyBinaryPlusResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify with (valid, NaN) + (valid, Valid)
realFirst = Support.GetRandomDoubleValue(false);
imgFirst = Double.NaN;
realSecond = Support.GetRandomDoubleValue(false);
imgSecond = Support.GetRandomDoubleValue(false);
VerifyBinaryPlusResult(realFirst, imgFirst, realSecond, imgSecond);
}
private static void VerifyLogWithBase(Complex complex)
{
Double baseValue = 0.0;
Double baseLog;
// verify with Random Int32
do
{
baseValue = Support.GetRandomInt32Value(false);
}while (0 == baseValue);
Complex logValue = Complex.Log(complex, baseValue);
Complex logComplex = Complex.Log(complex);
baseLog = Math.Log(baseValue);
Complex expectedLog = logComplex / baseLog;
if (false == Support.VerifyRealImaginaryProperties(logValue, expectedLog.Real, expectedLog.Imaginary))
{
Console.WriteLine("Error LogBase-ErrLoG01571! Log({0}, {1}):{2} != {3} as expected", complex, baseValue, logValue, expectedLog);
Assert.True(false, "Verification Failed");
}
// Verify with Random Double value
baseValue = 0.0;
do
{
baseValue = Support.GetRandomDoubleValue(false);
}while (0.0 == baseValue);
logValue = Complex.Log(complex, baseValue);
logComplex = Complex.Log(complex);
baseLog = Math.Log(baseValue);
expectedLog = logComplex / baseLog;
if (!Support.VerifyRealImaginaryProperties(logValue, expectedLog.Real, expectedLog.Imaginary))
{
Console.WriteLine("Error LogBaseDbL-ErrLoG1598! Log({0}, {1}):{2} != {3} as expected", complex, baseValue, logValue, expectedLog);
Assert.True(false, "Verification Failed");
}
}
public static void RunTests_DoubleImplicitCastToComplex()
{
VerifyDoubleImplicitCastToComplex(Double.MinValue);
for (int i = 0; i < Support.RandomSampleCount; ++i)
{
Double randomValue = Support.GetRandomDoubleValue(false);
VerifyDoubleImplicitCastToComplex(randomValue);
}
VerifyDoubleImplicitCastToComplex(0);
VerifyDoubleImplicitCastToComplex(1);
for (int i = 0; i < Support.RandomSampleCount; ++i)
{
Double randomValue = Support.GetRandomDoubleValue(true);
VerifyDoubleImplicitCastToComplex(randomValue);
}
VerifyDoubleImplicitCastToComplex(Double.MaxValue);
}
private static void VerifyLogWithBase(Complex complex)
{
double baseValue = 0.0;
double baseLog;
// Verify with Random Int32
do
{
baseValue = Support.GetRandomInt32Value(false);
}while (0 == baseValue);
Complex logValue = Complex.Log(complex, baseValue);
Complex logComplex = Complex.Log(complex);
baseLog = Math.Log(baseValue);
Complex expectedLog = logComplex / baseLog;
Support.VerifyRealImaginaryProperties(logValue, expectedLog.Real, expectedLog.Imaginary,
string.Format("Log({0}, {1}):{2} != {3} as expected", complex, baseValue, logValue, expectedLog));
// Verify with Random double value
baseValue = 0.0;
do
{
baseValue = Support.GetRandomDoubleValue(false);
}while (0.0 == baseValue);
logValue = Complex.Log(complex, baseValue);
logComplex = Complex.Log(complex);
baseLog = Math.Log(baseValue);
expectedLog = logComplex / baseLog;
Support.VerifyRealImaginaryProperties(logValue, expectedLog.Real, expectedLog.Imaginary,
string.Format("Log({0}, {1}):{2} != {3} as expected", complex, baseValue, logValue, expectedLog));
}
public static void RunTests_ImaginaryOne()
{
// Verify real part is 0.0, and imaginary part is 1.0
if (false == Support.VerifyRealImaginaryProperties(Complex.ImaginaryOne, 0.0, 1.0))
{
Console.WriteLine("ErRoR ErrImaginaryOne_2563-1! Verify real part is 0.0, and imaginary part is 1.0");
Assert.True(false, "Verification Failed");
}
// verify magnitude is 1.0 and phase is Math.PI/2.
if (false == Support.VerifyMagnitudePhaseProperties(Complex.ImaginaryOne, 1.0, (Double)(Math.PI / 2)))
{
Console.WriteLine("ErRoR ErrImaginaryOne_2567-1! verify magnitude is 1.0 and phase is Math.PI/2.");
Assert.True(false, "Verification Failed");
}
// verify ImaginaryOne * ImaginaryOne = -1
Complex multResultImgOnes = Complex.ImaginaryOne * Complex.ImaginaryOne;
if (-1 != multResultImgOnes)
{
Console.WriteLine("ErRoR ErrImaginaryOne_2973-1! Multiplication of ImaginaryOnes is not -1", multResultImgOnes);
Assert.True(false, "Verification Failed");
}
// verify ImaginaryOne / ImaginaryOne = 1
Complex divResultImgOnes = Complex.ImaginaryOne / Complex.ImaginaryOne;
if (1 != divResultImgOnes)
{
Console.WriteLine("ErRoR ErrImaginaryOne_2978-1! Division of ImaginaryOnes is not 1", divResultImgOnes);
Assert.True(false, "Verification Failed");
}
// verify ImaginaryOne / ImaginaryOne = 1
Double absResult = Complex.Abs(Complex.ImaginaryOne);
if (1 != absResult)
{
Console.WriteLine("ErRoR ErrImaginaryOne_2981-1! Abs of ImaginaryOne is not 1", absResult);
Assert.True(false, "Verification Failed");
}
// verify Conjugate(1) = 1
Complex conjugateResult = Complex.Conjugate(Complex.ImaginaryOne);
if (-Complex.ImaginaryOne != conjugateResult)
{
Console.WriteLine("ErRoR ErrImaginaryOne_2983-1! Conjugate of ImaginaryOne is not 1", conjugateResult);
Assert.True(false, "Verification Failed");
}
// verify Reciprocal(1) = 1
Complex reciprocalResult = Complex.Reciprocal(Complex.ImaginaryOne);
if (-Complex.ImaginaryOne != reciprocalResult)
{
Console.WriteLine("ErRoR ErrImaginaryOne_2986-1! Reciprocal of ImaginaryOne is not 1", reciprocalResult);
Assert.True(false, "Verification Failed");
}
// create a complex number with random real and imaginary parts
Double realPart = Support.GetRandomDoubleValue(false);
Double imaginaryPart = Support.GetRandomDoubleValue(false);
Complex complexRandom = new Complex(realPart, imaginaryPart);
// verify x*i = Complex(-x.Imaginary, x.Real)
Complex multResult = complexRandom * Complex.ImaginaryOne;
if (false == Support.VerifyRealImaginaryProperties(multResult, -complexRandom.Imaginary, complexRandom.Real))
{
Console.WriteLine("FAiL! ErRoR ErrImaginaryOne_2718-1! Mult with i does not equal to ({0}, {1}): {2}", -complexRandom.Imaginary, complexRandom.Real, multResult);
Assert.True(false, "Verification Failed");
}
// verify x/i = Complex(x.Imaginary, -x.Real)
Complex divResult = complexRandom / Complex.ImaginaryOne;
if (false == Support.VerifyRealImaginaryProperties(divResult, complexRandom.Imaginary, -complexRandom.Real))
{
Console.WriteLine("FAiL! ErRoR ErrImaginaryOne_2738-1! Div by i does not equal to ({0}, {1}): {2}", complexRandom.Imaginary, -complexRandom.Real, divResult);
Assert.True(false, "Verification Failed");
}
}
