INSTITUTO TECNOLÓGICO NACIONAL DE
MÉXICO
INSTITUTO TECNOLOGICO DE
ACAPULCO
INGENERIA EN SISTEMAS COMPUTACIONALES
MATERIA: PROGRAMACIÓN LOGICA Y FUNCIONAL.
NOMBRE DEL MAESTRO: ING.JOSE FRANCISCO GAZGA PORTILLO
DESCRPCIÓN DE TAREA: REPORTE DEL DESARROLLO DE SOFTWARE
APLICANDO EL PARADIGMA FUNCIONAL
IS3
ALUMNOS:
ROSAS FLORES JUAN JOSÉ 18320982
PADILLA REYES ANGEL 18320982
ANGELITO SALINAS MISAEL 18320798
RICO OLEA JAIME ERNESTO 18320971
LOZANO MIRANDA JAVIER YAIR 18321288
HORARIO: 9:00 AM A 10:00 AM
FECHA DE ENTREGA: VIERNES 22 DE OCTUBRE DEL 2021
2
Índice
Contenido
Introducción......................................................................................................................................3
Marco teórico...................................................................................................................................3
Desarrollo.........................................................................................................................................4
Resultados.......................................................................................................................................5
Programa 1:.................................................................................................................................5
Código Quicksort en paradigma funcional...........................................................................5
Programa 2:....................................................................................................................................7
SUMA DE CUADRADOS DE UNA LISTA DE ENTEROS.................................................7
Programa 3:....................................................................................................................................8
SUMA DE UNA LISTA DE VALORES ENTEROS..............................................................8
Programa 4:....................................................................................................................................9
ORDENAMIENTO POR SELECCIÓN:.................................................................................9
Programa 5:..................................................................................................................................10
FACTORIAL...........................................................................................................................10
Conclusiones..................................................................................................................................12
2
Introducción
Primeramente, para elaborar este reporte tuvimos que tener en claro el siguiente
concepto ¿Qué es programación funcional? “El estilo de programación que
enfatiza la evaluación de expresiones, antes que la ejecución de comandos
".[ CITATION DYB96 \l 2058 ] La definición anterior es bastante amplia y tal vez
ambigua, pues no se precisa a qué se refiere el énfasis del cual habla. Esto refleja
la frontera difusa que existe entre lenguajes funcionales puros y lenguajes no
funcionales; en esta frontera se ubican lenguajes como LISP, SCHEME y ML, que
nadie dudaría en catalogar como funcionales a pesar de que tienen características
no puras como asignaciones y efectos laterales, a diferencia de los lenguajes
funcionales puros, los cuales desarrollan todos sus cómputos exclusiva.
Un programa funcional está constituido enteramente por funciones; el programa
principal es una función que toma como argumento la entrada al programa y
genera la salida del programa como su resultado. Típicamente, la función principal
se define en términos de otras funciones, y éstas, a su vez, en término de más
funciones; esta cadena finaliza en funciones predefinidas o primitivas.
El fundamento de los lenguajes funcionales es el cálculo lambda, desarrollado por
Haskell Curry en la década del 30. Es un cálculo de funciones basado en la
abstracción y la aplicación. Curry demostró que las funciones definibles dentro de
este cálculo corresponden a las computables por una máquina de Turing. [ CITATION
CUR58 \l 2058 ].
Marco teórico
La programación funcional consiste en componer programas a partir de funciones,
estas funciones reciben unos parámetros retornan un valor o bien una función. Las
funciones que retorna otra función, se llaman funciones de alto orden, se
explicarán en esta sección.[ CITATION Chi14 \l 2058 ]
Los lenguajes de programación funcional están enraizados en el concepto de
función (matemática) y su definición mediante ecuaciones (generalmente
2
recursivas), que constituyen el programa. Diversos autores [ CITATION RPl93 \l 2058 ]
y [ CITATION CRe93 \l 2058 ]consideran que un programa funcional incluye también,
además de una lista de ecuaciones de definición de funciones, una expresión
básica (sin variables) que se pretende evaluar como objetivo.
Desarrollo
Los lenguajes de programación comunes suelen permitir diferentes paradigmas de
programación. Dentro de estos, se hace una distinción aproximada entre
los paradigmas de programación declarativa y de programación imperativa.
Simplificando mucho, estos paradigmas constituyen los métodos fundamentales
de programación. Una subcategoría de la estrategia declarativa es la llamada
programación funcional, que se utiliza en particular en el desarrollo de los
siguientes programas o códigos:
Aplicaciones técnicas y matemáticas
Inteligencia Artificial (IA)
Compiladores y analizadores
Algoritmos
¿Qué es la programación funcional?
El nombre ya lo sugiere: la programación funcional o functional programming se
centra en las funciones. En un programa funcional, todos los elementos pueden
entenderse como funciones y el código puede ejecutarse mediante llamadas de
función secuenciales. Por el contrario, no se asignan valores de forma
independiente. Una función se imagina mejor como una variante especial de un
subprograma. Esta es reutilizable y, a diferencia de un procedimiento, devuelve
directamente un resultado.
Por supuesto, en muchos lenguajes de programación superiores hay funciones
que se definen y después se aplican. Por esto, esta no es la característica
especial de la programación funcional. Lo que hace que la estrategia funcional sea
tan importante para la informática y a la vez tan versátil es el hecho de que las
2
funciones dentro de este paradigma de programación pueden adoptar diferentes
“formas”: estas pueden enlazarse entre sí como los datos y utilizarse como
parámetro y como resultado de la función. Este tratamiento especial de las
funciones permite a los programadores implementa
Resultados
Programa 1 :
Código Quicksort en paradigma funcional
Quicksort []=[]
Quicksort (x:xs) = (Quicksort [y | y <- xs, y <= x]) ++[x]++ (Quicksort [z | z <- xs, z >
x])
Nuestro código Quicksort trabaja con estas dos líneas de código las cuales dicen
que nuestra función va recibir una lista y dará como resultado una lista en la
segunda línea nos dice que tomará un elemento X y XS (X será nuestro pivote y
XS es lo que sobre de nuestra lista) en lo que divide el trabajo en dos listas
diferentes en una se almacenan los datos menores a X y en la otra los mayores a
X.
lo que sigue que XS le da los valores a Y y Z para comparar quien es menor o
mayor si el resultado es menor se pondrá en la lista Y si el valor es mayor se ira al
valor Z una vez obtenido el resultado esta concatena las listas colocando la lista Y
seguido de la lista X y terminando con la lista Z.
como ejemplo tenemos una lista de 5 números los cuales son [3,2,14,7,6]
2
Figura 1: Implementación en Haskell
Su evaluación es la siguiente
[3,2,14,7,6]
Qs [2] ++ [3] ++ Qs [14,7,6]
Así es
Qs []++ [2] ++ Qs [] ++ [3] ++ Qs [7,6] ++ [14]++ Qs[] como el
método
Qs []++ [2] ++ Qs [] ++ [3] ++ Qs [6] ++ [7] ++ Qs [] ++ [14] ++ Qs [] Quicksort
evalúa en
Qs []++ [2] ++ Qs [] ++ [3] ++ Qs [] ++ [6] ++ Qs [] ++ [7] ++ Qs [] ++ [14] ++ Qs [] el
paradigma
[]++ [2] ++ [] ++ [3] ++ [] ++ [6] ++ [] ++ [7] ++ [] ++ [14] ++ [] funcional y
como se ve
[]++ [2] ++ [] ++ [3] ++ [] ++ [6] ++ [] ++ [7] ++ [] ++ [14] nos da el
mismo
[]++ [2] ++ [] ++ [3] ++ [] ++ [6] ++ [] ++ [7] ++ [14] resultado
que en el
[]++ [2] ++ [] ++ [3] ++ [] ++ [6] ++ [] ++ [7,14] programa
[]++ [2] ++ [] ++ [3] ++ [] ++ [6] ++ [7,14]
[]++ [2] ++ [] ++ [3] ++ [] ++ [6,7,14]
[]++ [2] ++ [] ++ [3] ++ [6,7,14]
[]++ [2] ++ [] ++ [3,6,7,14]
[]++ [2] ++ [3,6,7,14]
[]++ [2,3,6,7,14]
[2,3,6,7,14]
2
Programa 2:
SUMA DE CUADRADOS DE UNA LISTA DE ENTEROS
El siguiente ejercicio suma el cuadrado de una lista de números enteros
Codificación
Figura 2: Codificación
suma_de_cuadrados(1 : (2 : (3: [ ])))
1*1 + suma_de_cuadrados (2 : (3 : [ ]))
1 + (2*2 + suma_de_cuadrados (3 : [ ])) Evaluación
1+ (4 + (3*3 + suma_de_cuadrados [ ])) Así es como el programa
1+ (4 + (9 + 0)) suma_de_cuadrados evalúa en el
paradigma funcional y como se ve nos
14 da el mismo resultado que en el
programa
Implementación en HASKELL
2
Figura 3: Implementación en Haskell
Programa 3:
SUMA DE UNA LISTA DE VALORES ENTEROS
La siguiente función toma una lista de valores enteros y los suma. Las dos
ecuaciones hacen que la función esté definida para cualquier lista. La primera
será utilizada si la lista está vacía, mientras que la segunda se usará en otro caso.
Codificación:
Figura 4: Codificación
suma_entero(7 : (10: (3: [])))
7 + suma_entero (10 : (3 : []))
7 + (10 + suma_entero (3 : []))
Evaluación
7 + (10 + (3 + suma_entero []))
Así es como el programa
7 + (10 + (3 + O))
suma_entero evalúa en el paradigma
20 funcional y como se ve nos da el
mismo resultado que en el programa
Implementación en HASKELL
2
Figura 5: Implementación en Haskell
Programa 4:
ORDENAMIENTO POR SELECCIÓN:
Para ordenar una lista xs mediante el algoritmo de ordenación por selección, se
selecciona el menor elemento de xs y se le añade a la ordenación por selección
de los restantes.
Codificación
Figura 6: Codificación
Por ejemplo, para ordenar la lista [7,6,5,4,3,2,1] el proceso es el siguiente:
-- ordenamiento_por_seleccion [7.6,5,4,3,2,1]
-- = 1 : ordenamiento_por_seleccion [7,6,5,4,3,2] Así es como el programa
ordenamiento_por_seleccion
-- = 1 : 2 : ordenamiento_por_seleccion [7,6,5,4,3] evalúa en el paradigma funcional
y como se ve nos da el mismo
-- = 1 : 2 : 3 : ordenamiento_por_seleccion [7,6,5,4] resultado que en el programa
2
-- = 1 : 2 : 3: 4 : ordenamiento_por_seleccion [7,6,5]
Evaluación
-- = 1 : 2 : 3 : 4 : 5 : ordenamiento_por_seleccion [7,6]
-- = 1 : 2 : 3 : 4 : 5 : 6 : ordenamiento_por_seleccion [7]
-- = 1 : 2 : 3 : 4: 5 : 6 : 7 : ordenamiento_por_seleccion []
-- = 1 : 2 : 3 : 4 : 5 : 6 : 7 : []
-- = [1,2,3,4,5,6,7]
Definir la función
-- o ordenamiento_por_seleccion :: Ord a => [a] -> [a]
-- tal que (ordenamiento_por_seleccion xs) es la lista obtenida ordenando por
selección la lista xs. Por ejemplo,
-- ordenamiento_por_seleccion [7,6,5,4,3,2,1] == [1,2,3,4,5,6,7]
Implementación en HASKELL
Figura 7: Implementación en Haskell
Programa 5:
FACTORIAL
En este programa da la factorial de cualquier número entero.
Codificación
2
Figura 8: Codificación
Evaluación
Factorial 4
4 * factorial (4-1)
4 * factorial (3)
4 * 3 * factorial (3-1)
4 * 3 * factorial (2)
4 * 3 * 2 factorial (2-1)
4 * 3 * 2 factorial (1)
4 * 3 * 2 * 1 factorial (1-1)
4 * 3 * 2 * 1 factorial (0)
4*3*2*1*1
12*2*1*1
24*1*1
24*1
24
Implementación en HASKELL
Figura 9: Implementación en Haskell
2
Conclusiones
Rosas Flores Juan José
La programación funcional nos permitirá desarrollar software mucho más legible y
fácil de testear, nos concentramos en qué estamos haciendo y no en cómo se está
haciendo. La programación funcional intenta tratar el problema de la programación
desde un punto de vista matemático, utilizando la noción de función como base
para la construcción de los algoritmos y estructuras de datos.
Padilla Reyes Ángel
Yo concluyo este tema dando un pequeño recopilatorio de lo que yo aprendí en
esta primera parte que fue la programación funcional. Creo que la programación
funcional es un paradigma que es muy importante aprender, al igual que la
programación que manejamos casi todos los estudiantes de ingeniería y los
profesionales que solamente usan la programación orientada a objetos.
Utilizamos haskell en esta unidad para ver cómo funcionaba la programación
funcional y creo que es fácil, solo que como cualquier cosa hay que seguir
estudiando para entender más y más.
Angelito Salinas Misael
En lo que a mí respecta el paradigma funcional es menos laborioso para trabajar
ya que como se ve para que el método funcione solo necesita dos líneas de
código mientras que en paradigmas imperativos esta necesita demasiadas líneas
de código solo para el método sin contar el método para imprimir la lista.
La forma de evaluar de dicho código en el paradigma funcional es más fácil de
analizar. El cómo trabaja el método para dividir cada dato de la lista pasándolo al
lado izquierdo como menor o igual o pasándolo al lado derecho los datos mayores.
2
