struct Complex

Overview

A complex number is a number represented in the form a + bi. In this form, a and b are real numbers, and i is an imaginary number such as i² = -1. The a is the real part of the number, and the b is the imaginary part of the number.

NOTE To use Complex, you must explicitly import it with require "complex"

require "complex"

Complex.new(1, 0)   # => 1.0 + 0.0.i
Complex.new(5, -12) # => 5.0 - 12.0.i

1.to_c # => 1.0 + 0.0.i
1.i    # => 0.0 + 1.0.i

complex.cr

Constructor Detail

def self.additive_identity : self #

def self.multiplicative_identity : self #

def self.new(real : Number, imag : Number = 0) #

def self.new(c : Complex) #

def self.zero : Complex #

Returns the number 0 in complex form.

Instance Method Detail

def *(other : Complex) : Complex #

Multiplies self by other.

def *(other : Number) : Complex #

Multiplies self by other.

def +(other : Complex) : Complex #

Adds the value of self to other.

def +(other : Number) : Complex #

Adds the value of self to other.

def + : Complex #

Returns self.

def -(other : Complex) : Complex #

Removes the value of other from self.

def -(other : Number) : Complex #

Removes the value of other from self.

def - : Complex #

Returns the opposite of self.

def /(other : Complex) : Complex #

Divides self by other.

def /(other : Number) : Complex #

Divides self by other.

def ==(other : Complex) #

Determines whether self equals other or not.

def ==(other : Number) #

Determines whether self equals other or not.

def ==(other) #

Determines whether self equals other or not.

def abs : Float64 #

Returns the absolute value of this complex number in a number form, using the Pythagorean theorem.

require "complex"

Complex.new(42, 2).abs  # => 42.04759208325728
Complex.new(-42, 2).abs # => 42.04759208325728

def abs2 : Float64 #

Returns the square of absolute value in a number form.

require "complex"

Complex.new(42, 2).abs2 # => 1768

def clone #

def conj : Complex #

Returns the conjugate of self.

require "complex"

Complex.new(42, 2).conj  # => 42.0 - 2.0.i
Complex.new(42, -2).conj # => 42.0 + 2.0.i

def hash(hasher) #

def imag : Float64 #

Returns the imaginary part.

def inspect(io : IO) : Nil #

Writes this complex object to an io, surrounded by parentheses.

require "complex"

Complex.new(42, 2).inspect # => "(42.0 + 2.0i)"

def inv : Complex #

Returns the inverse of self.

def phase : Float64 #

Returns the phase of self.

def polar : Tuple(Float64, Float64) #

Returns a Tuple with the #abs value and the #phase.

require "complex"

Complex.new(42, 2).polar # => {42.047592083257278, 0.047583103276983396}

def real : Float64 #

Returns the real part.

def round(digits = 0) : Complex #

Rounds to the nearest digits.

def sign : Complex #

Returns the complex sign of self.

If self is non-zero, the returned value has the same phase as self and absolute value 1.0. If self is zero, returns self.

The returned value's real and imaginary components always have the same signs as the respective components of self.

require "complex"

Complex.new(7, -24).sign        # => (0.28 - 0.96.i)
Complex.new(1.0 / 0.0, 24).sign # => (1.0 + 0.0.i)
Complex.new(-0.0, +0.0).sign    # => (-0.0 + 0.0.i)

def to_c #

Returns self.

def to_f #

See #to_f64.

def to_f32(*args, **options) #

def to_f32(*args, **options, &) #

def to_f64 : Float64 #

Returns the value as a Float64 if possible (the imaginary part should be exactly zero), raises otherwise.

def to_i #

See #to_i32.

def to_i128(*args, **options) #

def to_i128(*args, **options, &) #

def to_i16(*args, **options) #

def to_i16(*args, **options, &) #

def to_i32(*args, **options) #

def to_i32(*args, **options, &) #

def to_i64(*args, **options) #

def to_i64(*args, **options, &) #

def to_i8(*args, **options) #

def to_i8(*args, **options, &) #

def to_s(io : IO) : Nil #

Writes this complex object to an io.

require "complex"

Complex.new(42, 2).to_s # => "42.0 + 2.0i"

def to_u128(*args, **options) #

def to_u128(*args, **options, &) #

def to_u16(*args, **options) #

def to_u16(*args, **options, &) #

def to_u32(*args, **options) #

def to_u32(*args, **options, &) #

def to_u64(*args, **options) #

def to_u64(*args, **options, &) #

def to_u8(*args, **options) #

def to_u8(*args, **options, &) #

def zero? : Bool #

Returns true if the complex number is zero. This means the real and imaginary are both zero.

require "complex"

Complex.new(0, 0).zero? # => true
Complex.new(1, 0).zero? # => false
Complex.new(0, 1).zero? # => false