> ## 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 complex64
`complex64` is a built-in numeric data type in Go that represents a complex number using 64 bits of memory. It is composed of two 32-bit floating-point numbers (`float32`): one representing the real component and the other representing the imaginary component. Both underlying components adhere to the IEEE 754 standard for floating-point arithmetic.
## Memory Layout
* **Total Size:** 8 bytes (64 bits)
* **Real Part:** 4 bytes (`float32`)
* **Imaginary Part:** 4 bytes (`float32`)
## Declaration and Initialization
You can initialize a `complex64` variable using the built-in `complex()` function or by using complex literal syntax with the `i` suffix.
Because Go's untyped complex literals default to `complex128`, you must explicitly declare the type when creating a `complex64` using shorthand syntax.
```go theme={"dark"}
// Method 1: Using the built-in complex() function.
// The untyped floating-point constants yield an untyped complex constant,
// which is implicitly converted to complex64 by the variable assignment context.
var c1 complex64 = complex(2.5, 3.1)
// Method 2: Using literal notation with explicit type declaration.
var c2 complex64 = 2.5 + 3.1i
// Method 3: Using short variable declaration with type conversion.
c3 := complex64(2.5 + 3.1i)
```
## Component Extraction
Go provides two built-in functions, `real()` and `imag()`, to extract the respective components of a complex number. When applied to a `complex64` value, both functions return a `float32`.
```go theme={"dark"}
var c complex64 = 4.2 - 1.5i
// Extracting the real component
var r float32 = real(c) // r == 4.2
// Extracting the imaginary component
var im float32 = imag(c) // im == -1.5
```
## Arithmetic and Comparison Operations
`complex64` supports standard arithmetic operators. Operations are performed on both the real and imaginary parts simultaneously according to the mathematical rules of complex arithmetic.
```go theme={"dark"}
a := complex64(1.0 + 2.0i)
b := complex64(3.0 + 4.0i)
sum := a + b // 4.0 + 6.0i
difference := a - b // -2.0 - 2.0i
product := a * b // -5.0 + 10.0i
quotient := a / b // 0.44 + 0.08i
```
You can compare `complex64` values using equality operators (`==` and `!=`). Two `complex64` values are strictly equal if and only if both their real and imaginary `float32` components are exactly equal. Inequality operators (`<`, `<=`, `>`, `>=`) are not defined for complex types in Go.
## Standard Library Compatibility
The Go standard library's `math/cmplx` package exclusively operates on `complex128` values. To perform advanced mathematical operations (such as calculating the absolute value or square root) on a `complex64` variable, you must explicitly convert it to `complex128` before passing it to the function.
```go theme={"dark"}
package main
import (
"fmt"
"math/cmplx"
)
func main() {
var c complex64 = 3.0 + 4.0i
// Explicit conversion to complex128 is required for math/cmplx functions.
// The result is cast back to float32 to match the precision of complex64.
magnitude := float32(cmplx.Abs(complex128(c)))
fmt.Println(magnitude) // Output: 5
}
```
Tired of Poor Go Skills? Fix That With Deep Grasping!
Learn More
