ruby-calc 0.1.0

data/lib/calc.rb

@@ -0,0 +1,214 @@
+require "calc/version"
+require "calc/calc"
+require "calc/numeric"
+require "calc/q"
+require "calc/c"
+
+module Calc
+  # builtins implemented as instance methods on Calc::Q or Calc::C
+  BUILTINS1 = %i(
+    abs acos acosh acot acoth acsc acsch agd appr arg asec asech asin asinh
+    atan atan2 atanh bernoulli bit bround btrunc catalan ceil cfappr cfsim char
+    cmp comb conj cos cosh cot coth csc csch den digit digits estr euler exp
+    fact factor fcnt fib floor frac frem gcd gcdrem gd highbit hypot ilog
+    ilog10 ilog2 im int inverse iroot iseven isimag isint ismult isodd isprime
+    isqrt isreal isrel issq jacobi lcm lcmfact lfactor ln log lowbit ltol meq
+    minv mmin mne mod near nextcand nextprime norm num perm pfact pix places
+    pmod popcnt power prevcand prevprime ptest quo quomod re root round scale
+    sec sech sgn sin sinh sqrt tan tanh trunc xor
+  ).freeze
+
+  # builtins implemented as module methods on Calc
+  BUILTINS2 = %i(
+    avg config freebernoulli freeeuler hean hnrmod max min pi polar ssq sum
+    version
+  ).freeze
+
+  ALL_BUILTINS = BUILTINS1 + BUILTINS2
+
+  # module versions of instance builtins; implemented by turning the first
+  # argument into the right class and calling the instance method
+  class << self
+    BUILTINS1.each do |f|
+      define_method f do |*args|
+        x = args.shift
+        if x.is_a?(Calc::Q) || x.is_a?(Calc::C)
+          x.__send__(f, *args)
+        elsif x.is_a?(Complex)
+          Calc::C(x).__send__(f, *args)
+        else
+          Calc::Q(x).__send__(f, *args)
+        end
+      end
+    end
+  end
+
+  def self.Q(*args) # rubocop:disable Style/MethodName
+    Q.new(*args)
+  end
+
+  def self.C(*args) # rubocop:disable Style/MethodName
+    C.new(*args)
+  end
+
+  # Average (arithmetic mean)
+  #
+  # Any number of numeric arguments can be provided.  Returns the sum of all
+  # values divided by the number of values.  If no values are provided, returns
+  # nil.
+  #
+  # @return [Calc::Q,Calc::C]
+  # @example
+  #   Calc.avg(1, 2, 3)          #=> Calc::Q(2)
+  #   Calc.avg(4, Calc::C(2, 2)) #=> Calc::C(3+1i)
+  def self.avg(*args)
+    args.flatten!
+    return nil if args.none?
+    args.map { |n| to_calc_x(n) }.inject(:+) / args.size
+  end
+
+  # Harmonic mean
+  #
+  # Returns zero if any of the provded values is zero.  Returns nil if no
+  # values are provided.  Otherwise returns the harmonic mean of the given
+  # values.
+  #
+  # @return [Calc::Q,Calc::C]
+  #   Calc.hmean(1, 2, 4)          #=> Calc::Q(12/7)
+  #   Calc.hmean(2, Complex(0, 2)) #=> Calc::C(2+2i)
+  def self.hmean(*args)
+    args.flatten!
+    return nil if args.none?
+    return Q::ZERO if args.detect(&:zero?)
+    args.size / args.map { |n| to_calc_x(n) }.map(&:inverse).inject(:+)
+  end
+
+  # Maximum from provided values.
+  #
+  # Each argument must be convertable to Calc::Q.  If no values, returns nil.
+  #
+  # @return [Calc::Q]
+  # @example
+  #  Calc.max(5, 3, 7, 2, 9) #=> Calc::Q(9)
+  def self.max(*args)
+    args.compact.map { |n| Calc::Q(n) }.max
+  end
+
+  # Minimum from provided values
+  #
+  # Each argument must be convertable to Calc::Q.  If no values, returns nil.
+  #
+  # @return [Calc::Q]
+  # @example
+  #  Calc.min(5, 3, 7, 2, 9) #=> Calc::Q(2)
+  def self.min(*args)
+    args.compact.map { |n| Calc::Q(n) }.min
+  end
+
+  # Evaluate a polynomial
+  #
+  # First case:
+  #   poly(a_0, a_1, ..., a_n, x)
+  # returns:
+  #   a_n + (a_n-1 + ... + (a_1 + a_0 * x) * x ..) * x
+  # In particular:
+  #   poly(a, x) -> a
+  #   poly(a, b, x) -> b + a * x
+  #   poly(a, b, c, x) -> c + (b + a * x) * x
+  #                    or a*x**2 + b*x + c
+  #
+  # In the second case, the first parameter is an array of coefficients, ie:
+  #   poly([a_0, a_1, ... a_n], x)
+  # returns:
+  #   a_0 + (a_n-1 + (a_2 + ... a_n * x) * x)
+  # Note that the order of coeffecients is reverse of the first case.
+  #
+  # If one or more elements of clist is another array, and there is more than
+  # one argument (x, y, ...) the coefficient corresponding to such an element
+  # is the value of the poly for that list and the next argument in x, y, ...
+  # For example:
+  #   poly([[a, b, c], [d, e], f], x, y)
+  # Returns:
+  #   (a + b * y + c * y^2) + (d + e * y) * x + f * x^2
+  #
+  # For more explanation and examples on how the nested arrays works, see
+  # "help poly" bearning in mind that a calc list is equivament to a ruby
+  # array.
+  #
+  # @return [Calc::Numeric]
+  # @example
+  #   # 2 * 7**2 + 3 * 7 + 5
+  #   Calc.poly(2, 3, 5, 7) #=> Calc::Q(124)
+  def self.poly(*args)
+    raise ArgumentError, "Need at least one argument for poly" if args.none?
+    if args.first.respond_to?(:each)
+      # second case
+      clist = args.shift
+      evalpoly(clist, args.flatten, 0)
+    else
+      # first case
+      x = to_calc_x(args.pop)
+      return x if args.none?
+      args.reverse.each_with_index.map { |coeff, i| to_calc_x(coeff) * x**i }.reduce(:+)
+    end
+  end
+
+  # evalpoly and evp are modelled on functions of the same name in libcalc,
+  # which we can't use because they use VALUE and LIST types.  because the
+  # libcalc versions use doubly linked lists, the ruby versions has to pass
+  # around an index to the coeffecients array instead.
+  def self.evalpoly(clist, lp, x)
+    return nil if clist.none?
+    if lp[x].nil?
+      if clist.first.respond_to?(:each)
+        evalpoly(clist.first, lp, x + 1)
+      else
+        to_calc_x(clist.first)
+      end
+    else
+      evp(clist, lp, x)
+    end
+  end
+  private_class_method :evalpoly
+
+  def self.evp(clist, lp, x)
+    clist.reverse.reduce(Q::ZERO) do |vres, v|
+      (vres * lp[x]) + if v.respond_to?(:each)
+                         evalpoly(v, lp, x + 1) || Q::ZERO
+                       else
+                         to_calc_x(v)
+                       end
+    end
+  end
+  private_class_method :evp
+
+  # Returns the sum of squares.
+  #
+  # Nil values are ignored.  If any argument is am array, it contributes
+  # the sum of squares of its contents recursively.
+  #
+  # @return [Calc::C,Calc::Q]
+  # @raise [ArgumentError] if any argument can't be converted to a Calc class
+  # @example
+  #  Calc.ssq(1, 2, 3)       #=> Calc::Q(14)
+  #  Calc.ssq(1+2i, 3-4i, 5) #=> Calc::C(15-20i)
+  def self.ssq(*args)
+    args.flatten.map { |term| to_calc_x(term)**2 }.inject(:+)
+  end
+
+  def self.sum(*args)
+    args.flatten.map { |t| to_calc_x(t) }.compact.inject(:+)
+  end
+
+  # returns a Calc::Q or Calc::C object, converting if necessary
+  def self.to_calc_x(n)
+    if n.is_a?(Calc::Q) || n.is_a?(Calc::C)
+      n
+    elsif n.is_a?(Complex)
+      Calc::C(n)
+    else
+      Calc::Q(n)
+    end
+  end
+  private_class_method :to_calc_x
+end

data/lib/calc/c.rb

@@ -0,0 +1,371 @@
+module Calc
+  class C
+    # Returns the absolute value of a complex number.  For purely real or
+    # purely imaginary values, returns the absolute value of the non-zero
+    # part.  Otherwise returns the absolute part of its complex form within
+    # the specified accuracy.
+    #
+    # @param eps [Calc::Q] (optional) calculation accuracy
+    # @return [Calc::Q]
+    # @example
+    #   Calc::C(-1).abs          #=> Calc::Q(1)
+    #   Calc::C(3,-4).abs        #=> Calc::Q(5)
+    #   Calc::C(4,5).abs("1e-5") #=> Calc::Q(6.40312)
+    def abs(*args)
+      # see absvalue() in value.c
+      re.hypot(im, *args)
+    end
+    alias magnitude abs
+
+    # Approximate numbers of multiples of a specific number.
+    #
+    # c.appr(y,z) is equivalent to c.re.appr(y,z) + c.im.appr(y,z) * Calc::C(0,1)
+    def appr(*args)
+      q1 = re.appr(*args)
+      q2 = im.appr(*args)
+      if q2.zero?
+        q1
+      else
+        C.new(q1, q2)
+      end
+    end
+
+    # Returns the argument (the angle or phase) of a complex number in radians.
+    #
+    # @param eps [Calc::Q] (optional) calculation accuracy
+    # @return [Calc::Q]
+    # @example
+    #  Calc::C(1,0).arg  #=> 0
+    #  Calc::C(-1,0).arg #=> -pi
+    #  Calc::C(1,1).arg  #=> Calc::Q(0.78539816339744830962)
+    def arg(*args)
+      # see f_arg() in func.c
+      im.atan2(re, *args)
+    end
+    alias angle arg
+    alias phase arg
+
+    # Round real and imaginary parts to the specified number of binary digits
+    #
+    # @return [Calc::C,Calc::Q]
+    # @param places [Integer] number of binary places to round to (default 0)
+    # @param rns [Integer] rounding flags (default Calc.config(:round))
+    # @example
+    #   Calc::C("7/32","-7/32").bround(3) #=> Calc::C(0.25-0.25i)
+    def bround(*args)
+      q1 = re.bround(*args)
+      q2 = im.bround(*args)
+      if q2.zero?
+        q1
+      else
+        C.new(q1, q2)
+      end
+    end
+
+    # Complex conjugate
+    #
+    # Returns the complex conjugate of self (same real part and same imaginary
+    # part but with opposite sign)
+    #
+    # @return [Calc::C]
+    # @example
+    #  Calc::C(3,3).conj #=> Calc::C(3-3i)
+    def conj
+      C.new(re, -im)
+    end
+    alias conjugate conj
+
+    # Trigonometric cotangent
+    #
+    # @param eps [Calc::Q] (optional) calculation accuracy
+    # @return [Calc::C]
+    # @example
+    #  Calc::C(2,3).cot #=> Calc::C(~-0.00373971037633695666-~0.99675779656935831046i)
+    def cot(*args)
+      # see f_cot() in func.c
+      cos(*args) / sin(*args)
+    end
+
+    # Hyperbolic cotangent
+    #
+    # @param eps [Calc::Q] (optional) calculation accuracy
+    # @return [Calc::C]
+    # @example
+    #  Calc::C(2,3).coth #=> Calc::C(~1.03574663776499539611+~0.01060478347033710175i)
+    def coth(*args)
+      # see f_coth() in func.c
+      cosh(*args) / sinh(*args)
+    end
+
+    # Trigonometric cosecant
+    #
+    # @param eps [Calc::Q] (optional) calculation accuracy
+    # @return [Calc::C]
+    # @example
+    #  Calc::C(2,3).csc #=> Calc::C(~0.09047320975320743981+~0.04120098628857412646i)
+    def csc(*args)
+      # see f_csc() in func.c
+      sin(*args).inverse
+    end
+
+    # Hyperbolic cosecant
+    #
+    # @param eps [Calc::Q] (optional) calculation accuracy
+    # @return [Calc::C]
+    # @example
+    #  Calc::C(2,3).csch #=> Calc::C(~-0.27254866146294019951-~0.04030057885689152187i)
+    def csch(*args)
+      # see f_csch() in func.c
+      sinh(*args).inverse
+    end
+
+    # Denominator of a complex number
+    #
+    # The denominator is the lowest common denominator of the real and
+    # imaginary parts
+    #
+    # @return [Calc::Q]
+    # @example
+    #   Calc::C("1/2", "2/3").denominator #=> Calc::Q(6)
+    def denominator
+      re.den.lcm(im.den)
+    end
+
+    # Returns a string which if evaluated creates a new object with the original value
+    #
+    # @return [String]
+    # @example
+    #   Calc::C(0.5,-2).estr #=> "Calc::C(Calc::Q(1,2),-2)"
+    def estr
+      s = self.class.name
+      s << "("
+      s << (re.int? ? re.to_s : re.estr)
+      s << "," + (im.int? ? im.to_s : im.estr) unless im.zero?
+      s << ")"
+      s
+    end
+
+    # Returns true if self has integer real part and zero imaginary part
+    #
+    # @return [Boolean]
+    # @example
+    #   Calc::C(1,1).int?  #=> false
+    #   Calc::C(1,0).int?  #=> true
+    def int?
+      im.zero? ? re.int? : false
+    end
+
+    alias imaginary im
+
+    def iseven
+      even? ? Q::ONE : Q::ZERO
+    end
+
+    # Returns 1 if the number is imaginary (zero real part and non-zero
+    # imaginary part) otherwise returns 0.  See also [imag?].
+    #
+    # @return [Calc::Q]
+    # @example
+    #  Calc::C(0,1).isimag #=> Calc::Q(1)
+    #  Calc::C(1,1).isimag #=> Calc::Q(0)
+    def isimag
+      imag? ? Q::ONE : Q::ZERO
+    end
+
+    def isodd
+      odd? ? Q::ONE : Q::ZERO
+    end
+
+    # Returns 1 if the number has zero imaginary part, otherwise returns 0.
+    # See also [real?].
+    #
+    # @return [Calc::Q]
+    # @example
+    #  Calc::C(1,1).isreal #=> Calc::Q(0)
+    #  Calc::C(1,0).isreal #=> Calc::Q(1)
+    def isreal
+      real? ? Q::ONE : Q::ZERO
+    end
+
+    # Computes the remainder for an integer quotient
+    #
+    # Result is equivalent to applying the mod function separately to the real
+    # and imaginary parts.
+    #
+    # @param y [Integer]
+    # @param r [Integer] (optional) rounding mode (see "help mod")
+    # @return [Calc::C]
+    # @example
+    #   Calc::C(0, 11).mod(5) #=> Calc::C(1i)
+    def mod(*args)
+      q1 = re.mod(*args)
+      q2 = im.mod(*args)
+      if q2.zero?
+        q1
+      else
+        Calc::C(q1, q2)
+      end
+    end
+
+    # Numerator of a complex number
+    #
+    # @return [Calc::C]
+    # @example
+    #   Calc::C("1/2", "2/3").numerator #=> Calc::C(3+4i)
+    def numerator
+      C.new(re.num * denominator / re.den, im.num * denominator / im.den)
+    end
+
+    # Returns the real part of the value as a rational
+    #
+    # If this number is non-imaginary, equivalent to re.rationalize(eps).
+    #
+    # Note that this method exists for ruby Numeric compatibility.  Libcalc has
+    # an alternative approximation method with different semantics, see `appr`.
+    #
+    # @param eps [Float,Rational]
+    # @return [Calc::Q]
+    # @example
+    #  Calc::C("1/3", 0).rationalize #=> Calc::Q(1/3)
+    #  Calc::C(1, 2).rationalize     # RangeError
+    def rationalize(eps = nil)
+      raise RangeError, "Can't convert #{ self } into Rational" if im.nonzero?
+      re.rationalize(eps)
+    end
+
+    # Round real and imaginary parts to the specified number of decimal digits
+    #
+    # @return [Calc::C,Calc::Q]
+    # @param places [Integer] number of decimal places to round to (default 0)
+    # @param rns [Integer] rounding flags (default Calc.config(:round))
+    #   Calc::C("7/32","-7/32").round(3) #=> Calc::C(0.218-0.219i)
+    def round(*args)
+      q1 = re.round(*args)
+      q2 = im.round(*args)
+      if q2.zero?
+        q1
+      else
+        C.new(q1, q2)
+      end
+    end
+
+    # Trigonometric secant
+    #
+    # @param eps [Calc::Q] (optional) calculation accuracy
+    # @return [Calc::C]
+    # @example
+    #  Calc::C(2,3).sec #=> Calc::C(~-0.04167496441114427005+~0.09061113719623759653i)
+    def sec(*args)
+      # see f_sec() in func.c
+      cos(*args).inverse
+    end
+
+    # Hyperbolic secant
+    #
+    # @param eps [Calc::Q] (optional) calculation accuracy
+    # @return [Calc::C]
+    # @example
+    #  Calc::C(2,3).sech #=> Calc::C(~-0.26351297515838930964-~0.03621163655876852087i)
+    def sech(*args)
+      # see f_sech() in func.c
+      cosh(*args).inverse
+    end
+
+    # Trigonometric tangent
+    #
+    # @param eps [Calc::Q] (optional) calculation accuracy
+    # @return [Calc::C]
+    # @example
+    #  Calc::C(1,2).tan #=> Calc::C(~-0.00376402564150424829+~1.00323862735360980145i)
+    def tan(*args)
+      # see f_tan() in func.c
+      sin(*args) / cos(*args)
+    end
+
+    # Hyperbolic tangent
+    #
+    # @param eps [Calc::Q] (optional) calculation accuracy
+    # @return [Calc::C]
+    # @example
+    #  Calc::C(1,2).tanh #=> Calc::C(~0.96538587902213312428-~0.00988437503832249372i)
+    def tanh(*args)
+      # see f_tanh() in func.c
+      sinh(*args) / cosh(*args)
+    end
+
+    # Converts a Calc::C object into a ruby Complex object
+    #
+    # @return [Complex]
+    # @example
+    #   Calc::C(2, 3).to_c #=> ((2/1)+(3/1)*i)
+    def to_c
+      Complex(re.to_r, im.to_r)
+    end
+
+    # Convert a complex number with zero imaginary part into a ruby Float
+    #
+    # @return [Float]
+    # @raise [RangeError] if imaginary part is non-zero
+    # @example
+    #   Calc::C("2/3", 0).to_f #=> 0.6666666666666666
+    def to_f
+      raise RangeError, "can't convert #{ self } into Float" if im.nonzero?
+      re.to_f
+    end
+
+    # Convert a wholly real number to an integer.
+    #
+    # Note that the return value is a ruby Fixnum or Bignum.  If you want to
+    # convert to an integer but have the result be a `Calc::Q` object, use
+    # `trunc` or `round`.
+    #
+    # @return [Fixnum,Bugnum]
+    # @raise [RangeError] if imaginary part is non-zero
+    # @example
+    #   Calc::C(2, 0).to_i #=> 2
+    #   Calc::C(2, 2).to_i # RangeError
+    def to_i
+      raise RangeError, "can't convert #{ self } into Integer" if im.nonzero?
+      re.to_i
+    end
+
+    # Convert a complex number with zero imaginary part into a ruby Rational
+    #
+    # @return [Rational]
+    # @raise [RangeError] if imaginary part is non-zero
+    # @example
+    #   Calc::C("2/3", 0).to_r #=> (2/3)
+    def to_r
+      raise RangeError, "can't convert #{ self } into Rational" if im.nonzero?
+      re.to_r
+    end
+
+    def to_s(*args)
+      if im.zero?
+        re.to_s(*args)
+      elsif re.zero?
+        imag_part(im, *args)
+      elsif im > 0
+        re.to_s(*args) + "+" + imag_part(im, *args)
+      else
+        re.to_s(*args) + "-" + imag_part(im.abs, *args)
+      end
+    end
+
+    def inspect
+      "Calc::C(#{ self })"
+    end
+
+    # aliases for compatibility with ruby Complex
+    alias integer? int?
+
+    private
+
+    # for formatting imaginary parts; if a fraction, put the "i" after the
+    # denominator (eg 2i/3).  otherwise it goes at the end (eg 0.5i).
+    def imag_part(number, *args)
+      string = number.to_s(*args)
+      string.insert(string.index("/") || -1, "i")
+    end
+  end
+end