Algebra Lineal

Números complejos.

Acerca de numpy: Numpy



In [1]:

    
%pylab inline









    



Populating the interactive namespace from numpy and matplotlib



In [2]:

    
# Ahora utilizamos la función "np.sqrt" ("raiz cuadrada", del ingles 'square root')
# del módulo "np" utilizando la notación "modulo.función" ,
# usando el número complejo/imaginario -1 (en Python "j" denota el número imaginario "i"):
sqrt(complex(-1))









    Out[2]:





1j

Potencia	Desarrollo	Equivalencia
$i^1$	$\sqrt{-1}$	$i$
$i^2$	$(\sqrt{-1})(\sqrt{-1})=(\sqrt{-1})^2$	$-1$
$i^3$	$i^2·i=(-1)(\sqrt{-1})$	$-i$
$i^4$	$i^2·i^2=(-1)(-1)$	$1$
$i^5$	$i^4·i=(1)(i)$	$i$
$i^6$	$i^4·i^2=(1)(-1)$	$-1$

Para encontrar $i$ elevado a cualquier potencia, hay que dividir la potencia entre 4, ya que $i^4=1$. El residuo va a ser la potencia a la cual se eleve $i$ y se multiplique por 1, ejemplo:

$i^8$



In [3]:

    
# La función "divmod" regresa una tupla con el cociente y residuo de una división:
cociente, residuo = divmod(8, 4) # "divmod" nos da el cociente y el modulo (residuo) de 8/4.
print('cociente: {0}\n'
      ' residuo: {1}'.format(cociente, residuo))









    



cociente: 2
 residuo: 0

$\frac{8}{4} = (i^2)^4 i^0 = (1)(1)=1$

Representación binomica o cartesiana.

$a+bi$

Donde $a$ es la parte real y $bi$ es la parte imaginaria. Suponiendo que:

$2x^2-2x+5=0$

Usando la formula general:

$x = \frac{-b \pm \sqrt{b²-4ac}}{2a}$



In [4]:

    
# Despues definimos una función que compute la formula general,
# "fgen" regresa una tupla con el valor de (x1, x2),
# tenemos que usar la funcion "np.complex" para tener un
# numero complejo en caso de que la raiz sea negativa:
def fgen(a, b, c):
    x1 = (-b + sqrt(complex(b**2 - 4*a*c))) / (2*a)
    x2 = (-b - sqrt(complex(b**2 - 4*a*c))) / (2*a)
    return (x1, x2)



In [5]:

    
# Por ultimo llamamos a la función "fgen" con los argumentos (2, -2, 5).
# a = 2; b = -2; c = 5:
x1, x2 = fgen(2, -2, 5)

print('x1 = {0}\n'
      'x2 = {1}'.format(x1, x2))









    



x1 = (0.5+1.5j)
x2 = (0.5-1.5j)

Es decir, el resultado es:

$x_1 = \frac{1}{2} + \frac{3}{2}i$

$x_2 = \frac{1}{2} - \frac{3}{2}i$

Tarea:

$\sqrt{-70}$



In [6]:

    
r = sqrt(complex(-70))
print('Resultado: {0}'.format(r))









    



Resultado: 8.366600265340756j

$i^{203}$



In [7]:

    
cociente, residuo = divmod(203, 4)
print('cociente: {0}\n'
      ' residuo: {1}'.format(cociente, residuo))









    



cociente: 50
 residuo: 3

Resultado: $\frac{203}{4} = (i^50)^4 i^0 = (1)(1)=1$

$3x^2-2x+5=0$



In [8]:

    
x1, x2 = fgen(3, -2, 50)

print('x1 = {0}\n'
      'x2 = {1}'.format(x1, x2))









    



x1 = (0.3333333333333333+4.068851871911234j)
x2 = (0.3333333333333333-4.068851871911234j)

Plano cartesiano o complejo



In [9]:

    
%pylab inline









    



Populating the interactive namespace from numpy and matplotlib



In [10]:

    
z1 = 2+7j
z2 = 6+8j
z3 = -4+2j



In [11]:

    
z1 + z2









    Out[11]:





(8+15j)



In [12]:

    
z1 + z3









    Out[12]:





(-2+9j)



In [13]:

    
z2 -z1









    Out[13]:





(4+1j)



In [14]:

    
z2 - z3









    Out[14]:





(10+6j)



In [15]:

    
z1 * z2









    Out[15]:





(-44+58j)

$z_1 · z_2 = (2+7i)(6+8i)$

$= 12 + 42i+16i+56i^2$

$=12 + 42i + 16i +56^{(-1)}$

$=12 + 42i + 16i -56$

$=-44+58i$



In [16]:

    
z1 = 7-3j
z2 = -5+8j
z3 = -4-6j
#z3=4-6j
z4 = 6+9j



In [17]:

    
z1 / z2









    Out[17]:





(-0.6629213483146067-0.4606741573033708j)

$\frac{z_1}{z_2} · \frac{\overline{z_2}}{\overline{z_2}} = \frac{7-3i}{-5+8i} · \frac{-5-8i}{-5-8i} = \frac{(7-3i)(-5-8i)}{(-5+8i)(-5+8i)}$

$ \frac{-35+15i-56i+24i^2}{25-64i^2} = \frac{-35+15i-56i-24}{25+64} = \frac{-59-41i}{89} = \frac{59}{89} - \frac{41}{89}i$

TAREA



In [18]:

    
z4+z2









    Out[18]:





(1+17j)



In [19]:

    
z3-z1









    Out[19]:





(-11-3j)



In [20]:

    
z3*z2









    Out[20]:





(68-2j)



In [21]:

    
z4/z3









    Out[21]:





(-1.5-0j)

Graficar números complejos

En este ejemplo graficaremos 100 numeros complejos aleatorios:



In [22]:

    
import random as r
import numpy as np


def complejos_aleatorios(inicio, fin, rango):
    n_reales      = np.array([r.randint(inicio, fin) for i in range(rango)])
    n_imaginarios = np.array([r.randint(inicio, fin) for i in range(rango)])
    n_complejos   = n_reales + 1j*n_imaginarios
    return n_complejos


complejos = complejos_aleatorios(-100, 100, 100)

scatter(complejos.real, complejos.imag)
#plot([1,2,3],[2,6,5])
title('Gráfica de números complejos\n')
xlabel('reales')
ylabel('imaginarios')









    Out[22]:





<matplotlib.text.Text at 0xb0f9160c>

Forma Trigonometrica o Polar

$z = rCos\theta + irSen\theta$

$r = \sqrt{a^2+b^2}$

$Sen\theta = \frac{co}{h} = \frac{b}{r}$

$Cos\theta = \frac{ca}{h} = \frac{a}{r}$

$Tan\theta = \frac{co}{ca} = \frac{b}{a}$

$a = rCos\theta$

$b = rSen\theta$

$\theta = \tan(\frac{b}{a})^{-1}$



In [23]:

    
import numpy
import math 
import cmath

z = 2+3j
a = z.real
b = z.imag



In [24]:

    
theta = math.degrees(math.atan(b/a))
theta









    Out[24]:





56.309932474020215

Expresar el siguiente número complejo binomico en su forma polar:

$Z = -3+4i$



In [25]:

    
Z1 = -3+4j



In [26]:

    
cmath.polar(Z1)









    Out[26]:





(5.0, 2.214297435588181)



In [27]:

    
help(cmath.polar)









    



Help on built-in function polar in module cmath:

polar(...)
    polar(z) -> r: float, phi: float
    
    Convert a complex from rectangular coordinates to polar coordinates. r is
    the distance from 0 and phi the phase angle.



In [28]:

    
numpy.conjugate(Z1)









    Out[28]:





(-3-4j)



In [29]:

    
Z1 = 3-2j
Z2 = -5-6j
Z3 = -4+2j

Z4 = ((Z1 - numpy.conjugate(Z2)) / Z2) * ((2  *Z1) / Z3)
Z4









    Out[29]:





(-0.49836065573770494-2.2819672131147541j)



In [30]:

    
from fractions import Fraction
from numpy import conjugate as c



In [31]:

    
limit = 1000
real = Fraction.from_float(Z4.real).limit_denominator(limit)
imag = Fraction.from_float(Z4.imag).limit_denominator(limit)
real, imag









    Out[31]:





(Fraction(-152, 305), Fraction(-696, 305))



In [32]:

    
print(' {0}     {1}\n'
      '------------ + -----\n'
      ' {2}     {3}\n'.format(real.numerator, imag.numerator,
                              real.denominator, imag.denominator))









    



 -152     -696
------------ + -----
 305     305



In [33]:

    
#!/usr/bin/env python3


__author__ = 'Ismael Venegas Castelló' + '\t' + 'ismael.vc1337@gmail.com'
__date__ = '04 / Abril / 2014'


from fractions import Fraction  as F
from textwrap  import dedent as dd


def calc(expresión:'cualquier número'=0, precisión:'int'=1000):
    '''
    Calculadora de expresiones con números complejos.

    expresión: expresión númerica válida.
    precisión: precisión de la simplificación.

    Uso:
    
    >>> from calc_comp import calc
    >>> from numpy import conjugate as c
    
    >>> z1 =  3-2j
    >>> z2 = -5-6j
    >>> z3 = -4+2j
    
    >>> exp = ((z1 - c(z2)) / z2) * ((2*z1) / z3)
    >>> calc(exp)
    (-0.49836065573770494-2.281967213114754j) =
         -152             -696
    ------------- + ------------- i
         305             305
    '''
    z = expresión
    frac_real = F.from_float(z.real).limit_denominator(precisión)
    frac_imag = F.from_float(z.imag).limit_denominator(precisión)
    print(dd('''\
             {0} =
                  {1}             {2}
             ------------- + ------------- i
                  {3}             {4}'''.format(expresión,
                                                frac_real.numerator,
                                                frac_imag.numerator,
                                                frac_real.denominator,
                                                frac_imag.denominator)))



In [34]:

    
exp = ((Z1 - c(Z2)) / Z2) * ((2 * Z1) / Z3)
calc(exp)









    



(-0.49836065573770494-2.281967213114754j) =
     -152             -696
------------- + ------------- i
     305             305



In [35]:

    
exp = (Z1 / c(Z1)) * ((Z2 - Z3) / c(Z3))
calc(exp)









    



(1.7692307692307694-0.34615384615384615j) =
     23             -9
------------- + ------------- i
     13             26



In [36]:

    
exp = ((Z3 + Z2) / Z1) * ((Z1 - Z3) / c(Z2))
calc(exp)









    



(0.5813366960907944+2.7591424968474145j) =
     461             2188
------------- + ------------- i
     793             793



In [37]:

    
exp = ((Z3 + Z2) / Z1) * ((Z1 - Z3) / c(Z2))
calc(exp)









    



(0.5813366960907944+2.7591424968474145j) =
     461             2188
------------- + ------------- i
     793             793



In [38]:

    
help(calc)









    



Help on function calc in module __main__:

calc(expresión:'cualquier número'=0, precisión:'int'=1000)
    Calculadora de expresiones con números complejos.
    
    expresión: expresión númerica válida.
    precisión: precisión de la simplificación.
    
    Uso:
    
    >>> from calc_comp import calc
    >>> from numpy import conjugate as c
    
    >>> z1 =  3-2j
    >>> z2 = -5-6j
    >>> z3 = -4+2j
    
    >>> exp = ((z1 - c(z2)) / z2) * ((2*z1) / z3)
    >>> calc(exp)
    (-0.49836065573770494-2.281967213114754j) =
         -152             -696
    ------------- + ------------- i
         305             305



In [39]:

    
calc(0)









    



0 =
     0             0
------------- + ------------- i
     1             1



In [40]:

    
calc(1)









    



1 =
     1             0
------------- + ------------- i
     1             1



In [41]:

    
calc(-145-231j)









    



(-145-231j) =
     -145             -231
------------- + ------------- i
     1             1



In [42]:

    
calc(numpy.complex128(7-33j))









    



(7-33j) =
     7             -33
------------- + ------------- i
     1             1