> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Go complex128
`complex128` is a built-in numeric type in Go that represents a complex number using 128 bits of memory. It is composed of two 64-bit IEEE 754 floating-point numbers (`float64`): one representing the real component and the other representing the imaginary component.
## Memory Layout and Precision
* **Total Size:** 16 bytes (128 bits).
* **Real Part:** 8 bytes (`float64`).
* **Imaginary Part:** 8 bytes (`float64`).
* **Zero Value:** `0 + 0i` (or simply `0`).
## Declaration and Initialization
You can initialize a `complex128` variable using either the built-in `complex()` function or the imaginary literal suffix `i`.
```go theme={"dark"}
package main
import "fmt"
func main() {
// Method 1: Using the built-in complex() function
// Signature: func complex(r, i FloatType) ComplexType
var a complex128 = complex(5.5, 3.2)
// Method 2: Using literal syntax with the 'i' suffix
var b complex128 = 5.5 + 3.2i
// Method 3: Type inference (Go defaults to complex128 for complex literals)
c := 5.5 + 3.2i
fmt.Printf("a: %v\n", a)
fmt.Printf("b: %v\n", b)
fmt.Printf("Type: %T, Value: %v\n", c, c)
// Output: Type: complex128, Value: (5.5+3.2i)
}
```
## Component Extraction
Go provides built-in functions to extract the real and imaginary `float64` components from a `complex128` value.
```go theme={"dark"}
package main
import "fmt"
func main() {
c := 7.1 + 4.9i
// Extract the real part
// Signature: func real(c ComplexType) FloatType
r := real(c) // Type: float64, Value: 7.1
// Extract the imaginary part
// Signature: func imag(c ComplexType) FloatType
i := imag(c) // Type: float64, Value: 4.9
fmt.Printf("Real: %f, Imaginary: %f\n", r, i)
}
```
## Arithmetic Operations
`complex128` supports standard arithmetic operators. Operations are performed on both the real and imaginary planes according to standard complex arithmetic rules.
```go theme={"dark"}
package main
import "fmt"
func main() {
c1 := 2.0 + 3.0i
c2 := 1.0 + 2.0i
add := c1 + c2 // (3.0+5.0i)
sub := c1 - c2 // (1.0+1.0i)
mul := c1 * c2 // (-4.0+7.0i)
div := c1 / c2 // (1.6-0.2i)
fmt.Printf("Addition: %v\n", add)
fmt.Printf("Subtraction: %v\n", sub)
fmt.Printf("Multiplication: %v\n", mul)
fmt.Printf("Division: %v\n", div)
}
```
## The `math/cmplx` Package
For advanced mathematical operations, Go provides the `math/cmplx` standard library package. This package is specifically designed to operate exclusively on `complex128` values (it does not support `complex64`).
```go theme={"dark"}
package main
import (
"fmt"
"math/cmplx"
)
func main() {
c := 2.0 + 3.0i
// Returns the modulus/magnitude (float64)
abs := cmplx.Abs(c)
// Returns the complex conjugate (complex128)
conj := cmplx.Conj(c)
// Returns the phase/argument (float64)
phase := cmplx.Phase(c)
fmt.Printf("Absolute value: %f\n", abs)
fmt.Printf("Conjugate: %v\n", conj)
fmt.Printf("Phase: %f\n", phase)
}
```
Tired of Poor Go Skills? Fix That With Deep Grasping!
Learn More
