lib/dydx/helper.rb in dydx-0.1.4 vs lib/dydx/helper.rb in dydx-0.1.25

@@ -1,88 +1,114 @@
 module Dydx
   module Helper
+    OP_SYM_STR = {
+      addition:       :+,
+      multiplication: :*,
+      exponentiation: :^
+    }
+
     SUPER_OPE_RELATION = {
       :+ => :*,
       :- => :/,
-      :* => :**,
+      :* => :^,
       :/ => :|
     }
 
     INVERSE_OPE_RELATION = {
       :+ => :-,
       :- => :+,
       :* => :/,
       :/ => :*,
-      :** => :|,
-      :| => :**
+      :^ => :|,
+      :| => :^
     }
 
-    def num?
-      is_a?(Num) || is_a?(Numeric)
+    def super_ope(operator)
+      SUPER_OPE_RELATION[operator]
     end
 
-    def to_numeric
-      is_a?(Num) ? n : self
+    def sub_ope(operator)
+      SUPER_OPE_RELATION.invert[operator]
     end
 
-    def zero?
-      [0, 0.0].include?(self) || (is_a?(Num) && n.zero?)
+    def inverse_ope(operator)
+      INVERSE_OPE_RELATION[operator]
     end
 
-    def one?
-      [1, 1.0].include?(self) || (is_a?(Num) && n.one?)
+    def inverse_super_ope(operator)
+      inverse_ope(super_ope(operator))
     end
 
-    def minus1?
-      [-1, -1.0].include?(self) || (is_a?(Num) && n.minus1?)
+    def is_num?
+      (is_a?(Num) || is_a?(Fixnum) || is_a?(Float)) || (is_a?(Inverse) && x.is_num?)
     end
 
+    def is_0?
+      [0, 0.0].include?(self) || (is_a?(Num) && n.is_0?)
+    end
+
+    def is_1?
+      [1, 1.0].include?(self) || (is_a?(Num) && n.is_1?)
+    end
+
+    def is_minus1?
+      [1, -1.0].include?(self)|| (is_a?(Num) && n.is_minus1?)
+    end
+
     def distributive?(ope1, ope2)
-      [ope1.super, ope1.inv_super].include?(ope2)
+      [super_ope(ope1), inverse_super_ope(ope1)].include?(ope2)
     end
 
-    # TODO: Cyclomatic complexity for combinable? is too high. [17/6]
     def combinable?(x, operator)
       case operator
       when :+
-        (num? && x.num?) ||
-        (formula?(:*) && (f.num? || g.num?)) && x.num? ||
-        like_term?(x) ||
+        self == x ||
+        (is_num? && x.is_num?) ||
+        (multiplication? && (f == x || g == x)) ||
+        (x.multiplication? && (x.f == self || x.g == self)) ||
         inverse?(:+, x)
       when :*
         self == x ||
-        (num? && x.num?) ||
+        (is_num? && x.is_num?) ||
         inverse?(:*, x)
-      when :**
-        (num? && x.num?) || zero? || one?
+      when :^
+        (is_num? && x.is_num?) || is_0? || is_1?
       end
     end
 
-    # TODO: Cyclomatic complexity for combinable? is too high. [9/6]
-    def like_term?(x)
-      self == x                         ||
-      formula?(:*) && include?(x)       ||
-      x.formula?(:*) && x.include?(self)||
-      (formula?(:*) && formula?(:*) && !([f, g] & [x.f, x.g]).empty?)
+    def is_multiple_of(x)
+      if is_0?
+        e0
+      elsif self == x
+        e1
+      # elsif is_num? && x.is_num? && (self % x == 0)
+      #   _(n / x.n)
+      elsif multiplication? && (f == x || g == x)
+        f == x ? g : f
+      else
+        false
+      end
     end
 
-    # TODO: Cyclomatic complexity for combinable? is too high. [7/6]
-    def multiple_of?(x)
-      zero? ||
-      self == x ||
-      (num? && x.num? && self % x == 0) ||
-      (formula?(:*) && (f == x || g == x))
+    OP_SYM_STR.each do |operator_name, operator|
+      define_method("#{operator_name}?") do
+        is_a?(Formula) && (@operator == operator)
+        # is_a?(Inverse) && self.operator == operator
+      end
     end
 
     def rest(f_or_g)
       ([:f, :g] - [f_or_g]).first
     end
 
-    def distributable?(_operator)
+    def commutative?
     end
 
-    def inverse?(operator, x = nil)
+    def distributable?(operator)
+    end
+
+    def inverse?(operator, x=nil)
       if is_a?(Algebra::Inverse)
         self.operator == operator && (self.x == x || x.nil?)
       elsif x.is_a?(Algebra::Inverse)
         self == x.x
       else
@@ -95,29 +121,9 @@
     end
 
     Symbol.class_eval do
       def commutative?
         [:+, :*].include?(self)
-      end
-
-      def associative?
-        [:+, :*].include?(self)
-      end
-
-      def super
-        SUPER_OPE_RELATION[self] || self
-      end
-
-      def sub
-        SUPER_OPE_RELATION.invert[self] || self
-      end
-
-      def inv
-        INVERSE_OPE_RELATION[self] || self
-      end
-
-      def inv_super
-        self.super.inv
       end
     end
 
     def ==(x)
       to_s == x.to_s