Julia is shipped with a vast array of utility functions built into the core language and its standard libraries. Also, because of its speed, it is very well suited for the implementation of custom algorithms (as opposed to many other high-level languages, where users compose the analysis solely by using predefined algorithms from installed packages).

In this chapter, we show practical examples of how such custom algorithms can be implemented, while also taking advantage of the inbuilt functionality. The range of recipes shows that you can often implement your own low-level algorithm that is much faster than using standard functions (the recipe for finding the index of a random minimum element in an array) and that you can easily modify how standard operations work by overriding them with custom behavior (the matrix multiplication optimization recipe). Finally, we...

In many applications, you need to find the index of the minimum element of some array. The built-in argmin function is designed to perform this task—it returns the index of the minimum element in a collection. However, if there are multiple minimal elements, then the first one will be returned. There are situations when we need to get all indices of a minimal element or a single index is chosen uniformly at random from this set. In this recipe, we discuss how you can implement such a function.

Make sure that you have the StatsBase.jl and BenchmarkTools.jl packages installed.

You can add them by running the following...

Performing computations on matrices are one of the fundamental operations in numerical computing. In particular, if we want to multiply an  matrix by an  matrix, this operation has  complexity, producing an  matrix. Therefore, if we want to multiply several matrices in a chain, the cost of this operation depends on the sequence in which we perform the multiplications.

For example, assume that we have the following matrices:

• A having dimensions 10 x 40
• B having dimensions 40 x 10
• C having dimensions 10 x 50

And, we want to compute A*B*C. We can perform the computation either like this, (A*B)*C, or like this, A*(B*C). The cost of the first approach is proportional to 10*40*10+10*10*50=9000. The cost of the second approach is 40*10*50+10*40*50=40000. It is therefore evident that the order of operations has a significant...

In many situations in Julia, you might want to extend some abstract type defined in the base language. In this recipe, we will show how you can implement a simple pseudo-random number generator extending AbstractRNG.

In order to create your own pseudo-random number generator, you have to define a concrete type that is a subtype of the AbstractRNG abstract type and which implements methods for the seed!, rand, and rng_native_52 functions. In this recipe, we will show how you can achieve this.

The generator we will implement is called 64-bit Xorshift. It was proposed by George Marsaglia in the paper, Xorshift RNGs, published in the Journal...

One of the very common tasks in data science is parsing logs produced by some application. In this recipe, we will write a simple snippet that presents how we can analyze the contributions of committers to the Git repository.

In order to run this recipe, you need to have the DataFrames.jl and DataFramesMeta.jl packages installed. If they are missing run the following commands to add them:

julia> using Pkg

julia> Pkg.add("DataFrames")

julia> Pkg.add("DataFramesMeta")

Also, you need to have Git installed. You can get it from https://git-scm.com/.

When you run the git log --stat command on a repository, it prints output that looks similar...

Sorting is one of the basic operations commonly performed when processing data. In this recipe, we will explore several options for how you can perform sorting in non-standard cases. In particular, we will compare the performance of the various options that can be used for sorting.

In this recipe, we want to sort rows of an array of Float64 numbers by their norms. For our purposes, the norm of a list of values  is defined as , that is, the Euclidean norm (see http://mathworld.wolfram.com/MatrixNorm.html).

In this recipe, we will explain in detail how the Dict and Set types identify keys in Julia.

The example that we will use is the creation of a dictionary that stores a preimage function.

Given a function,  and , we will call preimage of  a set ; see the example at http://mathworld.wolfram.com/Preimage.html.

In particular, we need to create preimage of all possible values of a mapping, , given the domain, and the set B defined as an image of A under , as calculated by Julia.

Julia supports handling UTF-8 strings. However, the way you work with them is slightly different from such languages as R or Python. In this recipe, you will discover more about the String and SubString types, as well as the correct method of indexing into a string in Julia.

We will learn this by parsing a file containing the word Hello, written in different languages.

In this recipe we will work with text stored in the file hello.txt that has the following contents as shown in the following screenshot: