complexNumbers/test_numerosComplejos.py at master · JCPosso/complexNumbers · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
import unittest
from LibreriaNumerosComplejos import *
"""Librería computación Cuántica: Números complejos
   pruebaas de unidad a la libreria Py.py donde se evaluaran
   sus distintas propiedes y casos arbitrarios
   @author (Juan Camilo Posso G.)
   @version (1.0 or 16/01/2020)
"""
class TestMathMethods(unittest.TestCase):
        global a,b,c
        a=complejo(3,2)
        b=complejo(5,4)
        c=complejo(2,1)
        # Se evaluan las propiedades de la suma
        def test_suma(self):
                aa=a.suma(b)
                self.assertEqual(aa, complejo(8,6))
        def test_sumaEsConmutativa(self):
                aa=a.suma(b)
                bb= b.suma(a)
                self.assertEqual(aa,bb)
        def test_sumaEsAsociativa(self):
                r1= (a.suma(b)).suma(c)
                r2= a.suma((b).suma(c))
                self.assertEqual(r1,r2)
        def test_identidadDeSuma(self):
                d= complejo(0,0)
                r=a.suma(d)
                self.assertEqual(r,a)
        # Se evaluan las propiedades de la resta
        def test_resta(self):
                x=a.resta(b)
                self.assertEqual(x,complejo(-2,-2))
        def test_restaNoEsConmutativa(self):
                x=a.resta(b)
                y= b.resta(a)
                self.assertFalse(x==y)
        def test_identidadDeResta(self):
                d= complejo(0,0)
                r=a.resta(d)
                self.assertEqual(r,a)
        # Se evaluan las propiedades de la multiplicacion
        def test_multiplicacion(self):
                x=a.multiplica(b)
                self.assertEqual(x,complejo(7,22))
        def test_multiplicacionPorCero(self):
                d=complejo(0,0)
                x=a.multiplica(d)
                self.assertEqual(x,d)
        def test_identidadDeMultiplicacion(self):
                d=complejo(1,0)
                x=a.multiplica(d)
                self.assertEqual(x,a)
        def test_multiplicacionEsAsociativa(self):
                r1= (a.multiplica(b)).multiplica(c)
                r2= a.multiplica((b).multiplica(c))
                self.assertEqual(r1,r2)
        def test_multiplicacionEsConmutativa(self):
                aa=a.multiplica(b)
                bb= b.multiplica(a)
                self.assertEqual(aa,bb)
        def test_multiplicacionDistribuyeSobreAdicion(self):
                r1=a.multiplica(b.suma(c))
                r2=( a.multiplica(b)).suma(a.multiplica(c) )
                self.assertEqual(r1,r2)
        # Se evaluan las propiedades de la division
        def test_division(self):
                x=a.divide(b)
                self.assertEqual(x,complejo(0.56,-0.05))
        def test_identidadDeDivision(self):
                d=complejo(1,0)
                a=complejo(3.0,2.0)
                x=a.divide(d)
                self.assertEqual(x,a)
        def test_divisionPorCero(self):
                try:
                        d=complejo(0,0)
                        x=a.divide(d)
                except Exception :
                        pass
                else:
                        assert False
        # Se evalua  modulo
        def test01_modulo(self):
                r=a.modulo()
                self.assertEqual(round(r,2),3.61)
        def test02_modulo(self):
                r=b.modulo()
                self.assertEqual(round(r,2),6.4)
        def test03_modulo(self):
                r=c.modulo()
                self.assertEqual(round(r,2),2.24)
        #se evalua el conjugado
        def test01_conjugado(self):
                r=a.conjugado()
                self.assertTrue(r==complejo(3,-2))
        def test02_conjugado(self):
                r=b.conjugado()
                self.assertTrue(r==complejo(5,-4))
        def test03_conjugado(self):
                r=c.conjugado()
                self.assertTrue(r==complejo(2,-1))
        # Se evaluan la conversion de cartesiano a polar
        def test01_pasarAPolar(self):
                r=c.aPolar()
                self.assertEqual(r,complejo(2.24, 0.46))
        def test02_noPasarAPolarSiDivisorEsCero(self):
                try:
                        d=complejo(0,0)
                        x=d.aPolar()
                        self.assertFalse(x)
                except Exception :
                        pass
                else:
                        assert False
        def test03_pasarAPolar(self):
                r=b.aPolar()
                self.assertEqual(r,complejo(6.4, 0.67))
        # Se evaluan fase de un numero complejo
        def test01_faseCuadrante2(self):
                b=complejo(-5,4)
                r=b.fase()
                self.assertEqual(r,2.47)
        def test02_faseCuadrante3(self):
                c=complejo(-8,-5)
                r=c.fase()
                self.assertEqual(r,-2.58)
        def test03_faseCuadrante4(self):
                c=complejo(9,-2)
                r=c.fase()
                self.assertEqual(r,-0.22)
        def test04_noRetornarFaseSiEsIndefinido(self):
                try:
                        c=complejo(0,0)
                        r=c.fase()
                        self.assertTrue(r)
                except Exception :
                        pass
                else:
                        assert False
if __name__ == '__main__':
        unittest.main()