danica 2.6.1 → 2.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6ab0d9ea017c75592538650e87321f8223d1ae8
-  data.tar.gz: 5ad1639d117735e732418131973c42a18f0c90fd
+  metadata.gz: d736e0ee01a6528dec7f12896f5c1338e00d51d6
+  data.tar.gz: ca775b26d49286a0822f90c8a75568da819deac2
 SHA512:
-  metadata.gz: 252bf663163b2229951c1d1dcc5c261b48f7a6bd737d484036b08a052f0c9b68fb9efd973fa3e11acc07ba78e83e6b1a3a5e699197a6c0359f90a180f7b6daad
-  data.tar.gz: cb75b81a3d39061fe4eaaaceafbcd8d9ba103ff746f98022d80c7fc8434276a94f347d031d49048d4df75ff39218f0916f3626c27c1c9984d9aee28a9fc20280
+  metadata.gz: 599da1c0739706613bf7b9b67fe6915ed08faa9229003f35742a8f6dbcd9a0e033fe11ce6d2c66022aeb21d6b47c5d16ff1a8a03a1964d8be854860403b7b82d
+  data.tar.gz: 3de9269044e1ed521210f137d95bf283d2ee9809de5b8db38ccd062e5c4e7eb404649fcf4bd6ff75c5ff11a1902af341fbbff8331ca01145dfe37ea19d90812e

data/README.md

@@ -341,7 +341,6 @@ returns
 ```gnuplot
 x**(2) -y**(2)
 ```
-
 ### DSL and building
 An expression can be created using the DSL direct from ```Danica```
 
@@ -357,7 +356,7 @@ will result into a ```Danica::Operator::Power``` wrapped into an ```Danica::Expr
 Danica::Operator::Power.new(:x, -1)
 ```
 
-#### Operator registering on DSL
+#### Operator registration on DSL
 
 Any operator created can be added to the DSL by running ```DSL.register_operator```
 
@@ -401,3 +400,156 @@ will result into a ```Danica::Operator::Inverse``` object
 ```ruby
 Danica::Operator::Inverse.new(:x)
 ```
+
+### Variables
+Variables are instances of ```Danica::Wrapper::Variable``` having the optional attributes
+```name```, ```gnu``` , ```latex``` and ```value```
+
+The initialization of the variable can be made through the class, DSL or when initializing an operator
+
+```ruby
+  Danica::Wrapper::Variable.new(:x)
+```
+
+```ruby
+  Danica::Wrapper::Variable.new(name: :x)
+```
+
+```ruby
+Danica::DSL.build do
+  variable(:x)
+end
+```
+
+all will create the same variable that can be coverted ```#to_tex```
+
+```string
+x
+```
+
+When using it with function, operators or other ```Danica::Common``` objects, the variables are wrapped
+automatically
+
+```ruby
+Danica::DSL.build do
+  power(:x, { name: :y }) + :z
+end
+```
+
+will result in
+
+```ruby
+Danica::Operator::Addition.new(
+  Danica::Operator::Power.new(
+    Danica::Wrapper::Variable.new(:x), 
+    Danica::Wrapper::Variable.new(:y) 
+  ),
+  Danica::Wrapper::Variable.new(:z) 
+)
+```
+
+Variables can also behave differently when converting to tex or gnu
+
+```ruby
+Danica::DSL.build do
+  variable(name: :frequency, latex: '\lambda', gnu: :f)
+end
+```
+would produce different ```#to_tex``` and ```#to_gnu``` results (```\lambda``` and ```f``` respectvly)
+
+Also, valued variables will always use their value on string representation
+
+```ruby
+Danica::DSL.build do
+  variable(name: :frequency, latex: '\lambda', gnu: :f, value: 2)
+end
+```
+
+will always return ```2``` for both ```to(:tex)``` and ```to(:gnu)``` calls
+
+#### #to_f
+
+Variables can be used to calculate the value of an expression by usage of the value attribute
+
+```ruby
+Danica::DSL.build do
+  variable(name: :x, value: 2)
+end
+```
+
+with will respond to ```#tot_f``` as ```2```
+
+It can be used when calculating an expression later
+
+```ruby
+x = Danica::DSL.build do
+  variable(:x)
+end
+
+p = Danica::DSL.build do
+  power(x, 2)
+end
+
+x.value = 4
+p.to_f
+```
+
+which will return ```16```
+
+### Number
+Numberss are simple wrappers using ```Danica::Wrapper::Number```
+
+they can be initialized explicitly, through the DSL or whenever an operation is made with other ```Danica``` objects
+
+```ruby
+Danica::Wrapper::Number.new(3)
+```
+
+```ruby
+Danica::DSL.build do
+  number(3)
+end
+```
+
+will both return the number object that can be used to generate tex, gnu or float outputs (for calculation)
+
+Other ways of creating instances of number is when using it as a right side element in basic operations such as sum
+or when using it as the parameter of any other class such as functions and operators
+
+```ruby
+Danica::DSL.build do
+  power(:x, 2) + 3
+end
+```
+
+will create
+
+```ruby
+Danica::Operator::Addition.new(
+  Danica::Operator::Power.new(
+    Danica::Wrapper::Variable.new(:x), 
+    Danica::Wrapper::Number.new(2)
+  ),
+  Danica::Wrapper::Number.new(3)
+)
+```
+
+### Constant
+Constant are pretty much like any other variable, except that they always have value,
+and have a gnu and latex representation.
+
+While variables with value have a numeric string representation, constants will always
+be represented by their string attribute
+
+```ruby
+Danica::Wrapper::Constant.new(gnu: 'pi', latex: '\pi', value: 3.141592)
+```
+which will have the returns of ```#to(format)``` obeying the following
+
+```ruby
+{
+  tex: '\pi',
+  gnu: 'pi',
+  f: 3.141592
+}
+```

data/lib/danica/common.rb

@@ -38,6 +38,8 @@ module Danica
         to_tex
       when :gnu
         to_gnu
+      when :f
+        to_f
       else
         raise Exception::FormatNotFound.new
       end

data/lib/danica/dsl.rb

@@ -1,18 +1,32 @@
 module Danica
   module DSL
-    def self.register_operator(method, clazz=nil)
-      register(method, clazz, 'Danica::Operator')
-    end
+    class << self
+      def register_operator(method, clazz=nil)
+        register(method, clazz, 'Danica::Operator')
+      end
 
-    def self.register_wrapper(method, clazz=nil)
-      register(method, clazz, 'Danica::Wrapper')
-    end
+      def register_wrapper(method, clazz=nil)
+        register(method, clazz, 'Danica::Wrapper')
+      end
+
+      def register(method, clazz=nil, base=nil)
+        define_method method do |*args|
+          clazz = [base.to_s, method.to_s.camelize].compact.join('::').constantize unless clazz
+          clazz = [base, clazz.to_s].compact.join('::').constantize unless clazz.is_a? Class
+          clazz.new(*args)
+        end
+      end
+
+      def build(&block)
+        builder.instance_eval(&block)
+      end
+
+      private
 
-    def self.register(method, clazz=nil, base=nil)
-      define_method method do |*args|
-        clazz = [base.to_s, method.to_s.camelize].compact.join('::').constantize unless clazz
-        clazz = [base, clazz.to_s].compact.join('::').constantize unless clazz.is_a? Class
-        clazz.new(*args)
+      def builder
+        @builder ||= Class.new do
+          include DSL
+        end.new
       end
     end
 

data/lib/danica/version.rb

@@ -1,3 +1,3 @@
 module Danica
-  VERSION = '2.6.1'
+  VERSION = '2.6.2'
 end

data/lib/danica/wrapper/variable.rb

@@ -11,7 +11,7 @@ module Danica
 
     def initialize(*args)
       attrs = args.extract_options!
-      attrs = args.as_hash(%i(value name latex gnu)).merge(attrs)
+      attrs = args.as_hash(%i(name value latex gnu)).merge(attrs)
 
       attrs.each do |key, value|
         self.public_send("#{key}=", value)

data/spec/integration/readme/number_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Danica::Wrapper::Number do
+  let(:number) do
+    Danica::Wrapper::Number.new(3)
+  end
+
+  subject do
+    Danica::DSL.build do
+      number(3)
+    end
+  end
+
+  it do
+    expect(subject).to eq(number)
+  end
+
+  describe 'from basic operation' do
+    let(:sum) do
+      Danica::DSL.build do
+        power(:x, 2) + 3
+      end
+    end
+
+    let(:expected) do
+      Danica::Operator::Addition.new(
+        Danica::Operator::Power.new(
+          Danica::Wrapper::Variable.new(:x), 
+          Danica::Wrapper::Number.new(2)
+        ),
+        Danica::Wrapper::Number.new(3)
+      )
+    end
+
+    it do
+      expect(sum).to eq(expected)
+    end
+  end
+end
+

data/spec/integration/readme/variables_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Danica::Wrapper::Variable do
+  describe '#to_tex' do
+    context 'when initializing with the name' do
+      subject do
+        Danica::Wrapper::Variable.new(:x)
+      end
+
+      it do
+        expect(subject.to_tex).to eq('x')
+      end
+    end
+
+    context 'when initializing with a hash' do
+      subject do
+        Danica::Wrapper::Variable.new(name: :x)
+      end
+
+      it do
+        expect(subject.to_tex).to eq('x')
+      end
+    end
+
+    context 'when initializing from DSL' do
+      subject do
+        Danica::DSL.build do
+          variable(:x)
+        end
+      end
+
+      it do
+        expect(subject.to_tex).to eq('x')
+      end
+    end
+
+    context 'when variable has value' do
+      subject do
+        Danica::DSL.build do
+          variable(name: :frequency, latex: '\lambda', gnu: :f, value: 2)
+        end
+      end
+
+      it do
+        expect(subject.to_tex).to eq('2')
+      end
+    end
+  end
+
+  describe '#to_f' do
+    subject do
+      Danica::DSL.build do
+        variable(name: :x, value: 2)
+      end
+    end
+
+    it do
+      expect(subject.to_f).to eq(2)
+    end
+
+    context 'when adding the value later' do
+      subject do
+        Danica::DSL.build do
+          variable(:x)
+        end
+      end
+
+      let(:power) do
+        variable = subject
+        Danica::DSL.build do
+          power(variable, 2)
+        end
+      end
+
+      it do
+        subject.value = 4
+        expect(power.to_f).to eq(16)
+      end
+    end
+  end
+
+  describe 'custom outputs' do
+    subject do
+      Danica::DSL.build do
+        variable(name: :frequency, latex: '\lambda', gnu: :f)
+      end
+    end
+
+    describe '#to_tex' do
+      it do
+        expect(subject.to_tex).to eq('\lambda')
+      end
+    end
+
+    describe '#to_gnu' do
+      it do
+        expect(subject.to_gnu).to eq('f')
+      end
+    end
+  end
+
+  describe 'automatic wrapp' do
+    let(:sum) do
+      Danica::DSL.build do
+        power(:x, { name: :y }) + :z
+      end
+    end
+
+    let(:expected) do
+      Danica::Operator::Addition.new(
+        Danica::Operator::Power.new(
+          Danica::Wrapper::Variable.new(:x),
+          Danica::Wrapper::Variable.new(:y)
+        ),
+        Danica::Wrapper::Variable.new(:z)
+      )
+    end
+
+    it do
+      expect(sum).to eq(expected)
+    end
+  end
+end

data/spec/lib/danica/dsl_spec.rb

@@ -45,4 +45,17 @@ describe Danica::DSL do
 
   let(:subject) { described_class::Dummy.new }
   it_behaves_like 'a class with mapped dsl'
+
+  describe '.build' do
+    let(:expected) do
+      Danica::Operator::Addition.new(
+        Danica::Wrapper::Number.new(2),
+        Danica::Wrapper::Variable.new(:x)
+      )
+    end
+
+    it 'executes the build block' do
+      expect(described_class.build { number(2) + variable(:x) }).to eq(expected)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: danica
 version: !ruby/object:Gem::Version
-  version: 2.6.1
+  version: 2.6.2
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-08 00:00:00.000000000 Z
+date: 2018-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -185,7 +185,9 @@ files:
 - spec/integration/readme/equation_spec.rb
 - spec/integration/readme/expression_spec.rb
 - spec/integration/readme/function_spec.rb
+- spec/integration/readme/number_spec.rb
 - spec/integration/readme/operator_spec.rb
+- spec/integration/readme/variables_spec.rb
 - spec/lib/danica/common_spec.rb
 - spec/lib/danica/dsl_spec.rb
 - spec/lib/danica/equation_spec.rb
@@ -263,7 +265,9 @@ test_files:
 - spec/integration/readme/equation_spec.rb
 - spec/integration/readme/expression_spec.rb
 - spec/integration/readme/function_spec.rb
+- spec/integration/readme/number_spec.rb
 - spec/integration/readme/operator_spec.rb
+- spec/integration/readme/variables_spec.rb
 - spec/lib/danica/common_spec.rb
 - spec/lib/danica/dsl_spec.rb
 - spec/lib/danica/equation_spec.rb