From f88b0ba326f40a9e14b24438ecc1963d0138973f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20B=C3=BCttner?= Date: Sat, 24 Aug 2013 12:23:41 +0100 Subject: Fixed typo in Julia document Element was popped from wrong array. --- julia.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 1023e303..cf3a464b 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -147,7 +147,7 @@ push!(a,3) #=> [1,2,4,3] append!(a,b) #=> [1,2,4,3,4,5,6] # Remove from the end with pop -pop!(a) #=> 6 and b is now [4,5] +pop!(b) #=> 6 and b is now [4,5] # Let's put it back push!(b,6) # b is now [4,5,6] again. -- cgit v1.2.3 From 86c2bafaa542f643fc8db15f3bd38dc92cfbe831 Mon Sep 17 00:00:00 2001 From: Leah Hanson Date: Thu, 26 Sep 2013 15:38:48 -0400 Subject: improved first half of Julia tutorial: reworded comments, added a few new tips, fixed a bug or two. --- julia.html.markdown | 53 +++++++++++++++++++++++++++++++++-------------------- 1 file changed, 33 insertions(+), 20 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index cf3a464b..e824bfcf 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -20,20 +20,20 @@ This is based on the current development version of Julia, as of June 29th, 2013 # Everything in Julia is a expression. -# You have numbers +# 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}) -# Math is what you would expect +# 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 -5 / 2 #=> 2.5 -div(5, 2) #=> 2 2 ^ 2 #=> 4 # power, not bitwise xor 12 % 10 #=> 2 @@ -77,11 +77,13 @@ false # Strings are created with " "This is a string." -# Character literals written with ' +# Character literals are written with ' 'a' -# A string can be treated like a list of characters +# 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 reccommended (map, for loops, etc). # $ can be used for string interpolation: "2 + 2 = $(2 + 2)" #=> "2 + 2 = 4" @@ -94,10 +96,10 @@ false ## 2. Variables and Collections #################################################### -# Printing is pretty easy +# Printing is easy println("I'm Julia. Nice to meet you!") -# No need to declare variables before assigning to them. +# You don't declare variables before assigning to them. some_var = 5 #=> 5 some_var #=> 5 @@ -108,12 +110,14 @@ catch e println(e) end -# Variable name start with a letter. You can use uppercase letters, digits, -# and exclamation points as well after the initial alphabetic character. +# 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: # @@ -158,6 +162,10 @@ a[1] #=> 1 # remember that Julia indexes from 1, not 0! # 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] @@ -182,23 +190,24 @@ 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 arbitrary elements from a list with splice! +# 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, 3, 4, 5, 1, 2, 3] +append!(a,b) # Now a is [1, 2, 3, 4, 5, 1, 2, 3] # Check for existence in a list with contains contains(a,1) #=> true # Examine the length with length -length(a) #=> 7 +length(a) #=> 8 # Tuples are immutable. -tup = (1, 2, 3) #=>(1,2,3) # an (Int64,Int64,Int64) tuple. +tup = (1, 2, 3) #=> (1,2,3) # an (Int64,Int64,Int64) tuple. tup[1] #=> 1 try: tup[0] = 3 #=> ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) @@ -214,17 +223,21 @@ contains(tup,2) #=> 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 by default if you leave out the parentheses +# Tuples are created even if you leave out the parentheses d, e, f = 4, 5, 6 #=> (4,5,6) -# Now look how easy it is to swap two values +# 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}() -# Here is a prefilled dictionary +# You can create a dictionary using a literal filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3] # => Dict{ASCIIString,Int64} @@ -247,19 +260,19 @@ contains(filled_dict, ("two", 3)) #=> false haskey(filled_dict, "one") #=> true haskey(filled_dict, 1) #=> false -# Trying to look up a non-existing key will raise an error +# 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 get method to avoid the error +# 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 -# Sets store sets +# Use Sets to represent collections of unordered, unique values empty_set = Set() #=> Set{Any}() # Initialize a set with a bunch of values filled_set = Set(1,2,2,3,4) #=> Set{Int64}(1,2,3,4) -- cgit v1.2.3 From 7ec6479a3cbd5d50030492d3982e21a15410b21a Mon Sep 17 00:00:00 2001 From: Leah Hanson Date: Fri, 18 Oct 2013 18:33:42 -0500 Subject: Revised Julia in Y Minutes, until Types section. --- julia.html.markdown | 80 ++++++++++++++++++++++++++++++++--------------------- 1 file changed, 49 insertions(+), 31 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index e824bfcf..f8c2f6e7 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -274,22 +274,22 @@ get(filled_dict,"four",4) #=> 4 # Use Sets to represent collections of unordered, unique values empty_set = Set() #=> Set{Any}() -# Initialize a set with a bunch of values +# Initialize a set with values filled_set = Set(1,2,2,3,4) #=> Set{Int64}(1,2,3,4) -# Add more items to a set +# Add more values to a set add!(filled_set,5) #=> Set{Int64}(5,4,2,3,1) +# Check if the values are in the set +contains(filled_set,2) #=> true +contains(filled_set,10) #=> 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) -# Check for existence in a set with contains -contains(filled_set,2) #=> true -contains(filled_set,10) #=> false - #################################################### ## 3. Control Flow @@ -298,8 +298,7 @@ contains(filled_set,10) #=> false # Let's make a variable some_var = 5 -# Here is an if statement. Indentation is NOT meaningful in Julia. -# prints "some var is smaller than 10" +# 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. @@ -307,44 +306,56 @@ elseif some_var < 10 # This elseif clause is optional. 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, such as ranges, lists, sets, dicts, strings. - +# For loops iterate over iterables. +# Iterable types include Range, Array, Set, Dict, and String. for animal=["dog", "cat", "mouse"] - # You can use $ to interpolate into strings 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 =, if you want. +# 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[2])") + 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 $v") + println("$k is a $v") end - - -# While loops go until a condition is no longer met. # prints: -# 0 -# 1 -# 2 -# 3 +# 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/except block try @@ -359,11 +370,14 @@ end ## 4. Functions #################################################### -# Use the keyword function to create new 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 implicitly return the value of their last statement + # Functions return the value of their last statement x + y end @@ -373,13 +387,16 @@ add(5, 6) #=> 11 after printing out "x is 5 and y is 6" # 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. -# It can also be used in a fuction call -# to splat a list or tuple out to be the arguments +# 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) @@ -412,7 +429,7 @@ keyword_args(name2="ness") #=> ["name2"=>"ness","k1"=>4] keyword_args(k1="mine") #=> ["k1"=>"mine","name2"=>"hello"] keyword_args() #=> ["name2"=>"hello","k2"=>4] -# You can also do both at once +# 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") @@ -433,12 +450,15 @@ function create_adder(x) return adder end -# or equivalently +# 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 +# You can also name the internal function, if you want function create_adder(x) function adder(y) x + y @@ -449,14 +469,12 @@ end add_10 = create_adder(10) add_10(3) #=> 13 -# The first two inner functions above are anonymous functions -(x -> x > 2)(3) #=> true # 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 nice maps and filters +# 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] -- cgit v1.2.3 From 364c367ff3de7d65d68c909316f805213de262d4 Mon Sep 17 00:00:00 2001 From: Leah Hanson Date: Fri, 18 Oct 2013 23:48:02 -0500 Subject: Expanded Type and Multiple Dispatch sections, and added more dispatch examples. Also added link to mailing list. --- julia.html.markdown | 151 +++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 131 insertions(+), 20 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index f8c2f6e7..85aca49d 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -479,49 +479,104 @@ filter(x -> x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] [add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13] #################################################### -## 5. Types and Multiple-Dispatch +## 5. Types #################################################### -# Type definition +# 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 # no type annotation is implicitly Any + coatcolor # not including a type annotation is the same as `::Any` end -# default constructor is the properties in order -# so, Tiger(taillength,coatcolor) -# Type instantiation -tigger = Tiger(3.5,"orange") # the type doubles as the constructor function +# The default constructor's arguments are the properties +# of the tyep, in order 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") -# Abtract Types -abstract Cat # just a name and point in the type hierarchy +# These struct-style types are called concrete types +# They can be instantiated, but cannot have subtypes. +# The other kind of types is abstract types. -# * types defined with the type keyword are concrete types; they can be -# instantiated -# -# * types defined with the abstract keyword are abstract types; they can -# have subtypes. -# -# * each type has one supertype; a supertype can have zero or more subtypes. +# 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 Panter does, gives you control +# over how values of the type can be created. +# When possible, you should use outer constructors rather than inner ones. -# Multiple Dispatch +#################################################### +## 6. Multiple-Dispatch +#################################################### # In Julia, all named functions are generic functions # This means that they are built up from many small methods -# For example, let's make a function meow: +# 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(cat::Lion) - cat.roar # access properties using dot notation + cat.roar # access type properties using dot notation end function meow(cat::Panther) @@ -532,21 +587,76 @@ function meow(cat::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 -pet_cat(Lion(Panther(),"42")) #=> prints "The cat says 42" +# 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))") +end +#=> 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 ``` @@ -554,3 +664,4 @@ pet_cat(Lion(Panther(),"42")) #=> prints "The cat says 42" 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 d0e50426089263b4e629a44a1e4d4a30d6f276ae Mon Sep 17 00:00:00 2001 From: Leah Hanson Date: Fri, 18 Oct 2013 23:51:07 -0500 Subject: remove extraneous end --- julia.html.markdown | 1 - 1 file changed, 1 deletion(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 85aca49d..50ea6a80 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -631,7 +631,6 @@ 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))") -end #=> fight (generic function with 3 methods) fight(Lion("balooga!"),Panther()) #=> prints The victorious cat says grrr -- cgit v1.2.3 From 67472bb3911fefaaff2da458ee854d26c5a272b9 Mon Sep 17 00:00:00 2001 From: Leah Hanson Date: Fri, 18 Oct 2013 23:58:33 -0500 Subject: updated method names (add! -> push!, contains -> in) --- julia.html.markdown | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 50ea6a80..741dfc92 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -201,7 +201,7 @@ 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 contains -contains(a,1) #=> true +in(a,1) #=> true # Examine the length with length length(a) #=> 8 @@ -218,7 +218,7 @@ end # Many list functions also work on tuples length(tup) #=> 3 tup[1:2] #=> (1,2) -contains(tup,2) #=> true +in(tup,2) #=> 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 @@ -255,8 +255,8 @@ values(filled_dict) # Note - Same as above regarding key ordering. # Check for existence of keys in a dictionary with contains, haskey -contains(filled_dict, ("one", 1)) #=> true -contains(filled_dict, ("two", 3)) #=> false +in(filled_dict, ("one", 1)) #=> true +in(filled_dict, ("two", 3)) #=> false haskey(filled_dict, "one") #=> true haskey(filled_dict, 1) #=> false @@ -278,11 +278,11 @@ empty_set = Set() #=> Set{Any}() filled_set = Set(1,2,2,3,4) #=> Set{Int64}(1,2,3,4) # Add more values to a set -add!(filled_set,5) #=> Set{Int64}(5,4,2,3,1) +push!(filled_set,5) #=> Set{Int64}(5,4,2,3,1) # Check if the values are in the set -contains(filled_set,2) #=> true -contains(filled_set,10) #=> false +in(filled_set,2) #=> true +in(filled_set,10) #=> false # There are functions for set intersection, union, and difference. other_set = Set(3, 4, 5, 6) #=> Set{Int64}(6,4,5,3) -- cgit v1.2.3 From 5e362f5f4fd77f162453146b8c24fe3855a041fd Mon Sep 17 00:00:00 2001 From: Leah Hanson Date: Fri, 18 Oct 2013 23:59:21 -0500 Subject: updated date --- julia.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 741dfc92..ad8a5741 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -8,7 +8,7 @@ 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 June 29th, 2013. +This is based on the current development version of Julia, as of October 18th, 2013. ```ruby -- cgit v1.2.3 From 34aedd3fbb2223fe9258e13326273e1d04fc99b0 Mon Sep 17 00:00:00 2001 From: Leah Hanson Date: Mon, 21 Oct 2013 09:39:45 -0500 Subject: Fix a couple forgotten references to `contains` in the comments --- julia.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index ad8a5741..4ebd50ff 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -200,7 +200,7 @@ splice!(arr,2) #=> 4 ; arr is now [3,5] 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 contains +# Check for existence in a list with in in(a,1) #=> true # Examine the length with length @@ -254,7 +254,7 @@ 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 contains, haskey +# Check for existence of keys in a dictionary with in, haskey in(filled_dict, ("one", 1)) #=> true in(filled_dict, ("two", 3)) #=> false haskey(filled_dict, "one") #=> true -- cgit v1.2.3 From 2a60ecbb8d5d6a22fe5df3aa1efa8f1314da9326 Mon Sep 17 00:00:00 2001 From: supernullset Date: Mon, 4 Nov 2013 19:21:17 -0800 Subject: Update syntax for `in` calls The call was flipped from how it is in the current documentation: http://docs.julialang.org/en/latest/stdlib/base/#Base.in --- julia.html.markdown | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 4ebd50ff..c3d2195b 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -100,7 +100,7 @@ false println("I'm Julia. Nice to meet you!") # You don't declare variables before assigning to them. -some_var = 5 #=> 5 +some_var = 5 #=> 5 some_var #=> 5 # Accessing a previously unassigned variable is an error @@ -201,7 +201,7 @@ 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(a,1) #=> true +in(1, a) #=> true # Examine the length with length length(a) #=> 8 @@ -218,7 +218,7 @@ end # Many list functions also work on tuples length(tup) #=> 3 tup[1:2] #=> (1,2) -in(tup,2) #=> true +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 @@ -249,14 +249,14 @@ 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 +# 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(filled_dict, ("one", 1)) #=> true -in(filled_dict, ("two", 3)) #=> false +in(("one", 1), filled_dict) #=> true +in(("two", 3), filled_dict) #=> false haskey(filled_dict, "one") #=> true haskey(filled_dict, 1) #=> false @@ -281,8 +281,8 @@ filled_set = Set(1,2,2,3,4) #=> Set{Int64}(1,2,3,4) push!(filled_set,5) #=> Set{Int64}(5,4,2,3,1) # Check if the values are in the set -in(filled_set,2) #=> true -in(filled_set,10) #=> false +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) @@ -396,7 +396,7 @@ 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. +# 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) @@ -423,7 +423,7 @@ end # You can define functions that take keyword arguments function keyword_args(;k1=4,name2="hello") # note the ; return ["k1"=>k1,"name2"=>name2] -end +end keyword_args(name2="ness") #=> ["name2"=>"ness","k1"=>4] keyword_args(k1="mine") #=> ["k1"=>"mine","name2"=>"hello"] @@ -511,7 +511,7 @@ end # The default constructor's arguments are the properties # of the tyep, in order 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") @@ -529,8 +529,8 @@ subtypes(Number) #=> 6-element Array{Any,1}: # Complex{Float32} # Complex{Float64} # Complex{T<:Real} - # ImaginaryUnit - # Real + # ImaginaryUnit + # Real subtypes(Cat) #=> 0-element Array{Any,1} # Every type has a super type; use the `super` function to get it. @@ -565,7 +565,7 @@ end # When possible, you should use outer constructors rather than inner ones. #################################################### -## 6. Multiple-Dispatch +## 6. Multiple-Dispatch #################################################### # In Julia, all named functions are generic functions @@ -641,11 +641,11 @@ end # Also let the cat go first fight(c::Cat,l::Lion) = println("The cat beats the Lion") -#=> Warning: New definition +#=> Warning: New definition # fight(Cat,Lion) at none:1 -# is ambiguous with +# is ambiguous with # fight(Lion,Cat) at none:2. -# Make sure +# Make sure # fight(Lion,Lion) # is defined first. #fight (generic function with 4 methods) -- cgit v1.2.3 From a36cee194b40dd59608d3e306e74e1b68ba9aa46 Mon Sep 17 00:00:00 2001 From: Nami-Doc Date: Tue, 26 Nov 2013 09:32:11 +0100 Subject: fix #425 --- julia.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index c3d2195b..d05e165d 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -402,7 +402,7 @@ 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) +Set(x...) #=> Set{Int64}(1,2,3) # You can define functions with optional positional arguments -- cgit v1.2.3 From 3bc960034c867fd4255db3f80ddbe6f85901647b Mon Sep 17 00:00:00 2001 From: Nami-Doc Date: Tue, 3 Dec 2013 14:40:05 +0100 Subject: typos --- julia.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index d05e165d..d1e17a26 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -357,7 +357,7 @@ end # 2 # 3 -# Handle exceptions with a try/except block +# Handle exceptions with a try/catch block try error("help") catch e @@ -402,7 +402,7 @@ 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}(1,2,3) +Set(x...) #=> Set{Int64}(2,3,1) # You can define functions with optional positional arguments -- cgit v1.2.3 From b32d26240c5c4c51c7df6b219c656fd11a862410 Mon Sep 17 00:00:00 2001 From: Adrian Lopez Date: Mon, 16 Dec 2013 18:41:44 +0100 Subject: Trying to set a value in index 0. Is confusing --- julia.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index d1e17a26..4869e207 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -210,7 +210,7 @@ length(a) #=> 8 tup = (1, 2, 3) #=> (1,2,3) # an (Int64,Int64,Int64) tuple. tup[1] #=> 1 try: - tup[0] = 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) end -- cgit v1.2.3 From d297853c06f4651da4c83f536d601140ae4d571d Mon Sep 17 00:00:00 2001 From: Adrian Lopez Date: Mon, 16 Dec 2013 23:33:41 +0100 Subject: Is a little confusing naming the variable as the abstract. At first I was thinking that cat::Lion means that you are waiting for a Lion type of super type Cat --- julia.html.markdown | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index d1e17a26..4e89bea5 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -575,15 +575,15 @@ end # For a non-constructor example, let's make a function meow: # Definitions for Lion, Panther, Tiger -function meow(cat::Lion) - cat.roar # access type properties using dot notation +function meow(animal::Lion) + animal.roar # access type properties using dot notation end -function meow(cat::Panther) +function meow(animal::Panther) "grrr" end -function meow(cat::Tiger) +function meow(animal::Tiger) "rawwwr" end -- cgit v1.2.3 From e7b43c1ba3239d7e13fb5fa40a7dd44fba6a48de Mon Sep 17 00:00:00 2001 From: chappers Date: Thu, 19 Dec 2013 16:23:25 +1100 Subject: [julia/en] Fixed Spelling Mistake --- julia.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 4869e207..f1e1a4a2 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -83,7 +83,7 @@ false # 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 reccommended (map, for loops, etc). +# so iterating over strings is recommended (map, for loops, etc). # $ can be used for string interpolation: "2 + 2 = $(2 + 2)" #=> "2 + 2 = 4" -- cgit v1.2.3 From e7dcbed40ddbbcad60dd43edd6fd372141a75077 Mon Sep 17 00:00:00 2001 From: Alex Altair Date: Sat, 28 Dec 2013 02:22:25 -0800 Subject: Fix typos and indentation --- julia.html.markdown | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index ce55f956..4b946d46 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -105,7 +105,7 @@ some_var #=> 5 # Accessing a previously unassigned variable is an error try - some_other_var #=> ERROR: some_other_var not defined + some_other_var #=> ERROR: some_other_var not defined catch e println(e) end @@ -417,7 +417,7 @@ try defaults('h') #=> ERROR: no method defaults(Char,) defaults() #=> ERROR: no methods defaults() catch e -println(e) + println(e) end # You can define functions that take keyword arguments @@ -509,7 +509,7 @@ type Tiger end # The default constructor's arguments are the properties -# of the tyep, in order the order they are listed in the definition +# 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 -- cgit v1.2.3 From 400b00aa87a98f0601a566f94038d2b2197aae1a Mon Sep 17 00:00:00 2001 From: Laban Kimotho Date: Fri, 24 Jan 2014 10:59:53 +0200 Subject: typo fixes + view generated low level code --- julia.html.markdown | 79 +++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 77 insertions(+), 2 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 4b946d46..58ff7608 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -427,7 +427,7 @@ end keyword_args(name2="ness") #=> ["name2"=>"ness","k1"=>4] keyword_args(k1="mine") #=> ["k1"=>"mine","name2"=>"hello"] -keyword_args() #=> ["name2"=>"hello","k2"=>4] +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") @@ -560,7 +560,7 @@ type Panther <: Cat # Panther is also a subtype of Cat Panther() = new("green") # Panthers will only have this constructor, and no default constructor. end -# Using inner constructors, like Panter does, gives you control +# 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. @@ -657,6 +657,81 @@ fight(Lion("RAR"),Lion("brown","rarrr")) #=> prints The victorious cat says rarr 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 intermediate code and the assembly code generated. + +square_area(l) = l * l # square_area (generic function with 1 method) + +square_area(5) #25 + +code_native(square_area, (Int32,)) # What happens when we feed square_area an integer? + # .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 # 32bit square of 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 multiplication (AVX) (in this case square the number) + # 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 multiplacation (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 -- cgit v1.2.3 From c705d16a3e0b49f274564b3e61faa219ab63bd78 Mon Sep 17 00:00:00 2001 From: Laban Kimotho Date: Fri, 24 Jan 2014 11:06:41 +0200 Subject: style fixes --- julia.html.markdown | 30 ++++++++++++++++-------------- 1 file changed, 16 insertions(+), 14 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 58ff7608..3bc660cf 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -659,23 +659,24 @@ fight(Lion("RAR"),Lion("brown","rarrr")) #=> prints The lions come to a tie # Under the hood -# You can take a look at the llvm intermediate code and the assembly code generated. +# 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 -code_native(square_area, (Int32,)) # What happens when we feed square_area an integer? +# 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 + # Source line: 1 # Prologue # push RBP # mov RBP, RSP # Source line: 1 - # movsxd RAX, EDI # Fetch l from memory? - # imul RAX, RAX # 32bit square of l and store the result in RAX - # pop RBP # Restore old base pointer - # ret # Result will still be in RAX + # 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 @@ -684,7 +685,7 @@ code_native(square_area, (Float32,)) # push RBP # mov RBP, RSP # Source line: 1 - # vmulss XMM0, XMM0, XMM0 # Scalar single precision multiplication (AVX) (in this case square the number) + # vmulss XMM0, XMM0, XMM0 # Scalar single precision multiply (AVX) # pop RBP # ret @@ -695,11 +696,12 @@ code_native(square_area, (Float64,)) # push RBP # mov RBP, RSP # Source line: 1 - # vmulsd XMM0, XMM0, XMM0 # Scalar double precision multiplacation (AVX) + # 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. +# 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 @@ -711,10 +713,10 @@ code_native(circle_area, (Int32,)) # 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 + # 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 # -- cgit v1.2.3 From 0f4760f9eacc787de61e60b333a5ce8b3aa2321a Mon Sep 17 00:00:00 2001 From: brk0_0 Date: Sat, 8 Feb 2014 13:03:50 -0200 Subject: Moved println() from 'Variables and Collections' section --- julia.html.markdown | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 3bc660cf..b8e24b39 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -92,13 +92,13 @@ false # 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 #################################################### -# Printing is easy -println("I'm Julia. Nice to meet you!") - # You don't declare variables before assigning to them. some_var = 5 #=> 5 some_var #=> 5 -- cgit v1.2.3 From 9395900afd940e265b21a050f05290214ef37d44 Mon Sep 17 00:00:00 2001 From: Guillermo Garza Date: Tue, 18 Mar 2014 13:57:02 -0500 Subject: Remove multiline comments Julia introduced "#=" and "=#" as the delimiters for multiline comments. --- julia.html.markdown | 318 ++++++++++++++++++++++++++-------------------------- 1 file changed, 159 insertions(+), 159 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index b8e24b39..8245e616 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -21,58 +21,58 @@ This is based on the current development version of Julia, as of October 18th, 2 # 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}) +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 +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 +(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 +~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" +# => "0000000000000000000000000000000000000000000000000011000000111001" bits(12345.0) -#=> "0100000011001000000111001000000000000000000000000000000000000000" +# => "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 +!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 +1 < 2 < 3 # => true +2 < 3 < 2 # => false # Strings are created with " "This is a string." @@ -81,12 +81,12 @@ false 'a' # A string can be indexed like an array of characters -"This is a string"[1] #=> 'T' # Julia indexes from 1 +"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" +"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. @@ -100,24 +100,24 @@ println("I'm Julia. Nice to meet you!") #################################################### # You don't declare variables before assigning to them. -some_var = 5 #=> 5 -some_var #=> 5 +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 + 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 +SomeOtherVar123! = 6 # => 6 # You can also use unicode characters -☃ = 8 #=> 8 +☃ = 8 # => 8 # These are especially handy for mathematical notation -2 * π #=> 6.283185307179586 +2 * π # => 6.283185307179586 # A note on naming conventions in Julia: # @@ -133,49 +133,49 @@ SomeOtherVar123! = 6 #=> 6 # 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 +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 +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] +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] +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] +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! +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 +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] +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] +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 + 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 @@ -185,110 +185,110 @@ end # 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] +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] +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] +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 +in(1, a) # => true # Examine the length with length -length(a) #=> 8 +length(a) # => 8 # Tuples are immutable. -tup = (1, 2, 3) #=> (1,2,3) # an (Int64,Int64,Int64) tuple. -tup[1] #=> 1 +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) + 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 +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 +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) +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 +(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 +e, d = d, e # => (5,4) # d is now 5 and e is now 4 # Dictionaries store mappings -empty_dict = Dict() #=> Dict{Any,Any}() +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 +filled_dict["one"] # => 1 # Get all keys keys(filled_dict) -#=> KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2]) +# => 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]) +# => 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 +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 + 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 +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}() +empty_set = Set() # => Set{Any}() # Initialize a set with values -filled_set = Set(1,2,2,3,4) #=> Set{Int64}(1,2,3,4) +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) +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 +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) +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) #################################################### @@ -306,7 +306,7 @@ elseif some_var < 10 # This elseif clause is optional. else # The else clause is optional too. println("some_var is indeed 10.") end -#=> prints "some var is smaller than 10" +# => prints "some var is smaller than 10" # For loops iterate over iterables. @@ -363,7 +363,7 @@ try catch e println("caught it $e") end -#=> caught it ErrorException("help") +# => caught it ErrorException("help") #################################################### @@ -381,7 +381,7 @@ function add(x, y) x + y end -add(5, 6) #=> 11 after printing out "x is 5 and y is 6" +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 @@ -389,20 +389,20 @@ function varargs(args...) return args # use the keyword return to return anywhere in the function end -#=> varargs (generic function with 1 method) +# => varargs (generic function with 1 method) -varargs(1,2,3) #=> (1,2,3) +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) +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) +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 @@ -410,12 +410,12 @@ 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" +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() + defaults('h') # => ERROR: no method defaults(Char,) + defaults() # => ERROR: no methods defaults() catch e println(e) end @@ -425,9 +425,9 @@ 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] +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") @@ -451,7 +451,7 @@ function create_adder(x) end # This is "stabby lambda syntax" for creating anonymous functions -(x -> x > 2)(3) #=> true +(x -> x > 2)(3) # => true # This function is identical to create_adder implementation above. function create_adder(x) @@ -467,16 +467,16 @@ function create_adder(x) end add_10 = create_adder(10) -add_10(3) #=> 13 +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] +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] +[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 @@ -485,11 +485,11 @@ filter(x -> x > 5, [3, 4, 5, 6, 7]) #=> [6, 7] # 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 +typeof(5) # => Int64 # Types are first-class values -typeof(Int64) #=> DataType -typeof(DataType) #=> DataType +typeof(Int64) # => DataType +typeof(DataType) # => DataType # DataType is the type that represents types, including itself. # Types are used for documentation, optimizations, and dispatch. @@ -510,10 +510,10 @@ 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") +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") +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. @@ -524,23 +524,23 @@ 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}: +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(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 +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 @@ -588,23 +588,23 @@ function meow(animal::Tiger) end # Testing the meow function -meow(tigger) #=> "rawwr" -meow(Lion("brown","ROAAR")) #=> "ROAAR" -meow(Panther()) #=> "grrr" +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 +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" +pet_cat(Lion("42")) # => prints "The cat says 42" try - pet_cat(tigger) #=> ERROR: no method pet_cat(Tiger,) + pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,) catch e println(e) end @@ -617,31 +617,31 @@ end function fight(t::Tiger,c::Cat) println("The $(t.coatcolor) tiger wins!") end -#=> fight (generic function with 1 method) +# => fight (generic function with 1 method) -fight(tigger,Panther()) #=> prints The orange tiger wins! -fight(tigger,Lion("ROAR")) #=> prints The orange tiger wins! +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 (generic function with 2 methods) -fight(tigger,Panther()) #=> prints The orange tiger wins! -fight(tigger,Lion("ROAR")) #=> prints The green-maned lion wins! +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 (generic function with 3 methods) -fight(Lion("balooga!"),Panther()) #=> prints The victorious cat says grrr +fight(Lion("balooga!"),Panther()) # => prints The victorious cat says grrr try - fight(Panther(),Lion("RAWR")) #=> ERROR: no method fight(Panther,Lion) + 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 +# => Warning: New definition # fight(Cat,Lion) at none:1 # is ambiguous with # fight(Lion,Cat) at none:2. @@ -651,11 +651,11 @@ fight(c::Cat,l::Lion) = println("The cat beats the Lion") #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 +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 +fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The lions come to a tie # Under the hood -- cgit v1.2.3 From 0ac421577bd903d214b236c8fc0cd099ad83d736 Mon Sep 17 00:00:00 2001 From: Guillermo Garza Date: Tue, 18 Mar 2014 14:20:14 -0500 Subject: Add paragraph about multiline commments in julia --- julia.html.markdown | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 8245e616..8bd0d1df 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -13,6 +13,10 @@ 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 +=# #################################################### ## 1. Primitive Datatypes and Operators -- cgit v1.2.3 From 23a5fc837d9080e15ba152ccf7bca473916eb12a Mon Sep 17 00:00:00 2001 From: Guillermo Garza Date: Tue, 18 Mar 2014 14:27:49 -0500 Subject: Add comment about nesting julia multiline comments --- julia.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 8bd0d1df..36c57b2a 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -15,7 +15,7 @@ This is based on the current development version of Julia, as of October 18th, 2 # Single line comments start with a hash. #= Multiline comments can be written by putting '#=' before the text and '=#' - after the text + after the text. They can also be nested. =# #################################################### -- cgit v1.2.3 From 464930ecf8c4638dc5e49f253062f02c26292748 Mon Sep 17 00:00:00 2001 From: Trevor Wennblom Date: Wed, 19 Mar 2014 20:09:48 -0500 Subject: WARNING: deprecated syntax "x[i:]". 0.3.0-prerelease+2077 --- julia.html.markdown | 1 - 1 file changed, 1 deletion(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 36c57b2a..665b4fd3 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -193,7 +193,6 @@ 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! -- cgit v1.2.3 From 777c333ff078a7095f9b7ac303829b249f499b21 Mon Sep 17 00:00:00 2001 From: Sam Dodrill Date: Mon, 14 Apr 2014 11:04:44 -0700 Subject: Remove references to hash and hashtag in favor of number symbol --- julia.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 665b4fd3..15b4be90 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -12,7 +12,7 @@ This is based on the current development version of Julia, as of October 18th, 2 ```ruby -# Single line comments start with a hash. +# Single line comments start with a number symbol. #= Multiline comments can be written by putting '#=' before the text and '=#' after the text. They can also be nested. -- cgit v1.2.3 From e0e17156ee45822ea198ffdd11ff4d9f176f5b05 Mon Sep 17 00:00:00 2001 From: ysagal Date: Thu, 5 Jun 2014 12:20:54 -0400 Subject: Tiny typo fix --- julia.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 15b4be90..e9d3a162 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -500,7 +500,7 @@ typeof(DataType) # => DataType # Users can define types # They are like records or structs in other languages. -# New types are defined used the `type` keyword. +# New types are defined using the `type` keyword. # type Name # field::OptionalType -- cgit v1.2.3 From 92a2dbf34eeec0f4faf610e1b4d464d91dd10010 Mon Sep 17 00:00:00 2001 From: Geoffrey Liu Date: Sun, 21 Sep 2014 00:07:34 -0700 Subject: Fixes issue #747 --- julia.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index e9d3a162..82712553 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -12,7 +12,7 @@ This is based on the current development version of Julia, as of October 18th, 2 ```ruby -# Single line comments start with a number symbol. +# Single line comments start with a hash (pound) symbol. #= Multiline comments can be written by putting '#=' before the text and '=#' after the text. They can also be nested. -- cgit v1.2.3 From 54fad387b51371a9af1cb409dac74215c053c1ba Mon Sep 17 00:00:00 2001 From: Geoffrey Liu Date: Sun, 21 Sep 2014 17:16:05 -0700 Subject: Naming conventions in Julia As suggested in #768 by @ChristianPeel --- julia.html.markdown | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 82712553..feb38463 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -125,8 +125,9 @@ SomeOtherVar123! = 6 # => 6 # A note on naming conventions in Julia: # -# * Names of variables are in lower case, with word separation indicated by -# underscores ('\_'). +# * Word separation can be indicated by underscores ('_'), but use of +# underscores is discouraged unless the name would be hard to read +# otherwise. # # * Names of Types begin with a capital letter and word separation is shown # with CamelCase instead of underscores. -- cgit v1.2.3 From 6933d24227ec5a0f220bf897e57d5222eaba0084 Mon Sep 17 00:00:00 2001 From: Geoffrey Liu Date: Sun, 12 Oct 2014 12:24:52 -0700 Subject: Capitalize language names. See #137 --- julia.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index feb38463..3a52018c 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -1,5 +1,5 @@ --- -language: julia +language: Julia contributors: - ["Leah Hanson", "http://leahhanson.us"] filename: learnjulia.jl -- cgit v1.2.3 From 88dd3f24dab91c35f73157a1b1fffcf6d9bc4dc3 Mon Sep 17 00:00:00 2001 From: Jim Garrison Date: Sat, 2 May 2015 22:26:12 -0700 Subject: [julia/en] Update for Julia 0.3 and fix a few typos --- julia.html.markdown | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 3a52018c..5ccd6484 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -8,7 +8,7 @@ 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. +This is based on Julia 0.3. ```ruby @@ -91,7 +91,7 @@ false # $ can be used for string interpolation: "2 + 2 = $(2 + 2)" # => "2 + 2 = 4" -# You can put any Julia expression inside the parenthesis. +# You can put any Julia expression inside the parentheses. # 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 @@ -190,7 +190,7 @@ end # 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] +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] @@ -264,7 +264,7 @@ 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 +# Trying to look up a non-existent key will raise an error try filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489 catch e -- cgit v1.2.3 From 960ee4a1856db8eadb96277bb2422edfa8f2a81c Mon Sep 17 00:00:00 2001 From: Gabriel Halley Date: Wed, 7 Oct 2015 23:11:24 -0400 Subject: removing whitespace all over --- julia.html.markdown | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'julia.html.markdown') diff --git a/julia.html.markdown b/julia.html.markdown index 5ccd6484..66329feb 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -14,7 +14,7 @@ This is based on Julia 0.3. # Single line comments start with a hash (pound) symbol. #= Multiline comments can be written - by putting '#=' before the text and '=#' + by putting '#=' before the text and '=#' after the text. They can also be nested. =# @@ -670,7 +670,7 @@ 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,)) +code_native(square_area, (Int32,)) # .section __TEXT,__text,regular,pure_instructions # Filename: none # Source line: 1 # Prologue @@ -703,10 +703,10 @@ code_native(square_area, (Float64,)) # 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 +# 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 @@ -737,7 +737,7 @@ code_native(circle_area, (Float64,)) # vmulsd XMM0, XMM1, XMM0 # pop RBP # ret - # + # ``` ## Further Reading -- cgit v1.2.3