symbolic 0.2.5 → 0.3.0

data/README.rdoc

@@ -12,16 +12,16 @@ Symbolic math can be really helpful if you want to simplify some giant equation
   x = var :name => 'x'
   y = var :name => 'y'
 
-  f = (4 - 2*(-x) + y*(-1.0))*x - 0*y + 0 - 2
-  puts f # => (4+2*x-y)*x-2
+  f = (-2*(-x) + y*(-1.0) + 6*x/(3*x))*x - 2*y + 2*y - (2**x)**y
+  puts f # => (2*x-y+2)*x-2**(x*y)
 
-  p f.detailed_operations # => {"+"=>1, "-"=>2, "*"=>2}
-  p f.operations # => 5
-  p f.undefined_variables.map &:name # => ["x", "y"]
+  p f.operations # => {"+"=>1, "-"=>2, "*"=>3, "/"=>0, "**"=>1, "-@"=>0}
+  p f.variables.map &:name # => ["x", "y"]
   x.value = 2
+  p f.undefined_variables.map &:name # => ["y"]
   y.value = 4
 
-  puts f.value # => 6
+  puts f.value # => -252.0
 
 
   g = Symbolic::Math.cos(y)

data/Rakefile

@@ -5,7 +5,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "symbolic"
-    gem.version = '0.2.5'
+    gem.version = '0.3.0'
     gem.summary = 'Symbolic math for ruby'
     gem.description = %Q{Symbolic math can be really helpful if you want to simplify some giant equation or if you don't want to get a performance hit re-evaluating big math expressions every time when few variables change.}
     gem.email = "ravwar@gmail.com"

data/lib/symbolic/coerced.rb

@@ -5,23 +5,23 @@ module Symbolic
     end
 
     def +(numeric)
-      Operation::Binary::Addition.for numeric, @symbolic
+      Summand.add numeric, @symbolic
     end
 
     def -(numeric)
-      Operation::Binary::Subtraction.for numeric, @symbolic
+      Summand.subtract numeric, @symbolic
     end
 
     def *(numeric)
-      Operation::Binary::Multiplication.for numeric, @symbolic
+      Factor.multiply numeric, @symbolic
     end
 
     def /(numeric)
-      Operation::Binary::Division.for numeric, @symbolic
+      Factor.divide numeric, @symbolic
     end
 
     def **(numeric)
-      Operation::Binary::Exponentiation.for numeric, @symbolic
+      Factor.exponent numeric, @symbolic
     end
   end
 end

data/lib/{extensions → symbolic/extensions}/numeric.rb

@@ -2,8 +2,4 @@ class Numeric
   def value
     self
   end
-
-  def variables
-    []
-  end
 end

data/lib/symbolic/extensions/rational.rb

@@ -0,0 +1,13 @@
+# Fix for rational on 1.8.7
+[Fixnum,Bignum].each do |klass|
+  klass.class_eval do
+    def rpower(other)
+      if other.is_a?(Numeric) && other < 0
+        Rational.new!(self, 1)**other
+      else
+        self.power!(other)
+      end
+    end
+    alias ** rpower
+  end
+end

data/lib/symbolic/factor.rb

@@ -0,0 +1,129 @@
+class Symbolic::Factor
+  include Symbolic
+
+  class << self
+    def exponent(base, exponent)
+      simplify_exponents! factors = unite_exponents(base, exponent)
+      simplify(*factors) || new(factors)
+    end
+
+    def multiply(var1, var2)
+      simplify_exponents! factors = unite(factors(var1), factors(var2))
+      simplify(*factors) || new(factors)
+    end
+
+    def divide(var1, var2)
+      simplify_exponents! factors = unite(factors(var1), reverse(var2))
+      simplify(*factors) || new(factors)
+    end
+
+    def simplify_exponents!(factors)
+      factors[1].delete_if {|base, exp| (base == 1) || (exp == 0) }
+      factors[0] = 0 if factors[1].any? {|base, exp| base == 0 }
+    end
+
+    def simplify(numeric, symbolic)
+      if numeric == 0 || symbolic.empty?
+        (numeric.round == numeric) ? numeric.to_i : numeric.to_f
+      elsif numeric == 1 && symbolic.size == 1 && symbolic.values.first == 1
+        symbolic.keys.first
+      end
+    end
+
+    def reverse(var)
+      factors(var).dup.tap do |it|
+        it[0] = it[0]**-1
+        it[1] = Hash[*it[1].map {|b,e| [b,-e] }.flatten]
+      end
+    end
+
+    def factors(var)
+      var.is_a?(Symbolic) ? var.send(:factors) : [var, {}]
+    end
+
+    def unite(factors1, factors2)
+      numeric1, symbolic1 = factors1
+      numeric2, symbolic2 = factors2
+
+      numeric = numeric1 * numeric2
+      symbolic = symbolic1.merge(symbolic2) {|base, exp1, exp2| exp1 + exp2 }
+      return numeric, symbolic
+    end
+
+    def unite_exponents(base, exponent)
+      if base.is_a? Symbolic::Factor
+        numeric, symbolic = factors(base)
+        return numeric**exponent, Hash[*symbolic.map {|base,exp| [base,exp*exponent] }.flatten]
+      else
+        [1, { base => exponent }]
+      end
+    end
+  end
+
+  def initialize(factors)
+    @factors = factors
+  end
+
+  def value
+    @factors[1].inject(@factors[0]) {|value, (base, exp)| value * base.value ** exp.value }
+  end
+
+  def variables
+    @factors[1].map {|k,v| [variables_of(k), variables_of(v)] }.flatten.uniq
+  end
+
+  def to_s
+    simplify_output
+  end
+
+  def ==(object)
+    object.send(:factors) == @factors rescue false
+  end
+
+  private
+
+  attr_reader :factors
+
+  def summands
+    if @factors[0] == 1
+      super
+    else
+      [0, {(self/@factors[0]) => @factors[0]}]
+    end
+  end
+
+  def coefficient_to_string(numeric)
+    "#{'-' if numeric < 0}#{"#{rational_to_string numeric.abs}*" if numeric.abs != 1}"
+  end
+
+  def exponent_to_string(base, exponent)
+    "#{brackets base}#{"**#{brackets exponent}" if exponent != 1}"
+  end
+
+  def brackets(var)
+    [Numeric, Symbolic::Variable].any? {|klass| var.is_a? klass } ? var : "(#{var})"
+  end
+
+  def simplify_output
+    groups = @factors[1].group_by {|b,e| e.is_a?(Numeric) && e < 0 }
+    reversed_factors = groups[true] ? [1, Hash[*groups[true].flatten] ] : nil
+    factors = groups[false] ? [@factors[0], Hash[*groups[false].flatten] ] : nil
+    output = '' << (factors ? output(factors) : rational_to_string(@factors[0]))
+    output << "/#{reversed_output reversed_factors}" if reversed_factors
+    output
+  end
+
+  def output(factors)
+    coefficient_to_string(factors[0]) <<
+    factors[1].map {|base,exp| exponent_to_string base,exp }.join('*')
+  end
+
+  def reversed_output(factors)
+    result = output [factors[0], Hash[*factors[1].map {|b,e| [b,-e] }.flatten]]
+    (factors[1].length > 1) ? "(#{result})" : result
+  end
+
+  def rational_to_string(numeric)
+    ((numeric.round == numeric) ? numeric.to_i : numeric.to_f).to_s
+  end
+end

data/lib/symbolic/math.rb

@@ -1,9 +1,13 @@
 module Symbolic::Math
-  def self.cos(argument)
-    Symbolic::Function.new argument, :cos
-  end
-
-  def self.sin(argument)
-    Symbolic::Function.new argument, :sin
+  Math.methods(false).each do |method|
+    instance_eval <<-CODE, __FILE__, __LINE__
+      def #{method}(argument)
+        unless argument.is_a? Numeric
+          Symbolic::Function.new argument, :#{method}
+        else
+          ::Math.#{method} argument
+        end
+      end
+    CODE
   end
 end

data/lib/symbolic/statistics.rb

@@ -0,0 +1,13 @@
+module Symbolic
+  def operations
+    formula = to_s
+    stats = {}
+    stats['+'] = formula.scan(/\+/).size
+    stats['-'] = formula.scan(/[^(]-/).size
+    stats['*'] = formula.scan(/[^*]\*[^*]/).size
+    stats['/'] = formula.scan(/\//).size
+    stats['**']= formula.scan(/\*\*/).size
+    stats['-@']= formula.scan(/\(-/).size + formula.scan(/^-/).size
+    stats
+  end
+end

data/lib/symbolic/summand.rb

@@ -0,0 +1,86 @@
+class Symbolic::Summand
+  include Symbolic
+
+  class << self
+    def add(var1, var2)
+      simplify_coefficients! summands = unite(summands(var1), summands(var2))
+      simplify(*summands) || new(summands)
+    end
+
+    def subtract(var1, var2)
+      simplify_coefficients! summands = unite(summands(var1), reverse(var2))
+      simplify(*summands) || new(summands)
+    end
+
+    def reverse(var)
+      summands(var).tap do |it|
+        it[0] = -it[0]
+        it[1] = Hash[*it[1].map {|b,e| [b,-e] }.flatten]
+      end
+    end
+
+    def summands(var)
+      var.is_a?(Symbolic) ? var.send(:summands) : [var, {}]
+    end
+
+    def unite(summands1, summands2)
+      numeric1, symbolic1 = summands1
+      numeric2, symbolic2 = summands2
+
+      numeric = numeric1 + numeric2
+      symbolic = symbolic1.merge(symbolic2) {|base, coef1, coef2| coef1 + coef2 }
+      return numeric, symbolic
+    end
+
+    def simplify_coefficients!(summands)
+      summands[1].delete_if {|base, coef| coef == 0 }
+    end
+
+    def simplify(numeric, symbolic)
+      if symbolic.empty?
+        numeric
+      elsif numeric == 0 && symbolic.size == 1
+        symbolic.values.first * symbolic.keys.first
+      end
+    end
+  end
+
+  def initialize(summands)
+    @summands = summands
+  end
+
+  def value
+    @summands[1].inject(@summands[0]) {|value, (base, coef)| value + base.value * coef.value }
+  end
+
+  def variables
+    @summands[1].map {|k,v| [variables_of(k), variables_of(v)] }.flatten.uniq
+  end
+
+  def ==(object)
+    object.send(:summands) == @summands rescue false
+  end
+
+  def to_s
+    output = @summands[1].map {|base, coef| coef_to_string(coef) + base.to_s }
+    output << remainder_to_string(@summands[0]) if @summands[0] != 0
+    output[0] = output.first[1..-1]
+    output.join
+  end
+
+  private
+
+  attr_reader :summands
+
+  def coef_to_string(coef)
+    "#{(coef > 0) ? '+' : '-' }#{ "#{rational_to_string(coef.abs)}*" if coef.abs != 1}"
+  end
+
+  def remainder_to_string(numeric)
+    "#{'+' if numeric > 0}#{numeric}"
+  end
+
+  def rational_to_string(numeric)
+    ((numeric.round == numeric) ? numeric.to_i : numeric.to_f).to_s
+  end
+end

data/lib/symbolic.rb

@@ -1,27 +1,21 @@
 Symbolic = Module.new
 
-require 'symbolic/operation'
-require 'symbolic/operation/unary'
-require 'symbolic/operation/unary/minus'
-require 'symbolic/operation/binary'
-require 'symbolic/operation/binary/addition'
-require 'symbolic/operation/binary/subtraction'
-require 'symbolic/operation/binary/multiplication'
-require 'symbolic/operation/binary/division'
-require 'symbolic/operation/binary/exponentiation'
-
 require 'symbolic/coerced'
 require 'symbolic/variable'
+require 'symbolic/summand'
+require 'symbolic/factor'
 require 'symbolic/function'
 require 'symbolic/math'
+require 'symbolic/statistics'
 
-require 'extensions/kernel'
-require 'extensions/numeric'
-require 'extensions/matrix'
+require 'symbolic/extensions/kernel'
+require 'symbolic/extensions/numeric'
+require 'symbolic/extensions/matrix' if Object.const_defined? 'Matrix'
+require 'symbolic/extensions/rational' if RUBY_VERSION == '1.8.7'
 
 module Symbolic
   def -@
-    Operation::Unary::Minus.for self
+    Factor.multiply self, -1
   end
 
   def +@
@@ -29,30 +23,44 @@ module Symbolic
   end
 
   def +(var)
-    Operation::Binary::Addition.for self, var
+    Summand.add self, var
   end
 
   def -(var)
-    Operation::Binary::Subtraction.for self, var
+    Summand.subtract self, var
   end
 
   def *(var)
-    Operation::Binary::Multiplication.for self, var
+    Factor.multiply self, var
   end
 
   def /(var)
-    Operation::Binary::Division.for self, var
+    Factor.divide self, var
   end
 
   def **(var)
-    Operation::Binary::Exponentiation.for self, var
+    Factor.exponent self, var
   end
 
   def coerce(numeric)
     return Coerced.new(self), numeric
   end
 
-  def operations
-    detailed_operations.values.inject(0) {|sum,it| sum + it }
+  def undefined_variables
+    variables.select {|it| it.value.nil? }
+  end
+
+  private
+
+  def factors
+    [1, { self => 1 }]
+  end
+
+  def summands
+    [0, { self => 1 }]
+  end
+
+  def variables_of(var)
+    var.variables rescue []
   end
 end

data/spec/symbolic_spec.rb

@@ -43,9 +43,8 @@ describe "Symbolic" do
      'x*3'       => 3,
      '4*y'       => 8,
      '(+x)*(-y)' => -2,
-     'x/2'       => 0,
+     'x/2'       => 0.5,
      'y/2'       => 1,
-     'x/2.0'     => 0.5,
      '-2/x'      => -2,
      '4/(-y)'    => -2,
      'x**2'      => 1,
@@ -105,9 +104,10 @@ describe "Symbolic" do
     'x.variables' => '[x]',
     '(-(x+y)).variables' => '[x,y]',
     '(x+y).undefined_variables' => '[]',
-    '(-x**y-4*y+5-y/x).detailed_operations' =>
-    '{"+" => 1, "-" => 2, "*" => 1, "/" => 1, "-@" => 1, "**" => 1}',
-    '(-x**y-4*y+5-y/x).operations' => '7'
+    '(x*y).undefined_variables' => '[]'#,
+    # '(-x**y-4*y+5-y/x).detailed_operations' =>
+    # '{"+" => 1, "-" => 2, "*" => 1, "/" => 1, "-@" => 1, "**" => 1}',
+    # '(-x**y-4*y+5-y/x).operations' => '7'
   end
 
   describe "to_s:" do
@@ -124,16 +124,17 @@ describe "Symbolic" do
     '-x' => '-x',
     'x+1' => 'x+1',
     'x-4' => 'x-4',
-    '-(x+y)' => '-x-y',
-    '-(x-y)' => 'y-x',
+    # '-(x+y)' => '-x-y',
+    # '-(x-y)' => 'y-x',
     'x*y' => 'x*y',
     '(-x)*y' => '-x*y',
     '(x+2)*(y+3)*4' => '4*(x+2)*(y+3)',
     '4/x' => '4/x',
-    '(-(2+x))/(-(-y))' => '(-2-x)/y',
+    '2*x**(-1)*y**(-1)' => '2/(x*y)',
+    # '(-(2+x))/(-(-y))' => '(-2-x)/y',
     'x**y' => 'x**y',
     'x**(y-4)' => 'x**(y-4)',
-    '(x+1)**(y*2)' => '(x+1)**(2*y)',
-    '-(x**y -2)+5' => '2-x**y+5'
+    '(x+1)**(y*2)' => '(x+1)**(2*y)'#,
+    # '-(x**y -2)+5' => '2-x**y+5'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: symbolic
 version: !ruby/object:Gem::Version 
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors: 
 - brainopia
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-11 00:00:00 +03:00
+date: 2009-12-13 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,22 +34,17 @@ files:
 - .gitignore
 - README.rdoc
 - Rakefile
-- lib/extensions/kernel.rb
-- lib/extensions/matrix.rb
-- lib/extensions/numeric.rb
 - lib/symbolic.rb
 - lib/symbolic/coerced.rb
+- lib/symbolic/extensions/kernel.rb
+- lib/symbolic/extensions/matrix.rb
+- lib/symbolic/extensions/numeric.rb
+- lib/symbolic/extensions/rational.rb
+- lib/symbolic/factor.rb
 - lib/symbolic/function.rb
 - lib/symbolic/math.rb
-- lib/symbolic/operation.rb
-- lib/symbolic/operation/binary.rb
-- lib/symbolic/operation/binary/addition.rb
-- lib/symbolic/operation/binary/division.rb
-- lib/symbolic/operation/binary/exponentiation.rb
-- lib/symbolic/operation/binary/multiplication.rb
-- lib/symbolic/operation/binary/subtraction.rb
-- lib/symbolic/operation/unary.rb
-- lib/symbolic/operation/unary/minus.rb
+- lib/symbolic/statistics.rb
+- lib/symbolic/summand.rb
 - lib/symbolic/variable.rb
 - spec/spec.opts
 - spec/spec_helper.rb

data/lib/symbolic/operation/binary/addition.rb

@@ -1,15 +0,0 @@
-class Symbolic::Operation::Binary::Addition < Symbolic::Operation::Binary
-  symmetric
-
-  def self.simplify_first_arg(var1, var2)
-    if var1 == 0
-      var2
-    elsif negative?(var1)
-      var2 - var1.abs
-    end
-  end
-
-  def sign
-    '+'
-  end
-end

data/lib/symbolic/operation/binary/division.rb

@@ -1,25 +0,0 @@
-class Symbolic::Operation::Binary::Division < Symbolic::Operation::Binary
-  def self.simplify_first_arg(var1, var2)
-    if var1 == 0
-      0
-    elsif negative?(var1)
-      -(var1.abs / var2)
-    end
-  end
-
-  def self.simplify_second_arg(var1, var2)
-    if var2 == 1
-      var1
-    elsif negative?(var2)
-      -(var1 / var2.abs)
-    end
-  end
-
-  def sign
-    '/'
-  end
-
-  def brackets_for
-    [:addition, :subtraction]
-  end
-end

data/lib/symbolic/operation/binary/exponentiation.rb

@@ -1,35 +0,0 @@
-class Symbolic::Operation::Binary::Exponentiation < Symbolic::Operation::Binary
-  def self.simplify_first_arg(var1, var2)
-    if var1 == 0
-      0
-    elsif var1 == 1
-      1
-    elsif negative?(var1) && var2.respond_to?(:even?)
-      without_sign = var1.abs ** var2
-      var2.even? ? without_sign : -without_sign
-    elsif operation(var1) == :exponentiation
-      var1.send(:base) ** (var1.send(:exponent) * var2)
-    end
-  end
-
-  def self.simplify_second_arg(var1, var2)
-    if var2 == 0
-      1
-    elsif var2 == 1
-      var1
-    end
-  end
-
-  def brackets_for
-    [:unary_minus, :addition, :subtraction, :multiplication, :division]
-  end
-
-  def sign
-    '**'
-  end
-
-  private
-
-  alias base var1
-  alias exponent var2
-end

data/lib/symbolic/operation/binary/multiplication.rb

@@ -1,84 +0,0 @@
-class Symbolic::Operation
-  class Binary::Multiplication < Binary
-
-    class << self
-      def for(var1, var2)
-        # TODO: def -@(var); -1 * var; end
-        sign1, var1 = sign_and_modulus var1
-        sign2, var2 = sign_and_modulus var2
-        sign = (sign1 == sign2) ? :+@ : :-@
-
-        factors = unite factors(var1), factors(var2)
-        (simplify(factors) || new(factors)).send sign
-      end
-
-      def simplify(factors)
-        factors.first if factors.length == 1
-      end
-
-      def unite(factors1, factors2)
-        numeric = extract_numeric!(factors1) * extract_numeric!(factors2)
-        return [0] if numeric == 0
-        factors = unite_by_exponent factors1, factors2
-        factors.unshift(numeric) if numeric != 1 || factors.empty?
-        factors
-      end
-
-      def unite_by_exponent(factors1, factors2)
-        exponents(factors1).
-          merge(exponents factors2) {|base,exponent1,exponent2| exponent1 + exponent2 }.
-          delete_if {|base, exponent| exponent == 0 }.
-          map {|base, exponent| base**exponent }
-      end
-
-      def exponents(factors)
-        exponents = factors.map {|it| base_and_exponent it }
-        Hash[exponents]
-      end
-
-      def base_and_exponent(var)
-        var.is_a?(Binary::Exponentiation) ? [var.send(:base), var.send(:exponent)] : [var, 1]
-      end
-
-      def extract_numeric!(factors)
-        factors.first.is_a?(Numeric) ? factors.shift : 1
-      end
-
-      def sign_and_modulus(var)
-        negative?(var) ? [:-@, var.abs] : [:+@, var]
-      end
-
-      def factors(var)
-        var.respond_to?(:factors) ? var.send(:factors).dup : [var]
-      end
-    end
-
-    def sign
-      '*'
-    end
-
-    def brackets_for
-      [:addition, :subtraction]
-    end
-
-    def initialize(factors)
-      @factors = factors
-    end
-
-    def variables
-      @factors.map(&:variables).flatten.uniq
-    end
-
-    def value
-      @factors.inject(1) {|product, it| product*it.value } if undefined_variables.empty?
-    end
-
-    def to_s
-      @factors.map {|it| brackets it }.join '*'
-    end
-
-    protected
-
-    attr_reader :factors
-  end
-end

data/lib/symbolic/operation/binary/subtraction.rb

@@ -1,19 +0,0 @@
-class Symbolic::Operation::Binary::Subtraction < Symbolic::Operation::Binary
-  def self.simplify_first_arg(var1, var2)
-    -var2 if var1 == 0
-  end
-
-  def self.simplify_second_arg(var1, var2)
-    if var2 == 0
-      var1
-    elsif negative?(var2)
-      var1 + var2.abs
-    elsif [:addition, :subtraction].include? operation(var2)
-      var1 + (-var2)
-    end
-  end
-
-  def sign
-    '-'
-  end
-end

data/lib/symbolic/operation/binary.rb

@@ -1,54 +0,0 @@
-class Symbolic::Operation::Binary < Symbolic::Operation
-  def self.simplify(var1, var2)
-    simplify_first_arg(var1, var2) || simplify_second_arg(var1, var2)
-  end
-
-  def self.symmetric
-    def self.simplify(var1, var2)
-      simplify_first_arg(var1, var2) || simplify_first_arg(var2, var1)
-    end
-
-    def ==(object)
-      (object.class == self.class) &&
-      ((object.var1 == @var1 && object.var2 == @var2) || (object.var1 == @var2 && object.var2 == @var1))
-    end
-  end
-
-  def initialize(var1, var2)
-    @var1, @var2 = var1, var2
-  end
-
-  def variables
-    @var1.variables | @var2.variables
-  end
-
-  def undefined_variables
-    variables.select {|it| it.value.nil? }
-  end
-
-  def value
-    @var1.value.send sign, @var2.value if undefined_variables.empty?
-  end
-
-  def detailed_operations
-    operations_of(@var1).tap {|it| it.merge!(operations_of @var2)[sign] += 1 }
-  end
-
-  def to_s
-    "#{brackets @var1}#{sign}#{brackets @var2}"
-  end
-
-  def ==(object)
-    (object.class == self.class) && (object.var1 == @var1 && object.var2 == @var2)
-  end
-
-  protected
-
-  attr_reader :var1, :var2
-
-  private
-
-  def operations_of(var)
-    var.is_a?(Symbolic) ? var.detailed_operations : Hash.new(0)
-  end
-end

data/lib/symbolic/operation/unary/minus.rb

@@ -1,39 +0,0 @@
-class Symbolic::Operation
-  class Unary::Minus < Unary
-    def self.simplify(expression)
-      case operation(expression)
-      when :unary_minus
-        expression.abs
-      when :addition
-        -expression.send(:var1)-expression.send(:var2)
-      when :subtraction
-        expression.send(:var2) - expression.send(:var1)
-      end
-    end
-
-    def abs
-      # TODO: implement Symbolic#abs
-      @expression
-    end
-
-    def brackets_for
-      [:addition, :subtraction]
-    end
-
-    def value
-      -@expression.value if undefined_variables.empty?
-    end
-
-    def ==(object)
-      object.is_a?(Unary::Minus) && object.abs == @expression
-    end
-
-    def detailed_operations
-      @expression.detailed_operations.tap {|it| it['-@'] += 1}
-    end
-
-    def to_s
-      "-#{brackets @expression}"
-    end
-  end
-end

data/lib/symbolic/operation/unary.rb

@@ -1,13 +0,0 @@
-class Symbolic::Operation::Unary < Symbolic::Operation
-  def initialize(expression)
-    @expression = expression
-  end
-
-  def variables
-    @expression.variables
-  end
-
-  def undefined_variables
-    @expression.undefined_variables
-  end
-end

data/lib/symbolic/operation.rb

@@ -1,61 +0,0 @@
-class Symbolic::Operation
-  include Symbolic
-
-  def self.for(*args)
-    simplify(*args) || new(*args)
-  end
-
-  def self.negative?(var)
-    var.is_a?(Unary::Minus) || (var.is_a?(Numeric) && var < 0)
-  end
-
-  private
-
-  def self.operation(expression)
-    case expression
-    when Unary::Minus           then :unary_minus
-    when Binary::Addition       then :addition
-    when Binary::Subtraction    then :subtraction
-    when Binary::Multiplication then :multiplication
-    when Binary::Division       then :division
-    when Binary::Exponentiation then :exponentiation
-    when Symbolic::Variable     then :variable
-    end
-  end
-
-  def operation(expression)
-    self.class.operation expression
-  end
-
-  def unary_minus?(expression)
-    operation(expression) == :unary_minus
-  end
-
-  def addition?(expression)
-    operation(expression) == :addition
-  end
-
-  def subtraction?(expression)
-    operation(expression) == :subtraction
-  end
-
-  def multiplication?(expression)
-    operation(expression) == :multiplication
-  end
-
-  def division?(expression)
-    operation(expression) == :division
-  end
-
-  def variable?(expression)
-    operation(expession) == :variable
-  end
-
-  def brackets(var)
-    brackets_for.include?(operation var) ? "(#{var})" : var.to_s
-  end
-
-  def brackets_for
-    []
-  end
-end