summaryrefslogtreecommitdiffhomepage
path: root/es-es/julia-es.html.markdown
diff options
context:
space:
mode:
authorGuillermo Garza <ggarza23@gmail.com>2014-03-21 14:29:30 -0500
committerGuillermo Garza <ggarza23@gmail.com>2014-04-02 22:32:16 -0500
commite5d15eec06f7708e2ff423ac78f3effbd29f051b (patch)
tree06b68725c6cae7682a19115f372fc6e07e903a79 /es-es/julia-es.html.markdown
parenta732023f6221a402a9e276183de8c1dbd7aa6a83 (diff)
Fix typos in Spanish Julia
Diffstat (limited to 'es-es/julia-es.html.markdown')
-rw-r--r--es-es/julia-es.html.markdown90
1 files changed, 44 insertions, 46 deletions
diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 2dcc915e..4b79674d 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -8,19 +8,20 @@ lang: es-es
---
Julia es un nuevo lenguaje funcional homoiconic enfocado en computación técnica.
-Mientras que tiene todo el poder de macros homoiconic, funciones de primera
+Aunque que tiene todo el poder de macros homoiconic, funciones de primera
clase, y control de bajo nivel, Julia es tan fácil de aprender y utilizar como
Python.
Esto se basa en la versión de desarrollo actual de Julia, del 18 de octubre de
2013.
-```ruby
-j
+```julia
+
# Comentarios de una línea comienzan con una almohadilla (o signo gato)
+
#= Commentarios multilinea pueden escribirse
- usando '#=' antes de que el texto and '=#'
- después del texto. También se pueden anidar.
+ usando '#=' antes de el texto y '=#'
+ después del texto. También se pueden anidar.
=#
####################################################
@@ -40,10 +41,10 @@ j
8 - 1 # => 7
10 * 2 # => 20
35 / 5 # => 7.0
-5/2 # => 2.5 # dividir un Int por un Int siempre resulta en un Fload
+5/2 # => 2.5 # dividir un Int por un Int siempre resulta en un Float
div (5, 2) # => 2 # para un resultado truncado, usa div
5 \ 35 # => 7.0
-2 ^ 2 # => 4 # exponente, no exclusivo bit a bit
+2 ^ 2 # => 4 # exponente, no es xor
12 % 10 # => 2
# Refuerza la precedencia con paréntesis
@@ -91,17 +92,15 @@ false
'a'
# Una string puede ser indexado como una array de caracteres
-"Esto es un string."[1] # => 'E' # Julia indexes from 1
-# However, this is will not work well for UTF8 strings,
-# so iterating over strings is recommended (map, for loops, etc).
+"Esto es un string."[1] # => 'E' # Índices en Julia empiezen del 1
# Sin embargo, esto no va a funcionar bien para strings UTF8,
# Lo que se recomienda es la iteración (map, for, etc).
-# Puede ser utilizado para la interpolación de strings:
+# $ puede ser utilizado para la interpolación de strings:
"2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
# Se puede poner cualquier expresión de Julia dentro los paréntesis.
-# Otro forma de formatear strings es el printf macro
+# Otro forma de formatear strings es el macro printf
@printf "%d es menor de %f" 4.5 5.3 # 5 es menor de 5.300000
# Imprimir es muy fácil
@@ -123,7 +122,7 @@ catch e
end
# Los nombres de variables comienzan con una letra.
-# Después de eso, usted puede utilizar letras, dígitos, guiones y signos de
+# Después de eso, puedes utilizar letras, dígitos, guiones y signos de
# exclamación.
OtraVariable123! = 6 # => 6
@@ -138,13 +137,13 @@ OtraVariable123! = 6 # => 6
# palabra indicado por underscore ('\ _').
#
# * Los nombres de los tipos comienzan con una letra mayúscula y separación de
-# palabras se muestra Con CamelCase en vez de underscore.
+# palabras se muestra con CamelCase en vez de underscore.
#
-# * Los nombres de las funciones y las macros están en minúsculas, sin
+# * Los nombres de las funciones y los macros están en minúsculas, sin
# underscore.
#
# * Funciones que modifican sus inputs tienen nombres que terminan en!. Estos
-# funciones a veces se llaman mutating functions or in-place functions.
+# funciones a veces se llaman mutating functions o in-place functions.
# Los Arrays almacenan una secuencia de valores indexados entre 1 hasta n
a = Int64[] # => 0-element Int64 Array
@@ -159,7 +158,7 @@ b[end] # => 6
# separados por punto y coma.
matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
-# Añadir cosas a la final de una lista con push! y append!
+# Añadir cosas al final de una lista con push! y append!
push!(a,1) # => [1]
push!(a,2) # => [1,2]
push!(a,4) # => [1,2,4]
@@ -178,11 +177,11 @@ a[1] # => 1 # recuerdan que los índices de Julia empiezan desde 1, no desde 0!
# expresión de indexación
a[end] # => 6
-# tambien hay shift and unshift
+# tambien hay shift y unshift
shift!(a) # => 1 y a es ahora [2,4,3,4,5,6]
unshift!(a,7) # => [7,2,4,3,4,5,6]
-# Nombres de función que terminan en exclamaciones indican que modifican
+# Nombres de funciónes que terminan en exclamaciones indican que modifican
# su argumento.
arr = [5,4,6] # => 3-element Int64 Array: [5,4,6]
sort(arr) # => [4,5,6]; arr es todavía [5,4,6]
@@ -197,13 +196,13 @@ catch e
end
# Errors dan la línea y el archivo de su procedencia, aunque sea en el standard
-# library. Si construyes Julia de source, puedes buscar en la source para
+# library. Si construyes Julia de source, puedes buscar en el source para
# encontrar estos archivos.
# Se puede inicializar arrays de un range
a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5]
-# Usted puede mirar en ranges con sintaxis slice.
+# Puedes mirar en ranges con sintaxis slice.
a[1:3] # => [1, 2, 3]
a[2:end] # => [2, 3, 4, 5]
@@ -215,10 +214,10 @@ splice!(arr,2) # => 4 ; arr es ahora [3,5]
b = [1,2,3]
append!(a,b) # ahroa a es [1, 2, 3, 4, 5, 1, 2, 3]
-# Salida por la existencia de una lista con in
+# Comprobamos la existencia en una lista con in
in(1, a) # => true
-# Examinar la longitud con length
+# Examina la longitud con length
length(a) # => 8
# Tuples son immutable.
@@ -235,7 +234,7 @@ length(tup) # => 3
tup[1:2] # => (1,2)
in(2, tup) # => true
-# Se puede desempaquetar tuples en variables
+# Se puede desempacar tuples en variables
a, b, c = (1, 2, 3) # => (1,2,3) # a is now 1, b is now 2 and c is now 3
# Los tuples se crean, incluso si se omite el paréntesis
@@ -259,13 +258,13 @@ dict_lleno = ["one"=> 1, "two"=> 2, "three"=> 3]
# Busca valores con []
dict_lleno["one"] # => 1
-# Obtén todas las claves
+# Obtén todas las claves
keys(dict_lleno)
# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
# Nota - claves del dictionary no están ordenados ni en el orden en que se
# insertan.
-# Obtén todas las claves
+# Obtén todos los valores
values(dict_lleno)
# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
# Nota - Igual que el anterior en cuanto a ordenamiento de claves.
@@ -276,7 +275,7 @@ in(("tres", 3), dict_lleno) # => false
haskey(dict_lleno, "one") # => true
haskey(dict_lleno, 1) # => false
-# Tratando de buscar una clave inexistente producirá un error
+# Tratando de buscar una clave que no existe producirá un error
try
dict_lleno["dos"] # => ERROR: key not found: dos in getindex at dict.jl:489
catch e
@@ -347,7 +346,7 @@ end
# gato es un mamifero
# raton es un mamifero
-for (k,v) in ["perro"=>"mamifero","gato"=>"mamifero","raton"=>"mamifero"]
+for (k,v) in ["perro"=>"mamifero", "gato"=>"mamifero", "raton"=>"mamifero"]
println("$k es un $v")
end
# imprime:
@@ -367,7 +366,7 @@ end
# 2
# 3
-# Maneja excepciones con un bloque try/except
+# Maneja excepciones con un bloque try/catch
try
error("ayuda")
catch e
@@ -431,7 +430,7 @@ catch e
println(e)
end
-# Puede definir funciones que toman argumentos de palabra clave
+# Puedes definir funciones que toman argumentos de palabra clave
function args_clave(;k1=4,nombre2="hola") # note the ;
return ["k1"=>k1,"nombre2"=>nombre2]
end
@@ -440,14 +439,14 @@ args_clave(nombre2="ness") # => ["nombre2"=>"ness","k1"=>4]
args_clave(k1="mine") # => ["k1"=>"mine","nombre2"=>"hola"]
args_clave() # => ["nombre2"=>"hola","k1"=>4]
-# Se puede combinar todo tipo de argumentos en la misma función
+# Puedes combinar todo tipo de argumentos en la misma función
function todos_los_args(arg_normal, arg_posicional_opcional=2; arg_clave="foo")
println("argumento normal: $arg_normal")
println("argumento optional: $arg_posicional_opcional")
println("argumento de clave: $arg_clave")
end
-# todos_los_args(1, 3, arg_clave=4)
+todos_los_args(1, 3, arg_clave=4)
# imprime:
# argumento normal: 1
# argumento optional: 3
@@ -469,7 +468,7 @@ function crear_suma(x)
y -> x + y
end
-# También se puede nombrar la función interna, si quieres
+# También puedes nombrar la función interna, si quieres
function crear_suma(x)
function suma(y)
x + y
@@ -526,9 +525,7 @@ tigger = Tigre(3.5,"anaranjado") # => Tiger(3.5,"anaranjado")
# El tipo funciona como la función constructora de valores de ese tipo
sherekhan = typeof(tigger)(5.6,"fuego") # => Tiger(5.6,"fuego")
-# These struct-style types are called concrete types
-# They can be instantiated, but cannot have subtypes.
-# The other kind of types is abstract types.
+
# Este estilo de tipos son llamados tipos concrete
# Se pueden crear instancias, pero no pueden tener subtipos.
# La otra clase de tipos es tipos abstractos (abstract types).
@@ -574,8 +571,8 @@ type Pantera <: Gato # Pantera tambien es un a subtipo de Cat
# Panteras sólo tendrán este constructor, y ningún constructor
# predeterminado.
end
-# Utilizar constructores internos, como Panther hace, le da control sobre cómo
-# se pueden crear valores del tipo. Cuando sea posible, debe utilizar
+# Utilizar constructores internos, como Panther hace, te da control sobre cómo
+# se pueden crear valores del tipo. Cuando sea posible, debes utilizar
# constructores exteriores en lugar de los internos.
####################################################
@@ -584,9 +581,9 @@ end
# En Julia, todas las funciones nombradas son funciones genéricas.
# Esto significa que se construyen a partir de muchos métodos pequeños
-# Cada constructor de León es un método de la función genérica León.
+# Cada constructor de Leon es un método de la función genérica Leon.
-# Por ejemplo no constructor, vamos a hacer un maullar función:
+# Por ejemplo, vamos a hacer un maullar función:
# Definiciones para Leon, Pantera, y Tigre
function maullar(animal::Leon)
@@ -655,7 +652,7 @@ try
catch
end
-# Permítanos dejar que el gato vaya primero
+# Un metodo con el gato primero
pelear(c::Gato,l::Leon) = println("El gato le gana al León")
# Warning: New definition
# pelear(Gato,Leon) at none:1
@@ -675,14 +672,14 @@ pelear(l::Leon,l2::Leon) = println("Los leones llegan a un empate")
pelear(Leon("GR"),Leon("cafe","rar")) # => imprime Los leones llegan a un empate
-# Bajo el capó
+# Un vistazo al nivel bajo
# Se puede echar un vistazo a la LLVM y el código ensamblador generado.
area_cuadrada(l) = l * l # area_cuadrada (generic function with 1 method)
-area_cuadrada(5) #25
+area_cuadrada(5) # => 25
-# ¿Qué sucede cuando damos square_area diferentes argumentos?
+# ¿Qué sucede cuando damos area_cuadrada diferentes argumentos?
code_native(area_cuadrada, (Int32,))
# .section __TEXT,__text,regular,pure_instructions
# Filename: none
@@ -717,7 +714,8 @@ code_native(area_cuadrada, (Float64,))
# pop RBP
# ret
#
-# Tenga en cuenta que Julia usará instrucciones de "floating point" si alguno de
+
+# Ten en cuenta que Julia usará instrucciones de "floating point" si alguno de
# los argumentos son "floats"
# Vamos a calcular el área de un círculo
area_circulo(r) = pi * r * r # circle_area (generic function with 1 method)
@@ -753,7 +751,7 @@ code_native(area_circulo, (Float64,))
#
```
-# # Lectura adicional
+## ¿Listo para más?
Puedes obtener muchos más detalles en [The Julia Manual](http://docs.julialang.org/en/latest/manual/)