2 de mar. de 2015

Geometría Analítica con Sympy (circulos)

A continuación se tiene los artículos sobre sympy tratados anteriorente:


En este artículo se explicará las instrucciones de geometría analítica para el caso del circulo.

A continuación el código del script:
#!/usr/bin/env python
from sympy.geometry import *; #Se importa geometry de sympy
#SE crean los puntos P1,P2,P3 y P4
P1 = Point(0, 0)
P2 = Point(3, 4)
P3 = Point(2, -1)
P4 = Point(-1, 5)
L1 = Line(P1, P2); #linea 1 a partir de los puntos 1 y 2
L2 = L1.perpendicular_line(P3);#linea 2 perpendicular a la linea 1 y contenga al punto 3.
C1 = Circle(P1, 3);#se crea un circulo con centro en P1 y radio 3.
C2 = Circle(P2, P3, P4); #Se crea un circulo que contenta los puntos P1,P2 y P3
print (C2.area); #Area del circulo 2
print (C1.area);#Area del circulo 1
print (C2.radius); #Radio del circulo 2
print (C2.equation());#Ecuacion del circulo 2
print (C2.center);#Centro del circulo 2
print (C2.circumference);#Circunferencia del circulo 2
print (C2.intersection(C1)); #Intercepcion entre el circulo 2 y circulo 1
S1 = Segment(P1, P2);#segmento 1 a partir de los puntos 1 y 2
print (C2.intersection(S1));#Intercepcion entre el circulo 2 y el segmento 1
print (C2.is_tangent(L2));#La recta 2 es tangente al circulo 2?
print (C1.tangent_lines(P4)); #Cuales son las rectas tangentes  al circulo 1 con el punto 4



El resultado de la ejecución del script es el siguiente: 
1105*pi/98
9*pi
sqrt(2210)/14
(x - 5/14)**2 + (y - 27/14)**2 - 1105/98
Point(5/14, 27/14)
sqrt(2210)*pi/7
[Point(55/754 + 27*sqrt(6665)/754, -5*sqrt(6665)/754 + 297/754), Point(-27*sqrt(6665)/754 + 55/754, 297/754 + 5*sqrt(6665)/754)]
[Point(3, 4)]
False
[Line(Point(-1, 5), Point(-9/26 + 15*sqrt(17)/26, 3*sqrt(17)/26 + 45/26)), Line(Point(-1, 5), Point(-15*sqrt(17)/26 - 9/26, -3*sqrt(17)/26 + 45/26))]


A continuación se muestra una imagen del proceso de ejecución de ipython notebook:







23 de feb. de 2015

Geometría Analítica con Sympy (rectas)

Continuando con el manejo de geometría analítica de Sympy ahora se explicará el manejo de rectas.

Un resumen de los artículos anteriores: 

En el siguiente enlace encontrarán el archivo notebook del código que se explicará a continuación.

A continuación se muestra el código del script de manejo de rectas.

#!/usr/bin/env python

from sympy.geometry import *



#Creacion de 4 puntos

P1 = Point(0, 0)

P2 = Point(3, 4)

P3 = Point(2, -1)

P4 = Point(-1, 5)



#Creacion de 2 segmentos

S1 = Segment(P1, P2);#segmento 1 a partir de los puntos 1 y 2

S2 = Segment(P3, P4);#Segmento 2 a partir de los puntos 3 y 4



#Se crea 2 rectas

#A partir de los puntos 1 y 2

L1 = Line(P1, P2)

#Se crea la recta 2 que ser perpendicular a la recta 1 y contenga al punto 3

L2 = L1.perpendicular_line(P3)





#Manejo de rectas



print L2.arbitrary_point();#Punto arbitrario de la recta 2 (ecuacion parametrica)

print L2.equation() ;#ecuacion de la recta 2

print L2.contains(P4);#Linea 2 contiene al punto 4?

print L2.distance(P4);#distancia del punto 4 a la recta 2?

print L1.is_parallel(S2);#La recta 1 es paralela al segmento 2?

A continuación el resultado de la ejecución del script:

Point(4*t + 2, -3*t - 1)

3*x + 4*y - 2

False

3

False


A continuación se muestra una imagen de la ejecución del notebook para este artículo:

21 de feb. de 2015

Geometría Analítica con Sympy (Segmentos)

En los artículos anteriores se trataron los temas de como resolver límites, derivadasintegrales y resolución de sistemas de ecuaciones lineales, ahora se explicará el uso de Sympy en geometría analítica.

Los artículos sobre geometría analítica se basan en un artículo en inglés Computational Geomtry in Python.

En este artículo se explicará el manejo de segmentos.

Se inicia ipython notebook (si desea usar el archivo de este artículo lo puede descargar desde el siguiente enlace).


A continuación se muestra el código del script:

#!/usr/bin/env python



from sympy.geometry import *



#Definicion de puntos

P1 = Point(0, 0)

P2 = Point(3, 4)

P3 = Point(2, -1)

P4 = Point(-1, 5)



#Definicion de segmentos

S1 = Segment(P1, P2)

S2 = Segment(P3, P4)



print Point.is_collinear(P1, P2, P3); #Los puntos son colineales?



print S1.length ; #longitud del segmento 1



print S2.midpoint ;#punto medio del segmento 2



print S1.slope; #Slope del segmento 1



print S1.intersection(S2) ; #Intercepcion entre el Segmento 1 y 2



print Segment.angle_between(S1, S2);#Angulo entre el segmento 1 y 2



print S1.contains(P3);#El segmento  1 contiene a P3?



El resultado de ejecutar el script se muestra a continuación:
False

5

Point(1/2, 2)

4/3

[Point(9/10, 6/5)]

acos(-sqrt(5)/5)

False

La siguiente imagen muestra la ejecución del notebook:


Resolución de sistemas de ecuaciones con Sympy

Hasta ahora se tienen los siguientes artículos sobre el uso de la librería Sympy:
En este caso se explicará el uso de la librería Sympy en la resolución de sistemas de ecuaciones, se utilizará el ejemplo de un artículo anterior (Resolución de sistemas de ecuaciones lineales por descomposición QR usando Numpy).

Se inicia ipython notebook (si desean usar el archivo lo pueden bajar del siguiente enlace): 

A continuación se muestra el código del script:

#!/usr/bin/env python
#Se importa sympy
from sympy import *
#Se define las variables simbolicas x,y,z
x = Symbol('x')
y = Symbol('y')
z= Symbol('z')
#Resolver el sistema de ecuaciones
#3x+9y-10z  =   24
#x-6y+4z      =   -4
#10x-2y+8z  =  20
resultado =solve([3*x+9*y-10*z-24,x-6*y+4*z+4,10*x-2*y+8*z-20],[x,y,z])
print resultado


Al ejecutar el script se obtiene lo siguiente:
{x: 308/103, z: -117/103, y: 42/103}

Se nota que el resultado obtenido es el mismo del artículo ya mencionado.


La imagen de la utilización de notebook se muestra a continuación:

Cálculo de Integrales con Sympy

Contiuando con los artículos sobre la librería Sympy, en los artículos anteriores se toco lo siguiente:




En este artículo se tocará el tema de cálculo de Integrales.

A continuación se ejecuta ipython notebook (si desea cargar el archivo del notebook de este artículo lo puede bajar del siguiente enlace).

El script del tutorial de muestra a continuación:

# coding: utf-8



# In[16]:



#Se importa sympy

from sympy import *

x = Symbol('x')





# In[26]:



diff(5*(x**5)+3*(x**3)-6*x+5,x); #Se calcula la derivada de la funcion 5(x^5)+3(x^3)-6x+5





# In[27]:



integrate(Out[3],x);#Se integra el resultado de la derivada,noten q el resultado es la ecuación de In[3] pero sin el valor constante





# In[19]:



integrate(cos(x)**2+sin(x),x); #Se inte cos(x)**2+sin(x) con respecto a x





# In[20]:



pprint (Integral(cos(x)**2+sin(x),x));#Se muestra la integral de la ecuación anterior





# In[28]:



integrate(Out[27],(x,0,5));#Se calcula el valor de la integral de 0 a 5 de la ecuación de la salida 27 





# In[29]:



integrate(cos(x)**2+sin(x),(x,0,pi));#Se calcula la integral con el rango de 0 a pi





El res

La imagen de la ejecución del notebook se muestra a continuación:

Para una mejor visualización del ejercicio recomiendo ejecutar el notebook del enlace anterior.

Cálculo de derivadas con sympy

En el artículo anterior se explico como calcular límites de funciones, en este artículo se muestra como calcular la derivada.


Se inicia notebook (si desea abrir el archivo que se utilizo para este artículo lo puede encontrar en el siguiente enlace):

$ipython notebook

Puede crear un notebook (o abrir el notebook mencionado en el enlace anterior).

A continuación se muestra el script del calculo de derivadas de 3 funciones diferentes:

#!/usr/bin/env python

# coding: utf-8





#Se importa sympy

from sympy import *





x = Symbol('x')





#Se calcula la derivada de la funcion cos(sin(x^3)) con respecto a x

print diff(cos(sin(x**3)),x)





#Se calcula la derivada de la funcion 5(x^5)+3(x^3)-6x+5

print diff(5*(x**5)+3*(x**3)-6*x+5,x)





#Calcula la derivada ene-sima de x^2+8x-4+sin(2x)

print diff(x**2+8*x-4+sin(2*x),x,2)


Al ejecutar el script se muestra el resultado de la ejecución de los 3 instrucciones print:
-3*x**2*sin(sin(x**3))*cos(x**3)
25*x**4 + 9*x**2 - 6
2*(-2*sin(2*x) + 1)
x,2)

Al ejecutar el script se muestra el resultado de la ejecución de los 3 instrucciones print:
-3*x**2*sin(sin(x**3))*cos(x**3)
25*x**4 + 9*x**2 - 6
2*(-2*sin(2*x) + 1)


A continuación se muestra una imagen del notebook resultante:



A continuación se muestra una imagen del notebook resultante:

Cálculo de límites con la librería sympy

La librería Sympy permite realizar cálculo de límites, derivadas,  integrales entre otras cosas, usando notación simbólica.

La documentación de sympy la pueden revisar en el siguiente enlace.

Para instalar sympy e ipython-notebook en Debian se ejecuta:
apt-get install python-sympy ipython-notebook

En este caso se mostrará como realizar cálculo de límites con sympy.

Se ejecuta un servidor notebook ( en el siguiente enlace encontrarán el archivo usado para este artículo).

$ipython notebook

Se abre el navegador en http://localhost:8888 y se crea un notebook (para los que bajaron el enlace abren el archivo que se menciono anteriormente):

En este caso se usará un script que se llama limites.py:

#!/usr/bin/env python

# coding: utf-8





from sympy import *







#Se define la variable x como simbolica

x = Symbol("x")







#Calculo de limite de (1/x) cuando x tiende a cero

valor = limit(1/x,x,0)

print valor





#Calculo de limite de (1/x) cuando x tiende a infinito

valor = limit(1/x,x,oo)

print valor





#limite de (5x/2x-3) cuando x tiende a infinito.

valor = limit(5*x/(2*x-3),x,oo)

print valor


El resultado de ejecutarlo es el siguiente:

oo
0
5/2
Para el primer caso el resultado es infinito, para el segundo es cero y para el último es 2.5.

A continuación se deja una imagen del uso de ipython notebook:



3 de feb. de 2015

#MéridaTechMeetup

El día de hoy se realizó el la Facultad de Ingeniería de la ULA el 1er #MéridaTechMeetup.

Realice un par de presentaciones:

  • Desarrollo de aplicaciones multiplataforma con Python y Kivy.
  • Extracción de datos de páginas web con Python (webscraping).



A continuación las presentaciones desde slideshare:



Desarrollo de aplicaciones multiplataforma con python y Kivy from Ernesto Crespo


Gracias por la invitación a los organizadores del evento.

11 de ene. de 2015

Descubrir equipos en una red con ipcalc y python-nmap

En un artículo anterior se explico como descubrir equipos en una red usando ipcalc y scapy, ahora se explicará usando python-nmap.


El script pasa la red y mascara de la red que se va a analizar, se define unos puertos de los cuales se quiere saber si están abiertos y se usa la librería nmap con unos argumentos para detectar los host de la red.

A continuación el código del script:

#!/usr/bin/env python2.7
#se importa python-nmap
import nmap
#De ipcalc se importa IP y Network
from ipcalc import IP, Network
#Se crea la instancia de nmap para escanear puertos
escanear = nmap.PortScanner()
#Se define una tupla con los puertos
puertos = ("21","22","25","53","80")
#Se define los argumentos que nmap va a utilizar
argumentos = "-sS -sV -O"
#Se crea la función escaneo donde se le pasa los host y puertos.
def Escaneo(host,puertos):
    #Se hace un recorrido por puerto 
    for puerto in puertos:
        try:
            #Se verifica que el puerto esté abierto en el host
            #Si lo está se muestra, si no se continua con el siguiente puerto.
            escanear.scan(host,puerto,argumentos)
            if escanear[host]['tcp'][int(puerto)]['state'] == "open":
                print("Host: %s ,Puerto: %s, abierto" %(host,puerto))
        except KeyError:
            pass
if __name__ == "__main__":
    import sys
    try:
        #Escaneo(hosts,puertos)
       #Se recorre los host de la red, y se llama a la función escaneo que evalua que puertos están abiertos
       #en cada host.
        for x in Network('192.168.52.0/24'):
            host =str(x)
            Escaneo(host,puertos)
    except KeyboardInterrupt:
        sys.exit()

El resultado de ejecutar el script es el siguiente:

Host: 192.168.52.2 ,Puerto: 22, abierto
Host: 192.168.52.2 ,Puerto: 53, abierto
Host: 192.168.52.9 ,Puerto: 22, abierto
Host: 192.168.52.9 ,Puerto: 53, abierto
Host: 192.168.52.17 ,Puerto: 22, abierto
Host: 192.168.52.17 ,Puerto: 53, abierto
Host: 192.168.52.33 ,Puerto: 22, abierto
Host: 192.168.52.33 ,Puerto: 53, abierto
Host: 192.168.52.65 ,Puerto: 22, abierto
Host: 192.168.52.65 ,Puerto: 53, abierto
...


Generación de un histograma de frecuencia con numpy, Scipy y Matplotlib

En el artículo de creación de grafos se muestra como generar un histograma, ahora se mostrará un histograma con datos generados.

Se generarán datos de manera aleatoria, y con ella se generará el histograma con la función scipy.stats.histogram, luego se gráfica el histograma.

A continuación el código del programa:


#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#Se importa numpy como np
import numpy as np
import matplotlib.pyplot as plt
import scipy.stats as st
#Se importa pylab
from pylab import *
#Generación de números aleatorios menores que 1000
x = np.random.randn(1000)
#Generación de los datos del histograma con scipy.stats.
n, low_range, binsize, extrapoints = st.histogram(x)
#define el rango superior
upper_range = low_range+binsize*(len(n)-1)
#Se calcula los intervalos discretos
bins = np.linspace(low_range, upper_range, len(n))
#Generación del gráfico de barras
bar(bins, n, width=0.3, color='blue')
#Etiquetas de los ejes X y Y.
xlabel('X', fontsize=15)
ylabel('número de datos discretos', fontsize=15)
#Se muestra la gráfica.
show()
A continuación se muestra la gráfica:

AddThis