Menu Close

Categoría: I1M2018

I1M2018: El tipo abstracto de datos de las colas en Haskell

En la primera parte de la clase de hoy del curso de Informática de 1º del Grado en Matemáticas hemos continuado el estudio de los tipos abstractos (TAD) de datos en Haskell y hemos presentados el TAD de las colas siguiendo el esquema usado para el TAD de las pilas.

Se ha comenzado la modelización de las pilas observando la forma de introducir o extraer sus elementos. El resultado de la modelización es la especificación del TAD: su signatura y propiedades características.

A continuación se han estudiados dos implementaciones (una basada listas y la otra en pares de listas) juntos con sus complejidades.

Se ha vuelto a resaltar la forma de conseguir la abstracción de tipos en Haskell mediante módulos y exportación sólo de la signatura.

Finalmente, usando QuickCheck se comprueban las propiedades características del TAD de las colas.

Los apuntes correspondientes a la clase son los del tema 15

I1M2018: El tipo abstracto de datos de las pilas en Haskell

En la primera parte de la clase de hoy del curso de Informática de 1º del Grado en Matemáticas hemos empezado el estudio de los tipos abstractos (TAD) de datos en Haskell.

Después de tratar de la abstracción, los TAD en general y su analogía con las estructuras algebraicas, se ha estudiado el primero de los TAD: las pilas.

Se ha comenzado la modelización de las pilas observando la forma de introducir o extraer sus elementos. El resultado de la modelización es la especificación del TAD: su signatura y propiedades características.

A continuación se han estudiados dos implementaciones (una basada en tipos de datos algebraicos y otra en listas) y las complejidades de las operaciones.

Un punto importante es la forma de conseguir la abstracción de tipos en Haskell mediante módulos y exportación sólo de la signatura.

Finalmente, usando QuickCheck se comprueban las propiedades características del TAD de las pilas.

Los apuntes correspondientes a la clase son los del tema 14

I1M2018: De la matemática a la máquina

En la segunda parte de la clase de hoy del curso de Informática de 1º del Grado en Matemáticas se ha comentado cómo los se pueden representar los conceptos matemáticos en los ordenadores.

Para ello se ha visto cómo la definición de factorial se puede definir en distintos paradigmas desde la matemática al código máquina. Las definiciones consideradas han sido

  • En matemáticas
     n
n! = ∏ k 
    k=1
  • En programación funcional (Haskell).
factorial :: Int -> Int
factorial n = product [1..n]
  • En programación imperativa (C).
int factorial(int n)
{
    int ret = 1;
 
    while (n > 1)
    {
        ret *= n;
        n--;
    }
 
    return ret;
}
  • En ensamblador.
factorial:
    mov rdi, 1
 
  .loop:
    cmp rax, 1
    jle .done
 
    imul rdi, rax
    dec rax
 
    jmp .loop
 
  .done:
    ret
  • En código máquina.
48 bf 01 00 00 00 00 00 00 00 48 3d 01 00 00 00 7e 0c 48 0f af f8 48 ff
c8 e9 ec ff ff ff c3

La exposición se ha basado en el artículo From math to machine: translating a function to machine code de Brian Steffens.

I1M2018: Análisis de la complejidad de los algoritmos

En la primera parte de la clase hoy de Informática de 1º del Grado en Matemáticas se ha explicado el tema de análisis de la complejidad de los algoritmos.

Se empezó explicando la notación de Landau y los órdenes de complejidad. A continuación se presentaron varios ejemplos de definiciones de distintos órdenes. En cada ejemplo, se especificó el problema, se definió la función, se hizo una tabla sobre la variación de los tiempos y su correspondiente gráfica, se extrajeron las ecuaciones en recurrencia, se resolvieron con Wolfram Alpha y se demostró por inducción el orden de la definición.

Como resumen, en la siguiente tabla se muestra los ejemplos presentados

| Ejemplo     | Ecuaciones         | Orden      |
|-------------|--------------------|------------|
| suma        | T(1)   = k         | O(n)       |
|             | T(n+1) = T(n)+k'   |            |
|-------------|--------------------|------------|
| suma2       | T(1) = k           | O(1)       |
|-------------|--------------------|------------|
| sumaDeSumas | T(1)   = k         | O(n²)      |
|             | T(n+1) = T(n)+n    |            |
|-------------|--------------------|------------|
| potencia    | T(1)   = k         | O(log(n))  |
|             | T(n)   = T(n/2)+k' |            |
|-------------|--------------------|------------|
| raiz        | T(0)   = k         | O(2ⁿ)      |
|             | T(n+1) = 2T(n)+k'  |            |
|-------------|--------------------|------------|
| ordenación  | T(1)   = k         | O(nlog(n)) |
| por mezcla  | T(n)   = 2T(n/2)+n |            |

Los apuntes correspondientes a la clase son

I1M2018: Ejercicios de programación de cálculo numérico en Maxima

En la cuarta parte de la clase de hoy de Informática de 1º del Grado en Matemáticas se han comentado las soluciones de los ejercicios de la relación 21, en la que se definen en Maxima funciones para resolver los siguientes problemas de cálculo numérico:

  • diferenciación numérica,
  • cálculo de la raíz cuadrada mediante el método de Herón,
  • cálculo de los ceros de una función por el método de Newton y
  • cálculo de funciones inversas.

Los ejercicios, y sus soluciones, se muestran a continuación.

I1M2018: Cálculo numérico en Haskell (2º parte)

En la tercera parte de la clase de hoy de Informática de 1º del Grado en Matemáticas se han explicado las soluciones de los ejercicios de la relación 20, en la que se definen funciones para resolver los siguientes problemas de cálculo numérico:

  • Cálculo de límites.
  • Cálculo de los ceros de una función por el método de la bisección.
  • Cálculo de raíces enteras.
  • Cálculo de integrales por el método de los rectángulos.
  • Algoritmo de bajada para resolver un sistema triangular inferior.

Los ejercicios, y sus soluciones, se muestran a continuación.