Cookbooks
Go
Chapter 3. Numbers
Working with complex numbers

Go:
Working with complex numbers

How to:

In Go, complex numbers are handled using the built-in complex, real, and imag functions, along with complex64 and complex128 types (representing 64-bit and 128-bit complex numbers respectively). Here’s a quick start guide:

package main

import (
	"fmt"
)

func main() {
	// Creating complex numbers
	a := complex(2, 3) // 2+3i
	b := complex(1, -1) // 1-1i

	// Arithmetic operations
	c := a + b
	fmt.Println("Addition:", c) // Output: Addition: (3+2i)

	d := a * b
	fmt.Println("Multiplication:", d) // Output: Multiplication: (5+1i)

	// Accessing real and imaginary parts
	realPart := real(a)
	imagPart := imag(a)
	fmt.Printf("Real part: %.1f, Imaginary part: %.1f\n", realPart, imagPart) // Output: Real part: 2.0, Imaginary part: 3.0

	// Complex conjugate and magnitude can be calculated
	conjugate := complex(real(a), -imag(a)) // Manually
	fmt.Println("Conjugate of a:", conjugate) // Output: Conjugate of a: (2-3i)
}

This example covers the basics, but there’s much more you can do with complex numbers, including leveraging the math/cmplx package for more advanced operations like finding the magnitude, phase, and much more.

Deep Dive

The concept of complex numbers dates back to the 16th century, but only got wide recognition and rigorous formalization in the 19th century. In computer programming, complex numbers have been a staple for complex arithmetic in scientific and engineering calculations since the early days. Go’s approach to complex numbers, by making them a first-class citizen with built-in support and comprehensive standard library support through the math/cmplx package, stands out among programming languages. This design decision reflects Go’s emphasis on simplicity and performance.

Nevertheless, it’s worth noting that working with complex numbers in Go, while powerful, may not always be the best approach for all applications, particularly those requiring symbolic mathematics or high-precision arithmetic. Languages and environments specialized in scientific computing, such as Python with libraries like NumPy and SciPy, or software like MATLAB, might offer more flexibility and a broader range of functionalities for specific applications.

That said, for systems programming and contexts where integrating complex number calculations into a larger, performance-sensitive application is crucial, Go’s native support for complex numbers provides a uniquely efficient option.

Rounding numbers