danica 2.3.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f4c20cfa612c100125cf73a89cd2d30f02ab4f12
-  data.tar.gz: 3894bdce489e74dfdd9dd59320177e6dbbce10b3
+  metadata.gz: 68db92a2ab4f0816a2678a44e458b7fcbeb87eda
+  data.tar.gz: b83bd4b12f815aae2c7d9eb1f00da008e886e8a5
 SHA512:
-  metadata.gz: 8d67bb880292f39d3b3946e1f9a386292fa06fc4f354e4f289ed542b7f24ae79e267bd30e047f3ff75aa5b832da0274b813f83e3b0c593500ec40f649fa985da
-  data.tar.gz: 5adcd6154c4c4b28a48c2cc99f1f859697a72254c759415a12e8597fc5e223552e4e8c15c5b6985ec55fdfc0d7ba2547748d9c029e8b06f2cbc19efdc2fb06ab
+  metadata.gz: 819529160a878cbc4b49d5c2323891cd3ddddabbacb68b764d8d5909fe26bcf84c1b1586294ef2449fe9331376893c103b6e4f600b6ea8871f3c82e232544725
+  data.tar.gz: 51d0237f2037afa9c1d4ac1af254d2a93ed9eb0a68341df0fce2830a19c2eb1dc0f5a29f047de83568206883e0d3f06c563b08acdbb24e432f811b8f96ddecf5

data/lib/danica.rb

@@ -13,6 +13,8 @@ module Danica
   autoload :Wrapper,          'danica/wrapper'
   autoload :Operator,         'danica/operator'
 
+  autoload :PI,               'danica/wrapper/constant'
+
   class << self
     delegate :build, to: :builder
 

data/lib/danica/common.rb

@@ -1,6 +1,7 @@
 module Danica
   module Common extend ::ActiveSupport::Concern
     included do
+      include Wrapper
       include DSL
 
       class << self
@@ -22,14 +23,6 @@ module Danica
   
     private
 
-    def wrap_value(value)
-      return wrap_value(number(value)) if value.is_a?(Numeric)
-      return wrap_value(variable(value)) if value.is_a?(Hash)
-      return wrap_value(variable(name: value)) if [ String, Symbol ].any? { |c| value.is_a?(c) }
-      return wrap_value(variable) if value.nil?
-      value
-    end
-
     def wrap_as_group(value)
       return value if is_grouped? || value.priority >= priority
       group(value)

data/lib/danica/function.rb

@@ -23,6 +23,10 @@ module Danica
       end
     end
 
+    def self.create(*vars, &block)
+      build(*vars, &block).new
+    end
+
     def initialize(*args)
       options = args.extract_options!
 
@@ -40,5 +44,15 @@ module Danica
 
       self.class.new(vars_map).to_f
     end
+
+    def describe_tex
+      "#{name}(#{variables.map(&:to_tex).join(', ')}) = #{to_tex}"
+    end
+
+    def describe_gnu
+      "#{name}(#{variables.map(&:to_gnu).join(', ')}) = #{to_gnu}"
+    end
+
+    autoload :Gauss,    'danica/function/gauss'
   end
 end

data/{spec/support/models/functions → lib/danica/function}/gauss.rb

@@ -1,9 +1,9 @@
 module Danica
-  class Function::Gauss < Function.build(:x, median: :u, variance_root: { latex: '\theta', gnu: :v }) { multiplication(parcels) }
+  class Function::Gauss < Function.build(:x, average: { latex: '\mu', gnu: :u }, variance_root: { latex: '\sigma', gnu: :v }) { multiplication(elements) }
 
     private
 
-    def parcels
+    def elements
       [
         division(1, denominator),
         exponential(exp)
@@ -11,8 +11,9 @@ module Danica
     end
 
     def denominator
+      variance_root *
       squared_root(
-        multiplication(2, PI, variance),
+        multiplication(2, PI),
       )
     end
 
@@ -20,7 +21,7 @@ module Danica
       negative(
         division(
           power(group(
-            addition(x, negative(median))
+            addition(x, negative(average))
           ), 2),
           multiplication(2, variance)
         )

data/lib/danica/operator/chained.rb

@@ -1,6 +1,12 @@
 module Danica
   class Operator
     class Chained < Operator
+      attr_reader :variables
+
+      def variables=(vars)
+        @variables = vars.map { |v| wrap_value(v) }
+      end
+
       def to_f
         chain(variables.map(&:to_f))
       end

data/lib/danica/variables_holder.rb

@@ -9,29 +9,33 @@ module Danica
         end
 
         def variables_names
-          @variables_names ||= (
-            (superclass.try(:variables_names) || []) + []
-          )
+          variables_hash.keys
+        end
+
+        def variables_hash
+          @variables_hash ||= (superclass.try(:variables_hash) || {}).dup
         end
       end
     end
 
-    attr_accessor :variables
- 
-    def variables=(variables)
-      @variables = variables.map { |v| wrap_value(v) }
+    def variables=(vars)
+      vars = vars.as_hash(self.class.variables_names).compact unless vars.is_a? Hash
+      vars = vars.change_values(skip_inner: false) { |v| wrap_value(v) }
+      @variables_hash = self.class.variables_hash.merge(vars)
     end
 
     def variables
-      @variables ||= variables_hash.values
+      variables_hash.values
     end
   
     def variables_hash
-      @variabels_map ||= (@variables || []).as_hash(self.class.variables_names)
+      @variables_hash ||= {}.merge(self.class.variables_hash)
     end
 
     def variables_value_hash
-      variables.map(&:value).as_hash(self.class.variables_names)
+      variables.map do |var|
+        var.try(:value)
+      end.as_hash(self.class.variables_names)
     end
 
     private

data/lib/danica/variables_holder/variables_builder.rb

@@ -1,5 +1,8 @@
 module Danica::VariablesHolder
   class VariablesBuilder
+    include Danica::DSL
+    include Danica::Wrapper
+
     attr_reader :instance, :attr_names
 
     def initialize(attr_names, instance)
@@ -8,16 +11,18 @@ module Danica::VariablesHolder
     end
 
     def build
-      attr_names.extract_options!.each do |name, default|
+      names_hash = attr_names.extract_options!
+
+      attr_names.each do |name|
         add_setter(name)
-        add_reader(name, default)
-        instance.variables_names << name
+        add_reader(name)
+        instance.variables_hash[name.to_sym] = wrap_value(name)
       end
 
-      attr_names.each do |name|
+      names_hash.each do |name, default|
         add_setter(name)
-        add_reader(name, name)
-        instance.variables_names << name
+        add_reader(name)
+        instance.variables_hash[name.to_sym] = wrap_value(default)
       end
     end
 
@@ -26,13 +31,12 @@ module Danica::VariablesHolder
     def add_setter(name)
       instance.send(:define_method, "#{name}=") do |value|
         variables_hash[name.to_sym] = wrap_value(value)
-        @variables = variables_hash.values
       end
     end
 
-    def add_reader(name, default)
+    def add_reader(name)
       instance.send(:define_method, name) do
-        variables_hash[name.to_sym] ||= wrap_value(default)
+        variables_hash[name.to_sym]
       end
     end
   end

data/lib/danica/version.rb

@@ -1,3 +1,3 @@
 module Danica
-  VERSION = '2.3.1'
+  VERSION = '2.4.0'
 end

data/lib/danica/wrapper.rb

@@ -1,5 +1,13 @@
 module Danica
   module Wrapper
+    def wrap_value(value)
+      return wrap_value(number(value)) if value.is_a?(Numeric)
+      return wrap_value(variable(value)) if value.is_a?(Hash)
+      return wrap_value(variable(name: value)) if [ String, Symbol ].any? { |c| value.is_a?(c) }
+      return wrap_value(variable) if value.nil?
+      value
+    end
+
     autoload :Number,    'danica/wrapper/number'
     autoload :Group,     'danica/wrapper/group'
     autoload :Negative,  'danica/wrapper/negative'

data/spec/lib/danica/dsl_spec.rb

@@ -17,8 +17,6 @@ shared_context 'a class with mapped dsl' do
     multiplication: Danica::Operator::Multiplication,
     product:        Danica::Operator::Multiplication,
     division:       Danica::Operator::Division,
-    sin:            Danica::Operator::Sin,
-    cos:            Danica::Operator::Cos,
     power:          Danica::Operator::Power
   }.each do |aliaz, clazz|
     it_behaves_like 'a class with alias to a clazz', aliaz, clazz, 2, 3
@@ -26,6 +24,8 @@ shared_context 'a class with mapped dsl' do
   {
     squared_root:  Danica::Operator::SquaredRoot,
     exponential:   Danica::Operator::Exponential,
+    sin:           Danica::Operator::Sin,
+    cos:           Danica::Operator::Cos,
     group:         Danica::Wrapper::Group,
     negative:      Danica::Wrapper::Negative,
     number:        Danica::Wrapper::Number,

data/spec/lib/danica/function/gauss_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Danica::Function::Gauss do
+  let(:variables) do
+    {
+      x: :x,
+      average: :u,
+      variance_root: { latex: '\theta', gnu: :v }
+    }
+  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}{\theta \cdot \sqrt{2 \cdot \pi}} \cdot e^{-\frac{\left(x -u\right)^{2}}{2 \cdot \theta^{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)/(v * sqrt(2 * pi)) * exp(-((x -u)**(2))/(2 * v**(2)))' }
+
+      it 'return the gnu format CAM' do
+        expect(subject.to_gnu).to eq(expected)
+      end
+    end
+  end
+
+  context 'when not passing variables' do
+    subject { described_class::Gauss.new }
+
+    describe '#to_tex' do
+      let(:expected) { '\frac{1}{\sigma \cdot \sqrt{2 \cdot \pi}} \cdot e^{-\frac{\left(x -\mu\right)^{2}}{2 \cdot \sigma^{2}}}'  }
+
+      it 'rely on default variables definition' do
+        expect(subject.to_tex).to eq(expected)
+      end
+    end
+
+    describe '#to_gnu' do
+      let(:expected) { '(1)/(v * sqrt(2 * pi)) * exp(-((x -u)**(2))/(2 * v**(2)))' }
+
+      it 'rely on default variables definition' do
+        expect(subject.to_gnu).to eq(expected)
+      end
+    end
+  end
+end

data/spec/lib/danica/function_spec.rb

@@ -1,39 +1,44 @@
 require 'spec_helper'
 
-describe Danica::Function do
-  describe '.build' do
-    let(:variables) { %i(x y) }
-    let(:function_class) do
-      described_class.build(*variables) do
-        Danica::Operator::Power.new(x, y)
-      end
-    end
-    let(:function) do
-      function_class.new
-    end
+shared_examples 'a generically generated function' do
+  it 'returns a function class' do
+    expect(function.class.superclass).to eq(described_class)
+  end
 
-    it 'returns a function class' do
-      expect(function_class.superclass).to eq(described_class)
+  it 'returns a class whose instance responds to the variables' do
+    variables.each do |variable|
+      expect(function).to respond_to(variable)
     end
+  end
 
-    it 'returns a class whose instance responds to the variables' do
-      variables.each do |variable|
-        expect(function).to respond_to(variable)
-      end
-    end
+  it 'returns a function that uses the block to process to_tex' do
+    expect(function.to_tex).to eq('x^{y}')
+  end
 
-    it 'returns a function that uses the block to process to_tex' do
-      expect(function.to_tex).to eq('x^{y}')
-    end
+  it 'returns a function that uses the block to process to_gnu' do
+    expect(function.to_gnu).to eq('x**(y)')
+  end
+
+  it 'returns a function thtat knows how to calculate' do
+    expect(function.calculate(x: 2, y: 3)).to eq(8)
+  end
+end
 
-    it 'returns a function that uses the block to process to_gnu' do
-      expect(function.to_gnu).to eq('x**(y)')
+describe Danica::Function do
+  let(:variables) { %i(x y) }
+  let(:function_class) do
+    described_class.build(*variables) do
+      Danica::Operator::Power.new(x, y)
     end
+  end
 
-    it 'returns a function thtat knows how to calculate' do
-      expect(function.calculate(x: 2, y: 3)).to eq(8)
+  describe '.build' do
+    let(:function) do
+      function_class.new
     end
 
+    it_behaves_like 'a generically generated function'
+
     context 'when no block is given' do
       let(:function_class) do
         described_class.build(*variables)
@@ -52,7 +57,7 @@ describe Danica::Function do
       end
 
       it 'has the defined variables' do
-        expect(function.variables_hash).to eq(x: nil)
+        expect(function.variables_hash).to eq(x: Danica::Wrapper::Variable.new(name: :x))
       end
 
       context 'when calling to_tex' do
@@ -76,7 +81,10 @@ describe Danica::Function do
       end
 
       it 'has the defined variables' do
-        expect(function.variables_hash).to eq(x: nil, y: nil)
+        expect(function.variables_hash).to eq(
+          x: Danica::Wrapper::Variable.new(name: :x),
+          y: Danica::Wrapper::Variable.new(name: :y)
+        )
       end
 
       context 'when calling to_tex' do
@@ -93,6 +101,39 @@ describe Danica::Function do
     end
   end
 
+  describe '.create' do
+    let(:function) do
+      described_class.create(*variables) do
+        Danica::Operator::Power.new(x, y)
+      end
+    end
+    it_behaves_like 'a generically generated function'
+  end
+
+  describe '#describe_tex' do
+    context 'when function has a name' do
+      let(:function) do
+        function_class.new(name: :f)
+      end
+
+      it 'returns the full function description' do
+        expect(function.describe_tex).to eq('f(x, y) = x^{y}')
+      end
+    end
+  end
+
+  describe '#describe_gnu' do
+    context 'when function has a name' do
+      let(:function) do
+        function_class.new(name: :f)
+      end
+
+      it 'returns the full function description' do
+        expect(function.describe_gnu).to eq('f(x, y) = x**(y)')
+      end
+    end
+  end
+
   describe 'spatial' do
     let(:variables) do
       {
@@ -219,7 +260,7 @@ describe Danica::Function do
 
         context 'when initialized with an empty variable set' do
           it do
-            expect(subject.variables.compact).to be_empty
+            expect(subject.variables.compact).not_to be_empty
           end
         end
 
@@ -228,8 +269,13 @@ describe Danica::Function do
             subject.time = time
           end
 
-          it 'returns the list of variables' do
-            expect(subject.variables.compact).to eq([ time ])
+          it 'returns the list of variables merged default and new variables' do
+            expect(subject.variables.compact).to eq([
+              time,
+              Danica::Wrapper::Variable.new(name: :acceleration),
+              Danica::Wrapper::Variable.new(name: :initial_space),
+              Danica::Wrapper::Variable.new(name: :initial_velocity)
+            ])
           end
         end
 
@@ -309,59 +355,6 @@ describe Danica::Function do
     end
   end
 
-  describe 'gauss' do
-    let(:variables) do
-      {
-        x: :x,
-        median: :u,
-        variance_root: { latex: '\theta', gnu: :v }
-      }
-    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{2 \cdot \pi \cdot \theta^{2}}} \cdot e^{-\frac{\left(x -u\right)^{2}}{2 \cdot \theta^{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(2 * pi * v**(2))) * exp(-((x -u)**(2))/(2 * v**(2)))' }
-
-        it 'return the gnu format CAM' do
-          expect(subject.to_gnu).to eq(expected)
-        end
-      end
-    end
-
-    context 'when not passing variables' do
-      subject { described_class::Gauss.new }
-
-      describe '#to_tex' do
-        let(:expected) { '\frac{1}{\sqrt{2 \cdot \pi \cdot \theta^{2}}} \cdot e^{-\frac{\left(x -u\right)^{2}}{2 \cdot \theta^{2}}}'  }
-
-        it 'rely on default variables definition' do
-          expect(subject.to_tex).to eq(expected)
-        end
-      end
-
-      describe '#to_gnu' do
-        let(:expected) { '(1)/(sqrt(2 * pi * v**(2))) * exp(-((x -u)**(2))/(2 * v**(2)))' }
-
-        it 'rely on default variables definition' do
-          expect(subject.to_gnu).to eq(expected)
-        end
-      end
-    end
-  end
-
   describe 'baskara' do
     context 'when using the default value for variables' do
       subject { described_class::Baskara.new }

data/spec/lib/danica/operator/addition_spec.rb

@@ -3,6 +3,12 @@ require 'spec_helper'
 describe Danica::Operator::Addition do
   subject { described_class.new(10, 2) }
 
+  it 'initializes from array' do
+    expect do
+      described_class.new(10, 2)
+    end.not_to raise_error
+  end
+
   it_behaves_like 'an object that respond to basic_methods'
 
   it_behaves_like 'an object with basic operation', ignore: %i(+ -)

data/spec/lib/danica/operator/division_spec.rb

@@ -4,6 +4,18 @@ describe Danica::Operator::Division do
   let(:variables) { [2, 4] }
   subject { described_class.new(*variables) }
 
+  describe '#numerator' do
+    it 'returns the numerator' do
+      expect(subject.numerator).to eq(Danica::Wrapper::Number.new(2))
+    end
+  end
+
+  describe '#denominator' do
+    it 'returns the denominator' do
+      expect(subject.denominator).to eq(Danica::Wrapper::Number.new(4))
+    end
+  end
+
   it_behaves_like 'an object that respond to basic_methods'
   it_behaves_like 'an object with basic operation'
 

data/spec/lib/danica/operator/multiplication_spec.rb

@@ -2,6 +2,13 @@ require 'spec_helper'
 
 describe Danica::Operator::Multiplication do
   subject { described_class.new(2,4) }
+
+  it 'initializes from array' do
+    expect do
+      described_class.new(10, 2)
+    end.not_to raise_error
+  end
+
   it_behaves_like 'an object that respond to basic_methods'
 
   it_behaves_like 'an object with * operation' do

data/spec/lib/danica/operator_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+class Danica::Operator::Dummy < Danica::Operator
+  variables :a, :b
+end
+
+describe Danica::Operator do
+  let(:variables) { [2, 4] }
+  let(:clazz) { described_class::Dummy }
+  subject { clazz.new(*variables) }
+
+  describe 'variables assignment' do
+    it 'assignes the variables tpo its places' do
+      expect(subject.a).to eq(Danica::Wrapper::Number.new(2))
+      expect(subject.b).to eq(Danica::Wrapper::Number.new(4))
+    end
+
+    context 'when initializing with a hash' do
+      let(:variables) { [{ name: :A, value: 2 }, { name: :B, value: 4 }] }
+
+      it 'assignes the variables tpo its places' do
+        expect(subject.a).to eq(Danica::Wrapper::Variable.new(name: :A, value: 2))
+        expect(subject.b).to eq(Danica::Wrapper::Variable.new(name: :B, value: 4))
+      end
+    end
+  end
+end

data/spec/lib/danica/variables_holder_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+shared_examples 'an object that returns the default variables hash' do
+  it 'returns the default variables hash' do
+    expect(subject.variables_hash).to eq(
+      x: Danica::Wrapper::Variable.new(name: :x),
+      y: Danica::Wrapper::Variable.new(latex: '\y'),
+      z: Danica::Wrapper::Number.new(10)
+    )
+  end
+end
+
+shared_examples 'an object that returns the default variables' do
+  it 'returns the default variables hash' do
+    expect(subject.variables).to eq([
+      Danica::Wrapper::Variable.new(name: :x),
+      Danica::Wrapper::Variable.new(latex: '\y'),
+      Danica::Wrapper::Number.new(10)
+    ])
+  end
+end
+
+describe Danica::VariablesHolder do
+  class Danica::VariablesHolder::Dummy
+    include Danica::Common
+    include Danica::VariablesHolder
+
+    variables :x, y: { latex: '\y' }, z: 10
+  end
+
+  let(:clazz) { described_class::Dummy }
+  subject do
+    clazz.new
+  end
+
+  it 'creates setters and getters for the variables' do
+    %i(x y z).each do |var|
+      expect(subject).to respond_to(var)
+      expect(subject).to respond_to("#{var}=")
+    end
+  end
+
+  describe '.variables_names' do
+    it 'returns the list of variables pre configured' do
+      expect(clazz.variables_names).to eq(%i(x y z))
+    end
+  end
+
+  describe '#variables=' do
+    before do
+      subject.variables = variables
+    end
+
+    context 'when setting the variables using a list' do
+      let(:variables) { [1, 2, 3] }
+
+      it 'changes the values of the variables' do
+        expect(subject.x).to eq(Danica::Wrapper::Number.new(1))
+      end
+
+      context 'but the array is empty' do
+        let(:variables) { [] }
+
+        it_behaves_like 'an object that returns the default variables hash'
+      end
+    end
+
+    context 'when setting the variales using a hash' do
+      let(:variables) { { x: 1, y: 2, z: 3 } }
+
+      it 'changes the values of the variables' do
+        expect(subject.x).to eq(Danica::Wrapper::Number.new(1))
+      end
+
+      context 'but the hash is empty' do
+        let(:variables) { {} }
+
+        it_behaves_like 'an object that returns the default variables hash'
+      end
+    end
+  end
+
+  describe '#variables' do
+    context 'when instance has no variables defined' do
+      it do
+        expect(subject.variables).not_to be_empty
+      end
+
+      it_behaves_like 'an object that returns the default variables'
+    end
+
+    context 'when some variables where defined' do
+      before do
+        subject.y = 1
+      end
+
+      it 'returns the default variables and the new set one' do
+        expect(subject.variables).to eq([
+          Danica::Wrapper::Variable.new(name: :x),
+          Danica::Wrapper::Number.new(1),
+          Danica::Wrapper::Number.new(10)
+        ])
+      end
+
+      it 'does not change the class variables' do
+        expect do
+          subject.z = 2
+        end.not_to change { clazz.variables_hash }
+      end
+    end
+  end
+
+  describe '#variables_hash' do
+    context 'when instance has no variables defined' do
+      it_behaves_like 'an object that returns the default variables hash'
+    end
+
+    context 'when some variables where defined' do
+      before do
+        subject.y = 1
+      end
+
+      it 'returns the default hash with the set value' do
+        expect(subject.variables_hash).to eq(
+          x: Danica::Wrapper::Variable.new(name: :x),
+          y: Danica::Wrapper::Number.new(1),
+          z: Danica::Wrapper::Number.new(10)
+        )
+      end
+    end
+  end
+  
+  describe '#variables_value_hash' do
+    context 'when instance has no variables defined' do
+      it 'returns the default value' do
+        expect(subject.variables_value_hash).to eq({x: nil, y: nil, z: 10})
+      end
+    end
+
+    context 'when some of the variables have been valued' do
+      before do
+        subject.y = 1
+      end
+
+      it 'returns the values' do
+        expect(subject.variables_value_hash).to eq({x: nil, y: 1, z: 10})
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: danica
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.4.0
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-07 00:00:00.000000000 Z
+date: 2017-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -159,6 +159,7 @@ files:
 - lib/danica/dsl.rb
 - lib/danica/exception.rb
 - lib/danica/function.rb
+- lib/danica/function/gauss.rb
 - lib/danica/operator.rb
 - lib/danica/operator/addition.rb
 - lib/danica/operator/chained.rb
@@ -186,6 +187,7 @@ files:
 - spec/integration/plus_minus_spec.rb
 - spec/integration/power_spec.rb
 - spec/lib/danica/dsl_spec.rb
+- spec/lib/danica/function/gauss_spec.rb
 - spec/lib/danica/function_spec.rb
 - spec/lib/danica/operator/addition_spec.rb
 - spec/lib/danica/operator/cos_spec.rb
@@ -195,6 +197,8 @@ files:
 - spec/lib/danica/operator/power_spec.rb
 - spec/lib/danica/operator/sin_spec.rb
 - spec/lib/danica/operator/squared_root_spec.rb
+- spec/lib/danica/operator_spec.rb
+- spec/lib/danica/variables_holder_spec.rb
 - spec/lib/danica/wrapper/constant_spec.rb
 - spec/lib/danica/wrapper/group_spec.rb
 - spec/lib/danica/wrapper/negative_spec.rb
@@ -204,7 +208,6 @@ files:
 - spec/lib/danica_spec.rb
 - spec/spec_helper.rb
 - spec/support/models/functions/baskara.rb
-- spec/support/models/functions/gauss.rb
 - spec/support/models/functions/hyperbole.rb
 - spec/support/models/functions/spatial.rb
 - spec/support/shared_contexts/common.rb
@@ -244,6 +247,7 @@ test_files:
 - spec/integration/plus_minus_spec.rb
 - spec/integration/power_spec.rb
 - spec/lib/danica/dsl_spec.rb
+- spec/lib/danica/function/gauss_spec.rb
 - spec/lib/danica/function_spec.rb
 - spec/lib/danica/operator/addition_spec.rb
 - spec/lib/danica/operator/cos_spec.rb
@@ -253,6 +257,8 @@ test_files:
 - spec/lib/danica/operator/power_spec.rb
 - spec/lib/danica/operator/sin_spec.rb
 - spec/lib/danica/operator/squared_root_spec.rb
+- spec/lib/danica/operator_spec.rb
+- spec/lib/danica/variables_holder_spec.rb
 - spec/lib/danica/wrapper/constant_spec.rb
 - spec/lib/danica/wrapper/group_spec.rb
 - spec/lib/danica/wrapper/negative_spec.rb
@@ -262,7 +268,6 @@ test_files:
 - spec/lib/danica_spec.rb
 - spec/spec_helper.rb
 - spec/support/models/functions/baskara.rb
-- spec/support/models/functions/gauss.rb
 - spec/support/models/functions/hyperbole.rb
 - spec/support/models/functions/spatial.rb
 - spec/support/shared_contexts/common.rb