valenrc's blog

conexión SSH desde Windows a Termux

Tue, 04 Mar 2025 00:00:00 +0000

Configuración de un servidor SSH en Termux y conección desde Windows

En este post voy a configurar un servidor SSH en Termux y conectarnos a él desde Windows usando Powershell. Esto es útil para acceder a Termux desde Windows sin tener que usar la terminal de Termux desde el telefono.

SSH server en Termux

Instalar el paquete openssh en Termux, esto instala y configura el servidor SSH automaticamente. La configuración y las claves se encuentran en /data/data/com.termux/files/usr/etc/ssh/.

pkg upgrade && pkg install openssh

Nos conectamos al servidor con USUARIO@IP en el puerto por defecto 8022.

Para obtener el nombre de usuario:

whoami

Para obtener la dirección IP del host: (Buscar la etiqueta wlan0)

pkg install iproute2 && ip addr

iniciar el servidor SSH. Opcionalmente con el flag -d para ver mensajes de debug.

sshd -d

Mas detalles en Termux Wiki - Remote Access

Conectarse al servidor desde Powershell

Usamos el cliente SSH de Windows que viene instalado por defecto en optional features Nos va a pedir una passphrase si es que la configuramos.

ssh <USUARIO>@IP -p 8022

Mas información en SSH in Windows Terminal

Autentificación

La autentificación por defecto es mediante la contraseña del usuario en Termux, pero se puede configurar para que sea mediante una clave pública (mucho mas seguro).

Contraseña

Para cambiar la contraseña de Termux:

passwd

Cada vez que nos conectemos al servidor SSH nos va a pedir la contraseña del usuario.

Clave pública

Tenemos que generar claves en el cliente (Windows) y copiar la clave pública en el host (Termux)

Generar el par de claves en la dirección C:\Users\<USUARIO>\.ssh\ (En powershell)

ssh-keygen -t rsa -b 2048 -f $env:USERPROFILE\.ssh\id_rsa
cat $env:USERPROFILE\.ssh\id_rsa.pub

el comando cat muestra el contenido del archivo, lo copiamos. Ahora hay que pegarlo en el archivo ~/.ssh/authorized_keys en Termux.

Para eso nos conectamos por ssh (ver Conectarse al servidor desde Powershell) y dentro del host (terminal de termux) copiamos el contenido del portapapeles dentro de ~/.ssh/authorized_keys.

Ahora queda deshabilitar la conexión por contraseña en el host: Dentro de termux, ir a /data/data/com.termux/files/usr/etc/ssh/sshd_config, descomentar la linea PasswordAuthentication yes y cambiarla por PasswordAuthentication no.

Listo, ya podemos empezar a usar Termux desde Windows.

Resumen de x86_64 - System V ABI

Mon, 25 Nov 2024 00:00:00 +0000

Resumen de x86_64 y System V ABI para el primer parcial de Arquitectura y Organización de Computadoras

Registros
Registros volátiles (caller saved)
Registros no volátiles (callee saved)
Valores de retorno de funciones
Llamadas a funciones de C
Pasaje de parámetros a funciones
Direccionamiento
Alineación de structs
GDB

Registros

64 bits	32 bits	16 bits	8 bits	Description
rax	eax	ax	al	return value
rbx	ebx	bx	bl
rcx	ecx	cx	cl	4th argument
rdx	edx	dx	dl	3rd argument
rsi	esi	si	sil	2nd argument
rdi	edi	di	dil	1st argument
r8	r8d	r8w	r8b	5th argument
r9	r9d	r9w	r9b	6th argument
r10	r10d	r10w	r10b
r11	r11d	r11w	r11b
r12	r12d	r12w	r12b
r13	r13d	r13w	r13b
r14	r14d	r14w	r14b
r15	r15d	r15w	r15b

Registros volátiles (caller saved)

Pushearlos si se usan en una función y se quiere preservar su valor después de una llamada a otra función:

RAX, RCX, RDX, RSI, RDI, R8, R9, R10, R11, XMM0-15

Registros no volátiles (callee saved)

Pushearlos siempre que se usan desde dentro de cualquier función:

RBX, RSP, RBP, R12, R13, R14, R15

Valores de retorno de funciones

RAX -> enteros/punteros
RAX -> floats

Llamadas a funciones de C

La pila debe estar alineada a 16 bytes (sub rsp, X).
Cuando se entra a una función en asm, la pila siempre está desalineada (alineada a 8 bytes).

Pasaje de parámetros a funciones

Primeros 6 argumentos:

Regsitro	N° arg
RDI	arg1
RSI	arg2
RDX	arg3
RCX	arg4
R8	arg5
R9	arg6

Argumentos siguientes:

se pushean de derecha a izquierda en la pila

Memoria	N° arg
rbp + 8	(rip caller)
rbp + 16	arg1
rbp + 24	arg2
…

Direccionamiento

[ Base + ( Index * Scale ) + Displacement ]
   ^         ^       ^            ^
   |         |       |            |
  RAX       RAX      1        Cte. 32 bits
  ...       ...      2
  R15       R15      4
          (No RSP)   8

Size directives:

BYTE 1 byte 8 bits
WORD 2 bytes 16 bits
DWORD 4 bytes 32 bits
QWORD 8 bytes 64 bits
OWORD 16 btyes 128 bits

Alineación de structs

Cada campo en un struct tiene un requisito de alineacion que por lo general es igual a su tamaño en bytes.

Cada campo debe estar alineado en direcciones de memoria que sean múltiplos de su requisito de alineacion. El compilador puede añadir padding entre los miembros del struct para hacer cumplir estos requisitos de alineación.

Al final, el tamaño total del struct debe ser múltiplo del mayor requisito de alineacion de sus campos, el compilador puede añadir padding al final del struct para hacer cumplir esto, haciendo que el tamaño del struct aumente.

Ejemplo:

typedef struct {
    char a;        // 1 byte
    uint32_t b;    // 4 bytes
    uint16_t c;    // 2 bytes
} example_t;

Asi queda el struct en memoria:

a (1 byte)

Padding (3 bytes)

b (4 bytes)

c (2 bytes)

Padding (2 bytes)

GDB

Machete de gdb: https://macapiaggio.github.io/gdb-guide/

Imprimir registros xmm

p/b $xmmn.f

b: base
- /d: base 10 signed
- /u: base 10 unsigned
- /t: base 2
- /x: base 16
f: formato
- .v4_int32: 4 registros de 32 bits c/u
- .v2_int64: 2 registros de 64 bits c/u
- .v8_int16: 8 registros de 16 bits c/u
- .v16_int8: 16 registros de 8 bits c/u
- .v4_float: 4 registros de single-precision float (32 bits)
- .v2_double: 2 registros de double-precision float (64 bits)

Examinar memoria

x /Nuf expression

N: units to display
u: unit size
- b: byte
- h: halfwords (2 bytes)
- w: words (4 bytes)
- g: giant words (8 bytes)
f: formato
- x: hexa
- d: signed decimal
- u: unsigned decimal
- t: binary
- a: address
- c: char
- f: float

Examinar la pila

Acceder a un elemento específico en [rbp - offset]:

x /1gx $rbp-offset

Imprimir punteros a structs

Ejemplo: rdi tiene un puntero a un struct de tipo struct_t:

p *(struct_t*) $rdi

Imprimir arrays

Arrays de tipos simples

Ejemplo: rdi tiene la direccion de un array de n enteros de tipo uint16_t:

p *(uint16_t(*)[n]) $rdi

Arrays de structs

Ejemplo: rdi apunta a un array de tamaño n de structs de tipo struct_t:

p *(struc_t(*)[n]) $rdi

Arrays de punteros a structs

Ejemplo: rdi es un array de n punteros a structs

p *(struct_t**(*)[n]) $rdi

github copilot gratis siendo alumno de la UBA

Mon, 18 Nov 2024 00:00:00 +0000

Con la llegada del update 1.95 VSCode mejoró notablemente su integración con Github copilot. Y ahora que lo pude probar (al fin), puedo decir que vale la pena totalmente. Aún mas con las restricciones de tokens diarios que imponen ChatGPT o Claude a los usuarios gratuitos.

En este post voy a explicar los pasos que seguí para tener acceso al programa Github Education, con el cual nos dan acceso al Student developer pack. Este pack contiene acceso completo a Copilot totalmente gratis:

Requisitos:

Tener un mail con dominio uba: Preferentemente dc.uba.ar (departamento de computación, i.e. DC), aunque debería funcionar con cualquier mail que GitHub detecte como perteneciente a la Universidad de Buenos Aires (terminado en uba.ar).
Tener un certificado de alumno regular: Se consigue generalemente a través de SIU Guaraní, se genera instantaneamente.

El mail del Departamento de Computación se consigue abriendo ticket en soporte (https://soporte.dc.uba.ar/) y enviando tu LU y certificado de alumno regular.

Lo siguiente va a ser configuar tu cuenta de GitHub en https://github.com/settings/profile:

En Public Profile completar con tu nombre real
En Billing and Plans -> Payment information completar los campos obligatorios (Nombre completo y Ubicación)

Es importante que el nombre coincida con el mismo que aparece en el certificado de la facultad.

Ahora queda enviar la solicitud a Github: Logeate en https://education.github.com/pack, ingresá el mail de alumno de la uba y van a pedirte una foto de tu certificado (en Proof Type elegí la segunda opcion signed transcript o algo así). Si hay algo mal, debería llegar un mail casi al instante de enviar la solicitud. Si no, entonces queda esperar a que llegue un mail de aprobación.

Despues de esto, queda reclamar el beneficio en la pagina principal de Student Developer Pack en la seccion All offers, te va a redirigir a configuración de Copilot y se va a activar automaticamente despues de completar la configuracion (Deshabilita la opcion Allow GitHub to use my code snippets from the code editor for product improvements :p y habilitá Anthropic Claude 3.5 Sonnet in Copilot si está disponible)

Listo, ahora tenemos Copilot + otros beneficios (GitLens, Github Pro, etc, etc)

apuntes de la facultad

Sun, 20 Oct 2024 00:00:00 +0000

Organización del computador

Resumen de assembler x86_64

PLP

Apunte para el primer parcial de PLP

Apunte para el segundo parcial de PLP

Sistemas Digitales

Apunte para el final de Orga I

apunte para el final de Orga I

Sun, 20 Oct 2024 00:00:00 +0000

Apunte para el final de Organización del computador I

- Arq. Von Neumann, Entrada/salida, Memoria –

versión en pdf

1. Contenido

2 Von Neumann

2.1 Que es una arquitectura

2.2 Características del modelo Von Neumann

2.3 Estructura del modelo Von Neumann

2.4 System bus model

2.5 Ciclo de instrucciones

3 Entrada/Salida

3.1 Interfaz de entrada/salida

3.2 Arquitectura de entrada/salida

3.3 Métodos de acceso a E/S

3.3.1 Polling (programmed I/O)

3.3.2 Interrupciones

3.3.3 Mapeo en memoria

3.3.4 Acceso directo a memoria (DMA)

3.3.5 Canal de E/S (Channel-attached I/O)

3.4 Comparación de métodos de acceso a E/S

4 Conversión de señales

4.1 Conversión Analógico/digital

4.1.1 Muestreo de la señal

4.1.2 Cuantificación

4.2 Conversión digital/analógico

5 Memoria

5.1 Introducción a memorias

5.2 Jerarquía de memorias

5.4.1 Principio de localidad

5.4.2 Niveles de caché

5.4.3 Operación de lectura de memoria

5.4.4 Hit rate

5.4.5 Algoritmos de reemplazo de contenido

6 Bibliografia

2. Von Neumann

2.1 Que es una arquitectura

La arquitectura de una computadora se refiere a los atributos de un sistema visibles para un programador, aquellos que tienen un impacto directo en la ejecución lógica de un programa. Estos atributos incluyen: la ISA, el número de bits que se usan para representar los datos, mecanismos de E/S y modos de direccionamiento de la memoria.

El estudio de la arquitectura se encarga de la estructura y el comportamiento de la computadora.

2.2 Características del modelo Von Neumann

Programa Almacenado: mantiene las instrucciones y los datos en una memoria de acceso aleatorio (RAM). Se diferencia de la arquitectura Harvard en que los datos e instrucciones de programa se almacenan en una única memoria.

Cada celda de memoria tiene una dirección: un numero único que la representa.

Los datos y las instrucciones tienen distintos tipos de uso, sin embargo, su estructura no se representa de forma codificada (la memoria no puede saber si en una posición tiene un dato o un comando)

Cada programa se ejecuta de forma secuencial, a menos que se indique lo contrario mediante instrucciones de control de transferencia.

2.3 Estructura del modelo Von Neumann

Consta de tres componentes principales:

Unidad central de procesamiento (CPU): Controla el funcionamiento de la computadora y realiza funciones de procesamiento de datos. Consta de otros cuatro componentes:
- Unidad de control: Se encarga de ejecutar los microinstrucciones que contienen las señales de control de los demás componentes de la CPU.
- Unidad aritmético-lógica (ALU): Realiza las funciones de procesamiento de datos de la computadora.
- Registros: Proporciona almacenamiento interno a la CPU, Pueden ser de propósito específico como el Program Counter o de uso general.
- Interconexión de la CPU: Mecanismo que permite la comunicación entre todos los demás componentes de la CPU
Memoria principal: Almacena los datos y las instrucciones de programas.
Sistema de entrada/salida (I/O): Mueve datos entre la computadora y aparatos externos como sensores o periféricos. Parte de lo que llega de datos a la memoria es resuelto por este subsistema.

La arquitectura tiene la particularidad de que existe un único camino (físico o lógico) desde donde se conecta la CPU con la memoria. En la mayoría de computadoras la velocidad de comunicación ente memoria y procesador es menor a la velocidad a la que puede trabajar el procesador, esto fuerza a la CPU a esperar continuamente a que lleguen los datos desde o hacia la memoria, limitando el rendimiento de la computadora. Esto se conoce como CUELLO DE BOTELLA DE VON NEUMANN.

2.4 System bus model

La arquitectura de Von Neumann se puede extender a un modelo llamado “System bus” o modelo de bus de sistema.
El bus de datos mueve datos desde la memoria principal a los registros de la CPU (y viceversa).
El bus de direcciones contiene la dirección de los datos que el bus de datos está accediendo actualmente.
El bus de control lleva las señales de control necesarias que especifican como se llevara a cabo la transferencia de información.

2.5. Ciclo de instrucciones

La arquitectura de Von Neumann ejecuta programas siguiendo el ciclo de instrucción fetch-decode-execute. Funciona de la siguiente manera:

Fetch: Se obtiene la instrucción almacenada en la dirección de memoria que indica el PC y se incrementa el PC, con la ALU o con un incrementador propio; se traen las instrucciones para que la CPU pueda ejecutarlas.
Decode: Se decodifica la instrucción traída de memoria en un lenguaje que la ALU pueda entender; en caso de que sea necesario, se buscan y obtienen los operandos faltantes desde la memoria y se los coloca en los registros correspondientes para poder realizar la operación.
Execute: La CPU utiliza los distintos componentes internos para procesar la instrucción correspondiente. De ser necesario almacena el resultado en memoria o en registros.

Ciclo de instrucciones

3. Entrada/Salida

3.1 Interfaz de entrada/salida

Los dispositivos de entrada y salida permiten la comunicación bidireccional entre la computadora y el mundo exterior.

Entrada/salida (I/O) es la transferencia de datos entre la memoria principal y varios periféricos de entrada o salida. Los dispositivos de entrada, como teclado y mouse, nos permiten ingresar datos. Los de salida, como monitor o impresora, permiten obtener información de la computadora.

La interfaz de entrada/salida se encarga de esta transmisión de datos, ya que los dispositivos no están conectados directamente a la CPU. La interfaz convierte las señales del sistema de bus a un formato entendible para el dispositivo al cual tiene que llegar. La CPU se comunica con estos dispositivos externos a través de los registros de entrada/salida.

3.2 Arquitectura de entrada/salida

I/O es un subsistema de componentes que transfieren información codificada entre dispositivos externos, la CPU y la memoria.

Los subsistemas de E/S incluyen:

Direcciones de memoria principal exclusivas para funciones de I/O.
Buses que proporciona los medios para mover datos dentro y fuera del subsistema.
Módulos de control dentro de la CPU o dentro de los dispositivos de entrada/salida.
Interfaces para componentes externos como teclados o discos que permiten la transferencia de datos (por ejemplo, un teclado se conecta a través de interfaces como SATA, USB, etc.)
Cableado o enlaces de comunicación entre la CPU y los periféricos.

Modelo de configuración I/O

Los módulos de I/O se encargan de la transferencia de datos desde la memoria principal hacia una interfaz especifica.

Las interfaces están diseñadas para comunicarse con un tipo de dispositivos en particular, como teclados, discos o impresoras. Pueden ser de diferentes tipos como puertos USB, puertos Ethernet, interfaces HDMI, etc. Se diseñan para un propósito específico y para soportar diferentes tipos de periféricos.

3.3 Métodos de acceso a E/S

Los módulos de E/S sirven para comunicar a los dispositivos con el bus de sistema (memoria y CPU).
Los métodos con los cuales los módulos de E/S se comunican con la CPU son cinco:

3.3.1 Polling (programmed I/O):

La CPU monitorea continuamente un registro de control asociado con cada puerto de E/S para determinar cuándo hay datos disponibles y cuando puede realizar operaciones de lectura o escritura.

Ventaja: Se puede controlar mediante código el comportamiento de cada dispositivo, el intervalo y las prioridades de polling.

Desventaja: La CPU queda en un bucle continuo llamado busy waiting y no hace ningún trabajo hasta que hay algún dato de E/S para procesar.

3.3.2 Interrupciones:

En lugar de estar constantemente monitoreando a los dispositivos de E/S, los dispositivos le indican a la CPU cuando tienen datos para enviar e interrumpen su tarea actual.

La CPU también puede decidir si acepta interrupciones o no dependiendo de la tarea que esté procesando.

Cuando se termina de ejecutar la rutina de interrupciones, se reestablece el estado de la CPU, regresa al programa que había sido interrumpido y continua con el ciclo fetch-decode-execute hasta la siguiente interrupción.

La comunicación entre la CPU y los dispositivos se lleva a cabo mediante un controlador de interrupciones, el cual maneja las señales de interrupción de todos los dispositivos de E/S.

Cuando el controlador de interrupciones detecta una señal de interrupción de los dispositivos de E/S conectados, manda una única señal de interrupción que activa una línea de control en el bus de sistema. Por lo general, esta línea de control se conecta directamente a la CPU.

Cada dispositivo de E/S en el sistema tiene acceso a una línea de solicitud de interrupción y el controlador de interrupciones tiene una entrada para cada línea de solicitud de interrupción. Cuando se activa una solicitud de interrupción, el controlador decodifica la interrupción y envía un 1 a la entrada INT del procesador.

Cuando el procesador está listo para procesar la interrupción, activa la señal INTA (Interrupt Acknowledge) que llega al controlador para que pueda desactivar la señal INT.

Cuando dos dispositivos activan su solicitud de interrupción al mismo tiempo, el controlador determina cual tiene prioridad basándose en el diseño del sistema. Las prioridades de interrupción se “cablean” físicamente en el controlador (hardwired), lo que las hace prácticamente imposibles de cambiar.

Ventaja: Libera a la CPU de realizar polling y le permite realizar otras tareas, mejorando el rendimiento y optimizando los recursos y tiempos del procesador.

Desventaja: Es menos simple de implementar y gestionar que el método de polling.

3.3.3 Mapeo en memoria:

Se reserva una porción de memoria para recibir y mandar datos a los dispositivos. Para usarlo, se usan instrucciones de lectura y escritura en memoria. De esta manera, cada dispositivo de E/S tiene su propio bloque de memoria reservado.

La E/S mapeada a memoria se ve exactamente como un acceso a memoria normal desde el punto de vista de la CPU. Esto significa que se pueden usar las mismas instrucciones para mover datos desde y hacia la E/S y la memoria.

Ventaja: Se simplifica enormemente el diseño del sistema.

Desventaja: Se limita el espacio de direcciones disponibles al ser compartido con los dispositivos de E/S y la memoria principal.

3.3.4 Acceso directo a memoria (DMA):

El proceso de E/S se programa en un chip dedicado llamado controlador de DMA, el cual es mucho más sencillo que una CPU.

La CPU delega la ejecución de instrucciones de E/S en el controlador de DMA.

El controlador de DMA toma el control del bus de sistema (bus de direcciones y de datos) sin intervención de la CPU y transfiere los datos entre los dispositivos de E/S y la memoria. Cuando termina, notifica a la CPU con una interrupción para que pueda procesar los datos transferidos.

Ventajas: Libera a la CPU de la transferencia de datos entre los dispositivos de E/S. Aumenta la eficiencia a la hora de transferir grandes volúmenes de datos y al manejar dispositivos de E/S de alta velocidad como controladores de video.

Desventajas: Tener otro chip que se encargue de la E/S es más costoso y agrega complejidad al diseño de la computadora. Además, el CPU es generalmente más rápido que el chip de DMA, por lo que puede hacer el trabajo más rápido.

Configuración de DMA

3.3.5 Canal de E/S (Channel-attached I/O):

La mayoría de computadoras que se usan para aplicaciones más críticas (almacenamiento o procesamiento de datos a gran escala o servidores) utilizan un tipo de interfaz de DMA llamada I/O channel.

El canal de E/S funciona como intermediario entre los dispositivos de E/S y la CPU. Los dispositivos se conectan directamente al canal de E/S.

Los canales de E/S son controlados por procesadores optimizados para E/S llamados I/O processors (IOPs). A diferencia de los controladores de DMA, los IOPs tienen la capacidad de ejecutar instrucciones aritmético-lógicas y de saltos condicionales o branches (bifurcaciones) que permiten controlar directamente a los dispositivos de E/S.

Las instrucciones para el control de los dispositivos y la transferencia de datos son puestos en la memoria por la CPU y ejecutados por los IOPs.

Cada IOP puede controlar varias rutas del canal de E/S, permitiendo el control de varios dispositivos de E/S en un solo IOP.

Ventaja: Mejora el rendimiento de sistemas grandes que requieren una mayor eficiencia al gestionar dispositivos de E/S.

Desventaja: Aumenta notablemente el costo y la complejidad de implementación y mantenimiento.

3.4 Comparación de métodos de acceso a E/S

La Velocidad de cada método de I/O depende del hardware dedicado. Lo que no hace el hardware, lo tendrá que hacer el software.

El hardware dedicado a E/S logra una mayor eficiencia por que libera a la CPU de la mayoría de operaciones que se harían con software.

Método de E/S	Hardware	Software	Velocidad
Polling	*	***	*
Interrupciones	**	**	**
DMA	***	*	***

4. Conversión de señales

La conversión de señales se usa para permitir la interacción entre el mundo físico (analógico) y el mundo digital de las computadoras.

Las señales analógicas son aquellas que varían de manera continua en el tiempo y pueden tener un rango infinito de valores dentro de un intervalo dado. Son generadas por algún fenómeno, con cierta amplitud y frecuencia, que es representable por una función continua.

Las señales digitales son representadas mediante valores discretos (generalmente en forma binaria) donde solamente pueden tener un conjunto finito de valores.

Algunos dispositivos de entrada/salida (sensores, micrófonos, cámaras, etc.) generan señales analógicas, estas señales no pueden ser directamente procesadas por una computadora ya que no hay manera de representar los infinitos posibles valores de estas señales. La manera de poder manipular y procesar las señales analógicas en una computadora es convirtiéndolas a formato digital.

Por otro lado, otros dispositivos necesitan que las señales digitales almacenadas en forma de datos binarios se conviertan a señales analógicas para ser reproducidas por dispositivos de salida, como parlantes o pantallas.

4.1 Conversión Analógico/digital

Diagrama de un conversor A/D

La digitalización de una señal analógica consta de dos etapas: Muestreo de la señal y Cuantificación de las muestras.

4.1.1 Muestreo de la señal:

Consiste en tomar muestras del valor de la señal de forma periódica, el periodo entre dos muestras consecutivas se conoce como periodo de muestreo (Ts) o intervalo de muestreo (Δt) y a partir de este valor se puede calcular la frecuencia de muestreo:

\[Fs = \frac{1}{Δ_t}\]

Teorema del muestreo: Cuando se muestrea una señal analógica x(t), la frecuencia de muestreo debe ser mayor o igual que dos veces el valor de frecuencia máxima Fmax de la señal x(t), para poder reconstruirla a partir de las muestras.

\[Fs ≥ 2*Fmax\]

4.1.2 Cuantificación

Consiste en ajustar el valor real de cada una de las muestras al valor más parecido del conjunto de valores posibles para cada muestra.

La cantidad de bits del conversor A/D determina el rango dinámico (Xmin, Xmáx). Cuando se muestrea una señal analógica, se asigna a cada muestra el valor de amplitud más cercano a la amplitud de la onda original. (por ejemplo, un conversor de 16 bits puede cuantificar una muestra y asignarle un valor digital de entre 216 = 65536 valores posibles). Una profundidad de bits más alta proporciona más valores de amplitud posibles, lo que produce un rango dinámico más grande.

El intervalo Δx está dado por la siguiente formula, donde N es la cantidad de bits del conversor A/D:

\[∆x= \frac{X_{max}-X_{min}}{2^N}\]

4.2 Conversión digital/analógico

Diagrama de un conversor D/A

El conversor digital/analógico realiza el proceso inverso al que realiza el conversor analógico/digital. Se parte de muestras en formato digital (valores discretos) y estas se deben convertir en una señal analógica (valores continuos).

Para cada combinación de los bits de entrada, el DAC proporciona un valor analógico de salida distinto.

La implementación básica de un DAC es mediante un circuito de resistencias ponderadas usando un amplificador operacional en configuración de lazo cerrado.

Cada bit sucesivo en la palabra digital representa un nivel que es dos veces más grande que el bit anterior. La idea es tomar las señales digitales de entradas y asignarles un peso relativo mediante el uso de resistencias (el bit más significativo (MSB) tiene la menor resistencia mientras que el menos significativo (LSB) tiene la mayor resistencia, por lo que el peso del MSB es mayor que el del LSB) para luego sumarlas usando el amplificador operacional y obtener una señal analógica entre 0V y un valor máximo dado por la cantidad de bits y el valor de las resistencias.

5. Memoria

5.1. Introducción a memorias

Las computadoras basadas en la arquitectura de Von Neumann almacenan los programas y los datos en la memoria.

La estructura lógica de la memoria se puede ver como un array lineal de direcciones, desde 0 hasta el tamaño máximo de memoria a la que el procesador puede direccionar.

5.2. Jerarquía de memorias

No todas las memorias son iguales, algunas son mucho menos eficientes que otras (y, por lo tanto, más baratas). Para hacer frente a esta disparidad, los sistemas informáticos actuales utilizan una combinación de tipos de memoria para proporcionar el mejor rendimiento al mejor costo. Este enfoque se llama memoria jerárquica. Cuanto más rápida es la memoria, más cara es por bit de almacenamiento. Mediante el uso de una jerarquía de memorias, cada una con diferentes velocidades de acceso y capacidades de almacenamiento, un sistema informático puede exhibir un rendimiento superior al que sería posible sin una combinación de los distintos tipos.

La memoria se suele clasificar en función de su “distancia” desde el procesador, con la distancia medida por la cantidad de ciclos de máquina necesarios para el acceso. Cuanto más cerca esté la memoria del procesador, más rápida debería ser. Por lo tanto, se utilizan tecnologías más lentas para las memorias más lejanas y tecnologías más rápidas para memorias más cercanas a la CPU.

Los registros son ubicaciones de almacenamiento disponibles en el propio procesador. La memoria caché es una memoria de alta velocidad donde se pueden almacenar temporalmente los datos de la memoria principal utilizados con frecuencia. Esta memoria principal que suele ser de velocidad media es complementada por otra memoria secundaria de mayor tamaño compuesta generalmente por unidades de disco duro o de estado sólido y que contienen datos que la CPU solo puede acceder si se transfieren primero a la memoria principal.

5.3. Tipos de memoria

Existen dos tipos básicos de memoria: ROM (read-only memory) y RAM (random access memory).

5.3.1. RAM

Es el tipo de memoria que se utiliza para la memoria principal de la computadora. Es usada para almacenar los programas y los datos que necesita la CPU para ejecutar programas.

La memoria RAM es volátil, ya que pierde la información almacenada una vez que la computadora deja de recibir energía.

Hay dos tipos generales de chips que se usan para construir memorias RAM: SRAM (RAM Estática) y DRAM (RAM Dinámica)

5.3.1.1. DRAM

En este diseño, un bit se almacena en un capacitor, de manera que un capacitor descargado representa un 0 y un capacitor cargado representa un 1.

La lectura en DRAM es destructiva, al leer un bit el capacitor se descarga y pierde la información, por lo que necesita regenerar la carga para cada lectura.

El capacitor junto con el transistor de acceso, consume muy poca energía en comparación con otras tecnologías.

Celda de DRAM

5.3.1.2. SRAM

Las celdas de SRAM están construidas con circuitos de transistores llamados biestables (flip-flops o latches).

La lectura es directa y no es destructiva ya que se puede leer el estado de un bit sin afectar al estado del circuito.

Es más eficiente que DRAM, pero también mucho más costoso en términos de consumo de energía, ya que contiene más componentes por celda.

Celda de SRAM

5.3.1.3. Comparación entre DRAM y SRAM

Tabla comparativa:

Ram Dinámica (DRAM)	Ram Estática (SRAM)
Consumo mínimo	Alto consumo relativo
Capacidad de almacenamiento comparativamente alta	Capacidad de almacenamiento comparativamente baja
Costo por bit bajo (almacenar un bit es menos costoso que en SRAM)	Costo por bit alto
Tiempo de acceso lento (regeneración de carga por cada lectura)	Tiempo de acceso más rápido
Si se construye el banco de memoria con DRAM no se aprovecha la velocidad del procesador (cuello de botella)	Si se construye el banco de memoria con SRAM el costo y el consumo de la computadora son altos

5.3.2. ROM

La mayoría de computadoras contienen una memoria de solo lectura que sirve para almacenar información crítica (por ejemplo, las microinstrucciones de la unidad de control).

Las memorias ROM no son volátiles, por lo que siempre retienen su información, incluso si se apaga el sistema.

Son también usadas en sistemas embebidos o en cualquier sistema en donde no es necesario cambiar su programación.

Existen cinco tipos básicos de memoria ROM: ROM, PROM (programmable ROM), EPROM (erasable PROM), EEPROM (electrically erasable PROM) y memoria flash.

5.3.2.1. PROM

Es una variación de las memorias ROM en donde la información de un bit depende del estado de un fusible (el valor de fábrica de todos los bits de un PROM es 1; el quemado de cada fusible cambia el valor del correspondiente bit a 0). Una vez programado un PROM, los datos e instrucciones no se pueden cambiar.

5.3.2.2. EPROM

Las memorias EPROM también son programables, pero tienen la característica de que se puede borrar todo su contenido para reprogramarlas (borrar una EPROM requiere un dispositivo especial que emite luz ultravioleta)

5.3.2.3. EEPROM

Las EEPROM eliminan algunas de las desventajas de EPROM ya que no se necesitan herramientas especiales para el borrado de sus datos y solo se puede borrar partes de la información, un byte a la vez.

5.3.2.4. Memoria Flash

Las memorias flash son esencialmente memorias EEPROM con el beneficio adicional de que los datos se pueden escribir o borrar en bloques, eliminando la limitación de un byte a la vez. Esto hace que la memoria flash sea más rápida que EEPROM.

5.4. Memoria caché

Al momento de diseñar la memoria principal, tenemos que lidiar con el problema de la asimetría en la tasa de crecimiento de la velocidad de los procesadores con respecto a la tasa de crecimiento de la velocidad de las memorias.

Como actualmente la velocidad de las memorias no son capaces de seguir el ritmo de la velocidad de los procesadores, se utilizan las memorias caché como una memoria auxiliar que sirven para que el procesador reduzca el tiempo de acceso a datos ubicados en la memoria principal que se utilizan con más frecuencia.

Como la CPU no tiene forma de saber que datos son más probables que se accedan, se utiliza el principio de localidad para transferir los bloques a caché siempre que se haga un acceso a la memoria principal.

5.4.1. Principio de localidad

Para cualquier dato dado, el procesador envía una solicitud a la memoria caché. Si los datos se encuentran en caché (hit), pueden cargarse rápidamente a la CPU. En caso contrario (miss), la solicitud se envía al siguiente nivel más bajo con respecto a la jerarquía de memoria y comienza nuevamente este proceso de búsqueda.

Si los datos se encuentran en el nivel actual, se transfiere todo el bloque en el que residen los datos a la caché.

La idea es que cuando los niveles inferiores responden a una solicitud de los niveles superiores para acceder al contenido de la ubicación X, envían un bloque con el dato de X y los datos ubicados “alrededor” de X (…, X-2, X-1, X, X+1, X+2, …).

Esto se hace porque es probable que los datos adicionales que incluye el bloque sean utilizados por el procesador en un futuro cercano al pedido del dato original, entonces la transferencia del bloque entero ahorra tiempo de acceso.

Hay tres formas de localidad:

Localidad temporal: Los ítems accedidos recientemente tienden a ser accedidos de vuelta en el futuro cercano.
Localidad espacial: Los accesos tienden a agruparse en el espacio de la dirección (por ej. Arrays o ciclos)
Localidad secuencial: Las instrucciones o datos tienden a accederse secuencialmente.

5.4.2. Niveles de caché

Los datos en la memoria caché se alojan en distintos niveles según la frecuencia de uso que tengan. La información puede transferirse entre los distintos niveles de forma inclusiva (se mantiene una copia de los datos en dos o más niveles) o exclusiva (una vez transferidos los datos, se eliminan del nivel de procedencia)

L1 (nivel 1): Se encuentra dentro del procesador y tiene un tamaño y un tiempo de respuesta menor a los siguientes niveles.
L2 (nivel 2): Puede encontrarse dentro o fuera del procesador dependiendo de la arquitectura. Tiene mayor tamaño, pero es más lenta que caché L1. Puede tener una copia de L1 además de información extra o exclusiva.
L3 (nivel 3): Se encuentra fuera del procesador y es más grande y de acceso más lento que L1 y L2. También puede contener una copia de L2.

5.4.3. Operación de lectura de memoria

Resumen de la operación de lectura en memoria de la CPU:

5.4.4. Hit rate

Hit rate= Cantidad de accesos a memoria con presencia en cachéCantidad total de accesos a memoria = hittotal

El hit rate de la memoria caché es la medida de que tan seguido la CPU solicita datos que ya están presentes en la caché en lugar de tener que acceder a la memoria principal.
Idealmente, el hit rate debe ser lo más alto posible ya que indica una utilización eficiente de la caché y una optimización en tiempos de lectura, lo que mejora el rendimiento del sistema.

5.4.4 Algoritmos de reemplazo de contenido

Existen algoritmos para determinar qué datos se eliminan de la memoria caché cuando se necesita liberar espacio para nuevos datos.

La elección del algoritmo depende de factores como el tamaño de la caché o la complejidad de implementación y tiene un impacto directo en el hit rate.

Algunos algoritmos son:

LRU (Least recently used): Elimina los datos que no han sido accedidos durante más tiempo. Se corresponde con el principio de localidad temporal.
LFU (Least frequently used): Elimina los datos que han sido accedidos con menos frecuencia.
Random: Elimina los datos aleatoriamente.
FIFO; Elimina los datos más antiguos de la caché.

6. Bibliografia

Null L., Lobur J. – The essentials of computer organization and Architecture. Capitulos 6 y 7.

All About Circuits - Introduction to Digital-Analog Conversion - Link.

David J. Eck - Introduction to Programming Using Java – Sección 1.1 (The Fetch and Execute Cycle)

James M. Fiore – Operational Amplifiers & Linear Integrated Circuits:

Theory and Application – Sección 12.4 (DACs).

Andrew Scholer – Welcome to CS – Sección 6.5 (Memory Hierarchy)

The FurfiOS Corporation - Resumen Final de Orga 1 (Parte 2).

Ramiro Sánchez Posadas y Martino Simón – Q\&A para final de Orga I.

Diapositivas de las clases teóricas del Dr. Marcelo Risk. ☺

PLP - apunte para el segundo parcial

Sat, 05 Oct 2024 00:00:00 +0000

II. Paradigmas de programación - 1C2024

Resumen para el segundo parcial

LPO, Resolución, Prolog, Smalltalk

Todo el contenido de este archivo es una recopilación/resumen del contenido de las teóricas/prácticas del campus de la materia, que fue transcrito en Latex por mi. Puede contener errores.

versión en pdf

Lógica de primer orden (LPO)

Sintaxis de LPO

Sea P un símbolo de predicado de aridad n y X una variable ligada por los cuantificadores ∀ y ∃, la gramática de la lógica de primer orden es la siguiente:

-- Términos
σ ::= P(t1, ..., tn)  -- Formula atómica
    | ⊥               -- Contradicción
    | σ -> σ
    | σ ∧ σ
    | σ ∨ σ
    | ¬σ
    | ∀X. σ           -- Cuantificación universal
    | ∃X. σ           -- Cuantificación existencial
		
		
-- Ejemplo: (= es un simbolo de predicado) 
σ := succ(X) = Y -> ∃Z. X + Z = Y

Deducción natural

Se extiende la deducción natural de la lógica proposicional a primer orden:

Reglas para el cuantificador universal:

\[\frac{\Gamma \vdash \forall X.\sigma}{\Gamma \vdash \sigma\{X := \text{t}\}}\forall_E \\ \ \\ \frac{\Gamma \vdash \sigma \quad X \notin \text{fv}(\Gamma)}{\Gamma \vdash \forall X.\sigma}\forall_{I}\]

Reglas para el cuantificador existencial:

\[\frac{\Gamma \vdash \exists X.\sigma \quad \Gamma , \sigma \vdash \tau \quad X \notin \text{fv} (\Gamma, \tau)}{\Gamma \vdash \tau}\exists_E \\ \ \\ \frac{\Gamma \vdash \sigma\{\text{X := t}\}}{\Gamma \vdash \exists X.\sigma}\exists_{I}\]

Algoritmo de unificación:

Es el mismo algoritmo de unificación (Martelli-Montanari) para cálculo lambda pero adaptado a términos de primer orden.

Delete
${X\stackrel{?}{=}X} \ \cup E \phantom{llllllllllllllllllllllllllllllll}\to \quad E$
Decompose
$\text{{ f ($t_1,…,t_n$) $\stackrel{?}{=}$ f ($s_1,…,s_n$) } $\cup E$} \quad \to \quad {t_1 \stackrel{?}{=} s_1,…, t_n \stackrel{?}{=}s_n} \cup E$
Swap
${\text{t}\stackrel{?}{=}\ X} \ \cup E \phantom{lllllllllllllllllllllllllllllllll} \to \quad {X \stackrel{?}{=} \text{t} } \cup E$
(Si $\text{t}$ no es una variable)
Elim
${X\stackrel{?}{=}\text{t}} \ \cup E \phantom{lllllllllllllllllllllllll} \to_{{X\ := \ \text{t}}} \quad E’ = E{{ X} := \text{t} }$ (Si $X$ $\notin$ $\text{fv(t)}$)
Clash
${\text{f}(\tau_1, …,\tau_n)\stackrel{?}{=}\text{g}(\sigma_1,…,\sigma_n)} \ \cup \ E \phantom{lll}\to \quad \text{falla}$ (Si $\text{f} \neq \text{g})$
Occurs-Check
${X\stackrel{?}{=}\text{t}} \ \cup E \phantom{lllllllllllllllllllllllllllllllll}\to \quad \text{falla}$ (Si $X \neq \text{t y } X \in \text{fv(t)}$ )

Resolución general para lógica de primer orden

Entrada: fórmula $\sigma$ de LPO Salida: booleano que indica si $\sigma$ es válida

Procedimiento:

Escribir $\neg \sigma$ como conjunto $C$ de claúsulas.
Buscar una refutación de $C$:
- Si existe, el método encuentra alguna.
- Si no, el método puede colgarse.

1. Pasaje a forma clausal

Reescribir $\to$ usando $\boxed{a \to b = \neg a \lor b }$

Pasar a forma normal negada, empujando $\neg$ “hacia adentro”.

Forma normal negada: una fórmula está en FNN si todos sus $\neg$ afectan solo a fórmulas atómicas.

 -- Reglas para pasar a FNP
 ¬(σ ∧ τ)  ->  ¬σ ∨ ¬τ
 ¬(σ ∨ τ)  ->  ¬σ ∧ ¬τ
 ¬¬σ       ->  σ
 ¬∀X.σ     ->  ∃X.¬σ
 ¬∃X.σ     ->  ∀X.¬σ

Pasar a forma normal prenexa, extrayendo $\forall$, $\exists$ “hacia afuera”
- Forma normal prenexa: una fórmula está en FNP si está escrita con únicamente cuantificadores ($\exists$ y/o $\forall$) seguido de una fórmula sin cuantificadores.
```
 -- Reglas para pasar a FNP
 (∀X.σ) ∧ τ  -> ∀X.(σ ∧ τ)
 (∀X.σ) ∨ τ  -> ∀X.(σ ∨ τ)
 (∃X.σ) ∧ τ  -> ∃X.(σ ∧ τ)
 (∃X.σ) ∨ τ  -> ∃X.(σ ∨ τ)
```

Pasar a forma normal de Skolem (eliminar los $\exists$)

Forma normal de Skolem: Una fórmula está skolemizada si está en FNP y solo contiene $\forall$.

 -- Regla para pasar a forma normal de skolem
 ∀X1 ... ∀Xn.∃Y.σ   ->   ∀X1 ... ∀Xn.σ{Y := f(X1,...,Xn)}
 con f un nuevo simbolo de funcion de aridad n>=0

Pasar a forma normal conjuntiva, distribuyendo $\lor$ sobre $\land$.
- Forma normal conjuntiva: Una fórmula está en FNC cuando está escrita enteramente como una conjunción de cláusulas (disyunción de literales).
```
 -- Reglas para pasar a forma normal conjuntiva
 σ ∨ (τ ∧ ρ)   ->   (σ ∨ τ) ∧ (σ ∨ ρ)  
 (τ ∧ ρ) ∨ σ   ->   (σ ∨ τ) ∧ (σ ∨ ρ)
```
“Empujar” los cuantificadores universales hacia adentro de las conjunciones. De esta manera obtenemos un conjunto $C = { k_1,…, k_n}$ que representa una conjunción de cláusulas.

2. Refutación

Regla de resolución para lógica de primer orden:

\[\boxed{\frac{\begin{matrix}\{\color{red}{\sigma_1,...,\sigma_p},\ell_1,...,\ell_n\} \quad \{\color{red}{\neg\tau_1,...,\neg\tau_q},...,\ell_1^{\ '},...,\ell_m^{\ '}\} \\ S = \text{mgu}(\color{red}{\sigma_1} \stackrel{?}{=}... \stackrel{?}{=} \color{red}{\sigma_p} \stackrel{?}{=} \color{red}{\neg\tau_1} \stackrel{?}{=} ...\stackrel{?}{=} \color{red}{\neg\tau_q}) \end{matrix}}{S(\{ \ell_1,...,\ell_n,\ell_1^{\ '},...,\ell_m^{\ '} \})}}\]

(Con $p > 0$ y $q>0$)

Resolución SLD

El método de resolución SLD (Selective Linear Definite) es un método de resolución lineal eficiente que solo puede aplicarse a un conjunto de cláusulas dadas:

Cláusulas de Horn

Son cláusulas de la forma $\forall X_1 \ … \ \forall X_m .\ C$ tal que la disyunción de literales C solamente tiene uno o ningún literal positivo.

Ejemplo : ${P(\text{x}), P(\text{y}), \neg Q(\text{y,z})}$ no es una cláusula de horn ${P(\text{x}), \neg P(\text{y}), \neg Q(\text{y,z})}$ es una cláusula de horn

Cláusulas de definición:

Son cláusulas de la forma $\forall X_1 \ … \ \forall X_m .\ C$ tal que la disyunción de literales C tiene exactamente un literal positivo.

Cláusulas objetivo:

Son cláusulas de la forma $\forall X_1 \ … \ \forall X_m .\ C$ tal que la disyunción de literales C no tiene ningún literal positivo.

Cláusulas de entrada:

Es un conjunto de cláusulas de Horn de la forma $\boxed{H = P \cup {G}}$ $P$: conjunto de cláusulas de definición. (se lo llama programa o base de conocimiento) $C$: cláusula objetivo. (se lo llama goal o meta)

Secuencia de pasos para resolución SLD

Una secuencia de pasos de resolución SLD para un conjunto de cláusulas de Horn $H$ (cláusulas de entrada) es una secuencia de cláusulas objetivo de la forma: $<N_0, N_1, …,N_p>$ tal que satisfacen las siguientes condiciones:

$N_0 \in H$ ($N_0$ es la única cláusula objetivo de H).
Para todo $0 < \text{i} < \text{p}$, si $N_{\text{i}}$ es: $\phantom{llllllllllllllllllllllll}{\neg A_{1},…,\neg A_{k-1},\neg A_{k},\neg A_{k+1},…,\neg A_{n}}$o Entonces hay alguna cláusula de definición $C_{\text{i}}$ de la forma ${A, \neg B_1,…,\neg B_m}$ en $H$, tal que $A_{\text{k}}$ y $A$ son unificables con MGU S y $N_{\text{i+1}}$ es: $\phantom{llllllllllllllllllll}S{(\neg A_{1},…,\neg B_{1},…,\neg B_{m}, \neg A_{k+1},…,\neg A_{n})}$

En resumen:

Resolvemos la cláusula objetivo $N_{\text{i}}$ con las cláusulas de definición en $H$.
El resultado es otra cláusula objetivo $N_{\text{i+1}}$.
Repetimos el proceso hasta llegar a $N_{\text{p}} = \varnothing$.
El resultado es la sustitución compuesta de todas las sustituciones que se fueron realizando

La regla es la siguiente:

\[\boxed{\frac{ \overbrace{ {\{\color{red}A, \neg B_{1},...,\neg B_{n} \}}}^{\text{definición}} \quad \overbrace{\{\neg A_{1},...,\neg A_{k-1},\color{red}{\neg A_{k}},\neg A_{k+1},...,\neg A_{m}\}}^{\text{objetivo}}}{\underbrace{S(\{\neg A_{1},...,\neg A_{k-1},B_{1},...,\neg B_{n},\neg A_{k+1},...,\neg A_{m} \})}_{\text{nuevo objetivo}}}}\]

Con $S$ = $\text{mgu}{\color{red}A \stackrel{?}{=}\color{red}{A_k}}$

La resolución es SLD cuando:

La estrategia es lineal (utilizando en cada paso el resolvente obtenido en el paso anterior)
Se usan solamente cláusulas de Horn.
Se empieza por una cláusula objetivo.
La selección es binaria (un literal de cada cláusula)
La resolvente (nuevo objetivo) es una nueva cláusula objetivo

Prolog

Semántica de Prolog

Un programa en Prolog es un conjunto de cláusulas de definición. Una consulta en Prolog es una cláusula objetivo.

% Ejemplo:
% Para las siguientes clausulas:

% {a(0,X,X)}
% {a(s(X),Y,s(Z)) , ¬a(X,Y,Z)}

% {¬a(s(0),X,s(s(0)))}      %% goal

% el programa en prolog es el siguiente:
a(0,X,X).
a(s(X),Y,s(Z))) :- a(X,Y,Z).

?- a(s(0),X,s(s(0)))        %% consulta

La ejecución de un programa se basa en la resolución SLD. Criterio de búsqueda: busca las cláusulas objetivo por orden de aparición (desde la primera hasta la última) haciendo DFS. Criterio de selección: elegir siempre el primer literal de la cláusula objetivo elegida.

Predicados

sort, msort, length, nth1, nth0, member, append, last, between, is_list, list_to_set, is_set, union, intersection, subset, subtract, select, delete, reverse, atom, number, numlist, sum_list, flatten.

sort(+List, -Sorted)
% ordena List de forma creciente, remueve duplicados
msort(+List, -Sorted)
% igual a sort pero no elimina repetidos
length(?List, ?Length)
% true si Length representa la cantidad de elementos en List
nth1(?Index, ?List, ?Elem)
% true si Elem es el n(Index)-esimo elemento de List
nth0(?Index, ?List, ?Elem)
% igual que nth1 pero indexa desde cero
member(?Elem, ?List)
% true si Elem pertenece a List
append(+ListOfLists, ?List)
%concatena en List todas la listas que pertenecen a ListOfLists
append(?List1, ?List2, ?List1AndList2)
% List1AndList2 es la concatenacion de List1 y List2
between(+Low, +High, ?Value)
% Value se unifica con todos los valores entre Low y High
subset(+SubSet, +Set)
% true si SubSet es un subconjunto de Set (todo elemento en SubSet pertenece a Set)
subtract(+Set, +Delete, -Result)
% elimina todos los elementos de Delete que se encuentren en Set (todas las apariciones)
select(?Elem, ?List1, ?List2)
% true si List2 resulta en eliminar una aparicion de Elem en List1
atom(@Term)
% true si Term esta ligado a un átomo
numlist(+Low, +High, -List)
% List es una lista creciente [Low, Low+1, ..., High]
sum_list(+List, -Sum)
% Sum es la suma de todos los elementos de List
flatten(+NestedList, -FlatList)
% FlatList es el resultado de aplanar la lista de listas NestedList

Motor aritmético de Prolog

Predicados:

between(+Low, +High, ?Value)
% Value se unifica con todos los valores entre Low y High
succ(?Int1, ?Int2)
% true si Int2 = Int1 +1 , alguno de los dos arg. debe estar instanciado
plus(?Int1, ?Int2, ?Int3)
% true si Int3 = Int1 + Int2, al menos 2 de los 3 arg. debe estar instanciado
divmod(+Dividend, +Divisor, -Quotient, -Remainder)
% computa el cociente y resto de Dividend/Divisor

Operadores

% Evaluan de ambos lados las expresiones
+Expr1 > +Expr2
+Expr1 < +Expr2
+Expr1 =< +Expr2
+Expr1 >= +Expr2
+Expr1 =\= +Expr2
+Expr1 =:= +Expr2

-Number is +Expr
% true si Number es el valor el cual Expr evalúa
% solo se evalúa Expr

+IntExpr1 mod +IntExpr2
% Res = IntExpr1 modulo IntExpr2
+IntExpr1 rem +IntExpr2
% Res = resto de la IntExpr1 // IntExpr2
+IntExpr1 // +IntExpr2
% division entera
+IntExpr1 gcd +IntExpr2
% maximo comun divisor
+IntExpr1 lcm +IntExpr2
% minimo comun multiplo
abs(+Expr)
% valor absoluto
max(+Expr1, +Expr2)
min(+Expr1, +Expr2)

Meta-predicados

**not**(:Goal)
% true si Goal no puede ser satisfacido

Smalltalk

Objetos

Un objeto es una entidad con:

Estado
Comportamiento
Identidad

Ejemplo:

Un objeto ‘archivo’ es una entidad que consta de:

Estado: dirección, contenido
Comportamiento: mostrar contenido, cambiar su contenido, renombrar
Identidad: cada archivo es distinto uno del otro

Mensajes

Los objetos se comunican a través de mensajes, cada mensaje invoca un método.

Distintos objetos pueden “entender” el mismo mensaje, pero pueden tener distinta respuesta a determinado mensaje.

aWindow open
aFile open
aZip open

Un mensaje tiene receptores y colaboradores.

objeto mensaje: colaborador

!Ejemplos:
aCar goTo: aLocation
aWindow open
aFile open

Métodos

Un método es una secuencia de instrucciones a ser ejecutadas por el receptor de un mensaje. Operan con los datos encapsulados en los objetos y pueden modificar el estado de un objeto o realizar otras operaciones.

Clase >> nombre_método
   ...
   ... (def del metodo)

En resumen: Mensaje: Indican a un objeto QUE hacer. Método: Indican a un objeto COMO implementar determinado mensaje.

Clases

Una clase es una plantilla o molde a partir de la cual se crean instancias de un objeto. Definen las variables y el comportamiento de todas sus instancias. Una clase puede heredar características de otras clases. Las clases también son objetos, por lo que pueden recibir mensajes y tener su propio comportamiento.

-- La respuesta de la clase Car al mensaje new es una nueva instancia de Car
Car new
>>> aCar 

Pseudo-variables

Son variables que vienen predefinidas en Smalltalk y no pueden ser redefinidas.

self: se refiere siempre al objeto del método en donde se define, se pueden enviar mensajes a self y puede ser enviado como colaborador de otros mensajes Ejemplo:

self computeTaxes

phoneBook at:self put: i

super: se refiere al mismo objeto que self (self == super). La diferencia está en que cuando super recibe un mensaje, la búsqueda del método empieza en la superclase de la clase que contiene el método que se está definiendo. Ejemplo:

Cuando se envíe el mensaje show a una instancia de BorderedPanedWindow, va a buscar el método en su propia clase, como no lo encuentra, sigue buscando en su superclase (PanedWindow), donde efectivamente lo encuentra. Evalúa super show, buscando el método show primero en la superclase de PanedWindow (el objeto receptor sigue siendo aBorderedPanedWindow). Encuentra show en Window y evalúa self drawBorder (Ahora la búsqueda empieza en la clase del objeto al que se refiere self, o sea, BorderedPanedWindow).

-- Jerarquía:
-- Window --> PanedWindow --> BorderedPanedWindow

Window
	show
		self drawBorder
		self showTitle
	
PanedWindow
	show
		super show
		self showPanes
		
BorderedPanedWindow
	drawBorder

nil: **es la única instancia de la clase UndefinedObject. Todas las variables de instancias, clases, y variables locales son inicializadas como **nil.

Block closures

Un bloque es una función anónima. Es evaluada al enviarle el mensaje #value, #value:, #value:value:, #value:value:value, #value:value:value:value (solo hasta cuatro parámetros) o #valueWithArguments: (cualquier número de parámetros, el colaborador es un array de parametros). También pueden ser pasados como colaboradores de otros mensajes (como cualquier objeto)

Ejemplos:

[:x | 1 + x] value: 2
-> 3

|z|
[:x :y | z:= x + y. z+1] value:3 value:5
-> 9

| n m |
n := 60
m := 45
(1 to n) select: [:d | n//d == 0].
-> #(1 2 3 4 5 6 10 12 15 20 30 60)

Condicionales y estructuras de control

If Hay tres mensajes para el condicional if: #ifTrue: - #ifFalse: - #ifTrue:ifFalse: Los colaboradores de los tres mensajes deben ser block closures. Ejemplo:

  -- Codigo en java/c++
  if(x>y){
  	max = x;
  	i = j
  }else{
  	max = y;
  	i = k
  }
    
  -- Codigo en smalltalk
  (x>y) ifTrue: [max := x. i := k] ifFalse : [max := y. i := k]

While Dos mensajes: #whileTrue:, #whileFalse: La expresión condicional tiene que estar en un bloque debido a que en cada iteración vamos a tener que reevaluarla.

-- Codigo en c++/java
while(i<100){
	sum = sum + 1;
	i = i + 1;
}

-- Codigo en smalltalk
[i < 100] whileTrue: [sum := sum + i. i := i+1]

For Dos tipos de mensajes (aunque hay más mensajes que implementan estructuras similares): #to:do: - #timesRepeat:

-- Codigo en c++/java
for(i = 0; i<n; i++){
	sum = sum + i
}

-- Codigo en smalltalk
|sum n|
sum := 0
n := 5
1 **to**: n **do**: [:i | sum := sum + i]

sum := 0
n:= 1
5 **timesRepeat**: [sum := sum+n. n := n + 1]

Colecciones

Collection
	|__ Bag                     -- coleccion no-ordenada - permite repetidos
	|__ Set                     -- coleccion no-ordenada - no hay repetidos
	|   |__ Dictionary
	|
	|__ SequenceableCollection  -- collecciones ordenadas
			|__ SortedCollection    -- internamente ordenadas
			|__ OrderedCollection   -- ordenadas por aparicion
			|__ Interval
			|__ ArrayedCollection   -- ordenadas por indice
					|__ Array
					|__ String

Principales métodos en la clase Collection:

add: newObject
	"añade newObject al receptor del msj"
	
addAll : aCollection
	"añade todos los objetos en aCollection al receptor del msj"
	
remove: oldObj
	"elimina oldObj del receptor del msj"

remove: oldObj ifAbsent: aBlock
	"elimina oldObj, evalua aBlock si no encuentra oldObj en el receptor del msj"

removeAll: aCollection
	"elimina todos los objetos de aCollection en el receptor del msj"

isEmpty
	"true si la colleccion está vacía"

size
	"devuelve la cantidad de objetos en la colección"
	
	
do: aBlock
	"aplica aBlock para cada elemento"

collect: aBlock
	"devuelve una nueva coleccion aplicando aBlock a cada elemento"
	
select: aBlock
	"devuelve una nueva colleccion con los elementos que devuelven true segun aBlock"

otros: reject, inject, detect

Ejemplos:

|col arr sum|
col := OrderedCollection new.

col size.
	-> 0

col add: 4; add: 5.
col
	-> #(4 5)

sum := 0.
#(1 3 4) do: [:e | sum := sum + e].
sum.
	-> 8

#(1 2 3) collect: [:e | e + 10].
	-> #(11 12 13)
	
#(47 29 12 1 89 37845 12 94 58) select: [:e | e \\ 2 == 0].
	-> #(12 12 94 58)

arr := Array new: 5
arr at: 1 put: 23
arr
	-> #(23 nil nil nil nil)

PLP - apunte para el primer parcial

Sat, 05 Oct 2024 00:00:00 +0000

Paradigmas de Lenguajes de Programación 1C2024

Resumen para el primer parcial

Todo el contenido de este archivo es una recopilación/resumen del contenido de las teóricas/prácticas del campus de la materia, que fue transcrito en Latex por mi. Puede contener errores.

versión en pdf

Haskell

Tipos de datos algebraicos

En general, los tipos de datos algebraicos tienen la siguiente estructura:

Los constructores base NO reciben parámetros de tipo T.

Los constructores recursivos reciben al menos UN parámetro de tipo T.

Definición inductiva de T: Los valores de tipo T solamente se pueden construir aplicando una cantidad finita de constructores base y/o recursivos del mismo tipo T.

data T =  casoBase1 <parametros>
	| casoBase2 <parametros>
	...
	| casoBaseN <parametros>
						
	| casoRecursivo1 <parametros>
	| casoRecursivo2 <parametros>
	...
	| casoRecursivoN <parametros>
				

Recursión estructural

Dada una función g : T → Y definida por ecuaciones:

g(Cbase1 <parametros>)       = <caso base1>
g(Cbase2 <parametros>)       = <caso base2>
...
g(CbaseN <parametros>)       = <caso baseN>

g(Crecursivo1 <parametros>)  = <caso recursivo1>
g(Crecursivo2 <parametros>)  = <caso recursivo2>
...
g(CrecursivoN <parametros>)  = <caso recursivoN>

g está dada por recursión estructural si cumple:

Cada caso base devuelve un valor fijo
Cada caso recursivo se escribe combinando:
1. Los parámetros del constructor que NO son de tipo T (sin usar los parámetros del constructor que son del tipo T).
2. El llamado recursivo sobre cada parámetro de tipo T (sin hacer otros llamados recursivos).

Ejemplo de recursión estructural:

data AB a = Nil | Bin (AB a) a (AB a)
							  
-- Funcion que abstrae el esquema de recursion estructural en arboles binarios:
foldAB :: b -> (b -> a -> b -> b) -> (AB a) -> b
foldAB cNil cBin Nil = cNil
foldAB cNil cBin (Bin izq r der) = 
	cBin (foldAB cNil cBin izq) r (foldAB cNil cBin der)
	
-- Ejemplo de uso: sumar todos los elementos del arbol 
sumAB :: (Num a) => AB a -> a
sumAB = foldAB 0 (\recI r recD -> recI + r + recD)

mapAB :: (a->b) -> AB a -> AB b
mapAB fMap = foldAB Nil (\recI r recD -> Bin recI (fMap r) recD)

Recursión primitiva

Dada una función g : T → Y

g está dada por recursión primitiva si cumple:

Cada caso base devuelve un valor fijo
Cada caso recursivo se escribe combinando:
1. Todos los parámetros del constructor del tipo T (incluyendo a los que son de tipo T)
2. El llamado recursivo sobre todos los constructores recursivos (sin hacer otros llamados recursivos)

Recursión iterativa

— TO-DO (en el parcial entra recursión estructural sobre tipos algebraicos)

Inducción estructural

Queremos demostrar que ciertas expresiones son equivalentes

Para eso debemos asumir lo siguiente:

Trabajamos con estructuras de datos finitas: tipos de datos inductivos
Trabajamos con funciones totales:
1. Las ecuaciones deben cubrir todos los casos.
2. La recursión siempre debe terminar.
El programa no depende del orden de las ecuaciones.

Principio de reemplazo

Sea e1 = e2 una ecuación dentro del programa. Las siguientes operaciones preservan la igualdad de expresiones:

Reemplazar cualquier instancia de e1 por e2
Reemplazar cualquier instancia de e2 por e1

Si una igualdad se puede demostrar solo por principio de reemplazo, decimos que la igualdad vale por definición.

A veces conviene dar nombre a todas las ecuaciones del programa para saber cuál ecuación se utilizó para reemplazar una instancia por otra.

Ejemplo:

sucesor :: Int -> Int
-- tenemos una igualdad de la forma e1 = e2
sucesor n = n+1      -- {SUC}

-- sucesor (factorial 10) + 1
-- ((factorial 10) + 1) + 1        (por SUC. reemplazo e1 por e2)
-- sucesor (factorial 10 + 1)      (por SUC. reemplazo e2 por e1)

Inducción sobre booleanos

Si $P(True)\ \text y\ P(False)$ entonces: $∀x :: Bool.\enspace P(x)$

Ejemplo:

\[\text{Para probar}\ \forall x::Bool.\text\ {not (not\ x) = x} \\\text{Basta con probar: }\\ \text{1. P(True): not(not True) = True}\\ \text{2.P(False): not(not False) = False}\]

Ahora podemos usar principio de reemplazo usando las siguientes ecuaciones para probar 1 y 2:

not True  = False   -- {NT}
not False = True    -- {NF}

Inducción sobre pares

Ejemplo:

\[\text{Para probar}\ \forall p::(a,b).\text{\ fst p = snd (swap p)} \\\text{Basta con probar: }\\ \forall x::a. \forall y::b.\ \text{fst (x,y) = snd (swap (x,y))}\]

Y para probar esto podemos usar ppo. de reemplazo usando, por ejemplo, las siguientes ecuaciones dadas:

fst (x,_)   =  x      -- {FST}
snd (_,y)   =  y      -- {SND}
swap (x, y) = (y, x)  -- {SWAP}

Inducción sobre naturales

-- Usamos la siguiente representacion de numeros naturales
data Nat = Zero | Suc Nat

Inducción estructural

Para probar una propiedad $P$ sobre todas las instancias de tipo $T$, basta probar $P$ para cada uno de los constructores (asumiendo como H.I que se cumple para los constructores recursivos)

Tenemos un tipo de datos inductivo de la forma:

data T =  casoBase1 <parametros>
	| casoBase2 <parametros>
	...
	casoBaseN <parametros>
						
	| casoRecursivo1 <parametros>
	| casoRecursivo2 <parametros>
	...
	| casoRecursivoM <parametros>

Ejemplo: Inducción sobre árboles binarios

data AB a = Nil | Bin (AB a) a (AB a)

\[\text{Sea} \ P \text{\ una propiedad sobre expresiones de tipo AB tal que:} \\- \ P(\text{Nil})\\ -\ \forall i::(AB \ \text{a}). \ \forall r:: \text{a}.\ \forall d:: (AB\ \text{a}). \\ (P(i) \land P(d)) \implies (P(\text{Bin} \ i \ r \ d)) \\ \ \\ \text{Entonces} \ \forall x::AB\ a. \ P(x)\]

Ejemplo: Inducción sobre listas

data [a] = [] | a : [a]

\[\text{Sea} \ P \text{\ una propiedad sobre expresiones de tipo [a] tal que:} \\- \ P(\text{[ ]})\\ -\ \forall x::\text{a} . \ \forall xs:: \text{[a]}. \ (P(xs) \implies P(x:xs)) \\ \ \\ \text{Entonces} \ \forall xs:\text{[a]}. \ P(xs)\]

Extensionalidad

Extensionalidad para pares

(se prueba mediante ppo. de inducción estructural)

Extensionalidad para sumas

data Either a b = Left a | Right b

Principio de extensionalidad funcional

Sea $\text{f, g :: \ a} \to \text{b}$

Para probar una igualdad de tipo $\text{f = g}$ basta con probar que vale $\text{f x = g x}$ para todo $\text{x}$ del dominio de las funciones $\text{f}$ y $\text{g}$. (Son iguales punto a punto)

Calculo lambda

Calculo lambda puro (sin tipos) extendido con booleanos

-- Sintaxis (términos)
M := x                     -- Variables 
	| λx.M                 -- Abstraccion
	| M M                  -- Aplicacion
		
	| true
	| false
	| if M then M else M
		
-- Semantica (reglas de reduccion)
Si M -> M' entonces:
	M N  ->  M' N
	N M  ->  N M'
	λx.M ->  λx.M'
	
	if M then N else O -> if M' then N else O
	

Calculo lambda tipado. $\lambda ^{BN}$

Se agregan los siguientes tipos:

Funciones
Booleanos
Naturales

Es determinista: estrategia Call-by-value (evaluar primero los argumentos antes de pasarlos a la función).

$\lambda (x.M)\, V $ reduce solo cuando V está en forma normal (no existe V’ tal que V → V’)

Sintaxis del cálculo lambda tipado $\lambda ^{BN}$

-- Términos
M ::=  x 
	| λx:σ. M
	| M M 
	| true
	| false
	| if M then M else M
	| zero 
	| suc(M)
	| pred(M)
	| isZero(M)
		
-- Tipos
σ ::= Bool      -- Booleanos
	| Nat       -- Naturales
	| σ -> σ    -- Funciones

Reglas de tipado de $\lambda ^{BN}$

Cada término tiene su propia regla de tipado.

\[\frac{}{\Gamma, x : \sigma \vdash x:\sigma}ax_v \\ \ \\ \frac{\Gamma, x:\sigma \vdash M:\tau}{\Gamma \vdash \lambda x:\sigma .M \ :\sigma \to \tau}\to_i \quad \frac{\Gamma \vdash M:\sigma \to \tau \quad \Gamma \vdash N:\sigma}{\Gamma \vdash MN : \tau}\to_e \\ \ \\ \frac{}{\Gamma \vdash \text{true} : Bool}ax_{true} \quad \frac{}{\Gamma \vdash \text{false}:Bool}ax_{false} \\ \ \\ \frac{\Gamma \vdash M:Bool \quad \Gamma \vdash P:\sigma \quad \Gamma \vdash Q:\sigma}{\Gamma \vdash \text{if M then P else Q : }\sigma}\text{if} \\ \ \\ \frac{}{\Gamma \vdash \text{Zero : Nat}}\text{zero} \quad \frac{\Gamma \vdash M : \text{Nat}}{\Gamma \vdash \text{isZero(M) : }Bool}\text{isZero} \\ \ \\ \frac{\Gamma \vdash \text{M : Nat}}{\Gamma \vdash \text{pred(M) : Nat}}\text{pred}\quad \frac{\Gamma \vdash \text{M : Nat}}{\Gamma \vdash \text{succ(M) : Nat}}\text{succ}\]

Semántica del cálculo lambda tipado $\lambda ^{BN}$

Valores: Son los términos M los cuales están en forma normal y además FV(M) = ∅

Semántica operacional (small-step):

Las reglas de cómputo nos dan el significado de los términos al definir como operan.

Las reglas de congruencia permiten reducir subtérminos. (Términos que están dentro de otros términos)

-- Valores
V  ::=  true
	| false
	| λx:σ.M
	| zero
	| succ(V)
		
-- Semantica operacional:
	-- Reglas de cómputo
{β}       - (λx:σ.M) V             -> M{x := V}
{if_t}    - if true then M else N  -> M
{if_f}    - if false then M else N -> N
{pred_}   - pred(succ(V))          -> V
{isZero0} - isZero(zero)           -> true
{isZeroN} - isZero(succ(V))        -> false 

	-- Reglas de congruencia
	-- Si M -> M' entonces:
{u}       - M N                 -> M' N
{v}       - V M                 -> V M'
{ifC}     - if M then N else O  -> if M' then N else O
{succC}   - succ(M)             -> succ(M')
{predC}   - pred(M)             -> pred(M')
{isZero}  - isZero(M)           -> isZero(M')

Captura de variables (sustituciones)

$M{x:=N}$ significa sustitución sin captura de variables de las ocurrencias libres de x en M por N. Se define por inducción en M:

x{x := N}        = N
y{x := N}        = y
(λx:σ.M){x := N} = M{x := N}                -- No puedo sustituir x porque no está libre
(λy:σ.M){x := N} = λy:σ.(M{x := N})          -- Si y ∉ FV(N)
(λy:σ.M){x := N} = λz:σ.(M{y := z}{x := N})  -- Si y ∈ FV(N), z ∉ FV(N)
(M O){x := N}    = (M{x := N})(O{x := N}) 

true{x := N}                  = true
false{x := N}                 = false
zero{x := N}                  = zero
(if M then O else P){x := N}  = (if M{x := N} then O{x := N} else P{x := N}) 
succ(M){x := N}               = succ(M{x := N})
pred(M){x := N}               = pred(M{x := N})
isZero(M){x := N}             = isZero(M{x := N})

Inferencia de tipos

Un término $U$ sin anotaciones de tipo es Tipable si y solo si existen:

Un contexto de tipado $\Gamma$
Un término con anotaciones de tipos $M$
Un tipo $\tau$

Tales que erase(M) = U y $\ \Gamma \vdash M : \tau$

Donde erase(M) es el término sin anotaciones de tipos que resulta de borrar las anotaciones de tipos de M.

Problema de inferencia de tipos

Dado un término $U$, determinar si este es tipable.
En caso de que $U$ sea tipable:
- hallar un contexto $\Gamma$, un término $M$ y un tipo $\tau$ tales que erase(M) = U y $\ \Gamma \vdash M : \tau$

Se resuelve con algoritmo $W$ de inferencia de tipos.

Algoritmo de unificación de Martelli-Montanari

Unificación: Problema de resolver sistemas de ecuaciones entre tipos con incógnitas.

Definición:

Dado un problema de unificación $E$:

Mientras $E \neq \varnothing$, se aplica sucesivamente alguna de las seis reglas de unificación
La regla puede resultar en una falla
De lo contrario, la regla es de la forma $E \to_S E’$ La resolución del problema E se reduce a resolver otro problema $E’$ aplicando la sustitución $S$.

Si $E = E_0 \to_{S_1} E_1 \to_{S_2} E_2 \to … \to_{Sn} E_n \to_{Sn+1} \text{falla}$ En tal caso, el problema de unificación $E$ no tiene solución.

Si $E = E_0 \to_{S_1} E_1 \to_{S_2} E_2 \to … \to_{Sn} E_n \to_{Sn+1} E_n = \varnothing$ En tal caso, el problema de unificación $E$ tiene solución.

Reglas:

Delete
$ {x\stackrel{?}{=}x } \ \cup E \to \quad E$
Decompose
${C(\tau_1, …,\tau_n)\stackrel{?}{=}C(\sigma_1,…,\sigma_n)} \ \cup \ E \quad \to \quad { \tau_1 \stackrel{?}{=} \sigma_1,…, \tau_n \stackrel{?}{=}\sigma_n} \ \cup \ E$
Swap
${\tau\stackrel{?}{=}\ {?n}} \ \cup E \to \quad {?n \stackrel{?}{=} \tau} \cup E$
(Si $\tau$ no es una incógnita)
Elim
${?n\stackrel{?}{=}\tau} \ \cup E \to_{{?n\ := \ \tau}} \quad E’ = {{?n} := \tau }(E)$ (Si ?n no ocurre en $\tau$)
Clash
${C(\tau_1, …,\tau_n)\stackrel{?}{=}C(\sigma_1,…,\sigma_n)} \ \cup \ E \phantom{lll}\to \quad \text{falla}$ (Si $C \neq C’)$
Occurs-Check
${?n\stackrel{?}{=}\tau} \ \cup E \to \quad \text{falla}$ (Si $?n \neq \tau \; \text{y} \; ?n$ ocurre en $\tau$)

Corrección del algoritmo de Martelli-Montanari

El algoritmo termina para cualquier $E$
Si $E$ no tiene solución, el algoritmo $\text{falla}$
Si $E$ tiene solución, el algoritmo llega a: $\boxed{E = E_0 \to_{S_1} E_1 \to_{S_2} E_2 \to … \to_{Sn} E_n \to_{Sn+1} E_n = \varnothing }$ Y además: $\boxed{S = S_n\ \circ \ … \ \circ S_2 \ \circ S_1}$ Es el unificador más general posible (mgu)

Algoritmo W de inferencia de tipos

Recibe un término $U$ sin anotaciones de tipos. Procede recursivamente sobre la estructura de $U$:

Si falla, entonces $U$no es tipable.
Si tiene éxito: Devuelve una tripla ($\Gamma$, $M$, $\tau$) tal que: erase($M$) = $U$ y $\Gamma \vdash M : \tau$ es válido.

Escribimos $W(U) \rightsquigarrow \Gamma \vdash M : \tau$ para indicar que el algoritmo de inferencia tiene éxito cuando se le pasa U como entrada y devuelve una tripla $(\Gamma, M, \tau)$.

Reglas:

\[\frac{}{W(\text{True}) \rightsquigarrow \varnothing \vdash \text{True : Bool}} \\ \ \\ \frac{}{W(\text{False}) \rightsquigarrow \varnothing \vdash \text{False : Bool}} \\ \ \\ \frac{?k \text{\ es una incógnita fresca}}{W(x) \rightsquigarrow x : \ ?k \vdash x: \ ?k} \\ \ \\ \frac{\begin{matrix}\Large\substack{W(U_1) \rightsquigarrow \Gamma_1 \ \vdash M_1 : \ \tau_1 \\ W(U_2) \rightsquigarrow \Gamma_2 \ \vdash M_2 : \ \tau_2 \\ W(U_3) \rightsquigarrow \Gamma_3 \ \vdash M_3 : \ \tau_3} & S= \text{mgu} \left(\Large{\substack{\{\tau_1 \stackrel{?}{=} \text{Bool}, \ \tau_2 \stackrel{?}{=} \tau_3\} \\ \{ \Gamma_{\text{i}}(x) \stackrel{?}{=}\Gamma_{\text{j}}(x) \ | \ i,j \ \in \{1,2,3\}, \ x \ \in \ \Gamma_{\text{i}} \cap\Gamma_{\text{j}} \}}}\right) \end{matrix}}{\Large{\substack{W(\text{if} \ U_1 \text{\ then}\ U_2 \text{\ else} \ U_3) \space \rightsquigarrow \space S(\Gamma_1) \ \cup \ S(\Gamma_2) \ \cup \ S(\Gamma_3) \ \vdash \\S(\text{if} \ M_1 \text{\ then}\ M_2 \text{\ else} \ M_3) \space : \space S(\tau_2)}}} \\ \ \\ \frac{\Large\substack{ W(U) \rightsquigarrow \Gamma_1 \ \vdash \ M : \tau \\ W(V) \rightsquigarrow \Gamma_2 \ \vdash \ N : \sigma \\ ?k \text{\ es una incógnita fresca} \\ S = \text{mgu} \{ \tau \; \stackrel{?}{=} \; \sigma \to ?k\} \ \cup \ \{\Gamma_1(x) \stackrel{?}{=} \Gamma_2(x) \; : \; x \; \in \; \Gamma_1 \cap \Gamma_2\}}}{W(UV) \rightsquigarrow S(\Gamma_1) \ \cup \ S(\Gamma_2) \ \space \vdash \space S(MN) \; : \; S(?k)} \\ \ \\ \frac{\begin{matrix} W(U) \rightsquigarrow \Gamma \ \vdash \ M : \tau & \sigma = \begin{cases} \Gamma(x) &\text{si x} \in \Gamma \\ \text{incógnita fresca} \ ?k &\text{si no}\end{cases} \end{matrix}}{W(\lambda x.\, U) \space \rightsquigarrow \space \Gamma /\{x\} \ \vdash \ (\lambda x : \sigma. M) : \sigma \to \tau}\]

Algoritmo $W$ extendido para $\large\lambda^{BN}$

\[\frac{}{W(\text{zero}) \rightsquigarrow \varnothing \vdash \text{zero : Nat}} \\ \ \\ \frac{\begin{matrix} W(U) = \Gamma \vdash M : \sigma & \quad S = \text{mgu}(\sigma \stackrel{?}{=} \text{Nat})\end{matrix}}{W(\text{succ(}U)) \rightsquigarrow S(\Gamma) \vdash S(\text{succ(}M)) : \text{Nat}} \\ \ \\ \frac{\begin{matrix} W(U) = \Gamma \vdash M : \sigma & \quad S = \text{mgu}(\sigma \stackrel{?}{=} \text{Nat})\end{matrix}}{W(\text{pred(}U)) \rightsquigarrow S(\Gamma) \vdash S(\text{pred(}M)) : \text{Nat}} \\ \ \\ \frac{\begin{matrix} W(U) = \Gamma \vdash M : \sigma & \quad S = \text{mgu}(\sigma \stackrel{?}{=} \text{Nat})\end{matrix}}{W(\text{isZero(}U)) \rightsquigarrow S(\Gamma) \vdash S(\text{isZero(}M)) : \text{Bool}} \\ \ \\\]

instalacion de termux y faq

Sun, 29 Sep 2024 00:00:00 +0000

Que es termux

Termux es un emulador de terminal para android, el principal uso que le doy es editar y ejecutar codigo, es útil para editar codigo “on-the-fly” de repositorios tanto en git como en syncthing.

Como instalar termux

Está disponible en Fdroid en formato .apk o en Github (recomendado)

Una vez instalado, Lo primero que hago es seleccionar un grupo de mirrors para mantener los repositorios

termux-change-repo

Esto invoca una interfaz gráfica que permite seleccionar un mirror, seleccionemos mirror groups y luego Mirrors in South America.

pkg update

Ahora otorgamos acceso al almacenamiento del dispositivo para lectura/escritura de archivos.

termux-setup-storage

Esto nos va a redirigir a la pantalla de configuracion del teléfono, activamos el slider para conceder acceso a todos los archivos:

Ahora deberíamos tener acceso a todos los archivos del dispositivo.

Listo! ya tenemos termux listo para editar y ejecutar código

Algunas preguntas que me surgieron al utilizar termux son:

Que es un emulador de terminal?

Una terminal solía ser (es, supongo) un dispositivo físico (un monitor y un teclado) el cual se usaba para comunicarse directamente con una computadora, ver su información en lineas de texto y darle instrucciones mediante una interfaz de comandos.

~Una terminal en fallout 4

Ahora las terminales son software, conocidas como emuladores de terminal. Imitan la misma funcionalidad pero sin necesitar hardware especializado. Termux emula una terminal en Android aprovechando el kernel de linux y completandola con un entorno que contiene el software básico y los comandos que vienen con todas las distribuciones modernas de linux.

Termux es linux?

The environment setup in Termux is similar to that of a modern Linux distribution. However, running on Android implies several important differences.

Ver Differences from Linux de la wiki de termux.

Las limitaciones de Android hacen que termux no sea compatible con software nativo de linux, las diferencias mas importantes son que termux no usa el sistema de archivos de linux, y ademas usa Bionic libc: la libreria standard de C escrita por Google para Android. Lo que rompe la compatibilidad con el software escrito para linux.

Mas contenido en la guía principal

guía de termux

Sat, 28 Sep 2024 00:00:00 +0000

tutorial para termux

Esto es una guía de cosas útiles para termux que escribí o tengo planeado escribir.

contenido:

instalacion de termux y faq
conectarse por ssh desde windows
como editar código en termux
como ejecutar codigo en termux (python, C, C++, Haskell)
como editar la pantalla de inicio
que es y como editar archivo bash.rc
como configurar un servidor x11
como editar la barra de teclado
como instalar una distribucion de linux (ubuntu, arch, debian)
como establecer comandos personalizados

comandos utiles para termux

Estos comandos son utiles también para linux

nano (editor de texto)
mkdir (crear carpeta)
mv (mover archivos/carpetas)
fastfetch (mostrar información del sistema)
unzip (descomprimir archivos)