In Files

  • complex.rb

Class/Module Index [+]

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 124
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+bi.

 
               # File complex.rb, line 120
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 113
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 168
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 136
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 152
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 184
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
quo(other) click to toggle source 
 
               # File complex.rb, line 195
def quo(other)
  Complex(@real.quo(1), @image.quo(1)) / other
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 see Improve the docs, or visit Documenting-ruby.org.

blog comments powered by Disqus