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

Defined in:

complex.cr

Constructors

Instance Method Summary

Instance methods inherited from struct Struct

==(other) : Bool ==, hash(hasher) hash, inspect(io : IO) : Nil inspect, pretty_print(pp) : Nil pretty_print, to_s(io : IO) : Nil to_s

Instance methods inherited from struct Value

==(other : JSON::Any)
==(other : YAML::Any)
==(other)
==
, dup dup

Instance methods inherited from class Object

! : Bool !, !=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other)
===
, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash
hash
, in?(collection : Object) : Bool
in?(*values : Object) : Bool
in?
, inspect(io : IO) : Nil
inspect : String
inspect
, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
not_nil!
not_nil!
, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String
to_json
, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil
to_pretty_json
, to_s(io : IO) : Nil
to_s : String
to_s
, to_yaml(io : IO) : Nil
to_yaml : String
to_yaml
, try(&) try, unsafe_as(type : T.class) forall T unsafe_as

Class methods inherited from class Object

from_json(string_or_io, root : String)
from_json(string_or_io)
from_json
, from_yaml(string_or_io : String | IO) from_yaml

Constructor Detail

def self.additive_identity : self #

[View source]
def self.multiplicative_identity : self #

[View source]
def self.new(real : Number, imag : Number = 0) #

[View source]
def self.new(c : Complex) #

[View source]
def self.zero : Complex #

Returns the number 0 in complex form.


[View source]

Instance Method Detail

def *(other : Complex) : Complex #

Multiplies self by other.


[View source]
def *(other : Number) : Complex #

Multiplies self by other.


[View source]
def +(other : Complex) : Complex #

Adds the value of self to other.


[View source]
def +(other : Number) : Complex #

Adds the value of self to other.


[View source]
def + : Complex #

Returns self.


[View source]
def -(other : Complex) : Complex #

Removes the value of other from self.


[View source]
def -(other : Number) : Complex #

Removes the value of other from self.


[View source]
def - : Complex #

Returns the opposite of self.


[View source]
def /(other : Complex) : Complex #

Divides self by other.


[View source]
def /(other : Number) : Complex #

Divides self by other.


[View source]
def ==(other : Complex) #

Determines whether self equals other or not.


[View source]
def ==(other : Number) #

Determines whether self equals other or not.


[View source]
def ==(other) #

Determines whether self equals other or not.


[View source]
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

[View source]
def abs2 : Float64 #

Returns the square of absolute value in a number form.

require "complex"

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

[View source]
def clone #

[View source]
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

[View source]
def hash(hasher) #

[View source]
def imag : Float64 #

Returns the imaginary part.


[View source]
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)"

[View source]
def inv : Complex #

Returns the inverse of self.


[View source]
def phase : Float64 #

Returns the phase of self.


[View source]
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}

[View source]
def real : Float64 #

Returns the real part.


[View source]
def round(digits = 0) : Complex #

Rounds to the nearest digits.


[View source]
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)

[View source]
def to_c #

Returns self.


[View source]
def to_f #

See #to_f64.


[View source]
def to_f32(*args, **options) #

[View source]
def to_f32(*args, **options, &) #

[View source]
def to_f64 : Float64 #

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


[View source]
def to_i #

See #to_i32.


[View source]
def to_i128(*args, **options) #

[View source]
def to_i128(*args, **options, &) #

[View source]
def to_i16(*args, **options) #

[View source]
def to_i16(*args, **options, &) #

[View source]
def to_i32(*args, **options) #

[View source]
def to_i32(*args, **options, &) #

[View source]
def to_i64(*args, **options) #

[View source]
def to_i64(*args, **options, &) #

[View source]
def to_i8(*args, **options) #

[View source]
def to_i8(*args, **options, &) #

[View source]
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"

[View source]
def to_u128(*args, **options) #

[View source]
def to_u128(*args, **options, &) #

[View source]
def to_u16(*args, **options) #

[View source]
def to_u16(*args, **options, &) #

[View source]
def to_u32(*args, **options) #

[View source]
def to_u32(*args, **options, &) #

[View source]
def to_u64(*args, **options) #

[View source]
def to_u64(*args, **options, &) #

[View source]
def to_u8(*args, **options) #

[View source]
def to_u8(*args, **options, &) #

[View source]
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

[View source]