Hola a todos, aquí les dejo mi reporte sobre los lenguajes funcionales voy a dar una pequeña introducción de cada uno pero los programas que voy a realizar van a ser en : R y Haskell.
----------------------------------------------------------------------------------------------------------
Lenguaje R
Es un lenguaje utilizado para uso de análisis estadístico y gráfico, es un lenguaje orientado a objetos, es un lenguaje interpretado como java y no compilado como c, c++,etc. Fue desarrollado por Robert Gentleman y Ross Ihaka del Departamento de Estadística de la Universidad de Auckland en 1993. La manipulación de datos en R es muy flexible.
A continuación les mencionare algunas características de R :
- Almacena y manipula efectivamente los datos.
- Utiliza operadores para cálculo sobre variables indexadas como arrays, en particular matrices.
- Tiene una amplia colección de herramientas para análisis de datos.
- Utiliza gráficas para analizar los datos que funcionan directamente sobre pantalla, es decir que al momento que se introducen los comandos se ejecutan directamente.
- Es un lenguaje de programación bien desarrollado, simple y efectivo, incluye condicionales, ciclos, funciones recursivas y posibilidad de entradas y salidas.
Aquí les dejo:
Un Curso básico de R donde te dicen como empezar a utilizar este lenguaje. :)
Aquí les dejo unos ejemplos de cosas que puedes realizar en R :
Una de las cosas que podemos hacer en R es utilizarlo como calculadora y realizar diferentes operaciones aritméticas
Otra cosa que puedes realizar en R es leer datos desde un archivo que ya tengas, por ejemplo yo tengo este archivo de datos.txt en emacs y lo que quiero hacer esque R me lo lea y esto lo realizará con la función read.table
Está es mi base de datos que tengo de calificaciones entonces para que R lo lea en la terminal introduzco lo siguiente : misdatos <- read.table("datos.txt"). En este caso R va a crear un marco llamado misdatos.
Y una última cosa que voy a poner es que en R se pueden realizar gráficas, pero a su vez si quieres para que no solo te quede una sola gráfica en la pantalla puedes dividirla en varias partes para ir colocando las gráficas que quieras y para esto yo utilice la función layout(matrix(1:6, 3, 2)), en donde el 1 marca el principio, el 6 el final osea serán 6 partes y el 3 es de filas y el 2 de columnas.
-----------------------------------------------------------------------------------------------------------
Lenguaje LISP
Les voy a hablar un poco sobre el lenguaje LISP, éste lenguaje fue creado por el profesor John McCarthy como una notación matemática basada en el cálculo lambda, es uno de los lenguajes favoritos utilizados para la inteligencia artificial. El nombre de LISP se deriva de LISt Processing
La lista es el elemento fundamental del lenguaje LISP, las listas estan delimitadas por paréntesis, uno de los motivos por los que LISP es utilizado en la inteligencia artificial es que el código y los datos tengan listas ya que es más sencillo escribir programas capaces de escribir otros programas.
El Lisp trata de manera no destructiva a los elementos que le introducimos, de forma que la mayoría de las funciones nos devuelven una lista que es el resultado de alguna transformación de otra que recibió.
Las estructuras de datos en LISP pueden clasificarse en dos grupos:
- Primitivas: se llaman “átomos” en LISP (“átomo” en griego significa
indivisible).
- Constructores: es la lista, la cual permite estructuras complicadas a partir de
estructuras simples.
Hay al menos dos tipos de átomos:
- Los átomos numéricos tienen la sintaxis de los números (o sea, son dígitos,
posiblemente con un punto decimal).
- Los átomos no numéricos son cadenas de caracteres que se pretendía originalmente
que representaran palabras o símbolos.
Comandos en LISP :
- car : devuelve el primer elemento de una lista.
> (CAR ‘(A B C D))
A
- cdr: devuelve la lista sin su primer elemento.
> (cdr ’(a b c))
(B C)
- cond: ejecuta un flujo de control dependiendo de la condicion si es cierta o no lo es, es parecido al switch en c pero en lisp lo que se pone en los case son condiciones lógicas y no constantes.
> (defun notas (n)
(cond ((< n 5) ’suspenso)
((< n 7) ’aprobado)
((< n 9) ’notable)
(t ’sobresaliente) )) => NOTAS
> (notas 8) => NOTABLE
- cons: añade al principio de una lista dada un elemento.
> (cons ’a ’(b c d))
(A B C D)
- defun: define una función con un nombre el cual será llamado mediante el comando (nombre-función args) y tiene como argumentos una lista de variables.
(defun CUADRADO (x) "Mi funcion cuadrado"
(* x x
)
)
- endp: cierto (T), si la lista está vacia y nil en caso contrario.
(endp '(a b c)) >nil
(endp '())
>T
- eq: se utiliza para saber si dos átomos son iguales.
(eq 3 3) => T
(eq 3 3.0) => NIL
(eq 3.0 3.0) => NIL
(eq (first ’(a b c)) ’a) => T
(eq (cons ’a ’(b c)) ’(a b c)) => NIL
(equal (cons ’a ’(b)) (cons ’a ’(b))) => T
- list: construye una lista a partir de sus elementos.
> (list ’a (+ 1 2) nil)
(A 3 NIL)
> (quote (+ (- 5 2) (* 3 3)))
(+ (- 5 2) (* 3 3))
Aquí les dejo una guía de lisp espero les sea útil :)
-----------------------------------------------------------------------------------------------------------
Lenguaje Scheme
Les hablare un poco sobre el lenguaje Scheme, éste lenguaje fue desarrollado por Guy L. Steele y Gerald Jay Sussman, es el primer dialecto de lisp que útiliza un ámbito estático o léxico.
A continuación les voy a mencionar algunas ventajas y desventajas que existen al utilizar Scheme:
~Ventajas:
- Tiene una sintáxis muy reducida, no necesita reglas de precedencia.
- Utiliza un sistema de macros higiénico que evita colisiones entre los nombres usados en la definición de la macro y en el contexto que ésta se expande.
- Se utilizan procedimientos con objetos de primera clase, y esto permite la definición de funciones de orden superior, que facilitan los programas.
~ Desventajas:
- Como el estándar de Scheme es minimalista y específico provoca que existan muchas implementaciones diferentes.
- Que los procedimientos y variables tengan el mismo espacio de nombres ya que algunas funciones tienen nombres que se utilizan comúnmente para las variables.
- Como el espacio de nombres tiene que ser único y en Scheme no lo es, no se pueden distinguir en uso de una macro o el de una función, entonces si no sabemos cual es la definición de cada uno de los objetos no vamos a poder determinar el orden de evaluación en los programas.
*Elementos de Scheme
1. Para agregar un comentario se inicia con un punto y coma (;) y continúan hasta el final de la línea.
2. Para poder asociar las variables a un valor concreto podemos utilizar define que las variables son visibles en el programa, y cuando utilizamos let es para ver su ámbito reducido.
3. En Scheme hay 3 tipos de igualdad: eq? = es el que devuelve #t si los objetos son exactamente el mismo objeto, eqv? = es muy parecido al eq? solo que trata algunos objetos como caracteres y números de forma especial para que los números que sean iguales eqv? incluso si no son eq?, equal? = es el que compara el contenido de las estructuras de datos tales como listas, vectores y cadenas para determinar si son iguales.
4. En Scheme hay operadores de equivalencia dependientes : string=? = es el que compara dos cadenas, char=? = es el que compara dos caracteres y el = compara números.
-----------------------------------------------------------------------------------------------------------
Lenguaje Haskell
Les hablare un poco sobre este lenguaje, Éste lenguaje funcional fue creado por Haskell Curry. Algunas características que tiene son : el soporte para tipos de datos y funciones recursivas, listas, tuplas y calce de patrones.
~ Algunos valores en haskell
-El tipo Bool
Los valores con este tipo representan expresiones lógicas cuyo resultado puede ser True o False.
Funciones y operadores
- (&&) :: Bool -> Bool -> Bool. Conjunción lógica.
- (||) :: Bool -> Bool -> Bool. Disyunción lógica.
- not :: Bool -> Bool. Negación lógica.
- otherwise :: Bool. Función constante que devuelve el valor True.
-El tipo Integer
Los valores de este tipo son números enteros de precisión ilimitada que tienen las mismas funciones y operadores del tipo Int.
-El tipo Float
Los valores de este tipo son números reales. ( 2010, 23.4 , 5.7 )
Funciones y operadores
- (+), (-), (*), (/), (^):: Float -> Float -> Float. Suma, resta, producto, división real y potencia de exponente entero.
- abs, signum, negate :: Int -> Int. Valor absoluto, signo y negación.
- (**) :: Float -> Float. Potencia de exponente real
-El tipo Double
Los valores de este tipo son números reales, de mayor rango y con aproximaciones más precisas que los de tipo Float.
-El tipo Char
Los valores de este tipo son caracteres que se encuentran en una masa de alta complejidad de en una suma de caracteres dados con su alta definición antes de utilizar esta función en hugs debemos utilizar IMPORT CHAR antes de nuestro algoritmo.
-Tuplas
Los elementos que forman una tupla pueden ser de distintos tipos.
Por ejemplo: ('a',True,3)
-Listas
Los valores de este tipo son una colección de elementos del mismo tipo.
- [Elementos_separados_por_comas] , por ejemplo: [1,2,3,4]
Aquí les dejo unos sencillos programas que hice en haskell
El primero es que te dice cual de los dos números es el máximo, y sí los dos números son iguales te dice "error ambos números son iguales".
Otro programa que realice en Haskell fue uno que te cuenta los dígitos del número que introduzcas.
Y el último que hice fue basandome en éste es parecido solo que en lugar de solo contarte los dígitos, te los suma y te saca el producto entre ellos.
Es todo de mi reporte 4 espero en verdad les sea útil :)
Saludos.
