danica 2.0.3 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 988951405b8e2e23338da2bb9a47c090e27c42e8
-  data.tar.gz: 5542a1e13081409b7fd5c318c3092d08acd70849
+  metadata.gz: 2c3aa11c78083f2cf4dbf106b5edc4ae7370dc2a
+  data.tar.gz: d16d37bfebfd039a1469dec4029f927cd5374fed
 SHA512:
-  metadata.gz: 1ddcef37ee4cc2c80f566a64829645fb9f8ad3a3189fa0470c2bdee03d31d035bd00fd900e70cba579bfbe7a7ab37a13c850f4f855cf8c775b5a2988cb5b7e24
-  data.tar.gz: b8d6b8d3c6d590b4b5d9a76e4cc41cc0fb9b3fd06b7dd48253a162b9c2b7dd2d2b0b5e9b23f73b3703c6fa6b4cf549944cc21eaa0aab108017da646146db1342
+  metadata.gz: ec1d1e75b021be3608dd5f2aae2662fc8104d9cbd4b10e27fb4d6ca8aeb8c5c09542e58443799284c30965f4d3d5b5d2d5f5dbd659645c7b36d87b143f1d933a
+  data.tar.gz: de6db957793d4f43a74b5c9c311ed82cafdd6f016dbe260b7d09d66418297d1d35eacf47a6909d8376efaf3ab33f3201c190d5bc48e40dcbe546b1a6d1729083

data/README.md

@@ -125,11 +125,6 @@ end
 
 #### Sample
 ```ruby
-require 'danica/operator/product'
-require 'danica/operator/sum'
-require 'danica/operator/division'
-require 'danica/operator/power'
-
 module Danica
   class Function::Spatial < Function
     variables :time, :acceleration, :initial_space, :initial_velocity

data/circle.yml

@@ -0,0 +1,10 @@
+dependencies:
+  post:
+    - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+    - chmod +x ./cc-test-reporter
+
+test:
+  pre:
+    - ./cc-test-reporter before-build
+  override:
+    - bundle exec rspec; ./cc-test-reporter after-build --exit-code $?

data/danica.gemspec

@@ -26,6 +26,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec-mocks'
   spec.add_development_dependency 'pry-nav'
   spec.add_development_dependency 'simplecov'
-  spec.add_development_dependency 'codeclimate-test-reporter'
-
 end

data/lib/danica.rb

@@ -4,6 +4,8 @@ module Danica
   autoload :BaseOperations, 'danica/base_operations'
   autoload :Common,        'danica/common'
   autoload :Number,        'danica/number'
+  autoload :Negative,      'danica/negative'
+  autoload :Group,         'danica/group'
   autoload :Variable,      'danica/variable'
   autoload :Operator,      'danica/operator'
   autoload :Function,      'danica/function'
@@ -18,5 +20,8 @@ module Danica
   autoload :Exponential,   'danica/exponential'
   autoload :Sin,           'danica/sin'
   autoload :Cos,           'danica/cos'
+
+  E = Constant.new(Math::E, :e, 'exp(1)')
+  PI =  Constant.new(Math::PI, '\pi', :pi)
 end
 

data/lib/danica/base_operations.rb

@@ -1,7 +1,21 @@
 module Danica
   module BaseOperations
     def +(other)
-      return Sum.new(self, other)
+      return other + self if other.is_a?(Sum)
+      Sum.new(self, other)
+    end
+
+    def *(other)
+      return other * self if other.is_a?(Product)
+      Product.new(self, other)
+    end
+
+    def /(other)
+      Division.new(self, other)
+    end
+
+    def -(other)
+      self + Negative.new(other)
     end
   end
 end

data/lib/danica/common.rb

@@ -5,22 +5,10 @@ module Danica
     require 'danica/common/variables_builder'
 
     attr_accessor :variables
-  
+ 
     def to_f
       raise 'Not IMplemented yet'
     end
-
-    def calculate(*args)
-      vars_map = args.extract_options!
-      vars_map = variables_value_hash.merge(vars_map)
-      vars_map.each do |k, v|
-        unless v && (v.is_a?(Integer) || v.valued?)
-          vars_map[k] = args.shift
-        end
-      end
-
-      self.class.new(vars_map).to_f
-    end
   
     def to_tex
       Number.new(to_f).to_tex
@@ -74,7 +62,7 @@ module Danica
       return Number.new(value) if value.is_a?(Numeric)
       return Variable.new(value) if value.is_a?(Hash)
       return Variable.new(name: value) if [ String, Symbol ].any? { |c| value.is_a?(c) }
-      return Variable.new if value == nil
+      return Variable.new if value.nil?
       value
     end
   end

data/lib/danica/constant.rb

@@ -31,8 +31,5 @@ module Danica
       true
     end
   end
-
-  E = Constant.new(Math::E, :e, 'exp(1)')
-  PI =  Constant.new(Math::PI, '\pi', :pi)
 end
 

data/lib/danica/function.rb

@@ -9,5 +9,17 @@ module Danica
 
       super({ variables: args.flatten }.merge(options))
     end
+
+    def calculate(*args)
+      vars_map = args.extract_options!
+      vars_map = variables_value_hash.merge(vars_map)
+      vars_map.each do |k, v|
+        unless v && (v.is_a?(Integer) || v.valued?)
+          vars_map[k] = args.shift
+        end
+      end
+
+      self.class.new(vars_map).to_f
+    end
   end
 end

data/lib/danica/group.rb

@@ -0,0 +1,21 @@
+module Danica
+  class Group <  Common
+    include ActiveModel::Model
+
+    attr_accessor :value
+    
+    delegate :to_f, :valued?, to: :value
+
+    def initialize(value)
+      @value = wrap_value(value)
+    end
+
+    def to_tex
+      "(#{value.to_tex})"
+    end
+
+    alias_method :to_gnu, :to_tex
+  end
+end
+
+

data/lib/danica/negative.rb

@@ -0,0 +1,31 @@
+module Danica
+  class Negative <  Common
+    include ActiveModel::Model
+
+    attr_accessor :value
+    
+    delegate :valued?, to: :value
+
+    def initialize(value)
+      @value = wrap_value(value)
+    end
+
+    def to_f
+      -value.to_f
+    end
+
+    def to_tex
+      "-#{value.to_tex}"
+    end
+
+    def to_gnu
+      "-#{value.to_gnu}"
+    end
+
+    def ==(other)
+      return false unless other.class == self.class
+      value == other.value
+    end
+  end
+end
+

data/lib/danica/number.rb

@@ -20,8 +20,12 @@ module Danica
       value.present?
     end
 
+    def ==(other)
+      return false unless other.class == self.class
+      value == other.value
+    end
+
     alias_method :to_gnu, :to_tex
   end
 end
 
-

data/lib/danica/operator/chained.rb

@@ -5,8 +5,18 @@ module Danica
         chain(variables.map(&:to_f))
       end
 
+      def include?(value)
+        value = wrap_value(value)
+        variables.include?(value)
+      end
+
       private
 
+      def repack(other)
+        other_variables = other.is_a?(self.class) ? other.variables : [ other ]
+        self.class.new(variables + other_variables)
+      end
+
       def tex_string
         (numeric_to_tex + non_numeric_variables.map(&:to_tex)).join(" #{tex_symbol} ")
       end

data/lib/danica/product.rb

@@ -2,6 +2,10 @@ require 'danica/operator/chained'
 
 module Danica
   class Product < Operator::Chained
+    def *(other)
+      repack(other)
+    end
+
     private
 
     def tex_symbol

data/lib/danica/sum.rb

@@ -2,6 +2,10 @@ require 'danica/operator/chained'
 
 module Danica
   class Sum < Operator::Chained
+    def +(other)
+      repack(other)
+    end
+
     private
 
     def tex_symbol

data/lib/danica/version.rb

@@ -1,3 +1,3 @@
 module Danica
-  VERSION = '2.0.3'
+  VERSION = '2.0.4'
 end

data/spec/lib/danica/constant_spec.rb

@@ -4,7 +4,8 @@ describe Danica::Constant do
   subject { described_class.new(2.5, :M, :m) }
   let(:other) { described_class.new(3, :N, :n) }
 
-  it_behaves_like 'an object with + operation'
+  it_behaves_like 'an object that respond to basic_methods'
+  it_behaves_like 'an object with basic operation'
 
   describe '#to_f' do
     it 'has a value' do

data/spec/lib/danica/cos_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe Danica::Cos do
-  it_behaves_like 'an object with + operation' do
-    subject { described_class.new(:x) }
-  end
+  subject { described_class.new(:x) }
+
+  it_behaves_like 'an object that respond to basic_methods'
+  it_behaves_like 'an object with basic operation'
 
   it_behaves_like 'a operator with a single input value', {
     variable_value: Math::PI,

data/spec/lib/danica/division_spec.rb

@@ -4,7 +4,8 @@ describe Danica::Division do
   let(:variables) { [2, 4] }
   subject { described_class.new(*variables) }
 
-  it_behaves_like 'an object with + operation'
+  it_behaves_like 'an object that respond to basic_methods'
+  it_behaves_like 'an object with basic operation'
 
   it_behaves_like 'a operator that has two terms', :division, {
     values: [ 2, 4 ],

data/spec/lib/danica/exponential_spec.rb

@@ -3,7 +3,8 @@ require 'spec_helper'
 describe Danica::Exponential do
   subject { described_class.new(2) }
 
-  it_behaves_like 'an object with + operation'
+  it_behaves_like 'an object that respond to basic_methods'
+  it_behaves_like 'an object with basic operation'
 
   it_behaves_like 'a operator with a single input value', {
     variable_value: 2,

data/spec/lib/danica/function_spec.rb

@@ -1,247 +1,250 @@
 require 'spec_helper'
 
 describe Danica::Function do
-  module Danica
-    class Function::Spatial < Function
-      variables :time, :acceleration, :initial_space, :initial_velocity
-      delegate :to_f, :to_tex, :to_gnu, to: :sum
-
-      private
-
-      def sum
-        @sum ||= Sum.new(parcels)
-      end
-
-      def parcels
-        [
-          initial_space,
-          spatial_velocity,
-          spatial_acceleration
-        ]
-      end
-
-      def spatial_velocity
-        Product.new(initial_velocity, time)
-      end
-
-      def spatial_acceleration
-        Division.new(Product.new(acceleration, time_squared), 2)
-      end
-
-      def time_squared
-        Power.new(time, 2)
-      end
-    end
-  end
-
-  let(:variables) do
-    {
-      time: :t,
-      acceleration: 'a',
-      initial_space: { name: :S0, latex: 'S_0' },
-      initial_velocity: { name: :V0, latex: 'V_0' }
-    }
-  end
-
-  subject { described_class::Spatial.new(variables) }
-
-  describe '#to_tex' do
-    context 'when creating the spatial operator for constantly accelerated movement' do
-      let(:expected) { 'S_0 + V_0 \cdot t + \frac{a \cdot t^{2}}{2}'  }
-
-      it 'return the latex format CAM' do
-        expect(subject.to_tex).to eq(expected)
-      end
-    end
-  end
-
-  describe '#to_gnu' do
-    context 'when creating the spatial operator for constantly accelerated movement' do
-      let(:expected) { 'S0 + V0 * t + a * t**2/2'  }
-
-      it 'return the latex format CAM' do
-        expect(subject.to_gnu).to eq(expected)
-      end
-    end
-  end
-
-  describe '#variables_hash' do
-    let(:expected) do
+  describe 'spatial' do
+    let(:variables) do
       {
-        time: Danica::Variable.new(name: :t),
-        acceleration: Danica::Variable.new(name: 'a'),
-        initial_space: Danica::Variable.new( name: :S0, latex: 'S_0' ),
-        initial_velocity: Danica::Variable.new( name: :V0, latex: 'V_0' )
+        time: :t,
+        acceleration: 'a',
+        initial_space: { name: :S0, latex: 'S_0' },
+        initial_velocity: { name: :V0, latex: 'V_0' }
       }
     end
 
-    context 'when variables are already wrapped with DanicaVariable' do
-      let(:variables) { expected }
-      it 'returns a hash with the variabels' do
-        expect(subject.variables_hash).to eq(expected)
-      end
-    end
+    subject { described_class::Spatial.new(variables) }
+    it_behaves_like 'an object that respond to basic_methods'
 
-    context 'when variables have been defined with string name' do
-      before do
-        variables.change_keys!(&:to_s)
-      end
+    describe '#to_tex' do
+      context 'when creating the spatial operator for constantly accelerated movement' do
+        let(:expected) { 'S_0 + V_0 \cdot t + \frac{a \cdot t^{2}}{2}'  }
 
-      it 'returns a hash with the variabels' do
-        expect(subject.variables_hash).to eq(expected)
+        it 'return the latex format CAM' do
+          expect(subject.to_tex).to eq(expected)
+        end
       end
     end
 
-    context 'when variables are not wrapped yet' do
-      it 'returns a hash with the variabels' do
-        expect(subject.variables_hash).to eq(expected)
+    describe '#to_gnu' do
+      context 'when creating the spatial operator for constantly accelerated movement' do
+        let(:expected) { 'S0 + V0 * t + a * t**2/2'  }
+
+        it 'return the latex format CAM' do
+          expect(subject.to_gnu).to eq(expected)
+        end
       end
     end
 
-    context 'when changing a variable' do
-      before do
-        subject.time = :x
-        expected[:time] = Danica::Variable.new(name: :x)
+    describe '#variables_hash' do
+      let(:expected) do
+        {
+          time: Danica::Variable.new(name: :t),
+          acceleration: Danica::Variable.new(name: 'a'),
+          initial_space: Danica::Variable.new( name: :S0, latex: 'S_0' ),
+          initial_velocity: Danica::Variable.new( name: :V0, latex: 'V_0' )
+        }
       end
 
-      it do
-        expect(subject.variables_hash).to eq(expected)
+      context 'when variables are already wrapped with DanicaVariable' do
+        let(:variables) { expected }
+        it 'returns a hash with the variabels' do
+          expect(subject.variables_hash).to eq(expected)
+        end
       end
-    end
 
-    context 'when initializing with array' do
-      context 'as hash' do
-        let(:variables) { [ :t, 'a', {name: :S0, latex: 'S_0'}, { name: :V0, latex: 'V_0' } ] }
-        subject { described_class::Spatial.new(variables) }
+      context 'when variables have been defined with string name' do
+        before do
+          variables.change_keys!(&:to_s)
+        end
 
         it 'returns a hash with the variabels' do
           expect(subject.variables_hash).to eq(expected)
         end
       end
-    end
-
-    context 'when initializing with sequence' do
-      context 'as hash' do
-        let(:variables) { [ :t, 'a', {name: :S0, latex: 'S_0'}, { name: :V0, latex: 'V_0' } ] }
-        subject { described_class::Spatial.new(*variables, {}) }
 
+      context 'when variables are not wrapped yet' do
         it 'returns a hash with the variabels' do
           expect(subject.variables_hash).to eq(expected)
         end
       end
-    end
 
-    context 'when initializing with variables array' do
-      context 'as hash' do
-        let(:variables) { [ :t, 'a', {name: :S0, latex: 'S_0'}, { name: :V0, latex: 'V_0' } ] }
-        subject { described_class::Spatial.new(variables: variables) }
+      context 'when changing a variable' do
+        before do
+          subject.time = :x
+          expected[:time] = Danica::Variable.new(name: :x)
+        end
 
-        it 'returns a hash with the variabels' do
+        it do
           expect(subject.variables_hash).to eq(expected)
         end
       end
-    end
-  end
 
-  describe '#variables' do
-    context 'when initialized with an array of variables' do
-      subject { described_class::Spatial.new(variables: variables.values) }
-      let(:expected) { variables.values.map { |v| subject.send(:wrap_value, v)} }
-      it do
-        expect(subject.variables.compact).to eq(expected)
+      context 'when initializing with array' do
+        context 'as hash' do
+          let(:variables) { [ :t, 'a', {name: :S0, latex: 'S_0'}, { name: :V0, latex: 'V_0' } ] }
+          subject { described_class::Spatial.new(variables) }
+
+          it 'returns a hash with the variabels' do
+            expect(subject.variables_hash).to eq(expected)
+          end
+        end
       end
-    end
 
-    context 'when not initializing all variables' do
-      subject { described_class::Spatial.new }
-      let(:time) { Danica::Variable.new(name: :t) }
+      context 'when initializing with sequence' do
+        context 'as hash' do
+          let(:variables) { [ :t, 'a', {name: :S0, latex: 'S_0'}, { name: :V0, latex: 'V_0' } ] }
+          subject { described_class::Spatial.new(*variables, {}) }
 
-      context 'when initialized with an empty variable set' do
-        it do
-          expect(subject.variables.compact).to be_empty
+          it 'returns a hash with the variabels' do
+            expect(subject.variables_hash).to eq(expected)
+          end
         end
       end
 
-      context 'when changing a variable' do
-        before do
-          subject.time = time
+      context 'when initializing with variables array' do
+        context 'as hash' do
+          let(:variables) { [ :t, 'a', {name: :S0, latex: 'S_0'}, { name: :V0, latex: 'V_0' } ] }
+          subject { described_class::Spatial.new(variables: variables) }
+
+          it 'returns a hash with the variabels' do
+            expect(subject.variables_hash).to eq(expected)
+          end
         end
+      end
+    end
 
-        it 'returns the list of variables' do
-          expect(subject.variables.compact).to eq([ time ])
+    describe '#variables' do
+      context 'when initialized with an array of variables' do
+        subject { described_class::Spatial.new(variables: variables.values) }
+        let(:expected) { variables.values.map { |v| subject.send(:wrap_value, v)} }
+        it do
+          expect(subject.variables.compact).to eq(expected)
         end
       end
 
-      context 'when initializing with a variable set' do
-        let(:names) { [ :t, :a, :s0, :v0 ] }
-        subject { described_class::Spatial.new *names }
+      context 'when not initializing all variables' do
+        subject { described_class::Spatial.new }
+        let(:time) { Danica::Variable.new(name: :t) }
 
-        it 'returns the variables given oin initialization' do
-          expect(subject.variables.map(&:name)).to eq(names)
+        context 'when initialized with an empty variable set' do
+          it do
+            expect(subject.variables.compact).to be_empty
+          end
         end
 
-        context 'when initializing variables with a hash out of order' do
-          let(:variables) do
-            {
-              initial_velocity: :v0,
-              initial_space: :s0,
-              acceleration: :a,
-              time: :t
-            }
+        context 'when changing a variable' do
+          before do
+            subject.time = time
           end
-          subject { described_class::Spatial.new variables }
 
-          it 'returns the variables given on initialization' do
+          it 'returns the list of variables' do
+            expect(subject.variables.compact).to eq([ time ])
+          end
+        end
+
+        context 'when initializing with a variable set' do
+          let(:names) { [ :t, :a, :s0, :v0 ] }
+          subject { described_class::Spatial.new *names }
+
+          it 'returns the variables given oin initialization' do
             expect(subject.variables.map(&:name)).to eq(names)
           end
+
+          context 'when initializing variables with a hash out of order' do
+            let(:variables) do
+              {
+                initial_velocity: :v0,
+                initial_space: :s0,
+                acceleration: :a,
+                time: :t
+              }
+            end
+            subject { described_class::Spatial.new variables }
+
+            it 'returns the variables given on initialization' do
+              expect(subject.variables.map(&:name)).to eq(names)
+            end
+          end
         end
       end
     end
-  end
 
-  describe '#calculate' do
-    context 'when all variables have value' do
-      let(:time_value) { 2 }
-      let(:time) { time_value }
-      let(:acceleration) { 3 }
-      let(:initial_space) { 1 }
-      let(:initial_velocity) { 1 }
-      subject { described_class::Spatial.new(time, acceleration, initial_space, initial_velocity) }
-      let(:expected) { initial_space + initial_velocity * time_value + acceleration * (time_value ** 2) / 2.0 }
-
-      it 'retuirns the calculated value' do
-        expect(subject.calculate).to eq(expected)
-      end
+    describe '#calculate' do
+      context 'when all variables have value' do
+        let(:time_value) { 2 }
+        let(:time) { time_value }
+        let(:acceleration) { 3 }
+        let(:initial_space) { 1 }
+        let(:initial_velocity) { 1 }
+        subject { described_class::Spatial.new(time, acceleration, initial_space, initial_velocity) }
+        let(:expected) { initial_space + initial_velocity * time_value + acceleration * (time_value ** 2) / 2.0 }
+
+        it 'retuirns the calculated value' do
+          expect(subject.calculate).to eq(expected)
+        end
 
-      context 'when not all variables have value' do
-        let(:time) { :t }
+        context 'when not all variables have value' do
+          let(:time) { :t }
 
-        it do
-          expect { subject.calculate }.to raise_error(Danica::Exception::NotDefined)
-        end
+          it do
+            expect { subject.calculate }.to raise_error(Danica::Exception::NotDefined)
+          end
 
-        context 'but calling calculate with a value for the variables' do
-          it 'calculate using the given value' do
-            expect(subject.calculate(time_value)).to eq(expected)
+          context 'but calling calculate with a value for the variables' do
+            it 'calculate using the given value' do
+              expect(subject.calculate(time_value)).to eq(expected)
+            end
+
+            it 'does not change the values of then valued variables' do
+              expect do
+                subject.calculate(time_value)
+              end.not_to change(subject.time, :valued?)
+            end
           end
 
-          it 'does not change the values of then valued variables' do
-            expect do
-              subject.calculate(time_value)
-            end.not_to change(subject.time, :valued?)
+          context 'when calling with a hash for the values' do
+            it 'calculate using the given value' do
+              expect(subject.calculate(time: time_value)).to eq(expected)
+            end
+
+            it 'does not change the values of then valued variables' do
+              expect do
+                subject.calculate(time: time_value)
+              end.not_to change(subject.time, :valued?)
+            end
           end
         end
+      end
+    end
+  end
 
-        context 'when calling with a hash for the values' do
-          it 'calculate using the given value' do
-            expect(subject.calculate(time: time_value)).to eq(expected)
-          end
+  describe 'gauss' do
+    let(:variables) do
+      {
+        x: :x,
+        median: :u,
+        variance_root: :v
+      }
+    end
 
-          it 'does not change the values of then valued variables' do
-            expect do
-              subject.calculate(time: time_value)
-            end.not_to change(subject.time, :valued?)
-          end
+    subject { described_class::Gauss.new(variables) }
+    it_behaves_like 'an object that respond to basic_methods'
+
+    describe '#to_tex' do
+      context 'when creating the spatial operator for constantly accelerated movement' do
+        let(:expected) { '\frac{1}{\sqrt{6.283185307179586 \cdot v^{2}}} \cdot e^{-\frac{(x + -u)^{2}}{2 \cdot v^{2}}}'  }
+
+        it 'return the latex format CAM' do
+          expect(subject.to_tex).to eq(expected)
+        end
+      end
+    end
+
+    describe '#to_gnu' do
+      context 'when creating the spatial operator for constantly accelerated movement' do
+        let(:expected) { '1/sqrt(6.283185307179586 * v**2) * exp(-(x + -u)**2/2 * v**2)' }
+
+        it 'return the latex format CAM' do
+          expect(subject.to_gnu).to eq(expected)
         end
       end
     end

data/spec/lib/danica/negative_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Danica::Negative do
+  let(:value) { Danica::Number.new(10) }
+  subject { described_class.new(value) }
+
+  it_behaves_like 'an object that respond to basic_methods'
+
+  describe '#to_f' do
+    it 'returns the float of value' do
+      expect(subject.to_f).to eq(-10)
+    end
+
+    it { expect(subject.to_f).to be_a(Float) }
+  end
+
+  describe '#to_tex' do
+    context 'when value should be integer' do
+      let(:value) { 10.0 }
+
+      it 'returns the value integer string' do
+        expect(subject.to_tex).to eq('-10')
+      end
+    end
+
+    context 'when value should be float' do
+      let(:value) { 10.5 }
+
+      it 'returns the value float string' do
+        expect(subject.to_tex).to eq('-10.5')
+      end
+    end
+  end
+
+  describe '#to_gnu' do
+    context 'when value should be integer' do
+      let(:value) { 10.0 }
+
+      it 'returns the value integer string' do
+        expect(subject.to_gnu).to eq('-10')
+      end
+    end
+
+    context 'when value should be a float' do
+      let(:value) { 10.5 }
+
+      it 'returns the value float string' do
+        expect(subject.to_gnu).to eq('-10.5')
+      end
+    end
+  end
+end

data/spec/lib/danica/number_spec.rb

@@ -4,7 +4,9 @@ describe Danica::Number do
   let(:value) { 10 }
   subject { described_class.new(value) }
 
-  it_behaves_like 'an object with + operation'
+  it_behaves_like 'an object that respond to basic_methods'
+
+  it_behaves_like 'an object with basic operation'
 
   describe '#to_f' do
     it 'returns the float of value' do
@@ -23,10 +25,10 @@ describe Danica::Number do
       end
     end
 
-    context 'when value should be integer' do
+    context 'when value should be a float' do
       let(:value) { 10.5 }
 
-      it 'returns the value integer string' do
+      it 'returns the value float string' do
         expect(subject.to_tex).to eq('10.5')
       end
     end

data/spec/lib/danica/power_spec.rb

@@ -4,7 +4,8 @@ describe Danica::Power do
   let(:variables) { [2, 4] }
   subject { described_class.new(*variables) }
 
-  it_behaves_like 'an object with + operation'
+  it_behaves_like 'an object that respond to basic_methods'
+  it_behaves_like 'an object with basic operation'
 
   it_behaves_like 'a operator that has two terms', :power, {
     values: [ 3, 2 ],

data/spec/lib/danica/product_spec.rb

@@ -2,8 +2,20 @@ require 'spec_helper'
 
 describe Danica::Product do
   subject { described_class.new(2,4) }
+  it_behaves_like 'an object that respond to basic_methods'
 
-  it_behaves_like 'an object with + operation'
+  it_behaves_like 'an object with * operation' do
+    let(:subject_included) { 4 }
+
+    context 'when other is also a sum' do
+      let(:other) { described_class.new(200, 5) }
+
+      it 'includes the sum parcels' do
+        expect(result).to include(200)
+      end
+    end
+  end
+  it_behaves_like 'an object with basic operation', ignore: :*
 
   it_behaves_like 'a operator that joins many variables with same operation', {
     calculated: 24,

data/spec/lib/danica/sin_spec.rb

@@ -3,7 +3,8 @@ require 'spec_helper'
 describe Danica::Sin do
   subject { described_class.new(10) }
 
-  it_behaves_like 'an object with + operation'
+  it_behaves_like 'an object that respond to basic_methods'
+  it_behaves_like 'an object with basic operation'
 
   it_behaves_like 'a operator with a single input value', {
     variable_value: Math::PI / 2.0,

data/spec/lib/danica/squared_root_spec.rb

@@ -3,7 +3,8 @@ require 'spec_helper'
 describe Danica::SquaredRoot do
   subject { described_class.new(9) }
 
-  it_behaves_like 'an object with + operation'
+  it_behaves_like 'an object that respond to basic_methods'
+  it_behaves_like 'an object with basic operation'
 
   it_behaves_like 'a operator with a single input value', {
     variable_value: 9,

data/spec/lib/danica/sum_spec.rb

@@ -3,7 +3,23 @@ require 'spec_helper'
 describe Danica::Sum do
   subject { described_class.new(10, 2) }
 
-  it_behaves_like 'an object with + operation'
+  it_behaves_like 'an object that respond to basic_methods'
+
+  it_behaves_like 'an object with basic operation', operations: %i(* /)
+  it_behaves_like 'an object with + operation' do
+    let(:subject_included) { 10 }
+
+    context 'when other is also a sum' do
+      let(:other) { described_class.new(200, 5) }
+
+      it 'includes the sum parcels' do
+        expect(result).to include(200)
+      end
+    end
+  end
+  it_behaves_like 'an object with - operation' do
+    let(:subject_included) { 10 }
+  end
 
   it_behaves_like 'a operator that joins many variables with same operation', {
     calculated: 10,

data/spec/lib/danica/variable_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe Danica::Variable do
-  it_behaves_like 'an object with + operation' do
+  it_behaves_like 'an object that respond to basic_methods'
+
+  it_behaves_like 'an object with basic operation' do
     subject { described_class.new(value: 100) }
   end
 

data/spec/spec_helper.rb

@@ -4,11 +4,6 @@ SimpleCov.profiles.define 'gem' do
   add_filter '/spec/'
 end
 
-if ENV['CODECLIMATE_REPO_TOKEN']
-  require 'codeclimate-test-reporter'
-  CodeClimate::TestReporter.start
-end
-
 SimpleCov.start 'gem'
 require 'pry-nav'
 require 'danica'

data/spec/support/models/functions/gauss.rb

@@ -0,0 +1,41 @@
+module Danica
+  class Function::Gauss < Function
+    variables :x, :median, :variance_root
+    delegate :to_f, :to_tex, :to_gnu, to: :product
+
+    private
+
+    def product
+      @sum ||= Product.new(parcels)
+    end
+
+    def parcels
+      [
+        Division.new(1, denominator),
+        Exponential.new(exponential)
+      ]
+    end
+
+    def denominator
+      SquaredRoot.new(
+        Product.new(2, PI, variance),
+      )
+    end
+
+    def exponential
+      Negative.new(
+        Division.new(
+          Power.new(Group.new(
+            Sum.new(x, Negative.new(median))
+          ), 2),
+          Product.new(2, variance)
+        )
+      )
+    end
+
+    def variance
+      @variance ||= Power.new(variance_root, 2)
+    end
+  end
+end
+

data/spec/support/models/functions/spatial.rb

@@ -0,0 +1,32 @@
+module Danica
+  class Function::Spatial < Function
+    variables :time, :acceleration, :initial_space, :initial_velocity
+    delegate :to_f, :to_tex, :to_gnu, to: :sum
+
+    private
+
+    def sum
+      @sum ||= Sum.new(parcels)
+    end
+
+    def parcels
+      [
+        initial_space,
+        spatial_velocity,
+        spatial_acceleration
+      ]
+    end
+
+    def spatial_velocity
+      Product.new(initial_velocity, time)
+    end
+
+    def spatial_acceleration
+      Division.new(Product.new(acceleration, time_squared), 2)
+    end
+
+    def time_squared
+      Power.new(time, 2)
+    end
+  end
+end

data/spec/support/shared_examples/base_operations.rb

@@ -1,4 +1,77 @@
+shared_examples 'an object with basic operation' do |operations:%i(+ - * /), ignore:[]|
+  (operations - [ ignore ].flatten).each do |operation|
+    it_behaves_like "an object with #{operation} operation"
+  end
+end
+
+shared_examples 'an object with an operation' do |clazz|
+  it { expect(result).to be_a(clazz) }
+
+  it 'includes other as parcel' do
+    expect(result).to be_include(other)
+  end
+
+  it 'includes the subject as parcel' do
+    expect(result).to be_include(subject_included)
+  end
+end
+
 shared_examples 'an object with + operation' do
   let(:other) { 104 }
-  it { expect(subject + other).to be_a(Danica::Sum) }
+  let(:result) { subject + other }
+  let(:subject_included) { subject }
+
+  it_behaves_like 'an object with an operation', Danica::Sum
+
+  context 'when operating as reverse' do
+    let(:result) { Danica::Number.new(other) + subject }
+    it_behaves_like 'an object with an operation', Danica::Sum
+  end
+end
+
+shared_examples 'an object with * operation' do
+  let(:other) { 104 }
+  let(:result) { subject * other }
+  let(:subject_included) { subject }
+
+  it_behaves_like 'an object with an operation', Danica::Product
+
+  context 'when operating as reverse' do
+    let(:result) { Danica::Number.new(other) * subject }
+    it_behaves_like 'an object with an operation', Danica::Product
+  end
+end
+
+shared_examples 'an object with / operation' do
+  let(:other) { 104 }
+  let(:other_number) { Danica::Number.new(104) }
+  let(:result) { subject / other }
+
+  it { expect(result).to be_a(Danica::Division) }
+
+  it 'includes other as denominator' do
+    expect(result.denominator).to eq(other_number)
+  end
+
+  it 'includes the subject as numerator' do
+    expect(result.numerator).to eq(subject)
+  end
+end
+
+shared_examples 'an object with - operation' do
+  let(:other) { 104 }
+  let(:negative_other) { Danica::Negative.new(other) }
+  let(:result) { subject - other }
+  let(:subject_included) { subject }
+
+  it { expect(result).to be_a(Danica::Sum) }
+
+  it 'includes other as negative parcel' do
+    expect(result).to be_include(negative_other)
+  end
+
+  it 'includes the subject as parcel' do
+    expect(result).to be_include(subject_included)
+  end
 end
+

data/spec/support/shared_examples/common.rb

@@ -0,0 +1,6 @@
+shared_examples 'an object that respond to basic_methods' do |ignore: [], methods: %i(to_f to_tex to_gnu valued?)|
+  (methods - ignore).each do |method|
+    it {expect(subject).to respond_to(method) }
+  end
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: danica
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-10 00:00:00.000000000 Z
+date: 2017-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -150,20 +150,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: codeclimate-test-reporter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: 
 email:
 - darthjee@gmail.com
@@ -176,6 +162,7 @@ files:
 - Gemfile
 - README.md
 - Rakefile
+- circle.yml
 - danica.gemspec
 - docker-compose.yml
 - lib/danica.rb
@@ -190,6 +177,8 @@ files:
 - lib/danica/exception/not_defined.rb
 - lib/danica/exponential.rb
 - lib/danica/function.rb
+- lib/danica/group.rb
+- lib/danica/negative.rb
 - lib/danica/number.rb
 - lib/danica/operator.rb
 - lib/danica/operator/chained.rb
@@ -205,6 +194,7 @@ files:
 - spec/lib/danica/division_spec.rb
 - spec/lib/danica/exponential_spec.rb
 - spec/lib/danica/function_spec.rb
+- spec/lib/danica/negative_spec.rb
 - spec/lib/danica/number_spec.rb
 - spec/lib/danica/power_spec.rb
 - spec/lib/danica/product_spec.rb
@@ -213,8 +203,11 @@ files:
 - spec/lib/danica/sum_spec.rb
 - spec/lib/danica/variable_spec.rb
 - spec/spec_helper.rb
+- spec/support/models/functions/gauss.rb
+- spec/support/models/functions/spatial.rb
 - spec/support/shared_contexts/common.rb
 - spec/support/shared_examples/base_operations.rb
+- spec/support/shared_examples/common.rb
 - spec/support/shared_examples/operator/chained.rb
 - spec/support/shared_examples/operator/dual_term.rb
 - spec/support/shared_examples/operator/single_input.rb
@@ -238,7 +231,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Danica
@@ -248,6 +241,7 @@ test_files:
 - spec/lib/danica/division_spec.rb
 - spec/lib/danica/exponential_spec.rb
 - spec/lib/danica/function_spec.rb
+- spec/lib/danica/negative_spec.rb
 - spec/lib/danica/number_spec.rb
 - spec/lib/danica/power_spec.rb
 - spec/lib/danica/product_spec.rb
@@ -256,8 +250,11 @@ test_files:
 - spec/lib/danica/sum_spec.rb
 - spec/lib/danica/variable_spec.rb
 - spec/spec_helper.rb
+- spec/support/models/functions/gauss.rb
+- spec/support/models/functions/spatial.rb
 - spec/support/shared_contexts/common.rb
 - spec/support/shared_examples/base_operations.rb
+- spec/support/shared_examples/common.rb
 - spec/support/shared_examples/operator/chained.rb
 - spec/support/shared_examples/operator/dual_term.rb
 - spec/support/shared_examples/operator/single_input.rb