operating complex numbers

• Complex numbers are usually used for scientific applications and calculations. Go implements complex numbers as the primitive type.
• The specific operations on complex numbers are part of the math/cmplx package.

Create the complex.go file with the following content:

        package main

        import (
          "fmt"
          "math/cmplx"
        )

        func main() {

          // complex numbers are
          // defined as real and imaginary
          // part defined by float64
          a := complex(2, 3)

          fmt.Printf("Real part: %f \n", real(a))
          fmt.Printf("Complex part: %f \n", imag(a))

          b := complex(6, 4)

          // All common
          // operators are useful
          c := a - b
          fmt.Printf("Difference : %v\n", c)
          c = a + b
          fmt.Printf("Sum : %v\n", c)
          c = a * b
          fmt.Printf("Product : %v\n", c)
          c = a / b
          fmt.Printf("Product : %v\n", c)

          conjugate := cmplx.Conj(a)
          fmt.Println("Complex number a's conjugate : ", conjugate)

          cos := cmplx.Cos(b)
          fmt.Println("Cosine of b : ", cos)

        }

output:

sangam:golang-daily sangam$ go run complex.go 
Real part: 2.000000 
Complex part: 3.000000 
Difference : (-4-1i)
Sum : (8+7i)
Product : (0+26i)
Product : (0.46153846153846156+0.19230769230769232i)
Complex number a's conjugate :  (2-3i)
Cosine of b :  (26.220553750072888+7.625225809442885i)

How it works...

• The basic operators are implemented for the primitive type complex. The other operations on complex numbers are provided by the math/cmplx package. In case high precision operations are needed, there is no big implementation.

• On the other hand, the complex number could be implemented as real, and the imaginary part expressed by the big.Float type.