UNIVERSIDAD DE BUENOS AIRES

FACULTAD DE INGENIERÍA
DEPARTAMENTO DE COMPUTACIÓN

ASIGNATURA: ANÁLISIS NUMÉRICO I CÓDIGOS: 75.12, 95.04, 95.13

AÑO: 2015 1º CUATRIMESTRE

PROFESORA: LIC. MIRYAM SASSANO

INTEGRANTES:

Cavanagh, Juan Tomás PADRÓN Nº     

Ducos, Matías PADRÓN Nº     
Mendia, Franco PADRÓN Nº     
 PADRÓN Nº     

TRABAJO PRÁCTICO Nº 1

TÍTULO: MÉTODO DE NEWTON-RAPHSON

FECHA DE PRESENTACIÓN: 13/05/2015

OBSERVACIONES FECHA
 

 

NOTA:

FIRMA DEL DOCENTE:

Introducción
El siguiente trabajo práctico consistió en obtener el mínimo momento de inercia de la
suma de un cuadrado y un círculo. Estos se formaron a partir de un alambre de 100 cm. de
longitud el cual se cortó en dos partes y se utilizaron ambas secciones para formar las
correspondientes figuras. De este modo la pregunta que buscamos resolver es ¿Cómo
debe ser cortado el alambre para que la suma de los momentos de inercia sea mínima?

Para llegar a una respuesta fue necesario utilizar el algoritmo de Newton-Raphson de

obtención de raíces.
Este método consiste en tomar una aproximación inicial, 𝑝0 , y a continuación obtener una
aproximación más refinada intentando acercarnos a la raíz por medio de la fórmula
recursiva

𝑓(𝑝𝑛−1 )
𝑝𝑛 = 𝑝𝑛−1 −
𝑓´(𝑝𝑛−1 )

La interpretación geométrica del método consiste en que la ecuación de la recta tangente

que pasa por el punto (𝑝𝑛 ; 𝑓(𝑝𝑛 )), viene dada por

𝑦 − 𝑓(𝑝𝑛 ) = 𝑓 ´ (𝑝𝑛 )(𝑥 − 𝑝𝑛 )

Si hacemos 𝑦 = 0 , 𝑥 = 𝑝𝑛+1 obtenemos la expresión anterior

𝑓(𝑝𝑛−1 )
𝑝𝑛 = 𝑝𝑛−1 −
𝑓´(𝑝𝑛−1 )

Importante:

 Se debe tomar siempre como 𝑝0 un valor tal que 𝑓(𝑝0 ) . 𝑓´´(𝑝0 ) > 0.
 El método converge siempre que tomemos un 𝑝0 lo bastante cercano al valor de la
raíz.

La principal ventaja del método mencionado, es que converge cuadráticamente siempre y cuando
la raíz que se busca sea una raíz simple de la función analizada.

-1-
Desarrollo
Teniendo en cuenta que los momentos de inercia de la circunferencia y el cuadrado son
respectivamente:

𝜋𝑟 4
𝐽𝑐𝑖𝑟𝑐 = (1) 𝑟 = 𝑟𝑎𝑑𝑖𝑜 𝑑𝑒 𝑙𝑎 𝑐𝑖𝑟𝑐𝑢𝑛𝑓𝑒𝑟𝑒𝑛𝑐𝑖𝑎
4
𝑙4
𝐽𝑐𝑢𝑎𝑑 = (2) 𝑙 = 𝑙 𝑒𝑠 𝑒𝑙 𝑙𝑎𝑑𝑜 𝑑𝑒𝑙 𝑐𝑢𝑎𝑑𝑟𝑎𝑑𝑜
12
Y si llamamos:

𝑎 = 𝑙𝑜𝑛𝑔𝑖𝑡𝑢𝑑 𝑔𝑒𝑛é𝑟𝑖𝑐𝑎 𝑑𝑒𝑙 𝑎𝑙𝑎𝑚𝑏𝑟𝑒

𝑡 = 𝑙𝑜𝑛𝑔𝑖𝑡𝑢𝑑 𝑑𝑒 𝑐𝑜𝑟𝑡𝑒 𝑑𝑒𝑙 𝑎𝑙𝑎𝑚𝑏𝑟𝑒
(𝑎 − 𝑡) = 𝑙𝑜𝑛𝑔𝑖𝑡𝑢𝑑 𝑟𝑒𝑠𝑡𝑎𝑛𝑡𝑒 𝑑𝑒𝑙 𝑎𝑙𝑎𝑚𝑏𝑟𝑒

Aclaración: Los siguientes cálculos se realizarán para “a” genérico, y luego se lo

reemplazará por su valor correspondiente.

Teniendo en cuenta que el perímetro de la circunferencia se relaciona con su radio de la

siguiente manera:
𝑡
𝑡 = 2. 𝜋. 𝑟 → =𝑟
2𝜋
En cuanto al cuadrado:

(𝑎 − 𝑡)
4. 𝑙 = (𝑎 − 𝑡) → 𝑙 =
4
De este modo, teniendo esto en cuenta la suma de los momentos de inercia será

𝜋𝑟 4 𝑙 4 𝑡4 (𝑎 − 𝑡)4
+ = + (3)
4 12 64. 𝜋 3 3072
Para todo valor dentro del intervalo [0; 𝑎]

Teniendo en cuenta que el valor de 𝑎 de la consigna es 100, la función de suma de

momentos de inercia será:

𝑡4 (100 − 𝑡)4
+ (4)
64. 𝜋 3 3072

La gráfica de dicha función se puede observar a continuación en la figura 1:

-2-
 Figura 1. Gráfica de la función (4)

Como debemos obtener el valor mínimo d la función en el intervalo [0; 𝑎], se derivó la
función y se la igualo a cero. En otras palabras fue necesario buscar las raíces de la función:

𝑡3 (𝑎 − 𝑡)3
𝑓(𝑡) = − (5)
16. 𝜋 3 768
Para poder aplicar el algoritmo de Newton-Raphson fue necesario calcular la derivada de la
función anterior. Por lo tanto:

3. 𝑡 2 (𝑎 − 𝑡)2
𝑓´(𝑡) = + (6)
16. 𝜋 3 256
𝑎
Definidas las funciones 𝑓(𝑡) 𝑦 𝑓´(𝑡), la semilla 𝑝0 = 2 = 50, el error relativo
𝑝𝑛 −𝑝𝑛−1
| | ≤ 1𝑥10−3 y aplicando la expresión:
𝑝𝑛
𝑓(𝑝𝑛−1 )
𝑝𝑛 = 𝑝𝑛−1 −
𝑓´(𝑝𝑛−1 )

𝑝𝑛−1 3 (100 − 𝑝𝑛−1 )3

3− 768
𝑝𝑛 = 𝑝𝑛−1 − 16. 𝜋 2
3. 𝑝𝑛−1 (100 − 𝑝𝑛−1 )2
+
16. 𝜋 3 256

-3-
El lenguaje utilizado para realizar las sucesivas iteraciones fue Python (ver código 1 en
anexo).

A continuación se presenta una tabla con las sucesivas iteraciones y sus respectivos valores
𝑝𝑛 −𝑝𝑛−1
tanto de 𝑝𝑛 , 𝑝𝑛−1 𝑦 | |
𝑝𝑛

𝑝𝑛 − 𝑝𝑛−1
𝑛 𝑝𝑛 | | <; >; =; 1𝑥10−3
𝑝𝑛
1 50 - -
2 46.41511113 0.07768729519 >
−3
3 46.364667237 1.087981345 𝑥 10 >
4 46.364664897 5.046948596 𝑥 10−8 <

Finalmente se obtuvo en la cuarta iteración que el valor de corte del alambre, de modo tal
que la suma de los momentos de inercia de la circunferencia y el cuadrado sea mínima, es
de t =46.364664897 ± 0,5 𝑥 10−8 , pero como el error pedido es de 0.001, entonces.
t = 46.365 ± 0.001

Esto significa que los lados del cuadrado deberán tener una longitud de l = 13.409 ±
0.001cms y el radio de la circunferencia r = 7.379 ± 0.001 cms.

Finalmente el valor del momento de inercia será

𝑡4 (100 − 𝑡)4 46.3654 (100 − 46.365)4

+ → + = 5022.63691 ± 0.008 𝑐𝑚4
64. 𝜋 3 3072 64. 𝜋 3 3072

Una vez finalizado este cálculo, se procedió a modificar el código de forma tal que el
usuario sea capaz de ingresar la longitud del alambre, así también como el error mínimo
deseado. De este modo las iteraciones sucesivas se realizarán para los nuevos datos
obteniendo los resultados correspondientes a cada caso. (ver código 2 en anexo)

-4-
Conclusión
Como conclusión del trabajo realizado, podemos decir que la programación matemática es
una herramienta muy útil, la cual permite realizar iteraciones y obtener resultados con una
precisión que de otro modo resultaría prácticamente imposible.

Sin embargo, para quienes no se encuentran familiarizados con los distintos lenguajes
existentes o las formas de programación puede causar un gran “dolor de cabeza” el hecho
de no entender que es lo que no permite que el código funcione. En más de una situación se
trata de factores externos al problema en sí, y termina resultado un tanto molesto para el
usuario.

Respecto al método en sí, si se llega a observar la gran convergencia que posee, ya que
variando el valor de “a”, en el código que lo permite, se observa que siempre llega al
resultado esperado en pocas iteraciones, lo que confirma su convergencia cuadrada.

Otra forma que podría haber sido utilizada para obtener el resultado deseado es el método
de la bisección. A diferencia del método de Newton-Rapson, el método de la bisección
converge en forma muy lenta, pero garantiza convergencia en todos los casos en que haya
una raíz dentro del intervalo analizado. Cabe remarcar que en el método de Newton Rapson
esto no es así, si la semilla inicial no es una aproximación cercana a la raíz.

-5-
Bibliografía
A continuación una lista de la bibliografía consultada para la realización del trabajo:

 http://www.epsem.upc.edu/~fpq/ale-hp/modulos/aplicaciones/newton.pdf
 http://es.wikipedia.org/wiki/M%C3%A9todo_de_Newton
 http://www.cursosdeprogramacionadistancia.com/static/pdf/material-sin-
personalizar-python.pdf.
 http://logix4u.net/component/content/article/27-tutorials/44-how-to-create-
windows-executable-exe-from-python-script

-6-
Anexos
Anexo 1: Código para método de Newton-Rapson con “a” constante

import math

def newtonRaphson():

xActual = 50.0

xSiguiente = calcularXSiguiente(xActual)

epsilon = calcularErrorRelativo(xActual,xSiguiente)

cantidadDeIteraciones = 0

while (epsilon > 0.001):

xActual = xSiguiente

xSiguiente = calcularXSiguiente(xActual)

epsilon = calcularErrorRelativo(xActual,xSiguiente)

cantidadDeIteraciones += 1

return (xSiguiente, cantidadDeIteraciones)

def evaluarEnFuncion(x):

return (((x**3.0) / (16.0 * (math.pi**3.0))) - (((100 - x)**3.0) / 768.0))

def evaluarEnDerivadaDeLaFuncion(x):

return (1.0/256.0) * (((100 - x)**2.0) + (48.0 * (x**2.0)) / (math.pi**3.0))

def calcularXSiguiente(x):

return x - (evaluarEnFuncion(x)/evaluarEnDerivadaDeLaFuncion(x))

def calcularErrorRelativo(x, xSiguiente):

evaluacionEnElSiguiente = evaluarEnFuncion(xSiguiente)

evaluacionEnElActual = evaluarEnFuncion(x)

-7-
 errorRelativo = (evaluacionEnElSiguiente - evaluacionEnElActual) /
evaluacionEnElSiguiente

if (errorRelativo < 0):

return -errorRelativo

return errorRelativo

def main():

print "Para comenzar el programa presione cualquier tecla"

resultado1, resultado2 = newtonRaphson()

print "El valor aproximado de corte del alambre es de", resultado1, "y fueron
necesarias", resultado2, "iteraciones"

main()

raw_input()

-8-
Anexo 2: Código para método de Newton-Rapson con “a” introducido por el usuario.

import math

def newtonRaphson(a, minimoError):

xActual = a / 2.0

xSiguiente = calcularXSiguiente(xActual, a)

epsilon = calcularErrorRelativo(xActual,xSiguiente,a)

cantidadDeIteraciones = 0

lado = (a - xSiguiente)/4.0

radio = (xSiguiente / 2.0 * (math.pi))

while (epsilon > minimoError):

xActual = xSiguiente

xSiguiente = calcularXSiguiente(xActual, a)

epsilon = calcularErrorRelativo(xActual,xSiguiente,a)

cantidadDeIteraciones += 1

return (xSiguiente, cantidadDeIteraciones, lado, radio)

def evaluarEnFuncion(xActual, a):

return (((xActual**3.0) / (16.0 * (math.pi**3.0))) - (((a - xActual)**3.0) / 768.0))

def evaluarEnDerivadaDeLaFuncion(xActual, a):

return (1.0/256.0) * (((a - xActual)**2.0) + (48.0 * (xActual**2.0)) /

(math.pi**3.0))

def calcularXSiguiente(xActual, a):

return xActual -
(evaluarEnFuncion(xActual,a)/evaluarEnDerivadaDeLaFuncion(xActual,a))

def calcularErrorRelativo(xActual, xSiguiente, a):

evaluacionEnElSiguiente = evaluarEnFuncion(xSiguiente,a)

evaluacionEnElActual = evaluarEnFuncion(xActual,a)

-9-
 errorRelativo = (evaluacionEnElSiguiente - evaluacionEnElActual) /
evaluacionEnElSiguiente

if (errorRelativo < 0):

return -errorRelativo

return errorRelativo

def main():

print "El siguiente programa permite obtener el punto de corte de un alambre de modo
tal que se puedan formar un cuadrado y una circuenferencia cuya suma de momentos de
inercia sea mínima"

print "Para comenzar presione cualquier tecla"

raw_input()

a = input("ingrese la longitud deseada del alambre (en cms.) a: ")

while (a <= 0):

print "ha ingresado un valor nulo o negativo"

a = input("reingrese la longitud deseada del alambre (en cms.) a: ")

minimoError = input("ingrese el minimo error deseado con que se realicen las

iteraciones : ")

while (minimoError <= 0):

print "ha ingresado un valor nulo o negativo"

minimoError = input("reingrese el minimo error deseado con que se realicen

las iteraciones : ")

print "La longitud del alambre ingresado es : ",a,"y el minimo error : ",minimoError

raw_input()

resultado1, resultado2, lado, radio = newtonRaphson(a, minimoError)

print "El valor aproximado de corte es", resultado1, "cms. y la cantidad de iteraciones"

print "necesarias para llegar a este fueron", resultado2

- 10 -
 raw_input()

print "Para finalizar el programa presione cualquier tecla"

main()

raw_input()

- 11 -