Chapter 1: Introduction to Find Functions

In programming, we often encounter vast data structures filled with various elements. To interact with these elements, we rely on a technique known as indexing, which enables us to extract values from a collection based on the element's order or specific properties pertinent to the collection type.

Working with large data structures can sometimes become cumbersome. While performing arithmetic on an individual value may seem straightforward, applying the same operation across an entire array complicates matters significantly. Fortunately, Julia provides a suite of methods designed for this very purpose! Among these, I would like to highlight a group of functions I refer to as Julia's "find functions," which are crucial for anyone looking to delve into algorithm development.

Section 1.1: The Basics of Find Functions

The find functions in Julia are instrumental for locating an element based on certain characteristics. Five essential functions that every Julia user should familiarize themselves with are:

• findall
• findfirst
• findlast
• findnext
• findprev

Typically, when utilizing these functions, we begin by specifying the method for filtering the collection, followed by the collection itself. It's important to note that Julia offers distinct find methods tailored for different data types, which means their behavior may vary depending on the type of collection in use.

Subsection 1.1.1: Examples of Find Functions

Let's start with a simple example using a string, highlighting the differences when applied to arrays.

# Finding the first occurrence of a substring

findfirst("example", "this is an example")

This function searches for the first instance of the specified string within another. The result is a UnitRange{Int64} indicating the position of the found substring. If we instead wanted to locate a single character, we could use:

# Finding a character in a string

findfirst(::Char, ::String) -> ::Int64

This will yield an Int64. For a character represented as a one-element string, it returns a UnitRange of length 1. The indices can then be used to extract the found value:

r = findfirst("example", "this is an example")

"this is an example"[r]

Now, when it comes to arrays, we can use a function that returns true or false based on a condition. Here’s an example using an anonymous function:

findfirst(z -> z == 5, [5, 10, 15])

If you're unfamiliar with anonymous functions or the syntax, my other article on Functions might clarify these concepts for you. You can read it here:

Section 1.2: Understanding the Differences

While most finding functions operate similarly, findall, findnext, and findprev have notable differences. The findall function retains the same arguments but returns a vector containing all indices that meet the specified condition:

x = Array(1:10)

findall(v::Int64 -> v < 7, x)

This will produce a vector of indices where the condition is satisfied.

To illustrate, let’s say we have:

x = "hello"

findall('l', x)

findall("llo", x)

Lastly, findnext and findprev require an additional index parameter, which denotes the starting point for the search.

x = [80, 800, 50, 500, 40, 400, 50]

findnext(x -> x == 50, x, 4)

These functions are straightforward yet immensely powerful. I highly recommend them to beginners! They have countless applications, and I’d like to conclude by presenting a practical example.

Chapter 2: Practical Application of Find Functions

Consider the following structure:

mutable struct Person

name::String

age::Int64

end

Now, imagine we have a vector of people:

the_squad = [Person("emmy", 22), Person("steve", 25), Person("Jessica", 19)]

To retrieve a person from this vector, rather than using numeric indexing (1, 2, 3...), it is more intuitive to identify individuals by their names. To achieve this, we can extend Base.getindex using the findfirst method:

getindex(vp::Vector{Person}, n::String) = findfirst(p::Person -> p.name == n, vp)

This allows us to access a person by name:

the_squad["emmy"]

or

the_squad[the_squad["emmy"]]

Thank you for taking the time to read my article! Your support means a lot, and I hope this information proves valuable in your journey with Julia. Have a fantastic day!