ruby-calc 0.1.0

data/lib/calc/import.rb

@@ -0,0 +1,6 @@
+require "forwardable"
+
+module Kernel
+  extend Forwardable
+  def_delegators Calc, *Calc::ALL_BUILTINS
+end

data/lib/calc/numeric.rb

@@ -0,0 +1,208 @@
+module Calc
+  class Numeric
+    # Modulo operator
+    #
+    # x % y is equivalent to x.mod(y).  Rounding mode is determined by
+    # Calc.config(:mod).
+    #
+    # @param y [Integer]
+    # @return [Calc::Numeric]
+    # @example
+    #   Calc::Q(11).mod(5)     #=> Calc::Q(1)
+    #   Calc::C(11, 11).mod(5) #=> Calc::C(1+1i)
+    def %(other)
+      mod other
+    end
+
+    # Unary plus.  Returns the receiver's value.
+    #
+    # @return [Calc::Numeric]
+    # @example
+    #  +Calc::C(1,1) #=> Calc::C(1,1)
+    #  +Calc::Q(1)   #=> Calc::Q(1)
+    def +@
+      self
+    end
+
+    # Returns the square of the absolute value
+    #
+    # This method exists for compatibility with ruby Complex/Numeric.
+    #
+    # @return [Calc::C,Calc::Q]
+    # @example
+    #   Calc::Q(5).abs2     #=> Calc::Q(25)
+    #   Calc::C(3, -4).abs2 #=> Calc:c::Q(25)
+    def abs2
+      abs * abs
+    end
+
+    # Ceiling
+    #
+    # For real self, returns the least integer not less than self.
+    #
+    # For complex self, returns a complex number composed of the ceiling
+    # of the real and imaginary parts separately.
+    #
+    # @return [Calc::Q,Calc::C]
+    # @example
+    #   Calc::Q(1.23).ceil      #=> Calc::Q(2)
+    #   Calc::C(7.8, 9.1).ceil  #=> Calc::C(8+10i)
+    def ceil
+      appr(1, 1)
+    end
+
+    # Division
+    #
+    # This method exists for ruby compatibility.  Note that Fixnum#fdiv will
+    # return a Float, however Q#div returns another Q.
+    #
+    # @param y [Numeric]
+    # @return [Calc::C,Calc::Q]
+    # @raise [Calc::MathError] if y is 0
+    # @example
+    #  Calc::Q(2, 3).fdiv(0.5) #=> Calc::Q(~1.33333333333333333333)
+    #  Calc::C(11, 22).fdiv(3) #=> Calc::C(~3.66666666666666666667+~7.33333333333333333333i)
+    def fdiv(y)
+      self / y
+    end
+
+    # Floor
+    #
+    # For real self, returns the greatest integer not greater than self.
+    #
+    # For complex self, returns a complex number composed of the floor of the
+    # real and imaginary parts separately.
+    #
+    # @return [Calc::Q,Calc::C]
+    # @example
+    #   Calc::Q(1.23).floor     #=> Calc::Q(1)
+    #   Calc::C(7.8, 9.1).floor #=> Calc::C(7+9i)
+    def floor
+      appr(1, 0)
+    end
+
+    # Floor of logarithm to base 10
+    #
+    # Returns the greatest integer n for which 10^n <= self.
+    #
+    # @return [Calc::Q]
+    # @raise [Calc::MathError] if self is zero
+    # @example
+    #   Calc::Q("1/15").ilog10 #=> Calc::Q(-2)
+    #   Calc::Q(777).ilog10    #=> Calc::Q(2)
+    #   Calc::C(10, 10).ilog10 #=> Calc::Q(1)
+    def ilog10
+      ilog 10
+    end
+
+    # Floor of logarithm to base 2
+    #
+    # Returns the greatest integer n for which 2^n <= self
+    #
+    # @return [Calc::Q]
+    # @raise [Calc::MathError] if self is zero
+    # @example
+    #   Calc::Q("1/15").ilog2 #=> Calc::Q(-4)
+    #   Calc::Q(777).ilog2    #=> Calc::Q(9)
+    #   Calc::C(10, 10).ilog2 #=> Calc::Q(3)
+    def ilog2
+      ilog 2
+    end
+
+    # Returns 1 if self is an integer, otherwise 0.
+    #
+    # @return [Calc::Q]
+    # @example
+    #   Calc::Q(1).isint    #=> Calc::Q(1)
+    #   Calc::Q(0.5).isint  #=> Calc::Q(0)
+    def isint
+      int? ? Q::ONE : Q::ZERO
+    end
+
+    # Base 2 logarithm
+    #
+    # @return [Calc::Q]
+    # @example
+    #  Calc::Q(1).log2    #=> Calc::Q(0)
+    #  Calc::Q(2).log2    #=> Calc::Q(1)
+    #  Calc::Q(10).log2   #=> Calc::Q(~3.32192809488736234786)
+    #  Calc::Q(-2).log2   #=> Calc::C(1+~4.53236014182719380961i)
+    #  Calc::C(1, 2).log2 #=> Calc::C(~1.16096404744368117393+~1.59727796468810880664i)
+    def log2(*args)
+      ln(*args) / Q::TWO.ln(*args)
+    end
+
+    # least-absol;ute-value residues modulo a specified number
+    #
+    # x.mmin(md) is equivalent to x.mod(md, 16)
+    #
+    # @param md [Numeric]
+    # @return [Calc::Numeric]
+    # @example
+    #  Calc::Q(3).mmin(6)    #=> Calc::Q(3)
+    #  Calc::C(0, 3).mmin(6) #=> Calc::C(3i)
+    def mmin(md)
+      mod md, 16
+    end
+
+    # Returns true if the number is not zero.  For complex `self`, this means
+    # that either the real or imaginary parts are not zero.
+    #
+    # @return [Boolean]
+    # @example
+    #  Calc::Q(0).nonzero?    #=> false
+    #  Calc::Q(1).nonzero?    #=> true
+    #  Calc::C(0, 0).nonzero? #=> false
+    #  Calc::C(1, 0).nonzero? #=> true
+    #  Calc::C(0, 1).nonzero? #=> true
+    def nonzero?
+      !zero?
+    end
+
+    # Returns an array containing the absolute value and the argument (angle).
+    # This method exists for compatiblity with ruby's Numeric class.
+    #
+    # Note that: Calc.polar(a, b).polar == [a, b]
+    #
+    # @return [Array]
+    # @example
+    #  Calc::Q(2).polar       #=> [Calc::Q(2), Calc::Q(0)]
+    #  Calc::C(1, 2).polar    #=> [Calc::Q(2.23606797749978969641), Calc::Q(1.10714871779409050302)]
+    #  Calc.polar(1, 2).polar #=> [Calc::Q(1), Calc::Q(2)]
+    def polar
+      [abs, arg]
+    end
+
+    # Rerurns an array containing the real and imaginary parts as elements.
+    # This method exists for compatibility with ruby's Numeric class.
+    #
+    # @return [Array]
+    # @example
+    #   Calc::Q(2).rectangular    #=> [Calc::Q(2), Calc::Q(0)]
+    #   Calc::C(1, 2).rectangular #=> [Calc::Q(1), Calc::Q(2)]
+    def rectangular
+      [re, im]
+    end
+    alias rect rectangular
+
+    # Invokes the child class's `to_i` method to convert self 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,Bignum]
+    # @raise [RangeError] if self is complex with non-zero imaginary part
+    # @example
+    #  Calc::Q("5/2").to_int #=> 2
+    #  Calc::C(2, 0).to_int  #=> 2
+    def to_int
+      to_i
+    end
+
+    # Provides support for Ruby type coercion.
+    def coerce(other)
+      [self.class.new(other), self]
+    end
+  end
+end

data/lib/calc/q.rb

@@ -0,0 +1,628 @@
+module Calc
+  class Q
+    NEGONE = new(-1)
+    ZERO = new(0)
+    ONE = new(1)
+    TWO = new(2)
+
+    def **(other)
+      power(other)
+    end
+
+    # Inverse gudermannian function
+    #
+    # @param eps [Calc::Q] (optional) calculation accuracy
+    # @return [Calc::Q,Calc::C]
+    # @example
+    #  Calc::Q(1).agd #=> Calc::Q(1.22619117088351707081)
+    #  Calc::Q(2).agd #=> Calc::C(1.5234524435626735209-3.14159265358979323846i)
+    def agd(*args)
+      r = Calc::C(self).agd(*args)
+      r.real? ? r.re : r
+    end
+
+    # Returns the argument (the angle or phase) of a complex number in radians
+    #
+    # This method is used by non-complex classes, it will be 0 for positive
+    # values, pi() otherwise.
+    #
+    # @param eps [Calc::Q] (optional) calculation accuracy
+    # @return [Calc::Q]
+    # @example
+    #  Calc::Q(-1).arg #=> Calc::Q(3.14159265358979323846)
+    #  Calc::Q(1).arg  #=> Calc::Q(0)
+    def arg(*args)
+      if self < 0
+        Calc.pi(*args)
+      else
+        ZERO
+      end
+    end
+    alias angle arg
+    alias phase arg
+
+    # Returns 1 if binary bit y is set in self, otherwise 0.
+    #
+    # @param y [Numeric] bit position
+    # @return [Calc::Q]
+    # @example
+    #  Calc::Q(9).bit(0) #=> Calc::Q(1)
+    #  Calc::Q(9).bit(1) #=> Calc::Q(0)
+    # @see bit?
+    def bit(y)
+      bit?(y) ? ONE : ZERO
+    end
+    alias [] bit
+
+    # Returns the number of bits in the integer part of `self`
+    #
+    # Note that this is compatible with ruby's Fixnum#bit_length.  Libcalc
+    # provides a similar function called `highbit` with different semantics.
+    #
+    # This returns the bit position of the highest bit which is different to
+    # the sign bit.  If there is no such bit (zero or -1), zero is returned.
+    #
+    # @return [Calc::Q]
+    # @example
+    #   Calc::Q(0xff).bit_length #=> Calc::Q(8)
+    def bit_length
+      (negative? ? -self : self + ONE).log2.ceil
+    end
+
+    # Returns a string containing the character corresponding to a value
+    #
+    # Note that this is for compatibility with calc, normally in ruby you
+    # should just #chr
+    #
+    # @return [String]
+    # @example
+    #  Calc::Q(88).char #=> "X"
+    def char
+      raise MathError, "Non-integer for char" unless int?
+      raise MathError, "Out of range for char" unless between?(0, 255)
+      if zero?
+        ""
+      else
+        to_i.chr
+      end
+    end
+
+    # Returns a string containing the character represented by `self` value
+    # according to encoding.
+    #
+    # Unlike the calc version (`char`), this allows numbers greater than 255
+    # if an encoding is specified.
+    #
+    # @return [String]
+    # @param encoding [Encoding]
+    # @example
+    #  Calc::Q(88).chr                   #=> "X"
+    #  Calc::Q(300).chr(Encoding::UTF_8) #=> Unicode I-breve
+    def chr(*args)
+      to_i.chr(*args)
+    end
+
+    # Complex conjugate
+    #
+    # As the conjugate of real x is x, this method returns self.
+    #
+    # @return [Calc::Q]
+    # @example
+    #  Calc::Q(3).conj #=> 3
+    def conj
+      self
+    end
+    alias conjugate conj
+
+    # Ruby compatible integer division
+    #
+    # Calls `quo` to get the quotient of integer division, with rounding mode
+    # which specifies behaviour compatible with ruby's Numeric#div
+    #
+    # @param y [Numeric]
+    # @example
+    #  Calc::Q(13).div(4)     #=> Calc::Q(3)
+    #  Calc::Q("11.5").div(4) #=> Calc::Q(2)
+    # @see Calc::Q#quo
+    def div(y)
+      quo(y, ZERO)
+    end
+
+    # Ruby compatible quotient/modulus
+    #
+    # Returns an array containing the quotient and modulus by dividing `self`
+    # by `y`.  Rounding is compatible with the ruby method `Numeric#divmod`.
+    #
+    # Unlike `quomod`, this is not affected by `Calc.config(:quomod)`.
+    #
+    # @param y [Numeric]
+    # @example
+    #   Calc::Q(11).divmod(3)  #=> [Calc::Q(3), Calc::Q(2)]
+    #   Calc::Q(11).divmod(-3) #=> [Calc::Q(-4), Calc::Q(-1)]
+    def divmod(y)
+      quomod(y, ZERO)
+    end
+
+    # Iterates the given block, yielding values from `self` decreasing by 1
+    # down to and including `limit`
+    #
+    # x.downto(limit) is equivalent to x.step(by: -1, to: limit)
+    #
+    # If no block is given, an Enumerator is returned instead.
+    #
+    # @return [Enumerator,nil]
+    # @param limit [Numeric] lowest value to return
+    # @example
+    #   Calc::Q(10).downto(5) { |i| print i, " " } #=> 10 9 8 7 6 5
+    def downto(limit, &block)
+      step(limit, NEGONE, &block)
+    end
+
+    # Returns a string which if evaluated creates a new object with the original value
+    #
+    # @return [String]
+    # @example
+    #  Calc::Q(0.5).estr #=> "Calc::Q(1,2)"
+    def estr
+      s = self.class.name
+      s << "("
+      s << (int? ? num.to_s : "#{ num },#{ den }")
+      s << ")"
+      s
+    end
+
+    # Returns an array; [gcd, lcm]
+    #
+    # This method exists for compatibility with ruby's Integer class, however
+    # note that the libcalc version works on rational numbers and the lcm can
+    # be negative.  You can also pass more than one value.
+    #
+    # @return [Array]
+    # @example
+    #   Calc::Q(2).gcdlcm(2)  #=> [Calc::Q(2), Calc::Q(2)]
+    #   Calc::Q(3).gcdlcm(-7) #=> [Calc::Q(1), Calc::Q(-21)]
+    def gcdlcm(*args)
+      [gcd(*args), lcm(*args)]
+    end
+
+    # Gudermannian function
+    #
+    # @param eps [Calc::Q] (optional) calculation accuracy
+    # @return [Calc::Q]
+    # @example
+    #  Calc::Q(1).gd #=> Calc::Q(0.86576948323965862429)
+    def gd(*args)
+      r = Calc::C(self).gd(*args)
+      r.real? ? r.re : r
+    end
+
+    # Returns the corresponding imaginary number
+    #
+    # @return [Calc::C]
+    # @example
+    #  Calc::Q(1).i #=> Calc::C(1i)
+    def i
+      Calc::C(ZERO, self)
+    end
+
+    def im
+      ZERO
+    end
+    alias imaginary im
+
+    # Returns true if the number is imaginary.  Instances of this class always
+    # return false.
+    #
+    # @return [Boolean]
+    # @example
+    #  Calc::Q(1).imag? #=> false
+    def imag?
+      false
+    end
+
+    def inspect
+      "Calc::Q(#{ self })"
+    end
+
+    def iseven
+      even? ? ONE : ZERO
+    end
+
+    # Returns 1 if the number is imaginary, otherwise returns 0.  Instance of
+    # this class always return 0.
+    #
+    # @return [Calc::Q]
+    # @example
+    #  Calc::Q(1).isimag #=> Calc::Q(0)
+    def isimag
+      ZERO
+    end
+
+    # Returns 1 if self exactly divides y, otherwise return 0.
+    #
+    # @return [Calc::Q]
+    # @example
+    #  Calc::Q(6).ismult(2) #=> Calc::Q(1)
+    #  Calc::Q(2).ismult(6) #=> Calc::Q(0)
+    # @see Calc::Q#mult?
+    def ismult(y)
+      mult?(y) ? ONE : ZERO
+    end
+
+    def isodd
+      odd? ? ONE : ZERO
+    end
+
+    # Returns 1 if self is prime, 0 if it is not prime.  This function can't
+    # be used for odd numbers > 2^32.
+    #
+    # @return [Calc::Q]
+    # @raise [Calc::MathError] if self is odd and > 2^32
+    # @example
+    #  Calc::Q(2**31 - 9).isprime #=> Calc::Q(0)
+    #  Calc::Q(2**31 - 1).isprime #=> Calc::Q(1)
+    def isprime
+      prime? ? ONE : ZERO
+    end
+
+    # Returns 1 if this number has zero imaginary part, otherwise returns 0.
+    # Instances of this class always return 1.
+    #
+    # @return [Calc::Q]
+    # @example
+    #  Calc::Q(1).isreal #=> Calc::Q(1)
+    def isreal
+      ONE
+    end
+
+    # Returns 1 if both values are relatively prime
+    #
+    # @param other [Integer]
+    # @return [Calc::Q]
+    # @raise [Calc::MathError] if either values are non-integers
+    # @example
+    #  Calc::Q(6).isrel(5) #=> Calc::Q(1)
+    #  Calc::Q(6).isrel(2) #=> Calc::Q(0)
+    # @see Calc::Q#rel?
+    def isrel(y)
+      rel?(y) ? ONE : ZERO
+    end
+
+    # Returns 1 if this value is a square
+    #
+    # @return [Calc::Q]
+    # @example
+    #  Calc::Q(25).issq     #=> Calc::Q(1)
+    #  Calc::Q(3).issq      #=> Calc::Q(0)
+    #  Calc::Q("4/25").issq #=> Calc::Q(1)
+    # @see Calc::Q#sq?
+    def issq
+      sq? ? ONE : ZERO
+    end
+
+    # test for equaility modulo a specific number
+    #
+    # Returns 1 if self is congruent to y modulo md, otherwise 0.
+    #
+    # @param y [Numeric]
+    # @param md [Numeric]
+    # @return [Calc::Q]
+    # @example
+    #  Calc::Q(5).meq(33, 7) #=> Calc::Q(1)
+    #  Calc::Q(5).meq(32, 7) #=> Calc::Q(0)
+    # @see Calc::Q#meq?
+    def meq(y, md)
+      meq?(y, md) ? ONE : ZERO
+    end
+
+    # test for inequality modulo a specific number
+    #
+    # Reurns 1 if self is not congruent to y modulo md, otherwise 0.
+    # This is the opposite of #meq.
+    #
+    # @param y [Numeric]
+    # @param md [Numeric]
+    # @return [Calc::Q]
+    # @example
+    #  Calc::Q(5).mne(33, 7) #=> Calc::Q(0)
+    #  Calc::Q(5).mne(32, 7) #=> Calc::Q(1)
+    # @see Calc::Q#mne?
+    def mne(y, md)
+      meq?(y, md) ? ZERO : ONE
+    end
+
+    # test for inequality modulo a specific number
+    #
+    # Returns true of self is not congruent to y modulo md.
+    # This is the opposiute of #meq?.
+    #
+    # @param y [Numeric]
+    # @param md [Numeric]
+    # @return [Boolean]
+    # @example
+    #   Calc::Q(5).mne?(33, 7) #=> false
+    #   Calc::Q(5).mne?(32, 6) #=> true
+    def mne?(y, md)
+      !meq?(y, md)
+    end
+
+    # Ruby compatible modulus
+    #
+    # Returns the modulus of `self` divided by `y`.
+    #
+    # Rounding is compatible with the ruby method Numeric#modulo.  Unlike
+    # `mod`, this is not affected by `Calc.confg(:mod)`.
+    #
+    # @param y [Numeric]
+    # @example
+    #  Calc::Q(13).modulo(4)  #=> Calc::Q(1)
+    #  Calc::Q(13).modulo(-4) #=> Calc::Q(-3)
+    def modulo(y)
+      mod(y, ZERO)
+    end
+
+    # Return true if `self` is less than zero.
+    #
+    # This method exists for ruby Fixnum/Rational compatibility
+    #
+    # @return [Boolean]
+    # @example
+    #  Calc::Q(-1).negative? #=> true
+    #  Calc::Q(0).negative?  #=> false
+    #  Calc::Q(1).negative?  #=> false
+    def negative?
+      self < ZERO
+    end
+
+    # Returns self.
+    #
+    # This method is for ruby Integer compatibility
+    #
+    # @return [Calc::Q]
+    def ord
+      self
+    end
+
+    # Return true if `self` is greater than zero.
+    #
+    # This method exists for ruby Fixnum/Rational compatibility
+    #
+    # @return [Boolean]
+    # @example
+    #  Calc::Q(-1).positive? #=> false
+    #  Calc::Q(0).positive?  #=> false
+    #  Calc::Q(1).positive?  #=> true
+    def positive?
+      self > ZERO
+    end
+
+    # Returns one less than self.
+    #
+    # This method exists for ruby Fixnum/Integer compatibility.
+    #
+    # @return [Calc::Q]
+    # @example
+    #   Calc::Q(1).pred #=> Calc::Q(0)
+    def pred
+      self - ONE
+    end
+
+    # Probabilistic primacy test
+    #
+    # Returns 1 if ptest? would have returned true, otherwise 0.
+    #
+    # @param count [Integer]
+    # @param skip [Integer]
+    # @return [Calc::Q]
+    # @see Calc::Q#ptest?
+    def ptest(*args)
+      ptest?(*args) ? ONE : ZERO
+    end
+
+    # Returns a simpler approximation of the value if the optional argument eps
+    # is given (rat-|eps| <= result <= rat+|eps|), self otherwise.
+    #
+    # 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::Q(5033165, 16777216).rationalize                   #=> Calc::Q(5033165/16777216)
+    #  Calc::Q(5033165, 16777216).rationalize(Rational('0.01')) #=> Calc::Q(3/10)
+    #  Calc::Q(5033165, 16777216).rationalize(Rational('0.1'))  #=> Calc::Q(1/3)
+    def rationalize(eps = nil)
+      eps ? Q.new(to_r.rationalize(eps)) : self
+    end
+
+    def re
+      self
+    end
+
+    # Returns true if this number has zero imaginary part.  Instances of this
+    # class always return true.
+    #
+    # @return [Boolean]
+    # @example
+    #  Calc::Q(1).real? #=> true
+    def real?
+      true
+    end
+
+    # Remainder of `self` divided by `y`
+    #
+    # This method is provided for compatibility with ruby's
+    # `Numeric#remainder`.  Unlike `%` and `mod`, this method behaves the same
+    # as the ruby version, unaffected by `Calc.config(:mod).
+    #
+    # @param y [Numeric]
+    # @return [Calc::C,Calc::Q]
+    # @example
+    #  Calc::Q(13).remainder(4) #=> Calc::Q(1)
+    def remainder(y)
+      z = modulo(y)
+      if !z.zero? && ((self < 0 && y > 0) || (self > 0 && y < 0))
+        z - y
+      else
+        z
+      end
+    end
+
+    # Invokes the given block with the sequence of numbers starting at self
+    # incrementing by step (default 1) on each call.
+    #
+    # In the first format, uses keyword parameters:
+    #   x.step(by: step, to: limit)
+    #
+    # In the second format, uses positional parameters:
+    #   x.step(limit = nil, step = 1)
+    #
+    # If step is negative, the sequence decrements instead of incrementing.
+    # If step is zero, the sequence will yield self forever.
+    #
+    # If limit exists, the sequence will stop once the next item yielded would
+    # be higher than limit (if step is positive) or lower than limit (if step
+    # is negative).  If limit is nil, the sequence never stops.
+    #
+    # If no block is givem, an Enumerator is returned instead.
+    #
+    # This method was added for ruby Numeric compatibiliy; unlike Numeric#step,
+    # it is not an error for step to be zero in the positional format.
+    #
+    # @param by [Numeric] amount to add to sequence each iteration
+    # @param to [Numeric] end of sequence value
+    # @return [Enumerator,nil]
+    # @example
+    #  Calc::Q(1).step(10, 3).to_a      #=> [Calc::Q(1), Calc::Q(4), Calc::Q(7), Calc::Q(10)]
+    #  Calc::Q(10).step(by: -2).take(4) #=> [Calc::Q(10), Calc::Q(8), Calc::Q(6), Calc::Q(4)]
+    #  Calc::Q(1).exp.step(to: Calc.pi, by: "0.2") { |q| print q, " " } #=> nil
+    # prints:
+    #  2.71828182845904523536 2.91828182845904523536 3.11828182845904523536
+    def step(a1 = nil, a2 = ONE)
+      return to_enum(:step, a1, a2) unless block_given?
+      to, by = step_args(a1, a2)
+      loop { yield self } if by.zero?
+      i = self
+      loop do
+        break if to && ((by.positive? && i > to) || (by.negative? && i < to))
+        yield i
+        i += by
+      end
+    end
+
+    # work out what the caller meant with their args to #step
+    # returns an array of [to, by] parameters
+    def step_args(a1, a2)
+      if a1.is_a?(Hash)
+        # fake keywords style
+        badkeys = a1.keys - %i(to by)
+        raise ArgumentError, "Unknown keywords: #{ badkeys.join(", ") }" if badkeys.any?
+        to = a1.fetch(:to, nil)
+        by = a1.fetch(:by, ONE)
+      else
+        # positional style (limit, step)
+        to = a1
+        by = a2
+      end
+      [to ? Q.new(to) : nil, Q.new(by)]
+    end
+    private :step_args
+
+    # Returns one more than self.
+    #
+    # This method exists for ruby Fixnum/Integer compatibility.
+    #
+    # @return [Calc::Q]
+    # @example
+    #   Calc::Q(1).pred #=> Calc::Q(2)
+    def succ
+      self + ONE
+    end
+    alias next succ
+
+    # Iterates the given block `self` times, passing in values from zero to
+    # self - 1
+    #
+    # If no block is given, an Enumerator is returned instead.
+    #
+    # @return [Enumerator,nil]
+    # @example
+    #   Calc::Q(5).times { |i| print i, " " }
+    #   #=> 0 1 2 3 4
+    def times
+      return to_enum(:times) unless block_given?
+      i = ZERO
+      while i < self
+        yield i
+        i += ONE
+      end
+    end
+
+    # Returns a ruby Complex number with self as the real part and zero
+    # imaginary part.
+    #
+    # @return [Complex]
+    # @example
+    #  Calc::Q(2).to_c    #=> (2+0i)
+    #  Calc::Q(2.5).to_c  #=> ((5/2)+0i)
+    def to_c
+      Complex(int? ? to_i : to_r, 0)
+    end
+
+    # Returns a Calc::C complex number with self as the real part and zero
+    # imaginary part.
+    #
+    # @return [Calc::C]
+    # @example
+    #   Calc::Q(2).to_complex #=> Calc::C(2)
+    def to_complex
+      C.new(self, 0)
+    end
+
+    # libcalc has no concept of floating point numbers.  so we use ruby's
+    # Rational#to_f
+    def to_f
+      to_r.to_f
+    end
+
+    # convert to a core ruby Rational
+    def to_r
+      Rational(numerator.to_i, denominator.to_i)
+    end
+
+    alias truncate trunc
+
+    # Iterates the given block, yielding values from `self` increasing by 1
+    # up to and including `limit`
+    #
+    # x.upto(limit) is equivalent to x.step(by: 1, to: limit)
+    #
+    # If no block is given, an Enumerator is returned instead.
+    #
+    # @return [Enumerator,nil]
+    # @param limit [Numeric] highest value to return
+    # @example
+    #   Calc::Q(5).upto(10) { |i| print i, " " } #=> 5 6 7 8 9 10
+    def upto(limit, &block)
+      step(limit, ONE, &block)
+    end
+
+    # Bitwise exclusive or of a set of integers
+    #
+    # xor(a, b, c, ...) is equivalent to (((a ^ b) ^ c) ... )
+    # note that ^ is the ruby xor operator, not the calc power operator.
+    #
+    # @return [Calc::Q]
+    # @example
+    #   Calc::Q(3).xor(5)           #=> Calc::Q(6)
+    #   Calc::Q(5).xor(3, -7, 2, 9) #=> Calc::Q(-12)
+    def xor(*args)
+      args.inject(self, :^)
+    end
+
+    # aliases for compatibility with ruby Fixnum/Bignum/Rational
+    alias imag im
+    alias integer? int?
+    alias real re
+  end
+end