This is the fourth part in the article series – ‘Getting started with Julia language’. If you have ever attempted to write an application, then you would have come across Julia multiple times before. Julia is a high-level, high-performance, dynamic programming language. It is an ideal choice for programs that require numerical computations, such as, ML/AI. In this article, we’ll take a look at the literals and operators that we find in Julia language. In the previous artickes, we’ve already covered how to set up Julia, Julia REPL and packages and Julia variables and types.
Literals
Literals are means of expressing specific values in a program.
Strings
We’ve already come across the string literals in some examples, String literals can be created by enclosing the value between ” (double quotes).
string_val = "test string"
Note: In Julia, strings can only be defined between ” (double quote), while ‘(single quote) is used for defining a character.
char_val = 'a'
Arrays/Lists
- Array literals are N-dimensional mutable containers.
- Each element they contain has to be either a variable or otherwise a valid literal.
- Can be heterogeneous, i.e, values don’t have to be of the same typ
- Values are separated by a , (comma)
- Values can be updated by subscripting through their index.
Note: Compared to other programming languages, Julia uses 1 indexing rather than 0 indexing, i.e, indexes start at 1 instead of 0.
1-D arrays — A linear array which has only one subscript,
# Initialize an array with values arr1 = [1, 2, "sausage", 5.9] # Initialize an empty array arr2 = [] # Update value by index arr1[1] = 3 # Updates 1st element of arr1
Multidimensional arrays — A rectangular array of numbers or symbols arranged in rows and columns, also known as matrix. A matrix can be declared in 2 ways,
mat1 = [[1,2,3] [4,5,6] [7,8,9]] --or-- mat2 = [1 2 3; 4 5 6; 7 8 9] # Update 2nd column in 1st row mat1[1][2] = 5
While creating a multidimensional array, each row has to be of the same length, otherwise, it raises an error.
Elements of bidimensional arrays can be accessed with the array[row,col] or array[row][col] syntax.
Nested arrays — Simply speaking, these are an array of arrays, i.e, a 1-D array with vector values.
arr2 = [[1,2,3], [4,5,6], [7,8,9]]
This creates a 1-D array with 3 elements (each of which are vectors). Note the , separation between each vector elements.
Tuples
Tuples are similar to 1-D arrays, but unlike them, tuples are immutable.
tuple1 = (1, 4, 5.5, "test")
NamedTuples
NamedTuples are collections of items whose position in the collection (index) can be identified not only by the position but also by name.
namedtuple1 = (a=1, b=2, c=3) # Accessing elements by name namdetuple1.a namedtuple1.c
Dictionaries
Dictionaries are used to store key-value pairs.
# Initialize a dictionary with values
dict1 = Dict('a'=>1, 'b'=>2, 'c'=>3)
# Initialize an empty dictionary
dict2 = Dict()
# Add new pairs to dictionary
dict1['d'] = 4
dict2['e'] = 5
# Update existing pairs
dict['a'] = 8
They may seem similar to NamedTuples but both have some major differences,
Dictionaries are mutable while NamedTuples are immutable
Dictionaries are type unstable if different type of values are stored, while NamedTuples remain type-stable
d = Dict(k1=>"v1", k2=>2) # Dict{Symbol,Any}
nt = (k1="v1", k2=2,) # NamedTuple{(:k1, :k2),Tuple{String,Int64}}
Sets
Sets are unordered collections used to store unique values.
# Create an empty set set1 = Set([]) # Create a set with values set2 = Set([1, 2, 3])
Though duplicate entries are present at the time of set construction, the resulting set will only have unique values
set3 = Set(["abcd", "efg", "efg", "hijk"]) Output -> Set(["hijk", "efg", "abcd"])
Ranges
A range in Julia is simply a shorthand for a sequence of numbers that are all spaced equally.
Syntax:
range(start:[step]:end)
- start — denotes the start value of the range
- step — is optional, specifies the spacing between each values in the sequence
- end — denotes the end value of the range
Ranges are lazy, meaning the values are not immediately available until they are needed. However, the generation of the values can be forced by using the collect() function.
0:20 # This return UnitRange{Int64}
collect(0:2:20) # This will generate a 6-element Array{Int64,1}
collect(0.5:5.5) # This will generate a 6-element Array{Float64,1}
Type Unions
Sometimes, it’s useful to have a single alias for multiple types. To do so, we can create a type union using the constructor Union:
Numeric = Union{Int, Float64}
# Assert for Int
5::Numeric # Returns 5
# Assert for Float
7.06::Numeric # Returns 7.06
# Assert for string
"abcd"::Numeric # Results in TypeError
As you can see from the above example, since String type is not in the Union Numeric , asserting a string will raise TypeError.
Operators in Julia
There are several operators in Julia, which include Arithmetic, Bitwise, Logical, Assignment, Vectorized dot and Relational.
Arithmetic Operators
Arithmetic operators are used to perform arithmetic operations such as addition, subtraction, multiplication, division, etc.
[table id=9 /]
Bitwise Operators
Bitwise operators are for bit level programming in which individual bits of an integer expression is manipulated.
[table id=10 /]
Logical Operators
Logical operators are used to combine two or more conditions or to complement the evaluation of the original condition.
[table id=11 /]
Assignment Operators
Assignment operators are used to assign values from right side operands to left side operands.
[table id=12 /]
Vectorized dot(.) Operator
The “dot” operator is used to perform element wise binary operations on a given array.
Syntax: Prepend dot operator to the desired binary operation.
x = x .^ 2
As you can see from this example, doing A = A ^ 2 will result in an error since it is not possible to perform square of an array, on the other hand if the dot operator is used, the squaring will be done element wise.
Relational Operators
Relational operators are used to check the relation between 2 operands.
[table id=13 /]
