danica 2.5.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbc5e0d585c75c30257524380ed56a556daa08c5
-  data.tar.gz: 429e5c4ed8845329ebd79f9bfa9353b809e1e763
+  metadata.gz: 97379e35fd308207eb9c9fce91da8235e36ac3ea
+  data.tar.gz: a254b8b7911c64d5a6a6d99cb86279098f864012
 SHA512:
-  metadata.gz: 4fb11c37df1b65c3b960d5d9cf1fecd828e445171e950b16c9f532190e490d37b733923be0d3fc809e54eb1d8cd27fcf9f05b02af60eb4772d13280ffbf825f0
-  data.tar.gz: e737d1f7f965f29bc7d95a44744385400f12c6b863544a52ea06f851cb137b0a0a33ce90d669c5d2effe79e575d4eeb92a1cff49dbd2fc2ebacd6796542e35b3
+  metadata.gz: f4e74d4eb9dcee0763c72342cdf6b2ae08c892284ca7c4d4fc9bea5898f18481a343c0407bc2ccd1b96de8a238ed6d327e5fbd70bf1421b7e296b7238d84c18d
+  data.tar.gz: 3dbfa63432ff97ea589d12f5331abf83e051aea1bdef257bb9caf8a17fbec8f982551f8ec519d0805652adb40f698b21becf69cbc1cdef5496369d360a0aef62

data/README.md

@@ -7,31 +7,29 @@ A tool for math formulation on docs
 ## How to use
 Add the gem to your project or just install the gem
 
-```
+```ruby
 gem 'danica'
 ```
 
-```console
+```bash
 bundle install danica
 ```
 
 Now you can use in your project
 
 ### Quick Use
-Use Danica build to build and use your formula using ```Danica.build```
+Use Danica build to build and use your expression using ```Danica.build```
 ```ruby
-formula = Danica.build do
+expression = Danica.build do
   (number(1) + 2) * power(3,4)
 end
-
-formula.to_tex
 ```
 
 create and use functions
 
 ```ruby
 func = Danica.build do
-  formula(:x, :y) do
+  Danica::Function.create(:x, :y) do
     (number(1) + x) * power(3, y)
   end
 end
@@ -39,14 +37,12 @@ end
 func.to_gnu
 ```
 
-create gnu or tex output strings to be used on yopur template
+create gnu or tex output strings to be used on your template
 
 ### 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 represent a matematical operation such as sum, product, sin, etc..
 
-Operators are to be composed to create a Function ([see below](#functions)) being their difference almost semantic
+Operators are to be composed to create an [expression](#expressions), [equation](#expressions) or [function](#functions) (see below)
 
 ```ruby
 class MyOperator < Danica::Operator
@@ -93,7 +89,7 @@ fx.to_tex
 ```
 
 returns
-```string
+```tex
 (x)^{-1}
 ```
 
@@ -103,7 +99,7 @@ fx.to_gnu
 ```
 
 returns
-```string
+```gnuplot
 (x) ** -1
 ```
 
@@ -117,24 +113,99 @@ Danica::Operator::Inverse.new(2).to_f
 ```
 
 both return
-```string
+```float
 0.5
 ```
 
+### Expressions
+
+Expressions  are composition of operators threating their variables input.
+
+Example of expression could be ```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
+
+Expressions can be defined on the fly or as a class
+
+```ruby
+clazz = Danica::Expression.build(:a, :b, :c) do
+  (
+    negative(b) + Danica::Wrapper::PlusMinus.new(
+      squared_root(
+        power(b, 2) - multiplication(4, a, c)
+      )
+    )
+  ) / (number(2) * a)
+end
+```
+
+```ruby
+module Danica
+  class Expression::Baskara < Expression.build(:a, :b, :c) { numerator / denominator }
+
+    private
+
+    def numerator
+       negative(b) + Wrapper::PlusMinus.new(squared_root(delta))
+    end
+
+    def denominator
+      number(2) * a
+    end
+
+    def delta
+      power(b, 2) - multiplication(4, a, c)
+    end
+  end
+end
+clazz = Danica::Expression::Baskara
+```
+
+Both would create a class whose instance knows how to build baskara formula
+
+```ruby
+clazz.new.to_tex
+```
+
+```tex
+\frac{-b \pm \sqrt{b^{2} -4 \cdot a \cdot c}}{2 \cdot a}
+```
+
+### Equations
+
+Equations are formed by two expressions with their own variables
+
+```ruby
+Danica::Equation.new.tap do |equation|
+  equation.left = Danica.build(:x, :y) do
+    x ** 2 + y ** 2
+  end
+  equation.right = Danica.build(:x, :z) do
+    number(1) - z ** 2
+  end
+end.to_tex
+```
+
+so we can create the equation
+
+```gnuplot
+x**(2) + y**(2) = 1 -z**(2)
+```
+
 ### Functions
 
-Functions are composition of operators threating their variables input.
+Functions are equations whose one of the sides is actually the naming of the function and variables declaration
 
 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 MyFunction
-  variables :variables_list
+class MyFunction < Danica::Function
+  variables :x, :y ...
 
   def function_block
-    # code of operators composition
+    #your code goes here
   end
 end
 ```
@@ -187,8 +258,8 @@ fx.to_tex
 ```
 
 returns
-```string
-S_0 + V_0 \cdot t + \frac{a \cdot t^{2}}{2}
+```tex
+f(t, a, S_0, V_0) = S_0 + V_0 \cdot t + \frac{a \cdot t^{2}}{2}
 ```
 
 ##### to_gnu
@@ -197,36 +268,8 @@ fx.to_gnu
 ```
 
 returns
-```string
-S0 + V0 * t + (a * t**(2))/(2)
-```
-
-##### describe_tex
-Returns the full description of the function
-
-```ruby
-fx.name = :g
-fx.describe_tex
-```
-
-returns
-
-```string
-g(t, a, S_0, V_0) = S_0 + V_0 \cdot t + \frac{a \cdot t^{2}}{2}
-```
-
-##### describe_gnu
-Returns the full description of the function
-
-```ruby
-fx.name = :g
-fx.describe_gnu
-```
-
-returns
-
-```string
-g(t, a, S0, V0) = S0 + V0 * t + (a * t**(2))/(2)
+```gnuplot
+f(t, a, S0, V0) = S0 + V0 * t + (a * t**(2))/(2)
 ```
 
 ##### calculate / to_f
@@ -282,7 +325,7 @@ fx.to_tex
 ```
 
 returns
-```string
+```tex
 x^{2} -y^{2}
 ```
 
@@ -292,12 +335,12 @@ fx.to_gnu
 ```
 
 returns
-```string
+```gnuplot
 x**(2) -y**(2)
 ```
 
 ### DSL and building
-A function can be created using the DSL direct from ```Danica```
+An expression can be created using the DSL direct from ```Danica```
 
 ```ruby
 Danica.build do
@@ -305,7 +348,7 @@ Danica.build do
 end
 ```
 
-will result into a ```Danica::Operator::Power``` object
+will result into a ```Danica::Operator::Power``` wrapped into an ```Danica::Expression```
 
 ```ruby
 Danica::Operator::Power.new(:x, -1)

data/lib/danica/builder.rb

@@ -2,8 +2,10 @@ module Danica
   class Builder
     include DSL
 
-    def build(&block)
-      instance_eval(&block)
+    def build(*vars, &block)
+      Expression.create(*vars, &block).tap do |expression|
+        return expression.expression_block if expression.expression_block.is_a? Expressable
+      end
     end
   end
 end

data/lib/danica/function/name.rb

@@ -4,7 +4,7 @@ module Danica
     attr_reader :name, :containers
 
     def initialize(name:, variables:)
-      @name = name
+      @name = name || :f
       @containers = variables.map do |v|
         v = wrap_value(v)
         v = Wrapper::Container.new(v) unless v.container?

data/lib/danica/version.rb

@@ -1,3 +1,3 @@
 module Danica
-  VERSION = '2.5.0'
+  VERSION = '2.5.1'
 end

data/spec/integration/readme/danica_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Danica do
+  describe '.build' do
+    context 'when building an expression' do
+      let(:expression) do
+        Danica.build do
+          (number(1) + 2) * power(3,4)
+        end
+      end
+
+      it do
+        expect(expression).to be_a(Danica::Expression)
+      end
+    end
+
+    context 'when building a function' do
+      let(:function) do
+        Danica.build do
+          Danica::Function.create(:x, :y) do
+            (number(1) + x) * power(3, y)
+          end
+        end
+      end
+
+      it do
+        expect(function).to be_a(Danica::Function)
+      end
+    end
+  end
+end
+

data/spec/integration/readme/equation_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Danica::Equation do
+  subject do
+    described_class.new.tap do |equation|
+      equation.left = Danica.build(:x, :y) do
+        x ** 2 + y ** 2
+      end
+      equation.right = Danica.build(:x, :z) do
+        number(1) - z ** 2
+      end
+    end
+  end
+
+  describe '#to_gnu' do
+    it 'generates the gnu format' do
+      expect(subject.to_gnu).to eq('x**(2) + y**(2) = 1 -z**(2)')
+    end
+  end
+end

data/spec/integration/readme/expression_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Danica::Expression::Baskara do
+  describe '#to_tex' do
+    it 'returns bascara tex string' do
+      expect(subject.to_tex).to eq('\frac{-b \pm \sqrt{b^{2} -4 \cdot a \cdot c}}{2 \cdot a}')
+    end
+  end
+end
+
+describe Danica::Expression do
+  let(:clazz) do
+    described_class.build(:a, :b, :c) do
+       (
+         negative(b) + Danica::Wrapper::PlusMinus.new(
+           squared_root(
+             power(b, 2) - multiplication(4, a, c)
+           )
+         )
+       ) / (number(2) * a)
+    end
+  end
+  subject { clazz.new }
+
+  describe 'to_tex' do
+    it 'returns bascara tex string' do
+      expect(subject.to_tex).to eq('\frac{-b \pm \sqrt{b^{2} -4 \cdot a \cdot c}}{2 \cdot a}')
+    end
+  end
+end

data/spec/integration/readme/function_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Danica::Function::Spatial do
+  subject do
+    described_class.new(
+      time: :t,
+      acceleration: 'a',
+      initial_space: { name: :S0, latex: 'S_0', gnu: 'S0' },
+      initial_velocity: { name: :V0, latex: 'V_0', gnu: 'V0' }
+    )
+  end
+
+  let(:name) { :f }
+
+  context 'when using it as default' do
+    let(:left) { "#{name}(time, acceleration, initial_space, initial_velocity)" }
+    let(:right) { 'initial_space + initial_velocity * time + (acceleration * time**(2))/(2)' }
+
+    subject { described_class.new }
+
+    it 'knows how to return to gnu format' do
+      expect(subject.to_gnu).to eq("#{left} = #{right}")
+    end
+
+    context 'when changing the name' do
+      let(:name) { :g }
+      subject { described_class.new(name: name) }
+
+      it 'knows how to return to gnu format' do
+        expect(subject.to_gnu).to eq("#{left} = #{right}")
+      end
+    end
+  end
+
+  context 'when setting the variables' do
+    let(:variables) do
+      { time: :t, acceleration: :a, initial_space: :s0, initial_velocity: :v0 }
+    end
+    let(:left) { "#{name}(t, a, s0, v0)" }
+    let(:right) { 's0 + v0 * t + (a * t**(2))/(2)' }
+
+    subject { described_class.new(variables) }
+
+    it 'knows how to return to gnu format' do
+      expect(subject.to_gnu).to eq("#{left} = #{right}")
+    end
+  end
+
+  describe '#to_tex' do
+    let(:left) { "#{name}(t, a, S_0, V_0)" }
+    let(:right) { 'S_0 + V_0 \cdot t + \frac{a \cdot t^{2}}{2}' }
+
+    it 'builds tex format with its variables' do
+      expect(subject.to_tex).to eq("#{left} = #{right}")
+    end
+  end
+
+  describe '#to_gnu' do
+    let(:left) { "#{name}(t, a, S0, V0)" }
+    let(:right) { 'S0 + V0 * t + (a * t**(2))/(2)' }
+
+    it 'builds gnu format with its variables' do
+      expect(subject.to_gnu).to eq("#{left} = #{right}")
+    end
+  end
+end
+
+describe Danica::Function::MyFunction do
+  describe '#to_gnu' do
+    it 'returns the function' do
+      expect(subject.to_gnu).to eq('f(x, y) = x**(2) + y')
+    end
+  end
+end

data/spec/integration/readme/operator_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe MyOperator do
+  describe '#to_gnu' do
+    it 'returns the gnu format' do
+      expect(subject.to_gnu).to eq('x**(pi)')
+    end
+  end
+
+  describe '#to_tex' do
+    it 'returns the tex format' do
+      expect(subject.to_tex).to eq('x^{\pi}')
+    end
+  end
+
+  describe '#to_f' do
+    subject { described_class.new(x: 2) }
+
+    it 'returns the result of the operation' do
+      expect(subject.to_f).to eq(2 ** Math::PI)
+    end
+  end
+end
+
+describe Danica::Operator::Inverse do
+  subject { described_class.new(:x) }
+
+  describe '#to_tex' do
+    it 'returns the formated tex string' do
+      expect(subject.to_tex).to eq('(x)^{-1}')
+    end
+  end
+
+  describe '#to_gnu' do
+    it 'returns the formated gnu string' do
+      expect(subject.to_gnu).to eq('(x) ** -1')
+    end
+  end
+
+  describe '#to_f' do
+    it do
+      expect { subject.to_f }.to raise_error(Danica::Exception::NotDefined)
+    end
+
+    context 'when value is defined' do
+      subject { described_class.new 2 }
+
+      it 'returns the calculated value' do
+        expect(subject.to_f).to eq(0.5)
+      end
+    end
+  end
+
+  describe '#calculate' do
+    it 'returns the calculated value' do
+      expect(subject.calculate(2)).to eq(0.5)
+    end
+  end
+end

data/spec/lib/danica_spec.rb

@@ -10,7 +10,7 @@ describe Danica do
       end
 
       it 'returns the expected addition' do
-        expect(result).to eq(Danica::Operator::Addition.new(1,2))
+        expect(result.expression_block).to eq(Danica::Operator::Addition.new(1,2))
       end
     end
 
@@ -26,7 +26,7 @@ describe Danica do
       end
 
       it 'returns the expected power' do
-        expect(result).to eq(expected)
+        expect(result.expression_block).to eq(expected)
       end
     end
 
@@ -37,7 +37,7 @@ describe Danica do
       let(:expected) { Danica::Wrapper::Negative.new(10) }
 
       it 'returns the expected negative' do
-        expect(result).to eq(expected)
+        expect(result.expression_block).to eq(expected)
       end
     end
 
@@ -55,6 +55,10 @@ describe Danica do
         end.new
       end
 
+      it do
+        expect(result).to be_a(Danica::Function)
+      end
+
       it 'returns the expected function with variables' do
         expect(result.variables_hash).to eq(function.variables_hash)
       end
@@ -76,7 +80,7 @@ describe Danica do
       end
 
       it 'wrap object with negative' do
-        expect(result).to eq(expected)
+        expect(result.expression_block).to eq(expected)
       end
 
       context 'for a number' do
@@ -89,7 +93,7 @@ describe Danica do
         end
 
         it 'wrap object with negative' do
-          expect(result).to eq(expected)
+          expect(result.expression_block).to eq(expected)
         end
       end
     end

data/spec/support/models/function/my_function.rb

@@ -0,0 +1,7 @@
+class MyFunction < Danica::Function
+  variables :x, :y
+
+  def function_block
+    x ** 2 + y
+  end
+end

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

@@ -0,0 +1,31 @@
+module Danica
+  class Function::Spatial < Function
+    variables :time, :acceleration, :initial_space, :initial_velocity
+
+    private
+
+    def function_block
+      @function_block ||= addition(parcels)
+    end
+
+    def parcels
+      [
+        initial_space,
+        spatial_velocity,
+        spatial_acceleration
+      ]
+    end
+
+    def spatial_velocity
+      multiplication(initial_velocity, time)
+    end
+
+    def spatial_acceleration
+      division(multiplication(acceleration, time_squared), 2)
+    end
+
+    def time_squared
+      power(time, 2)
+    end
+  end
+end

data/spec/support/models/operator/inverse.rb

@@ -0,0 +1,15 @@
+class Danica::Operator::Inverse < Danica::Operator
+  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
+
+  def to_tex
+    "(#{value.to_tex})^{-1}"
+  end
+
+  def to_gnu
+    "(#{value.to_gnu}) ** -1"
+  end
+end

data/spec/support/models/operator/my_operator.rb

@@ -0,0 +1,15 @@
+class MyOperator < Danica::Operator
+  variables :x
+
+  def to_f
+    (x ** Danica::PI).to_f
+  end
+
+  def to_tex
+    "#{x.to_tex}^{\\pi}"
+  end
+
+  def to_gnu
+    "#{x.to_tex}**(pi)"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: danica
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.5.1
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-19 00:00:00.000000000 Z
+date: 2017-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -179,6 +179,11 @@ files:
 - spec/integration/negative_spec.rb
 - spec/integration/plus_minus_spec.rb
 - spec/integration/power_spec.rb
+- spec/integration/readme/danica_spec.rb
+- spec/integration/readme/equation_spec.rb
+- spec/integration/readme/expression_spec.rb
+- spec/integration/readme/function_spec.rb
+- spec/integration/readme/operator_spec.rb
 - spec/lib/danica/common_spec.rb
 - spec/lib/danica/dsl_spec.rb
 - spec/lib/danica/equation_spec.rb
@@ -210,6 +215,10 @@ files:
 - spec/support/models/expression/hyperbole.rb
 - spec/support/models/expression/spatial.rb
 - spec/support/models/function/hyperbole.rb
+- spec/support/models/function/my_function.rb
+- spec/support/models/function/spatial.rb
+- spec/support/models/operator/inverse.rb
+- spec/support/models/operator/my_operator.rb
 - spec/support/models/variables_holder/dummy.rb
 - spec/support/shared_contexts/common.rb
 - spec/support/shared_examples/base_operations.rb
@@ -247,6 +256,11 @@ test_files:
 - spec/integration/negative_spec.rb
 - spec/integration/plus_minus_spec.rb
 - spec/integration/power_spec.rb
+- spec/integration/readme/danica_spec.rb
+- spec/integration/readme/equation_spec.rb
+- spec/integration/readme/expression_spec.rb
+- spec/integration/readme/function_spec.rb
+- spec/integration/readme/operator_spec.rb
 - spec/lib/danica/common_spec.rb
 - spec/lib/danica/dsl_spec.rb
 - spec/lib/danica/equation_spec.rb
@@ -278,6 +292,10 @@ test_files:
 - spec/support/models/expression/hyperbole.rb
 - spec/support/models/expression/spatial.rb
 - spec/support/models/function/hyperbole.rb
+- spec/support/models/function/my_function.rb
+- spec/support/models/function/spatial.rb
+- spec/support/models/operator/inverse.rb
+- spec/support/models/operator/my_operator.rb
 - spec/support/models/variables_holder/dummy.rb
 - spec/support/shared_contexts/common.rb
 - spec/support/shared_examples/base_operations.rb