Basics
In Julia, the name of the variables can be very flexible; we can use Unicode as a variable name. You can also use Unicode math symbols as variable names. To do so, type a backslash followed by the Latex Symbol; then press tab to autocomplete. For example, to type the alpha symbol, simply type “\alpha” followed by tab.
# Assigning values to different types to variables
x = 1
안녕하세요 = 2
y = "안녕하세요"
# We can use Unicode math symbols by backslash Latex symbol followed by tab.
# For example to type alpha symbol, you coud simply do \alpha-tab.
α = 3
β = 4
One can also assign values to different variables in a single line.
γ, δ, σ, ϵ, ε, ξ = 1, 2, 3, 4, 5, 6
A variable can hold a matrix and vector too.
# a is a 5x1 vector
a = [1;2;3;4;5]
# b is a 5x2 matrix
b = [1 2;3 4;5 6;7 8; 9 10]
Functions
A function is a mapping of a tuple of arguments to a return value. The following code produces a function called gFunction that has two arguments, x and y and returns their sum.
function gFunction(x,y)
x + y
end
gFunction(1,2)
julia > 3
Another way to define a function is to use “assignment form”, where we simply express the function in mathematical format. See the example below.
fFunction(x, y) = x - y
fFunction(5,2)
julia> 3
One exciting feature of Julia is its argument passing behavior. See the example below excerpted from Julia documentation.
fib(n::Integer) = n ≤ 2 ? one(n) : fib(n-1) + fib(n-2)
Let’s decompose the above codes into smaller components. Below we define a function called fib. This function takes one argument n that is declared to be Integer.
fib(n::integer)
The above example uses a “ternary operator”, an operator for conditional expressions that takes following form in Julia, ___ ? ___ : ___.
Notice that ? acts as a conditional evaluation. If the condition is met, the function will return component before :, i.e. one(n), otherwise, it will return the component after :, i.e., fib(n-1) + fib(n-2).
fib(n::Integer) = n ≤ 2 ? one(n) : fib(n-1) + fib(n-2)
Notice that this function is recursive. Even if we invoke, for example, fib(5), it will recursively run the function until fib(2) when it can actually return the numeric value.
Some useful operators with special names
To horizontally concatenate, use hcat.
hcat(a,b)
julia>
1 1 2
2 3 4
3 5 6
4 7 8
5 9 10
To vertically concatenate, use vcat.
c=[6;7;8;9;10]
vcat(a,c)
julia>
10-element Vector{Int64}:
1
2
3
4
5
6
7
8
9
10
Method vs. Function
Thus, the overall behavior of a function is a patchwork of the behaviors of its various method definitions.
The choice of which method to execute when a function is applied is called dispatch. Julia allows the dispatch process to choose which of a function’s methods to call based on the number of arguments given, and on the types of all of the function’s arguments. This is different than traditional object-oriented languages, where dispatch occurs based only on the first argument, which often has a special argument syntax, and is sometimes implied rather than explicitly written as an argument. Using all of a function’s arguments to choose which method should be invoked, rather than just the first, is known as multiple dispatch.
Anonymous function
Anonymous function is a function without a name. You can create one using either of the following syntax:
x -> x+ 3
function (x)
x+3
end
map is often used for executing anonymous function.
map(1:10) do x
2x
end
map(x->2x, 1:10)
map(1:10, 11:20) do x, y
x + y
end
map((x,y)->x+y, 1:10, 11:20)
Plots
To create plots, one can use the Plots or Gadfly package.
using Plots
x=range(0,10, length=100)
plot(x, x->x^2)
Reference
Julia documentation, https://docs.julialang.org/
Julia Plots documentation, https://docs.juliaplots.org/latest/