ruby-calc 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60dc0a56479aabb76308bf50c684b33dee34295a
-  data.tar.gz: 146f1c057188c53d530776232b992bc6f8de0042
+  metadata.gz: cb0e4ef73520d0841eea1ca26cc32ccf9da59198
+  data.tar.gz: 2cc20bd449fe8fc1771bc643099cdfc744493751
 SHA512:
-  metadata.gz: 138bc132c80fb43568cce386271ac3f8f9a331a80a861bc155e88b10e11bdf697bfd03becf96598a433d09b50be67519c4c93d0bac96608abab5aa0c223790b7
-  data.tar.gz: 33f6b72f5db4aeba9cd01b045b30eee2d904226111709cf20c7cb8b120be9900d2518bf0f65b3da1395ff48222e57bb78471f937cb9f5421fdbc8e3d2880d219
+  metadata.gz: 9c216a8a5f5b8cb848b39d4c880832a62320450d038419b04bd4083392244fde819ced6650a9d0d139b359b3506a06d149af706165fe9f157eb1613d687fc0c6
+  data.tar.gz: 96c66092a67f0f9a9974d741ec103d94eac1dd30e395be4fa611f60d41ff1bc6a7965596f531c4578b4819d9b24597d2a8bfca1de3b336750291a7099073e505

data/.travis.yml

@@ -5,6 +5,7 @@ rvm:
   - 2.1
   - 2.2
   - 2.3.0
+  - ruby-head
 env:
   - CALC_VERSION=2.12.5.0   # latest stable    (12-Oct-2014)
   - CALC_VERSION=2.12.5.4   # latest unstable  (22-Feb-2016)

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/) 
+and this project adheres to [Semantic Versioning](http://semver.org/).
+
+## [Unreleased]
+
+## [0.2.0] - 2016-12-24
+### Added
+- Compatibility with ruby 2.4 `Fixnum`/`Bignum` unification to `Integer`
+- Parameters for `ceil` and `floor` compatible with ruby 2.4 numeric classes
+- Methods `finite?` and `infinite?` compatible with ruby 2.4 numeric classes
+- Method `digits_r` compatible with ruby 2.4 numeric `digits`, as libcalc
+  already provides a `digits` function (requires ruby 2.4)
+- Method `clamp` returns ruby calc classes in ruby 2.4
+
+## 0.1.0 - 2016-05-28
+### Added
+- Adds `Calc::Q` (rational numbers) and `Calc::C` (complex numbers)
+- Important (mathematical) libcalc functions as methods
+- Several libcalc configuration options via `Calc#config`
+- Conversion to/from libcalc and ruby classes
+- Compatibility methods with ruby numeric classes
+
+[Unreleased]: https://github.com/timocp/ruby-calc/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/timocp/ruby-calc/compare/v0.1.0...v0.2.0

data/README.md

@@ -1,4 +1,4 @@
-# ruby-calc [![Build Status](https://travis-ci.org/timpeters/ruby-calc.svg?branch=master)](https://travis-ci.org/timpeters/ruby-calc)
+# ruby-calc [![Build Status](https://travis-ci.org/timocp/ruby-calc.svg?branch=master)](https://travis-ci.org/timocp/ruby-calc)
 
 ruby-calc provides ruby bindings for calc, a c-style arbitrary precision calculator.
 
@@ -18,7 +18,7 @@ Manual | Download and install calc yourself by referring to the calc website, or
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'ruby-calc', git: 'git://github.com/timpeters/ruby-calc.git'
+gem 'ruby-calc', git: 'git://github.com/timocp/ruby-calc.git'
 ```
 
 And then execute:
@@ -349,6 +349,13 @@ Calc::Q(1,20).to_s(:bin)      #=> "1/0b10100    base 2 fractions
 
 The default output mode can be set with [Calc::Config].  The output of `inspect` will match whatever the current default is.
 
+The argument to `to_s` may also be an integer.  In this case, it acts like ruby `Fixnum#to_s`, and treats the argument as a base.  This only works for integers.
+
+```ruby
+Calc::Q(12345).to_s(2)  #=> "11000000111001"
+Calc::Q(12345).to_s(36) #=> "9ix"
+```
+
 Note that you can also provide `Calc::Q` objects to the ruby printf method.  The format string parameter will coerce the number to the right internal type first (eg %d will display as an integer, %f as a floating point number).  The display may have lost precision in this conversion.
 
 ### Configuration
@@ -490,7 +497,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-1. Fork it ( https://github.com/timpeters/ruby-calc/fork )
+1. Fork it ( https://github.com/timocp/ruby-calc/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/bin/setup

@@ -2,6 +2,9 @@
 set -euo pipefail
 IFS=$'\n\t'
 
+if ! command -v bundle >/dev/null ; then
+    gem install bundler --no-document
+fi
 bundle install
 
 # Do any other automated setup that you need to do here

data/bin/todo.rb

@@ -344,20 +344,20 @@ end
 
 rat_methods = Rational(1, 2).methods - exclude
 com_methods = Complex(1, 2).methods - exclude
-fix_methods = 1.methods - exclude
+int_methods = 1.methods - exclude
 q_methods = Calc::Q(1).methods
 c_methods = Calc::C(1, 1).methods
 
-((rat_methods & fix_methods) - q_methods).sort.each do |m|
-  puts "Calc::Q needs method #{ m } for Rational and Fixnum compatibility"
+((rat_methods & int_methods) - q_methods).sort.each do |m|
+  puts "Calc::Q needs method #{ m } for Rational and #{ 1.class } compatibility"
 end
 
-(rat_methods - fix_methods - q_methods).sort.each do |m|
+(rat_methods - int_methods - q_methods).sort.each do |m|
   puts "Calc::Q needs method #{ m } for Rational compatibility"
 end
 
-(fix_methods - rat_methods - q_methods).sort.each do |m|
-  puts "Calc::Q needs method #{ m } for Fixnum compatibility"
+(int_methods - rat_methods - q_methods).sort.each do |m|
+  puts "Calc::Q needs method #{ m } for #{ 1.class } compatibility"
 end
 
 (com_methods - c_methods).sort.each do |m|
@@ -367,7 +367,7 @@ end
 [
   ["ruby-calc builtins", builtins_done, builtins],
   ["Rational compatibility", (rat_methods & q_methods).size, rat_methods.size.to_f],
-  ["Fixnum compatibility", (fix_methods & q_methods).size, fix_methods.size.to_f],
+  ["#{ 1.class } compatibility", (int_methods & q_methods).size, int_methods.size.to_f],
   ["Complex compatibility", (com_methods & c_methods).size, com_methods.size.to_f]
 ].each do |goal, done, total|
   printf "%25s:  %3d/%3d (%3.1f%%)\n", goal, done, total, done / total * 100

data/ext/calc/c.c

@@ -37,7 +37,7 @@ cc_alloc(VALUE klass)
  * If a single param of type Complex or Calc::C, returns a new complex number
  * with the same real and imaginary parts.
  *
- * If a single param of other numeric types (Fixnum, Bignum, Rational, Float,
+ * If a single param of other numeric types (Integer, Rational, Float,
  * Calc::Q), returns a complex number with the specified real part and zero
  * imaginary part.
  *
@@ -56,7 +56,7 @@ cc_initialize(int argc, VALUE * argv, VALUE self)
         if (CALC_C_P(re)) {
             cself = clink((COMPLEX *) DATA_PTR(re));
         }
-        else if (TYPE(re) == T_COMPLEX) {
+        else if (RB_TYPE_P(re, T_COMPLEX)) {
             cself = value_to_complex(re);
         }
         else {
@@ -238,7 +238,7 @@ cc_divide(VALUE x, VALUE y)
  * If the other value is complex (Calc::C or Complex), returns true if the
  * real an imaginary parts of both numbers are the same.
  *
- * The other value is some other numberic type (Fixnum, Bignum, Calc::Q,
+ * The other value is some other numberic type (Integer, Calc::Q,
  * Rational or Float) then returns true if the complex part of this number is
  * zero and the real part is equal to the other.
  *
@@ -262,13 +262,13 @@ cc_equal(VALUE self, VALUE other)
     if (CALC_C_P(other)) {
         result = !c_cmp(cself, DATA_PTR(other));
     }
-    else if (TYPE(other) == T_COMPLEX) {
+    else if (RB_TYPE_P(other, T_COMPLEX)) {
         cother = value_to_complex(other);
         result = !c_cmp(cself, cother);
         comfree(cother);
     }
-    else if (TYPE(other) == T_FIXNUM || TYPE(other) == T_BIGNUM || TYPE(other) == T_RATIONAL ||
-             TYPE(other) == T_FLOAT || CALC_Q_P(other)) {
+    else if (FIXNUM_P(other) || RB_TYPE_P(other, T_BIGNUM) || RB_TYPE_P(other, T_RATIONAL) ||
+             RB_TYPE_P(other, T_FLOAT) || CALC_Q_P(other)) {
         cother = qqtoc(value_to_number(other, 0), &_qzero_);
         result = !c_cmp(cself, cother);
         comfree(cother);

data/ext/calc/config.c

@@ -77,10 +77,10 @@ value_to_nametype_long(VALUE v, nametype2 * set)
     VALUE tmp;
     char *str;
 
-    if (TYPE(v) == T_STRING) {
+    if (RB_TYPE_P(v, T_STRING)) {
         str = StringValueCStr(v);
     }
-    else if (TYPE(v) == T_SYMBOL) {
+    else if (RB_TYPE_P(v, T_SYMBOL)) {
         tmp = rb_funcall(v, rb_intern("to_s"), 0);
         str = StringValueCStr(tmp);
     }

data/ext/calc/convert.c

@@ -50,8 +50,7 @@ rational_to_number(VALUE arg)
 }
 
 /* converts a ruby value into a NUMBER*.  Allowed types:
- *  - Fixnum
- *  - Bignum
+ *  - Integer
  *  - Calc::Q
  *  - Rational
  *  - String (using libcalc str2q)
@@ -66,24 +65,24 @@ value_to_number(VALUE arg, int string_allowed)
     NUMBER *qresult;
     VALUE num, tmp;
 
-    if (TYPE(arg) == T_FIXNUM) {
+    if (FIXNUM_P(arg)) {
         qresult = itoq(NUM2LONG(arg));
     }
-    else if (TYPE(arg) == T_BIGNUM) {
+    else if (RB_TYPE_P(arg, T_BIGNUM)) {
         num = bignum_to_calc_q(arg);
         qresult = qlink((NUMBER *) DATA_PTR(num));
     }
     else if (CALC_Q_P(arg)) {
         qresult = qlink((NUMBER *) DATA_PTR(arg));
     }
-    else if (TYPE(arg) == T_RATIONAL) {
+    else if (RB_TYPE_P(arg, T_RATIONAL)) {
         qresult = rational_to_number(arg);
     }
-    else if (TYPE(arg) == T_FLOAT) {
+    else if (RB_TYPE_P(arg, T_FLOAT)) {
         tmp = rb_funcall(arg, rb_intern("to_r"), 0);
         qresult = rational_to_number(tmp);
     }
-    else if (string_allowed && TYPE(arg) == T_STRING) {
+    else if (string_allowed && RB_TYPE_P(arg, T_STRING)) {
         qresult = str2q(StringValueCStr(arg));
         /* libcalc str2q allows a 0 denominator */
         if (ziszero(qresult->den)) {
@@ -116,7 +115,7 @@ value_to_complex(VALUE arg)
     if (CALC_C_P(arg)) {
         cresult = clink((COMPLEX *) DATA_PTR(arg));
     }
-    else if (TYPE(arg) == T_COMPLEX) {
+    else if (RB_TYPE_P(arg, T_COMPLEX)) {
         real = rb_funcall(arg, rb_intern("real"), 0);
         imag = rb_funcall(arg, rb_intern("imag"), 0);
         cresult = qqtoc(value_to_number(real, 0), value_to_number(imag, 0));
@@ -124,8 +123,8 @@ value_to_complex(VALUE arg)
     else if (CALC_Q_P(arg)) {
         cresult = qqtoc(DATA_PTR(arg), &_qzero_);
     }
-    else if (FIXNUM_P(arg) || TYPE(arg) == T_BIGNUM || TYPE(arg) == T_RATIONAL
-             || TYPE(arg) == T_FLOAT) {
+    else if (FIXNUM_P(arg) || RB_TYPE_P(arg, T_BIGNUM) || RB_TYPE_P(arg, T_RATIONAL)
+             || RB_TYPE_P(arg, T_FLOAT)) {
         cresult = qqtoc(value_to_number(arg, 0), &_qzero_);
     }
     else {

data/ext/calc/numeric.c

@@ -146,7 +146,7 @@ cn_cmp(VALUE self, VALUE other)
 
     if (CALC_Q_P(self)) {
         qself = DATA_PTR(self);
-        if (CALC_C_P(other) || TYPE(other) == T_COMPLEX) {
+        if (CALC_C_P(other) || RB_TYPE_P(other, T_COMPLEX)) {
             cother = value_to_complex(other);
             r = qrel(qself, cother->real);
             i = qrel(&_qzero_, cother->imag);
@@ -161,7 +161,7 @@ cn_cmp(VALUE self, VALUE other)
     }
     else if (CALC_C_P(self)) {
         cself = DATA_PTR(self);
-        if (CALC_C_P(other) || TYPE(other) == T_COMPLEX) {
+        if (CALC_C_P(other) || RB_TYPE_P(other, T_COMPLEX)) {
             cother = value_to_complex(other);
             r = qrel(cself->real, cother->real);
             i = qrel(cself->imag, cother->imag);

data/ext/calc/q.c

@@ -64,8 +64,7 @@ cq_alloc(VALUE klass)
  *
  * Arguments are either a numerator/denominator pair, or a single numerator.
  * With a single parameter, a denominator of 1 is implied.  Valid types are:
- * * Fixnum
- * * Bignum
+ * * Integer
  * * Rational
  * * Calc::Q
  * * String
@@ -150,20 +149,21 @@ numeric_op(VALUE self, VALUE other,
     VALUE ary;
     setup_math_error();
 
-    if (fql && TYPE(other) == T_FIXNUM) {
+    if (fql && FIXNUM_P(other)) {
         qresult = (*fql) (DATA_PTR(self), NUM2LONG(other));
     }
     else if (CALC_Q_P(other)) {
         qresult = (*fqq) (DATA_PTR(self), DATA_PTR(other));
     }
-    else if (TYPE(other) == T_FIXNUM || TYPE(other) == T_BIGNUM || TYPE(other) == T_FLOAT
-             || TYPE(other) == T_RATIONAL) {
+    else if (RB_TYPE_P(other, T_FIXNUM) || RB_TYPE_P(other, T_BIGNUM)
+             || RB_TYPE_P(other, T_FLOAT)
+             || RB_TYPE_P(other, T_RATIONAL)) {
         qother = value_to_number(other, 0);
         qresult = (*fqq) (DATA_PTR(self), qother);
         qfree(qother);
     }
     else if (rb_respond_to(other, id_coerce)) {
-        if (TYPE(other) == T_COMPLEX) {
+        if (RB_TYPE_P(other, T_COMPLEX)) {
             other = rb_funcall(cC, id_new, 1, other);
         }
         ary = rb_funcall(other, id_coerce, 1, self);
@@ -427,7 +427,7 @@ cq_divide(VALUE x, VALUE y)
  * nil is returned if the two values are incomparable.
  *
  * @param other [Numeric,Calc::Q]
- * @return [Fixnum,nil]
+ * @return [Integer,nil]
  * @example:
  *  Calc::Q(5) <=> 4     #=> 1
  *  Calc::Q(5) <=> 5.1   #=> -1
@@ -444,21 +444,21 @@ cq_spaceship(VALUE self, VALUE other)
 
     qself = DATA_PTR(self);
     /* qreli returns incorrect results if self > 0 and other == 0
-       if (TYPE(other) == T_FIXNUM) {
+       if (FIXNUM_P(other)) {
        result = qreli(qself, NUM2LONG(other));
        }
      */
     if (CALC_Q_P(other)) {
         result = qrel(qself, DATA_PTR(other));
     }
-    else if (TYPE(other) == T_FIXNUM || TYPE(other) == T_BIGNUM || TYPE(other) == T_FLOAT
-             || TYPE(other) == T_RATIONAL) {
+    else if (FIXNUM_P(other) || RB_TYPE_P(other, T_BIGNUM) || RB_TYPE_P(other, T_FLOAT)
+             || RB_TYPE_P(other, T_RATIONAL)) {
         qother = value_to_number(other, 0);
         result = qrel(qself, qother);
         qfree(qother);
     }
     else if (rb_respond_to(other, id_coerce)) {
-        if (TYPE(other) == T_COMPLEX) {
+        if (RB_TYPE_P(other, T_COMPLEX)) {
             other = rb_funcall(cC, id_new, 1, other);
         }
         ary = rb_funcall(other, id_coerce, 1, self);
@@ -1104,6 +1104,9 @@ cq_digit(int argc, VALUE * argv, VALUE self)
 }
 
 /* Returns the number of digits of the integral part of self in decimal or another base
+ *
+ * Note that this is unlike the ruby's `Integer#digits`.  For an equivalent,
+ * see `Q#digits_r`.
  *
  * @return [Calc::Q]
  * @param b [Integer] (optional) base >= 2 (default 10)
@@ -2128,11 +2131,11 @@ cq_power(int argc, VALUE * argv, VALUE self)
         qepsilon = value_to_number(epsilon, 1);
     }
     qself = DATA_PTR(self);
-    if (CALC_C_P(arg) || TYPE(arg) == T_COMPLEX || qisneg(qself)) {
+    if (CALC_C_P(arg) || RB_TYPE_P(arg, T_COMPLEX) || qisneg(qself)) {
         cself = comalloc();
         qfree(cself->real);
         cself->real = qlink(qself);
-        if (TYPE(arg) == T_STRING) {
+        if (RB_TYPE_P(arg, T_STRING)) {
             carg = comalloc();
             qfree(carg->real);
             carg->real = value_to_number(arg, 1);
@@ -2428,15 +2431,15 @@ cq_sinh(int argc, VALUE * argv, VALUE self)
 
 /* Returns the number of bytes in the machine representation of `self`
  *
- * This method acts like ruby's Fixnum#size, except that is works on fractions
+ * This method acts like ruby's Integer#size, except that is works on fractions
  * in which case the result is the number of bytes for both the numerator and
  * denominator.  As the internal representation of numbers differs between
  * ruby and libcalc, it wil not necessary return the same values as
- * Fixnum#size.
+ * Integer#size.
  *
  * @return [Calc::Q]
  * @example
- *  Calc::Q(1).size     #=> Calc;:Q(4)
+ *  Calc::Q(1).size     #=> Calc::Q(4)
  *  Calc::Q(2**32).size #=> Calc::Q(8)
  *  Calc::Q("1/3").size #=> Calc::Q(8)
  */
@@ -2508,15 +2511,15 @@ cq_tanh(int argc, VALUE * argv, VALUE self)
     return trans_function(argc, argv, self, &qtanh, NULL);
 }
 
-/* Converts this number to a core ruby integer (Fixnum or Bignum).
+/* Converts this number to a core ruby Integer.
  *
  * If self is a fraction, the fractional part is truncated.
  *
- * Note that the return value is a ruby Fixnum or Bignum.  If you want to
+ * Note that the return value is a ruby Integer.  If you want to
  * convert to an integer but have the result be a `Calc::Q` object, use
  * `trunc` or `round`.
  *
- * @return [Fixnum,Bignum]
+ * @return [Integer]
  * @example
  *  Calc::Q(42).to_i     #=> 42
  *  Calc::Q("1e19").to_i #=> 10000000000000000000
@@ -2560,12 +2563,13 @@ cq_to_i(VALUE self)
  * Format depends on the configuration parameters "mode" and "display.  The
  * mode can be overridden for individual calls.
  *
- * @param mode [String,Symbol] (optional) output mode, see [Calc::Config]
+ * @param mode [String,Symbol,Integer] (optional) output mode, see [Calc::Config]
  * @return [String]
  * @example
  *  Calc::Q(1,2).to_s        #=> "0.5"
  *  Calc::Q(1,2).to_s(:frac) #=> "1/2"
  *  Calc::Q(42).to_s(:hex)   #=> "0x2a"
+ *  Calc::Q(42).to_s(8)      #=> "52"
  */
 static VALUE
 cq_to_s(int argc, VALUE * argv, VALUE self)
@@ -2577,16 +2581,26 @@ cq_to_s(int argc, VALUE * argv, VALUE self)
     setup_math_error();
 
     args = rb_scan_args(argc, argv, "01", &mode);
-    math_divertio();
-    if (args == 0) {
-        qprintnum(qself, MODE_DEFAULT);
+    if (args == 1 && FIXNUM_P(mode)) {
+        if (qisint((NUMBER *) DATA_PTR(self))) {
+            rs = rb_funcall(cq_to_i(self), rb_intern("to_s"), 1, mode);
+        }
+        else {
+            rb_raise(rb_eArgError, "can't convert non-integer to string with base");
+        }
     }
     else {
-        qprintnum(qself, (int) value_to_mode(mode));
+        math_divertio();
+        if (args == 0) {
+            qprintnum(qself, MODE_DEFAULT);
+        }
+        else {
+            qprintnum(qself, (int) value_to_mode(mode));
+        }
+        s = math_getdivertedio();
+        rs = rb_str_new2(s);
+        free(s);
     }
-    s = math_getdivertedio();
-    rs = rb_str_new2(s);
-    free(s);
 
     return rs;
 }

data/lib/calc/c.rb

@@ -315,11 +315,11 @@ module Calc
 
     # Convert a wholly real number to an integer.
     #
-    # Note that the return value is a ruby Fixnum or Bignum.  If you want to
+    # Note that the return value is a ruby Integer.  If you want to
     # convert to an integer but have the result be a `Calc::Q` object, use
     # `trunc` or `round`.
     #
-    # @return [Fixnum,Bugnum]
+    # @return [Integer]
     # @raise [RangeError] if imaginary part is non-zero
     # @example
     #   Calc::C(2, 0).to_i #=> 2

data/lib/calc/numeric.rb

@@ -43,17 +43,22 @@ module Calc
     # For complex self, returns a complex number composed of the ceiling
     # of the real and imaginary parts separately.
     #
+    # If ndigits is present, the ceiling is calculated at the nth digit instead
+    # of returning an integer.
+    #
+    # @param ndigits [Integer]
     # @return [Calc::Q,Calc::C]
     # @example
     #   Calc::Q(1.23).ceil      #=> Calc::Q(2)
+    #   Calc::Q(1.23).ceil(1)   #=> Calc::Q(1.3)
     #   Calc::C(7.8, 9.1).ceil  #=> Calc::C(8+10i)
-    def ceil
-      appr(1, 1)
+    def ceil(ndigits = 0)
+      appr(Q.new(10)**-ndigits, 1)
     end
 
     # Division
     #
-    # This method exists for ruby compatibility.  Note that Fixnum#fdiv will
+    # This method exists for ruby compatibility.  Note that Integer#fdiv will
     # return a Float, however Q#div returns another Q.
     #
     # @param y [Numeric]
@@ -66,6 +71,16 @@ module Calc
       self / y
     end
 
+    # Returns true - calc values are always finite
+    #
+    # @return [true]
+    # @example
+    #   Calc::Q(1).finite?    #=> true
+    #   Calc::C(1, 1).finite? #=> true
+    def finite?
+      true
+    end
+
     # Floor
     #
     # For real self, returns the greatest integer not greater than self.
@@ -73,12 +88,16 @@ module Calc
     # For complex self, returns a complex number composed of the floor of the
     # real and imaginary parts separately.
     #
+    # If ndigits is present, the floor is calculated at the nth digit instead
+    # of returning an integer.
+    #
+    # @param ndigits [Integer]
     # @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)
+    def floor(ndigits = 0)
+      appr(Q.new(10)**-ndigits, 0)
     end
 
     # Floor of logarithm to base 10
@@ -109,6 +128,16 @@ module Calc
       ilog 2
     end
 
+    # Returns nil - calc values are never inifinite.
+    #
+    # @return [nil]
+    # @example
+    #   Calc::Q(1).infinite?    #=> nil
+    #   Calc::C(1, 1).infinite? #=> nil
+    def infinite?
+      nil
+    end
+
     # Returns 1 if self is an integer, otherwise 0.
     #
     # @return [Calc::Q]
@@ -187,11 +216,11 @@ module Calc
 
     # 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
+    # Note that the return value is a ruby Integer.  If you want to
     # convert to an integer but have the result be a `Calc::Q` object, use
     # `trunc` or `round`.
     #
-    # @return [Fixnum,Bignum]
+    # @return [Integer]
     # @raise [RangeError] if self is complex with non-zero imaginary part
     # @example
     #  Calc::Q("5/2").to_int #=> 2

data/lib/calc/q.rb

@@ -56,7 +56,7 @@ module Calc
 
     # Returns the number of bits in the integer part of `self`
     #
-    # Note that this is compatible with ruby's Fixnum#bit_length.  Libcalc
+    # Note that this is compatible with ruby's Integer#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
@@ -102,6 +102,14 @@ module Calc
       to_i.chr(*args)
     end
 
+    # if clamp has been inherited from <=>, make sure its return value is the
+    # correct class
+    if instance_methods.include?(:clamp)
+      def clamp(min, max)
+        super(Q.new(min), Q.new(max))
+      end
+    end
+
     # Complex conjugate
     #
     # As the conjugate of real x is x, this method returns self.
@@ -114,6 +122,26 @@ module Calc
     end
     alias conjugate conj
 
+    if 0.class.instance_methods.include?(:digits)
+      # Returns an array of digits in base b making up self
+      #
+      # This is compatible with ruby's `Integer#digits`.  Note that `Q#digits`
+      # implements the libcalc function `digits`, which is different.  Any
+      # fractional part of self is truncated.
+      #
+      # Requires ruby 2.4.
+      #
+      # @param b [Integer] (optional) base, default 10
+      # @return [Array]
+      # @example
+      #   Calc::Q(1234).digits_r      #=> [Calc::Q(4), Calc::Q(3), Calc::Q(2), Calc::Q(1)]
+      #   Calc::Q(1234).digits_r(7)   #=> [Calc::Q(2), Calc::Q(1), Calc::Q(4), Calc::Q(3)]
+      #   Calc::Q(1234).digits_r(100) #=> [Calc::Q(34), Calc::Q(12)]
+      def digits_r(b = 10)
+        to_i.digits(b).map { |d| Q.new(d) }
+      end
+    end
+
     # Ruby compatible integer division
     #
     # Calls `quo` to get the quotient of integer division, with rounding mode
@@ -363,7 +391,7 @@ module Calc
 
     # Return true if `self` is less than zero.
     #
-    # This method exists for ruby Fixnum/Rational compatibility
+    # This method exists for ruby Integer/Rational compatibility
     #
     # @return [Boolean]
     # @example
@@ -385,7 +413,7 @@ module Calc
 
     # Return true if `self` is greater than zero.
     #
-    # This method exists for ruby Fixnum/Rational compatibility
+    # This method exists for ruby Integer/Rational compatibility
     #
     # @return [Boolean]
     # @example
@@ -398,7 +426,7 @@ module Calc
 
     # Returns one less than self.
     #
-    # This method exists for ruby Fixnum/Integer compatibility.
+    # This method exists for ruby Integer compatibility.
     #
     # @return [Calc::Q]
     # @example
@@ -530,7 +558,7 @@ module Calc
 
     # Returns one more than self.
     #
-    # This method exists for ruby Fixnum/Integer compatibility.
+    # This method exists for ruby Integer compatibility.
     #
     # @return [Calc::Q]
     # @example
@@ -620,7 +648,7 @@ module Calc
       args.inject(self, :^)
     end
 
-    # aliases for compatibility with ruby Fixnum/Bignum/Rational
+    # aliases for compatibility with ruby Integer/Rational
     alias imag im
     alias integer? int?
     alias real re

data/lib/calc/version.rb

@@ -1,3 +1,3 @@
 module Calc
-  VERSION = "0.1.0".freeze
+  VERSION = "0.2.0".freeze
 end

data/ruby-calc.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = "Ruby bindings for calc"
   spec.description   = "Ruby bindings for calc, an arbitrary precision maths library.  ruby-calc provides access to a the large number of mathematical functions that come with calc."
-  spec.homepage      = "https://github.com/timpeters/ruby-calc"
+  spec.homepage      = "https://github.com/timocp/ruby-calc"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f[/^(test|spec|features)/] }
@@ -19,6 +19,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
   spec.extensions    = ["ext/calc/extconf.rb"]
+  spec.required_ruby_version = "~> 2.0"
 
   spec.add_development_dependency "bundler", "~> 1.8"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-calc
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Tim Peters
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-28 00:00:00.000000000 Z
+date: 2016-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -114,6 +114,7 @@ files:
 - ".rubocop_todo.yml"
 - ".travis.yml"
 - ".yardopts"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -139,7 +140,7 @@ files:
 - lib/calc/q.rb
 - lib/calc/version.rb
 - ruby-calc.gemspec
-homepage: https://github.com/timpeters/ruby-calc
+homepage: https://github.com/timocp/ruby-calc
 licenses:
 - MIT
 metadata: {}
@@ -149,9 +150,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="