enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-rational/test/rational.rb

@@ -0,0 +1,316 @@
+def assert_rational(exp, real)
+  assert "assert_rational" do
+    assert_kind_of Rational, real
+    assert_float exp.numerator,   real.numerator
+    assert_float exp.denominator, real.denominator
+  end
+end
+
+def assert_equal_rational(exp, o1, o2)
+  assert "assert_equal_rational" do
+    if exp
+      assert_operator(o1, :==, o2)
+      assert_not_operator(o1, :!=, o2)
+    else
+      assert_not_operator(o1, :==, o2)
+      assert_operator(o1, :!=, o2)
+    end
+  end
+end
+
+def assert_cmp(exp, o1, o2)
+  if exp == (o1 <=> o2)
+    pass
+  else
+    flunk "", "    Expected #{o1.inspect} <=> #{o2.inspect} to be #{exp}."
+  end
+end
+
+def assert_complex(real, imag)
+  if Object.const_defined?(:Complex)
+    assert "assert_complex" do
+      c = yield
+      assert_float(real, c.real)
+      assert_float(imag, c.imaginary)
+    end
+  end
+end
+
+assert 'Rational' do
+  r = 5r
+  assert_equal(Rational, r.class)
+  assert_equal([5, 1], [r.numerator, r.denominator])
+end
+
+assert 'Kernel#Rational' do
+  r = Rational(4,10)
+  assert_equal(2, r.numerator)
+  assert_equal(5, r.denominator)
+
+  r = Rational(3)
+  assert_equal(3, r.numerator)
+  assert_equal(1, r.denominator)
+
+  assert_raise(ArgumentError) { Rational() }
+  assert_raise(ArgumentError) { Rational(1,2,3) }
+end
+
+assert 'Rational#to_f' do
+  assert_float(2.0, Rational(2).to_f)
+  assert_float(2.25, Rational(9, 4).to_f)
+  assert_float(-0.75, Rational(-3, 4).to_f)
+  assert_float(6.666666666666667, Rational(20, 3).to_f)
+end
+
+assert 'Rational#to_i' do
+  assert_equal(0, Rational(2, 3).to_i)
+  assert_equal(3, Rational(3).to_i)
+  assert_equal(300, Rational(300.6).to_i)
+  assert_equal(1, Rational(98, 71).to_i)
+  assert_equal(-15, Rational(-30, 2).to_i)
+end
+
+assert 'Rational#*' do
+  assert_rational(Rational(4, 9),    Rational(2, 3)  * Rational(2, 3))
+  assert_rational(Rational(900, 1),  Rational(900)   * Rational(1))
+  assert_rational(Rational(1, 1),    Rational(-2, 9) * Rational(-9, 2))
+  assert_rational(Rational(9, 2),    Rational(9, 8)  * 4)
+  assert_float(   21.77777777777778, Rational(20, 9) * 9.8)
+  assert_float(   21.77777777777778, 9.8 * Rational(20, 9))
+  assert_complex(5.2, 2.6) {Rational(13,5)*(2.0+1i)}
+  assert_complex(5.2, 2.6) {(2.0+1i)*Rational(13,5)}
+end
+
+assert 'Rational#+' do
+  assert_rational(Rational(4, 3),     Rational(2, 3)  + Rational(2, 3))
+  assert_rational(Rational(901, 1),   Rational(900)   + Rational(1))
+  assert_rational(Rational(-85, 18),  Rational(-2, 9) + Rational(-9, 2))
+  assert_rational(Rational(41, 8),    Rational(9, 8)  + 4)
+  assert_rational(Rational(41, 8),    4 + Rational(9, 8))
+  assert_float(   12.022222222222222, Rational(20, 9) + 9.8)
+  assert_float(   12.022222222222222, 9.8 + Rational(20, 9))
+  assert_complex(24.0, 0) {Rational(24,2)+(12.0+0i)}
+  assert_complex(24.0, 0) {(12.0+0i)+Rational(24,2)}
+end
+
+assert 'Rational#-' do
+  assert_rational(Rational(0, 1),     Rational(2, 3)  - Rational(2, 3))
+  assert_rational(Rational(899, 1),   Rational(900)   - Rational(1))
+  assert_rational(Rational(77, 18),   Rational(-2, 9) - Rational(-9, 2))
+  assert_rational(Rational(23, 8),    4 - Rational(9, 8))
+  assert_float(   -7.577777777777778, Rational(20, 9) - 9.8)
+  assert_float(    7.577777777777778, 9.8 - Rational(20, 9))
+  assert_complex(2.0, 0) {Rational(24,2)-(10.0+0i)}
+  assert_complex(2.0, 0) {(14.0+0i)-Rational(24,2)}
+end
+
+assert 'Rational#/' do
+  assert_rational(Rational(1, 1),      Rational(2, 3)  / Rational(2, 3))
+  assert_rational(Rational(900, 1),    Rational(900)   / Rational(1))
+  assert_rational(Rational(4, 81),     Rational(-2, 9) / Rational(-9, 2))
+  assert_rational(Rational(9, 32),     Rational(9, 8)  / 4)
+  assert_rational(Rational(32, 9),     4 / Rational(9, 8))
+  assert_float(   0.22675736961451246, Rational(20, 9) / 9.8)
+  assert_float(   4.41,                9.8 / Rational(20, 9))
+  assert_complex(1.92, 1.44) {Rational(24,2)/(4.0-3i)}
+  assert_complex(0.25, 0.25) {(3.0+3i)/Rational(24,2)}
+end
+
+assert 'Rational#==, Rational#!=' do
+  assert_equal_rational(true, Rational(1,1), Rational(1))
+  assert_equal_rational(true, Rational(-1,1), -1r)
+  assert_equal_rational(true, Rational(13,4), 3.25)
+  assert_equal_rational(true, Rational(13,3.25), Rational(4,1))
+  assert_equal_rational(true, Rational(-3,-4), Rational(3,4))
+  assert_equal_rational(true, Rational(-4,5), Rational(4,-5))
+  assert_equal_rational(true, Rational(4,2), 2)
+  assert_equal_rational(true, Rational(-4,2), -2)
+  assert_equal_rational(true, Rational(4,-2), -2)
+  assert_equal_rational(true, Rational(4,2), 2.0)
+  assert_equal_rational(true, Rational(-4,2), -2.0)
+  assert_equal_rational(true, Rational(4,-2), -2.0)
+  assert_equal_rational(true, Rational(8,6), Rational(4,3))
+  assert_equal_rational(false, Rational(13,4), 3)
+  assert_equal_rational(false, Rational(13,4), 3.3)
+  assert_equal_rational(false, Rational(2,1), 1r)
+  assert_equal_rational(false, Rational(1), nil)
+  assert_equal_rational(false, Rational(1), '')
+end
+
+assert 'Integer#==(Rational), Integer#!=(Rational)' do
+  assert_equal_rational(true, 2, Rational(4,2))
+  assert_equal_rational(true, -2, Rational(-4,2))
+  assert_equal_rational(true, -2, Rational(4,-2))
+  assert_equal_rational(false, 3, Rational(13,4))
+end
+
+assert 'Float#==(Rational), Float#!=(Rational)' do
+  assert_equal_rational(true, 2.0, Rational(4,2))
+  assert_equal_rational(true, -2.0, Rational(-4,2))
+  assert_equal_rational(true, -2.0, Rational(4,-2))
+  assert_equal_rational(false, 3.3, Rational(13,4))
+end
+
+assert 'Rational#<=>' do
+  assert_cmp(-1, Rational(-1), Rational(0))
+  assert_cmp(0, Rational(0), Rational(0))
+  assert_cmp(1, Rational(1), Rational(0))
+  assert_cmp(-1, Rational(-1), 0)
+  assert_cmp(0, Rational(0), 0)
+  assert_cmp(1, Rational(1), 0)
+  assert_cmp(-1, Rational(-1), 0.0)
+  assert_cmp(0, Rational(0), 0.0)
+  assert_cmp(1, Rational(1), 0.0)
+  assert_cmp(-1, Rational(1,2), Rational(2,3))
+  assert_cmp(0, Rational(2,3), Rational(2,3))
+  assert_cmp(1, Rational(2,3), Rational(1,2))
+  assert_cmp(1, Rational(2,3), Rational(1,2))
+  assert_cmp(1, Rational(0), Rational(-1))
+  assert_cmp(-1, Rational(0), Rational(1))
+  assert_cmp(1, Rational(2,3), Rational(1,2))
+  assert_cmp(0, Rational(2,3), Rational(2,3))
+  assert_cmp(-1, Rational(1,2), Rational(2,3))
+  assert_cmp(-1, Rational(1,2), Rational(2,3))
+  assert_cmp(nil, 3r, "3")
+end
+
+assert 'Integer#<=>(Rational)' do
+  assert_cmp(-1, -2, Rational(-9,5))
+  assert_cmp(0, 5, 5r)
+  assert_cmp(1, 3, Rational(8,3))
+end
+
+assert 'Float#<=>(Rational)' do
+  assert_cmp(-1, -2.1, Rational(-9,5))
+  assert_cmp(0, 5.0, 5r)
+  assert_cmp(1, 2.7, Rational(8,3))
+end
+
+assert 'Rational#<' do
+  assert_operator(Rational(1,2), :<, Rational(2,3))
+  assert_not_operator(Rational(2,3), :<, Rational(2,3))
+  assert_operator(Rational(2,3), :<, 1)
+  assert_not_operator(2r, :<, 2)
+  assert_not_operator(Rational(2,3), :<, -3)
+  assert_operator(Rational(-4,3), :<, -0.3)
+  assert_not_operator(Rational(13,4), :<, 3.25)
+  assert_not_operator(Rational(2,3), :<, 0.6)
+  assert_raise(ArgumentError) { 1r < "2" }
+end
+
+assert 'Integer#<(Rational)' do
+  assert_not_operator(1, :<, Rational(2,3))
+  assert_not_operator(2, :<, 2r)
+  assert_operator(-3, :<, Rational(2,3))
+end
+
+assert 'Float#<(Rational)' do
+  assert_not_operator(-0.3, :<, Rational(-4,3))
+  assert_not_operator(3.25, :<, Rational(13,4))
+  assert_operator(0.6, :<, Rational(2,3))
+end
+
+assert 'Rational#<=' do
+  assert_operator(Rational(1,2), :<=, Rational(2,3))
+  assert_operator(Rational(2,3), :<=, Rational(2,3))
+  assert_operator(Rational(2,3), :<=, 1)
+  assert_operator(2r, :<=, 2)
+  assert_not_operator(Rational(2,3), :<=, -3)
+  assert_operator(Rational(-4,3), :<=, -0.3)
+  assert_operator(Rational(13,4), :<=, 3.25)
+  assert_not_operator(Rational(2,3), :<=, 0.6)
+  assert_raise(ArgumentError) { 1r <= "2" }
+end
+
+assert 'Integer#<=(Rational)' do
+  assert_not_operator(1, :<=, Rational(2,3))
+  assert_operator(2, :<=, 2r)
+  assert_operator(-3, :<=, Rational(2,3))
+end
+
+assert 'Float#<=(Rational)' do
+  assert_not_operator(-0.3, :<=, Rational(-4,3))
+  assert_operator(3.25, :<=, Rational(13,4))
+  assert_operator(0.6, :<=, Rational(2,3))
+end
+
+assert 'Rational#>' do
+  assert_not_operator(Rational(1,2), :>, Rational(2,3))
+  assert_not_operator(Rational(2,3), :>, Rational(2,3))
+  assert_not_operator(Rational(2,3), :>, 1)
+  assert_not_operator(2r, :>, 2)
+  assert_operator(Rational(2,3), :>, -3)
+  assert_not_operator(Rational(-4,3), :>, -0.3)
+  assert_not_operator(Rational(13,4), :>, 3.25)
+  assert_operator(Rational(2,3), :>, 0.6)
+  assert_raise(ArgumentError) { 1r > "2" }
+end
+
+assert 'Integer#>(Rational)' do
+  assert_operator(1, :>, Rational(2,3))
+  assert_not_operator(2, :>, 2r)
+  assert_not_operator(-3, :>, Rational(2,3))
+end
+
+assert 'Float#>(Rational)' do
+  assert_operator(-0.3, :>, Rational(-4,3))
+  assert_not_operator(3.25, :>, Rational(13,4))
+  assert_not_operator(0.6, :>, Rational(2,3))
+end
+
+assert 'Rational#>=' do
+  assert_not_operator(Rational(1,2), :>=, Rational(2,3))
+  assert_operator(Rational(2,3), :>=, Rational(2,3))
+  assert_not_operator(Rational(2,3), :>=, 1)
+  assert_operator(2r, :>=, 2)
+  assert_operator(Rational(2,3), :>=, -3)
+  assert_not_operator(Rational(-4,3), :>=, -0.3)
+  assert_operator(Rational(13,4), :>=, 3.25)
+  assert_operator(Rational(2,3), :>=, 0.6)
+  assert_raise(ArgumentError) { 1r >= "2" }
+end
+
+assert 'Integer#>=(Rational)' do
+  assert_operator(1, :>=, Rational(2,3))
+  assert_operator(2, :>=, 2r)
+  assert_not_operator(-3, :>=, Rational(2,3))
+end
+
+assert 'Float#>=(Rational)' do
+  assert_operator(-0.3, :>=, Rational(-4,3))
+  assert_operator(3.25, :>=, Rational(13,4))
+  assert_not_operator(0.6, :>=, Rational(2,3))
+end
+
+assert 'Rational#negative?' do
+  assert_predicate(Rational(-2,3), :negative?)
+  assert_predicate(Rational(2,-3), :negative?)
+  assert_not_predicate(Rational(2,3), :negative?)
+  assert_not_predicate(Rational(0), :negative?)
+end
+
+assert 'Rational#frozen?' do
+  assert_predicate(1r, :frozen?)
+  assert_predicate(Rational(2,3), :frozen?)
+  assert_predicate(4/5r, :frozen?)
+end
+
+assert 'Rational#**' do
+  assert_rational(1r, (14/2r)**0)
+  assert_rational(14/2r, (14/2r)**1)
+  assert_rational(49r, (14/2r)**2)
+  assert_rational(27r, (6/2r)**3)
+  assert_float(2.0, (4r)**(1/2r))
+  assert_rational(4r, (4r)**(2/2r))
+  assert_rational(16r, (4r)**(4/2r))
+  assert_float(1.0, (4r)**(0.0))
+  assert_float(2.0, (4r)**(0.5))
+  assert_float(4.0, (4r)**(1.0))
+  assert_float(16.0, (4r)**(2.0))
+  assert_float(3.5**1.5, (7/2r)**(1.5))
+end
+
+assert 'Integer#quo' do
+  a = 6.quo(5)
+  assert_equal 6/5r, a
+end

data/ext/enclave/mruby/mrbgems/mruby-set/LICENSE

@@ -0,0 +1,24 @@
+mruby-set
+
+Copyright (c) yui-knk 2016
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+[ MIT license: http://www.opensource.org/licenses/mit-license.php ]

data/ext/enclave/mruby/mrbgems/mruby-set/README.md

@@ -0,0 +1,260 @@
+# mruby-set
+
+`mruby-set` provides a `Set` class for mruby, offering a collection of unordered, unique elements. It's useful when you need to store a group of items and quickly check for membership, or perform set operations like union, intersection, and difference.
+
+## Installation
+
+To use `mruby-set` in your mruby project, add the following to your `build_config.rb`:
+
+```ruby
+conf.gem "#{MRUBY_ROOT}/mrbgems/mruby-set"
+```
+
+Or, if you have it as a separate gem:
+
+```ruby
+conf.gem :github => "mruby/mruby-set"
+```
+
+## Usage and Examples
+
+### Creating a Set
+
+You can create a set from an array or by using the `Set.[]` shorthand:
+
+```ruby
+require 'set' # Not strictly necessary in mruby if compiled in
+
+set1 = Set.new([1, 2, 3])
+#=> Set[1, 2, 3]
+
+set2 = Set[3, 4, 5]
+#=> Set[3, 4, 5]
+```
+
+### Adding and Deleting Elements
+
+```ruby
+s = Set.new
+s.add(10)    #=> Set[10]
+s << 20      #=> Set[10, 20]
+s.add?(30)   #=> Set[10, 20, 30]
+s.add?(20)   #=> nil (20 is already in the set)
+
+s.delete(10) #=> Set[20, 30]
+s.delete?(5) #=> nil (5 was not in the set)
+s.delete?(20) #=> Set[30]
+```
+
+### Set Operations
+
+`mruby-set` supports common set operations:
+
+**Union (`|`, `+`, `union`):** Returns a new set containing all elements from both sets.
+
+```ruby
+set_a = Set[1, 2, 3]
+set_b = Set[3, 4, 5]
+
+set_a | set_b  #=> Set[1, 2, 3, 4, 5]
+set_a + set_b  #=> Set[1, 2, 3, 4, 5]
+```
+
+**Intersection (`&`, `intersection`):** Returns a new set containing elements common to both sets.
+
+```ruby
+set_a = Set[1, 2, 3]
+set_b = Set[3, 4, 5]
+
+set_a & set_b  #=> Set[3]
+```
+
+**Difference (`-`, `difference`):** Returns a new set containing elements from the first set that are not in the second set.
+
+```ruby
+set_a = Set[1, 2, 3]
+set_b = Set[3, 4, 5]
+
+set_a - set_b  #=> Set[1, 2]
+```
+
+**Exclusive OR (`^`):** Returns a new set containing elements that are in one or the other of the sets, but not in both.
+
+```ruby
+set_a = Set[1, 2, 3]
+set_b = Set[3, 4, 5]
+
+set_a ^ set_b  #=> Set[1, 2, 4, 5]
+```
+
+### Querying the Set
+
+**Checking for inclusion (`include?`, `member?`, `===`):**
+
+```ruby
+s = Set["apple", "banana", "cherry"]
+s.include?("banana")  #=> true
+s.member?("grape")    #=> false
+```
+
+**Checking size (`size`, `length`):**
+
+```ruby
+s = Set[10, 20, 30]
+s.size #=> 3
+```
+
+**Checking if empty (`empty?`):**
+
+```ruby
+Set.new.empty? #=> true
+Set[1].empty?  #=> false
+```
+
+**Subset and Superset (`subset?`, `superset?`, `<`, `<=`, `>`, `>=`):**
+
+```ruby
+set_main = Set[1, 2, 3, 4]
+sub = Set[2, 3]
+super_set = Set[1, 2, 3, 4, 5]
+
+sub.subset?(set_main)         #=> true
+set_main.superset?(sub)       #=> true
+set_main < super_set          #=> true (proper subset)
+super_set > set_main          #=> true (proper superset)
+Set[1,2].proper_subset?(Set[1,2,3]) #=> true
+Set[1,2,3].proper_superset?(Set[1,2]) #=> true
+```
+
+**Disjoint (`disjoint?`):** Returns `true` if the set has no elements in common with the given set.
+
+```ruby
+Set[1, 2].disjoint?(Set[3, 4]) #=> true
+Set[1, 2].disjoint?(Set[2, 3]) #=> false
+```
+
+**Intersect (`intersect?`):** Returns `true` if the set has any elements in common with the given set.
+
+```ruby
+Set[1, 2].intersect?(Set[2, 3]) #=> true
+Set[1, 2].intersect?(Set[3, 4]) #=> false
+```
+
+### Other Useful Methods
+
+**Convert to Array (`to_a`):**
+
+```ruby
+s = Set["a", "b", "c"]
+s.to_a #=> ["a", "b", "c"] (order may vary)
+```
+
+**Iterating (`each`):**
+
+```ruby
+s = Set[1, 2, 3]
+s.each { |x| puts x * 10 }
+# Output:
+# 10
+# 20
+# 30
+```
+
+**Map/Collect (`map!`, `collect!`):** Modifies the set by applying the block to each element.
+
+```ruby
+s = Set[1, 2, 3]
+s.map! { |x| x * x } #=> Set[1, 4, 9]
+```
+
+**Select/Filter (`select!`, `filter!`):** Keeps elements for which the block returns true.
+
+```ruby
+s = Set[1, 2, 3, 4, 5]
+s.select! { |x| x.even? } #=> Set[2, 4]
+```
+
+**Reject (`reject!`):** Deletes elements for which the block returns true.
+
+```ruby
+s = Set[1, 2, 3, 4, 5]
+s.reject! { |x| x.odd? } #=> Set[2, 4]
+```
+
+**Clear (`clear`):** Removes all elements from the set.
+
+```ruby
+s = Set[1, 2, 3]
+s.clear #=> Set[]
+```
+
+**Replace (`replace`):** Replaces the contents of the set with the contents of the given enumerable.
+
+```ruby
+s = Set[1, 2, 3]
+s.replace([4, 5]) #=> Set[4, 5]
+```
+
+**Flatten (`flatten`, `flatten!`):** Returns a new set that is a copy of the set, flattening any nested sets. `flatten!` modifies the set in place.
+
+```ruby
+s = Set[1, Set[2, 3], 4]
+s.flatten #=> Set[1, 2, 3, 4]
+```
+
+## Method Overview
+
+Here's a list of commonly used methods available in `mruby-set`:
+
+- `Set.[](*ary)`
+- `initialize(enum = nil, &block)`
+- `size`, `length`
+- `empty?`
+- `clear`
+- `replace(enum)`
+- `to_a`
+- `include?(o)`, `member?(o)`, `===`
+- `superset?(set)`, `>=`
+- `proper_superset?(set)`, `>`
+- `subset?(set)`, `<=`
+- `proper_subset?(set)`, `<`
+- `intersect?(set)`
+- `disjoint?(set)`
+- `each(&block)`
+- `add(o)`, `<<(o)`
+- `add?(o)`
+- `delete(o)`
+- `delete?(o)`
+- `delete_if { |o| ... }`
+- `keep_if { |o| ... }`
+- `collect! { |o| ... }`, `map! { |o| ... }`
+- `reject! { |o| ... }`
+- `select! { |o| ... }`, `filter! { |o| ... }`
+- `merge(enum)`
+- `subtract(enum)`
+- `|(enum)`, `+(enum)`, `union(enum)`
+- `-(enum)`, `difference(enum)`
+- `&(enum)`, `intersection(enum)`
+- `^(enum)`
+- `==(other)`
+- `hash`
+- `eql?(o)`
+- `classify { |o| ... }`
+- `divide(&func)`
+- `join(separator = nil)`
+- `inspect`, `to_s`
+- `flatten`, `flatten!`
+
+## Limitations
+
+These methods are not implemented yet:
+
+- freeze
+- to_set
+- divide(Set#divide with 2 arity block is not implemented.)
+
+## License
+
+Under the MIT License:
+
+- see [LICENSE](LICENSE) file

data/ext/enclave/mruby/mrbgems/mruby-set/mrbgem.rake

@@ -0,0 +1,9 @@
+MRuby::Gem::Specification.new('mruby-set') do |spec|
+  spec.license = 'MIT'
+  spec.authors = 'yui-knk'
+  spec.summary = 'Set class'
+  spec.build.defines << "MRB_USE_SET"
+
+  spec.add_dependency "mruby-hash-ext", :core => "mruby-hash-ext"
+  spec.add_dependency "mruby-enumerator", :core => "mruby-enumerator"
+end