zig/lib/std / math/complex.zig 

const std = @import("../std.zig");
const testing = std.testing;
const math = std.math;

abs

complex/abs.zig 
pub const abs = @import("complex/abs.zig").abs;

acosh

complex/acosh.zig 
pub const acosh = @import("complex/acosh.zig").acosh;

acos

complex/acos.zig 
pub const acos = @import("complex/acos.zig").acos;

arg

complex/arg.zig 
pub const arg = @import("complex/arg.zig").arg;

asinh

complex/asinh.zig 
pub const asinh = @import("complex/asinh.zig").asinh;

asin

complex/asin.zig 
pub const asin = @import("complex/asin.zig").asin;

atanh

complex/atanh.zig 
pub const atanh = @import("complex/atanh.zig").atanh;

atan

complex/atan.zig 
pub const atan = @import("complex/atan.zig").atan;

conj

complex/conj.zig 
pub const conj = @import("complex/conj.zig").conj;

cosh

complex/cosh.zig 
pub const cosh = @import("complex/cosh.zig").cosh;

cos

complex/cos.zig 
pub const cos = @import("complex/cos.zig").cos;

exp

complex/exp.zig 
pub const exp = @import("complex/exp.zig").exp;

log

complex/log.zig 
pub const log = @import("complex/log.zig").log;

pow

complex/pow.zig 
pub const pow = @import("complex/pow.zig").pow;

proj

complex/proj.zig 
pub const proj = @import("complex/proj.zig").proj;

sinh

complex/sinh.zig 
pub const sinh = @import("complex/sinh.zig").sinh;

sin

complex/sin.zig 
pub const sin = @import("complex/sin.zig").sin;

sqrt

complex/sqrt.zig 
pub const sqrt = @import("complex/sqrt.zig").sqrt;

tanh

complex/tanh.zig 
pub const tanh = @import("complex/tanh.zig").tanh;

tan

complex/tan.zig 
pub const tan = @import("complex/tan.zig").tan;

Complex()

A complex number consisting of a real an imaginary part. T must be a floating-point value.

 
pub fn Complex(comptime T: type) type {
    return struct {
        const Self = @This();

        re: T,

        im: T,

init()

Real part. Imaginary part. Create a new Complex number from the given real and imaginary parts.

 
        pub fn init(re: T, im: T) Self {
            return Self{
                .re = re,
                .im = im,
            };
        }

add()

Returns the sum of two complex numbers.

 
        pub fn add(self: Self, other: Self) Self {
            return Self{
                .re = self.re + other.re,
                .im = self.im + other.im,
            };
        }

sub()

Returns the subtraction of two complex numbers.

 
        pub fn sub(self: Self, other: Self) Self {
            return Self{
                .re = self.re - other.re,
                .im = self.im - other.im,
            };
        }

mul()

Returns the product of two complex numbers.

 
        pub fn mul(self: Self, other: Self) Self {
            return Self{
                .re = self.re * other.re - self.im * other.im,
                .im = self.im * other.re + self.re * other.im,
            };
        }

div()

Returns the quotient of two complex numbers.

 
        pub fn div(self: Self, other: Self) Self {
            const re_num = self.re * other.re + self.im * other.im;
            const im_num = self.im * other.re - self.re * other.im;
            const den = other.re * other.re + other.im * other.im;

            return Self{
                .re = re_num / den,
                .im = im_num / den,
            };
        }

conjugate()

Returns the complex conjugate of a number.

 
        pub fn conjugate(self: Self) Self {
            return Self{
                .re = self.re,
                .im = -self.im,
            };
        }

neg()

Returns the negation of a complex number.

 
        pub fn neg(self: Self) Self {
            return Self{
                .re = -self.re,
                .im = -self.im,
            };
        }

mulbyi()

Returns the product of complex number and i=sqrt(-1)

 
        pub fn mulbyi(self: Self) Self {
            return Self{
                .re = -self.im,
                .im = self.re,
            };
        }

reciprocal()

Returns the reciprocal of a complex number.

 
        pub fn reciprocal(self: Self) Self {
            const m = self.re * self.re + self.im * self.im;
            return Self{
                .re = self.re / m,
                .im = -self.im / m,
            };
        }

magnitude()

Returns the magnitude of a complex number.

 
        pub fn magnitude(self: Self) T {
            return @sqrt(self.re * self.re + self.im * self.im);
        }
    };
}

const epsilon = 0.0001;

Test:

complex.add

 
test "complex.add" {
    const a = Complex(f32).init(5, 3);
    const b = Complex(f32).init(2, 7);
    const c = a.add(b);

    try testing.expect(c.re == 7 and c.im == 10);
}

Test:

complex.sub

 
test "complex.sub" {
    const a = Complex(f32).init(5, 3);
    const b = Complex(f32).init(2, 7);
    const c = a.sub(b);

    try testing.expect(c.re == 3 and c.im == -4);
}

Test:

complex.mul

 
test "complex.mul" {
    const a = Complex(f32).init(5, 3);
    const b = Complex(f32).init(2, 7);
    const c = a.mul(b);

    try testing.expect(c.re == -11 and c.im == 41);
}

Test:

complex.div

 
test "complex.div" {
    const a = Complex(f32).init(5, 3);
    const b = Complex(f32).init(2, 7);
    const c = a.div(b);

    try testing.expect(math.approxEqAbs(f32, c.re, @as(f32, 31) / 53, epsilon) and
        math.approxEqAbs(f32, c.im, @as(f32, -29) / 53, epsilon));
}

Test:

complex.conjugate

 
test "complex.conjugate" {
    const a = Complex(f32).init(5, 3);
    const c = a.conjugate();

    try testing.expect(c.re == 5 and c.im == -3);
}

Test:

complex.neg

 
test "complex.neg" {
    const a = Complex(f32).init(5, 3);
    const c = a.neg();

    try testing.expect(c.re == -5 and c.im == -3);
}

Test:

complex.mulbyi

 
test "complex.mulbyi" {
    const a = Complex(f32).init(5, 3);
    const c = a.mulbyi();

    try testing.expect(c.re == -3 and c.im == 5);
}

Test:

complex.reciprocal

 
test "complex.reciprocal" {
    const a = Complex(f32).init(5, 3);
    const c = a.reciprocal();

    try testing.expect(math.approxEqAbs(f32, c.re, @as(f32, 5) / 34, epsilon) and
        math.approxEqAbs(f32, c.im, @as(f32, -3) / 34, epsilon));
}

Test:

complex.magnitude

 
test "complex.magnitude" {
    const a = Complex(f32).init(5, 3);
    const c = a.magnitude();

    try testing.expect(math.approxEqAbs(f32, c, 5.83095, epsilon));
}

test {
    _ = @import("complex/abs.zig");
    _ = @import("complex/acosh.zig");
    _ = @import("complex/acos.zig");
    _ = @import("complex/arg.zig");
    _ = @import("complex/asinh.zig");
    _ = @import("complex/asin.zig");
    _ = @import("complex/atanh.zig");
    _ = @import("complex/atan.zig");
    _ = @import("complex/conj.zig");
    _ = @import("complex/cosh.zig");
    _ = @import("complex/cos.zig");
    _ = @import("complex/exp.zig");
    _ = @import("complex/log.zig");
    _ = @import("complex/pow.zig");
    _ = @import("complex/proj.zig");
    _ = @import("complex/sinh.zig");
    _ = @import("complex/sin.zig");
    _ = @import("complex/sqrt.zig");
    _ = @import("complex/tanh.zig");
    _ = @import("complex/tan.zig");
}