"{ Encoding: utf8 }"

"{ Package: 'stx:goodies/regression' }"

"{ NameSpace: RegressionTests }"

TestCase subclass:#ComplexTest
	instanceVariableNames:''
	classVariableNames:''
	poolDictionaries:''
	category:'tests-Regression-Numbers'
!


!ComplexTest class methodsFor:'accessing'!

testedClasses
    "for the browser and for coverage analysis:
     return a collection of classNames, which are tested by this testCase"

    ^ #( Complex )
! !

!ComplexTest methodsFor:'tests'!

testAbs
    | c |

    c := (6 - 6 i).
    self assert: c abs  = 72 sqrt.

    "
     self new testAbs

     self run: #testAbs
     self debug: #testAbs
    "
!

testAddition
    | c1 c2 c3 |

    self shouldnt: [ c1 := Complex real: 1 imaginary: 2 ] raise: Exception.
    self shouldnt: [ c2 := Complex real: 3 imaginary: 4 ] raise: Exception.

    self should: [ (c1 + c2) = (Complex real: 4 imaginary: 6) ].

    c3 := (5 - 6 i) + (-5 + 8 i).     "Complex with Complex"
    self assert: (c3 = (0 + 2 i)).

    self assert: (c1 + 1)   = (2 + 2 i).
    self assert: (c1 + 1.0) = (2 + 2 i).
    self assert: (1 + c1) = (2 + 2 i).
    self assert: (1.0 + c1) = (2 + 2 i).

    "
     self run: #testAddition
     self new testAddition
    "
!

testAngle
    | c |

    c := (1 + 1 i).
    self assert: (c angle radiansToDegrees rounded = 45).
    self assert: (c asPoint x = 1).
    self assert: (c asPoint y = 1).

    c := (-1 + 1 i).
    self assert: (c angle radiansToDegrees rounded = 135).
    self assert: (c asPoint x = -1).
    self assert: (c asPoint y = 1).

    c := (-1 - 1 i).
    self assert: (c angle radiansToDegrees rounded = -135).
    self assert: (c asPoint x = -1).
    self assert: (c asPoint y = -1).

    "
     self new testAngle

     self run: #testAngle
     self debug: #testAngle
    "
!

testCompare
    | c1 c2 |

    c1 := Complex real: 1 imaginary: 2.
    c2 := Complex real: 3 imaginary: 4.

    self assert: ( c1 ~= c2 ).
    self assert: ( c1 = c2 ) not.

    self should: [ c1 < c2 ] raise: Exception.
    self should: [ c1 <= c2 ] raise: Exception.
    self should: [ c1 >= c2 ] raise: Exception.
    self should: [ c1 > c2 ] raise: Exception.

    c1 := Complex fromReal: 1.

    self assert: ( c1 = 1 ).
    self assert: ( c1 = 1.0 ).
    self assert: ( c1 ~= 2 ).
    self assert: ( c1 ~= 2.0 ).

    self assert: ( 1 = c1 ).
    self assert: ( 1.0 = c1 ).
    self assert: ( 2 ~= c1 ).
    self assert: ( 2.0 ~= c1 ).
!

testComparing
    | c1a c1b c1c c1d c2a c2b c2c c2d |

    c1a := Complex real: 1 imaginary: 2.
    c1b := Complex real: 1.0 imaginary: 2.
    c1c := Complex real: 1 imaginary: 2.0.
    c1d := Complex real: 1.0 imaginary: 2.0.

    c2a := Complex real: 3 imaginary: 4.
    c2b := Complex real: 3.0 imaginary: 4.
    c2c := Complex real: 3 imaginary: 4.0.
    c2d := Complex real: 3.0 imaginary: 4.0.

    self assert: ( (c1a - c1a) isComplex not ).
    self assert: ( (c1a - c1b) isComplex not ).
    self assert: ( (c1a - c1c) isComplex not ).
    self assert: ( (c1a - c1d) isComplex not ).

    self assert: ( (c1b - c1a) isComplex not ).
    self assert: ( (c1b - c1b) isComplex not ).
    self assert: ( (c1b - c1c) isComplex not ).
    self assert: ( (c1b - c1d) isComplex not ).

    self assert: ( (c1c - c1a) isComplex not ).
    self assert: ( (c1c - c1b) isComplex not ).
    self assert: ( (c1c - c1c) isComplex not ).
    self assert: ( (c1c - c1d) isComplex not ).

    self assert: ( (c1d - c1a) isComplex not ).
    self assert: ( (c1d - c1b) isComplex not ).
    self assert: ( (c1d - c1c) isComplex not ).
    self assert: ( (c1d - c1d) isComplex not ).

    self assert: ( (c1a - c1a) = 0 ).
    self assert: ( (c1a - c1b) = 0 ).
    self assert: ( (c1a - c1c) = 0 ).
    self assert: ( (c1a - c1d) = 0 ).

    self assert: ( (c1a = c1a) ).
    self assert: ( (c1a = c1b) ).
    self assert: ( (c1a = c1c) ).
    self assert: ( (c1a = c1d) ).

    self assert: ( (c1a hash = c1a hash) ).
    self assert: ( (c1a hash = c1b hash) ).
    self assert: ( (c1a hash = c1c hash) ).
    self assert: ( (c1a hash = c1d hash) ).

    "Created: / 26-05-2019 / 10:08:55 / Claus Gittinger"
!

testConjugated
    | c |

    c := (2 + 5 i) .
    self assert: c conjugated  = (2 - 5i).

    "
     self run: #testConjugated
     self new testConjugated
    "
!

testConversion
    | c |

    c := Complex fromReal:1.
    self assert: (c asComplex = c).
    self assert: (c asFloat = 1).
    self assert: (c asInteger = 1).
    self assert: (c asPoint = (1@0) ).

    c := (1 + 1 i).
    self assert: (c asComplex = c).
    self should:[ c asFloat ] raise:Exception.
    self should:[ c asInteger ] raise:Exception.
    self assert: (c isComplex ).
    self assert: (c asPoint = (1@1) ).

    "
     self new testConversion

     self run: #testConversion
     self debug: #testConversion
    "
!

testCreation
    | c |

    false ifTrue:[
	"cg: I dont think this has to be known outside complex"
	"i.e. should it really be allowed to create complex numbers with new ?"
	self should: [ (c := Complex new) realPart = 0 ].
	self should: [ c imaginaryPart = 0 ].
    ].
    self should: [ (c := Complex real: 1 imaginary: 2) realPart = 1 ].
    self should: [ c imaginaryPart = 2 ].

    self should: [ (c := Complex real: -1 imaginary: 2) realPart = -1 ].
    self should: [ c imaginaryPart = 2 ].

    self should: [ (c := Complex real: 1 imaginary: -2) realPart = 1 ].
    self should: [ c imaginaryPart = -2 ].

    self should: [ (c := Complex real: -1 imaginary: -2) realPart = -1 ].
    self should: [ c imaginaryPart = -2 ].

    c := (1 % 2).
    self assert: (c real = 1).
    self assert: (c imaginary = 2).

    c := (-1 % 2).
    self assert: (c real = -1).
    self assert: (c imaginary = 2).

    c := (1 % -2).
    self assert: (c real = 1).
    self assert: (c imaginary = -2).

    c := (-1 % -2).
    self assert: (c real = -1).
    self assert: (c imaginary = -2).

    c := (1.0 % 2.0).
    self assert: (c real = 1.0).
    self assert: (c imaginary = 2.0).

    c := (-1.0 % 2.0).
    self assert: (c real = -1.0).
    self assert: (c imaginary = 2.0).

    c := (1.0 % -2.0).
    self assert: (c real = 1.0).
    self assert: (c imaginary = -2.0).

    c := (-1.0 % -2.0).
    self assert: (c real = -1.0).
    self assert: (c imaginary = -2.0).

    c := 5 i.
    self assert: (c real = 0).
    self assert: (c imaginary = 5).

    c := 6 + 7 i.
    self assert: (c real = 6).
    self assert: ( c imaginary = 7).

    c := 5.6 - 8 i.
    self assert: (c real = 5.6).
    self assert: (c imaginary = -8).

    c := Complex real: 10 imaginary: 5.
    self assert: (c real = 10).
    self assert: (c imaginary = 5).

    c := Complex abs: 5 arg: (Float pi/2).
    self assert: (c real rounded = 0).
    self assert: (c imaginary = 5).

    "
     self run: #testCreation
     self new testCreation
    "
!

testDivision
	| c1 c2 |

	self shouldnt: [ c1 := Complex real: 2 imaginary: 2 ] raise: Exception.
	self shouldnt: [ c2 := Complex real: 3 imaginary: 6 ] raise: Exception.

	self should: [ (c1 / c1) = (Complex real: 1 imaginary: 0) ].
	self should: [ (c1 / c2) = (Complex real: 2/5 imaginary: (-2/15)) ].
	self should: [ (c2 / c1) = (Complex real: 9/4 imaginary: 3/4) ].

	self should: [ c2 / 3 = (Complex real: 1 imaginary: 2) ].
	self should: [ c1 / 2 = (Complex real: 1 imaginary: 1) ].
!

testEquality
    self should: [ 3 = (Complex real: 3 imaginary: 0) ].
    self should: [ (Complex real: 3 imaginary: 0) = 3 ].

    self should: [ 3.0 = (Complex real: 3 imaginary: 0) ].
    self should: [ (Complex real: 3 imaginary: 0) = 3.0 ].

    self shouldnt: [ 3 = (Complex real: 3 imaginary: 1) ].
    self shouldnt: [ (Complex real: 3 imaginary: 1) = 3 ].

    self shouldnt: [ 3.0 = (Complex real: 3 imaginary: 1) ].
    self shouldnt: [ (Complex real: 3 imaginary: 1) = 3.0 ].

    self should: [ 3 ~= (Complex real: 3 imaginary: 1) ].
    self should: [ (Complex real: 3 imaginary: 1) ~= 3 ].

    self should: [ 3.0 ~= (Complex real: 3 imaginary: 1) ].
    self should: [ (Complex real: 3 imaginary: 1) ~= 3.0 ].

    self assert: 0i = 0.
    self assert: (2 - 5i) = ((1 - 4 i) + (1 - 1i)).
    self assert: 0i isZero.
    self deny: (1 + 3 i) = 1.
    self deny: (1 + 3 i) = (1 + 2i).

    "
     self run: #testEquality
     self new testEquality
    "
!

testFloorCeiling
    | c1 c2 |

    c1 := Complex real: 1 imaginary: 2.
    c2 := Complex real: 3 imaginary: 4.

    self should: [ c1 floor ] raise:Error.
    self should: [ c1 ceiling ] raise:Error.

    "Created: / 02-11-2012 / 10:04:43 / cg"
!

testModulus
	| c1 c2 |

	"Test case where |a| < |b| in complex number (a + ib)."

	self shouldnt: [ c1 := Complex real: 2 imaginary: 3 ] raise: Exception.
	self should: [ c1 modulus = (3 * ((1 + ((2 / 3) * (2 / 3))) sqrt)) ].

	"Test case where |a| >= |b| in complex number (a + ib)."

	self shouldnt: [ c2 := Complex real: 4 imaginary: -2 ] raise: Exception.
	self should: [ c2 modulus = (4 * ((1 + ((-2 / 4) * (-2 / 4))) sqrt)) ].
!

testMultiplication
    | c1 c2 |

    self shouldnt: [ c1 := Complex real: 1 imaginary: 2 ] raise: Exception.
    self shouldnt: [ c2 := Complex real: 3 imaginary: 4 ] raise: Exception.

    self should: [ (c1 * c2) = (Complex real: -5 imaginary: 10) ].
    self should: [ (c1 * Complex zero) = Complex zero ].

    self should: [ c1 * 5 = (Complex real: 5 imaginary: 10) ].
    self should: [ c1 * 1.1 = (Complex real: 1.1 imaginary: 2.2) ].
    self should: [ c1 * (2/3) = (Complex real: 2/3 imaginary: 4/3) ].

    self assert:( 1.0 * c1 = c1 ).
!

testNegated
    | c |
    c := (2 + 5 i) .
    self assert: c negated  = (-2 - 5i).

    "
     self run: #testNegated
     self new testNegated
    "
!

testRaisedTo
	| c |

	self shouldnt: [ c := Complex real: 3 imaginary: 2 ] raise: Exception.
	self assert:  ((c raisedTo: 2) = (c * c)).
	self assert:  ((c raisedTo: 3) = (c * c * c)).
	self assert:  ((c raisedTo: 4) = (c * c * c * c)).
!

testReciprocal
    | c |
    c := (2 + 5 i).
    self assert: c reciprocal  = ((2/29) - (5/29)i).

    "
     self run: #testReciprocal
     self new testReciprocal
    "
!

testReciprocalError
    | c |
    c := (0 i).
	self should: [c reciprocal] raise: ZeroDivide
    "
     self run: #testReciprocalError
     self new testReciprocalError
    "
!

testSqrt
	| c w |

	self shouldnt: [ c := Complex real: 0 imaginary: 0 ] raise: Exception.
	self should: [ c sqrt = 0 ].

	self shouldnt: [ c := Complex real: 9 imaginary: 4 ] raise: Exception.
	"cg: that cannot be tested easily, due to rounding errors"
	"original" false ifTrue:[
	    self should: [ w := 3 * (((1 + (1 + ((4/9) * (4/9))) sqrt) / 2) sqrt).
			    c sqrt = (Complex real: w imaginary: 4 / (2 * w)) ].
	] ifFalse:[
	    self should: [ |t1 t2 epsilon|
			    w := 3 * (((1 + (1 + ((4/9) * (4/9))) sqrt) / 2) sqrt).
			    t1 := c sqrt.
			    t2 := (Complex real: w imaginary: 4 / (2 * w)).
			    epsilon := 0.0000001.
			    (t1 realPart - t2 realPart) < epsilon
			    and:[ (t1 imaginaryPart - t2 imaginaryPart) < epsilon ]
			 ].
	].

	self shouldnt: [ c := Complex imaginary: -2 ] raise: Exception.
	"self should: [ c sqrt = (Complex real: 1 imaginary: -1) ].  Should be true, but rounding bites us..."
	self should: [ (c sqrt realPart - 1) abs < 1.0e-10 ].
	self should: [ (c sqrt imaginaryPart + 1) abs < 1.0e-10 ].
!

testSquared
    | c c2 |
    c := (6 - 6 i).
    c2 := (c squared).
    self assert: c2 imaginary = -72.
    self assert: c2 real = 0.

    "
     self new testSquared

     self run: #testSquared
     self debug: #testSquared
    "
!

testSubtraction
    | c1 c2 |

    self shouldnt: [ c1 := Complex real: 1 imaginary: 2 ] raise: Exception.
    self shouldnt: [ c2 := Complex real: 3 imaginary: 4 ] raise: Exception.

    self should: [ (c1 - c2) = (Complex real: -2 imaginary: -2) ].

    self assert: ( (c1 - 1.0) = (Complex real: 0 imaginary: 2) ).
    self assert: ( (1.0 - c1) = (Complex real: 0 imaginary: -2) ).
    self assert: ( (1.0 - (Complex fromReal:1.0)) = 0 ).
!

xxtestSecureDivision1
    | c1 c2 quotient |
    c1 := 2.0e252 + 3.0e70 i.
    c2 := c1.
    quotient := c1 divideSecureBy: c2.
    self assert: (quotient - 1) isZero.

    "
     self run: #testSecureDivision1
     self new testSecureDivision1
    "
!

xxtestSecureDivision2
    | c1 c2 quotient |
    c1 := 2.0e252 + 3.0e70 i.
    c2 := c1.
    quotient := c1 divideFastAndSecureBy: c2.
    self assert: (quotient - 1) isZero.

    "
     self run: #testSecureDivision2
     self new testSecureDivision2
    "
! !

!ComplexTest class methodsFor:'documentation'!

version
    ^ '$Header$'
!

version_CVS
    ^ '$Header$'
! !