diff options
Diffstat (limited to 'es-es')
| -rw-r--r-- | es-es/lambda-calculus-es.html.markdown | 216 | ||||
| -rw-r--r-- | es-es/pascal-es.html.markdown | 205 |
2 files changed, 421 insertions, 0 deletions
diff --git a/es-es/lambda-calculus-es.html.markdown b/es-es/lambda-calculus-es.html.markdown new file mode 100644 index 00000000..d49545c2 --- /dev/null +++ b/es-es/lambda-calculus-es.html.markdown @@ -0,0 +1,216 @@ +--- +category: Algorithms & Data Structures +name: Lambda Calculus +contributors: + - ["Max Sun", "http://github.com/maxsun"] + - ["Yan Hui Hang", "http://github.com/yanhh0"] +translators: + - ["Ivan Alburquerque", "https://github.com/AlburIvan"] +lang: es-es +--- + +# Cálculo Lambda + +Cálculo Lambda (Cálculo-λ), originalmente creado por +[Alonzo Church](https://es.wikipedia.org/wiki/Alonzo_Church), +es el lenguaje de programación más pequeño del mundo. +A pesar de no tener números, cadenas, valores booleanos o cualquier +tipo de datos no funcional, el cálculo lambda se puede utilizar para +representar cualquier máquina de Turing. + +El cálculo lambda se compone de 3 elementos: **variables**, **funciones** y +**aplicaciones**. + +| Nombre | Sintaxis | Ejemplo | Explicación | +|-------------|------------------------------------|-----------|-----------------------------------------------| +| Variable | `<nombre>` | `x` | una variable llamada "x" | +| Función | `λ<parámetro>.<cuerpo>` | `λx.x` | una función con parámetro "x" y cuerpo "x" | +| Aplicación | `<función><variable o función>` | `(λx.x)a` | llamando a la función "λx.x" con el argumento "a" | + +La función más básica es la función de identidad: `λx.x` que es equivalente a +`f(x) = x`. La primera "x" es el argumento de la función y la segunda es el +cuerpo de la función. + +## Variables Libres vs. Enlazadas: + +- En la función `λx.x`, "x" se llama una variable enlazada porque está tanto en + el cuerpo de la función como en el parámetro. +- En `λx.y`, "y" se llama variable libre porque nunca se declara de antemano. + +## Evaluación: + +Evaluación se realiza a través de +[β-Reduction](https://es.wikipedia.org/wiki/C%C3%A1lculo_lambda#%CE%B2-reducci%C3%B3n), +que es, esencialmente, sustitución de ámbito léxico. + +Al evaluar la expresión `(λx.x)a`, reemplazamos todas las ocurrencias de "x" +en el cuerpo de la función con "a". + +- `(λx.x)a` evalúa a: `a` +- `(λx.y)a` evalúa a: `y` + +Incluso puedes crear funciones de orden superior: + +- `(λx.(λy.x))a` evalúa a: `λy.a` + +Aunque el cálculo lambda tradicionalmente solo admite funciones +de un solo parámetro, podemos crear funciones multiparamétricas usando +una técnica llamada [Currificación](https://es.wikipedia.org/wiki/Currificación). + +- `(λx.λy.λz.xyz)` es equivalente a `f(x, y, z) = ((x y) z)` + +Algunas veces `λxy.<cuerpo>` es usado indistintamente con: `λx.λy.<cuerpo>` + +---- + +Es importante reconocer que el cálculo lambda tradicional **no tiene números, +caracteres ni ningún tipo de datos que no sea de función.** + +## Lógica Booleana: + +No hay "Verdadero" o "Falso" en el cálculo lambda. Ni siquiera hay un 1 o un 0. + +En vez: + +`T` es representado por: `λx.λy.x` + +`F` es representado por: `λx.λy.y` + +Primero, podemos definir una función "if" `λbtf` que devuelve +`t` si `b` es Verdadero y `f` si `b` es Falso + +`IF` es equivalente a: `λb.λt.λf.b t f` + +Usando `IF` podemos definir los operadores lógicos booleanos básicos: + +`a AND b` es equivalente a: `λab.IF a b F` + +`a OR b` es equivalente a: `λab.IF a T b` + +`a NOT b` es equivalente a: `λa.IF a F T` + +*Note: `IF a b c` es esencialmente diciendo: `IF((a b) c)`* + +## Números: + +Aunque no hay números en el cálculo lambda, podemos codificar números usando +[Númeral de Church](https://en.wikipedia.org/wiki/Church_encoding). + +Para cualquier número n: <code>n = λf.f <sup> n </sup></code> así: + +`0 = λf.λx.x` + +`1 = λf.λx.f x` + +`2 = λf.λx.f(f x)` + +`3 = λf.λx.f(f(f x))` + +Para incrementar un númeral de Church, usamos la función sucesora +`S(n) = n + 1` que es: + +`S = λn.λf.λx.f((n f) x)` + +Usando el sucesor, podemos definir AGREGAR: + +`AGREGAR = λab.(a S)n` + +**Desafío:** intenta definir tu propia función de multiplicación! + +## Vamos más pequeño: SKI, SK y Iota + +### Combinador de SKI + +Sean S, K, I las siguientes funciones: + +`I x = x` + +`K x y = x` + +`S x y z = x z (y z)` + +Podemos convertir una expresión en el cálculo lambda en una expresión +en el cálculo del combinador de SKI: + +1. `λx.x = I` +2. `λx.c = Kc` +3. `λx.(y z) = S (λx.y) (λx.z)` + +Tome el número 2 de Church por ejemplo: + +`2 = λf.λx.f(f x)` + +Para la parte interior `λx.f(f x)`: +``` + λx.f(f x) += S (λx.f) (λx.(f x)) (case 3) += S (K f) (S (λx.f) (λx.x)) (case 2, 3) += S (K f) (S (K f) I) (case 2, 1) +``` + +Así que: +``` + 2 += λf.λx.f(f x) += λf.(S (K f) (S (K f) I)) += λf.((S (K f)) (S (K f) I)) += S (λf.(S (K f))) (λf.(S (K f) I)) (case 3) +``` + +Para el primer argumento `λf.(S (K f))`: +``` + λf.(S (K f)) += S (λf.S) (λf.(K f)) (case 3) += S (K S) (S (λf.K) (λf.f)) (case 2, 3) += S (K S) (S (K K) I) (case 2, 3) +``` + +Para el segundo argumento `λf.(S (K f) I)`: +``` + λf.(S (K f) I) += λf.((S (K f)) I) += S (λf.(S (K f))) (λf.I) (case 3) += S (S (λf.S) (λf.(K f))) (K I) (case 2, 3) += S (S (K S) (S (λf.K) (λf.f))) (K I) (case 1, 3) += S (S (K S) (S (K K) I)) (K I) (case 1, 2) +``` + +Uniéndolos: +``` + 2 += S (λf.(S (K f))) (λf.(S (K f) I)) += S (S (K S) (S (K K) I)) (S (S (K S) (S (K K) I)) (K I)) +``` + +Al expandir esto, terminaríamos con la misma expresión para el número 2 de Church nuevamente. + +### Cálculo del combinador SKI + +El cálculo del combinador SKI puede reducirse aún más. Podemos eliminar +el combinador I observando que `I = SKK`. Podemos sustituir +todos los 'I' con `SKK`. + +### Combinador Iota + +El cálculo del combinador SK todavía no se encuentra en su expresión mínima. +Definiendo: + +``` +ι = λf.((f S) K) +``` + +Tenemos que: + +``` +I = ιι +K = ι(ιI) = ι(ι(ιι)) +S = ι(K) = ι(ι(ι(ιι))) +``` + +## Para una lectura más avanzada: + +1. [A Tutorial Introduction to the Lambda Calculus](http://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf) +2. [Cornell CS 312 Recitation 26: The Lambda Calculus](http://www.cs.cornell.edu/courses/cs3110/2008fa/recitations/rec26.html) +3. [Wikipedia - Lambda Calculus](https://es.wikipedia.org/wiki/Cálculo_lambda) +4. [Wikipedia - SKI combinator calculus](https://en.wikipedia.org/wiki/SKI_combinator_calculus) +5. [Wikipedia - Iota and Jot](https://en.wikipedia.org/wiki/Iota_and_Jot) diff --git a/es-es/pascal-es.html.markdown b/es-es/pascal-es.html.markdown new file mode 100644 index 00000000..8328fa1e --- /dev/null +++ b/es-es/pascal-es.html.markdown @@ -0,0 +1,205 @@ +--- +language: Pascal +filename: learnpascal-es.pas +contributors: + - ["Ganesha Danu", "http://github.com/blinfoldking"] + - ["Keith Miyake", "https://github.com/kaymmm"] +translators: + - ["Ivan Alburquerque", "https://github.com/AlburIvan"] +lang: es-es +--- + + +>Pascal es un lenguaje de programación imperativo y de procedimiento, que Niklaus Wirth diseñó en 1968–69 y publicó en 1970, como un lenguaje pequeño y eficiente destinado a fomentar las buenas prácticas de programación utilizando programación estructurada y estructuración de datos. Se nombra en honor al matemático, filósofo y físico francés Blaise Pascal. fuente: [wikipedia](https://es.wikipedia.org/wiki/Pascal_(lenguaje_de_programación))) + +Para compilar y ejecutar un programa pascal puede usar un compilador pascal gratuito. [Descargar aquí](https://www.freepascal.org/) + +```pascal +//Anatomía de un programa en Pascal +//Esto es un comentario +{ + Esto es un + comentario multilínea +} + +//nombre del programa +program learn_pascal; //<-- no olvides el punto y coma + +const + { + Aquí es donde se debe declarar valores constantes. + } +type + { + Aquí es donde se debe declarar un tipo de datos personalizado + } +var + { + aquí es donde se debe declarar una variable + } + +//área principal del programa +begin + { + área para declarar su instrucción + } +end. // El final de un área principal del programa debe requerir un símbolo "." +``` + +```pascal +//declarando variable +//puedes hacer esto +var a:integer; +var b:integer; +//o esto +var + a : integer; + b : integer; +//o esto +var a,b : integer; +``` + +```pascal +program Learn_More; +//Aprendamos sobre los tipos de datos y sus operaciones. + +const + PI = 3.141592654; + GNU = 'GNU No Es Unix'; + // las constantes se nombran convencionalmente usando CAPS (mayúscula) + // sus valores son fijos y no se pueden cambiar durante el tiempo de ejecución + // tiene cualquier tipo de datos estándar (enteros, reales, booleanos, characteres, cadenas) + +type + ch_array : array [0..255] of char; + // los son nuevos 'tipos' que especifican la longitud y el tipo de datos + // esto define un nuevo tipo de datos que contiene 255 caracteres + // (esto es funcionalmente equivalente a una variable string[256]) + md_array : array of array of integer; + // los arreglos anidados son equivalentes a los arreglos multidimensionales + // puede definir arreglos de longitud cero (0) que son de tamaño dinámico + // esta es una matriz bidimensional de enteros + +//Declarando variables +var + int, c, d : integer; + // Tres variables que contienen números enteros. + // los enteros son de 16 bits y están limitados al rango [-32,768..32,767] + r : real; + // una variable que contiene un número real como tipos de datos + // el rango de los reales pueden variar entre [3.4E-38..3.4E38] + bool : boolean; + // una variable que contiene un valor booleano (True/False) + ch : char; + // una variable que contiene un valor de carácter + // Las variables char se almacenan como tipos de datos de 8 bits, por lo que no hay UTF + str : string; + // una variable no estándar que contiene un valor de cadena + // Las cadenas son una extensión incluida en la mayoría de los compiladores de Pascal. + // se almacenan como una matriz de caracteres con una longitud predeterminada de 255. + s : string[50]; + // una cadena con longitud máxima de 50 caracteres. + // puede especificar la longitud de la cadena para minimizar el uso de memoria + my_str: ch_array; + // Puedes declarar variables de tipos personalizados. + my_2d : md_array; + // Las matrices de tamaño dinámico deben dimensionarse antes de que puedan usarse. + + // tipos de datos enteros adicionales + b : byte; // rango [0..255] + shi : shortint; // rango [-128..127] + smi : smallint; // rango [-32,768..32,767] (entero estándar) + w : word; // rango [0..65,535] + li : longint; // rango [-2,147,483,648..2,147,483,647] + lw : longword; // rango [0..4,294,967,295] + c : cardinal; // longword + i64 : int64; // rango [-9223372036854775808..9223372036854775807] + qw : qword; // rango [0..18,446,744,073,709,551,615] + + // tipos reales adicionales + rr : real; // rango depende de la plataforma (i.e., 8-bit, 16-bit, etc.) + rs : single; // rango [1.5E-45..3.4E38] + rd : double; // rango [5.0E-324 .. 1.7E308] + re : extended; // rango [1.9E-4932..1.1E4932] + rc : comp; // rango [-2E64+1 .. 2E63-1] + +Begin + int := 1;// como asignar un valor a una variable + r := 3.14; + ch := 'a'; + str := 'manzana'; + bool := true; + //pascal no es un lenguaje sensible a mayúsculas y minúsculas + //operación aritmética + int := 1 + 1; // int = 2 sobrescribiendo la asignacion anterior + int := int + 1; // int = 2 + 1 = 3; + int := 4 div 2; //int = 2 operación de división donde el resultado será redondeado. + int := 3 div 2; //int = 1 + int := 1 div 2; //int = 0 + + bool := true or false; // bool = true + bool := false and true; // bool = false + bool := true xor true; // bool = false + + r := 3 / 2; // un operador de división para reales + r := int; // Puede asignar un entero a una variable real pero no a la inversa + + c := str[1]; // asigna la primera letra de str a c + str := 'hola' + 'mundo'; // combinando cadenas + + my_str[0] := 'a'; // asignación de matriz necesita un índice + + setlength(my_2d,10,10); // inicializa matrices de tamaño dinámico: matriz 10 × 10 + for c := 0 to 9 do // los arreglos comienzan en 0 y terminan en longitud - 1 + for d := 0 to 9 do // Para los contadores de bucle hay que declarar variables. + my_2d[c,d] := c * d; + // aborda las matrices multidimensionales con un único conjunto de corchete + +End. +``` + +```pascal +program Functional_Programming; + +Var + i, dummy : integer; + +function recursion_factorial(const a: integer) : integer; +{ calcula recursivamente el factorial del parámetro entero a } + +// Declare variables locales dentro de la función. +// e.g.: +// Var +// local_a : integer; + +Begin + If a >= 1 Then + // devuelva valores de las funciones asignando un valor al nombre de la función + recursion_factorial := a * recursion_factorial(a-1) + Else + recursion_factorial := 1; +End; // termine una función usando un punto y coma después de la instrucción End. + +procedure obtener_entero(var i : integer; dummy : integer); +{ obten la entrada del usuario y almacenarla en el parámetro entero i. + los parámetros que preceden a 'var' son variables, lo que significa que su valor + puede cambiar fuera del parámetro. Los parámetros de valor (sin 'var') como 'dummy' + son estáticos y los cambios realizados dentro del alcance de la función/procedimiento + no afectan la variable que se pasa como parámetro } + +Begin + write('Escriba un entero: '); + readln(i); + dummy := 4; // dummy no cambiará el valor fuera del procedimiento +End; + +Begin // bloque de programa principal + dummy := 3; + obtener_entero(i, dummy); + writeln(i, '! = ', recursion_factorial(i)); + // muestra i! + writeln('dummy = ', dummy); // siempre muestra '3' ya que dummy no ha cambiado. +End. + +``` + |