Go complex128

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)
}

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)
}

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)
}

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)
}