Introducci on a la Inform atica · 2019-10-23 · I la programaci on est a basada en la L ogica...

Introduccion a la InformaticaGrado en Fısica 2020-2021

October 8, 2020

profesores

Prof. Alberto RuizDepartamento de Informatica y Sistemashttp://dis.um.es/profesores/[email protected]

Prof. Javier BussonsDepartamento de Fı[email protected]

Prof. Juan [email protected]

Informatica - Grado en Fısica - UMU 2

http://dis.um.es/profesores/alberto

mailto:[email protected]



→ gravity simulator


https://hermann.is/gravity

→ circuit simulator


http://www.falstad.com/circuit/circuitjs.html

objetivo de la asignatura

I conocer herramientas informaticas imprescindibles para uncientıfico

I aprender a escribir programas sencillos


contenidos

1. introduccion

2. fundamentos de programacion

3. herramientas de calculo cientıfico

4. otros temas (graficos, edicion documentos cientıficos, etc.)


practicas

I ejercicios semanales

I cuaderno de la asignatura

I practicas en aula de ordenadores (Querequete, Fac. Quımica)

online, dependiendo de la evolucion de la pandemia

asistencia obligatoria


evaluacion

examen teorico-practico:

ejercicios parecidos a los que haremos en clase


bibliografıa

I basica: apuntes de los profesores

dis.um.es/profesores/alberto ← aula virtual

I complementaria: material de internet



horario

I teorıa: 13:00-14:00 lunes, miercoles y (algunos) jueves

I practicas: 15:00-17:00 lunes, miercoles o jueves segun elgrupo asignado.

→ calendario

El grupo 1 empieza esta tarde


https://www.um.es/documents/14152/18285349/GF1-C1-curso2020-21_14072020.pdf

grupos de practicas

Asignacion de alumnos: en los recursos del aula virtual.

I grupo 1: lunes

I grupo 2: miercoles

I grupo 3: jueves


contacto primera parte

Prof. Alberto Ruiz GarcıaDepartamento de Informatica y Sistemas

http://dis.um.es/profesores/[email protected]

Facultad de Informatica2a planta, despacho 2.09

tutorıas: email / aula virtual.




apuntes

Estan disponibles en la pagina web de la asignatura, accesibledesde el Contenido Web del aula virtual.

Hay dos “materiales’:

I esta presentacion

I un conjunto de “notebooks jupyter”

Son documentos interactivos que combinan texto, programas ylos resultados de los calculos.

Aprenderemos a usarlos en la clase de practicas.


http://dis.um.es/profesores/alberto/inforfis.html

conceptos fundamentales

En informatica hay dos tipos de conceptos:

I Conceptos fundamentales que hay que aprender de memoria.

I Convenios para expresar esos conceptos. Se buscan en google.


lenguajes de programacion

Hay muchısimos. . .

Nosotros usaremos Python y R,

y sus herramientas de calculo cientıfico.


http://www.rosettacode.org/wiki/Find_the_intersection_of_two_lines

https://www.python.org/

https://www.r-project.org/

https://www.scipy.org/

como se estudia esta asignatura

1. Atender en clase

2. Leer cuidadosamente los apuntes.

3. Reproducir los ejemplos de programacion y experimentarcambiando cosas para ver lo que ocurre.

4. Preguntar lo antes posible todas las dudas. No avanzar sinentender bien los conceptos esenciales que iremos estudiando.

5. Practicar, practicar, practicar: el papel se lo traga todo peroel ordenador no admite ningun error.


informatica

procesamiento automatico de informacion

programacion: redactar instrucciones para resolver un problema

computador: maquina que obedece instrucciones (“ejecuta”programas)


programacion

un lenguaje matematico ampliado

formulas normales junto con instrucciones para:

I tomar decisiones

I repetir calculos

I poner nombres

Escribiendo las formulas usando solo los sımbolos del teclado


toma de decisiones

f =

{1 +√x, si x ≥ 0

cos(2x), en caso contrario

if x>=0:

f = 1 + sqrt(x)

else:

f = cos(2*x)


repeticion

x0 = 3

xk+1 = 5xk − 2, para k = 1, 2, . . .

¿ x9 ?

x[0] = 3

for k in range (9):

x[k+1] = 5*x[k] - 2

3, 13, 63, 313, 1563, 7813, 39063, 195313, 976563, 4882813


Ecuacion de Kepler

En esta ecuacion no podemos despejar x

x− ε sin(x) = M

pero para unos datos concretos, p.ej.

M =π

2' 1.5708 ε = 0.2

podemos construir una secuencia de aproximaciones cada vez mejores

x0 = M

xk+1 = M + ε sin(xk), para k = 1, 2, . . .

x = 1.5708, 1.7708, 1.7668, 1.7670, 1.7670, . . .


computacion

computacion: formula matematica que incluye repeticiones ytoma de decisiones (= programa)

algoritmo: computacion que resuelve un determinado problema(= receta)

ejecucion: realizar fısicamente la computacion (a mano o conordenador)


Mr Shanks, an English “computer”. . .

(Traduccion de los Elementos de Euclides, 1885.)

se equivoco en el dıgito no 507

https://en.wikipedia.org/wiki/William_Shanks

relacion con otras ciencias

relacion con la Fısica:

I herramienta de computo

I soporte de la computacion

relacion con las Matematicas

I la Teorıa de la Computacion es una rama de lasmatematicas

I la programacion esta basada en la Logica


Breve historia

I -150 Mecanismo de Antikythera

I 1640s Maquina de Pascal

I 1800s Tarjetas perforadas

I 1830s Analytical Engine, telegrafo, fotografıa

I 1890s coche, tabulador Hollerith, telefono, electron

I 1910s avion, Torres Quevedo, Einstein

I 1920s radio, calculadoras electromecanicas

I 1930s Turing, TV


https://en.wikipedia.org/wiki/Antikythera_mechanism

Breve historia

I 1940s Von Neumann, Shannon, transistor, ENIAC, EDSAC

I 1950s Fortran, Lisp, IBM 704, circuito integrado, Sputnik

I 1960s Algol, Basic, mainframes, 74xx, Apollo

I 1970s microprocesador, calculadoras, email

I 1980s ordenadores domesticos

I 1990s WWW, deep blue, windows, linux, portatiles

I 2000s wikipedia, google maps, youtube, SSD

I 2010s tablets, smartphones, redes sociales, deep learning,alphaGo, rpi


ejemplos


ejemplos

Calcula la superficie de un polıgono irregular


ejemplos

Datos experimentales:

corriente - voltaje


ejemplos

Recta de regresion

la pendiente es un estimador de la resistencia


ejemplos

Calcula la media de los siguientes numeros:

224, 700, 592, 13, 576, 151, 866, 940, 172, 468, 537, 647, 199,383, 239, 123, 877, 965, 181, 881, 491, 650, 364, 319, 213, 404,448, 619, 421, 881, 421, 148, 246, 989, 158, 529, 776, 113, 669,694, 506, 907, 524, 480, 534, 13, 519, 277, 90, 847, 433, 834, 239,72, 444, 374, 121, 991, 754, 659, 148, 289, 265, 115, 88, 992, 987,239, 313, 389, 740, 721, 428, 862, 914, 52, 507, 185, 505, 597,306, 339, 635, 608, 101, 846, 216, 507, 935, 98, 840, 519, 236,401, 196, 510, 55, 510, 161, 383, 849, 182, 447, 999, 762, 323,712, 911, 284, 754, 806, 41, 69, 568, 135, 157, 23, 894, 708, 657,23, 697, 132, 437, 136, 364, 35, 414, 417, 528, 778, 109, 643, 254,389, 164, 456, 269, 357, 31, 154, 633, 997, 50, 761, 598, 491, 541,615, 764, 458, 509, 17, 324, 821, 936, 692, 742, 60


ejemplos

Calcula la mediana de los siguientes numeros:

224, 700, 592, 13, 576, 151, 866, 940, 172, 468, 537, 647, 199,383, 239, 123, 877, 965, 181, 881, 491, 650, 364, 319, 213, 404,448, 619, 421, 881, 421, 148, 246, 989, 158, 529, 776, 113, 669,694, 506, 907, 524, 480, 534, 13, 519, 277, 90, 847, 433, 834, 239,72, 444, 374, 121, 991, 754, 659, 148, 289, 265, 115, 88, 992, 987,239, 313, 389, 740, 721, 428, 862, 914, 52, 507, 185, 505, 597,306, 339, 635, 608, 101, 846, 216, 507, 935, 98, 840, 519, 236,401, 196, 510, 55, 510, 161, 383, 849, 182, 447, 999, 762, 323,712, 911, 284, 754, 806, 41, 69, 568, 135, 157, 23, 894, 708, 657,23, 697, 132, 437, 136, 364, 35, 414, 417, 528, 778, 109, 643, 254,389, 164, 456, 269, 357, 31, 154, 633, 997, 50, 761, 598, 491, 541,615, 764, 458, 509, 17, 324, 821, 936, 692, 742, 60


ejemplos

Calcula la probabilidad de obtener una suma mayor o igual que 10al lanzar 2 dados.


ejemplos

Calcula la probabilidad de que al lanzar 3 dados no se repitaninguna puntuacion.

→ enumeracion


Resuelve el siguiente sistema de ecuaciones:

x1 + x2 + x3 = 5

x1 − x2 + 2x3 = 1

5x1 + x2 − x3 = 17


En forma matricial: halla el vector x tal que:

Ax = b

donde A =

1 1 11 −1 25 1 −1

y b =

5117


Resuelve el sistema

−6 −19 −8 −1 8−14 −13 −20 −20 −7−17 8 18 −1 514 3 6 2 −11−20 −18 −16 3 −15

x =

−38−356135−32−268]


Resuelve un sistemaAx = b

donde A tiene dimension 1000× 1000 . . .

from numpy.linalg import solve

x = solve(A,b)


Simplifica la siguiente expresion:

(1 + x)(1− x2) + (x3 − x)


Simplifica

p(x)

q(x)

donde

p(x) =− x16 + 7x15 − 15x14 + 5x13 + 5x12 + 31x11−− 27x10 − 35x9 − 25x8 + 45x7 + 51x6 + 23x5−− 25x4 − 35x3 − 25x2 − 9x− 2

y

q(x) =− x15 + 5x14 − 5x13 − 5x12 − 5x11 + 21x10 + 15x9−− 5x8 − 35x7 − 25x6 + x5 + 25x4 + 25x3 + 15x2 + 5x+ 1


Expresa de forma irreducible:

77

143


Expresa de forma irreducible:

8 377 851 883

18 939 210 449


Calcula los factores primos de

1234567891011121314151617181920

from sympy.ntheory import factorint

factorint (1234567891011121314151617181920)

{2: 5, 3: 1, 5: 1, 323339: 1, 3347983: 1,

2375923237887317: 1}


∫e−xdx


∫xe−x

2dx


∫e−x

2dx


∫ 1

0e−x

2dx


Φ(t) =1√2π

∫ t

−∞e−

12x2dx

Φ(0.46) =


Φ(t) =1√2π

∫ t

−∞e−

12x2dx

Φ(0.46) =

from scipy.stats import norm

norm.cdf (0.46)

0.6772418897496523


Φ(t) =1√2π

∫ t

−∞e−x

2dx

Φ(0.46) = 0.5+

from scipy.integrate import quad

from numpy import sqrt , pi, exp

def gauss(t):

return 1/sqrt (2*pi)*exp (-0.5*t**2)

quad(gauss ,0 ,0.46)

(0.1772418897496523 , 1.967780269281375e-15)

↑ ↑resultado error de la aproximacion


elementos basicos de Python

un programa es

un conjunto de instrucciones que se evaluan sucesivamente

d = 2+2

print(’hola’)

c = 5*d + 7

print(c)

hola

27


computacion

una secuencia de operaciones matematicas ampliadas

con “construcciones” para

I poner nombres (a datos y a formulas)

I repetir operaciones

I seleccionar operaciones dependiendo de condiciones

I operar “a la vez” con conjuntos de numeros


elementos basicos de Python

Incluye siempre al principio:

import numpy as np

import matplotlib.pyplot as plt

%matplotlib inline

Para usar las operaciones matematicas y hacer graficas.


numeros

enteros, reales, complejos

17

3.5 4e7 -3.4e-6

2-3.2j

enteros exactos (dıgitos ilimitados)

reales aproximados, coma flotante (15 dıgitos)


calculadora

operaciones aritmeticas

+ - * / **

cociente y resto de la division entera

// %

funciones trigonometricas, exponenciales, etc.

np.sin(), np.cos(), np.tan(), np.log(), np.exp(), ...

np.arcsin (), np.arccos (), np.arctan2(y,x), ...

np.pi, np.radians (), np.degrees (), ...

comparaciones

< <= > >= == !=

and or not


precedencia

d =3x+ a

2b

d = 3x+a/2b MAL

d = 3*x+a/2*b MAL

d = (3*x+a)/2*b MAL

d = (3*x+a)/(2*b) OK

d = (3*x+a)/2/b OK


raız cuadrada

numeros reales:

I 2**0.5

I np.sqrt(2)

I np.sqrt(-2) → NaN

numeros complejos

I (-2)**0.5

I np.sqrt(-2+0j)


¡¡OJO!!

No confundir = con ==

a = 2

if a==2:

bla bla


¡cuidado!

3,5 → (3, 5)

(se interpreta como un par ordenado o “tupla”)

La coma sirve para separar numeros en una secuencia

Los decimales se indican con un punto:

3.5

cuando tengais tiempo buscad en wikipedia floating point arithmetic


secuencias

programar: crear y transformar secuencias

[5.2, -7.4, 100.32 , 0, 42 ]

np.arange (20)

np.linspace(a,b,n)

np.random.randn(n)

[ 3*k**2 - 1 for k in range (10) ]


linspace

np.linspace(1,5,9)

1 2 3 4 5

[ 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 ]


range

np.arange(7)

0 1 2 3 4 5 6

[0, 1, 2, 3, 4, 5, 6]


range

np.arange(2, 8, 0.4)

2 3 4 5 6 7 8

[2.0 2.4 2.8 3.2 3.6 4.0 4.4 4.8 5.2 5.6 6.0 6.4 6.8 7.2 7.6]


random

np.random.rand(20)

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19k

0.2

0.4

0.6

0.8

1.0

x k

[0.88731441 0.50000184 0.05722593 0.20895773 0.95041584 0.58817358

0.43823722 0.95436973 0.41268205 0.09126576 0.78811276 0.59018398

0.88699176 0.81361323 0.36222857 0.19685292 0.70095276 0.19702364

0.79414344 0.85533817]

np.random.randint(a,b,n)

np.random.randn(n)


random

Simulamos el lanzamiento de 10 dados:

np.random.randint (1,7,10)

array([5, 2, 3, 2, 3, 2, 4, 6, 6, 3])


random

Simulamos repetir 10 veces el lanzamiento de 5 dados:

np.random.randint (1,7,(10,5))

array([[4, 2, 6, 3, 5],

[2, 5, 4, 3, 6],

[1, 5, 1, 4, 2],

[4, 2, 2, 2, 1],

[2, 2, 4, 1, 2],

[1, 3, 4, 4, 6],

[2, 2, 6, 3, 4],

[6, 4, 1, 4, 1],

[1, 2, 4, 1, 1],

[4, 6, 3, 4, 3]])


operaciones con secuencias

elemento a elemento:

+ - * / ** // %

np.sqrt np.sin np.cos np.exp np.log abs

reduccion:

np.sum np.mean np.median np.std

np.max np.argmax

np.linalg.norm

trocear y combinar

(veremos todos los detalles mas adelante)


np.dot

@

“dot product” (producto escalar)

I producto escalar de vectores: u @ v → numero

I producto matriz - vector M @ v → vector

I producto de matrices A @ B → matriz

en general: contraccion de “tensores”


sumatorio

combinando lo anterior ya podemos calcular facilmente expresiones como:

22∑k=5

(2k3 − 5k2 + 3

)

k = np.arange (5 ,22+1)

[ 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22]

2*k**3 - 5*k**2 + 3

[ 128 255 444 707 1056 1503 2060 2739 3552 4511

5628 6915 8384 10047 11916 14003 16320 18879]

np.sum( 2*k**3 - 5*k**2 + 3 )

109047


cuidado

10∑k=1

(k2 + 1) 6=10∑k=1

k2 + 1


“ceros numericos”

sin 30o =1

2

np.sin( np.radians (30) )

0.49999999999999994

np.sin( np.radians (30) ) == 1/2

False

abs( np.sin( np.radians (30) ) - 1/2 ) < 1e-13

True


otra forma

[ 2*j**3 - 5*j**2 + 3 for j in range(5, 22+1) ]

[ 128 255 444 707 1056 1503 2060 2739 3552 4511

5628 6915 8384 10047 11916 14003 16320 18879 ]

[ k**2 for k in range (20) if k % 2 == 0 ]

[0, 4, 16, 36, 64, 100, 144, 196, 256, 324]

Esta construccion se llama list comprehension o bucle implıcito.


archivos

# local

np.loadtxt("ruta/datos.txt")

# remoto

np.loadtxt("http :// maquina.dominio/ruta/datos.txt")


graficas

plt.plot(x,y)


plot

x = np.linspace(0, 2*np.pi , 100)

y = np.sin(x) + 1/3*np.sin(3*x) + 1/5 *np.sin(5*x)

plt.plot(x,y)

0 1 2 3 4 5 61.00

0.75

0.50

0.25

0.00

0.25

0.50

0.75

1.00


plot

t = np.linspace(0, 2*np.pi , 100)

plt.plot(np.cos(t), np.sin(t))

1.00 0.75 0.50 0.25 0.00 0.25 0.50 0.75 1.001.00

0.75

0.50

0.25

0.00

0.25

0.50

0.75

1.00


histogram

x = np.random.rand (1000)

plt.hist(x);

0.0 0.2 0.4 0.6 0.8 1.00

20

40

60

80

100

120


histogram

x = np.random.randn (1000)

plt.hist(x, edgecolor=’black’);

3 2 1 0 1 2 30

50

100

150

200


poner nombres

dos tipos de definicion: constantes y funciones

=

peso = 5*3

def

def cua(x):

return x**2


variables

b = 2

r = 5*b + 3

print(r)

13


variables

b = 2

r = 5*b + 3

b = 0

print(r)

13

El sımbolo =

I da nombre a un “dato” (numero, secuencia, texto, etc.)

I el nombre se puede reutilizar (redefinir)

I guarda un dato en un espacio de almacenamiento

I “variable” significa constante que se puede cambiar


funciones

b = 2

def fun(z):

y = -z**2 + b

return y

print( fun )

ERROR!


funciones

b = 2

def fun(z):

y = -z**2 + b

return y

print( fun(3) )

-7


funciones

b = 2

def fun(z):

y = -z**2 + b

return y

b = 5

print( fun(3) )

-4

El sımbolo def

I da nombre a una formula (computacion)

I tiene argumentos

I se evalua cada vez con las definiciones mas recientes


Leed detenidamente:

I Tema 1 (Operaciones simples)

I Tema 4 (Funciones)

Para estudiar los notebooks es conveniente quitar los resultados

(menu Cell → All Output → Clear)

y evaluar sucesivamente las celdas intentando adivinar el resultado que va a

aparecer.

Los apartados marcados con asterisco * son mas avanzados y se pueden saltar

en una primera lectura


Calculemos con lapiz y papel

ln 5


lnx =

∫ x

1

dt

t

0 1 2 3 4 5 6 70.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

ln5 = 1.6094379


lnx =

∫ x

1

dt

t

0 1 2 3 4 5 6 70.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

ln5 1.683

aproximamos el area mediante un polıgono


lnx =

∫ x

1

dt

t

0 1 2 3 4 5 6 70.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

ln5 1.622

aproximamos el area mediante un polıgono


trapecios


integracion

La informatica nace para automatizar la integracion numerica.

→ integrador mecanico

→ ball and disk

→ video

→ differential analyser


https://vimeo.com/70589461

https://www.jstor.org/stable/pdf/113220.pdf

https://www.youtube.com/watch?v=GZI-PydfsQs

https://en.wikipedia.org/wiki/Differential_analyser

ejercicio

Con lo aprendido hasta ahora ya podemos automatizar el calculoaproximado de integrales definidas como

ln(5) =

∫ 5

1

1

xdx

Φ(t) =1√2π

∫ t

0e−x

2dx, Φ(0.46) = ??

Dividiremos el area bajo la curva en varios trozos simples, rectangulares otriangulares.

Lo haremos primero con la funcion 1/x. Cuando funcione bien podemos

cambiar como deseemos la funcion y los extremos de integracion.


primera idea

def f(x):

return 1/x

x = np.linspace (1,5,7)

d = x[1]-x[0]

r = sum( f(x) ) * d

0 1 2 3 4 5 6 70.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

ln5 2.044


segunda idea

n=5; a=1; b=5

d = (b-a)/(n-1)

x = np.arange(a,b,d)

r = sum( f(x) + f(x+d) )/2 * d

0 1 2 3 4 5 6 70.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

ln5 1.683


Excepto en los extremos, cada valor de f(xk) se cuenta dos veces.Se puede simplificar.

Si yk = f(xk), el area de cada tramo es (yk + yk+1)d/2. La sumade todos es

((y0 + y1) + (y1 + y2) + (y2 + y3) + . . .+ (yn−2 + yn−1))d

2=

= (1y0 + 2y1 + 2y2 + 2y3 + . . .+ 2yn−2 + 1yn−1)d

2


mejor


d = x[1]-x[0]

y = f(x)

w = [1,2,2,2,1]

r = sum( y * w )/2 * d

0 1 2 3 4 5 6 70.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

ln5 1.683


con el producto escalar


d = x[1]-x[0]

y = f(x) * d/2

w = [1,2,2,2,1]

r = y @ w

equivalente a la anterior

0 1 2 3 4 5 6 70.0

0.2

0.4

0.6

0.8

1.0

1.2

1.4

ln5 1.683


en general

n = 10

x = np.linspace (1,5,n)

d = x[1]-x[0]

w = np.zeros(n)

w[0:n] = 2

w[0] = 1; w[n-1] = 1

y = f(x) * d/2

r = y @ w

1.6249415218949677

Hay diferentes formas de construir los coeficientes w = [1,2,2,...,2,1].

Las explicaremos en clase.


quad

∫ 1

0x2 dx

from scipy.integrate import quad

def f(x):

return x**2

quad(f,0,1)

(0.33333333333333337 , 3.700743415417189e-15)

↑ ↑resultado error de la aproximacion


secuencias

cerrada: x[k] solo depende de k

Puedo calcular directamente cualquier elemento, p.ej.x[7154], sin calcular los anteriores

podemos calcular facilmente muchos elementos “a la vez” ya que las

operaciones matematicas actuan automaticamente sobre secuencias. Lo

hemos hecho en el ejemplo del sumatorio y de la integral.

recursiva: x[k] depende de x[k-1], x[k-2], . . .

Hay que calcular antes todos los anteriores

Necesitamos programar la “iteracion” con instrucciones de repeticion.


A continuacion vamos a practicar con las construcciones derepeticion for, break, y while.

Tambien practicaremos la definicion de funciones con def.

Para ello vamos a resolver de varias formas el problema deencontrar una solucion aproximada de una ecuacion cualquieraf(x) = 0 en la que no se puede despejar x, y por tanto tenemosque recurrir a un metodo de aproximaciones sucesivas.

Es un problema tıpico en el que cada elemento depende de losanteriores, y por tanto hay que programar expresamente laiteracion.


Newton’s method

Buscamos la solucion x∗ (root) de una ecuacion:

f(x) = 0

−2 −1 0 1 2 3 4 5−100

0

100

200

300

400

y = f (x)

f (x∗) = 0

x∗


Newton’s method

Aproximacion inicial (semilla) x0:

f(x0) 6= 0

−2 −1 0 1 2 3 4 5−100

0

100

200

300

400

y = f (x)

x0


Newton’s method

Resolvemos una aproximacion lineal a la ecuacion:

f(x) ' f ′(x0)x+ b

−2 −1 0 1 2 3 4 5−100

0

100

200

300

400

y = f (x)

x0x1


Newton’s method

Aproximaciones sucesivas:

xk+1 = xk −f(xk)

f ′(xk)

−2 −1 0 1 2 3 4 5−100

0

100

200

300

400

y = f (x)


Newton’s method

Ejemplo: resuelve la ecuacion 2x3 + 20x = 10.

f(x) = 2x3 + 20x− 10

f ′(x) = 6x2 + 20

xk+1 = xk −2x3k + 20xk − 10

6x2k + 20


Newton’s method

Codigo:

def f(x):

y = 2*x**3 + 20 *x - 10

return y

def fp(x):

return 6*x**2 + 20

x = np.zeros (10)

x[0] = 4

for k in range (9):

x[k+1] = x[k] - f(x[k]) / fp(x[k])

print(x)

[4. 2.29310345 1.12961369 0.57005995 0.4893439 0.48835345

0.48835331 0.48835331 0.48835331 0.48835331]


En 6 pasos la secuencia se estabiliza: a partir de ahı lasaproximaciones se repiten.

Comprueba que f(x[6]) es (aproximadamente) cero. Hemosencontrado una solucion de la ecuacion.

Intenta encontrar mas soluciones cambiando la semilla.

Esta ecuacion tiene solo una solucion real. ¿Podemos encontrar lascomplejas mediante este metodo?


ecuacion de Kepler

Resuelve con el metodo de Newton

M = x− ε sin(x) para M = 3π/4, ε = 0.8

Solucion: con x0 = M las aproximaciones son

[2.356194490192345,

2.71749658570593,

2.6989297690080485,

2.698896384568338,

2.6988963844574974,

2.6988963844574974,

2.6988963844574974,

...]

¡compruebalo!


ecuacion de Kepler

Para estos valores de M = 3π/4 y ε = 0.8 el metodo simple de latransparencia 21 converge muy despacio:

x0 = M

xk+1 = M + ε sin(xk)

[ 2.356194490192345, 2.921879915141583, 2.530553911204325,

2.815169333413777, 2.612720308085192, 2.759842547568407,

2.6542306198829424, 2.7308318414083494, 2.6756400655894796,

2.715613723440277, 2.686764432048095, 2.707640894534943,

2.692562131556909, 2.7034683831622406, 2.6955878080375086,

2.701286207905195, 2.697167852036122, 2.70014539328672,

2.6979932339498625, 2.699549113988344 . . .


metodo de Newton

para calcular facilmente la raız cuadrada de un numero dado n.

x2 = n

0 = f(x) = x2 − n

f ′(x) = 2x

xk+1 = xk −f(xk)

f ′(xk)= xk −

x2k − n2xk

=x2k − n

2xk=

1

2

(xk +

n

xk

)

→ algoritmo babilonico


https://en.wikipedia.org/wiki/Methods_of_computing_square_roots

√7

xk+1 =1

2

(xk +

7

xk

)X = np.zeros (10)

X[0] = 1

n = 7

for k in range (9):

X[k+1] = ( X[k] + n/X[k] )/2

print(X)

[1. 4. 2.875 2.6548913 2.64576704 2.64575131

2.64575131 2.64575131 2.64575131 2.64575131]


√7

Lo mismo pero sin almacenar los pasos intermedios:

x← 1

2

(x+

7

x

)x = 1

n = 7

for k in range (9):

x = ( x + n/x )/2

print(x, x**2)

2.6457513110645907 7.000000000000001

Ahora x es una variable simple (no una secuencia) y redefinimos su valor en

cada paso.


√7

Si metemos el print dentro del bucle observamos los valores sucesivos en la

pantalla, pero no se guardan.

x = 1

n = 7

for k in range (9):

x = (x+n/x)/2

print(x, x**2)

4.0 16.0

2.875 8.265625

2.654891304347826 7.048447837901702

2.64576704419029 7.0000832521234235

2.6457513111113693 7.00000000024753

2.6457513110645907 7.000000000000001

2.6457513110645907 7.000000000000001

2.6457513110645907 7.000000000000001

2.6457513110645907 7.000000000000001


En los ejemplos anteriores estamos refinando la solucion unnumero fijo de veces.

Normalmente no sabemos cuantos pasos son necesarios.

Es mejor terminar el proceso cuando la aproximacion seasuficientemente buena. Hay dos formas: while y break.


while

Primera idea: detener la iteracion cuando f(x) = 0

(o sea, cuando se cumpla la ecuacion, en este caso x2 = n)

x← 1

2

(x+

n

x

)x = 1

n = 7

while x**2 != n:

x = ( x + n/x )/2

print(x)

¡¡¡El ordenador se ”cuelga”!!! (bucle infinito)

7 != 7.000000000000001

menu kernel → interruptInformatica - Grado en Fısica - UMU 109

OJO: si ponemos una condicion estricta como

while not( x**2 == n):

el ordenador se quedara “cogado” en un bucle infinito.

7 6= 7.000000000000001


while

Detenemos la iteracion cuando la ecuacion se cumpla bastantebien: f(xk) ' 0, o sea, |f(xk)| < ε

x← 1

2

(x+

7

x

)x = 1

n = 7

while abs( x**2 - n ) > 1E-6:

x = ( x + n/x )/2

print(x)

2.6457513111113693


break

x = 1

n = 7

for k in range (100):

x = ( x + n/x )/2

print(x)

if abs( x**2 - n ) < 1E-6:

break

4.0

2.875

2.654891304347826

2.64576704419029

2.6457513111113693


while pone las condiciones de continuacion al principio del bucle.Si no se cumplen nunca el proceso se quedara en un bucle infinito.

break es mas flexible: puedes poner varias condiciones determinacion a lo largo del cuerpo del bucle. Y ademas, garantizaun numero maximo de repeticiones.


Las siguientes transparencias son una breve introduccion a temasavanzados que estudiaremos mas adelante. Podemos saltarlas enuna primera lectura.


derivacion numerica

Para aplicar el metodo de Newton hay que calcular y programar laderivada manualmente.

Alternativa: usar una diferencia finita:

f ′(x) ' f(x+ h)− f(x)

hh = “pequeno”

En la ecuacion anterior 2x3 + 20x = 10, con h = 0.1 se obtiene:

[4., 2.32798514, 1.18227111, 0.60009897, 0.49210829,

0.4884096, 0.48835412, 0.48835332, 0.48835331. 0.48835331]

¡compruebalo!


derivacion numerica

Es mejor usar una biblioteca de funciones que proporciona unaaproximacion muy precisa a la derivada:

import numdifftools as nd

def f(x):

y = 2*x**3 + 20 *x - 10

return y

df = nd.Derivative(f)

x = np.zeros (10)

x[0] = 4

for k in range (9):

x[k+1] = x[k] - f(x[k]) / df(x[k])

[4., 2.29310345, 1.12961369, 0.57005995, 0.4893439,

0.48835345, 0.48835331, 0.48835331, 0.48835331, 0.48835331]


instalacion de paquetes

En una celda del jupyter notebook:

!pip install numdifftools

Collecting numdifftools

Downloading https :// files.pythonhosted.org/etc...

100%

Installing collected packages: numdifftools

Successfully installed numdifftools -0.9.39


calculo simbolico

Tambien es posible manipular sintacticamente formulas matematicas, sin dar

valores numericos concretos a las variables.

import sympy as s

x = s.symbols(’x’)

s.diff( 3*x**5 - s.sin(2*x) , x)

15*x**4 - 2*cos (2*x)

x,e,M = s.symbols(’x e M’)

kepler = x - e*s.sin(x) - M

s.diff( kepler , x)

-e*cos(x) + 1


condiciones logicas

expresiones que se evaluan a True o False y se se construyencombinando los operadores:

< <= > >= == != in

not and or

1 > 2

n%2 == 0

x > 0 and x**2 <= 100

( x in [10 ,20 ,30] or not (z != y) ) and c == []


condiciones logicas

Se usan en las construcciones if y while.

def fun(x):

if x > 0 and x**2 < 100:

return x

else:

return -3*x

r = 5 * (b if b >= 0 else -b) + 3

n = 17

while n != 1:

print(n)

n = n//2 if n%2==0 else 3*n+1


estructura de bloques

def fun(x,y):

z = x+y

for k in range(10):

print(k)

if k>z:

print('bien')

m = 2

else:

m = 3

return z**m


estructura de bloques

def fun(x,y):

z = x+y

for k in range(10):

print(k)

if k>z:

print('bien')

m = 2

else:

m = 3

return z**m

4

4

4


Graficas

Cada grafica permite especificar:

I una o varias curvas superpuestas, cada una con su estilo(color, grosor, etc.)

I leyenda

I seleccion del intervalo en cada eje, ticks, grid

I tıtulo, nombre de los ejes, anotaciones de texto

I dimensiones de la figura, subplots.

plt.savefig(’nombre.pdf’)


0 1 2 3 4 5 6x

1.00

0.75

0.50

0.25

0.00

0.25

0.50

0.75

1.00y hola

bonito plot

sin(x)sin(2x)cos(x)


Introducci on a la Inform atica · 2019-10-23 · I la programaci on est a basada en la L ogica...

Documents

Transcript of Introducci on a la Inform atica · 2019-10-23 · I la programaci on est a basada en la L ogica...