Machine Learning with Golang: Data Structures and Algorithms

1. Introduction

Machine learning is the process of creating systems that can learn from data and make predictions or decisions. Machine learning is widely used in various domains, such as computer vision, natural language processing, recommender systems, and more.

But what is the best programming language for machine learning? There is no definitive answer to this question, as different languages have different strengths and weaknesses. However, one language that has been gaining popularity and attention in the machine learning community is Golang.

Golang, or Go, is an open-source, compiled, and concurrent programming language developed by Google. Golang is designed to be simple, fast, and scalable, making it suitable for developing large and complex applications. Golang also has a rich set of built-in data structures and algorithms that can be used for machine learning.

In this blog, you will learn how to use Golang’s data structures and algorithms for machine learning. You will also learn about some popular machine learning libraries and frameworks in Golang. By the end of this blog, you will have a better understanding of how Golang can help you with your machine learning projects.

Are you ready to dive into the world of machine learning with Golang? Let’s get started!

2. Why Golang for Machine Learning?

Golang is a relatively new programming language, but it has already proven itself as a powerful and versatile tool for developing various applications. But what makes Golang a good choice for machine learning? Here are some of the reasons why you might want to consider using Golang for your machine learning projects:

• Performance: Golang is a compiled and concurrent language, which means it can run fast and handle multiple tasks at the same time. Golang also has a garbage collector that automatically manages memory allocation and deallocation, which reduces the risk of memory leaks and improves performance. Golang also supports cross-compilation, which means you can compile your code for different platforms and architectures without changing the source code.
• Simplicity: Golang is designed to be simple and easy to learn, with a syntax that is similar to C and other popular languages. Golang also has a small and consistent set of features, which avoids unnecessary complexity and confusion. Golang also has a built-in testing and documentation tool, which makes it easier to write and maintain high-quality code.
• Scalability: Golang is designed to scale well, with features such as goroutines and channels that enable concurrent and parallel programming. Goroutines are lightweight threads that can run multiple functions simultaneously, while channels are communication pipes that can pass data between goroutines. Golang also has a standard library that provides a rich set of packages for common tasks, such as networking, cryptography, compression, and more.
• Data Structures and Algorithms: Golang has a rich set of built-in data structures and algorithms that can be used for machine learning, such as slices, maps, structs, interfaces, sort, and search. Slices are dynamic arrays that can store and manipulate data efficiently, while maps are associative arrays that can store key-value pairs. Structs are user-defined types that can group related data together, while interfaces are abstract types that can define the behavior of a type. Sort and search are algorithms that can sort and search data in slices and maps.

As you can see, Golang has many advantages that make it a suitable language for machine learning. But how can you use Golang’s data structures and algorithms for machine learning? In the next section, you will learn how to use slices, maps, structs, and interfaces for machine learning.

3. Golang Data Structures for Machine Learning

In this section, you will learn how to use Golang’s built-in data structures for machine learning. Data structures are ways of organizing and storing data in memory, and they can affect the performance and efficiency of your machine learning algorithms. Golang has four main data structures that are useful for machine learning: slices, maps, structs, and interfaces.

Slices are dynamic arrays that can store and manipulate data efficiently. They are similar to Python’s lists, but they have some differences and advantages. Maps are associative arrays that can store key-value pairs. They are similar to Python’s dictionaries, but they have some differences and advantages. Structs are user-defined types that can group related data together. They are similar to Python’s classes, but they have some differences and advantages. Interfaces are abstract types that can define the behavior of a type. They are similar to Python’s abstract base classes, but they have some differences and advantages.

Why are these data structures important for machine learning? Because they can help you represent and manipulate different kinds of data, such as vectors, matrices, tensors, tables, records, graphs, and more. For example, you can use slices to store and operate on numerical data, such as adding, multiplying, or dotting two vectors. You can use maps to store and access categorical data, such as mapping labels to indices or vice versa. You can use structs to store and organize complex data, such as defining a custom type for a machine learning model or a dataset. You can use interfaces to define and implement common methods for different types, such as implementing a fit method for different machine learning models.

In the following subsections, you will learn how to use each of these data structures in more detail, with examples and code snippets. You will also learn how to use some of the built-in functions and methods that Golang provides for working with these data structures. By the end of this section, you will have a solid understanding of how to use Golang’s data structures for machine learning.

3.1. Slices

Slices are one of the most important and versatile data structures in Golang. A slice is a dynamic array that can store and manipulate data efficiently. A slice can hold any type of data, such as numbers, strings, booleans, structs, or even other slices. A slice can also grow or shrink as needed, without wasting memory or affecting performance.

How can you create and use slices in Golang? There are several ways to do that, but the most common ones are:

• Using the make function, which creates a slice with a given length and capacity. For example,

  x := make([]int, 5, 10)

  creates a slice of integers with length 5 and capacity 10.

• Using the slice literal syntax, which creates a slice with the values specified in brackets. For example,

  y := []string{"Hello", "World"}

  creates a slice of strings with the values “Hello” and “World”.

• Using the slicing operator, which creates a slice from another slice or array by specifying the start and end indices. For example,

  z := x[1:3]

  creates a slice of integers from the slice x, with the values x[1] and x[2].

Once you have a slice, you can access and modify its elements using the index notation, such as

x[0] = 42

or

fmt.Println(y[1])

. You can also use the len function to get the length of a slice, such as

fmt.Println(len(z))

. You can also use the append function to add new elements to a slice, such as

x = append(x, 100, 200)

. Note that append may create a new slice if the original slice does not have enough capacity.

Why are slices useful for machine learning? Because they can help you represent and manipulate different kinds of numerical data, such as vectors, matrices, tensors, and more. For example, you can use a slice of floats to store and operate on a vector, such as adding, multiplying, or dotting two vectors. You can use a slice of slices to store and operate on a matrix, such as transposing, multiplying, or inverting a matrix. You can use a slice of slices of slices to store and operate on a tensor, such as reshaping, slicing, or contracting a tensor.

In the next subsection, you will learn how to use another data structure in Golang, maps, which can help you store and access categorical data.

3.2. Maps

Maps are another data structure in Golang that can help you store and access categorical data. A map is an associative array that can store key-value pairs. A map can hold any type of data as keys or values, as long as the keys are comparable. A map can also grow or shrink as needed, without wasting memory or affecting performance.

How can you create and use maps in Golang? There are several ways to do that, but the most common ones are:

• Using the make function, which creates a map with a given type. For example,

  m := make(map[string]int)

  creates a map with string keys and integer values.

• Using the map literal syntax, which creates a map with the values specified in braces. For example,

  n := map[string]int{"one": 1, "two": 2, "three": 3}

  creates a map with string keys and integer values, with the values “one”, “two”, and “three” mapped to 1, 2, and 3 respectively.

• Using the comma ok idiom, which checks if a key exists in a map and returns its value and a boolean. For example,

  v, ok := n["four"]

  checks if the key “four” exists in the map n, and assigns its value to v and true to ok if it does, or zero and false otherwise.

Once you have a map, you can access and modify its elements using the index notation, such as

m["hello"] = 42

or

fmt.Println(n["two"])

. You can also use the len function to get the number of key-value pairs in a map, such as

fmt.Println(len(m))

. You can also use the delete function to remove a key-value pair from a map, such as

delete(n, "three")

. Note that deleting a non-existent key does nothing.

Why are maps useful for machine learning? Because they can help you store and access different kinds of categorical data, such as labels, features, parameters, and more. For example, you can use a map to store and access the labels of a dataset, such as mapping the names of the classes to their indices or vice versa. You can use a map to store and access the features of a dataset, such as mapping the names of the features to their values or vice versa. You can use a map to store and access the parameters of a machine learning model, such as mapping the names of the parameters to their values or vice versa.

In the next subsection, you will learn how to use another data structure in Golang, structs, which can help you store and organize complex data.

3.3. Structs and Interfaces

Structs and interfaces are two more data structures in Golang that can help you store and organize complex data. Structs are user-defined types that can group related data together, while interfaces are abstract types that can define the behavior of a type.

How can you create and use structs and interfaces in Golang? There are several ways to do that, but the most common ones are:

• Using the type keyword, which defines a new type with a name and a set of fields or methods. For example,

  type Point struct {
      x float64
      y float64
  }

  defines a new type called Point, which has two fields of type float64, x and y.

• Using the struct literal syntax, which creates a struct value with the values specified in braces. For example,

  p := Point{1.0, 2.0}

  creates a struct value of type Point, with the values 1.0 and 2.0 assigned to x and y respectively.

• Using the dot operator, which accesses or modifies the fields or methods of a struct value. For example,

  p.x = 3.0

  modifies the x field of the struct value p, while

  fmt.Println(p.y)

  accesses the y field of the struct value p.

• Using the interface keyword, which defines a new type with a name and a set of methods. For example,

  type Shape interface {
      Area() float64
      Perimeter() float64
  }

  defines a new type called Shape, which has two methods, Area and Perimeter, that return float64 values.

• Using the type assertion syntax, which checks if a value implements an interface and returns its underlying value and a boolean. For example,

  s, ok := p.(Shape)

  checks if the value p implements the interface Shape, and assigns its underlying value to s and true to ok if it does, or nil and false otherwise.

Why are structs and interfaces useful for machine learning? Because they can help you store and organize different kinds of complex data, such as models, datasets, metrics, and more. For example, you can use a struct to define a custom type for a machine learning model, such as a linear regression model, with fields for the parameters, the loss function, the optimizer, and the methods for training, predicting, and evaluating. You can use an interface to define a common behavior for different machine learning models, such as a fit method that takes a dataset and trains the model, or a predict method that takes an input and returns an output. You can also use structs and interfaces to implement polymorphism, which means you can use different types interchangeably as long as they implement the same interface.

In the next section, you will learn how to use some of the built-in algorithms in Golang, such as sort and search, which can help you manipulate data efficiently.

4. Golang Algorithms for Machine Learning

In this section, you will learn how to use some of the built-in algorithms in Golang, such as sort and search, which can help you manipulate data efficiently. Algorithms are sequences of steps that solve a specific problem or perform a specific task. Golang has a standard library that provides a package called sort, which implements various sorting algorithms for different types of data, and a package called search, which implements various searching algorithms for different types of data.

How can you use the sort and search packages in Golang? There are several ways to do that, but the most common ones are:

• Using the sort.Slice function, which sorts a slice of any type in place, using a custom comparison function. For example,

  sort.Slice(x, func(i, j int) bool { return x[i] < x[j] })

  sorts the slice of integers x in ascending order, using the less-than operator as the comparison function.

• Using the sort.Search function, which searches for a value in a sorted slice of any type, using a custom comparison function. For example,

  i := sort.Search(len(x), func(i int) bool { return x[i] >= 42 })

  searches for the value 42 in the sorted slice of integers x, using the greater-than-or-equal operator as the comparison function, and returns the index of the first element that satisfies the condition, or the length of the slice if none does.

• Using the sort.Interface interface, which defines the methods that a type must implement to be sortable by the sort package. For example,

  type Point struct {
      x float64
      y float64
  }
  
  type Points []Point
  
  func (p Points) Len() int { return len(p) }
  func (p Points) Less(i, j int) bool { return p[i].x < p[j].x }
  func (p Points) Swap(i, j int) { p[i], p[j] = p[j], p[i] }

  defines a type called Points, which is a slice of Point structs, and implements the Len, Less, and Swap methods, which compare the points by their x coordinates. This allows the Points type to be sortable by the sort package, such as

  sort.Sort(Points(p))

  , which sorts the slice of points p by their x coordinates.

Why are sorting and searching algorithms useful for machine learning? Because they can help you perform various tasks on data, such as finding the minimum or maximum value, finding the median or mode, finding the nearest neighbor, finding the kth largest or smallest element, finding the rank or percentile, and more. For example, you can use the sort package to sort a slice of floats that represents a vector, and then use the search package to find the index of a specific value in the vector, or the index of the median value, or the index of the value that is closest to a given value.

In the next subsection, you will learn how to use another algorithm in Golang, linear algebra and statistics, which can help you perform various calculations and analyses on data.

4.1. Sort

Sorting is the process of arranging data in a certain order, such as ascending or descending, alphabetical or numerical, or according to some other criteria. Sorting is one of the most fundamental and common algorithms in computer science, and it can help you perform various tasks on data, such as finding the minimum or maximum value, finding the median or mode, finding the kth largest or smallest element, finding the rank or percentile, and more.

How can you sort data in Golang? There are several ways to do that, but the most common one is to use the sort package, which provides various sorting algorithms for different types of data. The sort package has two main types of functions: generic and specific. Generic functions can sort any type of data, as long as it implements the sort.Interface interface, which defines the methods Len, Less, and Swap. Specific functions can sort specific types of data, such as slices of integers, floats, strings, or structs, using predefined comparison functions.

For example, if you have a slice of integers called x, you can sort it in ascending order using the sort.Ints function, which is a specific function for slices of integers. You can also sort it in descending order using the sort.Sort function, which is a generic function that takes a sort.Interface value, and passing it a reverse slice of integers, which is a type that implements the sort.Interface interface and reverses the order of the comparison function. Here is how you can do that:

// Define a type that implements the sort.Interface interface and reverses the order of the comparison function
type reverse []int

func (r reverse) Len() int { return len(r) }
func (r reverse) Less(i, j int) bool { return r[i] > r[j] } // Reverse the order of the comparison function
func (r reverse) Swap(i, j int) { r[i], r[j] = r[j], r[i] }

// Create a slice of integers
x := []int{5, 2, 7, 9, 1, 4, 6, 8, 3}

// Sort the slice in ascending order using the sort.Ints function
sort.Ints(x)
fmt.Println(x) // Prints [1 2 3 4 5 6 7 8 9]

// Sort the slice in descending order using the sort.Sort function and passing it a reverse slice of integers
sort.Sort(reverse(x))
fmt.Println(x) // Prints [9 8 7 6 5 4 3 2 1]

As you can see, the sort package makes it easy and convenient to sort data in Golang. You can also use the sort package to sort slices of other types, such as floats, strings, or structs, using the corresponding specific functions, such as sort.Float64s, sort.Strings, or sort.Slice. You can also use the sort package to sort custom types, such as Points, by implementing the sort.Interface interface or using the sort.Slice function with a custom comparison function.

In the next subsection, you will learn how to use another algorithm in Golang, search, which can help you find data efficiently.

4.2. Search

Searching is the process of finding a value or a range of values in a collection of data, such as a slice, a map, or a custom type. Searching is one of the most fundamental and common algorithms in computer science, and it can help you perform various tasks on data, such as finding the nearest neighbor, finding the kth largest or smallest element, finding the rank or percentile, and more.

How can you search data in Golang? There are several ways to do that, but the most common one is to use the search package, which provides various searching algorithms for different types of data. The search package has two main types of functions: generic and specific. Generic functions can search any type of data, as long as it is sorted and implements the sort.Interface interface, which defines the methods Len and Less. Specific functions can search specific types of data, such as slices of integers, floats, strings, or structs, using predefined comparison functions.

For example, if you have a sorted slice of integers called x, you can search for the value 42 using the sort.SearchInts function, which is a specific function for slices of integers. You can also search for the value 42 using the sort.Search function, which is a generic function that takes a sort.Interface value and a custom comparison function. Here is how you can do that:

// Create a sorted slice of integers
x := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}

// Search for the value 42 using the sort.SearchInts function
i := sort.SearchInts(x, 42)
fmt.Println(i) // Prints 9, which is the index where 42 should be inserted to maintain the order

// Search for the value 42 using the sort.Search function and a custom comparison function
j := sort.Search(len(x), func(i int) bool { return x[i] >= 42 })
fmt.Println(j) // Prints 9, which is the same as above

As you can see, the search package makes it easy and convenient to search data in Golang. You can also use the search package to search slices of other types, such as floats, strings, or structs, using the corresponding specific functions, such as sort.SearchFloat64s, sort.SearchStrings, or sort.SearchSlice. You can also use the search package to search custom types, such as Points, by implementing the sort.Interface interface or using the sort.Search function with a custom comparison function.

In the next subsection, you will learn how to use another algorithm in Golang, linear algebra and statistics, which can help you perform various calculations and analyses on data.

4.3. Linear Algebra and Statistics

Linear algebra and statistics are two branches of mathematics that are essential for machine learning, as they provide the tools and techniques to perform various calculations and analyses on data, such as matrix operations, vector operations, linear equations, linear transformations, eigenvalues, eigenvectors, regression, correlation, covariance, mean, median, mode, standard deviation, variance, probability, distribution, hypothesis testing, and more.

How can you use linear algebra and statistics in Golang? There are several ways to do that, but the most common one is to use the gonum package, which is a set of packages that provide numerical and scientific computing functionalities for Golang. The gonum package has several subpackages that are relevant for linear algebra and statistics, such as:

• gonum/mat, which provides matrix and vector types and operations, such as addition, subtraction, multiplication, division, transpose, inverse, determinant, trace, norm, dot product, cross product, and more.
• gonum/linalg, which provides linear algebra functions and algorithms, such as solving linear systems, finding eigenvalues and eigenvectors, performing singular value decomposition, performing QR decomposition, performing LU decomposition, and more.
• gonum/stat, which provides statistical functions and algorithms, such as computing mean, median, mode, standard deviation, variance, correlation, covariance, regression, distribution, probability, hypothesis testing, and more.

For example, if you have two slices of floats called x and y, you can create a matrix from them using the gonum/mat.NewDense function, which creates a dense matrix from a row-major flattened slice of data. You can also compute the mean and standard deviation of x and y using the gonum/stat.Mean and gonum/stat.StdDev functions, which take a slice of data and an optional weight slice and return the mean and standard deviation respectively. Here is how you can do that:

// Import the gonum packages
import (
    "fmt"
    "gonum.org/v1/gonum/mat"
    "gonum.org/v1/gonum/stat"
)

// Create two slices of floats
x := []float64{1, 2, 3, 4, 5}
y := []float64{6, 7, 8, 9, 10}

// Create a matrix from x and y
m := mat.NewDense(2, 5, append(x, y...))
fmt.Println(m) // Prints a 2x5 matrix with x as the first row and y as the second row

// Compute the mean and standard deviation of x and y
meanX := stat.Mean(x, nil)
stdX := stat.StdDev(x, nil)
meanY := stat.Mean(y, nil)
stdY := stat.StdDev(y, nil)
fmt.Println(meanX, stdX, meanY, stdY) // Prints 3 1.5811388300841898 8 1.5811388300841898

As you can see, the gonum package makes it easy and convenient to use linear algebra and statistics in Golang. You can also use the gonum package to perform other calculations and analyses on data, such as matrix inversion, matrix multiplication, linear regression, normal distribution, t-test, and more.

In the next section, you will learn how to use some of the popular machine learning libraries and frameworks in Golang, such as Gorgonia, Gonum, and TensorFlow, which can help you create and train machine learning models.

5. Machine Learning Libraries and Frameworks in Golang

Machine learning is the process of creating systems that can learn from data and make predictions or decisions. Machine learning is widely used in various domains, such as computer vision, natural language processing, recommender systems, and more. However, machine learning is not a trivial task, as it involves many steps and challenges, such as data preprocessing, feature engineering, model selection, model training, model evaluation, model deployment, and more.

How can you simplify and streamline the machine learning process in Golang? There are several ways to do that, but the most common one is to use some of the popular machine learning libraries and frameworks in Golang, such as Gorgonia, Gonum, and TensorFlow. These libraries and frameworks provide various tools and functionalities for machine learning, such as data manipulation, numerical computation, linear algebra, statistics, optimization, neural networks, deep learning, and more.

For example, if you want to create and train a neural network in Golang, you can use the Gorgonia library, which is a library for building and executing computational graphs, similar to TensorFlow or PyTorch. Gorgonia allows you to define the structure and operations of your neural network using a symbolic and declarative approach, and then automatically computes the gradients and updates the parameters using various optimization methods. Here is how you can do that:

// Import the Gorgonia packages
import (
    "fmt"
    "gorgonia.org/gorgonia"
    "gorgonia.org/tensor"
)

// Create a new computation graph
g := gorgonia.NewGraph()

// Define the input and output tensors
x := tensor.New(tensor.WithShape(4, 2), tensor.WithBacking([]float64{0, 0, 0, 1, 1, 0, 1, 1})) // Input: XOR data
y := tensor.New(tensor.WithShape(4, 1), tensor.WithBacking([]float64{0, 1, 1, 0})) // Output: XOR labels

// Define the input and output nodes
xNode := gorgonia.NewMatrix(g, gorgonia.Float64, gorgonia.WithShape(4, 2), gorgonia.WithName("x"), gorgonia.WithValue(x))
yNode := gorgonia.NewMatrix(g, gorgonia.Float64, gorgonia.WithShape(4, 1), gorgonia.WithName("y"), gorgonia.WithValue(y))

// Define the weights and biases nodes
w0 := gorgonia.NewMatrix(g, gorgonia.Float64, gorgonia.WithShape(2, 2), gorgonia.WithName("w0"), gorgonia.WithInit(gorgonia.GlorotN(1.0))) // Weights from input layer to hidden layer
b0 := gorgonia.NewMatrix(g, gorgonia.Float64, gorgonia.WithShape(1, 2), gorgonia.WithName("b0"), gorgonia.WithInit(gorgonia.Zeroes())) // Biases from input layer to hidden layer
w1 := gorgonia.NewMatrix(g, gorgonia.Float64, gorgonia.WithShape(2, 1), gorgonia.WithName("w1"), gorgonia.WithInit(gorgonia.GlorotN(1.0))) // Weights from hidden layer to output layer
b1 := gorgonia.NewMatrix(g, gorgonia.Float64, gorgonia.WithShape(1, 1), gorgonia.WithName("b1"), gorgonia.WithInit(gorgonia.Zeroes())) // Biases from hidden layer to output layer

// Define the hidden layer node
hNode := gorgonia.Must(gorgonia.Sigmoid(gorgonia.Must(gorgonia.Add(gorgonia.Must(gorgonia.Mul(xNode, w0)), b0)))) // Hidden layer = sigmoid(x * w0 + b0)

// Define the output layer node
oNode := gorgonia.Must(gorgonia.Sigmoid(gorgonia.Must(gorgonia.Add(gorgonia.Must(gorgonia.Mul(hNode, w1)), b1)))) // Output layer = sigmoid(h * w1 + b1)

// Define the loss function node
lossNode := gorgonia.Must(gorgonia.Mean(gorgonia.Must(gorgonia.Square(gorgonia.Must(gorgonia.Sub(yNode, oNode)))))) // Loss function = mean((y - o)^2)

// Define the gradient nodes
grads, err := gorgonia.Grad(lossNode, w0, b0, w1, b1)
if err != nil {
    fmt.Println(err)
    return
}

// Create a VM to run the graph
vm := gorgonia.NewTapeMachine(g, gorgonia.BindDualValues(w0, b0, w1, b1))
defer vm.Close()

// Create a solver to update the parameters
solver := gorgonia.NewAdamSolver(gorgonia.WithLearnRate(0.1))

// Train the neural network for 100 epochs
for epoch := 0; epoch < 100; epoch++ {
    // Run the graph
    vm.RunAll()
    // Get the current loss
    loss := lossNode.Value().Data().(float64)
    // Print the loss
    fmt.Printf("Epoch: %d, Loss: %f\n", epoch, loss)
    // Update the parameters
    solver.Step(grads)
    // Reset the VM
    vm.Reset()
}

As you can see, the Gorgonia library makes it easy and convenient to create and train a neural network in Golang. You can also use the Gorgonia library to create and train other types of machine learning models, such as linear regression, logistic regression, support vector machines, k-means clustering, and more.

In the next section, you will learn how to conclude your blog and summarize the main points and takeaways.

6. Conclusion

In this blog, you have learned how to use Golang for machine learning. You have learned how to use Golang's built-in data structures and algorithms for machine learning, such as slices, maps, structs, interfaces, sort, and search. You have also learned how to use some of the popular machine learning libraries and frameworks in Golang, such as Gorgonia, Gonum, and TensorFlow, which can help you create and train machine learning models.

Golang is a powerful and versatile programming language that can help you with your machine learning projects. Golang has many advantages, such as performance, simplicity, scalability, and a rich set of data structures and algorithms. Golang also has a growing and active community of developers and researchers who are working on improving and expanding the machine learning capabilities of Golang.

If you are interested in learning more about Golang and machine learning, you can check out some of the following resources:

• The official Golang documentation, which provides a comprehensive and detailed guide to the language and its features.
• The Gonum GitHub repository, which contains the source code and documentation of the Gonum package and its subpackages.
• The Gorgonia website, which provides tutorials, examples, and documentation of the Gorgonia library and its features.
• The TensorFlow for Go guide, which explains how to install and use TensorFlow in Golang.
• The machine learning Golang GitHub topic, which lists some of the most popular and interesting machine learning projects and repositories in Golang.

We hope you have enjoyed this blog and learned something new and useful. Thank you for reading and happy coding!