Category: julia

Julia – Files I/O ”; Previous Next Reading from files The functions namely open(), read(), and close() are the standard approach for extracting information from text files. Opening a text file If you want to read text from a text file, you need to first obtain the file handle. It can be done with the help of open() function as follows − foo = open(“C://Users//Leekha//Desktop//NLP.txt”) It shows that now foo is the Julia’s connection to the text file namely NLP.txt on the disk. Closing the file Once we are done with the file, we should have to close the connection as follows − Close(foo) In Julia, it is recommended to wrap any file-processing functions inside a do block as follows − open(“NLP.txt”) do file # here you can work with the open file end The advantage of wrapping file-processing functions inside do block is that the open file will be automatically closed when this block finishes. An example to keep some of the information like total time to read the file and total lines in the files − julia> totaltime, totallines = open(“C://Users//Leekha//Desktop//NLP.txt”) do foo linecounter = 0 timetaken = @elapsed for l in eachline(foo) linecounter += 1 end (timetaken, linecounter) end (0.0001184, 87) Reading a file all at once With read() function, we can read the whole content of an open file at once, for example − ABC = read(foo, String) Similarly, the below will store the contents of the file in ABC − julia> ABC = open(“C://Users//Leekha//Desktop//NLP.txt”) do file read(file, String) end We can also read in the whole file as an array. Use readlines() as follows − julia> foo = open(“C://Users//Leekha//Desktop//NLP.txt”) IOStream(<file C://Users//Leekha//Desktop//NLP.txt>) julia> lines = readlines(foo) 87-element Array{String,1}: “Natural Language Processing: Semantic Analysis “ “” “Introduction to semantic analysis:” ”The purpose of semantic analysis is to draw exact meaning, or you can say dictionary meaning from the text. Semantic analyzer checks the text for meaningfulness. “……………………………… Reading line by line We can also process a file line by line. For this task, Julia provides a function named eachline() which basically turns a source into an iterator. julia> open(“C://USers/Leekha//Desktop//NLP.txt”) do file for ln in eachline(file) println(“$(length(ln)), $(ln)”) end end 47, Natural Language Processing: Semantic Analysis 0, 34, Introduction to semantic analysis: ………………………………… If you want to keep a track of which line you are on while reading the file, use the below given approach − julia> open(“C://Users//Leekha//Desktop//NLP.txt”) do f line = 1 while !eof(f) x = readline(f) println(“$line $x”) line += 1 end end 1 Natural Language Processing: Semantic Analysis 2 3 Introduction to semantic analysis: 4 The purpose of semantic analysis is to draw exact meaning, or you can say dictionary meaning from the text. Semantic analyzer checks the text for meaningfulness. 5 We know that lexical analysis also deals with the meaning of the words then how semantic analysis is different from lexical analysis? The answer is that Lexical analysis is based on smaller token but on the other side semantic analysis focuses on larger chunks. That is why semantic analysis can be divided into the following two parts: 6 Studying the meaning of individual word: It is the first part of the semantic analysis in which the study of the meaning of individual words is performed. This part is called lexical semantics. 7 Studying the combination of individual words: In this second part, the individual words will be combined to provide meaning in sentences. 8 The most important task of semantic analysis is to get the proper meaning of the sentence. For example, analyze the sentence “Ram is great.” In this sentence, the speaker is talking either about Lord Ram or about a person whose name is Ram. That is why the job, to get the proper meaning of the sentence, of semantic analyzer is important. 9 Elements of semantic analysis: 10 Following are the elements of semantic analysis:…………………….. Path and File Names The table below shows functions that are useful for working with filenames − Sl.No Functions & Working 1 cd(path) This function changes the current directory. 2 pwd() This function gets the current working directory. 3 readdir(path) This function returns a list of the contents of a named directory, or the current directory. 4 abspath(path) This function adds the current directory”s path to a filename to make an absolute pathname. 5 joinpath(str, str, …) This function assembles a pathname from pieces. 6 isdir(path) This function tells you whether the path is a directory. 7 splitdir(path) This function splits a path into a tuple of the directory name and file name. 8 splitdrive(path) This function, on Windows, split a path into the drive letter part and the path part. And, On Unix systems, the first component is always the empty string. 9 splitext(path) This function, if the last component of a path contains a dot, split the path into everything before the dot and everything including and after the dot. Otherwise, return a tuple of the argument unmodified and the empty string. 10 expanduser(path) This function replaces a tilde character at the start of a path with the current user”s home directory. 11 normpath(path) This function normalizes a path, removing “.” and “..” entries. 12 realpath(path) This function canonicalizes a path by expanding symbolic links and removing “.” and “..” entries. 13 homedir() This function gives the current user”s home directory.

Julia – Arrays ”; Previous Next An Array is an ordered set of elements which are often specified with squared brackets having comma-separated items. We can create arrays that are − Full or empty Hold values of different types Restricted to values of a specific type In Julia, arrays are actually mutable type collections which are used for lists, vectors, tables, and matrices. That is why the values of arrays in Julia can be modified with the use of certain pre-defined keywords. With the help of push! command you can add new element in array. Similarly, with the help of splice! function you can add elements in an array at a specified index. Creating Simple 1D Arrays Following is the example showing how we can create a simple 1D array − julia> arr = [1,2,3] 3-element Array{Int64,1}: 1 2 3 The above example shows that we have created a 1D array with 3 elements each of which is a 64-bit integer. This 1D array is bound to the variable arr. Uninitialized array We can also specify the type and the dimension of an array by using the below syntax − Array{type}(dims) Following is an example of uninitialized array − julia> array = Array{Int64}(undef, 3) 3-element Array{Int64,1}: 0 0 0 julia> array = Array{Int64}(undef, 3, 3, 3) 3×3×3 Array{Int64,3}: [:, :, 1] = 8 372354944 328904752 3 331059280 162819664 32 339708912 1 [:, :, 2] = 331213072 3 331355760 1 328841776 331355984 -1 328841680 2 [:, :, 3] = 1 0 339709232 164231472 328841872 347296224 328841968 339709152 16842753 Here we placed the type in curly braces and the dimensions in parentheses. We use undef which means that particular array has not been initialized to any known value and thats why we got random numbers in the output. Arrays of anything Julia gives us the freedom to create arrays with elements of different types. Let us see the example below in which we are going to create array of an odd mixture — numbers, strings, functions, constants − julia> [1, “TutorialsPoint.com”, 5.5, tan, pi] 5-element Array{Any,1}: 1 “TutorialsPoint.com” 5.5 tan (generic function with 12 methods) π = 3.1415926535897… Empty Arrays Just like creating an array of specific type, we can also create empty arrays in Julia. The example is given below − julia> A = Int64[] Int64[] julia> A = String[] String[] Creating 2D arrays & matrices Leave out the comma between elements and you will be getting 2D arrays in Julia. Below is the example given for single row, multi-column array − julia> [1 2 3 4 5 6 7 8 9 10] 1×10 Array{Int64,2}: 1 2 3 4 5 6 7 8 9 10 Here, 1×10 is the first row of this array. To add another row, just add a semicolon(;). Let us check the below example − julia> [1 2 3 4 5 ; 6 7 8 9 10] 2×5 Array{Int64,2}: 1 2 3 4 5 6 7 8 9 10 Here, it becomes 2×5 array. Creating arrays using range objects We can create arrays using range objects in the following ways − Collect() function First useful function to create an array using range objects is collect(). With the help of colon(:) and collect() function, we can create an array using range objects as follows − julia> collect(1:5) 5-element Array{Int64,1}: 1 2 3 4 5 We can also create arrays with floating point range objects − julia> collect(1.5:5.5) 5-element Array{Float64,1}: 1.5 2.5 3.5 4.5 5.5 Let us see a three-piece version of a range object with the help of which you can specify a step size other than 1. The syntax for the same is given below − start:step:stop. Below is an example to build an array with elements that go from 0 to 50 in steps of 5 − julia> collect(0:5:50) 11-element Array{Int64,1}: 0 5 10 15 20 25 30 35 40 45 50 ellipsis(…) or splat operator Instead of using collect() function, we can also use splat operator or ellipsis(…) after the last element. Following is an example − julia> [0:10…] 11-element Array{Int64,1}: 0 1 2 3 4 5 6 7 8 9 10 range() function Range() is another useful function to create an array with range objects. It goes from start value to end value by taking a specific step value. For example, let us see an example to go from 1 to 150 in exactly 15 steps − julia> range(1, length=15, stop=150) 1.0:10.642857142857142:150.0 Or you can use range to take 10 steps from 1, stopping at or before 150: julia> range(1, stop=150, step=10) 1:10:141 We can use range() with collect() to build an array as follows − julia> collect(range(1, length=15, stop=150)) 15-element Array{Float64,1}: 1.0 11.642857142857142 22.285714285714285 32.92857142857143 43.57142857142857 54.214285714285715 64.85714285714286 75.5 86.14285714285714 96.78571428571429 107.42857142857143 118.07142857142857 128.71428571428572 139.35714285714286 150.0 Creating arrays using comprehensions and generators Another useful way to create an array is to use comprehensions. In this way, we can create array where each element can produce using a small computation. For example, we can create an array of 10 elements as follows − julia> [n^2 for n in 1:10] 10-element Array{Int64,1}: 1 4 9 16 25 36 49 64 81 100 We can easily create a 2-D array also as follows − julia> [n*m for n in 1:10, m in 1:10] 10×10 Array{Int64,2}: 1 2 3 4 5 6 7 8 9 10 2 4 6 8 10 12 14 16 18 20 3 6 9 12 15 18 21 24 27 30 4 8 12 16 20 24 28 32 36 40 5 10 15 20 25 30 35 40 45 50 6 12 18 24 30 36 42 48 54 60 7 14 21 28 35 42 49 56 63 70 8 16 24 32 40 48 56 64 72 80 9 18 27 36

Julia – Functions ”; Previous Next Function, the building blocks of Julia, is a collected group of instructions that maps a tuple of argument values to a return value. It acts as the subroutines, procedures, blocks, and other similar structures concepts found in other programming languages. Defining Functions There are following three ways in which we can define functions − When there is a single expression in a function, you can define it by writing the name of the function and any arguments in parentheses on the left side and write an expression on the right side of an equal sign. Example julia> f(a) = a * a f (generic function with 1 method) julia> f(5) 25 julia> func(x, y) = sqrt(x^2 + y^2) func (generic function with 1 method) julia> func(5, 4) 6.4031242374328485 If there are multiple expressions in a function, you can define it as shown below − function functionname(args) expression expression expression … expression end Example julia> function bills(money) if money < 0 return false else return true end end bills (generic function with 1 method) julia> bills(50) true julia> bills(-50) false If a function returns more than one value, we need to use tuples. Example julia> function mul(x,y) x+y, x*y end mul (generic function with 1 method) julia> mul(5, 10) (15, 50) Optional Arguments It is often possible to define functions with optional arguments i.e. default sensible values for functions arguments so that the function can use that value if specific values are not provided. For example − julia> function pos(ax, by, cz=0) println(“$ax, $by, $cz”) end pos (generic function with 2 methods) julia> pos(10, 30) 10, 30, 0 julia> pos(10, 30, 50) 10, 30, 50 You can check in the above output that when we call this function without supplying third value, the variable cz defaults to 0. Keyword Arguments Some functions which we define need a large number of arguments but calling such functions can be difficult because we may forget the order in which we have to supply the arguments. For example, check the below function − function foo(a, b, c, d, e, f) … end Now, we may forget the order of arguments and the following may happen − foo(“25”, -5.6987, “hello”, 56, good, ‘ABC’) or foo(“hello”, 56, “25”, -5.6987, ‘ABC’, good) Julia provides us a way to avoid this problem. We can use keywords to label arguments. We need to use a semicolon after the function’s unlabelled arguments and follow it with one or more keyword-value pair as follows − julia> function foo(a, b ; c = 10, d = “hi”) println(“a is $a”) println(“b is $b”) return “c => $c, d => $d” end foo (generic function with 1 method) julia> foo(100,20) a is 100 b is 20 ”c => 10, d => hi” julia> foo(“Hello”, “Tutorialspoint”, c=pi, d=22//7) a is Hello b is Tutorialspoint ”c => π, d => 22//7″ It is not necessary to define the keyword argument at the end or in the matching place, it can be written anywhere in the argument list. Following is an example − julia> foo(c=pi, d =22/7, “Hello”, “Tutorialspoint”) a is Hello b is Tutorialspoint ”c => π, d => 3.142857142857143″ Anonymous Functions It is waste of time thinking a cool name for your function. Use Anonymous functions i.e. functions with no name instead. In Julia, such functions can be used in number of places such as map() and in list comprehensions. The syntax of anonymous functions uses the symbol ->. You can check the below example − A -> A^3 + 3A – 3 The above function is an anonymous function that takes an argument A and returns A^3 + 3A – 3. It can be used with map() function whose first argument is a function and we can define an one-off function that exists just for one particular map() operation. The example is given below − julia> map(A -> A^3 + 3A – 3, [10,3,-2]) 3-element Array{Int64,1}: 1027 33 -17 Once the map() function finishes, the function and argument both will disappear − julia> A ERROR: UndefVarError: A not defined Recursive Functions In Julia, the functions can be nested. It is demonstrated in the example given below − julia> function add(x) Y = x * 2 function add1(Y) Y += 1 end add1(Y) end add (generic function with 1 method) julia> d = 10 10 julia> add(d) 21 In the same way, a function in Julia can be recursive also. It means the function can call itself. Before getting into details, we first need to test a condition in code which can be done with the help of ternary operator “?”. It takes the form expr ? a : b. It is called ternary because it takes three arguments. Here the expr is a condition, if it is true then a will be evaluated otherwise b. Let us use this in the following recursive definition − julia> sum(x) = x > 1 ? sum(x-1) + x : x sum (generic function with 1 method) The above statement calculates the sum of all the integers up to and including a certain number. But in this recursion ends because there is a base case, i.e., when x is 1, this value is returned. The most famous example of recursion is to calculate the nth Fibonacci number which is defined as the sum of two previous Fibonacci numbers. Let us understand it with the below given example − julia> fib(x) = x < 2 ? x : fib(x-1) + fib(x-2) fib (generic function with 1 method) Therefore while using recursion, we need to be careful to define a base case to stop calculation. Map Map may be defined as a function that takes the following form − map(func, coll) Here, func is a function applied successively to each element of collection coll. Map generally contains the anonymous function and returns a new collection. The example is given below − julia> map(A ->

Julia Programming – Basic Syntax ”; Previous Next The simplest first Julia program (and of many other programming languages too) is to print hello world. The script is as follows − If you have added Julia to your path, the same script can be saved in a file say hello.jl and can be run by typing Julia hello.jl at command prompt. Alternatively the same can also be run from Julia REPL by typing include(“hello.jl”). This command will evaluate all valid expressions and return the last output. Variables What can be the simplest definition of a computer program? The simplest one may be that a computer program is a series of instructions to be executed on a variety of data. Here the data can be the name of a person, place, the house number of a person, or even a list of things you have made. In computer programming, when we need to label such information, we give it a name (say A) and call it a variable. In this sense, we can say that a variable is a box containing data. Let us see how we can assign data to a variable. It is quite simple, just type it. For example, student_name = “Ram” roll_no = 15 marks_math = 9.5 Here, the first variable i.e. student_name contains a string, the second variable i.e. roll_no contains a number, and the third variable i.e. marks_math contains a floating-point number. We see, unlike other programming languages such as C++, Python, etc.,in Julia we do not have to specify the type of variables because it can infer the type of object on the right side of the equal sign. Stylistic Conventions and Allowed Variable Names Following are some conventions used for variables names − The names of the variables in Julia are case sensitive. So, the variables student_name and Student_name would not be same. The names of the variables in Julia should always start with a letter and after that we can use anything like digits, letters, underscores, etc. In Julia, generally lower-case letter is used with multiple words separated by an underscore. We should use clear, short, and to the point names for variables. Some of the valid Julia variable names are student_name, roll_no, speed, current_time. Comments Writing comments in Julia is quite same as Python. Based on the usage, comments are of two types − Single Line Comments In Julia, the single line comments start with the symbol of # (hashtag) and it lasts till the end of that line. Suppose if your comment exceeds one line then you should put a # symbol on the next line also and can continue the comment. Given below is the code snippet showing single line comment − Example julia> #This is an example to demonstrate the single lined comments. julia> #Print the given name Multi-line Comments In Julia, the multi-line comment is a piece of text, like single line comment, but it is enclosed in a delimiter #= on the start of the comment and enclosed in a delimiter =# on the end of the comment. Given below is the code snippet showing multi-line comment − Example julia> #= This is an example to demonstrate the multi-line comments that tells us about tutorialspoint.com. At this website you can browse the best resource for Online Education.=# julia> print(www.tutorialspoint.com) Print Page Previous Next Advertisements ”;

Julia – Basic Mathematical Functions ”; Previous Next Let us try to understand basic mathematical functions with the help of example in this chapter. Numerical Conversions In Julia, the user gets three different forms of numerical conversion. All the three differ in their handling of inexact conversions. They are as follows − T(x) or convert(T, x) − This notation converts x to a value of T. The result depends upon following two cases − T is a floating-point type − In this case the result will be the nearest representable value. This value could be positive or negative infinity. T is an integer type − The result will raise an InexactError if and only if x is not representable by T. x%T − This notation will convert an integer x to a value of integer type T corresponding to x modulo 2^n. Here n represents the number of bits in T. In simple words, this notation truncates the binary representation to fit. Rounding functions − This notation takes a type T as an optional argument for calculation. Eg − Round(Int, a) is shorthand for Int(round(a)). Example The example given below represent the various forms described above − julia> Int8(110) 110 julia> Int8(128) ERROR: InexactError: trunc(Int8, 128) Stacktrace: [1] throw_inexacterror(::Symbol, ::Type{Int8}, ::Int64) at .boot.jl:558 [2] checked_trunc_sint at .boot.jl:580 [inlined] [3] toInt8 at .boot.jl:595 [inlined] [4] Int8(::Int64) at .boot.jl:705 [5] top-level scope at REPL[4]:1 julia> Int8(110.0) 110 julia> Int8(3.14) ERROR: InexactError: Int8(3.14) Stacktrace: [1] Int8(::Float64) at .float.jl:689 [2] top-level scope at REPL[6]:1 julia> Int8(128.0) ERROR: InexactError: Int8(128.0) Stacktrace: [1] Int8(::Float64) at .float.jl:689 [2] top-level scope at REPL[7]:1 julia> 110%Int8 110 julia> 128%Int8 -128 julia> round(Int8, 110.35) 110 julia> round(Int8, 127.52) ERROR: InexactError: trunc(Int8, 128.0) Stacktrace: [1] trunc at .float.jl:682 [inlined] [2] round(::Type{Int8}, ::Float64) at .float.jl:367 [3] top-level scope at REPL[14]:1 Rounding functions Following table shows rounding functions that are supported on Julia’s primitive numeric types − Function Description Return type round(x) This function will round x to the nearest integer. typeof(x) round(T, x) This function will round x to the nearest integer. T floor(x) This function will round x towards -Inf returns the nearest integral value of the same type as x. This value will be less than or equal to x. typeof(x) floor(T, x) This function will round x towards -Inf and converts the result to type T. It will throw an InexactError if the value is not representable. T floor(T, x) This function will round x towards -Inf and converts the result to type T. It will throw an InexactError if the value is not representable. T ceil(x) This function will round x towards +Inf and returns the nearest integral value of the same type as x. This value will be greater than or equal to x. typeof(x) ceil(T, x) This function will round x towards +Inf and converts the result to type T. It will throw an InexactError if the value is not representable. T trunc(x) This function will round x towards zero and returns the nearest integral value of the same type as x. The absolute value will be less than or equal to x. typeof(x) trunc(T, x) This function will round x towards zero and converts the result to type T. It will throw an InexactError if the value is not representable. T Example The example given below represent the rounding functions − julia> round(3.8) 4.0 julia> round(Int, 3.8) 4 julia> floor(3.8) 3.0 julia> floor(Int, 3.8) 3 julia> ceil(3.8) 4.0 julia> ceil(Int, 3.8) 4 julia> trunc(3.8) 3.0 julia> trunc(Int, 3.8) 3 Division functions Following table shows the division functions that are supported on Julia’s primitive numeric types − Sl.No Function & Description 1 div(x,y), x÷y It is the quotation from Euclidean division. Also called truncated division. It computes x/y and the quotient will be rounded towards zero. 2 fld(x,y) It is the floored division. The quotient will be rounded towards -Inf i.e. largest integer less than or equal to x/y. It is shorthand for div(x, y, RoundDown). 3 cld(x,y) It is ceiling division. The quotient will be rounded towards +Inf i.e. smallest integer less than or equal to x/y. It is shorthand for div(x, y, RoundUp). 4 rem(x,y) remainder; satisfies x == div(x,y)*y + rem(x,y); sign matches x 5 mod(x,y) It is modulus after flooring division. This function satisfies the equation x == fld(x,y)*y + mod(x,y). The sign matches y. 6 mod1(x,y) This is same as mod with offset 1. It returns r∈(0,y] for y>0 or r∈[y,0) for y<0, where mod(r, y) == mod(x, y). 7 mod2pi(x) It is modulus with respect to 2pi. It satisfies 0 <= mod2pi(x) < 2pi 8 divrem(x,y) It is the quotient and remainder from Euclidean division. It equivalents to (div(x,y),rem(x,y)). 9 fldmod(x,y) It is the floored quotation and modulus after division. It is equivalent to (fld(x,y),mod(x,y)) 10 gcd(x,y…) It is the greatest positive common divisor of x, y,… 11 lcm(x,y…) It represents the least positive common multiple of x, y,… Example The example given below represent the division functions − julia> div(11, 4) 2 julia> div(7, 4) 1 julia> fld(11, 4) 2 julia> fld(-5,3) -2 julia> fld(7.5,3.3) 2.0 julia> cld(7.5,3.3) 3.0 julia> mod(5, 0:2) 2 julia> mod(3, 0:2) 0 julia> mod(8.9,2) 0.9000000000000004 julia> rem(8,4) 0 julia> rem(9,4) 1 julia> mod2pi(7*pi/5) 4.39822971502571 julia> divrem(8,3) (2, 2) julia> fldmod(12,4) (3, 0) julia> fldmod(13,4) (3, 1) julia> mod1(5,4) 1 julia> gcd(6,0) 6 julia> gcd(1//3,2//3) 1//3 julia> lcm(1//3,2//3) 2//3 Sign and Absolute value functions Following table shows the sign and absolute value

Julia – Tuples ”; Previous Next Similar to an array, tuple is also an ordered set of elements. Tuples work in almost the same way as arrays but there are following important differences between them − An array is represented by square brackets whereas a tuple is represented by parentheses and commas. Tuples are immutable. Creating tuples We can create tuples as arrays and most of the array’s functions can be used on tuples also. Some of the example are given below − julia> tupl=(5,10,15,20,25,30) (5, 10, 15, 20, 25, 30) julia> tupl (5, 10, 15, 20, 25, 30) julia> tupl[3:end] (15, 20, 25, 30) julia> tupl = ((1,2),(3,4)) ((1, 2), (3, 4)) julia> tupl[1] (1, 2) julia> tupl[1][2] 2 We cannot change a tuple: julia> tupl[2]=0 ERROR: MethodError: no method matching setindex!(::Tuple{Tuple{Int64,Int64},Tuple{Int64,Int64}}, ::Int64, ::Int64) Stacktrace: [1] top-level scope at REPL[7]:1 Named tuples A named tuple is simply a combination of a tuple and a dictionary because − A named tuple is ordered and immutable like a tuple and Like a dictionary in named tuple, each element has a unique key which can be used to access it. In next section, let us see how we can create named tuples − Creating named tuples You can create named tuples in Julia by − Providing keys and values in separate tuples Providing keys and values in a single tuple Combining two existing named tuples Keys and values in separate tuples One way to create named tuples is by providing keys and values in separate tuples. Example julia> names_shape = (:corner1, :corner2) (:corner1, :corner2) julia> values_shape = ((100, 100), (200, 200)) ((100, 100), (200, 200)) julia> shape_item2 = NamedTuple{names_shape}(values_shape) (corner1 = (100, 100), corner2 = (200, 200)) We can access the elements by using dot(.) syntax − julia> shape_item2.corner1 (100, 100) julia> shape_item2.corner2 (200, 200) Keys and values in a single tuple We can also create named tuples by providing keys and values in a single tuple. Example julia> shape_item = (corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0)) (corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0)) We can access the elements by using dot(.) syntax − julia> shape_item.corner1 (1, 1) julia> shape_item.corner2 (-1, -1) julia> shape_item.center (0, 0) julia> (shape_item.center,shape_item.corner2) ((0, 0), (-1, -1)) We can also access all the values as with ordinary tuples as follows − julia> c1, c2, center = shape_item (corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0)) julia> c1 (1, 1) Combining two named tuples Julia provides us a way to make new named tuples by combining two named tuples together as follows − Example julia> colors_shape = (top = “red”, bottom = “green”) (top = “red”, bottom = “green”) julia> shape_item = (corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0)) (corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0)) julia> merge(shape_item, colors_shape) (corner1 = (1, 1), corner2 = (-1, -1), center = (0, 0), top = “red”, bottom = “green”) Named tuples as keyword arguments If you want to pass a group of keyword arguments to a function, named tuple is a convenient way to do so in Julia. Following is the example of a function that accepts three keyword arguments − julia> function ABC(x, y, z; a=10, b=20, c=30) println(“x = $x, y = $y, z = $z; a = $a, b = $b, c = $c”) end ABC (generic function with 1 method) It is also possible to define a named tuple which contains the names as well values for one or more keywords as follows − julia> options = (b = 200, c = 300) (b = 200, c = 300) In order to pass the named tuples to the function we need to use; while calling the function − julia> ABC(1, 2, 3; options…) x = 1, y = 2, z = 3; a = 10, b = 200, c = 300 The values and keyword can also be overridden by later function as follows − julia> ABC(1, 2, 3; b = 1000_000, options…) x = 1, y = 2, z = 3; a = 10, b = 200, c = 300 julia> ABC(1, 2, 3; options…, b= 1000_000) x = 1, y = 2, z = 3; a = 10, b = 1000000, c = 300 Print Page Previous Next Advertisements ”;