enclave 0.1.0

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

@@ -0,0 +1,174 @@
+def assert_complex(real, exp)
+  assert "assert_complex" do
+    assert_float real.real,      exp.real
+    assert_float real.imaginary, exp.imaginary
+  end
+end
+
+assert 'Complex' do
+  c = 123i
+  assert_equal Complex, c.class
+  assert_equal [c.real, c.imaginary], [0, 123]
+  c = 123 + -1.23i
+  assert_equal Complex, c.class
+  assert_equal [c.real, c.imaginary], [123, -1.23]
+end
+
+assert 'Complex::polar' do
+  assert_complex Complex.polar(3, 0),           (3  +  0i)
+  assert_complex Complex.polar(3, Math::PI/2),  (0  +  3i)
+  assert_complex Complex.polar(3, Math::PI),    (-3 +  0i)
+  assert_complex Complex.polar(3, -Math::PI/2), (0  + -3i)
+end
+
+assert 'Complex::rectangular' do
+  assert_complex Complex.rectangular(1, 2), (1 + 2i)
+end
+
+assert 'Complex#*' do
+  assert_complex Complex(2, 3)  * Complex(2, 3),  (-5    + 12i)
+  assert_complex Complex(900)   * Complex(1),     (900   + 0i)
+  assert_complex Complex(-2, 9) * Complex(-9, 2), (0     - 85i)
+  assert_complex Complex(9, 8)  * 4,              (36    + 32i)
+  assert_complex Complex(20, 9) * 9.8,            (196.0 + 88.2i)
+  assert_complex 4 * Complex(9, 8),               (36    + 32i)
+  assert_complex 9.8 * Complex(20, 9),            (196.0 + 88.2i)
+end
+
+assert 'Complex#+' do
+  assert_complex Complex(2, 3)  + Complex(2, 3) , (4    + 6i)
+  assert_complex Complex(900)   + Complex(1)    , (901  + 0i)
+  assert_complex Complex(-2, 9) + Complex(-9, 2), (-11  + 11i)
+  assert_complex Complex(9, 8)  + 4             , (13   + 8i)
+  assert_complex Complex(20, 9) + 9.8           , (29.8 + 9i)
+  assert_complex 4 + Complex(9, 8)              , (13   + 8i)
+  assert_complex 9.8 + Complex(20, 9)           , (29.8 + 9i)
+end
+
+assert 'Complex#-' do
+  assert_complex Complex(2, 3)  - Complex(2, 3) , (0    + 0i)
+  assert_complex Complex(900)   - Complex(1)    , (899  + 0i)
+  assert_complex Complex(-2, 9) - Complex(-9, 2), (7    + 7i)
+  assert_complex Complex(9, 8)  - 4             , (5    + 8i)
+  assert_complex Complex(20, 9) - 9.8           , (10.2 + 9i)
+  assert_complex 4 - Complex(9, 8)              , (-5   - 8i)
+  assert_complex 10.5 - Complex(20, 9)          , (-9.5 - 9i)
+end
+
+assert 'Complex#-@' do
+  assert_complex((-1 - 2i), -Complex(1, 2))
+end
+
+assert 'Complex#/' do
+  assert_complex Complex(2, 3)  / Complex(2, 3) , (1                  + 0i)
+  assert_complex Complex(900)   / Complex(1)    , (900                + 0i)
+  assert_complex Complex(-2, 9) / Complex(-9, 2), ((36.0 / 85)        - (77i / 85))
+  assert_complex Complex(9, 8)  / 4             , ((9.0 / 4)          + 2i)
+  assert_complex Complex(20, 9) / 9.8           , (2.0408163265306123 + 0.9183673469387754i)
+  assert_complex 4 / Complex(9, 8)              , (0.2482758620689655 - 0.2206896551724138i)
+  assert_complex 9.8 / Complex(20, 9)           , (0.4074844074844075 - 0.1833679833679834i)
+  if 1e39.infinite? then
+    # MRB_USE_FLOAT32 in effect
+    ten = 1e21
+    one = 1e20
+  else
+    ten = 1e201
+    one = 1e200
+  end
+  assert_complex Complex(ten, ten) / Complex(one, one), Complex(10.0, 0.0)
+  assert_raise(ZeroDivisionError) { Complex(1,1) / 0 }
+  assert_raise(ZeroDivisionError) { Complex(1,1) / Complex(0,0) }
+end
+
+assert 'Complex#==' do
+  assert_true  Complex(2, 3)  == Complex(2, 3)
+  assert_true  Complex(5)     == 5
+  assert_true  Complex(0)     == 0.0
+  assert_true  5 == Complex(5)
+  assert_true  0.0 == Complex(0)
+end
+
+assert 'Complex#abs' do
+  assert_float Complex(-1).abs,        1
+  assert_float Complex(3.0, -4.0).abs, 5.0
+  if 1e39.infinite? then
+    # MRB_USE_FLOAT32 in effect
+    exp = 125
+  else
+    exp = 1021
+  end
+  assert_true Complex(3.0*2.0**exp, 4.0*2.0**exp).abs.finite?
+  assert_float Complex(3.0*2.0**exp, 4.0*2.0**exp).abs, 5.0*2.0**exp
+end
+
+assert 'Complex#abs2' do
+  assert_float Complex(-1).abs2,        1
+  assert_float Complex(3.0, -4.0).abs2, 25.0
+end
+
+assert 'Complex#arg' do
+  assert_float Complex.polar(3, Math::PI/2).arg, 1.5707963267948966
+end
+
+assert 'Complex#conjugate' do
+  assert_complex Complex(1, 2).conjugate, (1 - 2i)
+end
+
+assert 'Complex#fdiv' do
+  assert_complex Complex(11, 22).fdiv(3), (3.6666666666666665 + 7.333333333333333i)
+end
+
+assert 'Complex#imaginary' do
+  assert_float Complex(7).imaginary    , 0
+  assert_float Complex(9, -4).imaginary, -4
+end
+
+assert 'Complex#polar' do
+  assert_equal Complex(1, 2).polar, [2.23606797749979, 1.1071487177940904]
+end
+
+assert 'Complex#real' do
+  assert_float Complex(7).real,     7
+  assert_float Complex(9, -4).real, 9
+end
+
+assert 'Complex#real?' do
+  assert_false Complex(1).real?
+end
+
+assert 'Complex::rectangular' do
+  assert_equal Complex(1, 2).rectangular, [1, 2]
+end
+
+assert 'Complex::to_c' do
+  assert_equal Complex(1, 2).to_c, Complex(1, 2)
+end
+
+assert 'Complex::to_f' do
+  assert_float Complex(1, 0).to_f, 1.0
+  assert_raise(RangeError) do
+    Complex(1, 2).to_f
+  end
+end
+
+assert 'Complex::to_i' do
+  assert_equal Complex(1, 0).to_i, 1
+  assert_raise(RangeError) do
+    Complex(1, 2).to_i
+  end
+end
+
+assert 'Complex#frozen?' do
+  assert_predicate(1i, :frozen?)
+  assert_predicate(Complex(2,3), :frozen?)
+  assert_predicate(4+5i, :frozen?)
+end
+
+assert 'Complex#**' do
+  assert_complex Complex(2, 3) ** 2, Complex(-5, 12)
+  assert_complex Complex(2, 3) ** 0, Complex(1, 0)
+  assert_complex Complex(2, 3) ** 1, Complex(2, 3)
+  assert_complex Complex(2, 3) ** Complex(1, 0), Complex(2, 3)
+  assert_complex Complex(0, 1) ** 2, Complex(-1, 0)
+  assert_complex Complex(0, 1) ** Complex(0, 1), Complex(Math::E ** (-Math::PI / 2), 0)
+end

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

@@ -0,0 +1,126 @@
+# mruby-data
+
+The `mruby-data` mrbgem provides a way to define simple classes in mruby that act as data structures, similar to Ruby's `Struct` class. It allows you to bundle a number of attributes together and access them using accessor methods.
+
+## Purpose
+
+`mruby-data` is useful when you need to create lightweight objects that primarily serve to hold and provide access to a set of data attributes without the need to write a full class definition manually.
+
+## Functionality
+
+### Defining a Data Class
+
+You can define a new data class using the `Data.define` class method. It accepts one or more symbols as arguments, which will become the attribute names for the instances of the generated class.
+
+```ruby
+# Defines a new class 'Point' with attributes :x and :y
+Point = Data.define(:x, :y)
+
+# Defines a new class 'Customer' with attributes :name, :address, and :zip
+Customer = Data.define(:name, :address, :zip)
+```
+
+### Creating Instances
+
+Once a data class is defined, you can create instances of it using the `new` method, providing values for each attribute in the order they were defined.
+
+```ruby
+# Create an instance of Point
+point1 = Point.new(10, 20)
+
+# Create an instance of Customer
+customer1 = Customer.new("John Doe", "123 Main St", 12345)
+```
+
+Alternatively, you can pass keyword arguments (available if mruby is compiled with `MRB_KW_ARGS`):
+
+```ruby
+customer2 = Customer.new(name: "Jane Doe", address: "456 Oak Ave", zip: 67890)
+```
+
+### Accessing Attributes
+
+Instances of data classes have accessor methods for each defined attribute.
+
+```ruby
+puts point1.x      # Output: 10
+puts point1.y      # Output: 20
+
+puts customer1.name  # Output: "John Doe"
+```
+
+### Instance Methods
+
+Instances of classes created by `Data.define` have several useful methods:
+
+- **`members`**: Returns an array of symbols representing the names of the attributes.
+
+  ```ruby
+  p customer1.members  # Output: [:name, :address, :zip]
+  ```
+
+- **`== (other)`**: Returns `true` if `other` is an instance of the same data class and all attribute values are equal.
+
+  ```ruby
+  point2 = Point.new(10, 20)
+  point3 = Point.new(0, 0)
+
+  puts point1 == point2  # Output: true
+  puts point1 == point3  # Output: false
+  ```
+
+- **`eql?(other)`**: Similar to `==`, checks if `other` is an instance of the same data class and all attribute values are `eql?`.
+
+- **`to_h`**: Converts the data instance into a hash where keys are the attribute symbols and values are their corresponding values.
+
+  ```ruby
+  p customer1.to_h
+  # Output: {:name=>"John Doe", :address=>"123 Main St", :zip=>12345}
+  ```
+
+- **`to_s` / `inspect`**: Returns a string representation of the data instance.
+
+  ```ruby
+  puts customer1 # Output: #<data Customer name="John Doe", address="123 Main St", zip=12345>
+  p customer1    # Output: #<data Customer name="John Doe", address="123 Main St", zip=12345>
+  ```
+
+## Freezing
+
+By default, instances of data classes are frozen after initialization, meaning their attributes cannot be modified after creation.
+
+```ruby
+point = Point.new(1, 2)
+# The following would raise an error as the object is frozen:
+# point.x = 100
+```
+
+## Example Usage
+
+```ruby
+# Define a class for 2D vectors
+Vector2D = Data.define(:x, :y)
+
+# Create some vector instances
+v1 = Vector2D.new(3, 4)
+v2 = Vector2D.new(1, 5)
+
+# Access attributes
+puts "Vector v1: (#{v1.x}, #{v1.y})"
+puts "Vector v2: (#{v2.x}, #{v2.y})"
+
+# Use instance methods
+puts "v1 members: #{v1.members}"
+puts "v1 as hash: #{v1.to_h}"
+
+# Comparison
+v3 = Vector2D.new(3, 4)
+puts "v1 == v2: #{v1 == v2}" # false
+puts "v1 == v3: #{v1 == v3}" # true
+```
+
+This mrbgem simplifies the creation of simple value objects in mruby.
+
+```
+
+```

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

@@ -0,0 +1,5 @@
+MRuby::Gem::Specification.new('mruby-data') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'standard Data class'
+end