articulo leonel
TRANSCRIPT
EL PROBLEMA DE CORTE 2D
Lic. Leonel Antonio Mendieta Fonseca1
1Licenciado en Matemática. Universidad Nacional Autónoma de Nicaragua.
Docente Horario; UNAN Managua. [email protected]
RESUMEN
En este trabajo se presenta el uso de Algoritmos Constructivo para dar solución
a un problema de corte tipo guillotina, el cual consiste, dado un tablero con
dimensiones de largo y ancho de 555 unidades de largo y 632 unidades de
ancho, en el que se desea realizar cortes considerando un inventario de 30
piezas de diferente tamaño. Donde el objetivo principal del problema consiste
en determinar la estrategia de corte óptima. Para el cumplimiento de los
objetivos propuestos, se desarrolló un código en el lenguaje de programación
C++. Con esta investigación se demostrara que la programación matemática es
fundamental para darle soluciones a problemas de optimización tediosos de
resolver de forma manual.
Palabras clave: Corte guillotina, Algoritmo constructivo, Programación en C++,
Introducción
El problema de corte en dos dimensiones consiste en cortar con máximo
beneficio un tablero rectangular en un conjunto finito de pequeñas piezas
rectangulares. Este problema tiene un extenso campo de aplicaciones en la
industria y comercio. Aparece en el corte de madera, cartón, cristal, plástico,
laminas metálicas, etc.
El principal objetivo de este problema es reducir la cantidad de residuo
(desperdicio) de material que se origina al momento de realizar un determinado
corte. (Ruiz & Ruiz, 200 6)
El problema de corte se puede considerar como un sub problema o versión
sencilla de un problema de corte más general en el cual se debe satisfacer toda
la demanda de piezas a partir de un conjunto de tableros de distintos tamaños.
En este trabajo imponemos a los patrones de corte las siguientes restricciones:
Las piezas tienen orientación fija, los cortes son de tipo guillotina y se realizan
sin límite de etapas y no poseen demanda.
Para resolver el problema existen diversos algoritmos los cuales podemos
mencionar los siguientes algoritmos heurísticos: Constructivo, GRASP, Tabu
Search, Evolutivo Paralelo Adaptativo y Path Relinking. Los resultados
computacionales muestran que estos procedimientos meta heurísticos son muy
eficientes. Para el caso particular del problema a resolver se utilizó el algoritmo
Constructivo.
Algoritmo Constructivo para corte 2D
El algoritmo constructivo ubica las piezas en los diferentes sub-espacios
definidos por los vectores H y T. Como cada sub-espacio debe ubicar arreglos
del mismo tipo solo basta determinar cuál es el desperdicio para cada tipo de
arreglo asegurando que se cumpla la restricción de demanda.
La idea general del algoritmo es la siguiente:
La instancia para la cual se elaboró el programa es la siguiente:
Lamina:
Largo: 555
Ancho: 632
Descripción de las 30 piezas ya ordenadas según el índice se presentan en la
siguiente tabla:
Largo
Ancho Costo
Área Índice
99 129 700 12771 0.054811683
141 102 480 14382 0.033375052
121 124 427 15004 0.028459078
92 167 405 15364 0.026360323
Datos de entrada →T,H
For k = 1 To Ns
(Xk,Yk) ←Tamaño del sub-espacio k
Max ←0
For i = 1 To n
a ←Entera( Xk / xi )
b←Entera ( Yk / yi )
z ←min(a*b, Di)
If z*Ai > Max
Max = z*Ai
Result(k) ← [z,i]
EndIf
EndFor
EndFor
119 98 307 11662 0.026324816
96 200 452 19200 0.023541667
121 257 620 31097 0.019937615
154 169 458 26026 0.017597787
120 252 524 30240 0.017328042
213 101 370 21513 0.017198903
154 158 394 24332 0.016192668
166 236 600 39176 0.015315499
333 130 620 43290 0.014322014
100 123 170 12300 0.013821138
213 110 300 23430 0.012804097
257 163 469 41891 0.011195722
220 230 520 50600 0.01027668
133 227 310 30191 0.010267961
110 100 110 11000 0.01
206 157 309 32342 0.00955414
111 153 160 16983 0.009421186
152 251 357 38152 0.009357308
186 335 580 62310 0.009308297
267 331 630 88377 0.007128552
112 219 160 24528 0.006523157
212 252 340 53424 0.006364181
254 352 562 89408 0.006285791
312 122 150 38064 0.003940731
354 254 354 89916 0.003937008
141 261 130 36801 0.003532513
ResultadosAl realizar la programación del algoritmo constructivo en C++ (Ver código
fuente en anexos) el resumen de la salida es el siguiente:
La solución grafica es la siguiente:
Al comparar los resultados obtenidos en el programa con los generados en el
software “Cutting Optimization pro” tenemos:
RESUMEN DE LOS CORTES QUE SE PUEDEN REALIZAR EN LA PIEZA, CANTIDAD A CORTAR Y COSTO TOTAL PRIMERA PIEZA A CORTAR (99)(129)
=================================================================
Cantidad de Piezas (99,129)= 20
Costo de las 20 Piezas cortadas (99,129)= 14000
Costo Acumulado 14000
Cantidad de Piezas (141,102)= 3
Costo de las 3 Piezas cortadas (141,102)= 1440
Costo Acumulado 15440
Cantidad de Piezas (119,98)= 1
Costo de las 2 Piezas cortadas (119,98)= 307
Costo Acumulado 15747
===============================================================
COSTO TOTAL DE LAS PIEZAS CORTADAS= 15747
===============================================================
(13,98)
(132,18)(555,18)
(119,98)(141,102)(141,102)(141,102)
(60,516)
(99,129)(99,129)(99,129)(99,129)(99,129)
(99,129)(99,129)(99,129)(99,129)(99,129)
(99,129)(99,129)(99,129)(99,129)(99,129)
(99,129)(99,129)(99,129)(99,129)(99,129)
(99,129)(99,129)(99,129)(99,129)(99,129)
Se comparó el resultado del programa con los del El software “Cutting
Optimization pro” y la solución grafica mostrada fue la siguiente:
El resumen de las piezas que se deben de cortar es el siguiente:
El software “Cutting Optimization pro” no considera los costos de cada pieza,
calculándolo el costo es el siguiente:
96 x 200 el costo es 452 por 3 piezas = 1356
333 X 130 el costo es 620 = 620
100 x 123 el costo es 170 = 170
152 x 251 el costo es 357 x 6 piezas = 2142
El costo total de este plan de corte es 4,288
Este costo es inferior al obtenido con el programa que se desarrolló.
ConclusionesCon la implantación del algoritmo constructivo a un problema en particular del
corte guillotina se deja ver la importancia que como futuros doctores en
Matemática Aplicada, tengamos la habilidad de programar problemas
matemáticos en el área de programación lineal y optimización. Aquí tenemos
un ejemplo. Un problema que llevaría mucho tiempo resolver a mano se le da
solución en algunos segundos gracias a la implementación en un lenguaje de
programación como lo es C++.
Bibliografía
Ruiz, M., & Ruiz, E. (200 6). Algoritmo GRASP para cortes de guillotina.
SISTEMAS E INFORMÁTICA, 53.