bigcomplex 0.1

data/lib/bigcomplex.rb

@@ -0,0 +1,188 @@
+# @author {https://github.com/karatedog karatedog}
+class BigComplex
+  require 'bigdecimal'
+  @real, @imag = BigDecimal("0.0"), BigDecimal("0.0")
+
+  # @return [Boolean]
+  # @param [Fixnum, Bignum, String, Float, BigDecimal]
+  # Checks if _class_type_ is among the acceptable class types for creating a BigComplex object
+  def acceptable_class_type?(class_type)
+    return [Fixnum, Bignum, String, Float, BigDecimal].include?(class_type)
+  end
+  # for lazy typers
+  alias :act? :acceptable_class_type?
+
+  # @return [BigComplex]
+  # @param [Fixnum, Bignum, String, Float, BigDecimal, BigComplex] real_part,imag_part
+  # @raise TypeError If input is not one of the acceptable class types (acceptable_class_type?(type) == false)
+  # Creates a new BigComplex object.
+  def initialize(real_part=BigDecimal("0.0"), imag_part=BigDecimal("0.0"))
+
+    # If input is BigComplex, split the object to parts and return them as new objects
+    if real_part.class == BigComplex then
+      real_part = BigDecimal(real_part.real)
+    end
+    if imag_part.class == BigComplex then
+      imag_part = BigDecimal(imag_part.imag)
+    end
+
+    if real_part.class == Complex then
+      real_part = BigDecimal(real_part.real)
+    end
+    if imag_part.class == Complex then
+      imag_part = BigDecimal(imag_part.imag)
+    end
+
+    # @return [BigDecimal]
+    # @param [Fixnum, Bignum, String, Float, BigDecimal]
+    # Converts values to BigDecimal to use for creating BigComplex objects. If input is a String and starts with letter, the converted value will be 0.
+    def convert_values(val)
+      case val
+        when Fixnum, Bignum, Float then BigDecimal(val.to_s) # Ruby 1.9.3< does not accept Integer, but 1.9.3+ does
+        when String then BigDecimal(val)
+        when BigDecimal then val
+        else return nil
+      end
+    end
+    raise(TypeError, "Not a Fixnum/Bignum, String, Float or BigDecimal!") unless acceptable_class_type?(real_part.class) and acceptable_class_type?(imag_part.class)
+    self.real = real_part
+    self.imag = imag_part
+  end
+
+  # @param [Fixnum, String, Float, BigDecimal, BigComplex]
+  # @return [BigDecimal]
+  # Returns the _real_ part of _self_
+  def real; @real; end
+
+  # @param [Fixnum, String, Float, BigDecimal, BigComplex] val
+  # @return [BigDecimal]
+  # Modifies _self.real_
+  # @raise TypeError
+  def real=(val); return @real = convert_values(val); end
+
+  # @return [BigDecimal]
+  def imag; return @imag; end
+
+  # @return [BigDecimal] Modifies _self.imaginary_
+  # @raise TypeError
+  # @param [Fixnum, String, Float, BigDecimal, BigComplex] val
+  def imag=(val); return @imag = convert_values(val); end
+
+  # @return [BigDecimal] the _imaginary_ part of _self_
+  alias :imaginary :imag
+
+  # (see #imag=)
+  # Alias for imag_
+  alias :imaginary= :imag=
+
+  # @return [Boolean]
+  # @param [Fixnum, String, Float, BigDecimal, BigComplex] other
+  # Returns _true_ if _other_.real == _self_.real and _other_.imag == _self_.imag (no type checking).
+  def ==(other)
+    self.real == other.real and self.imag == other.imag
+  end
+
+  # @return [BigComplex]
+  # @param [Fixnum, String, Float, BigDecimal, BigComplex] other The multiplicand
+  # Multiplies _self_ with _other_ and returns a new object.
+  def *(other)
+    case other
+      when Fixnum, Float, Bignum, BigDecimal
+        return BigComplex.new(self.real * other, self.imag * other)
+      when BigComplex
+        return BigComplex.new((self.real*other.real - self.imag*other.imag), (self.real*other.imag + self.imag*other.real))
+      else raise TypeError, "Not a Fixnum/Bignum, Float, BigDecimal or BigComplex!"
+    end
+  end
+
+  # @return [BigComplex]
+  # @param [Fixnum, String, Float, BigDecimal, BigComplex] other The addend
+  # Adds _other_ to _self_ and returns a new object.
+  def +(other)
+    # format the object
+    # @todo Check if input is String and if it can be converted. Automatic coerce somewhere?
+    case other
+      when Fixnum, Float, Bignum, BigDecimal
+        return BigComplex.new(self.real + other, self.imag)
+      when BigComplex
+        return BigComplex.new(self.real + other.real, self.real + other.imag)
+      else raise TypeError, "Not a Fixnum/Bignum, Float, BigDecimal or BigComplex!"
+    end
+  end
+
+  # @return [BigComplex]
+  # @param [Fixnum, String, Float, BigDecimal, BigComplex] other The subtrahend
+  # Subtracts _other_ from _self_ and returns a new object.
+  def -(other)
+    case other
+      when Fixnum, Float, Bignum, BigDecimal
+        return BigComplex.new(self.real - other, self.imag)
+      when BigComplex
+        return BigComplex.new(self.real - other.real, self.imag - other.imag)
+    end
+  end
+
+  # @return [BigComplex]
+  # @param [Fixnum, String, Float, BigDecimal, BigComplex] other The exponent
+  # Raises _self_ to the power of _other_ and returns a new object. Works well for huge exponents.
+  def **(other)
+    case other
+      when Fixnum, Bignum, BigDecimal
+        if other == 0 then
+          return BigComplex.new(1.0, 0.0)
+          fail "This line should not be reached" # being over-paranoid here
+        end
+
+        if other == 1 then
+          return self
+          fail "This line should not be reached"
+        end
+
+        if other < 0 then
+          return BigComplex.new
+          fail "This line should not be reached"
+        end
+
+        if (other.class == BigDecimal) && (other.to_i != other) then
+          raise TypeError, 'BigDecimal with a Rational value'
+        else
+          other = other.to_i
+        end
+
+        binary_repr_of_exponent = other.to_s(2).reverse.split('').map { |x| x.to_i }
+        base = self
+        result = binary_repr_of_exponent.reduce(BigComplex.new(1,0)) do | memo, value |
+          memo *= (value == 1 ? base : 1)
+          base = base * base
+          memo
+        end
+        return result # explicit return, just for visibility
+      else raise TypeError, 'Not a Fixnum, Bignum or BigDecimal for exponent'
+    end
+  end
+
+  # Returns the conjugate of _self_ as new object
+  # @return [BigComplex]
+  def conjugate
+    BigComplex.new(self.real, -self.imag)
+  end
+
+  # Returns the magnitude of _self_. It can be calculation heavy for large numbers
+  # @return [BigDecimal]
+  def magnitude
+    (self.real**2 + self.imag**2).sqrt(12) # uhh-ohh, need to ditch sqrt as of now, it is imprecise as well.
+  end
+
+  # @return [Complex, BigComplex]
+  # Converts _self_ to Complex if it fits Complex' boundaries. The method _will_ _not_ require the Complex library and if no Complex class is available, returns _self_. Some rubies contain Complex class by default, some not (ie: MRI 1.8.7)
+  def to_c
+    begin
+      dmy = Complex(1,2) # dummy Complex value
+    rescue NoMethodError
+      return self # Complex class is not available
+    rescue
+      return self # some other thing hit the fan
+    end
+    return Complex(self.real.to_i, self.imag.to_i) # there is no type/size check yet. Converting with to_i loses fractional part but keeps magnitude.
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: bigcomplex
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Földes László
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-30 00:00:00.000000000 Z
+dependencies: []
+description: A replacement of the standard Complex class for better precision for
+  certain operations (addition, subtraction, multiplication, power)
+email: foldes.laszlo2@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bigcomplex.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: A replacement of the standard Complex class for better precision for certain
+  operations
+test_files: []
+has_rdoc: