/Crystal 0.31

# 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.

```require "complex"

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

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

complex.cr

## Constructor Detail

### def self.zero : ComplexSource

Returns the number `0` in complex form.

## Instance Method Detail

### def *(other : Number)Source

Multiplies `self` by other.

### def *(other : Complex)Source

Multiplies `self` by other.

### def +(other : Complex)Source

Adds the value of `self` to other.

### def +(other : Number)Source

Adds the value of `self` to other.

### def +Source

Returns absolute value of `self`.

### def -(other : Complex)Source

Removes the value of other from `self`.

### def -Source

Returns the opposite of `self`.

### def -(other : Number)Source

Removes the value of other from `self`.

### def /(other : Number)Source

Divides `self` by other.

### def /(other : Complex)Source

Divides `self` by other.

### def ==(other : Complex)Source

Determines whether `self` equals other or not.

### def ==(other : Number)Source

Determines whether `self` equals other or not.

### def ==(other)Source

Determines whether `self` equals other or not.

### def absSource

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 abs2Source

Returns the square of absolute value in a number form.

```require "complex"

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

### def conjSource

Returns the conjugate of `self`.

```require "complex"

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

### def expSource

Calculates the exp of `self`.

```require "complex"

Complex.new(4, 2).exp # => -22.720847417619233 + 49.645957334580565i```

### def hash(hasher)Source

See `Object#hash(hasher)`

### def imag : Float64Source

Returns the imaginary part.

### def inspect(io : IO) : NilSource

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

```require "complex"

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

### def invSource

Returns the inverse of `self`.

### def logSource

Calculates the log of `self`.

### def log10Source

Calculates the log10 of `self`.

### def log2Source

Calculates the log2 of `self`.

### def phaseSource

Returns the phase of `self`.

### def polarSource

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

```require "complex"

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

### def real : Float64Source

Returns the real part.

### def sqrtSource

`Complex#sqrt` was inspired by the following blog post of Pavel Panchekha on floating point precision.

### def to_cSource

Returns `self`.

### def to_fSource

See `#to_f64`.

### def to_f32Source

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

### def to_f64Source

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

### def to_iSource

See `#to_i32`.

### def to_i64Source

Returns the value as an `Int64` if possible (the imaginary part should be exactly zero), raises otherwise.

### def to_s(io : IO) : NilSource

Writes this complex object to an io.

```require "complex"

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

### def to_u64Source

Returns the value as an `UInt64` if possible (the imaginary part should be exactly zero), raises otherwise.