public static void RunTests_RandomValidValues()
{
// Verify test results with ComplexInFirstQuad
double real = Support.GetSmallRandomDoubleValue(false);
double imaginary = Support.GetSmallRandomDoubleValue(false);
VerifySinh(real, imaginary);
// Verify test results with ComplexInSecondQuad
real = Support.GetSmallRandomDoubleValue(true);
imaginary = Support.GetSmallRandomDoubleValue(false);
VerifySinh(real, imaginary);
// Verify test results with ComplexInThirdQuad
real = Support.GetSmallRandomDoubleValue(true);
imaginary = Support.GetSmallRandomDoubleValue(true);
VerifySinh(real, imaginary);
// Verify test results with ComplexInFourthQuad
real = Support.GetSmallRandomDoubleValue(false);
imaginary = Support.GetSmallRandomDoubleValue(true);
VerifySinh(real, imaginary);
}
public static void RunTests_SByteImplicitCastToComplex()
{
VerifySByteImplicitCastToComplex(SByte.MinValue);
#if CLS_Compliant
for (int i = 0; i < Support.RandomSampleCount; ++i)
{
SByte randomValue = Support.GetRandomSByteValue(false);
VerifySByteImplicitCastToComplex(randomValue);
}
#endif
VerifySByteImplicitCastToComplex(0);
VerifySByteImplicitCastToComplex(1);
#if CLS_Compliant
for (int i = 0; i < Support.RandomSampleCount; ++i)
{
SByte randomValue = Support.GetRandomSByteValue(true);
VerifySByteImplicitCastToComplex(randomValue);
}
#endif
VerifySByteImplicitCastToComplex(SByte.MaxValue);
}
public static void RunTests_RandomValidValues()
{
// Verify test results with ComlexInFirstQuad
Double real = Support.GetSmallRandomDoubleValue(false);
Double imaginary = Support.GetSmallRandomDoubleValue(false);
VerifyBinaryAbs(real, imaginary, Math.Sqrt(real * real + imaginary * imaginary));
// Verify test results with ComplexInSecondQuad
real = Support.GetSmallRandomDoubleValue(true);
imaginary = Support.GetSmallRandomDoubleValue(false);
VerifyBinaryAbs(real, imaginary, Math.Sqrt(real * real + imaginary * imaginary));
// Verify test results with ComplexInThirdQuad
real = Support.GetSmallRandomDoubleValue(false);
imaginary = Support.GetSmallRandomDoubleValue(true);
VerifyBinaryAbs(real, imaginary, Math.Sqrt(real * real + imaginary * imaginary));
// Verify test results with ComplexInFourthQuad
real = Support.GetSmallRandomDoubleValue(true);
imaginary = Support.GetSmallRandomDoubleValue(true);
VerifyBinaryAbs(real, imaginary, Math.Sqrt(real * real + imaginary * imaginary));
}
private static void RunTests_PowComplex(double a, double b)
{
VerifyPow(a, b, 0.0, -1.0);
VerifyPow(a, b, 0.0, 0.0);
VerifyPow(a, b, 0.0, 1.0);
VerifyPow(a, b, 1.0, 0.0);
double real = Support.GetSmallRandomDoubleValue(false);
double imaginary = Support.GetSmallRandomDoubleValue(false);
VerifyPow(a, b, real, imaginary);
real = Support.GetSmallRandomDoubleValue(true);
imaginary = Support.GetSmallRandomDoubleValue(false);
VerifyPow(a, b, real, imaginary);
real = Support.GetSmallRandomDoubleValue(true);
imaginary = Support.GetSmallRandomDoubleValue(true);
VerifyPow(a, b, real, imaginary);
real = Support.GetSmallRandomDoubleValue(false);
imaginary = Support.GetSmallRandomDoubleValue(true);
VerifyPow(a, b, real, imaginary);
}
private static void VerifyPow(double a, double b, double doubleVal)
{
Complex x = new Complex(a, b);
Complex powComplex = Complex.Pow(x, doubleVal);
double expectedReal = 0;
double expectedImaginary = 0;
if (0 == doubleVal)
{
expectedReal = 1;
}
else if (!(0 == a && 0 == b))
{
//pow(x, y) = exp(y·log(x))
Complex y = new Complex(doubleVal, 0);
Complex expected = Complex.Exp(y * Complex.Log(x));
expectedReal = expected.Real;
expectedImaginary = expected.Imaginary;
}
Support.VerifyRealImaginaryProperties(powComplex, expectedReal, expectedImaginary,
string.Format("Pow (({0}, {1}), {2})", a, b, doubleVal));
}
private static void VerifyBinaryMultiplyResult(double realFirst, double imgFirst, double realSecond, double imgSecond)
{
// calculate the expected results
double realExpectedResult = realFirst * realSecond - imgFirst * imgSecond;
double imaginaryExpectedResult = realFirst * imgSecond + imgFirst * realSecond;
// Create complex numbers
Complex cFirst = new Complex(realFirst, imgFirst);
Complex cSecond = new Complex(realSecond, imgSecond);
// arithmetic multiply (binary) operation
Complex cResult = cFirst * cSecond;
// verify the result
Support.VerifyRealImaginaryProperties(cResult, realExpectedResult, imaginaryExpectedResult,
string.Format("Binary Multiply test = ({0}, {1}) * ({2}, {3})", realFirst, imgFirst, realSecond, imgSecond));
// arithmetic multiply (static) operation
cResult = Complex.Multiply(cFirst, cSecond);
// verify the result
Support.VerifyRealImaginaryProperties(cResult, realExpectedResult, imaginaryExpectedResult,
string.Format("Multiply (Static) test = ({0}, {1}) * ({2}, {3})", 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;
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));
}
private static void VerifyExpWithAddition(double real, double imaginary)
{
// verify with e(x+y) = e(x)*e(y) if xy == yx
Complex realComplex = new Complex(real, 0.0);
Complex imgComplex = new Complex(0.0, imaginary);
Complex ri = realComplex * imgComplex;
Complex ir = imgComplex * realComplex;
if (!ri.Equals(ir))
{
return;
}
Complex realExp = Complex.Exp(realComplex);
Complex imgExp = Complex.Exp(imgComplex);
Complex expectedExp = realExp * imgExp;
Complex complex = new Complex(real, imaginary);
Complex complexExp = Complex.Exp(complex);
Support.VerifyRealImaginaryProperties(complexExp, expectedExp.Real, expectedExp.Imaginary,
string.Format("Exp({0}):{1} != {2})", complex, complexExp, expectedExp));
}
// Verification is done with Abs and Conjugate methods
private static void VerifyBinaryDivideResult(double realFirst, double imgFirst, double realSecond, double imgSecond)
{
// Create complex numbers
Complex cFirst = new Complex(realFirst, imgFirst);
Complex cSecond = new Complex(realSecond, imgSecond);
Complex cExpectedResult = (cFirst * Complex.Conjugate(cSecond));
double cExpectedReal = cExpectedResult.Real;
double cExpectedImaginary = cExpectedResult.Imaginary;
if (!double.IsInfinity(cExpectedReal))
{
cExpectedReal = cExpectedReal / (cSecond.Magnitude * cSecond.Magnitude);
}
if (!double.IsInfinity(cExpectedImaginary))
{
cExpectedImaginary = cExpectedImaginary / (cSecond.Magnitude * cSecond.Magnitude);
}
// local variables
Complex cResult;
// arithmetic binary divide operation
cResult = cFirst / cSecond;
// verify the result
Support.VerifyRealImaginaryProperties(cResult, cExpectedReal, cExpectedImaginary,
string.Format("Binary Divide test = ({0}, {1}) / ({2}, {3})", realFirst, imgFirst, realSecond, imgSecond));
// arithmetic divide (static) operation
cResult = Complex.Divide(cFirst, cSecond);
// verify the result
Support.VerifyRealImaginaryProperties(cResult, cExpectedReal, cExpectedImaginary,
string.Format("Divide (Static) test = ({0}, {1}) / ({2}, {3})", realFirst, imgFirst, realSecond, imgSecond));
}
public static void RunTests_RandomValidValues()
{
// Verify test results with ComplexInFirstQuad - ComplexInFirstQuad
double realFirst = Support.GetRandomDoubleValue(false);
double imgFirst = Support.GetRandomDoubleValue(false);
double realSecond = Support.GetRandomDoubleValue(false);
double imgSecond = Support.GetRandomDoubleValue(false);
VerifyBinaryMinusResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify test results with ComplexInFirstQuad - ComplexInSecondQuad
realFirst = Support.GetRandomDoubleValue(false);
imgFirst = Support.GetRandomDoubleValue(false);
realSecond = Support.GetRandomDoubleValue(true);
imgSecond = Support.GetRandomDoubleValue(false);
VerifyBinaryMinusResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify test results with ComplexInFirstQuad - ComplexInThirdQuad
realFirst = Support.GetRandomDoubleValue(false);
imgFirst = Support.GetRandomDoubleValue(false);
realSecond = Support.GetRandomDoubleValue(true);
imgSecond = Support.GetRandomDoubleValue(true);
VerifyBinaryMinusResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify test results with ComplexInFirstQuad - ComplexInFourthQuad
realFirst = Support.GetRandomDoubleValue(false);
imgFirst = Support.GetRandomDoubleValue(false);
realSecond = Support.GetRandomDoubleValue(false);
imgSecond = Support.GetRandomDoubleValue(true);
VerifyBinaryMinusResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify test results with ComplexInSecondQuad - ComplexInSecondQuad
realFirst = Support.GetRandomDoubleValue(true);
imgFirst = Support.GetRandomDoubleValue(false);
realSecond = Support.GetRandomDoubleValue(true);
imgSecond = Support.GetRandomDoubleValue(false);
VerifyBinaryMinusResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify test results with ComplexInSecondQuad - ComplexInThirdQuad
realFirst = Support.GetRandomDoubleValue(true);
imgFirst = Support.GetRandomDoubleValue(false);
realSecond = Support.GetRandomDoubleValue(true);
imgSecond = Support.GetRandomDoubleValue(true);
VerifyBinaryMinusResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify test results with ComplexInSecondQuad - ComplexInFourthQuad
realFirst = Support.GetRandomDoubleValue(true);
imgFirst = Support.GetRandomDoubleValue(false);
realSecond = Support.GetRandomDoubleValue(false);
imgSecond = Support.GetRandomDoubleValue(true);
VerifyBinaryMinusResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify test results with ComplexInThirdQuad - ComplexInThirdQuad
realFirst = Support.GetRandomDoubleValue(true);
imgFirst = Support.GetRandomDoubleValue(true);
realSecond = Support.GetRandomDoubleValue(true);
imgSecond = Support.GetRandomDoubleValue(true);
VerifyBinaryMinusResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify test results with ComplexInThirdQuad - ComplexInFourthQuad
realFirst = Support.GetRandomDoubleValue(true);
imgFirst = Support.GetRandomDoubleValue(true);
realSecond = Support.GetRandomDoubleValue(false);
imgSecond = Support.GetRandomDoubleValue(true);
VerifyBinaryMinusResult(realFirst, imgFirst, realSecond, imgSecond);
// Verify test results with ComplexInFourthQuad - ComplexInFourthQuad
realFirst = Support.GetRandomDoubleValue(true);
imgFirst = Support.GetRandomDoubleValue(false);
realSecond = Support.GetRandomDoubleValue(true);
imgSecond = Support.GetRandomDoubleValue(false);
VerifyBinaryMinusResult(realFirst, imgFirst, realSecond, imgSecond);
}
public static void RunTests_Zero()
{
// Verify it is zero.
Assert.True(0 == Complex.Zero, string.Format("Zero does not equal to (0.0, 0.0)"));
// Verify real and imaginary parts are 0.0
Support.VerifyRealImaginaryProperties(Complex.Zero, 0.0, 0.0, "Verify real and imaginary parts are 0.0");
// verify magnitude is 0.0 and phase is NaN.
Support.VerifyMagnitudePhaseProperties(Complex.Zero, 0.0, double.NaN, "Verify magnitude is 0.0 and phase is NaN");
// 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*0 = 0
Complex multResult = complexRandom * Complex.Zero;
Assert.True(0 == multResult, string.Format("Multiplication with Zero does not equal to 0: {0}", multResult));
// verify x/0 = Infinity
Complex divisorZeroResult = complexRandom / Complex.Zero;
Support.VerifyRealImaginaryProperties(divisorZeroResult, double.NaN, double.NaN,
string.Format("Division with Zero does not equal to (NaN, NaN): {0}", divisorZeroResult));
// verify 0/x = 0
Complex divZeroResult = Complex.Zero / complexRandom;
Assert.True(0 == divZeroResult, string.Format("Division of Zero does not equal to 0: {0}", divZeroResult));
// verify x - 0 = 0
Complex subZeroResult = complexRandom - Complex.Zero;
Assert.True(complexRandom == subZeroResult, string.Format("Zero sub does not equal to complex {0} itself: {1}", complexRandom, subZeroResult));
// verify 0 - x = -x
Complex subComplexResult = Complex.Zero - complexRandom;
Assert.True(subComplexResult == -complexRandom, string.Format("Sub from Zero does not equal to neg complex {0}: {1}", complexRandom, subComplexResult));
// verify x + 0 = x
Complex addZeroResult = complexRandom + Complex.Zero;
Assert.True(addZeroResult == complexRandom, string.Format("Add Zero result does not equal to complex {0}: {1}", complexRandom, addZeroResult));
// verify 0 + x = x
Complex addComplexResult = Complex.Zero + complexRandom;
Assert.True(addComplexResult == complexRandom, string.Format("Add to Zero result does not equal to complex {0}: {1}", complexRandom, addComplexResult));
// verify Abs(0) = 0
double absResult = Complex.Abs(Complex.Zero);
Assert.True(0.0 == absResult, string.Format("Abs(Zero) does not equal to 0: {0}", absResult));
// verify Conjugate(0) = 0
Complex conjugateResult = Complex.Conjugate(Complex.Zero);
Assert.True(0 == conjugateResult, string.Format("Conjugate(Zero) does not equal to 0: {0}", conjugateResult));
// verify Reciprocal(0) goes to 0
Complex reciprocalResult = Complex.Reciprocal(Complex.Zero);
Assert.True(reciprocalResult == Complex.Zero, string.Format("Reciprocal(Zero) does not go to Infinity: {0}", reciprocalResult));
}
public static void RunTests_ZeroOneImaginaryOne()
{
double real = Support.GetRandomDoubleValue(false);
double imaginary = Support.GetRandomDoubleValue(false);
Complex randomComplex = new Complex(real, imaginary);
real = Support.GetRandomDoubleValue(true);
imaginary = Support.GetRandomDoubleValue(true);
Complex randomComplexNeg = new Complex(real, imaginary);
real = Support.GetSmallRandomDoubleValue(false);
imaginary = Support.GetSmallRandomDoubleValue(false);
Complex randomSmallComplex = new Complex(real, imaginary);
real = Support.GetSmallRandomDoubleValue(true);
imaginary = Support.GetSmallRandomDoubleValue(true);
Complex randomSmallComplexNeg = new Complex(real, imaginary);
VerifyComplexComparison(Complex.Zero, Complex.Zero, true);
VerifyComplexComparison(Complex.Zero, Complex.One, false);
VerifyComplexComparison(Complex.Zero, -Complex.One, false);
VerifyComplexComparison(Complex.Zero, Complex.ImaginaryOne, false);
VerifyComplexComparison(Complex.Zero, -Complex.ImaginaryOne, false);
VerifyComplexComparison(Complex.Zero, -Complex.ImaginaryOne, false);
bool expectedResult = (randomComplex.Real == 0.0 && randomComplex.Imaginary == 0.0);
VerifyComplexComparison(Complex.Zero, randomComplex, expectedResult);
expectedResult = (randomComplexNeg.Real == 0.0 && randomComplexNeg.Imaginary == 0.0);
VerifyComplexComparison(Complex.Zero, randomComplexNeg, expectedResult);
expectedResult = (randomSmallComplex.Real == 0.0 && randomSmallComplex.Imaginary == 0.0);
VerifyComplexComparison(Complex.Zero, randomSmallComplex, expectedResult);
expectedResult = (randomSmallComplexNeg.Real == 0.0 && randomSmallComplexNeg.Imaginary == 0.0);
VerifyComplexComparison(Complex.Zero, randomSmallComplexNeg, expectedResult);
VerifyComplexComparison(Complex.One, Complex.One, true);
VerifyComplexComparison(Complex.One, -Complex.One, false);
VerifyComplexComparison(Complex.One, Complex.ImaginaryOne, false);
VerifyComplexComparison(Complex.One, -Complex.ImaginaryOne, false);
expectedResult = (randomComplex.Real == 1.0 && randomComplex.Imaginary == 0.0);
VerifyComplexComparison(Complex.One, randomComplex, expectedResult);
expectedResult = (randomComplexNeg.Real == 1.0 && randomComplexNeg.Imaginary == 0.0);
VerifyComplexComparison(Complex.One, randomComplexNeg, expectedResult);
expectedResult = (randomSmallComplex.Real == 1.0 && randomSmallComplex.Imaginary == 0.0);
VerifyComplexComparison(Complex.One, randomSmallComplex, expectedResult);
expectedResult = (randomSmallComplexNeg.Real == 1.0 && randomSmallComplexNeg.Imaginary == 0.0);
VerifyComplexComparison(Complex.One, randomSmallComplexNeg, expectedResult);
VerifyComplexComparison(-Complex.One, -Complex.One, true);
VerifyComplexComparison(-Complex.One, Complex.ImaginaryOne, false);
VerifyComplexComparison(-Complex.One, -Complex.ImaginaryOne, false);
expectedResult = (randomComplex.Real == -1.0 && randomComplex.Imaginary == 0.0);
VerifyComplexComparison(-Complex.One, randomComplex, expectedResult);
expectedResult = (randomComplexNeg.Real == -1.0 && randomComplexNeg.Imaginary == 0.0);
VerifyComplexComparison(-Complex.One, randomComplexNeg, expectedResult);
expectedResult = (randomSmallComplex.Real == -1.0 && randomSmallComplex.Imaginary == 0.0);
VerifyComplexComparison(-Complex.One, randomSmallComplex, expectedResult);
expectedResult = (randomSmallComplexNeg.Real == -1.0 && randomSmallComplexNeg.Imaginary == 0.0);
VerifyComplexComparison(-Complex.One, randomSmallComplexNeg, expectedResult);
VerifyComplexComparison(Complex.ImaginaryOne, Complex.ImaginaryOne, true);
VerifyComplexComparison(Complex.ImaginaryOne, -Complex.ImaginaryOne, false);
expectedResult = (randomComplex.Real == 0.0 && randomComplex.Imaginary == 1.0);
VerifyComplexComparison(Complex.ImaginaryOne, randomComplex, expectedResult);
expectedResult = (randomComplexNeg.Real == 0.0 && randomComplexNeg.Imaginary == 1.0);
VerifyComplexComparison(Complex.ImaginaryOne, randomComplexNeg, expectedResult);
expectedResult = (randomSmallComplex.Real == 0.0 && randomSmallComplex.Imaginary == 1.0);
VerifyComplexComparison(Complex.ImaginaryOne, randomSmallComplex, expectedResult);
expectedResult = (randomSmallComplexNeg.Real == 0.0 && randomSmallComplexNeg.Imaginary == 1.0);
VerifyComplexComparison(Complex.ImaginaryOne, randomSmallComplexNeg, expectedResult);
VerifyComplexComparison(-Complex.ImaginaryOne, -Complex.ImaginaryOne, true);
expectedResult = (randomComplex.Real == 0.0 && randomComplex.Imaginary == -1.0);
VerifyComplexComparison(-Complex.ImaginaryOne, randomComplex, expectedResult);
expectedResult = (randomComplexNeg.Real == 0.0 && randomComplexNeg.Imaginary == -1.0);
VerifyComplexComparison(-Complex.ImaginaryOne, randomComplexNeg, expectedResult);
expectedResult = (randomSmallComplex.Real == 0.0 && randomSmallComplex.Imaginary == -1.0);
VerifyComplexComparison(-Complex.ImaginaryOne, randomSmallComplex, expectedResult);
expectedResult = (randomSmallComplexNeg.Real == 0.0 && randomSmallComplexNeg.Imaginary == -1.0);
VerifyComplexComparison(-Complex.ImaginaryOne, randomSmallComplexNeg, expectedResult);
}
public static void RunTests_MaxMinValues()
{
double real = Support.GetRandomDoubleValue(false);
double imaginary = Support.GetRandomDoubleValue(false);
Complex randomComplex = new Complex(real, imaginary);
real = Support.GetRandomDoubleValue(true);
imaginary = Support.GetRandomDoubleValue(true);
Complex randomComplexNeg = new Complex(real, imaginary);
real = Support.GetSmallRandomDoubleValue(false);
imaginary = Support.GetSmallRandomDoubleValue(false);
Complex randomSmallComplex = new Complex(real, imaginary);
real = Support.GetSmallRandomDoubleValue(true);
imaginary = Support.GetSmallRandomDoubleValue(true);
Complex randomSmallComplexNeg = new Complex(real, imaginary);
Complex maxComplex = new Complex(double.MaxValue, double.MaxValue);
Complex minComplex = new Complex(double.MinValue, double.MinValue);
Complex maxReal = new Complex(double.MaxValue, 0.0);
Complex minReal = new Complex(double.MinValue, 0.0);
Complex maxImaginary = new Complex(0.0, double.MaxValue);
Complex minImaginary = new Complex(0.0, double.MinValue);
VerifyComplexComparison(maxComplex, maxComplex, true);
VerifyComplexComparison(maxComplex, minComplex, false);
VerifyComplexComparison(maxComplex, maxReal, false);
VerifyComplexComparison(maxComplex, minReal, false);
VerifyComplexComparison(maxComplex, maxImaginary, false);
VerifyComplexComparison(maxComplex, minImaginary, false);
bool expectedResult = (randomComplex.Real == maxComplex.Real && randomComplex.Imaginary == maxComplex.Imaginary);
VerifyComplexComparison(maxComplex, randomComplex, expectedResult);
expectedResult = (randomComplexNeg.Real == maxComplex.Real && randomComplexNeg.Imaginary == maxComplex.Imaginary);
VerifyComplexComparison(maxComplex, randomComplexNeg, expectedResult);
expectedResult = (randomSmallComplex.Real == maxComplex.Real && randomSmallComplex.Imaginary == maxComplex.Imaginary);
VerifyComplexComparison(maxComplex, randomSmallComplex, expectedResult);
expectedResult = (randomSmallComplexNeg.Real == maxComplex.Real && randomSmallComplexNeg.Imaginary == maxComplex.Imaginary);
VerifyComplexComparison(maxComplex, randomSmallComplexNeg, expectedResult);
VerifyComplexComparison(minComplex, minComplex, true);
VerifyComplexComparison(minComplex, maxReal, false);
VerifyComplexComparison(minComplex, maxImaginary, false);
VerifyComplexComparison(minComplex, minImaginary, false);
expectedResult = (randomComplex.Real == minComplex.Real && randomComplex.Imaginary == minComplex.Imaginary);
VerifyComplexComparison(minComplex, randomComplex, expectedResult);
expectedResult = (randomComplexNeg.Real == minComplex.Real && randomComplexNeg.Imaginary == minComplex.Imaginary);
VerifyComplexComparison(minComplex, randomComplexNeg, expectedResult);
expectedResult = (randomSmallComplex.Real == minComplex.Real && randomSmallComplex.Imaginary == minComplex.Imaginary);
VerifyComplexComparison(minComplex, randomSmallComplex, expectedResult);
expectedResult = (randomSmallComplexNeg.Real == minComplex.Real && randomSmallComplexNeg.Imaginary == minComplex.Imaginary);
VerifyComplexComparison(minComplex, randomSmallComplexNeg, expectedResult);
VerifyComplexComparison(maxReal, maxReal, true);
VerifyComplexComparison(maxReal, minReal, false);
VerifyComplexComparison(maxReal, maxImaginary, false);
VerifyComplexComparison(maxReal, minImaginary, false);
expectedResult = (randomComplex.Real == maxReal.Real && randomComplex.Imaginary == maxReal.Imaginary);
VerifyComplexComparison(maxReal, randomComplex, expectedResult);
expectedResult = (randomComplexNeg.Real == maxReal.Real && randomComplexNeg.Imaginary == maxReal.Imaginary);
VerifyComplexComparison(maxReal, randomComplexNeg, expectedResult);
expectedResult = (randomSmallComplex.Real == maxReal.Real && randomSmallComplex.Imaginary == maxReal.Imaginary);
VerifyComplexComparison(maxReal, randomSmallComplex, expectedResult);
expectedResult = (randomSmallComplexNeg.Real == maxReal.Real && randomSmallComplexNeg.Imaginary == maxReal.Imaginary);
VerifyComplexComparison(maxReal, randomSmallComplexNeg, expectedResult);
VerifyComplexComparison(minReal, minReal, true);
VerifyComplexComparison(minReal, maxImaginary, false);
VerifyComplexComparison(minReal, minImaginary, false);
expectedResult = (randomComplex.Real == minReal.Real && randomComplex.Imaginary == minReal.Imaginary);
VerifyComplexComparison(minReal, randomComplex, expectedResult);
expectedResult = (randomComplexNeg.Real == minReal.Real && randomComplexNeg.Imaginary == minReal.Imaginary);
VerifyComplexComparison(minReal, randomComplexNeg, expectedResult);
expectedResult = (randomSmallComplex.Real == minReal.Real && randomSmallComplex.Imaginary == minReal.Imaginary);
VerifyComplexComparison(minReal, randomSmallComplex, expectedResult);
expectedResult = (randomSmallComplexNeg.Real == minReal.Real && randomSmallComplexNeg.Imaginary == minReal.Imaginary);
VerifyComplexComparison(minReal, randomSmallComplexNeg, expectedResult);
VerifyComplexComparison(maxImaginary, maxImaginary, true);
VerifyComplexComparison(maxImaginary, minImaginary, false);
expectedResult = (randomComplex.Real == maxImaginary.Real && randomComplex.Imaginary == maxImaginary.Imaginary);
VerifyComplexComparison(maxImaginary, randomComplex, expectedResult);
expectedResult = (randomComplexNeg.Real == maxImaginary.Real && randomComplexNeg.Imaginary == maxImaginary.Imaginary);
VerifyComplexComparison(maxImaginary, randomComplexNeg, expectedResult);
expectedResult = (randomSmallComplex.Real == maxImaginary.Real && randomSmallComplex.Imaginary == maxImaginary.Imaginary);
VerifyComplexComparison(maxImaginary, randomSmallComplex, expectedResult);
expectedResult = (randomSmallComplexNeg.Real == maxImaginary.Real && randomSmallComplexNeg.Imaginary == maxImaginary.Imaginary);
VerifyComplexComparison(maxImaginary, randomSmallComplexNeg, expectedResult);
VerifyComplexComparison(minImaginary, minImaginary, true);
expectedResult = (randomComplex.Real == minImaginary.Real && randomComplex.Imaginary == minImaginary.Imaginary);
VerifyComplexComparison(minImaginary, randomComplex, expectedResult);
expectedResult = (randomComplexNeg.Real == minImaginary.Real && randomComplexNeg.Imaginary == minImaginary.Imaginary);
VerifyComplexComparison(minImaginary, randomComplexNeg, expectedResult);
expectedResult = (randomSmallComplex.Real == minImaginary.Real && randomSmallComplex.Imaginary == minImaginary.Imaginary);
VerifyComplexComparison(minImaginary, randomSmallComplex, expectedResult);
expectedResult = (randomSmallComplexNeg.Real == minImaginary.Real && randomSmallComplexNeg.Imaginary == minImaginary.Imaginary);
VerifyComplexComparison(minImaginary, randomSmallComplexNeg, expectedResult);
}
private static void VerifyCtor(double real, double imaginary)
{
Complex c_new = new Complex(real, imaginary);
Support.VerifyRealImaginaryProperties(c_new, real, imaginary,
string.Format("Error_ctor(Complex): ({0}, {1})", real, imaginary));
}
