• complex.rb

Quicksearch

# Complex

The complex number class. See complex.rb for an overview.

### Constants

I

`I` is the imaginary number. It exists at point (0,1) on the complex plane.

### Attributes

imag[R]

The imaginary part of a complex number.

image[R]

The imaginary part of a complex number.

real[R]

The real part of a complex number.

### Public Class Methods

new(a, b) click to toggle source
```
# File complex.rb, line 128
def initialize(a, b)
raise TypeError, "non numeric 1st arg `#{a.inspect}'" if !a.kind_of? Numeric
raise TypeError, "`#{a.inspect}' for 1st arg" if a.kind_of? Complex
raise TypeError, "non numeric 2nd arg `#{b.inspect}'" if !b.kind_of? Numeric
raise TypeError, "`#{b.inspect}' for 2nd arg" if b.kind_of? Complex
@real = a
@image = b
end
```
new!(a, b=0) click to toggle source

Creates a `Complex` number `a`+`b`i.

```
# File complex.rb, line 124
def Complex.new!(a, b=0)
new(a,b)
end
```
polar(r, theta) click to toggle source

Creates a `Complex` number in terms of `r` (radius) and `theta` (angle).

```
# File complex.rb, line 117
def Complex.polar(r, theta)
Complex(r*Math.cos(theta), r*Math.sin(theta))
end
```

### Public Instance Methods

%(other) click to toggle source

Remainder after division by a real or complex number.

```
# File complex.rb, line 247
def % (other)
if other.kind_of?(Complex)
Complex(@real % other.real, @image % other.image)
elsif Complex.generic?(other)
Complex(@real % other, @image % other)
else
x , y = other.coerce(self)
x % y
end
end
```
*(other) click to toggle source

Multiplication with real or complex number.

```
# File complex.rb, line 172
def * (other)
if other.kind_of?(Complex)
re = @real*other.real - @image*other.image
im = @real*other.image + @image*other.real
Complex(re, im)
elsif Complex.generic?(other)
Complex(@real * other, @image * other)
else
x , y = other.coerce(self)
x * y
end
end
```
**(other) click to toggle source

Raise this complex number to the given (real or complex) power.

```
# File complex.rb, line 202
def ** (other)
if other == 0
return Complex(1)
end
if other.kind_of?(Complex)
r, theta = polar
ore = other.real
oim = other.image
nr = Math.exp!(ore*Math.log!(r) - oim * theta)
ntheta = theta*ore + oim*Math.log!(r)
Complex.polar(nr, ntheta)
elsif other.kind_of?(Integer)
if other > 0
x = self
z = x
n = other - 1
while n != 0
while (div, mod = n.divmod(2)
mod == 0)
x = Complex(x.real*x.real - x.image*x.image, 2*x.real*x.image)
n = div
end
z *= x
n -= 1
end
z
else
if defined? Rational
(Rational(1) / self) ** -other
else
self ** Float(other)
end
end
elsif Complex.generic?(other)
r, theta = polar
Complex.polar(r**other, theta*other)
else
x, y = other.coerce(self)
x**y
end
end
```
+(other) click to toggle source

Addition with real or complex number.

```
# File complex.rb, line 140
def + (other)
if other.kind_of?(Complex)
re = @real + other.real
im = @image + other.image
Complex(re, im)
elsif Complex.generic?(other)
Complex(@real + other, @image)
else
x , y = other.coerce(self)
x + y
end
end
```
-(other) click to toggle source

Subtraction with real or complex number.

```
# File complex.rb, line 156
def - (other)
if other.kind_of?(Complex)
re = @real - other.real
im = @image - other.image
Complex(re, im)
elsif Complex.generic?(other)
Complex(@real - other, @image)
else
x , y = other.coerce(self)
x - y
end
end
```
/(other) click to toggle source

Division by real or complex number.

```
# File complex.rb, line 188
def / (other)
if other.kind_of?(Complex)
self*other.conjugate/other.abs2
elsif Complex.generic?(other)
Complex(@real/other, @image/other)
else
x, y = other.coerce(self)
x/y
end
end
```
<=>(other) click to toggle source

Compares the absolute values of the two numbers.

```
# File complex.rb, line 314
def <=> (other)
self.abs <=> other.abs
end
```
==(other) click to toggle source

Test for numerical equality (`a == a + 0i`).

```
# File complex.rb, line 321
def == (other)
if other.kind_of?(Complex)
@real == other.real and @image == other.image
elsif Complex.generic?(other)
@real == other and @image == 0
else
other == self
end
end
```
abs() click to toggle source

Absolute value (aka modulus): distance from the zero point on the complex plane.

```
# File complex.rb, line 277
def abs
Math.hypot(@real, @image)
end
```
abs2() click to toggle source

Square of the absolute value.

```
# File complex.rb, line 284
def abs2
@real*@real + @image*@image
end
```
angle() click to toggle source
Alias for: arg
arg() click to toggle source

Argument (angle from (1,0) on the complex plane).

```
# File complex.rb, line 291
def arg
Math.atan2!(@image, @real)
end
```
Also aliased as: angle
coerce(other) click to toggle source

Attempts to coerce `other` to a Complex number.

```
# File complex.rb, line 334
def coerce(other)
if Complex.generic?(other)
return Complex.new!(other), self
else
super
end
end
```
conj() click to toggle source
Alias for: conjugate
conjugate() click to toggle source

Complex conjugate (```z + z.conjugate = 2 * z.real```).

```
# File complex.rb, line 306
def conjugate
Complex(@real, -@image)
end
```
Also aliased as: conj
denominator() click to toggle source

FIXME

```
# File complex.rb, line 345
def denominator
@real.denominator.lcm(@image.denominator)
end
```
hash() click to toggle source

Returns a hash code for the complex number.

```
# File complex.rb, line 388
def hash
@real.hash ^ @image.hash
end
```
inspect() click to toggle source

Returns “`Complex(real, image)`”.

```
# File complex.rb, line 395
def inspect
sprintf("Complex(%s, %s)", @real.inspect, @image.inspect)
end
```
numerator() click to toggle source

FIXME

```
# File complex.rb, line 352
def numerator
cd = denominator
Complex(@real.numerator*(cd/@real.denominator),
@image.numerator*(cd/@image.denominator))
end
```
polar() click to toggle source

Returns the absolute value and the argument.

```
# File complex.rb, line 299
def polar
return abs, arg
end
```
to_s() click to toggle source

Standard string representation of the complex number.

```
# File complex.rb, line 361
def to_s
if @real != 0
if defined?(Rational) and @image.kind_of?(Rational) and @image.denominator != 1
if @image >= 0
@real.to_s+"+("+@image.to_s+")i"
else
@real.to_s+"-("+(-@image).to_s+")i"
end
else
if @image >= 0
@real.to_s+"+"+@image.to_s+"i"
else
@real.to_s+"-"+(-@image).to_s+"i"
end
end
else
if defined?(Rational) and @image.kind_of?(Rational) and @image.denominator != 1
"("+@image.to_s+")i"
else
@image.to_s+"i"
end
end
end
```

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.