Universidad del Norte Soluciones Computacionales a

Divisin de Ingenieras Problemas en Ingeniera

Departamento de Ingeniera de Augusto Sisa
Sistemas Segundo Semestre 2016

Actividad 06 Optimizacin
Nombres: Escriba los nombres y usuarios de los miembros del grupo aqu

El Fraude es una falta grave y puede ser penalizada

Condiciones
Las condiciones para esta actividad son:
La presentacin es en parejas.
Debe incluir este documento de Word (obligatorio) con el contenido del cdigo desarrollado, las
entradas dadas al programa, los resultados obtenidos y sus comentarios personales.
Los archivos de Python .py debe contar con la plantilla suministrada.
Los archivos de Matlab .m debe contar con la plantilla suministrada.

1 Funciones de inters
Funciones generales de inters:

Matlab Python
fminunc scipy.optimize.minimize
fmincon
scipy.optimize.brute
linprog linprog
scipy.optimize.bracket
fminbnd scipy.optimize.minimize_scalar

Referencias
Optimization and root finding (scipy.optimize) http://docs.scipy.org/doc/scipy/reference/optimize.html
http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html
http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize_scalar.html
http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.OptimizeResult.html

1 Funcin objetivo univariada no restringida

Python
scipy.optimize.minimize_scalar(fun, bracket=None, bounds=None, args=(), method='brent',
tol=None, options=None)

Si el cigeal de un motor a combustin est en un ngulo desde el TDC (punto muerto) con
=t donde es la velocidad angular y t es el tiempo, la distancia desde el pistn al
extremo de la biela (x) es:

1/13
 Universidad del Norte Soluciones Computacionales a
Divisin de Ingenieras Problemas en Ingeniera
Departamento de Ingeniera de Augusto Sisa
Sistemas Segundo Semestre 2016

(2 )
1cos
2
r
x=r ( 1cos ( ) ) +
4l

Wikipedia 2016

a) Encuentre el ngulo donde se maximiza la velocidad si r = 1.0 y l = 5.0 utilizando los siguientes
tres mtodos: 1) implementacin propia del mtodo de bsqueda aurea, 2) funcin de scipy
minimize_scalar con el mtodo golden y 3) funcin de scipy minimize_scalar con el
mtodo brent usado por defecto. Y compare la calidad y cantidad de iteraciones, o
evaluaciones de la funcin que cada uno requiere para encontrar el ptimo.

Algoritmo Resultado
get_ipython().magic('matplotlib notebook') Factor = 0.61803398875
import numpy as np Iteracin 1 x1 = 1.483, x2 = 2.400, f1
= 1.014, f2 = 0.576, error =
import matplotlib.pyplot as plt 3.88322207745
import scipy.optimize as sciop Iteracin 2 x1 = 0.917, x2 = 1.483, f1
= 0.890, f2 = 1.014, error =
def distancia(teta): 2.39996322973
r=1. Iteracin 3 x1 = 1.483, x2 = 1.833, f1
l=5. = 1.014, f2 = 0.916, error =
1.48325884772
return r*(1.-np.cos(teta))+(r**2/4.*l)*(1.-
Iteracin 4 x1 = 1.267, x2 = 1.483, f1
np.cos(2.*teta)) = 1.011, f2 = 1.014, error =
def velocidad(teta): 0.916704382006
r=1. Iteracin 5 x1 = 1.483, x2 = 1.617, f1
l=5. = 1.014, f2 = 0.990, error =
return r*np.sin(teta) + ((r**2/ 0.566554465716
(4.*l))*(2*np.sin(2*teta))) Iteracin 6 x1 = 1.401, x2 = 1.483, f1
= 1.019, f2 = 1.014, error =
0.35014991629
def funcion_para_max(teta): Iteracin 7 x1 = 1.350, x2 = 1.401, f1
return -velocidad(teta) = 1.018, f2 = 1.019, error =
0.216404549425
tetamin = 0 Iteracin 8 x1 = 1.401, x2 = 1.432, f1
tetamax = 2*np.pi = 1.019, f2 = 1.018, error =
0.133745366865
xspace = np.linspace(tetamin, tetamax) Iteracin 9 x1 = 1.381, x2 = 1.401, f1

2/13
 Universidad del Norte Soluciones Computacionales a
Divisin de Ingenieras Problemas en Ingeniera
Departamento de Ingeniera de Augusto Sisa
Sistemas Segundo Semestre 2016

yspace =velocidad(xspace) = 1.019, f2 = 1.019, error =

plt.plot(xspace, yspace) 0.0826591825604
Iteracin 10 x1 = 1.369, x2 = 1.381, f1
= 1.019, f2 = 1.019, error =
centinela = True 0.0510861843046
iteraciones_max = 20 Iteracin 11 x1 = 1.381, x2 = 1.389, f1
iteracion = 1 = 1.019, f2 = 1.019, error =
toleranciax = 0.001 0.0315729982558
factor = (np.sqrt(5.)-1.)/2. Iteracin 12 x1 = 1.376, x2 = 1.381, f1
= 1.019, f2 = 1.019, error =
print 'Factor = {}'.format(factor)
0.0195131860488
Iteracin 13 x1 = 1.381, x2 = 1.384, f1
intervalo = tetamax - tetamin = 1.019, f2 = 1.019, error =
x2 = tetamin + factor*intervalo 0.012059812207
x1 = tetamax - factor*intervalo Iteracin 14 x1 = 1.384, x2 = 1.386, f1
= 1.019, f2 = 1.019, error =
0.00745337384185
while centinela:
Iteracin 15 x1 = 1.383, x2 = 1.384, f1
f1 = velocidad(x1) = 1.019, f2 = 1.019, error =
f2 = velocidad(x2) 0.00460643836512
Iteracin 16 x1 = 1.384, x2 = 1.385, f1
if f1 > f2: = 1.019, f2 = 1.019, error =
tetamax = x2 0.00284693547673
x2 = x1 Iteracin 17 x1 = 1.384, x2 = 1.384, f1
= 1.019, f2 = 1.019, error =
f2 = f1 0.0017595028884
intervalo = tetamax-tetamin Iteracin 18 x1 = 1.383, x2 = 1.384, f1
x1 = tetamax - factor*intervalo = 1.019, f2 = 1.019, error =
f1 = velocidad(x1) 0.00108743258833
Iteracin 19 x1 = 1.384, x2 = 1.384, f1
else: = 1.019, f2 = 1.019, error =
0.000672070300063
tetamin = x1
x1 = x2
f1 = f2
intervalo = tetamax-tetamin
x2 = tetamin + factor*intervalo
f2 = velocidad(x2)

errorx = intervalo

plt.plot(x1, f1, 'r*')

plt.plot(x2, f2, 'g*')

print u'Iteracin {} x1 = {:.3f}, x2 = {:.3f},

f1 = {:.3f}, f2 = {:.3f}, error = {}
'.format(iteracion, x1, x2, f1, f2, errorx)
iteracion = iteracion + 1
if iteracion > iteraciones_max or errorx <=
fun: -1.0191006063429009
toleranciax: nfev: 11
nit: 10
3/13
 Universidad del Norte Soluciones Computacionales a
Divisin de Ingenieras Problemas en Ingeniera
Departamento de Ingeniera de Augusto Sisa
Sistemas Segundo Semestre 2016

centinela = False success: True

x: 1.383563660468818
solucionbrent=sciop.minimize_scalar(funcion_ fun: -1.0191006063429011
para_max, method='brent') nfev: 43
print solucionbrent x: 1.3835636395925297

soluciongolden=sciop.minimize_scalar(funcion la solucion con el mtodo de brent es:

_para_max, method='golden') 1.38356366047
el nmero de iteraciones fue : 10
print soluciongolden
la solucion con el mtodo de golden es:
1.38356363959
print u'la solucion con el mtodo de brent es:
{}'.format(solucionbrent.x)
print u'el nmero de iteraciones fue :
{}'.format(solucionbrent.nit)
print u'la solucion con el mtodo de golden es:
{}'.format(soluciongolden.x)

(Adaptado de Rao 2009))

2 Funcin objetivo univariada no restringida

Python
scipy.optimize.minimize_scalar(fun, bracket=None, bounds=None, args=(), method='brent',
tol=None, options=None)

b) Encuentre el valor de x donde se minimiza la siguiente funcin objetivo utilizando los

siguientes tres mtodos: 1) implementacin propia del mtodo de bsqueda aurea, 2) funcin
de scipy minimize_scalar con el mtodo golden (bsqueda aurea) y 3) funcin de scipy
minimize_scalar con el mtodo brent usado por defecto y compare la calidad y cantidad de
iteraciones que cada uno requiere para encontrar el ptimo

Algoritmo Resultado- minimizando

import numpy as np fun: 0.0
import matplotlib.pyplot as plt nfev: 34
nit: 33
import scipy.optimize as sciop success: True
x: -4.6533067121057055e-11
def funcion(x): la solucion en grados es :-0.00
return 1.*(1.-np.cos(x))+(1./20.)*(1.-
np.cos(2.*x))

4/13
 Universidad del Norte Soluciones Computacionales a
Divisin de Ingenieras Problemas en Ingeniera
Departamento de Ingeniera de Augusto Sisa
Sistemas Segundo Semestre 2016

solucionbrent=sciop.minimize_scalar(funcion,
method='brent')
print solucionbrent
print'la solucion en grados es : Resultado maximizando
{:.2f}'.format(solucionbrent.x*180/np.pi) fun: -2.0
nfev: 9
nit: 8
success: True
import numpy as np x: 3.1415926538517991
import matplotlib.pyplot as plt la solucion en grados es :180.00
import scipy.optimize as sciop

def derivadafuncion(x):
r=1.
l=5.
return -r*np.sin(teta) + ((r**2/
(4.*l))*(2*np.sin(2*teta)))

solucionbrent=sciop.minimize_scalar(distancia
, method='brent')
print solucionbrent
x=solucionbrent.x
sol1=1.*(1.-np.cos(x))+(1./20.)*(1.-
np.cos(2.*x))

print sol1

def funcion(x):
return -1.*(1.-np.cos(x))+(1./20.)*(1.-
np.cos(2.*x))

solucionbrent=sciop.minimize_scalar(funcion,
method='brent')
print solucionbrent
print'la solucion en grados es :
{:.2f}'.format(solucionbrent.x*180/np.pi)

Utilizando el x del punto anterior: Resultado

Algoritmo
fun: -1.0191006063429009
import numpy as np nfev: 11
import matplotlib.pyplot as plt nit: 10
import scipy.optimize as sciop success: True
x: -1.383563639639974
5/13
 Universidad del Norte Soluciones Computacionales a
Divisin de Ingenieras Problemas en Ingeniera
Departamento de Ingeniera de Augusto Sisa
Sistemas Segundo Semestre 2016

def derivadafuncion(x): la solucion utilizando el x anterior

r=1. es:0.91
l=5.
return -r*np.sin(teta) + ((r**2/
(4.*l))*(2*np.sin(2*teta)))

solucionbrent=sciop.minimize_scalar(distancia
, method='brent')
print solucionbrent
x=solucionbrent.x
sol1=1.*(1.-np.cos(x))+(1./20.)*(1.-
np.cos(2.*x))
print'la solucion utilizando el x anterior es:
{:.2f}'.format(sol1)

3 Funcin objetivo multivariada no restringida

a) Reescriba la funcin dada a continuacin en su forma matricial, al agrupar los valores escalares
de x 1 , x 2 y x 3 en un vector X y definir la matriz A, el vector B y el escalar C:

f ( x 1 , x 2 , x 3 ) =x 21x 22 +2 x 1 x2 x23 +6 x 1 x 3 + 4 x1 5 x 3 +2

X


f

b) Encuentre la relacin que existe entre la matriz A, el vector B de la forma matricial y la matriz
Hessiana y el vector gradiente de la funcin f ( x 1 , x 2 , x 3 )

6/13
 Universidad del Norte Soluciones Computacionales a
Divisin de Ingenieras Problemas en Ingeniera
Departamento de Ingeniera de Augusto Sisa
Sistemas Segundo Semestre 2016

c) Con base en la informacin obtenida antes escriba una funcin en Python que reciba cuatro
parmetros correspondientes a:
Vector X
Matriz A
Vector B
Escalar C

Y retorne el valor de f

d) Determine si la matriz A es definida positiva, definida negativa o indefinida

e) Utilizando la funcin construida antes encuentre utilizando las funciones de Python los puntos
crticos que minimizan o maximizan la funcin.

4 Funcin objetivo multivariada no restringida

Python
scipy.optimize.minimize(fun, x0, args=(), method=None, jac=None, hess=None, hessp=None,
bounds=None, constraints=(), tol=None, callback=None, options=None)[source]

Una estructura compuesta por dos barras metlicas est dispuesta como se muestra en la siguiente
figura

7/13
 Universidad del Norte Soluciones Computacionales a
Divisin de Ingenieras Problemas en Ingeniera
Departamento de Ingeniera de Augusto Sisa
Sistemas Segundo Semestre 2016

(Rao 2009)

En estas condiciones la energa potencial de la estructura puede ser calculada con la expresin
2 2
EA l EA h 2
8 f ( x 1 , x 2 )=
s 2s ( )
x 21 + ()
x P x1 cos ( ) P x 2 sin ( )
s s 2
Donde E es el mdulo de Young, A es el rea transversal de cada elemento, l (ele) la longitud de la
estructura, s la longitud de cada elemento, h la altura de la estructura, P la carga aplicada, el
ngulo de aplicacin de la carga y x 1 y x 2 los desplazamientos del punto de aplicacin desde la
posicin libre.

(Adaptado de RAO 2009)

a) Encuentre los valores de x 1 y x 2 donde se minimiza la energa potencial de la estructura

cuando los dems parmetros de la funcin son:

E = 207x109 Pa
A = 10-5 m2
l (ele) = 1.5 m
h = 4.0 m
P = 104 N
= 30

Utilice los siguientes tres mtodos: 1) implementacin propia del mtodo de mximo descenso,
2) funcin de scipy minimize con el mtodo BFGS con los parmetros por defectos y 3)
funcin de scipy minimize con el mtodo BFGS asignado el argumento jac. Compare sus
resultados prestando atencin a la cantidad de evaluaciones y de iteraciones realizadas.

Algoritmo Resultado
import numpy as np semilla:
8/13
 Universidad del Norte Soluciones Computacionales a
Divisin de Ingenieras Problemas en Ingeniera
Departamento de Ingeniera de Augusto Sisa
Sistemas Segundo Semestre 2016

import scipy.optimize as sp [ 0. 0.]

import numpy.linalg as linalg solucion:
[ 0.00091372 0.00508901]
from scipy.optimize import minimize menor principal: 9478012.5
menor principal: 9.31224456532e+12
fun: -16.679039093614584
def funcionep(x1,x2): hess_inv: array([[ 1.05507352e-07,
E = 207*10**9 -1.90244176e-16],
A = 10**(-5) [ -1.90244176e-16,
1.01780107e-06]])
l = 1.5
jac: array([ 0.00000000e+00,
h = 4. 2.38418579e-07])
P = 10**4 message: 'Optimization terminated
t = np.pi/6 successfully.'
s = 4.07 nfev: 28
return (E*A/s)*((l/2*s)**2)*x1**2 + nit: 4
njev: 7
(E*A/s)*((h/s)**2)*x2**2 - P*x1 * np.cos(t) -
status: 0
P*x2*np.sin(t) success: True
x: array([ 0.00091371,
def gradienteep(v): 0.005089 ])
x1 = v[0] fun: -16.679039093904926
x2 = v[1] hess_inv: array([[ 1.05507352e-07,
E = 207*10**9 -1.34334131e-20],
[ -1.67785315e-20,
A = 10**(-5) 1.01780107e-06]])
l = 1.5 jac: array([ 0., 0.])
h = 4. message: 'Optimization terminated
P = 10**4 successfully.'
t = np.pi/6 nfev: 6
s = 4.07 nit: 3
njev: 6
dfdx = (E*A/s)*((l/2*s)**2)*2*x1 - status: 0
P*np.cos(t) success: True
dfdy = (E*A/s)*((h/s)**2)*2*x2 - x: array([ 0.00091372,
P*np.sin(t) 0.00508901])
return np.array([dfdx,dfdy]) la solucion con el mtodo de minimize
es: [ 0.00091371 0.005089 ]
la solucion con el mtodo de BFGS es: [
0.00091372 0.00508901]

def hessianaep(v):
x1 = v[0]
x2 = v[1]
E = 207*10**9
A = 10**(-5)
l = 1.5
h = 4.
P = 10**4
t = np.pi/6
s = 4.07
df2dx2 = (E*A/s)*((l/2*s)**2)*2
9/13
 Universidad del Norte Soluciones Computacionales a
Divisin de Ingenieras Problemas en Ingeniera
Departamento de Ingeniera de Augusto Sisa
Sistemas Segundo Semestre 2016

df2dxdy = 0
df2dydx = df2dxdy
df2dy2 = (E*A/s)*((h/s)**2)*2
return np.array([[df2dx2,df2dxdy],
[df2dydx,df2dy2]])

x0 = 0.
y0 = 0.
semilla = np.array([x0,y0])

sol = sp.fsolve(gradienteep, semilla)

print u'semilla:\n{}'.format(semilla)
print u'solucion:\n{}'.format(sol)

hess = hessianaep(sol)
#print u'hessiana:\n{}'.format(hess)

print u'menor principal: {}'.format(hess[0,0])

print u'menor principal:
{}'.format(linalg.det(hess))
#metodo minimize
def funcion_para_minimize(v):
x = v[0]
y = v[1]
return funcionep(x,y)

semilla = np.array([2,3])

solucionminimize =
minimize(funcion_para_minimize, semilla)
print solucionminimize

semilla = np.array([2,3])
solucionbfgs =
minimize(funcion_para_minimize, semilla,jac
= gradienteep)
print solucionbfgs

print u'la solucion con el mtodo de minimize

es: {}'.format(solucionminimize.x)
print u'la solucion con el mtodo de BFGS es:
{}'.format(solucionbfgs.x)

10/13
 Universidad del Norte Soluciones Computacionales a
Divisin de Ingenieras Problemas en Ingeniera
Departamento de Ingeniera de Augusto Sisa
Sistemas Segundo Semestre 2016

b) Confirme los resultados obtenidos antes haciendo una grfica de curvas de igual energa
potencial en funcin de los valores de los desplazamientos
Algoritmo curva de nivel Resultado

import numpy as np
import matplotlib.pyplot as plt
def funcionep(x1,x2):
E = 207*10**9
A = 10**(-5)
l = 1.5
h = 4.
P = 10**4
t = np.pi/6
s = 4.07
return (E*A/s)*((l/2*s)**2)*x1**2 +
(E*A/s)*((h/s)**2)*x2**2 - P*x1 * np.cos(t) -
P*x2*np.sin(t)

x1=np.linspace(-4.,4.)
x2=np.linspace(-4.,4.)
X1,X2 = np.meshgrid(x1, x2)
plt.figure()
plt.contourf(X1,X2,funcionep(X1,X2))
plt.show()

5 Funcin objetivo multivariada con restricciones de igualdad

Python
scipy.optimize.minimize(fun, x0, args=(), method=None, jac=None, hess=None, hessp=None,
bounds=None, constraints=(), tol=None, callback=None, options=None)[source]

En una hoja impresa se ha decidido dejar un margen de 30 mm en el borde superior, 20mm a la

izquierda, a la derecha y la parte inferior. Si el rea total de la pgina es 5.0x10 4 mm2 determine las
dimensiones de la pgina que maximizan el rea til de la hoja impresa.

import numpy as np
from scipy.optimize import minimize

11/13
 Universidad del Norte Soluciones Computacionales a
Divisin de Ingenieras Problemas en Ingeniera
Departamento de Ingeniera de Augusto Sisa
Sistemas Segundo Semestre 2016

def s(x,y):
return -x*y
def funcion_para_minimize(v): #vector con valor de x y y
x= v[0]
y= v[1]
return s(x,y)
semilla=np.array([0,0])

print funcion_para_minimize(semilla)
solucion=minimize(funcion_para_minimize,semilla) #paquete, fun(cuanto vale la funcion minimizada), jac(gradiente
debe ser 0)

print solucion

print u'El numero de iteraciones es: {}'.format(solucion.nit)

print u'El valor de x es: {:.2f}'.format(solucion.x[0])
print u'El valor de y es: {:.2f}'.format(solucion.x[1])

#MAXIMIZAR SE DEBE MULTPLICAR LA FUNCION POR -1

def funcion_para_max(v): #vector con valor de x y y
x= v[0]
y= v[1]
return -s(x,y)

semilla=np.array([1,1])
print funcion_para_max(semilla)
solucion=minimize(funcion_para_max,semilla) #paquete, fun(cuanto vale la funcion minimizada), jac(gradiente
debe ser 0)
print solucion

def restriccion1(v):
x = v[0]
y = v[1]
return (x-40)*(y-50)-5*10**4.

diccionario_restricciones=({'type':'eq',
'fun':restriccion1}, {'type':'eq',
'fun': lambda v: v[1]-v[0]})

solucion= minimize(funcion_para_minimize,semilla
,constraints=diccionario_restricciones)

print u'El numero de iteraciones es: {}'.format(solucion.nit)

print u'El valor de x es: {:.2f}'.format(solucion.x[0])
print u'El valor de y es: {:.2f}'.format(solucion.x[1])
print solucion

12/13
 Universidad del Norte Soluciones Computacionales a
Divisin de Ingenieras Problemas en Ingeniera
Departamento de Ingeniera de Augusto Sisa
Sistemas Segundo Semestre 2016

13/13