summaryrefslogtreecommitdiff
path: root/lib/complex.rb
diff options
context:
space:
mode:
authortadf <tadf@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2008-03-16 00:23:43 +0000
committertadf <tadf@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2008-03-16 00:23:43 +0000
commit6125552c27b40a8da9e162af2655feca82ac16d3 (patch)
tree8f77bc1b34603f4ce939aa4b5a77f5e8303b7df4 /lib/complex.rb
parent2694b2f937681526550b8aabf798f033fa557049 (diff)
both complex and rational are now builtin classes.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@15783 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
Diffstat (limited to 'lib/complex.rb')
-rw-r--r--lib/complex.rb620
1 files changed, 103 insertions, 517 deletions
diff --git a/lib/complex.rb b/lib/complex.rb
index 9a621c0..505b012 100644
--- a/lib/complex.rb
+++ b/lib/complex.rb
@@ -1,473 +1,90 @@
-#
-# complex.rb -
-# $Release Version: 0.5 $
-# $Revision: 1.3 $
-# by Keiju ISHITSUKA(SHL Japan Inc.)
-#
-# ----
-#
-# complex.rb implements the Complex class for complex numbers. Additionally,
-# some methods in other Numeric classes are redefined or added to allow greater
-# interoperability with Complex numbers.
-#
-# Complex numbers can be created in the following manner:
-# - <tt>Complex(a, b)</tt>
-# - <tt>Complex.polar(radius, theta)</tt>
-#
-# Additionally, note the following:
-# - <tt>Complex::I</tt> (the mathematical constant <i>i</i>)
-# - <tt>Numeric#im</tt> (e.g. <tt>5.im -> 0+5i</tt>)
-#
-# The following +Math+ module methods are redefined to handle Complex arguments.
-# They will work as normal with non-Complex arguments.
-# sqrt exp cos sin tan log log10
-# cosh sinh tanh acos asin atan atan2 acosh asinh atanh
-#
-
-
-#
-# Numeric is a built-in class on which Fixnum, Bignum, etc., are based. Here
-# some methods are added so that all number types can be treated to some extent
-# as Complex numbers.
-#
-class Numeric
- #
- # Returns a Complex number <tt>(0,<i>self</i>)</tt>.
- #
- def im
- Complex(0, self)
- end
-
- #
- # The real part of a complex number, i.e. <i>self</i>.
- #
- def real
- self
- end
-
- #
- # The imaginary part of a complex number, i.e. 0.
- #
- def image
- 0
- end
- alias imag image
-
- #
- # See Complex#arg.
- #
- def arg
- if self >= 0
- return 0
- else
- return Math::PI
- end
- end
- alias angle arg
-
- #
- # See Complex#polar.
- #
- def polar
- return abs, arg
- end
-
- #
- # See Complex#conjugate (short answer: returns <i>self</i>).
- #
- def conjugate
- self
- end
- alias conj conjugate
-end
-
-
-#
-# Creates a Complex number. +a+ and +b+ should be Numeric. The result will be
-# <tt>a+bi</tt>.
-#
-def Complex(a, b = 0)
- if b == 0 and (a.kind_of?(Complex) or defined? Complex::Unify)
- a
- elsif a.scalar? and b.scalar?
- # Don't delete for -0.0
- Complex.new(a, b)
- else
- Complex.new( a.real-b.imag, a.imag+b.real )
- end
-end
-
-#
-# The complex number class. See complex.rb for an overview.
-#
-class Complex < Numeric
- @RCS_ID='-$Id: complex.rb,v 1.3 1998/07/08 10:05:28 keiju Exp keiju $-'
-
- undef step
- undef <, <=, <=>, >, >=
- undef between?
- undef div, divmod, modulo
- undef floor, truncate, ceil, round
-
- def scalar?
- false
- end
-
- def Complex.generic?(other) # :nodoc:
- other.kind_of?(Integer) or
- other.kind_of?(Float) or
- (defined?(Rational) and other.kind_of?(Rational))
- end
-
- #
- # Creates a +Complex+ number in terms of +r+ (radius) and +theta+ (angle).
- #
- def Complex.polar(r, theta)
- Complex(r*Math.cos(theta), r*Math.sin(theta))
- end
-
- #
- # Creates a +Complex+ number <tt>a</tt>+<tt>b</tt><i>i</i>.
- #
- def Complex.new!(a, b=0)
- new(a,b)
- end
-
- 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
-
- #
- # Addition with real or complex number.
- #
- 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
-
- #
- # Subtraction with real or complex number.
- #
- 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
-
- #
- # Multiplication with real or complex number.
- #
- 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
-
- #
- # Division by real or complex number.
- #
- 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
+class Integer
- def quo(other)
- Complex(@real.quo(1), @image.quo(1)) / other
- end
-
- #
- # Raise this complex number to the given (real or complex) power.
- #
- 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
-
- #
- # Remainder after division by a real or complex number.
- #
-
-=begin
- 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
-=end
-
-#--
-# def divmod(other)
-# if other.kind_of?(Complex)
-# rdiv, rmod = @real.divmod(other.real)
-# idiv, imod = @image.divmod(other.image)
-# return Complex(rdiv, idiv), Complex(rmod, rmod)
-# elsif Complex.generic?(other)
-# Complex(@real.divmod(other), @image.divmod(other))
-# else
-# x , y = other.coerce(self)
-# x.divmod(y)
-# end
-# end
-#++
-
- #
- # Absolute value (aka modulus): distance from the zero point on the complex
- # plane.
- #
- def abs
- Math.hypot(@real, @image)
- end
-
- #
- # Square of the absolute value.
- #
- def abs2
- @real*@real + @image*@image
- end
-
- #
- # Argument (angle from (1,0) on the complex plane).
- #
- def arg
- Math.atan2!(@image, @real)
- end
- alias angle arg
-
- #
- # Returns the absolute value _and_ the argument.
- #
- def polar
- return abs, arg
- end
-
- #
- # Complex conjugate (<tt>z + z.conjugate = 2 * z.real</tt>).
- #
- def conjugate
- Complex(@real, -@image)
- end
- alias conj conjugate
-
- #
- # Test for numerical equality (<tt>a == a + 0<i>i</i></tt>).
- #
- 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
+ def gcd(other)
+ min = self.abs
+ max = other.abs
+ while min > 0
+ tmp = min
+ min = max % min
+ max = tmp
end
+ max
end
- #
- # Attempts to coerce +other+ to a Complex number.
- #
- def coerce(other)
- if Complex.generic?(other)
- return Complex.new!(other), self
+ def lcm(other)
+ if self.zero? or other.zero?
+ 0
else
- super
+ (self.div(self.gcd(other)) * other).abs
end
end
- #
- # FIXME
- #
- def denominator
- @real.denominator.lcm(@image.denominator)
- end
-
- #
- # FIXME
- #
- def numerator
- cd = denominator
- Complex(@real.numerator*(cd/@real.denominator),
- @image.numerator*(cd/@image.denominator))
- end
-
- #
- # Standard string representation of the complex number.
- #
- 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
+ def gcdlcm(other)
+ gcd = self.gcd(other)
+ if self.zero? or other.zero?
+ [gcd, 0]
else
- if defined?(Rational) and @image.kind_of?(Rational) and @image.denominator != 1
- "("+@image.to_s+")i"
- else
- @image.to_s+"i"
- end
+ [gcd, (self.div(gcd) * other).abs]
end
end
-
- #
- # Returns a hash code for the complex number.
- #
- def hash
- @real.hash ^ @image.hash
- end
-
- #
- # Returns "<tt>Complex(<i>real</i>, <i>image</i>)</tt>".
- #
- def inspect
- sprintf("Complex(%s, %s)", @real.inspect, @image.inspect)
- end
-
-
- #
- # +I+ is the imaginary number. It exists at point (0,1) on the complex plane.
- #
- I = Complex(0,1)
-
- # The real part of a complex number.
- attr_reader :real
-
- # The imaginary part of a complex number.
- attr_reader :image
- alias imag image
-
-end
-
-class Integer
-
- unless defined?(1.numerator)
- def numerator() self end
- def denominator() 1 end
-
- def gcd(other)
- min = self.abs
- max = other.abs
- while min > 0
- tmp = min
- min = max % min
- max = tmp
- end
- max
- end
-
- def lcm(other)
- if self.zero? or other.zero?
- 0
- else
- (self.div(self.gcd(other)) * other).abs
- end
- end
-
- end
end
module Math
- alias sqrt! sqrt
+
alias exp! exp
alias log! log
alias log10! log10
- alias cos! cos
+ alias sqrt! sqrt
+
alias sin! sin
+ alias cos! cos
alias tan! tan
- alias cosh! cosh
+
alias sinh! sinh
+ alias cosh! cosh
alias tanh! tanh
- alias acos! acos
+
alias asin! asin
+ alias acos! acos
alias atan! atan
alias atan2! atan2
- alias acosh! acosh
+
alias asinh! asinh
- alias atanh! atanh
+ alias acosh! acosh
+ alias atanh! atanh
+
+ def exp(z)
+ if Complex.generic?(z)
+ exp!(z)
+ else
+ Complex(exp!(z.real) * cos!(z.image),
+ exp!(z.real) * sin!(z.image))
+ end
+ end
+
+ def log(*args)
+ z, b = args
+ if Complex.generic?(z) and z >= 0 and (b.nil? or b >= 0)
+ log!(*args)
+ else
+ r, theta = z.polar
+ a = Complex(log!(r.abs), theta)
+ if b
+ a /= log(b)
+ end
+ a
+ end
+ end
+
+ def log10(z)
+ if Complex.generic?(z)
+ log10!(z)
+ else
+ log(z) / log!(10)
+ end
+ end
- # Redefined to handle a Complex argument.
def sqrt(z)
if Complex.generic?(z)
if z >= 0
@@ -481,41 +98,29 @@ module Math
else
r = z.abs
x = z.real
- Complex( sqrt!((r+x)/2), sqrt!((r-x)/2) )
+ Complex(sqrt!((r + x) / 2), sqrt!((r - x) / 2))
end
end
end
-
- # Redefined to handle a Complex argument.
- def exp(z)
+
+ def sin(z)
if Complex.generic?(z)
- exp!(z)
+ sin!(z)
else
- Complex(exp!(z.real) * cos!(z.image), exp!(z.real) * sin!(z.image))
+ Complex(sin!(z.real) * cosh!(z.image),
+ cos!(z.real) * sinh!(z.image))
end
end
-
- # Redefined to handle a Complex argument.
+
def cos(z)
if Complex.generic?(z)
cos!(z)
else
- Complex(cos!(z.real)*cosh!(z.image),
- -sin!(z.real)*sinh!(z.image))
+ Complex(cos!(z.real) * cosh!(z.image),
+ -sin!(z.real) * sinh!(z.image))
end
end
-
- # Redefined to handle a Complex argument.
- def sin(z)
- if Complex.generic?(z)
- sin!(z)
- else
- Complex(sin!(z.real)*cosh!(z.image),
- cos!(z.real)*sinh!(z.image))
- end
- end
-
- # Redefined to handle a Complex argument.
+
def tan(z)
if Complex.generic?(z)
tan!(z)
@@ -528,7 +133,8 @@ module Math
if Complex.generic?(z)
sinh!(z)
else
- Complex( sinh!(z.real)*cos!(z.image), cosh!(z.real)*sin!(z.image) )
+ Complex(sinh!(z.real) * cos!(z.image),
+ cosh!(z.real) * sin!(z.image))
end
end
@@ -536,7 +142,8 @@ module Math
if Complex.generic?(z)
cosh!(z)
else
- Complex( cosh!(z.real)*cos!(z.image), sinh!(z.real)*sin!(z.image) )
+ Complex(cosh!(z.real) * cos!(z.image),
+ sinh!(z.real) * sin!(z.image))
end
end
@@ -544,42 +151,23 @@ module Math
if Complex.generic?(z)
tanh!(z)
else
- sinh(z)/cosh(z)
- end
- end
-
- # Redefined to handle a Complex argument.
- def log(z)
- if Complex.generic?(z) and z >= 0
- log!(z)
- else
- r, theta = z.polar
- Complex(log!(r.abs), theta)
- end
- end
-
- # Redefined to handle a Complex argument.
- def log10(z)
- if Complex.generic?(z)
- log10!(z)
- else
- log(z)/log!(10)
+ sinh(z) / cosh(z)
end
end
- def acos(z)
+ def asin(z)
if Complex.generic?(z) and z >= -1 and z <= 1
- acos!(z)
+ asin!(z)
else
- -1.0.im * log( z + 1.0.im * sqrt(1.0-z*z) )
+ -1.0.im * log(1.0.im * z + sqrt(1.0 - z * z))
end
end
- def asin(z)
+ def acos(z)
if Complex.generic?(z) and z >= -1 and z <= 1
- asin!(z)
+ acos!(z)
else
- -1.0.im * log( 1.0.im * z + sqrt(1.0-z*z) )
+ -1.0.im * log(z + 1.0.im * sqrt(1.0 - z * z))
end
end
@@ -587,7 +175,7 @@ module Math
if Complex.generic?(z)
atan!(z)
else
- 1.0.im * log( (1.0.im+z) / (1.0.im-z) ) / 2.0
+ 1.0.im * log((1.0.im + z) / (1.0.im - z)) / 2.0
end
end
@@ -595,7 +183,7 @@ module Math
if Complex.generic?(y) and Complex.generic?(x)
atan2!(y,x)
else
- -1.0.im * log( (x+1.0.im*y) / sqrt(x*x+y*y) )
+ -1.0.im * log((x + 1.0.im * y) / sqrt(x * x + y * y))
end
end
@@ -603,7 +191,7 @@ module Math
if Complex.generic?(z) and z >= 1
acosh!(z)
else
- log( z + sqrt(z*z-1.0) )
+ log(z + sqrt(z * z - 1.0))
end
end
@@ -611,7 +199,7 @@ module Math
if Complex.generic?(z)
asinh!(z)
else
- log( z + sqrt(1.0+z*z) )
+ log(z + sqrt(1.0 + z * z))
end
end
@@ -619,49 +207,47 @@ module Math
if Complex.generic?(z) and z >= -1 and z <= 1
atanh!(z)
else
- log( (1.0+z) / (1.0-z) ) / 2.0
+ log((1.0 + z) / (1.0 - z)) / 2.0
end
end
- module_function :sqrt!
- module_function :sqrt
module_function :exp!
module_function :exp
module_function :log!
module_function :log
module_function :log10!
module_function :log10
- module_function :cosh!
- module_function :cosh
- module_function :cos!
- module_function :cos
- module_function :sinh!
- module_function :sinh
+ module_function :sqrt!
+ module_function :sqrt
+
module_function :sin!
module_function :sin
+ module_function :cos!
+ module_function :cos
module_function :tan!
module_function :tan
+
+ module_function :sinh!
+ module_function :sinh
+ module_function :cosh!
+ module_function :cosh
module_function :tanh!
module_function :tanh
- module_function :acos!
- module_function :acos
+
module_function :asin!
module_function :asin
+ module_function :acos!
+ module_function :acos
module_function :atan!
module_function :atan
module_function :atan2!
module_function :atan2
- module_function :acosh!
- module_function :acosh
+
module_function :asinh!
module_function :asinh
+ module_function :acosh!
+ module_function :acosh
module_function :atanh!
module_function :atanh
-
-end
-# Documentation comments:
-# - source: original (researched from pickaxe)
-# - a couple of fixme's
-# - RDoc output for Bignum etc. is a bit short, with nothing but an
-# (undocumented) alias. No big deal.
+end