From 64f4d444cca52197db8dd728d073144663e1f00a Mon Sep 17 00:00:00 2001 From: Guillermo Garza Date: Tue, 18 Mar 2014 23:51:32 -0500 Subject: Add file for spanish translation of julia --- es-es/julia-es.html.markdown | 747 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 747 insertions(+) create mode 100644 es-es/julia-es.html.markdown (limited to 'es-es/julia-es.html.markdown') diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown new file mode 100644 index 00000000..36c57b2a --- /dev/null +++ b/es-es/julia-es.html.markdown @@ -0,0 +1,747 @@ +--- +language: julia +contributors: + - ["Leah Hanson", "http://leahhanson.us"] +filename: learnjulia.jl +--- + +Julia is a new homoiconic functional language focused on technical computing. +While having the full power of homoiconic macros, first-class functions, and low-level control, Julia is as easy to learn and use as Python. + +This is based on the current development version of Julia, as of October 18th, 2013. + +```ruby + +# Single line comments start with a hash. +#= Multiline comments can be written + by putting '#=' before the text and '=#' + after the text. They can also be nested. +=# + +#################################################### +## 1. Primitive Datatypes and Operators +#################################################### + +# Everything in Julia is a expression. + +# There are several basic types of numbers. +3 # => 3 (Int64) +3.2 # => 3.2 (Float64) +2 + 1im # => 2 + 1im (Complex{Int64}) +2//3 # => 2//3 (Rational{Int64}) + +# All of the normal infix operators are available. +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 +35 / 5 # => 7.0 +5 / 2 # => 2.5 # dividing an Int by an Int always results in a Float +div(5, 2) # => 2 # for a truncated result, use div +5 \ 35 # => 7.0 +2 ^ 2 # => 4 # power, not bitwise xor +12 % 10 # => 2 + +# Enforce precedence with parentheses +(1 + 3) * 2 # => 8 + +# Bitwise Operators +~2 # => -3 # bitwise not +3 & 5 # => 1 # bitwise and +2 | 4 # => 6 # bitwise or +2 $ 4 # => 6 # bitwise xor +2 >>> 1 # => 1 # logical shift right +2 >> 1 # => 1 # arithmetic shift right +2 << 1 # => 4 # logical/arithmetic shift left + +# You can use the bits function to see the binary representation of a number. +bits(12345) +# => "0000000000000000000000000000000000000000000000000011000000111001" +bits(12345.0) +# => "0100000011001000000111001000000000000000000000000000000000000000" + +# Boolean values are primitives +true +false + +# Boolean operators +!true # => false +!false # => true +1 == 1 # => true +2 == 1 # => false +1 != 1 # => false +2 != 1 # => true +1 < 10 # => true +1 > 10 # => false +2 <= 2 # => true +2 >= 2 # => true +# Comparisons can be chained +1 < 2 < 3 # => true +2 < 3 < 2 # => false + +# Strings are created with " +"This is a string." + +# Character literals are written with ' +'a' + +# A string can be indexed like an array of characters +"This is a string"[1] # => 'T' # Julia indexes from 1 +# However, this is will not work well for UTF8 strings, +# so iterating over strings is recommended (map, for loops, etc). + +# $ can be used for string interpolation: +"2 + 2 = $(2 + 2)" # => "2 + 2 = 4" +# You can put any Julia expression inside the parenthesis. + +# Another way to format strings is the printf macro. +@printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000 + +# Printing is easy +println("I'm Julia. Nice to meet you!") + +#################################################### +## 2. Variables and Collections +#################################################### + +# You don't declare variables before assigning to them. +some_var = 5 # => 5 +some_var # => 5 + +# Accessing a previously unassigned variable is an error +try + some_other_var # => ERROR: some_other_var not defined +catch e + println(e) +end + +# Variable names start with a letter. +# After that, you can use letters, digits, underscores, and exclamation points. +SomeOtherVar123! = 6 # => 6 + +# You can also use unicode characters +☃ = 8 # => 8 +# These are especially handy for mathematical notation +2 * π # => 6.283185307179586 + +# A note on naming conventions in Julia: +# +# * Names of variables are in lower case, with word separation indicated by +# underscores ('\_'). +# +# * Names of Types begin with a capital letter and word separation is shown +# with CamelCase instead of underscores. +# +# * Names of functions and macros are in lower case, without underscores. +# +# * Functions that modify their inputs have names that end in !. These +# functions are sometimes called mutating functions or in-place functions. + +# Arrays store a sequence of values indexed by integers 1 through n: +a = Int64[] # => 0-element Int64 Array + +# 1-dimensional array literals can be written with comma-separated values. +b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6] +b[1] # => 4 +b[end] # => 6 + +# 2-dimentional arrays use space-separated values and semicolon-separated rows. +matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4] + +# Add stuff to the end of a list with push! and append! +push!(a,1) # => [1] +push!(a,2) # => [1,2] +push!(a,4) # => [1,2,4] +push!(a,3) # => [1,2,4,3] +append!(a,b) # => [1,2,4,3,4,5,6] + +# Remove from the end with pop +pop!(b) # => 6 and b is now [4,5] + +# Let's put it back +push!(b,6) # b is now [4,5,6] again. + +a[1] # => 1 # remember that Julia indexes from 1, not 0! + +# end is a shorthand for the last index. It can be used in any +# indexing expression +a[end] # => 6 + +# we also have shift and unshift +shift!(a) # => 1 and a is now [2,4,3,4,5,6] +unshift!(a,7) # => [7,2,4,3,4,5,6] + +# Function names that end in exclamations points indicate that they modify +# their argument. +arr = [5,4,6] # => 3-element Int64 Array: [5,4,6] +sort(arr) # => [4,5,6]; arr is still [5,4,6] +sort!(arr) # => [4,5,6]; arr is now [4,5,6] + +# Looking out of bounds is a BoundsError +try + a[0] # => ERROR: BoundsError() in getindex at array.jl:270 + a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270 +catch e + println(e) +end + +# Errors list the line and file they came from, even if it's in the standard +# library. If you built Julia from source, you can look in the folder base +# inside the julia folder to find these files. + +# You can initialize arrays from ranges +a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5] + +# You can look at ranges with slice syntax. +a[1:3] # => [1, 2, 3] +a[2:] # => [2, 3, 4, 5] +a[2:end] # => [2, 3, 4, 5] + +# Remove elements from an array by index with splice! +arr = [3,4,5] +splice!(arr,2) # => 4 ; arr is now [3,5] + +# Concatenate lists with append! +b = [1,2,3] +append!(a,b) # Now a is [1, 2, 3, 4, 5, 1, 2, 3] + +# Check for existence in a list with in +in(1, a) # => true + +# Examine the length with length +length(a) # => 8 + +# Tuples are immutable. +tup = (1, 2, 3) # => (1,2,3) # an (Int64,Int64,Int64) tuple. +tup[1] # => 1 +try: + tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) +catch e + println(e) +end + +# Many list functions also work on tuples +length(tup) # => 3 +tup[1:2] # => (1,2) +in(2, tup) # => true + +# You can unpack tuples into variables +a, b, c = (1, 2, 3) # => (1,2,3) # a is now 1, b is now 2 and c is now 3 + +# Tuples are created even if you leave out the parentheses +d, e, f = 4, 5, 6 # => (4,5,6) + +# A 1-element tuple is distinct from the value it contains +(1,) == 1 # => false +(1) == 1 # => true + +# Look how easy it is to swap two values +e, d = d, e # => (5,4) # d is now 5 and e is now 4 + + +# Dictionaries store mappings +empty_dict = Dict() # => Dict{Any,Any}() + +# You can create a dictionary using a literal +filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3] +# => Dict{ASCIIString,Int64} + +# Look up values with [] +filled_dict["one"] # => 1 + +# Get all keys +keys(filled_dict) +# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# Note - dictionary keys are not sorted or in the order you inserted them. + +# Get all values +values(filled_dict) +# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# Note - Same as above regarding key ordering. + +# Check for existence of keys in a dictionary with in, haskey +in(("one", 1), filled_dict) # => true +in(("two", 3), filled_dict) # => false +haskey(filled_dict, "one") # => true +haskey(filled_dict, 1) # => false + +# Trying to look up a non-existant key will raise an error +try + filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489 +catch e + println(e) +end + +# Use the get method to avoid that error by providing a default value +# get(dictionary,key,default_value) +get(filled_dict,"one",4) # => 1 +get(filled_dict,"four",4) # => 4 + +# Use Sets to represent collections of unordered, unique values +empty_set = Set() # => Set{Any}() +# Initialize a set with values +filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4) + +# Add more values to a set +push!(filled_set,5) # => Set{Int64}(5,4,2,3,1) + +# Check if the values are in the set +in(2, filled_set) # => true +in(10, filled_set) # => false + +# There are functions for set intersection, union, and difference. +other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3) +intersect(filled_set, other_set) # => Set{Int64}(3,4,5) +union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6) +setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4) + + +#################################################### +## 3. Control Flow +#################################################### + +# Let's make a variable +some_var = 5 + +# Here is an if statement. Indentation is not meaningful in Julia. +if some_var > 10 + println("some_var is totally bigger than 10.") +elseif some_var < 10 # This elseif clause is optional. + println("some_var is smaller than 10.") +else # The else clause is optional too. + println("some_var is indeed 10.") +end +# => prints "some var is smaller than 10" + + +# For loops iterate over iterables. +# Iterable types include Range, Array, Set, Dict, and String. +for animal=["dog", "cat", "mouse"] + println("$animal is a mammal") + # You can use $ to interpolate variables or expression into strings +end +# prints: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# You can use 'in' instead of '='. +for animal in ["dog", "cat", "mouse"] + println("$animal is a mammal") +end +# prints: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] + println("$(a[1]) is a $(a[2])") +end +# prints: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] + println("$k is a $v") +end +# prints: +# dog is a mammal +# cat is a mammal +# mouse is a mammal + +# While loops loop while a condition is true +x = 0 +while x < 4 + println(x) + x += 1 # Shorthand for x = x + 1 +end +# prints: +# 0 +# 1 +# 2 +# 3 + +# Handle exceptions with a try/catch block +try + error("help") +catch e + println("caught it $e") +end +# => caught it ErrorException("help") + + +#################################################### +## 4. Functions +#################################################### + +# The keyword 'function' creates new functions +#function name(arglist) +# body... +#end +function add(x, y) + println("x is $x and y is $y") + + # Functions return the value of their last statement + x + y +end + +add(5, 6) # => 11 after printing out "x is 5 and y is 6" + +# You can define functions that take a variable number of +# positional arguments +function varargs(args...) + return args + # use the keyword return to return anywhere in the function +end +# => varargs (generic function with 1 method) + +varargs(1,2,3) # => (1,2,3) + +# The ... is called a splat. +# We just used it in a function definition. +# It can also be used in a fuction call, +# where it will splat an Array or Tuple's contents into the argument list. +Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # produces a Set of Arrays +Set([1,2,3]...) # => Set{Int64}(1,2,3) # this is equivalent to Set(1,2,3) + +x = (1,2,3) # => (1,2,3) +Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # a Set of Tuples +Set(x...) # => Set{Int64}(2,3,1) + + +# You can define functions with optional positional arguments +function defaults(a,b,x=5,y=6) + return "$a $b and $x $y" +end + +defaults('h','g') # => "h g and 5 6" +defaults('h','g','j') # => "h g and j 6" +defaults('h','g','j','k') # => "h g and j k" +try + defaults('h') # => ERROR: no method defaults(Char,) + defaults() # => ERROR: no methods defaults() +catch e + println(e) +end + +# You can define functions that take keyword arguments +function keyword_args(;k1=4,name2="hello") # note the ; + return ["k1"=>k1,"name2"=>name2] +end + +keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4] +keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"] +keyword_args() # => ["name2"=>"hello","k1"=>4] + +# You can combine all kinds of arguments in the same function +function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo") + println("normal arg: $normal_arg") + println("optional arg: $optional_positional_arg") + println("keyword arg: $keyword_arg") +end + +all_the_args(1, 3, keyword_arg=4) +# prints: +# normal arg: 1 +# optional arg: 3 +# keyword arg: 4 + +# Julia has first class functions +function create_adder(x) + adder = function (y) + return x + y + end + return adder +end + +# This is "stabby lambda syntax" for creating anonymous functions +(x -> x > 2)(3) # => true + +# This function is identical to create_adder implementation above. +function create_adder(x) + y -> x + y +end + +# You can also name the internal function, if you want +function create_adder(x) + function adder(y) + x + y + end + adder +end + +add_10 = create_adder(10) +add_10(3) # => 13 + + +# There are built-in higher order functions +map(add_10, [1,2,3]) # => [11, 12, 13] +filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7] + +# We can use list comprehensions for nicer maps +[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13] +[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] + +#################################################### +## 5. Types +#################################################### + +# Julia has a type system. +# Every value has a type; variables do not have types themselves. +# You can use the `typeof` function to get the type of a value. +typeof(5) # => Int64 + +# Types are first-class values +typeof(Int64) # => DataType +typeof(DataType) # => DataType +# DataType is the type that represents types, including itself. + +# Types are used for documentation, optimizations, and dispatch. +# They are not statically checked. + +# Users can define types +# They are like records or structs in other languages. +# New types are defined used the `type` keyword. + +# type Name +# field::OptionalType +# ... +# end +type Tiger + taillength::Float64 + coatcolor # not including a type annotation is the same as `::Any` +end + +# The default constructor's arguments are the properties +# of the type, in the order they are listed in the definition +tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange") + +# The type doubles as the constructor function for values of that type +sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire") + +# These struct-style types are called concrete types +# They can be instantiated, but cannot have subtypes. +# The other kind of types is abstract types. + +# abstract Name +abstract Cat # just a name and point in the type hierarchy + +# Abstract types cannot be instantiated, but can have subtypes. +# For example, Number is an abstract type +subtypes(Number) # => 6-element Array{Any,1}: + # Complex{Float16} + # Complex{Float32} + # Complex{Float64} + # Complex{T<:Real} + # ImaginaryUnit + # Real +subtypes(Cat) # => 0-element Array{Any,1} + +# Every type has a super type; use the `super` function to get it. +typeof(5) # => Int64 +super(Int64) # => Signed +super(Signed) # => Real +super(Real) # => Number +super(Number) # => Any +super(super(Signed)) # => Number +super(Any) # => Any +# All of these type, except for Int64, are abstract. + +# <: is the subtyping operator +type Lion <: Cat # Lion is a subtype of Cat + mane_color + roar::String +end + +# You can define more constructors for your type +# Just define a function of the same name as the type +# and call an existing constructor to get a value of the correct type +Lion(roar::String) = Lion("green",roar) +# This is an outer constructor because it's outside the type definition + +type Panther <: Cat # Panther is also a subtype of Cat + eye_color + Panther() = new("green") + # Panthers will only have this constructor, and no default constructor. +end +# Using inner constructors, like Panther does, gives you control +# over how values of the type can be created. +# When possible, you should use outer constructors rather than inner ones. + +#################################################### +## 6. Multiple-Dispatch +#################################################### + +# In Julia, all named functions are generic functions +# This means that they are built up from many small methods +# Each constructor for Lion is a method of the generic function Lion. + +# For a non-constructor example, let's make a function meow: + +# Definitions for Lion, Panther, Tiger +function meow(animal::Lion) + animal.roar # access type properties using dot notation +end + +function meow(animal::Panther) + "grrr" +end + +function meow(animal::Tiger) + "rawwwr" +end + +# Testing the meow function +meow(tigger) # => "rawwr" +meow(Lion("brown","ROAAR")) # => "ROAAR" +meow(Panther()) # => "grrr" + +# Review the local type hierarchy +issubtype(Tiger,Cat) # => false +issubtype(Lion,Cat) # => true +issubtype(Panther,Cat) # => true + +# Defining a function that takes Cats +function pet_cat(cat::Cat) + println("The cat says $(meow(cat))") +end + +pet_cat(Lion("42")) # => prints "The cat says 42" +try + pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,) +catch e + println(e) +end + +# In OO languages, single dispatch is common; +# this means that the method is picked based on the type of the first argument. +# In Julia, all of the argument types contribute to selecting the best method. + +# Let's define a function with more arguments, so we can see the difference +function fight(t::Tiger,c::Cat) + println("The $(t.coatcolor) tiger wins!") +end +# => fight (generic function with 1 method) + +fight(tigger,Panther()) # => prints The orange tiger wins! +fight(tigger,Lion("ROAR")) # => prints The orange tiger wins! + +# Let's change the behavior when the Cat is specifically a Lion +fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!") +# => fight (generic function with 2 methods) + +fight(tigger,Panther()) # => prints The orange tiger wins! +fight(tigger,Lion("ROAR")) # => prints The green-maned lion wins! + +# We don't need a Tiger in order to fight +fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))") +# => fight (generic function with 3 methods) + +fight(Lion("balooga!"),Panther()) # => prints The victorious cat says grrr +try + fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion) +catch +end + +# Also let the cat go first +fight(c::Cat,l::Lion) = println("The cat beats the Lion") +# => Warning: New definition +# fight(Cat,Lion) at none:1 +# is ambiguous with +# fight(Lion,Cat) at none:2. +# Make sure +# fight(Lion,Lion) +# is defined first. +#fight (generic function with 4 methods) + +# This warning is because it's unclear which fight will be called in: +fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The victorious cat says rarrr +# The result may be different in other versions of Julia + +fight(l::Lion,l2::Lion) = println("The lions come to a tie") +fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The lions come to a tie + + +# Under the hood +# You can take a look at the llvm and the assembly code generated. + +square_area(l) = l * l # square_area (generic function with 1 method) + +square_area(5) #25 + +# What happens when we feed square_area an integer? +code_native(square_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 # Prologue + # push RBP + # mov RBP, RSP + # Source line: 1 + # movsxd RAX, EDI # Fetch l from memory? + # imul RAX, RAX # Square l and store the result in RAX + # pop RBP # Restore old base pointer + # ret # Result will still be in RAX + +code_native(square_area, (Float32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulss XMM0, XMM0, XMM0 # Scalar single precision multiply (AVX) + # pop RBP + # ret + +code_native(square_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vmulsd XMM0, XMM0, XMM0 # Scalar double precision multiply (AVX) + # pop RBP + # ret + # +# Note that julia will use floating point instructions if any of the +# arguements are floats. +# Let's calculate the area of a circle +circle_area(r) = pi * r * r # circle_area (generic function with 1 method) +circle_area(5) # 78.53981633974483 + +code_native(circle_area, (Int32,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # Source line: 1 + # vcvtsi2sd XMM0, XMM0, EDI # Load integer (r) from memory + # movabs RAX, 4593140240 # Load pi + # vmulsd XMM1, XMM0, QWORD PTR [RAX] # pi * r + # vmulsd XMM0, XMM0, XMM1 # (pi * r) * r + # pop RBP + # ret + # + +code_native(circle_area, (Float64,)) + # .section __TEXT,__text,regular,pure_instructions + # Filename: none + # Source line: 1 + # push RBP + # mov RBP, RSP + # movabs RAX, 4593140496 + # Source line: 1 + # vmulsd XMM1, XMM0, QWORD PTR [RAX] + # vmulsd XMM0, XMM1, XMM0 + # pop RBP + # ret + # +``` + +## Further Reading + +You can get a lot more detail from [The Julia Manual](http://docs.julialang.org/en/latest/manual/) + +The best place to get help with Julia is the (very friendly) [mailing list](https://groups.google.com/forum/#!forum/julia-users). -- cgit v1.2.3 From 38f55957ac1773098ce17bf59dba2b1f704e9245 Mon Sep 17 00:00:00 2001 From: Guillermo Garza Date: Wed, 19 Mar 2014 00:08:07 -0500 Subject: Translate Julia to Spanish This is based partly on the Python translation. --- es-es/julia-es.html.markdown | 700 ++++++++++++++++++++++--------------------- 1 file changed, 351 insertions(+), 349 deletions(-) (limited to 'es-es/julia-es.html.markdown') diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown index 36c57b2a..6c5a6428 100644 --- a/es-es/julia-es.html.markdown +++ b/es-es/julia-es.html.markdown @@ -12,39 +12,39 @@ This is based on the current development version of Julia, as of October 18th, 2 ```ruby -# Single line comments start with a hash. -#= Multiline comments can be written - by putting '#=' before the text and '=#' - after the text. They can also be nested. +# 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. =# #################################################### -## 1. Primitive Datatypes and Operators +## 1. Tipos de datos primitivos y operadores. #################################################### -# Everything in Julia is a expression. +# Todo en Julia es una expresión. -# There are several basic types of numbers. +# Hay varios tipos básicos de números. 3 # => 3 (Int64) 3.2 # => 3.2 (Float64) 2 + 1im # => 2 + 1im (Complex{Int64}) 2//3 # => 2//3 (Rational{Int64}) -# All of the normal infix operators are available. +# Todos los operadores infijos normales están disponibles. 1 + 1 # => 2 8 - 1 # => 7 10 * 2 # => 20 35 / 5 # => 7.0 -5 / 2 # => 2.5 # dividing an Int by an Int always results in a Float -div(5, 2) # => 2 # for a truncated result, use div +5/2 # => 2.5 # dividir un Int por un Int siempre resulta en un Fload +div (5, 2) # => 2 # para un resultado truncado, usa div 5 \ 35 # => 7.0 -2 ^ 2 # => 4 # power, not bitwise xor +2 ^ 2 # => 4 # exponente, no exclusivo bit a bit 12 % 10 # => 2 -# Enforce precedence with parentheses +# Refuerza la precedencia con paréntesis (1 + 3) * 2 # => 8 -# Bitwise Operators +# Operadores a nivel de bit ~2 # => -3 # bitwise not 3 & 5 # => 1 # bitwise and 2 | 4 # => 6 # bitwise or @@ -53,17 +53,17 @@ div(5, 2) # => 2 # for a truncated result, use div 2 >> 1 # => 1 # arithmetic shift right 2 << 1 # => 4 # logical/arithmetic shift left -# You can use the bits function to see the binary representation of a number. +# Se puede utilizar la función bits para ver la representación binaria de un número. bits(12345) # => "0000000000000000000000000000000000000000000000000011000000111001" bits(12345.0) # => "0100000011001000000111001000000000000000000000000000000000000000" -# Boolean values are primitives +# Valores 'boolean' (booleanos) son primitivos true false -# Boolean operators +# Operadores Boolean (booleanos) !true # => false !false # => true 1 == 1 # => true @@ -74,109 +74,112 @@ false 1 > 10 # => false 2 <= 2 # => true 2 >= 2 # => true -# Comparisons can be chained +# ¡Las comparaciones pueden ser concatenadas! 1 < 2 < 3 # => true 2 < 3 < 2 # => false -# Strings are created with " -"This is a string." +# Strings se crean con " +"Esto es un string." -# Character literals are written with ' +# Literales de caracteres se escriben con ' 'a' -# A string can be indexed like an array of characters -"This is a string"[1] # => 'T' # Julia indexes from 1 +# 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). +# Sin embargo, esto no va a funcionar bien para strings UTF8, +# Lo que se recomienda es la iteración (map, for, etc). -# $ can be used for string interpolation: +# Puede ser utilizado para la interpolación de strings: "2 + 2 = $(2 + 2)" # => "2 + 2 = 4" -# You can put any Julia expression inside the parenthesis. +# Se puede poner cualquier expresión de Julia dentro los paréntesis. -# Another way to format strings is the printf macro. -@printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000 +# Otro forma de formatear strings es el printf macro +@printf "%d es menor de %f" 4.5 5.3 # 5 es menor de 5.300000 -# Printing is easy -println("I'm Julia. Nice to meet you!") +# Imprimir es muy fácil +println("Soy Julia. ¡Encantado de conocerte!") #################################################### -## 2. Variables and Collections +## 2. Variables y Colecciones #################################################### -# You don't declare variables before assigning to them. -some_var = 5 # => 5 -some_var # => 5 +# No hay necesidad de declarar las variables antes de asignarlas. +una_variable = 5 # => 5 +una_variable # => 5 -# Accessing a previously unassigned variable is an error +# Acceder a variables no asignadas previamente es una excepción. try - some_other_var # => ERROR: some_other_var not defined + otra_variable # => ERROR: some_other_var not defined catch e println(e) end -# Variable names start with a letter. -# After that, you can use letters, digits, underscores, and exclamation points. -SomeOtherVar123! = 6 # => 6 +# Los nombres de variables comienzan con una letra. +# Después de eso, usted puede utilizar letras, dígitos, guiones y signos de exclamación. +OtraVariable123! = 6 # => 6 -# You can also use unicode characters +# También puede utilizar caracteres unicode ☃ = 8 # => 8 -# These are especially handy for mathematical notation +# Estos son especialmente útiles para la notación matemática 2 * π # => 6.283185307179586 -# A note on naming conventions in Julia: +# Una nota sobre las convenciones de nomenclatura de Julia: # -# * Names of variables are in lower case, with word separation indicated by -# underscores ('\_'). +# * Los nombres de las variables aparecen en minúsculas, con separación de +# palabra indicado por underscore ('\ _'). # -# * Names of Types begin with a capital letter and word separation is shown -# with CamelCase instead of underscores. +# * Los nombres de los tipos comienzan con una letra mayúscula y separación de +# palabras se muestra Con CamelCase en vez de underscore. # -# * Names of functions and macros are in lower case, without underscores. +# * Los nombres de las funciones y las macros están en minúsculas, sin +# underscore. # -# * Functions that modify their inputs have names that end in !. These -# functions are sometimes called mutating functions or in-place functions. +# * Funciones que modifican sus inputs tienen nombres que terminan en!. Estos +# funciones a veces se llaman mutating functions or in-place functions. -# Arrays store a sequence of values indexed by integers 1 through n: +# Los Arrays almacenan una secuencia de valores indexados entre 1 hasta n a = Int64[] # => 0-element Int64 Array -# 1-dimensional array literals can be written with comma-separated values. +# Literales de arrays 1-dimensionales se pueden escribir con valores separados por comas. b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6] b[1] # => 4 b[end] # => 6 -# 2-dimentional arrays use space-separated values and semicolon-separated rows. +# Los arrays 2-dimensionales usan valores separados por espacios y filas separados por punto y coma. matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4] -# Add stuff to the end of a list with push! and append! +# Añadir cosas a la final de una lista con push! y append! push!(a,1) # => [1] push!(a,2) # => [1,2] push!(a,4) # => [1,2,4] push!(a,3) # => [1,2,4,3] append!(a,b) # => [1,2,4,3,4,5,6] -# Remove from the end with pop -pop!(b) # => 6 and b is now [4,5] +# Eliminar de la final con pop +pop!(b) # => 6 y b ahora es [4,5] -# Let's put it back -push!(b,6) # b is now [4,5,6] again. +# Vamos a ponerlo de nuevo +push!(b, 6) # b es ahora [4,5,6] de nuevo. -a[1] # => 1 # remember that Julia indexes from 1, not 0! +a[1] # => 1 # recuerdan que los índices de Julia empiezan desde 1, no desde 0! -# end is a shorthand for the last index. It can be used in any -# indexing expression +# end es una abreviatura para el último índice. Se puede utilizar en cualquier +# expresión de indexación a[end] # => 6 -# we also have shift and unshift -shift!(a) # => 1 and a is now [2,4,3,4,5,6] +# tambien hay shift and unshift +shift!(a) # => 1 y a es ahora [2,4,3,4,5,6] unshift!(a,7) # => [7,2,4,3,4,5,6] -# Function names that end in exclamations points indicate that they modify -# their argument. +# Nombres de función 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 is still [5,4,6] -sort!(arr) # => [4,5,6]; arr is now [4,5,6] +sort(arr) # => [4,5,6]; arr es todavía [5,4,6] +sort!(arr) # => [4,5,6]; arr es ahora [4,5,6] -# Looking out of bounds is a BoundsError +# Buscando fuera de límites es un BoundsError try a[0] # => ERROR: BoundsError() in getindex at array.jl:270 a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270 @@ -184,34 +187,33 @@ catch e println(e) end -# Errors list the line and file they came from, even if it's in the standard -# library. If you built Julia from source, you can look in the folder base -# inside the julia folder to find these files. +# 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 +# encontrar estos archivos. -# You can initialize arrays from ranges +# Se puede inicializar arrays de un range a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5] -# You can look at ranges with slice syntax. +# Usted puede mirar en ranges con sintaxis slice. a[1:3] # => [1, 2, 3] -a[2:] # => [2, 3, 4, 5] a[2:end] # => [2, 3, 4, 5] -# Remove elements from an array by index with splice! +# Eliminar elementos de una array por índice con splice! arr = [3,4,5] -splice!(arr,2) # => 4 ; arr is now [3,5] +splice!(arr,2) # => 4 ; arr es ahora [3,5] -# Concatenate lists with append! +# Concatenar listas con append! b = [1,2,3] -append!(a,b) # Now a is [1, 2, 3, 4, 5, 1, 2, 3] +append!(a,b) # ahroa a es [1, 2, 3, 4, 5, 1, 2, 3] -# Check for existence in a list with in +# Salida por la existencia de una lista con in in(1, a) # => true -# Examine the length with length +# Examinar la longitud con length length(a) # => 8 -# Tuples are immutable. -tup = (1, 2, 3) # => (1,2,3) # an (Int64,Int64,Int64) tuple. +# Tuples son immutable. +tup = (1, 2, 3) # => (1,2,3) # un (Int64,Int64,Int64) tuple. tup[1] # => 1 try: tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) @@ -219,204 +221,197 @@ catch e println(e) end -# Many list functions also work on tuples +# Muchas funciones de lista también trabajan en las tuples length(tup) # => 3 tup[1:2] # => (1,2) in(2, tup) # => true -# You can unpack tuples into variables +# Se puede desempaquetar 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 -# Tuples are created even if you leave out the parentheses +# Los tuples se crean, incluso si se omite el paréntesis d, e, f = 4, 5, 6 # => (4,5,6) -# A 1-element tuple is distinct from the value it contains +# Un tuple 1-elemento es distinto del valor que contiene (1,) == 1 # => false (1) == 1 # => true -# Look how easy it is to swap two values +# Mira que fácil es cambiar dos valores e, d = d, e # => (5,4) # d is now 5 and e is now 4 -# Dictionaries store mappings -empty_dict = Dict() # => Dict{Any,Any}() +# Dictionaries almanecan mapeos +dict_vacio = Dict() # => Dict{Any,Any}() -# You can create a dictionary using a literal -filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3] +# Se puede crear un dictionary usando un literal +dict_lleno = ["one"=> 1, "two"=> 2, "three"=> 3] # => Dict{ASCIIString,Int64} -# Look up values with [] -filled_dict["one"] # => 1 +# Busca valores con [] +dict_lleno["one"] # => 1 -# Get all keys -keys(filled_dict) +# Obtén todas las claves +keys(dict_lleno) # => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) -# Note - dictionary keys are not sorted or in the order you inserted them. +# Nota - claves del dictionary no están ordenados ni en el orden en que se insertan. -# Get all values -values(filled_dict) +# Obtén todas las claves +values(dict_lleno) # => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) -# Note - Same as above regarding key ordering. +# Nota - Igual que el anterior en cuanto a ordenamiento de claves. -# Check for existence of keys in a dictionary with in, haskey -in(("one", 1), filled_dict) # => true -in(("two", 3), filled_dict) # => false -haskey(filled_dict, "one") # => true -haskey(filled_dict, 1) # => false +# Compruebe si hay existencia de claves en un dictionary con in y haskey +in(("one", 1), dict_lleno) # => true +in(("two", 3), dict_lleno) # => false +haskey(dict_lleno, "one") # => true +haskey(dict_lleno, 1) # => false -# Trying to look up a non-existant key will raise an error +# Tratando de buscar una clave inexistente producirá un error try - filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489 + dict_lleno["four"] # => ERROR: key not found: four in getindex at dict.jl:489 catch e println(e) end -# Use the get method to avoid that error by providing a default value +# Utilice el método get para evitar ese error proporcionando un valor predeterminado # get(dictionary,key,default_value) -get(filled_dict,"one",4) # => 1 -get(filled_dict,"four",4) # => 4 - -# Use Sets to represent collections of unordered, unique values -empty_set = Set() # => Set{Any}() -# Initialize a set with values -filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4) - -# Add more values to a set -push!(filled_set,5) # => Set{Int64}(5,4,2,3,1) - -# Check if the values are in the set -in(2, filled_set) # => true -in(10, filled_set) # => false - -# There are functions for set intersection, union, and difference. -other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3) -intersect(filled_set, other_set) # => Set{Int64}(3,4,5) -union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6) +get(dict_lleno,"one",4) # => 1 +get(dict_lleno,"four",4) # => 4 + +# Usa Sets para representar colecciones (conjuntos) de valores únicos, no ordenadas +conjunto_vacio = Set() # => Set{Any}() +# Iniciar una set de valores +conjunto_lleno = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4) + +# Añadir más valores a un conjunto +push!(conjunto_lleno,5) # => Set{Int64}(5,4,2,3,1) +push!(conjunto_lleno,5) # => Set{Int64}(5,4,2,3,1) + +# Compruebe si los valores están en el conjunto +in(2, conjunto_lleno) # => true +in(10, conjunto_lleno) # => false + +# Hay funciones de intersección de conjuntos, la unión, y la diferencia. +conjunto_otro= Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3) +intersect(conjunto_lleno, conjunto_otro) # => Set{Int64}(3,4,5) +union(conjunto_lleno, conjunto_otro) # => Set{Int64}(1,2,3,4,5,6) setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4) #################################################### -## 3. Control Flow +## 3. Control de Flujo #################################################### -# Let's make a variable -some_var = 5 - -# Here is an if statement. Indentation is not meaningful in Julia. -if some_var > 10 - println("some_var is totally bigger than 10.") -elseif some_var < 10 # This elseif clause is optional. - println("some_var is smaller than 10.") -else # The else clause is optional too. - println("some_var is indeed 10.") +# Hagamos una variable +una_variable = 5 + +# Aquí está una declaración de un 'if'. La indentación no es significativa en +# Julia +if una_variable > 10 + println("una_variable es completamente mas grande que 10.") +elseif una_variable < 10 # Este condición 'elseif' es opcional. + println("una_variable es mas chica que 10.") +else # Esto también es opcional. + println("una_variable es de hecho 10.") end -# => prints "some var is smaller than 10" +# => imprime "una_variable es mas chica que 10." - -# For loops iterate over iterables. -# Iterable types include Range, Array, Set, Dict, and String. -for animal=["dog", "cat", "mouse"] - println("$animal is a mammal") - # You can use $ to interpolate variables or expression into strings -end -# prints: -# dog is a mammal -# cat is a mammal -# mouse is a mammal - -# You can use 'in' instead of '='. -for animal in ["dog", "cat", "mouse"] - println("$animal is a mammal") +# For itera sobre tipos iterables +# Tipos iterables incluyen Range, Array, Set, Dict, y String. +for animal=["perro", "gato", "raton"] + println("$animal es un mamifero") + # Se puede usar $ para interpolar variables o expresiónes en strings end -# prints: -# dog is a mammal -# cat is a mammal -# mouse is a mammal +# imprime: +# perro es un mamifero +# gato es un mamifero +# raton es un mamifero -for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] - println("$(a[1]) is a $(a[2])") +for a in ["perro"=>"mamifero","gato"=>"mamifero","raton"=>"mamifero"] + println("$(a[1]) es un $(a[2])") end -# prints: -# dog is a mammal -# cat is a mammal -# mouse is a mammal +# imprime: +# perro es un mamifero +# gato es un mamifero +# raton es un mamifero -for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"] - println("$k is a $v") +for (k,v) in ["perro"=>"mamifero","gato"=>"mamifero","raton"=>"mamifero"] + println("$k es un $v") end -# prints: -# dog is a mammal -# cat is a mammal -# mouse is a mammal +# imprime: +# perro es un mamifero +# gato es un mamifero +# raton es un mamifero -# While loops loop while a condition is true +# While itera hasta que una condición no se cumple. x = 0 while x < 4 println(x) - x += 1 # Shorthand for x = x + 1 + x += 1 # versión corta de x = x + 1 end -# prints: +# imprime: # 0 # 1 # 2 # 3 -# Handle exceptions with a try/catch block +# Maneja excepciones con un bloque try/except try - error("help") + error("ayuda") catch e - println("caught it $e") + println("capturando $e") end -# => caught it ErrorException("help") +# => capturando ErrorException("ayuda") #################################################### -## 4. Functions +## 4. Funciones #################################################### -# The keyword 'function' creates new functions -#function name(arglist) -# body... +# Usa 'function' para crear nuevas funciones + +#function nombre(arglist) +# cuerpo... #end -function add(x, y) - println("x is $x and y is $y") +function suma(x, y) + println("x es $x e y es $y") - # Functions return the value of their last statement + # Las funciones devuelven el valor de su última declaración x + y end -add(5, 6) # => 11 after printing out "x is 5 and y is 6" +suma(5, 6) # => 11 # después de imprimir "x es 5 e y es de 6" -# You can define functions that take a variable number of -# positional arguments +# Puedes definir funciones que toman un número variable de +# argumentos posicionales function varargs(args...) return args - # use the keyword return to return anywhere in the function + # Usa la palabra clave return para devolver en cualquier lugar de la función end # => varargs (generic function with 1 method) varargs(1,2,3) # => (1,2,3) -# The ... is called a splat. -# We just used it in a function definition. -# It can also be used in a fuction call, -# where it will splat an Array or Tuple's contents into the argument list. -Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # produces a Set of Arrays -Set([1,2,3]...) # => Set{Int64}(1,2,3) # this is equivalent to Set(1,2,3) +# El ... se llama un splat. +# Acabamos de utilizar lo en una definición de función. +# También se puede utilizar en una llamada de función, +# donde va splat un Array o el contenido de un Tuple en la lista de argumentos. +Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # Produce un Set de Arrays +Set([1,2,3]...) # => Set{Int64}(1,2,3) # esto es equivalente a Set(1,2,3) x = (1,2,3) # => (1,2,3) -Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # a Set of Tuples +Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # un Set de Tuples Set(x...) # => Set{Int64}(2,3,1) -# You can define functions with optional positional arguments +# Puede definir funciones con argumentos posicionales opcionales function defaults(a,b,x=5,y=6) - return "$a $b and $x $y" + return "$a $b y $x $y" end -defaults('h','g') # => "h g and 5 6" -defaults('h','g','j') # => "h g and j 6" -defaults('h','g','j','k') # => "h g and j k" +defaults('h','g') # => "h g y 5 6" +defaults('h','g','j') # => "h g y j 6" +defaults('h','g','j','k') # => "h g y j k" try defaults('h') # => ERROR: no method defaults(Char,) defaults() # => ERROR: no methods defaults() @@ -424,120 +419,122 @@ catch e println(e) end -# You can define functions that take keyword arguments -function keyword_args(;k1=4,name2="hello") # note the ; - return ["k1"=>k1,"name2"=>name2] +# Puede definir funciones que toman argumentos de palabra clave +function args_clave(;k1=4,nombre2="hola") # note the ; + return ["k1"=>k1,"nombre2"=>nombre2] end -keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4] -keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"] -keyword_args() # => ["name2"=>"hello","k1"=>4] +args_clave(nombre2="ness") # => ["nombre2"=>"ness","k1"=>4] +args_clave(k1="mine") # => ["k1"=>"mine","nombre2"=>"hola"] +args_clave() # => ["nombre2"=>"hola","k1"=>4] -# You can combine all kinds of arguments in the same function -function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo") - println("normal arg: $normal_arg") - println("optional arg: $optional_positional_arg") - println("keyword arg: $keyword_arg") +# Se puede 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 -all_the_args(1, 3, keyword_arg=4) -# prints: -# normal arg: 1 -# optional arg: 3 -# keyword arg: 4 +# todos_los_args(1, 3, arg_clave=4) +# imprime: +# argumento normal: 1 +# argumento optional: 3 +# argumento de clave: 4 -# Julia has first class functions -function create_adder(x) - adder = function (y) +# Julia tiene funciones de primera clase +function crear_suma(x) + suma = function (y) return x + y end - return adder + return suma end -# This is "stabby lambda syntax" for creating anonymous functions +# Esta es el sintaxis "stabby lambda" para crear funciones anónimas (x -> x > 2)(3) # => true -# This function is identical to create_adder implementation above. -function create_adder(x) +# Esta función es idéntica a la crear_suma implementación anterior. +function crear_suma(x) y -> x + y end -# You can also name the internal function, if you want -function create_adder(x) - function adder(y) +# También se puede nombrar la función interna, si quieres +function crear_suma(x) + function suma(y) x + y end - adder + suma end -add_10 = create_adder(10) -add_10(3) # => 13 +suma_10 = crear_suma(10) +suma_10(3) # => 13 -# There are built-in higher order functions -map(add_10, [1,2,3]) # => [11, 12, 13] +# Hay funciones integradas de orden superior +map(suma_10, [1,2,3]) # => [11, 12, 13] filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7] -# We can use list comprehensions for nicer maps -[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13] -[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] +# Podemos usar listas por comprensión para mapeos +[suma_10(i) for i=[1, 2, 3]] # => [11, 12, 13] +[suma_10(i) for i in [1, 2, 3]] # => [11, 12, 13] #################################################### -## 5. Types +## 5. Tipos #################################################### -# Julia has a type system. -# Every value has a type; variables do not have types themselves. -# You can use the `typeof` function to get the type of a value. +# Julia tiene sistema de tipos. +# Cada valor tiene un tipo y las variables no tienen propios tipos. +# Se puede utilizar la función `typeof` para obtener el tipo de un valor. typeof(5) # => Int64 -# Types are first-class values +# Los tipos son valores de primera clase typeof(Int64) # => DataType typeof(DataType) # => DataType -# DataType is the type that represents types, including itself. +# DataType es el tipo que representa los tipos, incluyéndose a sí mismo. -# Types are used for documentation, optimizations, and dispatch. -# They are not statically checked. +# Los tipos se usan para la documentación, optimizaciones, y envio. +# No están comprobados estáticamente. -# Users can define types -# They are like records or structs in other languages. -# New types are defined used the `type` keyword. +# Los usuarios pueden definir tipos +# Son como registros o estructuras en otros idiomas. +# Nuevos tipos se definen utilizado la palabra clave `type`. -# type Name +# type Nombre # field::OptionalType # ... # end -type Tiger - taillength::Float64 - coatcolor # not including a type annotation is the same as `::Any` +type Tigre + longituddecola::Float64 + colordelpelaje # no incluyendo una anotación de tipo es el mismo que `::Any` end -# The default constructor's arguments are the properties -# of the type, in the order they are listed in the definition -tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange") +# Los argumentos del constructor por default son las propiedades +# del tipo, en el orden en que están listados en la definición +tigger = Tigre(3.5,"anaranjado") # => Tiger(3.5,"anaranjado") -# The type doubles as the constructor function for values of that type -sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire") +# 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). -# abstract Name -abstract Cat # just a name and point in the type hierarchy +# abstract Nombre +abstract Gato # sólo un nombre y un punto en la jerarquía de tipos -# Abstract types cannot be instantiated, but can have subtypes. -# For example, Number is an abstract type +# De los tipos Abstract no se pueden crear instancias, pero pueden tener +# subtipos. Por ejemplo, Number es un tipo abstracto. subtypes(Number) # => 6-element Array{Any,1}: # Complex{Float16} # Complex{Float32} # Complex{Float64} # Complex{T<:Real} - # ImaginaryUnit # Real -subtypes(Cat) # => 0-element Array{Any,1} +subtypes(Gato) # => 0-element Array{Any,1} -# Every type has a super type; use the `super` function to get it. +# Cada tipo tiene un supertipo, utilice la función `súper` para conseguirlo. typeof(5) # => Int64 super(Int64) # => Signed super(Signed) # => Real @@ -545,132 +542,136 @@ super(Real) # => Number super(Number) # => Any super(super(Signed)) # => Number super(Any) # => Any -# All of these type, except for Int64, are abstract. +# Todo de estos tipos, a excepción de Int64, son abstractos. -# <: is the subtyping operator -type Lion <: Cat # Lion is a subtype of Cat - mane_color - roar::String +# <: es el operador de subtipos +type Leon <: Gato # Leon es un subtipo de Gato + color_de_crin + rugido::String end -# You can define more constructors for your type -# Just define a function of the same name as the type -# and call an existing constructor to get a value of the correct type -Lion(roar::String) = Lion("green",roar) -# This is an outer constructor because it's outside the type definition - -type Panther <: Cat # Panther is also a subtype of Cat - eye_color - Panther() = new("green") - # Panthers will only have this constructor, and no default constructor. +# Se puede definir más constructores para su tipo. +# Sólo defina una función del mismo nombre que el tipo +# y llame a un constructor existente para obtener un valor del tipo correcto +Leon(rugido::String) = Leon("verde",rugido) +# Este es un constructor externo porque es fuera de la definición del tipo + +type Pantera <: Gato # Pantera tambien es un a subtipo de Cat + color_de_ojos + Pantera() = new("verde") + # Panteras sólo tendrán este constructor, y ningún constructor + # predeterminado. end -# Using inner constructors, like Panther does, gives you control -# over how values of the type can be created. -# When possible, you should use outer constructors rather than inner ones. +# Utilizar constructores internos, como Panther hace, le da control sobre cómo +# se pueden crear valores del tipo. Cuando sea posible, debe utilizar +# constructores exteriores en lugar de los internos. #################################################### -## 6. Multiple-Dispatch +## 6. Envio múltiple #################################################### -# In Julia, all named functions are generic functions -# This means that they are built up from many small methods -# Each constructor for Lion is a method of the generic function Lion. +# 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. -# For a non-constructor example, let's make a function meow: +# Por ejemplo no constructor, vamos a hacer un maullar función: -# Definitions for Lion, Panther, Tiger -function meow(animal::Lion) - animal.roar # access type properties using dot notation +# Definiciones para Leon, Pantera, y Tigre +function maullar(animal::Leon) + animal.rugido # acceso utilizando notación de puntos end -function meow(animal::Panther) +function maullar(animal::Pantera) "grrr" end -function meow(animal::Tiger) +function maullar(animal::Tigre) "rawwwr" end -# Testing the meow function -meow(tigger) # => "rawwr" -meow(Lion("brown","ROAAR")) # => "ROAAR" -meow(Panther()) # => "grrr" +# Prueba de la función maullar +maullar(tigger) # => "rawwr" +maullar(Leon("cafe","ROAAR")) # => "ROAAR" +maullar(Pantera()) # => "grrr" -# Review the local type hierarchy -issubtype(Tiger,Cat) # => false -issubtype(Lion,Cat) # => true -issubtype(Panther,Cat) # => true +# Revisar la jerarquía de tipos locales +issubtype(Tigre,Gato) # => false +issubtype(Leon,Gato) # => true +issubtype(Pantera,Gato) # => true -# Defining a function that takes Cats -function pet_cat(cat::Cat) - println("The cat says $(meow(cat))") +# Definición de una función que toma Gatos +function mascota(gato::Gato) + println("El gato dice $(maullar(gato))") end -pet_cat(Lion("42")) # => prints "The cat says 42" +mascota(Leon("42")) # => imprime "El gato dice 42" try - pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,) + mascota(tigger) # => ERROR: no method mascota(Tigre)) catch e println(e) end -# In OO languages, single dispatch is common; -# this means that the method is picked based on the type of the first argument. -# In Julia, all of the argument types contribute to selecting the best method. +# En los lenguajes orientados a objetos, expedición única es común. Esto +# significa que el método se recogió basándose en el tipo del primer argumento. +# En Julia, todos los tipos de argumentos contribuyen a seleccionar el mejor +# método. -# Let's define a function with more arguments, so we can see the difference -function fight(t::Tiger,c::Cat) - println("The $(t.coatcolor) tiger wins!") +# Vamos a definir una función con más argumentos, para que podamos ver la +# diferencia +function pelear(t::Tigre,c::Gato) + println("¡El tigre $(t.colordelpelaje) gana!") end -# => fight (generic function with 1 method) +# => pelear (generic function with 1 method) -fight(tigger,Panther()) # => prints The orange tiger wins! -fight(tigger,Lion("ROAR")) # => prints The orange tiger wins! +pelear(tigger,Pantera()) # => imprime ¡El tigre anaranjado gana! +pelear(tigger,Leon("ROAR")) # => ¡El tigre anaranjado gana! -# Let's change the behavior when the Cat is specifically a Lion -fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!") -# => fight (generic function with 2 methods) +# Vamos a cambiar el comportamiento cuando el Gato es específicamente un Leon +pelear(t::Tigre,l::Leon) = println("!El león con melena $(l.color_de_crin) gana!") +# => pelear (generic function with 2 methods) -fight(tigger,Panther()) # => prints The orange tiger wins! -fight(tigger,Lion("ROAR")) # => prints The green-maned lion wins! +pelear(tigger,Pantera()) # => imprime ¡El tigre anaranjado gana! +pelear(tigger,Leon("ROAR")) # => imprime ¡El león con melena verde gana! -# We don't need a Tiger in order to fight -fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))") +# No necesitamos un tigre para poder luchar +pelear(l::Leon,c::Gato) = println("El gato victorioso dice $(maullar(c))") # => fight (generic function with 3 methods) -fight(Lion("balooga!"),Panther()) # => prints The victorious cat says grrr +pelear(Leon("balooga!"),Pantera()) # => imprime El gato victorioso dice grrr try - fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion) + pelear(Pantera(),Leon("RAWR")) # => ERROR: no method pelear(Pantera, Leon)) catch end -# Also let the cat go first -fight(c::Cat,l::Lion) = println("The cat beats the Lion") -# => Warning: New definition -# fight(Cat,Lion) at none:1 -# is ambiguous with -# fight(Lion,Cat) at none:2. -# Make sure -# fight(Lion,Lion) -# is defined first. -#fight (generic function with 4 methods) +# Permítanos dejar que el gato vaya primero +pelear(c::Gato,l::Leon) = println("El gato le gana al León") +# Warning: New definition +# pelear(Gato,Leon) at none:1 +# is ambiguous with: +# pelear(Leon,Gato) at none:1. +# To fix, define +# pelear(Leon,Leon) +# before the new definition. +# pelear (generic function with 4 methods) -# This warning is because it's unclear which fight will be called in: -fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The victorious cat says rarrr -# The result may be different in other versions of Julia +# Esta advertencia se debe a que no está claro que metodo de pelear será llamado +# en: +pelear(Leon("RAR"),Leon("brown","rarrr")) # => imprime El gato victorioso dice rarrr +# El resultado puede ser diferente en otras versiones de Julia -fight(l::Lion,l2::Lion) = println("The lions come to a tie") -fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The lions come to a tie +pelear(l::Leon,l2::Leon) = println("Los leones llegan a un empate") +pelear(Leon("RAR"),Leon("brown","rarrr")) # => imprime Los leones llegan a un empate -# Under the hood -# You can take a look at the llvm and the assembly code generated. +# Bajo el capó +# Se puede echar un vistazo a la LLVM y el código ensamblador generado. -square_area(l) = l * l # square_area (generic function with 1 method) +area_cuadrada(l) = l * l # area_cuadrada (generic function with 1 method) -square_area(5) #25 +area_cuadrada(5) #25 -# What happens when we feed square_area an integer? -code_native(square_area, (Int32,)) +# ¿Qué sucede cuando damos square_area diferentes argumentos? +code_native(area_cuadrada, (Int32,)) # .section __TEXT,__text,regular,pure_instructions # Filename: none # Source line: 1 # Prologue @@ -682,7 +683,7 @@ code_native(square_area, (Int32,)) # pop RBP # Restore old base pointer # ret # Result will still be in RAX -code_native(square_area, (Float32,)) +code_native(area_cuadrada, (Float32,)) # .section __TEXT,__text,regular,pure_instructions # Filename: none # Source line: 1 @@ -693,7 +694,7 @@ code_native(square_area, (Float32,)) # pop RBP # ret -code_native(square_area, (Float64,)) +code_native(area_cuadrada, (Float64,)) # .section __TEXT,__text,regular,pure_instructions # Filename: none # Source line: 1 @@ -704,13 +705,13 @@ code_native(square_area, (Float64,)) # pop RBP # ret # -# Note that julia will use floating point instructions if any of the -# arguements are floats. -# Let's calculate the area of a circle -circle_area(r) = pi * r * r # circle_area (generic function with 1 method) -circle_area(5) # 78.53981633974483 +# Tenga 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) +area_circulo(5) # 78.53981633974483 -code_native(circle_area, (Int32,)) +code_native(area_circulo, (Int32,)) # .section __TEXT,__text,regular,pure_instructions # Filename: none # Source line: 1 @@ -725,7 +726,7 @@ code_native(circle_area, (Int32,)) # ret # -code_native(circle_area, (Float64,)) +code_native(area_circulo, (Float64,)) # .section __TEXT,__text,regular,pure_instructions # Filename: none # Source line: 1 @@ -740,8 +741,9 @@ code_native(circle_area, (Float64,)) # ``` -## Further Reading +# # Lectura adicional + +Puedes obtener muchos más detalles en [The Julia Manual](http://docs.julialang.org/en/latest/manual/) -You can get a lot more detail from [The Julia Manual](http://docs.julialang.org/en/latest/manual/) +El mejor lugar para obtener ayuda con Julia es el (muy amable) [lista de correos](https://groups.google.com/forum/#!forum/julia-users). -The best place to get help with Julia is the (very friendly) [mailing list](https://groups.google.com/forum/#!forum/julia-users). -- cgit v1.2.3 From 21bed16bba39002432403874bb0779c865d6aebd Mon Sep 17 00:00:00 2001 From: Guillermo Garza Date: Wed, 19 Mar 2014 00:30:25 -0500 Subject: Translate introduction, too. --- es-es/julia-es.html.markdown | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'es-es/julia-es.html.markdown') diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown index 6c5a6428..3d131773 100644 --- a/es-es/julia-es.html.markdown +++ b/es-es/julia-es.html.markdown @@ -5,13 +5,13 @@ contributors: filename: learnjulia.jl --- -Julia is a new homoiconic functional language focused on technical computing. -While having the full power of homoiconic macros, first-class functions, and low-level control, Julia is as easy to learn and use as Python. +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 clase, y control de bajo nivel, Julia es tan fácil de aprender y utilizar como Python. -This is based on the current development version of Julia, as of October 18th, 2013. +Esto se basa en la versión de desarrollo actual de Julia, del 18 de octubre de 2013. ```ruby - +j # Comentarios de una línea comienzan con una almohadilla (o signo gato) #= Commentarios multilinea pueden escribirse usando '#=' antes de que el texto and '=#' -- cgit v1.2.3 From 0b05a9db124988f37c82115837d1014703574edc Mon Sep 17 00:00:00 2001 From: Guillermo Garza Date: Wed, 19 Mar 2014 00:39:44 -0500 Subject: Trim lines to 80 characters --- es-es/julia-es.html.markdown | 42 ++++++++++++++++++++++++++---------------- 1 file changed, 26 insertions(+), 16 deletions(-) (limited to 'es-es/julia-es.html.markdown') diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown index 3d131773..3897efff 100644 --- a/es-es/julia-es.html.markdown +++ b/es-es/julia-es.html.markdown @@ -6,9 +6,12 @@ filename: learnjulia.jl --- 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 clase, y control de bajo nivel, Julia es tan fácil de aprender y utilizar como Python. +Mientras 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. +Esto se basa en la versión de desarrollo actual de Julia, del 18 de octubre de +2013. ```ruby j @@ -53,7 +56,8 @@ div (5, 2) # => 2 # para un resultado truncado, usa div 2 >> 1 # => 1 # arithmetic shift right 2 << 1 # => 4 # logical/arithmetic shift left -# Se puede utilizar la función bits para ver la representación binaria de un número. +# Se puede utilizar la función bits para ver la representación binaria de un +# número. bits(12345) # => "0000000000000000000000000000000000000000000000000011000000111001" bits(12345.0) @@ -117,7 +121,8 @@ 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 exclamación. +# Después de eso, usted puede utilizar letras, dígitos, guiones y signos de +# exclamación. OtraVariable123! = 6 # => 6 # También puede utilizar caracteres unicode @@ -142,12 +147,14 @@ OtraVariable123! = 6 # => 6 # Los Arrays almacenan una secuencia de valores indexados entre 1 hasta n a = Int64[] # => 0-element Int64 Array -# Literales de arrays 1-dimensionales se pueden escribir con valores separados por comas. +# Literales de arrays 1-dimensionales se pueden escribir con valores separados +# por comas. b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6] b[1] # => 4 b[end] # => 6 -# Los arrays 2-dimensionales usan valores separados por espacios y filas separados por punto y coma. +# Los arrays 2-dimensionales usan valores separados por espacios y filas +# 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! @@ -253,7 +260,8 @@ dict_lleno["one"] # => 1 # 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. +# Nota - claves del dictionary no están ordenados ni en el orden en que se +# insertan. # Obtén todas las claves values(dict_lleno) @@ -261,24 +269,26 @@ values(dict_lleno) # Nota - Igual que el anterior en cuanto a ordenamiento de claves. # Compruebe si hay existencia de claves en un dictionary con in y haskey -in(("one", 1), dict_lleno) # => true -in(("two", 3), dict_lleno) # => false +in(("uno", 1), dict_lleno) # => true +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 try - dict_lleno["four"] # => ERROR: key not found: four in getindex at dict.jl:489 + dict_lleno["dos"] # => ERROR: key not found: dos in getindex at dict.jl:489 catch e println(e) end -# Utilice el método get para evitar ese error proporcionando un valor predeterminado +# Utilice el método get para evitar ese error proporcionando un valor +# predeterminado # get(dictionary,key,default_value) get(dict_lleno,"one",4) # => 1 get(dict_lleno,"four",4) # => 4 -# Usa Sets para representar colecciones (conjuntos) de valores únicos, no ordenadas +# Usa Sets para representar colecciones (conjuntos) de valores únicos, no +# ordenadas conjunto_vacio = Set() # => Set{Any}() # Iniciar una set de valores conjunto_lleno = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4) @@ -627,11 +637,11 @@ pelear(tigger,Pantera()) # => imprime ¡El tigre anaranjado gana! pelear(tigger,Leon("ROAR")) # => ¡El tigre anaranjado gana! # Vamos a cambiar el comportamiento cuando el Gato es específicamente un Leon -pelear(t::Tigre,l::Leon) = println("!El león con melena $(l.color_de_crin) gana!") +pelear(t::Tigre,l::Leon) = println("El león con melena $(l.color_de_crin) gana") # => pelear (generic function with 2 methods) pelear(tigger,Pantera()) # => imprime ¡El tigre anaranjado gana! -pelear(tigger,Leon("ROAR")) # => imprime ¡El león con melena verde gana! +pelear(tigger,Leon("ROAR")) # => imprime El león con melena verde gana # No necesitamos un tigre para poder luchar pelear(l::Leon,c::Gato) = println("El gato victorioso dice $(maullar(c))") @@ -656,11 +666,11 @@ pelear(c::Gato,l::Leon) = println("El gato le gana al León") # Esta advertencia se debe a que no está claro que metodo de pelear será llamado # en: -pelear(Leon("RAR"),Leon("brown","rarrr")) # => imprime El gato victorioso dice rarrr +pelear(Leon("RAR"),Leon("cafe","rar")) # => imprime El gato victorioso dice rar # El resultado puede ser diferente en otras versiones de Julia pelear(l::Leon,l2::Leon) = println("Los leones llegan a un empate") -pelear(Leon("RAR"),Leon("brown","rarrr")) # => imprime Los leones llegan a un empate +pelear(Leon("GR"),Leon("cafe","rar")) # => imprime Los leones llegan a un empate # Bajo el capó -- cgit v1.2.3 From 82ac7779819b7117638b5d41d1adee8e9c4ab20d Mon Sep 17 00:00:00 2001 From: Guillermo Garza Date: Wed, 19 Mar 2014 00:43:21 -0500 Subject: Fix header at beginning of file. --- es-es/julia-es.html.markdown | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'es-es/julia-es.html.markdown') diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown index 3897efff..2dcc915e 100644 --- a/es-es/julia-es.html.markdown +++ b/es-es/julia-es.html.markdown @@ -2,7 +2,9 @@ language: julia contributors: - ["Leah Hanson", "http://leahhanson.us"] -filename: learnjulia.jl + - ["Guillermo Garza" ] +filename: learnjulia-es.jl +lang: es-es --- Julia es un nuevo lenguaje funcional homoiconic enfocado en computación técnica. -- cgit v1.2.3 From e5d15eec06f7708e2ff423ac78f3effbd29f051b Mon Sep 17 00:00:00 2001 From: Guillermo Garza Date: Fri, 21 Mar 2014 14:29:30 -0500 Subject: Fix typos in Spanish Julia --- es-es/julia-es.html.markdown | 90 ++++++++++++++++++++++---------------------- 1 file changed, 44 insertions(+), 46 deletions(-) (limited to 'es-es/julia-es.html.markdown') 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/) -- cgit v1.2.3 From 4e85becf286cafe347d3e36e6b2c5e4f31a56819 Mon Sep 17 00:00:00 2001 From: Guillermo Garza Date: Fri, 21 Mar 2014 14:45:13 -0500 Subject: Change lang declaration back to ruby from julia --- es-es/julia-es.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'es-es/julia-es.html.markdown') diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown index 4b79674d..7303bb40 100644 --- a/es-es/julia-es.html.markdown +++ b/es-es/julia-es.html.markdown @@ -15,7 +15,7 @@ Python. Esto se basa en la versión de desarrollo actual de Julia, del 18 de octubre de 2013. -```julia +```ruby # Comentarios de una línea comienzan con una almohadilla (o signo gato) -- cgit v1.2.3 From 764f5967da3d0b8ca0c0af2183abc1a05c6973f6 Mon Sep 17 00:00:00 2001 From: Guillermo Garza Date: Wed, 2 Apr 2014 22:41:12 -0500 Subject: More fixes to Spanish Julia. --- es-es/julia-es.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'es-es/julia-es.html.markdown') diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown index 7303bb40..41a7c68b 100644 --- a/es-es/julia-es.html.markdown +++ b/es-es/julia-es.html.markdown @@ -158,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 al final de una lista con push! y append! +# Añadir cosas a la final de una lista con push! y append! push!(a,1) # => [1] push!(a,2) # => [1,2] push!(a,4) # => [1,2,4] @@ -214,7 +214,7 @@ 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] -# Comprobamos la existencia en una lista con in +# Comprueba la existencia en una lista con in in(1, a) # => true # Examina la longitud con length -- cgit v1.2.3 From ef6544a8868d3b19a115804b2db3962d91ad7979 Mon Sep 17 00:00:00 2001 From: Geoffrey Liu Date: Sun, 12 Oct 2014 14:24:42 -0700 Subject: Capitalize language names for translations. #137 --- es-es/julia-es.html.markdown | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'es-es/julia-es.html.markdown') diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown index 41a7c68b..203ee3bb 100644 --- a/es-es/julia-es.html.markdown +++ b/es-es/julia-es.html.markdown @@ -1,8 +1,9 @@ --- -language: julia +language: Julia contributors: - ["Leah Hanson", "http://leahhanson.us"] - - ["Guillermo Garza" ] +translators: + - ["Guillermo Garza", "http://github.com/ggarza"] filename: learnjulia-es.jl lang: es-es --- -- cgit v1.2.3 From a0e8d3202b1642d9be1a8fcc6db95273415373b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ismael=20Venegas=20Castell=C3=B3?= Date: Fri, 14 Aug 2015 20:28:08 -0500 Subject: Update julia-es to v0.3.11 --- es-es/julia-es.html.markdown | 1268 ++++++++++++++++++++++++------------------ 1 file changed, 724 insertions(+), 544 deletions(-) (limited to 'es-es/julia-es.html.markdown') diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown index 203ee3bb..1e01c2e3 100644 --- a/es-es/julia-es.html.markdown +++ b/es-es/julia-es.html.markdown @@ -4,757 +4,937 @@ contributors: - ["Leah Hanson", "http://leahhanson.us"] translators: - ["Guillermo Garza", "http://github.com/ggarza"] + - ["Ismael Venegas Castelló", "https://github.com/Ismael-VC"] filename: learnjulia-es.jl lang: es-es --- -Julia es un nuevo lenguaje funcional homoiconic enfocado en computación técnica. -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. +![JuliaLang](https://camo.githubusercontent.com/e1ae5c7f6fe275a50134d5889a68f0acdd09ada8/687474703a2f2f6a756c69616c616e672e6f72672f696d616765732f6c6f676f5f68697265732e706e67) -Esto se basa en la versión de desarrollo actual de Julia, del 18 de octubre de -2013. +[Julia](http://julialanges.github.io) es un [lenguaje de programación](http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n) [multiplataforma](http://es.wikipedia.org/wiki/Multiplataforma) y [multiparadigma](http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n_multiparadigma) de [tipado dinámico](http://es.wikipedia.org/wiki/Tipado_din%C3%A1mico), [alto nivel](http://es.wikipedia.org/wiki/Lenguaje_de_alto_nivel) y [alto desempeño](http://es.wikipedia.org/wiki/Computaci%C3%B3n_de_alto_rendimiento) para la computación [genérica](http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n_de_prop%C3%B3sito_general), [técnica y científica](http://es.wikipedia.org/wiki/Computaci%C3%B3n_cient%C3%ADfica), con una sintaxis que es familiar para los usuarios de otros entornos de computación técnica y científica. Provee de un [sofisticado compilador JIT](http://es.wikipedia.org/wiki/Compilaci%C3%B3n_en_tiempo_de_ejecuci%C3%B3n), [ejecución distribuida y paralela](http://docs.julialang.org/en/release-0.3/manual/parallel-computing), [precisión numérica](http://julia.readthedocs.org/en/latest/manual/integers-and-floating-point-numbers) y de una [extensa librería con funciones matemáticas](http://docs.julialang.org/en/release-0.3/stdlib). La librería estándar, escrita casi completamente en Julia, también integra las mejores y más maduras librerías de C y Fortran para el [álgebra lineal](http://docs.julialang.org/en/release-0.3/stdlib/linalg), [generación de números aleatorios](http://docs.julialang.org/en/release-0.3/stdlib/numbers/?highlight=random#random-numbers), [procesamiento de señales](http://docs.julialang.org/en/release-0.3/stdlib/math/?highlight=signal#signal-processing), y [procesamiento de cadenas](http://docs.julialang.org/en/release-0.3/stdlib/strings). Adicionalmente, la comunidad de [desarrolladores de Julia](https://github.com/JuliaLang/julia/graphs/contributors) contribuye un número de [paquetes externos](http://pkg.julialang.org) a través del gestor de paquetes integrado de Julia a un paso acelerado. [IJulia](https://github.com/JuliaLang/IJulia.jl), una colaboración entre las comunidades de [IPython](http://ipython.org) y Julia, provee de una poderosa interfaz gráfica basada en el [navegador para Julia](https://juliabox.org). -```ruby +En Julia los programas están organizados entorno al [despacho múltiple](http://docs.julialang.org/en/release-0.3/manual/methods/#man-methods); definiendo funciones y sobrecargándolas para diferentes combinaciones de tipos de argumentos, los cuales también pueden ser definidos por el usuario. -# Comentarios de una línea comienzan con una almohadilla (o signo gato) +### ¡Prueba Julia ahora mismo! -#= Commentarios multilinea pueden escribirse - usando '#=' antes de el texto y '=#' - después del texto. También se pueden anidar. +* [TryJupyter](https://try.jupyter.org) +* [JuliaBox](https://juliabox.org) +* [SageMathCloud](https://cloud.sagemath.com) + +### Resumen de Características: + +* [Despacho múltiple](http://en.wikipedia.org/wiki/Multiple_dispatch): permite definir el comportamiento de las funciones a través de múltiples combinaciones de tipos de argumentos (**métodos**). +* Sistema de **tipado dinámico**: tipos para la documentación, la optimización y el despacho. +* [Buen desempeño](http://julialang.org/benchmarks), comparado al de lenguajes **estáticamente compilados** como C. +* [Gestor de paquetes](http://docs.julialang.org/en/release-0.3/stdlib/pkg) integrado. +* [Macros tipo Lisp](http://docs.julialang.org/en/release-0.3/manual/metaprogramming/#macros) y otras comodidades para la [meta programación](http://docs.julialang.org/en/release-0.3/manual/metaprogramming). +* Llamar funciones de otros lenguajes, mediante paquetes como: **Python** ([PyCall](https://github.com/stevengj/PyCall.jl)), [Mathematica](http://github.com/one-more-minute/Mathematica.jl), **Java** ([JavaCall](http://github.com/aviks/JavaCall.jl)), **R** ([Rif](http://github.com/lgautier/Rif.jl) y [RCall](http://github.com/JuliaStats/RCall.jl)) y **Matlab** ([MATLAB](http://github.com/JuliaLang/MATLAB.jl)). +* [Llamar funciones de C y Fortran](http://docs.julialang.org/en/release-0.3/manual/calling-c-and-fortran-code) **directamente**: sin necesidad de usar envoltorios u APIs especiales. +* Poderosas características de **línea de comandos** para [gestionar otros procesos](http://docs.julialang.org/en/release-0.3/manual/running-external-programs). +* Diseñado para la [computación paralela y distribuida](http://docs.julialang.org/en/release-0.3/manual/parallel-computing) **desde el principio**. +* [Corrutinas](http://en.wikipedia.org/wiki/Coroutine): hilos ligeros "**verdes**". +* Los [tipos definidos por el usuario](http://docs.julialang.org/en/release-0.3/manual/types) son tan **rápidos y compactos** como los tipos estándar integrados. +* [Generación automática de código](http://docs.julialang.org/en/release-0.3/stdlib/base/?highlight=%40code#internals) **eficiente y especializado** para diferentes tipos de argumentos. +* [Conversiones y promociones](http://docs.julialang.org/en/release-0.3/manual/conversion-and-promotion) para tipos numéricos y de otros tipos, **elegantes y extensibles**. +* Soporte eficiente para [Unicode](http://es.wikipedia.org/wiki/Unicode), incluyendo [UTF-8](http://es.wikipedia.org/wiki/UTF-8) pero sin limitarse solo a este. +* [Licencia MIT](https://github.com/JuliaLang/julia/blob/master/LICENSE.md): libre y de código abierto. + +Esto se basa en la versión `0.3.11`. + +```julia +# Los comentarios de una línea comienzan con una almohadilla (o signo de gato). + +#= + Los commentarios multilínea pueden escribirse + usando '#=' antes de el texto y '=#' + después del texto. También se pueden anidar. =# -#################################################### -## 1. Tipos de datos primitivos y operadores. -#################################################### -# Todo en Julia es una expresión. +############################################## +# 1. Tipos de datos primitivos y operadores. # +############################################## + +# Todo en Julia es una expresión (Expr). # Hay varios tipos básicos de números. -3 # => 3 (Int64) -3.2 # => 3.2 (Float64) -2 + 1im # => 2 + 1im (Complex{Int64}) -2//3 # => 2//3 (Rational{Int64}) +3 # => 3 # Int64 +3.2 # => 3.2 # Float64 +2 + 1im # => 2 + 1im # Complex{Int64} +2 // 3 # => 2//3 # Rational{Int64} # Todos los operadores infijos normales están disponibles. -1 + 1 # => 2 -8 - 1 # => 7 -10 * 2 # => 20 -35 / 5 # => 7.0 -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 es xor -12 % 10 # => 2 - -# Refuerza la precedencia con paréntesis -(1 + 3) * 2 # => 8 - -# Operadores a nivel de bit -~2 # => -3 # bitwise not -3 & 5 # => 1 # bitwise and -2 | 4 # => 6 # bitwise or -2 $ 4 # => 6 # bitwise xor -2 >>> 1 # => 1 # logical shift right -2 >> 1 # => 1 # arithmetic shift right -2 << 1 # => 4 # logical/arithmetic shift left - -# Se puede utilizar la función bits para ver la representación binaria de un -# número. +1 + 1 # => 2 +8 - 1 # => 7 +10 * 2 # => 20 +35 / 5 # => 7.0 # dividir un Int por un Int siempre resulta + # en un Float +5 / 2 # => 2.5 +div(5, 2) # => 2 # para un resultado truncado, usa la función div +5 \ 35 # => 7.0 +2 ^ 2 # => 4 # exponente, no es XOR +12 % 10 # => 2 + +# Refuerza la precedencia con paréntesis. +(1 + 3) * 2 # => 8 + +# Operadores a nivel de bit. +~2 # => -3 # bitwise NOT +3 & 5 # => 1 # bitwise AND +2 | 4 # => 6 # bitwise OR +2 $ 4 # => 6 # bitwise XOR +2 >>> 1 # => 1 # desplazamiento lógico hacia la derecha +2 >> 1 # => 1 # desplazamiento aritmético hacia la derecha +2 << 1 # => 4 # desplazamiento lógico/aritmético hacia la izquierda + +# Se puede utilizar la función bits para ver la representación +# binaria de un número. bits(12345) # => "0000000000000000000000000000000000000000000000000011000000111001" + bits(12345.0) # => "0100000011001000000111001000000000000000000000000000000000000000" -# Valores 'boolean' (booleanos) son primitivos -true -false - -# Operadores Boolean (booleanos) -!true # => false -!false # => true -1 == 1 # => true -2 == 1 # => false -1 != 1 # => false -2 != 1 # => true -1 < 10 # => true -1 > 10 # => false -2 <= 2 # => true -2 >= 2 # => true +# Los valores booleanos (Bool) son primitivos. +true # => true +false # => false + +# Operadores booleanos. +!true # => false +!false # => true +1 == 1 # => true +2 == 1 # => false +1 != 1 # => false +2 != 1 # => true +1 < 10 # => true +1 > 10 # => false +2 <= 2 # => true +2 >= 2 # => true + # ¡Las comparaciones pueden ser concatenadas! -1 < 2 < 3 # => true -2 < 3 < 2 # => false +1 < 2 < 3 # => true +2 < 3 < 2 # => false -# Strings se crean con " -"Esto es un string." +# Los literales de cadenas (String) se crean con la comilla doble: " +"Esto es una cadena." -# Literales de caracteres se escriben con ' +# Los literales de caracteres (Char) se crean con la comilla simple: ' 'a' -# Una string puede ser indexado como una array de caracteres -"Esto es un string."[1] # => 'E' # Índices en Julia empiezen del 1 -# Sin embargo, esto no va a funcionar bien para strings UTF8, +# Una cadena puede ser indexada como una arreglo de caracteres. +"Esto es un string."[1] # => 'E' # Los índices en Julia comienzan en: 1 + +# Sin embargo, esto no va a funcionar bien para las cadenas UTF8 (UTF8String), # Lo que se recomienda es la iteración (map, for, etc). -# $ 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. +# $ puede ser utilizado para la interpolación de cadenas, se puede poner +# cualquier expresión de Julia dentro los paréntesis. +"2 + 2 = $(2 + 2)" # => "2 + 2 = 4" + +# Otra forma para formatear cadenas es usando el macro printf. +@printf "%d es menor de %f\n" 4.5 5.3 # 5 es menor de 5.300000 -# 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! +println("¡Hola Julia!") # ¡Hola Julia! -# Imprimir es muy fácil -println("Soy Julia. ¡Encantado de conocerte!") -#################################################### -## 2. Variables y Colecciones -#################################################### +############################## +# 2. Variables y Colecciones # +############################## # No hay necesidad de declarar las variables antes de asignarlas. -una_variable = 5 # => 5 -una_variable # => 5 +una_variable = 5 # => 5 +una_variable # => 5 -# Acceder a variables no asignadas previamente es una excepción. +# Acceder a una variable no asignada previamente es una excepción. try - otra_variable # => ERROR: some_other_var not defined + otra_variable # ERROR: otra_variable not defined catch e - println(e) + println(e) # UndefVarError(:otra_variable) end -# Los nombres de variables comienzan con una letra. -# Después de eso, puedes utilizar letras, dígitos, guiones y signos de +# Los nombres de variables comienzan con una letra o guion bajo: _. +# Después de eso, puedes utilizar letras, dígitos, guiones bajos y signos de # exclamación. -OtraVariable123! = 6 # => 6 +otraVariable_123! = 6 # => 6 + +# También puedes utilizar caracteres Unicode. +☃ = 8 # => 8 -# También puede utilizar caracteres unicode -☃ = 8 # => 8 # Estos son especialmente útiles para la notación matemática -2 * π # => 6.283185307179586 - -# Una nota sobre las convenciones de nomenclatura de Julia: -# -# * Los nombres de las variables aparecen en minúsculas, con separación de -# 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. -# -# * 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 o in-place functions. - -# Los Arrays almacenan una secuencia de valores indexados entre 1 hasta n -a = Int64[] # => 0-element Int64 Array - -# Literales de arrays 1-dimensionales se pueden escribir con valores separados -# por comas. -b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6] -b[1] # => 4 -b[end] # => 6 - -# Los arrays 2-dimensionales usan valores separados por espacios y filas -# 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! -push!(a,1) # => [1] -push!(a,2) # => [1,2] -push!(a,4) # => [1,2,4] -push!(a,3) # => [1,2,4,3] -append!(a,b) # => [1,2,4,3,4,5,6] - -# Eliminar de la final con pop -pop!(b) # => 6 y b ahora es [4,5] - -# Vamos a ponerlo de nuevo -push!(b, 6) # b es ahora [4,5,6] de nuevo. - -a[1] # => 1 # recuerdan que los índices de Julia empiezan desde 1, no desde 0! - -# end es una abreviatura para el último índice. Se puede utilizar en cualquier -# expresión de indexación -a[end] # => 6 - -# 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ó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] -sort!(arr) # => [4,5,6]; arr es ahora [4,5,6] - -# Buscando fuera de límites es un BoundsError +# (multiplicación implicita). +2π # => 6.283185307179586 + +#= + Una nota sobre las convenciones de nomenclatura de Julia: + + * Los nombres de las variables aparecen en minúsculas, con separación de + palabra indicado por un guion bajo: + + otra_variable + + * Los nombres de los tipos comienzan con una letra mayúscula y separación de + palabras se muestra con CamelCase en vez de guion bajo: + + OtroTipo + + * Los nombres de las funciones y los macros están en minúsculas, sin + underscore: + + otromacro + + * Funciones que modifican sus entradas tienen nombres que terminan en: !. + Estas funciones a veces se les llaman funciones transformadoras o + funciones in situ: + + otra_funcion! +=# + +# Los arreglos (Array) almacenan una secuencia de valores indexados de entre 1 hasta n. +a = Int64[] # => 0-element Array{Int64,1} + +# Los literales de arregos unidimensionales se pueden escribir con valores +# separados por comas. +b = [4, 5, 6] +#= + => 3-element Array{Int64,1}: + 4 + 5 + 6 +=# +b[1] # => 4 +b[end] # => 6 + +# Los arreglos bidimensionales usan valores separados por espacios y filas +# separadas por punto y coma. +matrix = [1 2; 3 4] +#= + => 2x2 Array{Int64,2}: + 1 2 + 3 4 +=# + +# Añadir cosas a la final de un arreglo con push! y append!. +push!(a, 1) # => [1] +push!(a, 2) # => [1,2] +push!(a, 4) # => [1,2,4] +push!(a, 3) # => [1,2,4,3] +append!(a, b) # => [1,2,4,3,4,5,6] + +# Eliminar del final con pop!. +pop!(b) # => 6 y b ahora es: [4,5] + +# Vamos a ponerlo de nuevo. +push!(b, 6) # b es ahora [4,5,6] de nuevo + +a[1] # => 1 # recuerda, los índices de Julia empiezan desde 1, no desde 0! + +# end es una abreviatura para el último índice. Se puede utilizar en cualquier +# expresión de indexación. +a[end] # => 6 + +# También 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] + +# Los nombres de funciónes que terminan en exclamaciones indican que modifican +# su o sus argumentos de entrada. +arr = [5, 4, 6] # => 3-element Array{Int64,1}: [5,4,6] +sort(arr) # => [4,5,6] y arr es todavía: [5,4,6] +sort!(arr) # => [4,5,6] y arr es ahora: [4,5,6] + +# Buscando fuera de límites es un BoundsError. try - a[0] # => ERROR: BoundsError() in getindex at array.jl:270 - a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270 + a[0] # ERROR: BoundsError() in getindex at array.jl:270 + a[end+1] # ERROR: BoundsError() in getindex at array.jl:270 catch e - println(e) + println(e) # BoundsError() 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 el source para -# encontrar estos archivos. +# Las excepciones y los errores dan la línea y el archivo de su procedencia, +# aunque provenga de la librería estándar. Si compilas Julia del código fuente, +# puedes buscar en el código para encontrar estos archivos. + +# Se puede inicializar un arreglo con un rango (Range). +a = [1:5] # => 5-element Array{Int64,1}: [1,2,3,4,5] -# Se puede inicializar arrays de un range -a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5] +# Puedes mirar en los rangos con la sintaxis de rebanada. +a[1:3] # => [1,2,3] +a[2:end] # => [2,3,4,5] -# Puedes mirar en ranges con sintaxis slice. -a[1:3] # => [1, 2, 3] -a[2:end] # => [2, 3, 4, 5] +# Eliminar elementos de un arreglo por índice con splice! +arr = [3, 4, 5] +splice!(arr, 2) # => 4 y arr es ahora: [3,5] -# Eliminar elementos de una array por índice con splice! -arr = [3,4,5] -splice!(arr,2) # => 4 ; arr es ahora [3,5] +# Concatenar arreglos con append! +b = [1, 2, 3] +append!(a, b) # a ahora es: [1,2,3,4,5,1,2,3] -# Concatenar listas con append! -b = [1,2,3] -append!(a,b) # ahroa a es [1, 2, 3, 4, 5, 1, 2, 3] +# Comprueba la existencia de un elemento en un arreglo con in. +in(1, a) # => true -# Comprueba la existencia en una lista con in -in(1, a) # => true +# Examina la longitud con length. +length(a) # => 8 -# Examina la longitud con length -length(a) # => 8 +# Las tuplas (Tuple) son inmutables. +tup = (1, 2, 3) # => (1,2,3) # una tupla tipo (Int64,Int64,Int64) +tup[1] # => 1 -# Tuples son immutable. -tup = (1, 2, 3) # => (1,2,3) # un (Int64,Int64,Int64) tuple. -tup[1] # => 1 try: - tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) + tup[1] = 3 # ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) catch e - println(e) + println(e) # MethodError(setindex!,(:tup,3,1)) end -# Muchas funciones de lista también trabajan en las tuples -length(tup) # => 3 -tup[1:2] # => (1,2) -in(2, tup) # => true +# Muchas funciones de arreglos también trabajan en con las tuplas. +length(tup) # => 3 +tup[1:2] # => (1,2) +in(2, tup) # => true -# 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 +# Se pueden desempacar las tuplas en variables individuales. +a, b, c = (1, 2, 3) # => (1,2,3) # ahora a es 1, b es 2 y c es 3 -# Los tuples se crean, incluso si se omite el paréntesis -d, e, f = 4, 5, 6 # => (4,5,6) +# Los tuplas se crean, incluso si se omiten los paréntesis. +d, e, f = 4, 5, 6 # => (4,5,6) -# Un tuple 1-elemento es distinto del valor que contiene -(1,) == 1 # => false -(1) == 1 # => true +# Una tupla de un elemento es distinta del valor que contiene. +(1,) == 1 # => false +(1) == 1 # => true -# Mira que fácil es cambiar dos valores -e, d = d, e # => (5,4) # d is now 5 and e is now 4 +# Mira que fácil es cambiar dos valores! +e, d = d, e # => (5,4) # ahora d es 5 y e es 4 +# Los diccionarios (Dict) son arreglos asociativos. +dicc_vacio = Dict() # => Dict{Any,Any} with 0 entries -# Dictionaries almanecan mapeos -dict_vacio = Dict() # => Dict{Any,Any}() +# Se puede crear un diccionario usando una literal. +dicc_lleno = ["uno" => 1, "dos" => 2, "tres" => 3] +#= + => Dict{ASCIIString,Int64} with 3 entries: + "tres" => 3 + "dos" => 2 + "uno" => 1 +=# + +# Busca valores con: []. +dicc_lleno["uno"] # => 1 + +# Obtén todas las claves con. +keys(dicc_lleno) +#= + => KeyIterator for a Dict{ASCIIString,Int64} with 3 entries. Keys: + "tres" + "dos" + "uno" +=# -# Se puede crear un dictionary usando un literal -dict_lleno = ["one"=> 1, "two"=> 2, "three"=> 3] -# => Dict{ASCIIString,Int64} +# Nota: los elementos del diccionario no están ordenados y no se guarda el orden +# en que se insertan. -# Busca valores con [] -dict_lleno["one"] # => 1 +# Obtén todos los valores. +values(dicc_lleno) +#= + => ValueIterator for a Dict{ASCIIString,Int64} with 3 entries. Values: + 3 + 2 + 1 +=# -# 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. +# Nota: igual que el anterior en cuanto a ordenamiento de los elementos. -# 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. +# Comprueba si una clave existe en un diccionario con in y haskey. +in(("uno", 1), dicc_lleno) # => true +in(("tres", 3), dicc_lleno) # => false -# Compruebe si hay existencia de claves en un dictionary con in y haskey -in(("uno", 1), dict_lleno) # => true -in(("tres", 3), dict_lleno) # => false -haskey(dict_lleno, "one") # => true -haskey(dict_lleno, 1) # => false +haskey(dicc_lleno, "uno") # => true +haskey(dicc_lleno, 1) # => false -# Tratando de buscar una clave que no existe producirá un error +# Tratar de obtener un valor con una clave que no existe producirá un error. try - dict_lleno["dos"] # => ERROR: key not found: dos in getindex at dict.jl:489 + # ERROR: key not found: cuatro in getindex at dict.jl:489 + dicc_lleno["cuatro"] catch e - println(e) + println(e) # KeyError("cuatro") end -# Utilice el método get para evitar ese error proporcionando un valor -# predeterminado -# get(dictionary,key,default_value) -get(dict_lleno,"one",4) # => 1 -get(dict_lleno,"four",4) # => 4 +# Utiliza el método get para evitar este error proporcionando un valor +# predeterminado: get(diccionario, clave, valor_predeterminado). +get(dicc_lleno, "uno", 4) # => 1 +get(dicc_lleno, "cuatro", 4) # => 4 + +# Usa conjuntos (Set) para representar colecciones de valores únicos, no +# ordenados. +conjunto_vacio = Set() # => Set{Any}({}) -# Usa Sets para representar colecciones (conjuntos) de valores únicos, no -# ordenadas -conjunto_vacio = Set() # => Set{Any}() -# Iniciar una set de valores -conjunto_lleno = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4) +# Iniciar una conjunto de valores. +conjunto_lleno = Set(1, 2, 2, 3, 4) # => Set{Int64}({4,2,3,1}) -# Añadir más valores a un conjunto -push!(conjunto_lleno,5) # => Set{Int64}(5,4,2,3,1) -push!(conjunto_lleno,5) # => Set{Int64}(5,4,2,3,1) +# Añadir más valores a un conjunto. +push!(conjunto_lleno, 5) # => Set{Int64}({4,2,3,5,1}) +push!(conjunto_lleno, 5) # => Set{Int64}({4,2,3,5,1}) -# Compruebe si los valores están en el conjunto -in(2, conjunto_lleno) # => true -in(10, conjunto_lleno) # => false +# Comprobar si los valores están en el conjunto. +in(2, conjunto_lleno) # => true +in(10, conjunto_lleno) # => false -# Hay funciones de intersección de conjuntos, la unión, y la diferencia. -conjunto_otro= Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3) -intersect(conjunto_lleno, conjunto_otro) # => Set{Int64}(3,4,5) -union(conjunto_lleno, conjunto_otro) # => Set{Int64}(1,2,3,4,5,6) -setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4) +# Hay funciones de intersección, unión y diferencia de conjuntos. +otro_conjunto = Set(3, 4, 5, 6) # => Set{Int64}({6,4,5,3}) +intersect(conjunto_lleno, otro_conjunto) # => Set{Int64}({3,4,5}) +union(conjunto_lleno, otro_conjunto) # => Set{Int64}({1,2,3,4,5,6}) +setdiff(Set(1, 2, 3, 4), Set(2, 3, 5)) # => Set{Int64}({1,4}) -#################################################### -## 3. Control de Flujo -#################################################### +####################### +# 3. Control de Flujo # +####################### -# Hagamos una variable +# Hagamos una variable. una_variable = 5 -# Aquí está una declaración de un 'if'. La indentación no es significativa en -# Julia +# Aquí está la declaración de un if. La indentación no es significativa en +# Julia. if una_variable > 10 - println("una_variable es completamente mas grande que 10.") -elseif una_variable < 10 # Este condición 'elseif' es opcional. - println("una_variable es mas chica que 10.") -else # Esto también es opcional. - println("una_variable es de hecho 10.") + println("una_variable es completamente mayor que 10.") +elseif una_variable < 10 # esta condición elseif es opcional + println("una_variable es menor que 10.") +else # esto también es opcional + println("De echo una_variable es 10.") end -# => imprime "una_variable es mas chica que 10." +# imprime: una_variable es menor que 10. -# For itera sobre tipos iterables -# Tipos iterables incluyen Range, Array, Set, Dict, y String. -for animal=["perro", "gato", "raton"] - println("$animal es un mamifero") - # Se puede usar $ para interpolar variables o expresiónes en strings +# El bucle for itera sobre tipos iterables, ie. Range, Array, Set, +# Dict y String. +for animal in ["perro", "gato", "ratón"] + # Se puede usar $ para interpolar variables o expresiones en ls cadenas. + println("$animal es un mamífero.") end -# imprime: -# perro es un mamifero -# gato es un mamifero -# raton es un mamifero +#= + imprime: + perro es un mamífero. + gato es un mamífero. + ratón es un mamífero. +=# -for a in ["perro"=>"mamifero","gato"=>"mamifero","raton"=>"mamifero"] - println("$(a[1]) es un $(a[2])") +for a in ["perro" => "mamífero", "gato" => "mamífero", "ratón" => "mamífero"] + println("$(a[1]) es un $(a[2]).") end -# imprime: -# perro es un mamifero -# gato es un mamifero -# raton es un mamifero +#= + imprime: + perro es un mamífero. + gato es un mamífero. + ratón es un mamífero. +=# -for (k,v) in ["perro"=>"mamifero", "gato"=>"mamifero", "raton"=>"mamifero"] - println("$k es un $v") +for (k,v) in ["perro"=>"mamífero", "gato"=>"mamífero", "ratón"=>"mamífero"] + println("$k es un $v.") end -# imprime: -# perro es un mamifero -# gato es un mamifero -# raton es un mamifero +#= + imprime: + perro es un mamífero. + gato es un mamífero. + ratón es un mamífero. +=# -# While itera hasta que una condición no se cumple. +# El bucle while itera hasta que una condición se deje de cumplir. x = 0 while x < 4 println(x) - x += 1 # versión corta de x = x + 1 + x += 1 # versión corta de: x = x + 1 end -# imprime: -# 0 -# 1 -# 2 -# 3 +#= +imprime: + 0 + 1 + 2 + 3 +=# -# Maneja excepciones con un bloque try/catch -try - error("ayuda") +# Maneja excepciones con un bloque try/catch. +try # intentar + error("Ooops!") catch e - println("capturando $e") + println("capturando: $e") # capturando: ErrorException("Ooops!") end -# => capturando ErrorException("ayuda") -#################################################### -## 4. Funciones -#################################################### +################ +# 4. Funciones # +################ -# Usa 'function' para crear nuevas funciones +# Usa function para crear nuevas funciones. -#function nombre(arglist) -# cuerpo... -#end +#= + function nombre(arglist) + cuerpo... + end +=# function suma(x, y) println("x es $x e y es $y") - # Las funciones devuelven el valor de su última declaración + # las funciones devuelven el valor de su última expresión x + y end +# => suma (generic function with 1 method) -suma(5, 6) # => 11 # después de imprimir "x es 5 e y es de 6" +suma(5, 6) # => 11 # después de imprimir: x es 5 e y es 6 + +# También puedes usar esta otra sintaxis para definir funciones! +resta(x, y) = x - y # => resta (generic function with 1 method) # Puedes definir funciones que toman un número variable de -# argumentos posicionales +# argumentos posicionales (el ... se llama un splat). function varargs(args...) + # Usa la palabra clave return para regresar desde cualquier + # lugar de la función. return args - # Usa la palabra clave return para devolver en cualquier lugar de la función end # => varargs (generic function with 1 method) -varargs(1,2,3) # => (1,2,3) +varargs(1, 2, 3) # => (1,2,3) +varargs([1, 2, 3]) # => ([1,2,3],) -# El ... se llama un splat. -# Acabamos de utilizar lo en una definición de función. -# También se puede utilizar en una llamada de función, -# donde va splat un Array o el contenido de un Tuple en la lista de argumentos. -Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # Produce un Set de Arrays -Set([1,2,3]...) # => Set{Int64}(1,2,3) # esto es equivalente a Set(1,2,3) +# Acabamos de utilizar el splat (...) en la definición de una función. También +# se puede utilizar al llamar a una función, donde se esparce un arreglo, tupla +# o en general una secuencia iterable en la tupla de argumentos. +varargs([1, 2, 3]...) # => (1,2,3) # igual que: varargs(1, 2, 3) -x = (1,2,3) # => (1,2,3) -Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # un Set de Tuples -Set(x...) # => Set{Int64}(2,3,1) +x = (1, 2, 3) # => (1,2,3) +varargs(x) # => ((1,2,3),) +varargs(x...) # => (1,2,3) +varargs("abc"...) # => ('a','b','c') -# Puede definir funciones con argumentos posicionales opcionales -function defaults(a,b,x=5,y=6) +# Puedes definir funciones con argumentos posicionales opcionales. +function defaults(a, b, x=5, y=6) return "$a $b y $x $y" end +# => defaults (generic function with 3 methods) + +defaults('h', 'g') # => "h g y 5 6" +defaults('h', 'g', 'j') # => "h g y j 6" +defaults('h', 'g', 'j', 'k') # => "h g y j k" -defaults('h','g') # => "h g y 5 6" -defaults('h','g','j') # => "h g y j 6" -defaults('h','g','j','k') # => "h g y j k" try - defaults('h') # => ERROR: no method defaults(Char,) - defaults() # => ERROR: no methods defaults() + defaults('h') # ERROR: `defaults` has no method matching defaults(::Char) + defaults() # ERROR: `defaults` has no method matching defaults() catch e - println(e) + println(e) # MethodError(defaults,('h',)) end -# Puedes definir funciones que toman argumentos de palabra clave -function args_clave(;k1=4,nombre2="hola") # note the ; - return ["k1"=>k1,"nombre2"=>nombre2] +# Puedes definir funciones que tomen argumentos de palabras clave. +function args_clave(;k1=4, nombre2="hola") # nota el punto y coma: ; + return ["k1" => k1, "nombre2" => nombre2] end +# => args_clave (generic function with 1 method) -args_clave(nombre2="ness") # => ["nombre2"=>"ness","k1"=>4] -args_clave(k1="mine") # => ["k1"=>"mine","nombre2"=>"hola"] -args_clave() # => ["nombre2"=>"hola","k1"=>4] +args_clave(nombre2="ness") # => ["nombre2"=>"ness","k1"=>4] +args_clave(k1="mine") # => ["k1"=>"mine","nombre2"=>"hola"] +args_clave() # => ["nombre2"=>"hola","k1"=>4] -# 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") +# Puedes combinar todo tipo de argumentos en la misma función. +function todos_los_args(arg_posicional, arg_opcional=2; arg_clave="foo") + println("argumento posicional: $arg_posicional") + println(" argumento opcional: $arg_opcional") + println(" argumento clave: $arg_clave") end +# => todos_los_args (generic function with 2 methods) +# No se necesita punto y coma ; al llamar la función usando un argumento clave, +# esto solo es necesario en la definición de la función. todos_los_args(1, 3, arg_clave=4) -# imprime: -# argumento normal: 1 -# argumento optional: 3 -# argumento de clave: 4 +#= + imprime: + argumento posicional: 1 + argumento opcional: 3 + argumento clave: 4 +=# -# Julia tiene funciones de primera clase +# Julia tiene funciones de primera clase. function crear_suma(x) - suma = function (y) + suma = function (y) # función anónima return x + y end return suma end +# => crear_suma (generic function with 1 method) -# Esta es el sintaxis "stabby lambda" para crear funciones anónimas -(x -> x > 2)(3) # => true +# Esta es otra sintaxis (estilo cálculo lambda), para crear funciones anónimas. +(x -> x > 2)(3) # => true # Esta función es idéntica a la crear_suma implementación anterior. -function crear_suma(x) - y -> x + y -end +crear_suma(x) = y -> x + y -# También puedes 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 end suma end +# => crear_suma (generic function with 1 method) -suma_10 = crear_suma(10) -suma_10(3) # => 13 +suma_10 = crear_suma(10) # => suma (generic function with 1 method) +suma_10(3) # => 13 +# Hay funciones integradas de orden superior. +map(suma_10, [1, 2, 3]) # => [11,12,13] +filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6,7] -# Hay funciones integradas de orden superior -map(suma_10, [1,2,3]) # => [11, 12, 13] -filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7] +# Se puede pasar un bloque a las funciones cuyo primer argumento posicional +# es otra función, como en map y filter. +map([1, 2, 3]) do arr + suma_10(arr) +end +#= + => 3-element Array{Int64,1}: + 11 + 12 + 13 +=# + +filter([3, 4, 5, 6, 7]) do arr + (x -> x > 5)(arr) +end +#= + => 2-element Array{Int64,1}: + 6 + 7 +=# -# Podemos usar listas por comprensión para mapeos -[suma_10(i) for i=[1, 2, 3]] # => [11, 12, 13] -[suma_10(i) for i in [1, 2, 3]] # => [11, 12, 13] +# Podemos usar comprensiones de listas multidimensionales. +[suma_10(i) for i = [1, 2, 3]] # => [11, 12, 13] # 1D +[suma_10(i) for i in [1, 2, 3]] # => [11, 12, 13] -#################################################### -## 5. Tipos -#################################################### +[i*j for i = [1:3], j in [1:3]] # 2D +#= + => 3x3 Array{Int64,2}: + 1 2 3 + 2 4 6 + 3 6 9 +=# + +[i*j/k for i = [1:3], j = [1:3], k in [1:3]] # 3D +#= + => 3x3x3 Array{Float64,3}: + [:, :, 1] = + 1.0 2.0 3.0 + 2.0 4.0 6.0 + 3.0 6.0 9.0 + + [:, :, 2] = + 0.5 1.0 1.5 + 1.0 2.0 3.0 + 1.5 3.0 4.5 + + [:, :, 3] = + 0.333333 0.666667 1.0 + 0.666667 1.33333 2.0 + 1.0 2.0 3.0 +=# + + +############ +# 5. Tipos # +############ -# Julia tiene sistema de tipos. # Cada valor tiene un tipo y las variables no tienen propios tipos. -# Se puede utilizar la función `typeof` para obtener el tipo de un valor. -typeof(5) # => Int64 +# Se puede utilizar la función typeof para obtener el tipo de un valor. +typeof(5) # => Int64 # en un sistema de 64 bits, de lo contrario: Int32 -# Los tipos son valores de primera clase -typeof(Int64) # => DataType -typeof(DataType) # => DataType -# DataType es el tipo que representa los tipos, incluyéndose a sí mismo. +# Los tipos son valores de primera clase, DataType es el tipo que representa a +# los tipos, incluyéndose a sí mismo. +typeof(Int64) # => DataType +typeof(DataType) # => DataType -# Los tipos se usan para la documentación, optimizaciones, y envio. -# No están comprobados estáticamente. +# Los tipos se usan para la documentación, para optimizaciones +# y el despacho múltiple. No están comprobados estáticamente. -# Los usuarios pueden definir tipos -# Son como registros o estructuras en otros idiomas. -# Nuevos tipos se definen utilizado la palabra clave `type`. +# Los usuarios pueden definir sus propios tipos. +# Son como registros o estructuras en otros idiomas. +# Un nuevo tipos se define utilizado la palabra clave type. # type Nombre -# field::OptionalType +# atributo::UnTipo # las anotaciones de tipos son opcionales # ... # end type Tigre - longituddecola::Float64 - colordelpelaje # no incluyendo una anotación de tipo es el mismo que `::Any` + longitud_cola::Float64 + color_pelaje # sin una anotación de tipo, es lo mismo que `::Any` end -# Los argumentos del constructor por default son las propiedades -# del tipo, en el orden en que están listados en la definición -tigger = Tigre(3.5,"anaranjado") # => Tiger(3.5,"anaranjado") +# Los argumentos del constructor por defecto son los atributos +# del tipo, en el orden en que están listados en la definición. +tigre = Tigre(3.5, "anaranjado") # => Tigre(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") +# El tipo funciona como método constructor para los valores de ese tipo. +sherekhan = typeof(tigre)(5.6, "fuego") # => Tigre(5.6,"fuego") -# 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). +# Este estilo de tipos son llamados tipos concretos. +# Se pueden crear instancias de estos, pero no pueden tener subtipos. +# La otra clase de tipos son los tipos abstractos. # abstract Nombre -abstract Gato # sólo un nombre y un punto en la jerarquía de tipos - -# De los tipos Abstract no se pueden crear instancias, pero pueden tener -# subtipos. Por ejemplo, Number es un tipo abstracto. -subtypes(Number) # => 6-element Array{Any,1}: - # Complex{Float16} - # Complex{Float32} - # Complex{Float64} - # Complex{T<:Real} - # Real -subtypes(Gato) # => 0-element Array{Any,1} - -# Cada tipo tiene un supertipo, utilice la función `súper` para conseguirlo. -typeof(5) # => Int64 -super(Int64) # => Signed -super(Signed) # => Real -super(Real) # => Number -super(Number) # => Any -super(super(Signed)) # => Number -super(Any) # => Any -# Todo de estos tipos, a excepción de Int64, son abstractos. - -# <: es el operador de subtipos -type Leon <: Gato # Leon es un subtipo de Gato - color_de_crin - rugido::String -end +abstract Gato # sólo un nombre y un punto en la jerarquía de tipos + +# No se pueden crear instancias de los tipos abstractos, pero pueden tener +# subtipos. Por ejemplo, Number es un tipo abstracto. +subtypes(Number) +#= + => 2-element Array{Any,1}: + Complex{T<:Real} + Real +=# + +subtypes(Gato) # => 0-element Array{Any,1} + +# Cada tipo tiene un supertipo, utiliza la función súper para conseguirlo. +typeof(5) # => Int64 +super(Int64) # => Signed +super(Signed) # => Integer +super(Integer) # => Real +super(Real) # => Number +super(Number) # => Any +super(super(Signed)) # => Real +super(Any) # => Any -# Se puede definir más constructores para su tipo. -# Sólo defina una función del mismo nombre que el tipo -# y llame a un constructor existente para obtener un valor del tipo correcto -Leon(rugido::String) = Leon("verde",rugido) -# Este es un constructor externo porque es fuera de la definición del tipo - -type Pantera <: Gato # Pantera tambien es un a subtipo de Cat - color_de_ojos - Pantera() = new("verde") - # Panteras sólo tendrán este constructor, y ningún constructor - # predeterminado. +# Todos estos tipos, a excepción de Int64, son abstractos. + +# <: es el operador de subtipos. +type Leon <: Gato # Leon es un subtipo de Gato + color_crin + rugido::String end -# 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. -#################################################### -## 6. Envio múltiple -#################################################### +# Se pueden definir más constructores para un tipo. +# Sólo define una función del mismo nombre que el tipo y llama al constructor +# existente para obtener un valor del tipo correcto. -# 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 Leon es un método de la función genérica Leon. +# Este es un constructor externo porque es fuera de la definición del tipo. +Leon(rugido::String) = Leon("verde", rugido) -# Por ejemplo, vamos a hacer un maullar función: +type Pantera <: Gato # Pantera también es un a subtipo de Gato + color_ojos -# Definiciones para Leon, Pantera, y Tigre -function maullar(animal::Leon) - animal.rugido # acceso utilizando notación de puntos + # Pantera sólo tendrá este constructor, y ningún constructor predeterminado. + Pantera() = new("verde") end -function maullar(animal::Pantera) - "grrr" -end +# Utilizar constructores internos, como se hace en Pantera, te da control sobre +# cómo se pueden crear valores de este tipo. Cuando sea posible, debes utilizar +# constructores externos en lugar de internos. -function maullar(animal::Tigre) - "rawwwr" -end -# Prueba de la función maullar -maullar(tigger) # => "rawwr" -maullar(Leon("cafe","ROAAR")) # => "ROAAR" -maullar(Pantera()) # => "grrr" +######################## +# 6. Despacho Múltiple # +######################## -# Revisar la jerarquía de tipos locales -issubtype(Tigre,Gato) # => false -issubtype(Leon,Gato) # => true -issubtype(Pantera,Gato) # => true +# En Julia, todas las funciones nombradas son funciones genéricas. +# Esto significa que se construyen a partir de muchos métodosmás pequeños. +# Cada constructor de Leon es un método de la función genérica Leon. -# Definición de una función que toma Gatos -function mascota(gato::Gato) - println("El gato dice $(maullar(gato))") -end +# Por ejemplo, vamos a hacer métodos para para Leon, Pantera, y Tigre de una +# función genérica maullar: + +# acceso utilizando notación de puntos +maullar(animal::Leon) = animal.rugido +# => maullar (generic function with 1 method) +maullar(animal::Pantera) = "grrr" +# => maullar (generic function with 2 methods) +maullar(animal::Tigre) = "rawwwr" +# => maullar (generic function with 3 methods) + +# Se puede obtener una lista de métodos con la función methods. +methods(maullar) +#= + # 3 methods for generic function "maullar": + maullar(animal::Leon) at none:1 + maullar(animal::Pantera) at none:1 + maullar(animal::Tigre) at none:1 +=# + +# Prueba de la función maullar. +maullar(tigre) # => "rawwwr" +maullar(Leon("cafe", "ROAAR")) # => "ROAAR" +maullar(Pantera()) # => "grrr" + +# Revisar la jerarquía de tipos locales. +issubtype(Tigre, Gato) # => false # igual que: Tigre <: Gato +issubtype(Leon, Gato) # => true # igual que: Leon <: Gato +issubtype(Pantera, Gato) # => true + +# Definición de una función que acepta argumentos de tipo Gato. +mascota(gato::Gato) = println("El gato dice $(maullar(gato))") + +mascota(Leon("42")) # El gato dice 42 -mascota(Leon("42")) # => imprime "El gato dice 42" try - mascota(tigger) # => ERROR: no method mascota(Tigre)) + mascota(tigre) # ERROR: `mascota` has no method matching mascota(::Tigre) catch e - println(e) + println(e) # MethodError(mascota,(Tigre(3.5,"anaranjado"),)) end -# En los lenguajes orientados a objetos, expedición única es común. Esto -# significa que el método se recogió basándose en el tipo del primer argumento. -# En Julia, todos los tipos de argumentos contribuyen a seleccionar el mejor -# método. +# En los lenguajes orientados a objetos, el despacho simple es común. Esto +# significa que la implementación del método a llamar se selecciona en base +# al tipo del primer argumento. + +# En Julia, los tipos de todos los argumentos contribuyen a seleccionar método +# más específico. # Vamos a definir una función con más argumentos, para que podamos ver la # diferencia -function pelear(t::Tigre,c::Gato) - println("¡El tigre $(t.colordelpelaje) gana!") -end +pelear(t::Tigre, c::Gato) = println("¡El tigre $(t.color_pelaje) gana!") # => pelear (generic function with 1 method) -pelear(tigger,Pantera()) # => imprime ¡El tigre anaranjado gana! -pelear(tigger,Leon("ROAR")) # => ¡El tigre anaranjado gana! +pelear(tigre, Pantera()) # ¡El tigre anaranjado gana! +pelear(tigre, Leon("ROAR")) # ¡El tigre anaranjado gana! -# Vamos a cambiar el comportamiento cuando el Gato es específicamente un Leon -pelear(t::Tigre,l::Leon) = println("El león con melena $(l.color_de_crin) gana") +# Vamos a cambiar el comportamiento cuando el Gato sea específicamente un Leon. +pelear(t::Tigre, l::Leon) = println("El león con melena $(l.color_crin) gana.") # => pelear (generic function with 2 methods) -pelear(tigger,Pantera()) # => imprime ¡El tigre anaranjado gana! -pelear(tigger,Leon("ROAR")) # => imprime El león con melena verde gana +pelear(tigre, Pantera()) # ¡El tigre anaranjado gana! +pelear(tigre, Leon("ROAR")) # El león con melena verde gana. -# No necesitamos un tigre para poder luchar -pelear(l::Leon,c::Gato) = println("El gato victorioso dice $(maullar(c))") -# => fight (generic function with 3 methods) +# No necesitamos un tigre para poder luchar. +pelear(l::Leon, c::Gato) = println("El gato victorioso dice $(maullar(c)).") +# => pelear (generic function with 3 methods) + +methods(pelear) +#= + # 3 methods for generic function "pelear": + pelear(t::Tigre,l::Leon) at none:2 + pelear(t::Tigre,c::Gato) at none:1 + pelear(l::Leon,c::Gato) at none:2 +=# -pelear(Leon("balooga!"),Pantera()) # => imprime El gato victorioso dice grrr +pelear(Leon("balooga!"), Pantera()) # El gato victorioso dice grrr. try - pelear(Pantera(),Leon("RAWR")) # => ERROR: no method pelear(Pantera, Leon)) -catch + # ERROR: `pelear` has no method matching pelear(::Pantera, ::Leon) + pelear(Pantera(),Leon("RAWR")) +catch # no hacer nada con la excepción atrapada end -# Un metodo con el gato primero +# Un metodo con el tipo Gato primero. pelear(c::Gato,l::Leon) = println("El gato le gana al León") -# Warning: New definition -# pelear(Gato,Leon) at none:1 -# is ambiguous with: -# pelear(Leon,Gato) at none:1. -# To fix, define -# pelear(Leon,Leon) -# before the new definition. -# pelear (generic function with 4 methods) - -# Esta advertencia se debe a que no está claro que metodo de pelear será llamado -# en: -pelear(Leon("RAR"),Leon("cafe","rar")) # => imprime El gato victorioso dice rar -# El resultado puede ser diferente en otras versiones de Julia +#= + Warning: New definition + pelear(Gato,Leon) at none:1 + is ambiguous with: + pelear(Leon,Gato) at none:1. + To fix, define + pelear(Leon,Leon) + before the new definition. + pelear (generic function with 4 methods) +=# + +# Esta advertencia se debe a que no está claro que método de pelear +# será llamado en: +pelear(Leon("RAR"),Leon("cafe","rar")) # El gato victorioso dice rar. +# El resultado puede ser diferente en otras versiones de Julia 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 - - -# 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 - -# ¿Qué sucede cuando damos area_cuadrada diferentes argumentos? -code_native(area_cuadrada, (Int32,)) - # .section __TEXT,__text,regular,pure_instructions - # Filename: none - # Source line: 1 # Prologue - # push RBP - # mov RBP, RSP - # Source line: 1 - # movsxd RAX, EDI # Fetch l from memory? - # imul RAX, RAX # Square l and store the result in RAX - # pop RBP # Restore old base pointer - # ret # Result will still be in RAX - -code_native(area_cuadrada, (Float32,)) - # .section __TEXT,__text,regular,pure_instructions - # Filename: none - # Source line: 1 - # push RBP - # mov RBP, RSP - # Source line: 1 - # vmulss XMM0, XMM0, XMM0 # Scalar single precision multiply (AVX) - # pop RBP - # ret - -code_native(area_cuadrada, (Float64,)) - # .section __TEXT,__text,regular,pure_instructions - # Filename: none - # Source line: 1 - # push RBP - # mov RBP, RSP - # Source line: 1 - # vmulsd XMM0, XMM0, XMM0 # Scalar double precision multiply (AVX) - # pop RBP - # ret - # - -# 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) -area_circulo(5) # 78.53981633974483 + +pelear(Leon("GR"),Leon("cafe","rar")) # Los leones llegan a un empate + + +################################ +# 7. Un vistazo de bajo nivel. # +################################ + +# Se puede echar un vistazo al código IR de LLVM y al código +# ensamblador generado. +area_cuadrado(l) = l * l # => area_cuadrado (generic function with 1 method) + +area_cuadrado(5) # => 25 + +# ¿Qué sucede cuando damos area_cuadrada diferentes tipos de argumentos? +code_native(area_cuadrado, (Int32,)) +#= + .section __TEXT,__text,regular,pure_instructions + Filename: none + Source line: 1 # prólogo + push RBP + mov RBP, RSP + Source line: 1 + imul RDI, RDI # elevar l al cuadrado + mov RAX, RDI # almacenar el resultado en RAX + pop RBP # restaurar el puntero base anterior + ret # el resultado estará en RAX +=# + +code_native(area_cuadrado, (Float32,)) +#= + .section __TEXT,__text,regular,pure_instructions + Filename: none + Source line: 1 + push RBP + mov RBP, RSP + Source line: 1 + mulss XMM0, XMM0 # multiplicación escalar de presición simple (AVX) + pop RBP + ret +=# + +code_native(area_cuadrado, (Float64,)) +#= + .section __TEXT,__text,regular,pure_instructions + Filename: none + Source line: 1 + push RBP + mov RBP, RSP + Source line: 1 + mulsd XMM0, XMM0 # multiplicación escalar de presición doble (AVX) + pop RBP + ret +=# + +# Ten en cuenta que Julia usará instrucciones de punto flotante si el tipo de +# alguno de los argumentos es flotante. + +# Vamos a calcular el área de un círculo. +area_circulo(r) = π * r * r # area_circulo (generic function with 1 method) +area_circulo(5) # 78.53981633974483 code_native(area_circulo, (Int32,)) - # .section __TEXT,__text,regular,pure_instructions - # Filename: none - # Source line: 1 - # push RBP - # mov RBP, RSP - # Source line: 1 - # vcvtsi2sd XMM0, XMM0, EDI # Load integer (r) from memory - # movabs RAX, 4593140240 # Load pi - # vmulsd XMM1, XMM0, QWORD PTR [RAX] # pi * r - # vmulsd XMM0, XMM0, XMM1 # (pi * r) * r - # pop RBP - # ret - # +#= + .section __TEXT,__text,regular,pure_instructions + Filename: none + Source line: 1 + push RBP + mov RBP, RSP + Source line: 1 + cvtsi2sd XMM1, EDI # cargar entero r de la memoria + movabs RAX, 4477117456 # cargar constante matemática π + movsd XMM0, QWORD PTR [RAX] + mulsd XMM0, XMM1 # π * r + mulsd XMM0, XMM1 # (π * r) * r + pop RBP + ret +=# code_native(area_circulo, (Float64,)) - # .section __TEXT,__text,regular,pure_instructions - # Filename: none - # Source line: 1 - # push RBP - # mov RBP, RSP - # movabs RAX, 4593140496 - # Source line: 1 - # vmulsd XMM1, XMM0, QWORD PTR [RAX] - # vmulsd XMM0, XMM1, XMM0 - # pop RBP - # ret - # +#= + .section __TEXT,__text,regular,pure_instructions + Filename: none + Source line: 1 + push RBP + mov RBP, RSP + movabs RAX, 4477120336 + movsd XMM1, QWORD PTR [RAX] + Source line: 1 + mulsd XMM1, XMM0 + mulsd XMM1, XMM0 + movaps XMM0, XMM1 + pop RBP + ret +=# ``` -## ¿Listo para más? +![Julia-tan](http://www.mechajyo.org/wp/wp-content/uploads/2014/10/3a2c3b7de5dd39aa7f056a707cd4eb59.png) -Puedes obtener muchos más detalles en [The Julia Manual](http://docs.julialang.org/en/latest/manual/) +## ¿Listo para más? -El mejor lugar para obtener ayuda con Julia es el (muy amable) [lista de correos](https://groups.google.com/forum/#!forum/julia-users). +Para más detalles, lee el [manual de Julia](http://docs.julialang.org/en/release-0.3). +El mejor lugar para obtener ayuda con Julia, es en su amigable [lista de correos](https://groups.google.com/forum/#!forum/julia-users). -- cgit v1.2.3 From b0036199c4fa6974f285e3b9520e9e058294d584 Mon Sep 17 00:00:00 2001 From: Adam Bard Date: Wed, 30 Sep 2015 10:40:48 +0800 Subject: Still can't use `julia` highlighting --- es-es/julia-es.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'es-es/julia-es.html.markdown') diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown index 1e01c2e3..65cb4343 100644 --- a/es-es/julia-es.html.markdown +++ b/es-es/julia-es.html.markdown @@ -41,7 +41,7 @@ En Julia los programas están organizados entorno al [despacho múltiple](http:/ Esto se basa en la versión `0.3.11`. -```julia +```ruby # Los comentarios de una línea comienzan con una almohadilla (o signo de gato). #= -- cgit v1.2.3 From 64d031429dd68fdd5b76fdd0e87f8379ba681439 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ismael=20Venegas=20Castell=C3=B3?= Date: Wed, 30 Sep 2015 00:10:14 -0500 Subject: Use smaller images I didn't notice they wouldnt fit well, because they fitted ok in github preview. --- es-es/julia-es.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'es-es/julia-es.html.markdown') diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown index 65cb4343..95a16412 100644 --- a/es-es/julia-es.html.markdown +++ b/es-es/julia-es.html.markdown @@ -9,7 +9,7 @@ filename: learnjulia-es.jl lang: es-es --- -![JuliaLang](https://camo.githubusercontent.com/e1ae5c7f6fe275a50134d5889a68f0acdd09ada8/687474703a2f2f6a756c69616c616e672e6f72672f696d616765732f6c6f676f5f68697265732e706e67) +![JuliaLang](http://s13.postimg.org/z89djuwyf/julia_small.png) [Julia](http://julialanges.github.io) es un [lenguaje de programación](http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n) [multiplataforma](http://es.wikipedia.org/wiki/Multiplataforma) y [multiparadigma](http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n_multiparadigma) de [tipado dinámico](http://es.wikipedia.org/wiki/Tipado_din%C3%A1mico), [alto nivel](http://es.wikipedia.org/wiki/Lenguaje_de_alto_nivel) y [alto desempeño](http://es.wikipedia.org/wiki/Computaci%C3%B3n_de_alto_rendimiento) para la computación [genérica](http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n_de_prop%C3%B3sito_general), [técnica y científica](http://es.wikipedia.org/wiki/Computaci%C3%B3n_cient%C3%ADfica), con una sintaxis que es familiar para los usuarios de otros entornos de computación técnica y científica. Provee de un [sofisticado compilador JIT](http://es.wikipedia.org/wiki/Compilaci%C3%B3n_en_tiempo_de_ejecuci%C3%B3n), [ejecución distribuida y paralela](http://docs.julialang.org/en/release-0.3/manual/parallel-computing), [precisión numérica](http://julia.readthedocs.org/en/latest/manual/integers-and-floating-point-numbers) y de una [extensa librería con funciones matemáticas](http://docs.julialang.org/en/release-0.3/stdlib). La librería estándar, escrita casi completamente en Julia, también integra las mejores y más maduras librerías de C y Fortran para el [álgebra lineal](http://docs.julialang.org/en/release-0.3/stdlib/linalg), [generación de números aleatorios](http://docs.julialang.org/en/release-0.3/stdlib/numbers/?highlight=random#random-numbers), [procesamiento de señales](http://docs.julialang.org/en/release-0.3/stdlib/math/?highlight=signal#signal-processing), y [procesamiento de cadenas](http://docs.julialang.org/en/release-0.3/stdlib/strings). Adicionalmente, la comunidad de [desarrolladores de Julia](https://github.com/JuliaLang/julia/graphs/contributors) contribuye un número de [paquetes externos](http://pkg.julialang.org) a través del gestor de paquetes integrado de Julia a un paso acelerado. [IJulia](https://github.com/JuliaLang/IJulia.jl), una colaboración entre las comunidades de [IPython](http://ipython.org) y Julia, provee de una poderosa interfaz gráfica basada en el [navegador para Julia](https://juliabox.org). @@ -931,7 +931,7 @@ code_native(area_circulo, (Float64,)) =# ``` -![Julia-tan](http://www.mechajyo.org/wp/wp-content/uploads/2014/10/3a2c3b7de5dd39aa7f056a707cd4eb59.png) +![Julia-tan](http://s27.postimg.org/x37ndhz0j/julia_tan_small.png) ## ¿Listo para más? -- cgit v1.2.3 From e4a33446a9c910f13bc0224c745c51baf62c1778 Mon Sep 17 00:00:00 2001 From: Jesus Tinoco Date: Thu, 1 Oct 2015 21:34:02 +0200 Subject: Typos fixed in julia-es.html.markdown --- es-es/julia-es.html.markdown | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'es-es/julia-es.html.markdown') diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown index 95a16412..bf035edf 100644 --- a/es-es/julia-es.html.markdown +++ b/es-es/julia-es.html.markdown @@ -45,7 +45,7 @@ Esto se basa en la versión `0.3.11`. # Los comentarios de una línea comienzan con una almohadilla (o signo de gato). #= - Los commentarios multilínea pueden escribirse + Los comentarios multilínea pueden escribirse usando '#=' antes de el texto y '=#' después del texto. También se pueden anidar. =# @@ -174,7 +174,7 @@ otraVariable_123! = 6 # => 6 otra_variable * Los nombres de los tipos comienzan con una letra mayúscula y separación de - palabras se muestra con CamelCase en vez de guion bajo: + palabras se muestra con CamelCase en vez de guión bajo: OtroTipo @@ -214,7 +214,7 @@ matrix = [1 2; 3 4] 3 4 =# -# Añadir cosas a la final de un arreglo con push! y append!. +# Añadir cosas al final de un arreglo con push! y append!. push!(a, 1) # => [1] push!(a, 2) # => [1,2] push!(a, 4) # => [1,2,4] @@ -237,7 +237,7 @@ a[end] # => 6 shift!(a) # => 1 y a es ahora: [2,4,3,4,5,6] unshift!(a, 7) # => [7,2,4,3,4,5,6] -# Los nombres de funciónes que terminan en exclamaciones indican que modifican +# Los nombres de funciones que terminan en exclamaciones indican que modifican # su o sus argumentos de entrada. arr = [5, 4, 6] # => 3-element Array{Int64,1}: [5,4,6] sort(arr) # => [4,5,6] y arr es todavía: [5,4,6] @@ -710,7 +710,7 @@ end # Sólo define una función del mismo nombre que el tipo y llama al constructor # existente para obtener un valor del tipo correcto. -# Este es un constructor externo porque es fuera de la definición del tipo. +# Este es un constructor externo porque está fuera de la definición del tipo. Leon(rugido::String) = Leon("verde", rugido) type Pantera <: Gato # Pantera también es un a subtipo de Gato @@ -730,7 +730,7 @@ end ######################## # En Julia, todas las funciones nombradas son funciones genéricas. -# Esto significa que se construyen a partir de muchos métodosmás pequeños. +# Esto significa que se construyen a partir de muchos métodos más pequeños. # Cada constructor de Leon es un método de la función genérica Leon. # Por ejemplo, vamos a hacer métodos para para Leon, Pantera, y Tigre de una -- cgit v1.2.3 From c0b09da46f93bc1b59231c9ebd2832198bc85fcb Mon Sep 17 00:00:00 2001 From: Jesus Tinoco Date: Fri, 2 Oct 2015 16:11:23 +0200 Subject: Fixing typo in julia-es.html.markdown --- es-es/julia-es.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'es-es/julia-es.html.markdown') diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown index bf035edf..e4181609 100644 --- a/es-es/julia-es.html.markdown +++ b/es-es/julia-es.html.markdown @@ -733,7 +733,7 @@ end # Esto significa que se construyen a partir de muchos métodos más pequeños. # Cada constructor de Leon es un método de la función genérica Leon. -# Por ejemplo, vamos a hacer métodos para para Leon, Pantera, y Tigre de una +# Por ejemplo, vamos a hacer métodos para Leon, Pantera, y Tigre de una # función genérica maullar: # acceso utilizando notación de puntos -- cgit v1.2.3