danica 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be618ffc1e1620cc02cad2c42ad749bd75b9cf5c
-  data.tar.gz: c8388dda1c1763dbb12945e6da568c2077e68626
+  metadata.gz: 0cbd63065be86cd93d10bf1a1d2fc624775e3331
+  data.tar.gz: bf977f09ed4bdb576aad2a2683fd6758a017a2d1
 SHA512:
-  metadata.gz: cfa2f7388464148bbe4124527ae798f813c53c5ed0461d52c0105501465df6d25df687959fdeb9ddc2bcb98c2d258e7e4604a87a0ad4759f43bf05f42f99cd11
-  data.tar.gz: 76caede443c7296d5aee872f391888838b4ea662dc4f209e255485a4119b1277892ab9a8ba23c3e95c3b8b3cf7d5767931cbe5139fe3264db470943f7b6b22da
+  metadata.gz: 43d21db5bc46b37c41fda6a23f8fbeee6e147b1c55eb256e31951175a7bab6d75770b8f2c9feeb335f15da068647cb5409a5b64d1076d40cf16df7e30cc6f33c
+  data.tar.gz: e3aff36c623f3a9548c643985faf82e94a13e1bc2f2a0630cfa47dce5c41abd0805ec01414f2bad43fa5df91ff3799bec16cfc478f03c469ef9aae50f77d761e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    danica (1.2.0)
+    danica (2.0.0)
       activemodel
       activesupport
       bidu-core_ext

data/README.md

@@ -17,25 +17,121 @@ bundle install danica
 
 Now you can use in your project
 
+### Operators
+Operators are much like function, but they do not have a name.
+
+While a function would be something in the format ```f(x) = x + 1```, an operator would just represent the sum ```x + 1```
+
+Operators are to be composed to create a Function (see below) being their difference almost semantic
 
 ```ruby
-class MyFunction < Danica::Function
+class MyOperator < Danica::Operator
+  variables :elements_list
   def to_f
     #implement to float method
   end
 
   def to_tex
-    #implement to tex method
+    #optionaly implement custom to_tex method
+  end
+
+  def to_gnu
+    #optionaly implement custom to_gnu method
+  end
+
+  private
+
+  def tex_string
+    #implement tex_string here
+  end
+
+  def gnu_string
+    #implement gnu_string here
+  end
+end
+```
+#### Sample
+```ruby
+class Danica::Inverse
+  variables :value
+
+  def to_f
+    value.to_f ** -1 #Do not worry with nil value as this has been implemented already raising Danica::Exception::NotDefined
+  end
+
+  private
+
+  def tex_string
+    "(#{value.to_tex})^{-1}"
+  end
+
+  def gnu_string
+    "(#{value.to_gnu}) ** -1"
   end
 end
+
+fx = Danica::Inverse.new(:x)
+```
+
+##### to_tex
+```ruby
+fx.to_tex
+```
+
+returns
+```string
+(x)^{-1}
+```
+
+##### to_gnu
+```ruby
+fx.to_gnu
+```
+
+returns
+```string
+(x) ** -1
+```
+
+##### calculate / to_f
+```ruby
+fx.calculate(2)
+```
+or
+```ruby
+Danica::Inverse.new(2).to_f
+```
+
+both return
+```string
+0.5
 ```
 
+### Functions
 
-### Sample
+Functions are composition of operators threating their variables input.
+
+Example of function could be ```f(x,y) = x ^ y + y / 2``` which is composed of an operator sum of 2 parcels,
+being the first an operator power and the second an operator division, while the variable ```x``` is only used
+as the base of the power operator and the y variable is present on both power and division operator
 
 ```ruby
-class Danica::Function
-  class Spatial < Danica::Function
+class MyFunction
+  variables :variables_list
+
+  # code of operators composition
+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
     delegate :to_tex, :to_gnu, to: :sum
 
@@ -67,7 +163,7 @@ class Danica::Function
   end
 end
 
-fx = Danica::Function.new(
+fx = Danica::Function::Spatial.new(
   time: :t,
   acceleration: 'a',
   initial_space: { name: :S0, latex: 'S_0', gnu: 'S0' },
@@ -75,6 +171,7 @@ fx = Danica::Function.new(
 )
 ```
 
+##### to_tex
 ```ruby
 fx.to_tex
 ```
@@ -84,6 +181,7 @@ returns
 S_0 + V_0 \cdot t + \frac{a \cdot t^2}{2}
 ```
 
+##### to_gnu
 ```ruby
 fx.to_gnu
 ```
@@ -93,3 +191,35 @@ returns
 S0 + V0 * t + a * t**2/2
 ```
 
+##### to_gnu
+```ruby
+fx = Danica::Function::Spatial.new(
+  time: :t,
+  acceleration: :a,
+  initial_space: 1,
+  initial_velocity: 2
+)
+```
+
+```ruby
+fx.calculate(10, 3)
+```
+
+or
+
+
+```ruby
+fx.calculate(time: 10, acceleration: 3)
+```
+
+or
+
+```ruby
+Danica::Function::Spatial.new(10, 3, 1, 2).to_f
+```
+
+all return
+
+```ruby
+171.0
+```

data/lib/danica.rb

@@ -1,8 +1,10 @@
 require 'active_model'
 
 module Danica
+  require 'danica/common'
   require 'danica/number'
   require 'danica/variable'
+  require 'danica/operator'
   require 'danica/function'
   require 'danica/exception'
 end

data/lib/danica/common.rb

@@ -0,0 +1,80 @@
+module Danica
+  class Common
+    require 'danica/common/class_methods'
+    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?(Fixnum) || 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
+    rescue Exception::NotDefined
+      tex_string
+    end
+
+    def to_gnu
+      Number.new(to_f).to_gnu
+    rescue Exception::NotDefined
+      gnu_string
+    end
+  
+    def variables=(variables)
+      @variables = variables.map { |v| wrap_value(v) }
+    end
+  
+    def valued?
+      to_f.present?
+    rescue Exception::NotDefined
+      false
+    end
+
+    def variables
+      @variables ||= variables_hash.values
+    end
+  
+    def variables_hash
+      @variabels_map ||= (@variables || []).as_hash(self.class.variables_names)
+    end
+
+    def variables_value_hash
+      variables.map(&:value).as_hash(self.class.variables_names)
+    end
+
+    private
+
+    def non_valued_variables
+      variables.reject(&:valued?)
+    end
+
+    def tex_string
+      raise 'Not IMplemented yet'
+    end
+
+    def gnu_string
+      raise 'Not IMplemented yet'
+    end
+  
+    def wrap_value(value)
+      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
+      value
+    end
+  end
+end

data/lib/danica/{function → common}/class_methods.rb

@@ -1,4 +1,4 @@
-class Danica::Function
+class Danica::Common
   class << self
     def variables(*names)
       VariablesBuilder.new(names, self).build

data/lib/danica/{function → common}/variables_builder.rb

@@ -1,7 +1,7 @@
 require 'concern_builder'
 require 'bidu/core_ext'
 
-class Danica::Function
+class Danica::Common
   class VariablesBuilder < ::ConcernBuilder
     attr_reader :instance
 

data/lib/danica/division.rb

@@ -0,0 +1,20 @@
+module Danica
+  class Division < Operator
+    variables :numerator, :denominator
+
+    def to_f
+    numerator.to_f / denominator.to_f
+    end
+
+    private
+
+    def tex_string
+    "\\frac{#{numerator.to_tex}}{#{denominator.to_tex}}"
+    end
+
+    def gnu_string
+    "#{numerator.to_gnu}/#{denominator.to_gnu}"
+    end
+  end
+end
+

data/lib/danica/exponential.rb

@@ -0,0 +1,21 @@
+module Danica
+  class Exponential < Operator
+    variables :exponent
+
+    def to_f
+    Math.exp(exponent.to_f)
+    end
+
+    private
+
+    def tex_string
+    "e^{#{exponent.to_tex}}"
+    end
+
+    def gnu_string
+    "exp(#{exponent.to_gnu})"
+    end
+  end
+end
+
+

data/lib/danica/function.rb

@@ -1,94 +1,13 @@
 module Danica
-  class Function
+  class Function < Common
     include ActiveModel::Model
   
-    require 'danica/function/variables_builder'
-    require 'danica/function/class_methods'
-    require 'danica/function/chained'
-    require 'danica/function/product'
-    require 'danica/function/sum'
-    require 'danica/function/division'
-    require 'danica/function/power'
-    require 'danica/function/square_root'
-  
-    attr_accessor :name, :variables
+    attr_accessor :name
 
     def initialize(*args)
       options = args.extract_options!
 
       super({ variables: args.flatten }.merge(options))
     end
-  
-    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?(Fixnum) || 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
-    rescue Exception::NotDefined
-      tex_string
-    end
-
-    def to_gnu
-      Number.new(to_f).to_gnu
-    rescue Exception::NotDefined
-      gnu_string
-    end
-  
-    def variables=(variables)
-      @variables = variables.map { |v| wrap_value(v) }
-    end
-  
-    def valued?
-      to_f.present?
-    rescue Exception::NotDefined
-      false
-    end
-
-    def variables
-      @variables ||= variables_hash.values
-    end
-  
-    def variables_hash
-      @variabels_map ||= (@variables || []).as_hash(self.class.variables_names)
-    end
-
-    def variables_value_hash
-      variables.map(&:value).as_hash(self.class.variables_names)
-    end
-
-    private
-
-    def non_valued_variables
-      variables.reject(&:valued?)
-    end
-
-    def tex_string
-      raise 'Not IMplemented yet'
-    end
-
-    def gnu_string
-      raise 'Not IMplemented yet'
-    end
-  
-    def wrap_value(value)
-      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
-      value
-    end
   end
 end

data/lib/danica/operator.rb

@@ -0,0 +1,9 @@
+module Danica
+  class Operator < Common
+    include ActiveModel::Model
+  
+    def initialize(*args)
+      super( variables: args.flatten )
+    end
+  end
+end

data/lib/danica/{function → operator}/chained.rb

@@ -1,6 +1,6 @@
 module Danica
-  class Function
-    class Chained < Function
+  class Operator
+    class Chained < Operator
       def to_f
         chain(variables.map(&:to_f))
       end

data/lib/danica/power.rb

@@ -0,0 +1,20 @@
+module Danica
+  class Power < Operator
+    variables :base, :exponent
+
+    def to_f
+    base.to_f ** exponent.to_f
+    end
+
+    private
+
+    def tex_string
+    "#{base.to_tex}^{#{exponent.to_tex}}"
+    end
+
+    def gnu_string
+    "#{base.to_gnu}**#{exponent.to_gnu}"
+    end
+  end
+end
+

data/lib/danica/product.rb

@@ -0,0 +1,19 @@
+require 'danica/operator/chained'
+
+module Danica
+  class Product < Operator::Chained
+    private
+
+    def tex_symbol
+    '\cdot'
+    end
+
+    def gnu_symbol
+    '*'
+    end
+
+    def chain_operation(a, b)
+    a * b
+    end
+  end
+end

data/lib/danica/square_root.rb

@@ -0,0 +1,20 @@
+module Danica
+  class SquareRoot < Operator
+    variables :variable
+
+    def to_f
+    Math.sqrt(variable.to_f)
+    end
+
+    private
+
+    def tex_string
+    "\\sqrt{#{variable.to_tex}}"
+    end
+
+    def gnu_string
+    "sqrt(#{variable.to_gnu})"
+    end
+  end
+end
+

data/lib/danica/sum.rb

@@ -0,0 +1,20 @@
+require 'danica/operator/chained'
+
+module Danica
+  class Sum < Operator::Chained
+    private
+
+    def tex_symbol
+      '+'
+    end
+
+    def gnu_symbol
+      '+'
+    end
+
+    def chain_operation(a, b)
+      a + b
+    end
+  end
+end
+

data/lib/danica/version.rb

@@ -1,3 +1,3 @@
 module Danica
-  VERSION = '1.2.0'
+  VERSION = '2.0.0'
 end

data/spec/lib/danica/{function/division_spec.rb → division_spec.rb}

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Danica::Function::Division do
+describe Danica::Division do
   let(:subject) do
-    described_class.new(numerator: variables[0], denominator: variables[1])
+    described_class.new(*variables)
   end
 
-  it_behaves_like 'a function that has two terms', :division, {
+  it_behaves_like 'a operator that has two terms', :division, {
     values: [ 2, 4 ],
     calculated: 1.0 / 2.0,
     to_tex: {

data/spec/lib/danica/exponential_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Danica::Exponential do
+  it_behaves_like 'a operator with a single input value', {
+    variable_value: 2,
+    expected_number: Math.exp(2),
+    expected_number_text: Math.exp(2).to_s,
+    expected_tex: 'e^{X}',
+    expected_gnu: 'exp(X)'
+  }
+end

data/spec/lib/danica/function_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe Danica::Function do
-  class Danica::Function
-    class Spatial < Danica::Function
+  module Danica
+    class Function::Spatial < Function
       variables :time, :acceleration, :initial_space, :initial_velocity
       delegate :to_f, :to_tex, :to_gnu, to: :sum
 
@@ -46,7 +46,7 @@ describe Danica::Function do
   let(:subject) { described_class::Spatial.new(variables) }
 
   describe '#to_tex' do
-    context 'when creating the spatial function for constantly accelerated movement' 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
@@ -56,7 +56,7 @@ describe Danica::Function do
   end
 
   describe '#to_gnu' do
-    context 'when creating the spatial function for constantly accelerated movement' 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

data/spec/lib/danica/{function/power_spec.rb → power_spec.rb}

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Danica::Function::Power do
+describe Danica::Power do
   let(:subject) do
-    described_class.new(base: variables[0], exponent: variables[1])
+    described_class.new(*variables)
   end
 
-  it_behaves_like 'a function that has two terms', :power, {
+  it_behaves_like 'a operator that has two terms', :power, {
     values: [ 3, 2 ],
     calculated: 9.0,
     to_tex: {

data/spec/lib/danica/{function/product_spec.rb → product_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe Danica::Function::Product do
-  it_behaves_like 'a function that joins many variables with same operation', {
+describe Danica::Product do
+  it_behaves_like 'a operator that joins many variables with same operation', {
     calculated: 24,
     numeric_variables: [ 1.5, 2, 3.5 ],
     to_tex: { 

data/spec/lib/danica/square_root_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Danica::SquareRoot do
+  it_behaves_like 'a operator with a single input value', {
+    variable_value: 9,
+    expected_number: 3.0,
+    expected_number_text: '3',
+    expected_tex: '\sqrt{X}',
+    expected_gnu: 'sqrt(X)'
+  }
+end

data/spec/lib/danica/{function/sum_spec.rb → sum_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe Danica::Function::Sum do
-  it_behaves_like 'a function that joins many variables with same operation', {
+describe Danica::Sum do
+  it_behaves_like 'a operator that joins many variables with same operation', {
     calculated: 10,
     numeric_variables: [ 1.5, 2.5, 3.5 ],
     to_tex: {

data/spec/spec_helper.rb

@@ -13,6 +13,13 @@ SimpleCov.start 'gem'
 require 'pry-nav'
 require 'danica'
 
+require 'danica/product'
+require 'danica/sum'
+require 'danica/division'
+require 'danica/power'
+require 'danica/square_root'
+require 'danica/exponential'
+
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
 # Require this file using `require "spec_helper"` to ensure that it is only

data/spec/support/shared_contexts/common.rb

@@ -0,0 +1,5 @@
+shared_context 'variables are initialized' do |arguments, *names|
+  names.each do |key|
+    let(key) { arguments[key.to_sym]  }
+  end
+end

data/spec/support/shared_examples/{function → operator}/chained.rb

@@ -1,13 +1,11 @@
-shared_examples 'a function that joins many variables with same operation' do |arguments|
-  it_behaves_like 'a function that knows how to calculate', arguments
-  it_behaves_like 'a function that knows how to write to tex', arguments
-  it_behaves_like 'a function that knows how to write to gnu', arguments
+shared_examples 'a operator that joins many variables with same operation' do |arguments|
+  it_behaves_like 'a operator that knows how to calculate', arguments
+  it_behaves_like 'a operator that knows how to write to tex', arguments
+  it_behaves_like 'a operator that knows how to write to gnu', arguments
 end
 
-shared_examples 'a function that knows how to calculate' do |arguments|
-  %w(calculated).each do |key|
-    let(key) { arguments[key.to_sym]  }
-  end
+shared_examples 'a operator that knows how to calculate' do |arguments|
+  include_context 'variables are initialized', arguments, 'calculated'
   let(:variables) do
     (1..4).map do |i|
       { name: "X#{i}", value: numeric_variables[i-1] }
@@ -15,7 +13,7 @@ shared_examples 'a function that knows how to calculate' do |arguments|
   end
   let(:numeric_variables){ (1..4).to_a }
   let(:subject) do
-    described_class.new(variables: variables)
+    described_class.new(*variables)
   end
 
   describe 'to_f' do
@@ -41,21 +39,19 @@ shared_examples 'a function that knows how to calculate' do |arguments|
   end
 end
 
-shared_examples 'a function that knows how to write to tex' do |arguments|
-  it_behaves_like 'a function that knows how to write to a string', :to_tex, arguments
+shared_examples 'a operator that knows how to write to tex' do |arguments|
+  it_behaves_like 'a operator that knows how to write to a string', :to_tex, arguments
 end
 
-shared_examples 'a function that knows how to write to gnu' do |arguments|
-  it_behaves_like 'a function that knows how to write to a string', :to_gnu, arguments
+shared_examples 'a operator that knows how to write to gnu' do |arguments|
+  it_behaves_like 'a operator that knows how to write to a string', :to_gnu, arguments
 end
 
-shared_examples 'a function that knows how to write to a string' do |command, arguments|
+shared_examples 'a operator that knows how to write to a string' do |command, arguments|
   let(:numeric_variables) { arguments[:numeric_variables]  }
-  %w(integer_expected string_expected float_expected).each do |key|
-    let(key) { arguments[command][key.to_sym]  }
-  end
+  include_context 'variables are initialized', arguments[command], *%w(integer_expected string_expected float_expected)
   let(:subject) do
-    described_class.new(variables: variables)
+    described_class.new(*variables)
   end
 
   describe "#{command}" do

data/spec/support/shared_examples/{function → operator}/dual_term.rb

@@ -1,13 +1,11 @@
-shared_examples 'a function that has two terms' do |name, arguments|
-  it_behaves_like 'a function that has two terms and knows how to calculate it', name, arguments
-  it_behaves_like 'a function that has two terms and knows how to call to_tex', arguments
-  it_behaves_like 'a function that has two terms and knows how to call to_gnu', arguments
+shared_examples 'a operator that has two terms' do |name, arguments|
+  it_behaves_like 'a operator that has two terms and knows how to calculate it', name, arguments
+  it_behaves_like 'a operator that has two terms and knows how to call to_tex', arguments
+  it_behaves_like 'a operator that has two terms and knows how to call to_gnu', arguments
 end
 
-shared_examples 'a function that has two terms and knows how to calculate it' do |name, arguments|
-  %w(values calculated).each do |key|
-    let(key) { arguments[key.to_sym]  }
-  end
+shared_examples 'a operator that has two terms and knows how to calculate it' do |name, arguments|
+  include_context 'variables are initialized', arguments, *%w(values calculated)
 
   let(:variables) do
     [ 1, 2 ].map do |i|
@@ -54,20 +52,18 @@ shared_examples 'a function that has two terms and knows how to calculate it' do
   end
 end
 
-shared_examples 'a function that has two terms and knows how to call to_tex' do |arguments|
-  it_behaves_like 'a function that has two terms and knows how to return a string out of it', :to_tex, arguments
+shared_examples 'a operator that has two terms and knows how to call to_tex' do |arguments|
+  it_behaves_like 'a operator that has two terms and knows how to return a string out of it', :to_tex, arguments
 end
 
-shared_examples 'a function that has two terms and knows how to call to_gnu' do |arguments|
-  it_behaves_like 'a function that has two terms and knows how to return a string out of it', :to_gnu, arguments
+shared_examples 'a operator that has two terms and knows how to call to_gnu' do |arguments|
+  it_behaves_like 'a operator that has two terms and knows how to return a string out of it', :to_gnu, arguments
 end
 
-shared_examples 'a function that has two terms and knows how to return a string out of it' do |command, arguments|
+shared_examples 'a operator that has two terms and knows how to return a string out of it' do |command, arguments|
   let(:values) { arguments[:values]  }
 
-  %w(string_expected numeric_string_expected partial_string_expected).each do |key|
-    let(key) { arguments[command][key.to_sym]  }
-  end
+  include_context 'variables are initialized', arguments[command], *%w(string_expected numeric_string_expected partial_string_expected)
   describe "##{command}" do
     let(:variables) do
       [ 1, 2 ].map do |i|

data/spec/{lib/danica/function/square_root_spec.rb → support/shared_examples/operator/single_input.rb}

@@ -1,16 +1,14 @@
-require 'spec_helper'
-
-describe Danica::Function::SquareRoot do
-  let(:variables_number) { 4 }
-  let(:variable) { { name: "X", value: 9 } }
+shared_examples 'a operator with a single input value' do |arguments|
+  include_context 'variables are initialized', arguments, *%w(variable_value expected_number expected_tex expected_number_text expected_gnu)
+  let(:variable) { { name: "X", value: variable_value } }
   let(:subject) do
-    described_class.new(variable: variable)
+    described_class.new(variable)
   end
 
   describe '#to_f' do
     context 'when variables are not numbers but have value' do
       it 'returns the division of the values' do
-        expect(subject.to_f).to eq(3.0)
+        expect(subject.to_f).to eq(expected_number)
       end
 
       it do
@@ -19,10 +17,10 @@ describe Danica::Function::SquareRoot do
     end
 
     context 'when the variable is a number' do
-      let(:variable) { 9 }
+      let(:variable) { variable_value }
 
       it 'returns the squared root of the value' do
-        expect(subject.to_f).to eq(3.0)
+        expect(subject.to_f).to eq(expected_number)
       end
 
       it do
@@ -36,16 +34,16 @@ describe Danica::Function::SquareRoot do
       let(:variable) { :X }
 
       it 'returns a latex format fraction' do
-        expect(subject.to_tex).to eq('\sqrt{X}')
+        expect(subject.to_tex).to eq(expected_tex)
       end
     end
 
     context 'when the variable is numeric' do
       before do
-        subject.variable.value = 9
+        subject.variables[0].value = variable_value
       end
       it 'prints both numbers' do
-        expect(subject.to_tex).to eq('3')
+        expect(subject.to_tex).to eq(expected_number_text)
       end
     end
   end
@@ -55,16 +53,16 @@ describe Danica::Function::SquareRoot do
       let(:variable) { :X }
 
       it 'returns a latex format fraction' do
-        expect(subject.to_gnu).to eq('sqrt(X)')
+        expect(subject.to_gnu).to eq(expected_gnu)
       end
     end
 
     context 'when the variable is numeric' do
       before do
-        subject.variable.value = 9
+        subject.variables[0].value = variable_value
       end
       it 'prints both numbers' do
-        expect(subject.to_gnu).to eq('3')
+        expect(subject.to_gnu).to eq(expected_number_text)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: danica
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-17 00:00:00.000000000 Z
+date: 2016-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -179,31 +179,37 @@ files:
 - Rakefile
 - danica.gemspec
 - lib/danica.rb
+- lib/danica/common.rb
+- lib/danica/common/class_methods.rb
+- lib/danica/common/variables_builder.rb
+- lib/danica/division.rb
 - lib/danica/exception.rb
 - lib/danica/exception/not_defined.rb
+- lib/danica/exponential.rb
 - lib/danica/function.rb
-- lib/danica/function/chained.rb
-- lib/danica/function/class_methods.rb
-- lib/danica/function/division.rb
-- lib/danica/function/power.rb
-- lib/danica/function/product.rb
-- lib/danica/function/square_root.rb
-- lib/danica/function/sum.rb
-- lib/danica/function/variables_builder.rb
 - lib/danica/number.rb
+- lib/danica/operator.rb
+- lib/danica/operator/chained.rb
+- lib/danica/power.rb
+- lib/danica/product.rb
+- lib/danica/square_root.rb
+- lib/danica/sum.rb
 - lib/danica/variable.rb
 - lib/danica/version.rb
-- spec/lib/danica/function/division_spec.rb
-- spec/lib/danica/function/power_spec.rb
-- spec/lib/danica/function/product_spec.rb
-- spec/lib/danica/function/square_root_spec.rb
-- spec/lib/danica/function/sum_spec.rb
+- spec/lib/danica/division_spec.rb
+- spec/lib/danica/exponential_spec.rb
 - spec/lib/danica/function_spec.rb
 - spec/lib/danica/number_spec.rb
+- spec/lib/danica/power_spec.rb
+- spec/lib/danica/product_spec.rb
+- spec/lib/danica/square_root_spec.rb
+- spec/lib/danica/sum_spec.rb
 - spec/lib/danica/variable_spec.rb
 - spec/spec_helper.rb
-- spec/support/shared_examples/function/chained.rb
-- spec/support/shared_examples/function/dual_term.rb
+- spec/support/shared_contexts/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
 - spec/support/shared_examples/variable.rb
 homepage: 
 licenses: []
@@ -229,15 +235,18 @@ signing_key:
 specification_version: 4
 summary: Danica
 test_files:
-- spec/lib/danica/function/division_spec.rb
-- spec/lib/danica/function/power_spec.rb
-- spec/lib/danica/function/product_spec.rb
-- spec/lib/danica/function/square_root_spec.rb
-- spec/lib/danica/function/sum_spec.rb
+- spec/lib/danica/division_spec.rb
+- spec/lib/danica/exponential_spec.rb
 - spec/lib/danica/function_spec.rb
 - spec/lib/danica/number_spec.rb
+- spec/lib/danica/power_spec.rb
+- spec/lib/danica/product_spec.rb
+- spec/lib/danica/square_root_spec.rb
+- spec/lib/danica/sum_spec.rb
 - spec/lib/danica/variable_spec.rb
 - spec/spec_helper.rb
-- spec/support/shared_examples/function/chained.rb
-- spec/support/shared_examples/function/dual_term.rb
+- spec/support/shared_contexts/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
 - spec/support/shared_examples/variable.rb

data/lib/danica/function/division.rb

@@ -1,22 +0,0 @@
-module Danica
-  class Function
-    class Division < Function
-      variables :numerator, :denominator
-
-      def to_f
-        numerator.to_f / denominator.to_f
-      end
-
-      private
-
-      def tex_string
-        "\\frac{#{numerator.to_tex}}{#{denominator.to_tex}}"
-      end
-
-      def gnu_string
-        "#{numerator.to_gnu}/#{denominator.to_gnu}"
-      end
-    end
-  end
-end
-

data/lib/danica/function/power.rb

@@ -1,22 +0,0 @@
-module Danica
-  class Function
-    class Power < Function
-      variables :base, :exponent
-
-      def to_f
-        base.to_f ** exponent.to_f
-      end
-
-      private
-
-      def tex_string
-        "#{base.to_tex}^{#{exponent.to_tex}}"
-      end
-
-      def gnu_string
-        "#{base.to_gnu}**#{exponent.to_gnu}"
-      end
-    end
-  end
-end
-

data/lib/danica/function/product.rb

@@ -1,19 +0,0 @@
-module Danica
-  class Function
-    class Product < Chained
-      private
-
-      def tex_symbol
-        '\cdot'
-      end
-
-      def gnu_symbol
-        '*'
-      end
-
-      def chain_operation(a, b)
-        a * b
-      end
-    end
-  end
-end

data/lib/danica/function/square_root.rb

@@ -1,22 +0,0 @@
-module Danica
-  class Function
-    class SquareRoot < Function
-      variables :variable
-
-      def to_f
-        Math.sqrt(variable.to_f)
-      end
-
-      private
-
-      def tex_string
-        "\\sqrt{#{variable.to_tex}}"
-      end
-
-      def gnu_string
-        "sqrt(#{variable.to_gnu})"
-      end
-    end
-  end
-end
-

data/lib/danica/function/sum.rb

@@ -1,20 +0,0 @@
-module Danica
-  class Function
-    class Sum < Chained
-      private
-
-      def tex_symbol
-        '+'
-      end
-
-      def gnu_symbol
-        '+'
-      end
-
-      def chain_operation(a, b)
-        a + b
-      end
-    end
-  end
-end
-