enclave 0.1.0

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

@@ -0,0 +1,42 @@
+MRuby::Gem::Specification.new 'mruby-compiler' do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'mruby compiler library'
+
+  spec.build_settings do
+    objs = %w[codegen y.tab].map do |name|
+      src = "#{dir}/core/#{name}.c"
+      if build.cxx_exception_enabled?
+        build.compile_as_cxx(src)
+      else
+        objfile(src.pathmap("#{build_dir}/core/%n"))
+      end
+    end
+    build.libmruby_core_objs << objs
+  end
+end
+
+dir = __dir__
+lex_def = "#{dir}/core/lex.def"
+
+unless Rake::Task.task_defined?(lex_def)
+  # Parser
+  file "#{dir}/core/y.tab.c" => ["#{dir}/core/parse.y", lex_def] do |t|
+    MRuby.targets["host"].yacc.run t.name, t.prerequisites.first
+    replace_line_directive(t.name)
+  end
+
+  # Lexical analyzer
+  file lex_def => "#{dir}/core/keywords" do |t|
+    MRuby.targets["host"].gperf.run t.name, t.prerequisites.first
+    replace_line_directive(t.name)
+  end
+
+  def replace_line_directive(path)
+    content = File.read(path).gsub(%r{
+      ^\#line\s+\d+\s+"\K.*(?="$) |             # #line directive
+      ^/\*\s+Command-line:.*\s\K\S+(?=\s+\*/$)  # header comment in lex.def
+    }x, &:relative_path)
+    File.write(path, content)
+  end
+end

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

@@ -0,0 +1,55 @@
+# mruby-complex
+
+mruby-complex is an mrbgem that provides a `Complex` class for mruby, allowing for the representation and manipulation of complex numbers. It is designed to be compatible with the Complex class in standard Ruby.
+
+## Functionality
+
+The `Complex` class provided by this mrbgem supports:
+
+- Creation of complex numbers from real and imaginary parts, or using the `i` suffix for numbers.
+- Basic arithmetic operations: addition (`+`), subtraction (`-`), multiplication (`*`), division (`/`).
+- Methods to access the real and imaginary parts (`real`, `imaginary` or `imag`).
+- Calculation of absolute value (`abs`, `magnitude`), argument/angle (`arg`, `angle`, `phase`), and square of the absolute value (`abs2`).
+- Complex conjugate (`conjugate`, `conj`).
+- Conversion to polar coordinates (`polar`).
+- Conversion to other numeric types where appropriate (`to_f`, `to_i`, `to_r`, `to_c`).
+- Inspection and string representation (`inspect`, `to_s`).
+
+## Usage Examples
+
+Here are some basic examples of how to use the `Complex` class:
+
+```ruby
+# Creating complex numbers
+c1 = Complex(1, 2)      # => (1+2i)
+c2 = 3 + 4i             # => (3+4i)
+c3 = Complex.polar(5, Math::PI/2) # => (0.0+5.0i) (approximately)
+
+# Arithmetic operations
+puts c1 + c2  # => (4+6i)
+puts c1 - c2  # => (-2-2i)
+puts c1 * c2  # => (-5+10i)
+puts c1 / c2  # => (0.44+0.08i)
+
+# Accessing parts
+puts c1.real      # => 1
+puts c1.imaginary # => 2
+
+# Other methods
+puts c2.abs       # => 5.0
+puts c2.arg       # => 0.9272952180016122 (radians)
+puts c2.conjugate # => (3-4i)
+puts c1.polar     # => [2.23606797749979, 1.1071487177940904]
+
+# Numerics can be converted to Complex
+puts 5.to_c       # => (5+0i)
+puts 2.3.to_c     # => (2.3+0i)
+
+# The `i` method on numerics creates a complex number with zero real part
+puts 5i           # => (0+5i)
+puts 2.3i         # => (0+2.3i)
+```
+
+## Note
+
+This mrbgem aims to provide functionality similar to the `Complex` class found in the standard Ruby library. Refer to the Ruby documentation for `Complex` for more detailed information on the behavior of various methods.

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

@@ -0,0 +1,7 @@
+MRuby::Gem::Specification.new('mruby-complex') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'Complex class'
+  spec.build.defines << "MRB_USE_COMPLEX"
+  spec.add_dependency 'mruby-math', core: 'mruby-math'
+end

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

@@ -0,0 +1,259 @@
+class Complex < Numeric
+  #
+  # call-seq:
+  #   Complex.polar(abs [, arg]) -> complex
+  #
+  # Returns a complex number in terms of its polar coordinates.
+  # abs is the absolute value (magnitude) and arg is the argument (angle).
+  #
+  #   Complex.polar(3, 0)            #=> (3+0i)
+  #   Complex.polar(3, Math::PI/2)   #=> (1.836909530733566e-16+3.0i)
+  #   Complex.polar(3, Math::PI)     #=> (-3.0+3.673819061467132e-16i)
+  #
+  def self.polar(abs, arg = 0)
+    Complex(abs * Math.cos(arg), abs * Math.sin(arg))
+  end
+
+  #
+  # call-seq:
+  #   cmp.inspect -> string
+  #
+  # Returns the value as a string for inspection.
+  #
+  #   Complex(2).inspect      #=> "(2+0i)"
+  #   Complex(-8, 6).inspect  #=> "(-8+6i)"
+  #   Complex(1, 2).inspect   #=> "(1+2i)"
+  #
+  def inspect
+    "(#{to_s})"
+  end
+
+  #
+  # call-seq:
+  #   cmp.to_s -> string
+  #
+  # Returns the value as a string.
+  #
+  #   Complex(2).to_s      #=> "2+0i"
+  #   Complex(-8, 6).to_s  #=> "-8+6i"
+  #   Complex(1, -2).to_s  #=> "1-2i"
+  #
+  def to_s
+    "#{real}#{'+' unless imaginary < 0}#{imaginary}#{'*' unless imaginary.finite?}i"
+  end
+
+  #
+  # call-seq:
+  #   +cmp -> cmp
+  #
+  # Returns self.
+  #
+  #   +Complex(1, 2)  #=> (1+2i)
+  #
+  def +@
+    self
+  end
+
+  #
+  # call-seq:
+  #   -cmp -> complex
+  #
+  # Returns the negation of self.
+  #
+  #   -Complex(1, 2)   #=> (-1-2i)
+  #   -Complex(-1, 2)  #=> (1-2i)
+  #
+  def -@
+    Complex(-real, -imaginary)
+  end
+
+  #
+  # call-seq:
+  #   cmp <=> numeric -> -1, 0, +1, or nil
+  #
+  # Returns -1, 0, or +1 depending on whether cmp is less than, equal to,
+  # or greater than numeric. This is the basis for the tests in the Comparable module.
+  # Returns nil if the two values are incomparable.
+  #
+  #   Complex(2, 3) <=> Complex(2, 3)  #=> 0
+  #   Complex(5) <=> 5                 #=> 0
+  #   Complex(2, 3) <=> 1              #=> 1
+  #
+  def <=>(other)
+    return nil unless other.kind_of?(Numeric)
+    self.to_f <=> other.to_f
+  rescue
+    nil
+  end
+
+  #
+  # call-seq:
+  #   cmp.abs        -> real
+  #   cmp.magnitude  -> real
+  #
+  # Returns the absolute part of its polar form.
+  #
+  #   Complex(-1).abs         #=> 1.0
+  #   Complex(3.0, -4.0).abs  #=> 5.0
+  #
+  def abs
+    Math.hypot(imaginary, real)
+  end
+  alias_method :magnitude, :abs
+
+  #
+  # call-seq:
+  #   cmp.abs2 -> real
+  #
+  # Returns square of the absolute value.
+  #
+  #   Complex(-1).abs2         #=> 1
+  #   Complex(3.0, -4.0).abs2  #=> 25.0
+  #
+  def abs2
+    real * real + imaginary * imaginary
+  end
+
+  #
+  # call-seq:
+  #   cmp.arg    -> float
+  #   cmp.angle  -> float
+  #   cmp.phase  -> float
+  #
+  # Returns the angle part of its polar form.
+  #
+  #   Complex.polar(3, Math::PI/2).arg  #=> 1.5707963267948966
+  #
+  def arg
+    Math.atan2(imaginary, real)
+  end
+  alias_method :angle, :arg
+  alias_method :phase, :arg
+
+  #
+  # call-seq:
+  #   cmp.conjugate -> complex
+  #   cmp.conj      -> complex
+  #
+  # Returns the complex conjugate.
+  #
+  #   Complex(1, 2).conjugate  #=> (1-2i)
+  #
+  def conjugate
+    Complex(real, -imaginary)
+  end
+  alias_method :conj, :conjugate
+
+  #
+  # call-seq:
+  #   cmp.fdiv(numeric) -> complex
+  #
+  # Performs division as each part is a float, even if the parts are not floats.
+  #
+  #   Complex(11, 22).fdiv(3)  #=> (3.6666666666666665+7.333333333333333i)
+  #
+  def fdiv(numeric)
+    Complex(real / numeric, imaginary / numeric)
+  end
+
+  #
+  # call-seq:
+  #   cmp.polar -> array
+  #
+  # Returns an array; [cmp.abs, cmp.arg].
+  #
+  #   Complex(1, 2).polar  #=> [2.23606797749979, 1.1071487177940904]
+  #
+  def polar
+    [abs, arg]
+  end
+
+  #
+  # call-seq:
+  #   cmp.real? -> false
+  #
+  # Returns false.
+  #
+  #   Complex(1).real?  #=> false
+  #
+  def real?
+    false
+  end
+
+  #
+  # call-seq:
+  #   cmp.rectangular -> array
+  #   cmp.rect        -> array
+  #
+  # Returns an array; [cmp.real, cmp.imag].
+  #
+  #   Complex(1, 2).rectangular  #=> [1, 2]
+  #
+  def rectangular
+    [real, imaginary]
+  end
+  alias_method :rect, :rectangular
+
+  #
+  # call-seq:
+  #   cmp.to_c -> cmp
+  #
+  # Returns self.
+  #
+  #   Complex(2).to_c      #=> (2+0i)
+  #   Complex(-8, 6).to_c  #=> (-8+6i)
+  #
+  def to_c
+    self
+  end
+
+  #
+  # call-seq:
+  #   cmp.to_r -> rational
+  #
+  # Returns the value as a rational if possible (the imaginary part should be exactly zero).
+  #
+  #   Complex(1, 0).to_r    #=> (1/1)
+  #   Complex(1, 0.0).to_r  #=> (1/1)
+  #   Complex(1, 2).to_r    #=> RangeError
+  #
+  def to_r
+    raise RangeError.new "can't convert #{to_s} into Rational" unless imaginary.zero?
+    Rational(real, 1)
+  end
+
+  alias_method :imag, :imaginary
+
+  Numeric.class_eval do
+    #
+    # call-seq:
+    #   num.i -> complex
+    #
+    # Returns the Complex object created from this number and i (0+num*i).
+    #
+    #   -42.i  #=> (0-42i)
+    #   2.0.i  #=> (0+2.0i)
+    #
+    def i
+      Complex(0, self)
+    end
+  end
+  undef i
+end
+
+class Numeric
+  #
+  # call-seq:
+  #   num.to_c -> complex
+  #
+  # Returns the value as a complex.
+  #
+  #   1.to_c       #=> (1+0i)
+  #   -1.to_c      #=> (-1+0i)
+  #   1.0.to_c     #=> (1.0+0i)
+  #   3.14159.to_c #=> (3.14159+0i)
+  #
+  def to_c
+    Complex(self, 0)
+  end
+end