primitive_wrapper 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de77195e3edaeb4ddf58d6e33c1fd88b26e9fc69
-  data.tar.gz: 5c1dc0e6730a024aa6953ba29e7333185349a2ab
+  metadata.gz: 6aa5f4b217c6e6eddf82f17d5b062a125acbec26
+  data.tar.gz: e0ac33dd51b163d938c3821c0908690548529902
 SHA512:
-  metadata.gz: 26ea44e1849e51f79624f1294131bf60f1df83274408b9375293ca3877dc56d3ce93b0d725f3587a6b62b1508fc21cae4e90e3e768da96beee1daa3697e90c46
-  data.tar.gz: d17ed816653cc2a496279238ef5ef95cdf3ee537b464e0ef06d7ceec437f786641e7544a8f0fb3cd91aa6f78387499838c637a1f3cbdc4f8ecacdf91374b952a
+  metadata.gz: 047242da1920d239a5ee10d942d2246647f625f87985bd2faf78eddc34897224550f14ce020a8828e1a06f8a2f03dcf0cd09757438ab305aeeba7541b7cf1483
+  data.tar.gz: e824f363837b937dc44311930562a32ab05dbc8c128f7aefdfe7491f4264bc3b09f2a317ae610533fdb8bca1c20c019844c3ec20ad6c6cc739eac9ccf5193b90

data/README.md

@@ -105,6 +105,7 @@ Hash         =>   Property
 String       =>   Datum
 Array        =>   XArray
 Range        =>   XRange
+Rational     =>   Fraction  
 ```
 
 Some examples are as follows:
@@ -301,6 +302,43 @@ This works just like the other specific number wrappers previously described.
 The `Datum` container holds everything a `Number` can hold and allows `String` data to be added. This represents things that a human can type into a form as a general data thing.
 The methods of `String` are also added. Errors will occur if you try to call string methods on a `Datum` that is holding a number and visa versa.
 
+#### Fraction class container
+
+The `Fraction` container holds a `Rational` primitive. All the methods of `Rational` are mimicked with some important modifications.
+All operators of `Fraction` return a `Fraction` type. Note that `Rational` types when operated with `Float` types will return `Float` types.
+The mutating methods of the `Value` base class as well as some new mutating methods have also been added.
+The constructor can take 1 to 3 parameters. The main idea behind this wrapper is to support mixed fractions as well as proper fractions.
+See below:
+
+```ruby
+# Construction:  mixed fractions using 3 parameters
+frac = Fraction.new(3,4,5)   # frac.inspect == "(Fraction==>(19/5))"  ... frac.to_s == "(3 4/5)"  ... frac.to_s(false) == "3 4/5"
+frac = Fraction(5,6,7)       # shorter function call   ... (Fraction==>(41/7))
+frac = Fraction(-5,-6,7)     # negative                ... (Fraction==>(-41/7))
+# note: always negate first two parameters to define negative fractions
+
+# Construction:  proper fractions using 2 parameters
+frac = Fraction(27,7)            # frac.inspect == "(Fraction==>(27/7))" ... frac.to_s false == "3 6/7"
+
+# Construction:  using float with/without approximation
+frac = Fraction(Math::PI, 0.1)      # fract.inspect == "(Fraction==>(22/7))"  ... second parameter => percent error
+frac = Fraction(Math::PI, 0.0001)   # fract.inspect == "(Fraction==>(355/113))" 
+frac = Fraction(Math::PI)           # fract.inspect == "(Fraction==>(884279719003555/281474976710656))"
+frac = Math::PI.to_fraction(0.0001) # (Fraction==>(355/113))
+frac = Math::PI.to_fraction         # (Fraction==>(884279719003555/281474976710656))
+# note: Rational does not have approximate construction
+
+# mutating methods:
+frac = Math::PI.to_fraction(0.0001)
+frac.negate!      # make negative
+frac.to_s(false)  # "-3 -16/113"  ... note: true add parenthesis, false removes parenthesis
+frac.abs!         # make positive
+frac.to_s(false)  # "3 16/113"
+frac.to_r.to_s    # "355/113"     ... convert to rational, then to string for proper fraction
+frac *= 113       # (Fraction==>(355/1))  ... operators return type of Fraction
+frac.to_s         # 355   ... no parenthesis if whole number           
+```
+
 #### SymbolW class container
 
 The `SymbolW` class container holds a `Symbol` primitive. It derives directly from `Value`.
@@ -444,7 +482,7 @@ Below is a list of what has changed:
 
 This creates a wrapped `Array` with behavior that enhances the access operators of `Array`;
 additionally a few new methods were added to the wrapped version as well as the original `Array` class.
-`XArray` mimics the behavior of `Array` but redefines `:[]` and `:[]=` to include lists wich comprise indexes, ranges, and arrays of indexes.
+`XArray` mimics the behavior of `Array` but redefines `:[]` and `:[]=` to include lists which comprise indexes, ranges, and arrays of indexes.
 There is also behavior that defines many-to-one, one-to-many, and many-to-many operations. Note that one-to-one behavior has not changed.
 An example best explains how this works:
 
@@ -574,21 +612,25 @@ This can be mostly a matter of taste, but we can choose custom names that convey
 So it is left to you to decide.
 
 ## Revision History
+
+### Version 2.1.0
+* Added Fraction wrapper for Rational types
+
 ### Version 2.0.0
-* fixed Range reversals defined with excluded end
-* added #type to Object, Value
-* added #simple? to Range, XRange
+* Fixed Range reversals defined with excluded end
+* Added #type to Object, Value
+* Added #simple? to Range, XRange
 
 ### Version 1.0.1
-* updated documentation to include undocumented methods
-* fixed XArray `#delete_at` bugs
+* Updated documentation to include undocumented methods
+* Fixed XArray `#delete_at` bugs
 
 ### Version 1.0.0
-* fixed wrapper inside wrapper causing stack overflow
+* Fixed wrapper inside wrapper causing stack overflow
 * Documentation updates
 * Added new wrappers for Range, Array as XRange and XArray
-* added primitive methods
-* added Value methods, and enhanced other derived wrappers
+* Added primitive methods
+* Added Value methods, and enhanced other derived wrappers
 
 ## Development
 

data/lib/primitive_wrapper.rb

@@ -34,6 +34,7 @@ class Object
     return Property.new(self) if self.kind_of? Hash
     return XArray.new(self) if self.kind_of? Array
     return XRange.new(self) if self.kind_of? Range
+    return Fraction.new(self) if self.kind_of? Rational
     return Value.new(self)
   end
 end
@@ -717,6 +718,166 @@ class Property < Value
   end
 end
 
+class Fraction < ValueAdd
+  capture_base_methods(Rational)
+  
+  def coerce(other)
+    [Fraction.new(other.prim_value), self.prim_value]
+  end  
+  
+  def self.approximate_by_float(p1, pcnt=nil)
+    return Fraction.new(p1.prim_value) if pcnt.nil?
+    pcnt/= 100.0
+    neg = p1.negative?
+    p1=p1.abs
+    if p1 >=1.0
+      top = p1.floor
+      bot = 1
+    else
+      top = 1
+      bot = (1/p1).floor
+    end
+    loop do
+      app = top.to_f/bot.to_f
+      tst = (app - p1).abs/p1
+      break if tst < pcnt
+      if app > p1
+        bot += 1
+      else
+        top += 1
+      end        
+    end
+    return Fraction.new(top.prim_value,bot.prim_value)
+  end
+
+  def initialize(*prms)
+    #obj = obj.prim_value
+    #ensure_valid(obj)
+    #@value = obj
+    if 1==prms.count
+      @value = Rational(prms[0].prim_value)
+    elsif 2==prms.count
+      if prms[0].type_of? Float
+        fract = self.class.approximate_by_float(prms[0].prim_value,prms[1].prim_value)
+        @value = fract.prim_value
+      else
+        @value = Rational(prms[0].prim_value,prms[1].prim_value)
+      end
+      
+    elsif 3==prms.count
+      @value = Rational(prms[1].prim_value,prms[2].prim_value) + prms[0].prim_value
+    else
+      raise("expected 1..3 parameters")
+    end
+  end
+  
+  def replace(other)    
+    @value = Rational(other.prim_value)
+  end
+  
+  def abs!
+    @value = @value.abs
+    self
+  end
+
+  def negate!
+    @value = -@value.abs
+    self
+  end
+  
+  def +(other)
+    Fraction.new(@value + other)
+  end
+
+  def -(other)
+    Fraction.new(@value - other)
+  end
+
+  def *(other)
+    Fraction.new(@value * other)
+  end
+  
+  def **(other)
+    Fraction.new(@value ** other)
+  end
+
+  def %(other)
+    Fraction.new(@value % other)
+  end
+
+  def /(other)
+    Fraction.new(@value / other)
+  end
+
+  def +@
+    Fraction.new(@value)
+  end
+
+  def -@
+    Fraction.new(-@value)
+  end
+  
+  def to_fraction
+    self
+  end
+
+  def to_s(paren=true)
+    return @value.numerator if @value.denominator==1
+    if @value.numerator.abs < @value.denominator
+      if paren
+        return "(#{@value.numerator}/#{@value.denominator})"
+      else
+        return "#{@value.numerator}/#{@value.denominator}"
+      end    
+    end    
+    if @value.negative?
+      rat = -@value
+      whole, rem = rat.numerator.divmod rat.denominator
+      if paren
+        return "(-#{whole} -#{rem}/#{@value.denominator})"
+      else
+        return "-#{whole} -#{rem}/#{@value.denominator}"
+      end
+      
+    end
+    whole, rem = @value.numerator.divmod @value.denominator
+    if paren
+      return "(#{whole} #{rem}/#{@value.denominator})"
+    else
+      return "#{whole} #{rem}/#{@value.denominator}"
+    end
+  end
+  
+  def valid_type(prm)
+    return true
+  end
+  
+end
+
+module Kernel
+  def Fraction(*prms)
+    Fraction.new(*prms)
+  end
+end
+
+class Integer
+  def to_fraction
+    Fraction.new(self)
+  end
+end
+
+class Float
+  def to_fraction(pcnt=nil)
+    Fraction.approximate_by_float(self, pcnt)
+  end
+end
+
+class Rational
+  def to_fraction
+    Fraction.new(self)
+  end
+end
+
 class XRange < ValueAdd
   capture_base_methods(Range)
   def valid_type(prm)

data/lib/primitive_wrapper/version.rb

@@ -2,6 +2,8 @@
 # note that there is no exclude start, so reversing will require recalculation or simplification
 #  ... put this on the back burner for now
 
+# adding rational to fraction
+
 module PrimitiveWrapper
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end

data/primitive_wrapper.gemspec

@@ -20,7 +20,8 @@ What is interesting to note is Number objects do not derive from `Numeric`, but
 but at the same time, `Number` objects mimic the methods of `Fixnum`, `Complex`, `Float`, etc.
 Many of the wrappers can be used in an expression without having to call an access method.
 There are also new types: `Bool` which wraps `true,false` and `Property` which wraps `Hash` types.
-The `Property` object auto-methodizes the key names of the Hash.}
+The `Property` object auto-methodizes the key names of the Hash.
+Also `Fraction` supports mixed fractions.}
 
   spec.license       = "MIT"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: primitive_wrapper
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Bryan Colvin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-20 00:00:00.000000000 Z
+date: 2018-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: blockify
@@ -144,6 +144,7 @@ description: |-
   Many of the wrappers can be used in an expression without having to call an access method.
   There are also new types: `Bool` which wraps `true,false` and `Property` which wraps `Hash` types.
   The `Property` object auto-methodizes the key names of the Hash.
+  Also `Fraction` supports mixed fractions.
 email:
 - bryan@bdlsys.com
 executables: []