All Case Studies Design Development Interviews Our Way Project Management

Vector Operations in Go

This post originally appeared on After Eight Coding

 

Foreword


I was always thrilled about learning new stuff, and recently that new stuff happened to be Go.

Why Go? I was hesitating between Rust, Elixir and Go. After some googling I found out that Go is the fastest of the three and the most mature one.

I've always enjoyed implementing raytracing algorithms, it is the most rewarding kind of programming, when after hours of brain-twisting programming you can see the result in a form of a beautiful, rendered image.

I've also found that implementing raytracers is the fastest way to learn a new language, because it touches on all the basic concepts:


  • collections
  • file I/O
  • concurrency
  • packaging and architecture
  • branching, looping, recursion

The project will be written using TDD where it is possible. For testing I will be using the following packages:


  • testing - the Go test package
  • testify - from stretchr, mainly the assert package

Vectors are the core mathematical tool hiding inside the ray tracing algorithm. They allow us to describe relations in 3 dimensional space.


In this blog post I will describe all of the needed vector operations that will be used in GoRay.


You can view the full code for this post here.


Vector representation in Go


First thing I need to do, is define how vectors will be represented in the code. I'm coming from a highly object oriented language (ruby), so naturally I picked a thing that ressembles objects the most - struct (this may not be the Go way, so if you have any other propositions, please ping me).


So let's define a struct that will represent a 3 dimensional vector with coordinates (x, y, z):

[code]

Note that the struct's name and all of the coordinates are written in capital letters. That's because in Go, only stuff that's written in capital letters gets exported when your package is imported somewhere. Lowercase functions, structs, etc. are available only inside the package. If you want some more information about this, visit this link.


Operations on vectors


Go allows us to define methods on structs, which seems like a perfect candidate for defining all of the needed vector operations.

Methods are plain Go functions, but they are defined with a receiver that comes before the function name.


We can define a method on a receiver in two ways:


  • Pointer receiver

    [code]

  • Value receiver

    [code]

The core difference between these two is that, the one that is defined on a pointer receiver, will mutate the actual object it was called on. Analogically a method called on a value receiver will not mutate the receiver, because it will operate on a copy of the original receiver.


All of the methods that will be presented in this post are defined on a value receiver. A new Vector will be returned where applicable.

This type of notation allows for a verbose representation of the equations used in the ray tracing algorithm.


With the technicalities out of the way, let's move on to implementing the actual vector operations.


Adding two vectors


This operation is achieved by adding the corresponding coefficients of two vectors together.


Geometrically it looks like this:

Geometric definition of adding two vectors

[code]


Subtracting two vectors


Subtraction is similar to addition, with the difference that we add a negated vector:

Geometric definition of subtracting two vectors

Analogically to addition of two vectors, we subtract the corresponding coefficients of two vectors:

[code]

Multiplying vector by scalar


Multiplying by a scalar can be interpreted as scaling the vector (modifying it's length). This operation is also pretty straightforward, as we have to multiply each coefficient by the scalar:

 

Geometric definition of scaling a vector

[code]

As a bonus, we also get division by a scalar, by multiplying by 1/s


Dot product of two vectors


The dot product is the first operation that doesn't return a Vector. It returns a scalar value of type float64.

This operation is particurarly important in the context of the ray tracing algorithm, because of it's common use in the equations.


It's algebraic definition is the following:

 

Dot product algebraic definition


It's a simple equation, we multiply corresponding coefficients of both vectors, and then sum those multiplications. But this definition isn't of much use in context of the ray tracing algorithm. What we need here is the geometric definition:

 

Dot product geometric definition

 

The notation ||A|| means length of vector A (more on that in a sec). θ is the angle between the vectors. The fact that we use the cosine function gives us some interesting cases:

 

  1. When the vectors are orthogonal, then the angle between them is 90°. This means that the cosine is 0 and the whole dot product is 0
  2. When the vectors are codirectional, then the angle between them is 0°. This means that the cosine is 1 and the dot product evaluates to:

    Dot product geometric definition

This two cases give us a way to determine if two rays are orthogonal or codirectional, which has a huge meaning when evaluating materials of objects.


With the theoretical stuff out of the way, let's proceed with the implementation:

[code]

Pretty simple, eh?


Length of a vector


As stated earlier, we denote the length of a vector A like this - ||A||. It's algebraic definition is following:

 

Vector length algebraic definition

 

As you can see, it's basically a dot product of a vector with itself, under a square root.

So we can use the already implemented `Dot` method, to implement this one:

[code]

Cross product of two vectors


Unlike the dot product, the cross product returns a new vector, that is perpendicular to the other two.

Additionally this operation is defined in R3


The cross product can be also used for calculating a surface normal (the surface that is defined by the two vectors).

Cross product

The cross product formula is somewhat hard to remember:

 

Cross product formula

 

The implementation looks like this:

[code]

Normalizing a vector


Also called calculating a unit vector - versor:

 

Vector normalization formula

 

All we have to do, is divide (multiply by 1 / x) each of the vectors components by the length of the vector:

[code]

Summary


Now that we have the basic math implemented, we will move to the more exciting stuff. Stay tuned.

Follow Netguru
Join our Newsletter

READ ALSO FROM Go
Read also
Need a successful project?
Estimate project or contact us