symbo 0.1.0pre

data/lib/symbo/constant.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Symbo
+  module Constant; end
+end

data/lib/symbo/cos.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'symbo/trigonometric_function'
+
+module Symbo
+  class Cos < TrigonometricFunction
+    using Symbo
+
+    def self.[](x) # rubocop:disable Naming/MethodParameterName
+      new(x)
+    end
+
+    def initialize(x) # rubocop:disable Naming/MethodParameterName
+      super :cos, x
+    end
+
+    def to_s
+      "cos(#{operand(1)})"
+    end
+
+    protected
+
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    def _simplify
+      if x.zero?
+        1
+      elsif x == PI
+        -1
+      elsif x.constant? && x.negative?
+        Cos[Product[-1, x].simplify].simplify
+      elsif x.product? && x.operand(0).integer? && x.operand(0).negative?
+        Cos[Product[-1, x.operand(0), *x.operands[1..-1]].simplify].simplify
+      elsif kn_pi?
+        simplify_kn_pi.simplify
+      else
+        self
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    private
+
+    # Simplification of cos(kπ/n)
+    #
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    def simplify_kn_pi
+      k = x.operand(0).numerator
+      n = x.operand(0).denominator
+
+      case n
+      when 1
+        case k % 2
+        when 0
+          1
+        end
+      when 2
+        case k % 2
+        when 1
+          0
+        end
+      when 3
+        case k % 6
+        when 1, 5
+          1/2
+        when 2, 4
+          -1/2
+        end
+      when 4
+        case k % 8
+        when 1, 7
+          1/√(2)
+        when 3, 5
+          -1/√(2)
+        end
+      when 6
+        case k % 12
+        when 1, 11
+          √(3)/2
+        when 5, 7
+          Product[-1, √(3)/2]
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+  end
+end

data/lib/symbo/diff.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'symbo/expression'
+
+module Symbo
+  class Diff < Expression
+    using Symbo
+
+    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/AbcSize
+    def evaluate
+      v = operand(0).simplify
+
+      if length == 1
+        if v == UNDEFINED
+          UNDEFINED
+        else
+          Product[-1, v].evaluate
+        end
+      elsif length == 2
+        w = operand(1).simplify
+
+        if v == UNDEFINED || w == UNDEFINED
+          UNDEFINED
+        else
+          Sum[v, -w].evaluate
+        end
+      end
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/AbcSize
+  end
+end

data/lib/symbo/e.rb

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

data/lib/symbo/expression.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'symbo/algebraic_operators'
+require 'symbo/integer'
+require 'symbo/relational_operators'
+require 'symbo/symbol'
+
+module Symbo
+  UNDEFINED = :undefined
+
+  # General expression interface
+  class Expression
+    using Symbo
+
+    include AlgebraicOperators
+    include ExpressionType
+    include RelationalOperators
+
+    attr_reader :operands
+
+    def self.[](*operands)
+      new(*operands)
+    end
+
+    def initialize(*operands)
+      @operands = operands
+    end
+
+    # :section: Simplification Methods
+
+    def simplify
+      self.class.new(*@operands.map(&:simplify))._simplify
+    end
+
+    # :section: Power Transformation Methods
+    #
+    # 自動簡約式 u のべき乗変形に使うオペレータ。
+    #
+    #   u^v·u^w = u^{v+w}
+    #
+
+    # べき乗の低
+    def base
+      raise NotImplementedError, "#{self.class}#base"
+    end
+
+    # べき指数
+    #
+    # べき指数を書かない b のような式では exponent → 1 を返すことで、
+    #
+    #   b·b^2 = b^3
+    #
+    # のような式変形を簡単にする。
+    def exponent
+      raise NotImplementedError
+    end
+
+    # :section: Basic Distributive Transformation Methods
+    #
+    # 同類項のまとめに使うオペレータ。
+    #
+    #   v·u + w·u = (v+w)u
+    #
+
+    # 同類項の項部分
+    #
+    # 返り値は Product または UNDEFINED になる。返り値が単項の積 ·u の場合があるが、
+    # これは x と 2x の term を取ったときにどちらも同じ ·x を返すようにするための工夫。
+    def term
+      raise NotImplementedError, "#{self.class}#term"
+    end
+
+    # 同類項の定数部分
+    def const
+      raise NotImplementedError
+    end
+
+    # :section: Order Relation Methods
+
+    # 交換法則によるオペランド並べ替えに使う順序関係
+    def compare(_other)
+      raise NotImplementedError, "#{self.class}#compare"
+    end
+
+    # :section: Operand Methods
+
+    # Returns nth operand
+    def operand(n) # rubocop:disable Naming/MethodParameterName
+      @operands[n]
+    end
+
+    # Returns the number of operands
+    def length
+      @operands.length
+    end
+
+    protected
+
+    # :category: Simplification Methods
+
+    def _simplify
+      raise NotImplementedError
+    end
+
+    def simplify_rne
+      v = simplify_rne_rec
+      if v == UNDEFINED
+        UNDEFINED
+      else
+        v.simplify_rational_number
+      end
+    end
+  end
+end

data/lib/symbo/expression_type.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Symbo
+  module ExpressionType
+    # :section: Expression Type Methods
+
+    def undefined?
+      self == UNDEFINED
+    end
+
+    def integer?
+      is_a?(Integer)
+    end
+
+    def complex?
+      is_a?(Complex)
+    end
+
+    def fraction?
+      is_a?(Fraction)
+    end
+
+    def constant?
+      is_a?(Constant)
+    end
+
+    def sum?
+      is_a?(Sum)
+    end
+
+    def product?
+      is_a?(Product)
+    end
+
+    def power?
+      is_a?(Power)
+    end
+
+    def symbol?
+      is_a?(Symbol)
+    end
+  end
+end

data/lib/symbo/factorial.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'symbo/integer'
+require 'symbo/symbol'
+
+module Symbo
+  # シンボリックな階乗
+  class Factorial < Expression
+    using Symbo
+
+    # :section: Power Transformation Methods
+
+    # べき乗の低
+    #
+    #   Factorial[:x].base # => Factorial[:x]
+    def base
+      dup
+    end
+
+    # べき指数
+    #
+    #   Factorial[:x].exponent # => 1
+    def exponent
+      1
+    end
+
+    # :section: Basic Distributive Transformation Methods
+
+    # 同類項の項部分
+    #
+    #   Factorial[:x].term # => Product[Factorial[:x]]
+    def term
+      Product[self]
+    end
+
+    # 同類項の定数部分
+    #
+    #   Factorial[:x].const # => 1
+    def const
+      1
+    end
+
+    # :section: Order Relation Methods
+
+    # 交換法則によるオペランド並べ替えに使う順序関係
+    #
+    # - 相手が階乗の場合
+    # オペランド同士を比較する
+    #
+    #   Factorial[:m].compare(:n) # => true
+    #
+    # - 関数またはシンボルの場合
+    # 最初のオペランドが相手と同じ場合 false
+    #
+    #   Factorial[Function[:f, :x]].compare(Function[:f, :x]) # => false
+    #   Factorial[:x].compare(:x) # => true
+    #
+    # 異なる場合、相手を階乗と見て比較
+    #
+    #   Factorial[:x].compare(Function[:f, :x]) # => true
+    #
+    # - それ以外の場合
+    # 次のルールで比較
+    #
+    #   !other.compare(self)
+    def compare(other)
+      case other
+      when Factorial
+        @operands[0].compare other.operands[0]
+      when Function, Symbol
+        if @operands[0] == other
+          false
+        else
+          compare Factorial[other]
+        end
+      else
+        !other.compare(self)
+      end
+    end
+  end
+end

data/lib/symbo/float.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# 浮動小数点数のシンボリック演算
+class Float
+  def simplify
+    self
+  end
+end

data/lib/symbo/fraction.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'symbo/constant'
+
+module Symbo
+  # Symbo fraction computation
+  class Fraction < Expression
+    include Constant
+
+    using Symbo
+
+    # :section: Power Transformation Methods
+
+    # べき乗の低
+    #
+    #   (1/3).base # => UNDEFINED
+    def base
+      UNDEFINED
+    end
+
+    # べき指数
+    #
+    #   (1/3).exponent # => UNDEFINED
+    def exponent
+      UNDEFINED
+    end
+
+    # :section: Basic Distributive Transformation Methods
+
+    # 同類項の項部分
+    #
+    #   (1/3).term # => UNDEFINED
+    def term
+      UNDEFINED
+    end
+
+    # 同類項の定数部分
+    #
+    #   (1/3).const # => UNDEFINED
+    def const
+      UNDEFINED
+    end
+
+    # :section: Order Relation Methods
+
+    # 交換法則によるオペランド並べ替えに使う順序関係
+    #
+    # - 相手が定数の場合
+    # 大小関係で順序を決定
+    #
+    #   (1/2).compare(4) # => true
+    #   (1/2).compare(5/2) # => true
+    #
+    # - それ以外の場合
+    # 常に true
+    #
+    #   (1/2).compare(:x + :y) # => true
+    #   (1/2).compare(:x * :y) # => true
+    #   (1/2).compare(2**:x) # => true
+    #   (1/2).compare(Factorial(2)) # => true
+    #   (1/2).compare(Function(:f, :x)) # => true
+    def compare(other)
+      case other
+      when Integer
+        rational < other
+      when Fraction
+        rational < other.rational
+      else
+        true
+      end
+    end
+
+    # :section:
+
+    def positive?
+      rational.positive?
+    end
+
+    def rational
+      Rational operand(0), operand(1)
+    end
+
+    def numerator
+      if operands.all?(&:integer?)
+        rational.numerator
+      else
+        operand(0)
+      end
+    end
+
+    def denominator
+      if operands.all?(&:integer?)
+        rational.denominator
+      else
+        operand(1)
+      end
+    end
+
+    def evaluate
+      if denominator.zero?
+        UNDEFINED
+      else
+        self
+      end
+    end
+
+    def simplify_rne_rec
+      if denominator.zero?
+        UNDEFINED
+      else
+        self
+      end
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def simplify_rational_number
+      n = operand(0)
+      d = operand(1)
+
+      case [n, d]
+      in Integer, Integer
+        if (n % d).zero?
+          n.div d
+        else
+          g = n.gcd(d)
+          if d.positive?
+            Fraction[n.div(g), d.div(g)]
+          else
+            Fraction[(-n).div(g), (-d).div(g)]
+          end
+        end
+      in Complex, Integer
+        real_mod = n.real % d
+        imag_mod = n.imag % d
+        if real_mod.zero? && imag_mod.zero?
+          if n.imag.div(d).zero?
+            n.real.div d
+          else
+            Complex(n.real.div(d), n.imag.div(d))
+          end
+        else
+          gr = n.real.gcd(d)
+          gi = n.imag.gcd(d)
+          if gr == gi
+            if d.positive?
+              Fraction[Complex(n.real.div(gr), n.imag.div(gr)), d.div(gr)]
+            else
+              Fraction[Complex(-n.real.div(gr), -n.imag.div(gr)), -d.div(gr)]
+            end
+          else
+            self
+          end
+        end
+      else
+        raise NotImplementedError, "Fraction#simplify_rational_number(#{n.inspect}/#{d.inspect})"
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def negative?
+      false
+    end
+
+    def to_s
+      "#{operand(0)}/#{operand(1)}"
+    end
+
+    protected
+
+    def _simplify
+      return UNDEFINED if operand(1).zero?
+
+      simplify_rational_number
+    end
+  end
+end