symbo 0.1.0pre

data/lib/symbo/function.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'symbo/expression'
+require 'symbo/integer'
+require 'symbo/symbol'
+
+module Symbo
+  class Function < Expression
+    include Symbo
+
+    using Symbo
+
+    def name
+      @operands[0]
+    end
+
+    def parameters
+      @operands[1..-1]
+    end
+
+    # :section: Power Transformation Methods
+
+    # べき乗の低
+    #
+    #   Function(:f, :x).base # => Function(:f, :x)
+    def base
+      dup
+    end
+
+    # べき指数
+    #
+    #   Function(:f, :x).exponent # => 1
+    def exponent
+      1
+    end
+
+    # :section: Basic Distributive Transformation Methods
+
+    # 同類項の項部分
+    #
+    #   Function(:f, :x).term # => Product(Function(:f, :x))
+    def term
+      Product[self]
+    end
+
+    # 同類項の定数部分
+    #
+    #   Function(:f, :x).const # => 1
+    def const
+      1
+    end
+
+    # :section: Order Relation Methods
+
+    # 交換法則によるオペランド並べ替えに使う順序関係
+    #
+    # - 相手が関数の場合
+    # 関数名が異なる場合、関数名で順序を決定。
+    #
+    #   Function(:f, :x).compare(Function(:g, :x)) # => true
+    #
+    # 関数名が同じの場合、関数の最左のオペランドから順に compare していき、
+    # 異なるものがあればそれで順序を決定する。
+    #
+    #   Function(:f, :x).compare(Function(:f, :y)) # => true
+    #
+    # どちらかのオペランドがなくなれば、短いほうが左側。
+    #
+    #   Function(:g, :x).compare(Function(:g, :x, :y)) # => true
+    #
+    # - シンボルの場合
+    # 関数名とシンボルが等しい場合 false
+    #
+    #   Function(:f, :x).compare(:f) # => false
+    #
+    # 異なる場合、関数名とシンボルで比較
+    #
+    #   Function(:f, :x).compare(:g) # => true
+    #
+    # - それ以外の場合
+    # 次のルールで比較
+    #
+    #   !other.compare(self)
+    #
+    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/AbcSize
+    def compare(other)
+      case other
+      when Function
+        if name != other.name
+          name.compare other.name
+        else
+          return parameters.first.compare other.parameters.first if parameters.first != other.parameters.first
+
+          m = parameters.length
+          n = other.parameters.length
+          0.upto([m, n].min - 2) do |j|
+            return parameters[j + 1].compare(other.parameters[j + 1]) if (parameters[j] == other.parameters[j]) && (parameters[j + 1] != other.parameters[j + 1])
+          end
+
+          m.compare(n)
+        end
+      when Symbol
+        if name == other
+          false
+        else
+          name.compare other
+        end
+      else
+        !other.compare(self)
+      end
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/AbcSize
+  end
+end

data/lib/symbo/integer.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'symbo/algebraic_operators'
+require 'symbo/constant'
+require 'symbo/expression_type'
+
+# Symbolic computation
+module Symbo
+  # Integer refinements
+  refine Integer do
+    alias_method :mult, :*
+    alias_method :div, :/
+
+    include AlgebraicOperators
+    include ExpressionType
+    include Constant
+
+    def simplify
+      self
+    end
+
+    # :section: Power Transformation Methods
+
+    # べき乗の低
+    #
+    #   1.base # => UNDEFINED
+    def base
+      UNDEFINED
+    end
+
+    # べき指数
+    #
+    #   1.exponent # => UNDEFINED
+    def exponent
+      UNDEFINED
+    end
+
+    # :section: Basic Distributive Transformation Methods
+
+    # 同類項の項部分
+    #
+    #   1.term # => UNDEFINED
+    def term
+      UNDEFINED
+    end
+
+    # 同類項の定数部分
+    #
+    #   1.const # => UNDEFINED
+    def const
+      UNDEFINED
+    end
+
+    # :section: Order Relation Methods
+
+    # 交換法則によるオペランド並べ替えに使う順序関係
+    #
+    # - 相手が定数の場合
+    # 大小関係で順序を決定
+    #
+    #   2.compare(4) # => true
+    #   2.compare(5/2) # => true
+    #
+    # - それ以外の場合
+    # 常に true
+    #
+    #   2.compare(:x + :y) # => true
+    #   2.compare(:x * :y) # => true
+    #   2.compare(2**:x) # => true
+    #   2.compare(Factorial(2)) # => true
+    #   2.compare(Function(:f, :x)) # => true
+    def compare(other)
+      case other
+      when Integer
+        self < other
+      when Fraction
+        self < other.rational
+      else
+        true
+      end
+    end
+
+    # :section:
+
+    def numerator
+      self
+    end
+
+    def denominator
+      1
+    end
+
+    def evaluate
+      self
+    end
+
+    def simplify_rational_number
+      self
+    end
+
+    def simplify_rne_rec
+      self
+    end
+  end
+end
+
+# Matrix などの中で使われる Integer#+ などをハイジャック
+class Integer
+  include Symbo::Constant
+  include Symbo::ExpressionType
+
+  alias plus +
+  alias mult *
+
+  def +(other)
+    plus other
+  rescue TypeError
+    Symbo::Sum[self, other]
+  end
+
+  def *(other)
+    mult other
+  rescue TypeError
+    Symbo::Product[self, other]
+  end
+end

data/lib/symbo/matrix.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'matrix'
+
+module Symbo
+  # シンボリック演算を使う行列
+  refine Matrix do
+    alias_method :mult, :*
+
+    def *(other)
+      if other.respond_to?(:to_matrix)
+        (mult other.to_matrix).simplify
+      else
+        mult other
+      end
+    end
+
+    def simplify
+      map(&:simplify)
+    end
+  end
+end

data/lib/symbo/mergeable.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Symbo
+  module Mergeable
+    private
+
+    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def merge(p, q) # rubocop:disable Naming/MethodParameterName
+      return p if q.empty?
+      return q if p.empty?
+
+      p1 = p[0]
+      q1 = q[0]
+      h = simplify_rec([p1, q1])
+      case h
+      in []
+        merge p[1..-1], q[1..-1]
+      in [_]
+        h + merge(p[1..-1], q[1..-1])
+      in ^p1, ^q1
+        [p1] + merge(p[1..-1], q)
+      in ^q1, ^p1
+        [q1] + merge(p, q[1..-1])
+      end
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
+  end
+end

data/lib/symbo/pi.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Symbo
+  PI = :π
+end

data/lib/symbo/power.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require 'symbo/expression'
+
+module Symbo
+  class Power < Expression
+    using Symbo
+
+    # :section: Power Transformation Methods
+
+    # べき乗の低
+    #
+    #   (:x**2).base # => :x
+    def base
+      @operands[0]
+    end
+
+    # べき指数
+    #
+    #   (:x**2).exponent # => 2
+    def exponent
+      @operands[1]
+    end
+
+    # :section: Basic Distributive Transformation Methods
+
+    # 同類項の項部分
+    #
+    #   (:x**2).term # => Product(:x**2)
+    def term
+      Product[self]
+    end
+
+    # 同類項の定数部分
+    #
+    #   (:x**2).const # => 1
+    def const
+      1
+    end
+
+    # :section: Order Relation Methods
+
+    # 交換法則によるオペランド並べ替えに使う順序関係
+    #
+    # - 相手がべき乗の場合
+    # 底が異なる場合、底同士で順序を決める。
+    # 底が等しい場合、べき指数同士で順序を決める。
+    #
+    #   ((1 + :x)**3).compare((1 + :y)**2) # => true
+    #   ((1 + :x)**2).compare((1 + :x)**3) # => true
+    #
+    # - 和、階乗、関数、シンボルの場合
+    # 相手を 1 乗のべき乗に変換して比較
+    #
+    #   ((1 + :x)**3).compare(1 + :y) # => true
+    #
+    # - それ以外の場合
+    # 次のルールで比較
+    #
+    #   !other.compare(self)
+    def compare(other)
+      case other
+      when Power
+        return base.compare(other.base) if base != other.base
+
+        exponent.compare other.exponent
+      when Sum, Factorial, Function, Symbol
+        compare Power[other, 1]
+      else
+        !other.compare(self)
+      end
+    end
+
+    # :section: Evaluation Methods
+
+    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/AbcSize
+    def evaluate
+      raise unless base.constant?
+      raise unless exponent.integer?
+
+      if base.numerator != 0
+        if exponent.positive?
+          Product[Power[base, exponent - 1].evaluate, base].evaluate
+        elsif exponent.zero?
+          1
+        elsif exponent == -1
+          Fraction[1, base]
+        elsif exponent < -1
+          raise NotImplementedError
+        end
+      elsif base.numerator.zero?
+        if n >= 1
+          0
+        else
+          UNDEFINED
+        end
+      end
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/AbcSize
+
+    def to_s
+      "#{base}^(#{exponent})"
+    end
+
+    protected
+
+    # :section: Simplification Methods
+
+    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/AbcSize
+    def _simplify
+      return UNDEFINED if base == UNDEFINED || exponent == UNDEFINED
+
+      if base.zero?
+        return 1 if exponent.positive? && exponent.constant?
+
+        return UNDEFINED
+      end
+
+      return 1 if base == 1
+      return simplify_integer_power if exponent.integer?
+      return simplify_eulers_formula if base == E
+
+      self
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/AbcSize
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/AbcSize
+    def simplify_integer_power
+      return Power[base, exponent].simplify_rne if base.constant?
+      return 1 if exponent.zero?
+      return base if exponent == 1
+
+      case base
+      when Power
+        r = base.operands[0]
+        s = base.operands[1]
+        p = Product.new(s, exponent).simplify
+
+        if p.integer?
+          Power[r, p].simplify_integer_power
+        else
+          Power[r, p]
+        end
+      when Product
+        r = base.operands.map { |each| Power[each, exponent].simplify_integer_power }
+        Product[*r].simplify
+      else
+        self
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/AbcSize
+
+    # e^ix = cos(x) + sin(x)
+    #
+    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/AbcSize
+    def simplify_eulers_formula
+      if exponent.product? &&
+         exponent.operand(0).is_a?(Complex) && exponent.operand(0).real.zero? &&
+         exponent.operand(1) == PI
+        # eg e^{ki * π}
+        x = Product[exponent.operand(0).imag, exponent.operand(1)]
+        (Cos[x] + 1i * Sin[x]).simplify
+      elsif exponent.product? &&
+            exponent.operand(0).fraction? && exponent.operand(0).operand(0).is_a?(Complex) && exponent.operand(0).operand(0).real.zero? &&
+            exponent.operand(1) == PI
+        # eg e^{(k/n)i * π}
+        x = Product[Fraction[exponent.operand(0).operand(0).imag, exponent.operand(0).operand(1)], exponent.operand(1)]
+        (Cos[x] + 1i * Sin[x]).simplify
+      else
+        self
+      end
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/AbcSize
+
+    def simplify_rne_rec
+      v = base.simplify_rne_rec
+      if v == UNDEFINED
+        UNDEFINED
+      else
+        Power[v, exponent].evaluate
+      end
+    end
+  end
+end