danica 2.2.1 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe5a9965099461f931104adf9ad6e0372b7a88b4
-  data.tar.gz: d2fe7fd8afe885d6e2064c3e9a80449052d04d4d
+  metadata.gz: ad28c3d7ea149780e400d116c83de57d427766fd
+  data.tar.gz: 03df4bd255f7bd7f3ea1574ff3d762ee79ebcbb5
 SHA512:
-  metadata.gz: dd2f74aabff6aeb3cd57839ac622b26391f0b251bd167a9d693671e1b869968686890641c54a2689e46994f81d39204127b0805873c41912c3fa8c79ee80d539
-  data.tar.gz: a11fa801c71ccf5abbc6086c63c09ba28bf37d9b5d86e2cb7d898c6fde6d07c477f91b1079d1894c6a10e8607dc40055f76fe032922580c61fe68b9d82152c7e
+  metadata.gz: 6d5df83e1861e86792509782fe1c79767ee032d93dfe5b50a353f38960e2897ff1740cfe0876bb958fc1e23a82eb7959df35f3237aa14bff19964755b9953a99
+  data.tar.gz: 239199aeb9ee44347f4721cb65b336926c9f38fef5678c384411c48bcbc57a41426d08aebebe896fbbb11abff5ac6764d8fed5927c58752a3693b5338a2ded6f

data/README.md

@@ -17,6 +17,30 @@ bundle install danica
 
 Now you can use in your project
 
+###Quick Use
+Use Danica build to build and use your formula using ```Danica.build```
+```ruby
+formula = 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
+    (number(1) + x) * power(3, y)
+  end
+end
+
+func.to_gnu
+```
+
+create gnu or tex output strings to be used on yopur template
+
 ### Operators
 Operators are much like function, but they do not have a name.
 
@@ -43,7 +67,7 @@ end
 
 #### Sample
 ```ruby
-class Danica::Inverse < Danica::Operator
+class Danica::Operator::Inverse < Danica::Operator
 
   variables :value
 
@@ -60,7 +84,7 @@ class Danica::Inverse < Danica::Operator
   end
 end
 
-fx = Danica::Inverse.new(:x)
+fx = Danica::Operator::Inverse.new(:x)
 ```
 
 ##### to_tex
@@ -89,7 +113,7 @@ fx.calculate(2)
 ```
 or
 ```ruby
-Danica::Inverse.new(2).to_f
+Danica::Operator::Inverse.new(2).to_f
 ```
 
 both return
@@ -124,7 +148,7 @@ module Danica
     private
 
     def function_block
-      @function_block ||= sum(parcels)
+      @function_block ||= addition(parcels)
     end
 
     def parcels
@@ -136,11 +160,11 @@ module Danica
     end
 
     def spatial_velocity
-      product(initial_velocity, time)
+      multiplication(initial_velocity, time)
     end
 
     def spatial_acceleration
-      division(product(acceleration, time_squared), 2)
+      division(multiplication(acceleration, time_squared), 2)
     end
 
     def time_squared
@@ -253,19 +277,19 @@ Danica.build do
 end
 ```
 
-will result into a ```Danica::Power``` object
+will result into a ```Danica::Operator::Power``` object
 
 ```ruby
-Danica::Power.new(:x, -1)
+Danica::Operator::Power.new(:x, -1)
 ```
 
 #### Operator registering on DSL
 
-Any operator created can be added to the DSL by running ```DSL.register```
+Any operator created can be added to the DSL by running ```DSL.register_operator```
 
 ```ruby
 module Danica
-  class Inverse < Danica::Operator
+  class Operator::Inverse < Danica::Operator
     include DSL
     variables :value
 
@@ -278,16 +302,16 @@ module Danica
 end
 ```
 
-In order to add the new operator, DSL cna infer by the name ```inverse``` which results in ```Danica::Inverse```
+In order to add the new operator, DSL cna infer by the name ```inverse``` which results in ```Danica::Operator::Inverse```
 
 ```ruby
-Danica::DSL.register(:inverse)
+Danica::DSL.register_operator(:inverse)
 ```
 
 or
 
 ```ruby
-Danica::DSL.register(:inverse, Danica::inverse)
+Danica::DSL.register(:inverse, Danica::Operator::Inverse)
 ```
 
 This will allow the usage of the inverse function
@@ -298,8 +322,8 @@ Danica.build do
 end
 ```
 
-will result into a ```Danica::Inverse``` object
+will result into a ```Danica::Operator::Inverse``` object
 
 ```ruby
-Danica::Inverse.new(:x)
+Danica::Operator::Inverse.new(:x)
 ```

data/lib/danica.rb

@@ -1,29 +1,17 @@
 require 'active_model'
+require 'darthjee/core_ext'
 
 module Danica
   autoload :Builder,          'danica/builder'
   autoload :BaseOperations,   'danica/base_operations'
   autoload :VariablesHolder,  'danica/variables_holder'
   autoload :Common,           'danica/common'
-  autoload :Number,           'danica/number'
-  autoload :Negative,         'danica/negative'
-  autoload :PositiveNegative, 'danica/positive_negative'
-  autoload :Group,            'danica/group'
-  autoload :Variable,         'danica/variable'
-  autoload :Operator,         'danica/operator'
   autoload :Function,         'danica/function'
   autoload :Exception,        'danica/exception'
-  autoload :Constant,         'danica/constant'
 
-  autoload :Product,          'danica/product'
-  autoload :Sum,              'danica/sum'
-  autoload :Division,         'danica/division'
-  autoload :Power,            'danica/power'
-  autoload :SquaredRoot,      'danica/squared_root'
-  autoload :Exponential,      'danica/exponential'
-  autoload :Sin,              'danica/sin'
-  autoload :Cos,              'danica/cos'
   autoload :DSL,              'danica/dsl'
+  autoload :Wrapper,          'danica/wrapper'
+  autoload :Operator,         'danica/operator'
 
   class << self
     delegate :build, to: :builder
@@ -32,8 +20,5 @@ module Danica
       @builder ||= Builder.new
     end
   end
-
-  E = Constant.new(Math::E, :e, 'exp(1)')
-  PI =  Constant.new(Math::PI, '\pi', :pi)
 end
 

data/lib/danica/base_operations.rb

@@ -1,21 +1,21 @@
 module Danica
   module BaseOperations
     def +(other)
-      return other + self if other.is_a?(Sum)
-      Sum.new(self, other)
+      return other + self if other.is_a?(Operator::Addition)
+      addition(self, other)
     end
 
     def *(other)
-      return other * self if other.is_a?(Product)
-      Product.new(self, other)
+      return other * self if other.is_a?(Operator::Multiplication)
+      multiplication(self, other)
     end
 
     def /(other)
-      Division.new(self, other)
+      division(self, other)
     end
 
     def -(other)
-      self + Negative.new(other)
+      self + negative(other)
     end
   end
 end

data/lib/danica/common.rb

@@ -1,6 +1,8 @@
 module Danica
   module Common extend ::ActiveSupport::Concern
     included do
+      include DSL
+
       class << self
         def default_value(name, value)
           define_method(name) { value }
@@ -21,16 +23,16 @@ module Danica
     private
 
     def wrap_value(value)
-      return wrap_value(Number.new(value)) if value.is_a?(Numeric)
-      return wrap_value(Variable.new(value)) if value.is_a?(Hash)
-      return wrap_value(Variable.new(name: value)) if [ String, Symbol ].any? { |c| value.is_a?(c) }
-      return wrap_value(Variable.new) if value.nil?
+      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.new(value)
+      group(value)
     end
   end
 end

data/lib/danica/dsl.rb

@@ -1,8 +1,17 @@
 module Danica
   module DSL
-    def self.register(method, clazz=nil)
+    def self.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 self.register(method, clazz=nil, base=nil)
       define_method method do |*args|
-        clazz = "Danica::#{method.to_s.camelize}".constantize unless clazz
+        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
@@ -13,9 +22,16 @@ module Danica
   end
 
   %i(
-    sum product division sin cos power number
-    squared_root exponential group negative
+    addition multiplication division sin cos power
+    squared_root exponential
   ).each do |method|
-    DSL.register(method)
+    DSL.register_operator(method)
   end
+
+  %i(number group negative plus_minus variable).each do |method|
+    DSL.register_wrapper(method)
+  end
+
+  DSL.register_operator :sum, :Addition
+  DSL.register_operator :product, :Multiplication
 end

data/lib/danica/exception.rb

@@ -1,4 +1,4 @@
 class Danica::Exception < ::Exception
-  require 'danica/exception/not_defined'
+  class Danica::Exception::NotDefined < self; end
 end
 

data/lib/danica/operator.rb

@@ -16,5 +16,16 @@ module Danica
       return false unless other.class == self.class
       variables == other.variables
     end
+
+    autoload :Functional,     'danica/operator/functional'
+    autoload :Chained,        'danica/operator/chained'
+    autoload :Multiplication, 'danica/operator/multiplication'
+    autoload :Addition,       'danica/operator/addition'
+    autoload :Division,       'danica/operator/division'
+    autoload :Power,          'danica/operator/power'
+    autoload :Cos,            'danica/operator/cos'
+    autoload :Sin,            'danica/operator/sin'
+    autoload :SquaredRoot,    'danica/operator/squared_root'
+    autoload :Exponential,    'danica/operator/exponential'
   end
 end

data/lib/danica/{sum.rb → operator/addition.rb}

@@ -1,7 +1,5 @@
-require 'danica/operator/chained'
-
 module Danica
-  class Sum < Operator::Chained
+  class Operator::Addition < Operator::Chained
     default_value :priority, 1
 
     def +(other)
@@ -22,7 +20,7 @@ module Danica
 
     def join_proc(symbol)
       proc do |_, value|
-        value.is_a?(Negative) || value.is_a?(PositiveNegative) ? ' ' : " #{symbol} "
+        value.is_a?(Wrapper::Negative) || value.is_a?(Wrapper::PlusMinus) ? ' ' : " #{symbol} "
       end
     end
   end

data/lib/danica/operator/cos.rb

@@ -0,0 +1,5 @@
+module Danica
+  class Operator::Cos < Operator::Functional.build(operator: :cos)
+  end
+end
+

data/lib/danica/{division.rb → operator/division.rb}

@@ -1,5 +1,5 @@
 module Danica
-  class Division < Operator
+  class Operator::Division < Operator
     variables :numerator, :denominator
     default_value :priority, 2
     default_value :is_grouped?, true

data/lib/danica/operator/exponential.rb

@@ -0,0 +1,5 @@
+module Danica
+  class Operator::Exponential < Operator::Functional.build(operator: :exp, tex: 'e^{:value:}')
+  end
+end
+

data/lib/danica/operator/functional.rb

@@ -0,0 +1,29 @@
+module Danica
+  class Operator::Functional < Operator
+    variables :value
+    default_value :is_grouped?, true
+
+    def self.build(operator:, text: nil, tex: nil, gnu: nil)
+      text = "#{operator}(:value:)" if text.nil?
+      tex = text if tex.nil?
+      gnu = text if gnu.nil?
+
+      Class.new(self) do
+        module_eval(%Q(
+          def to_f
+            Math.#{operator}(value.to_f)
+          end
+
+          def to_tex
+            '#{tex.gsub(':value:', "' + value.to_tex + '")}'
+          end
+
+          def to_gnu
+            '#{gnu.gsub(':value:', "' + value.to_gnu + '")}'
+          end
+        ))
+      end
+    end
+  end
+end
+

data/lib/danica/{product.rb → operator/multiplication.rb}

@@ -1,7 +1,5 @@
-require 'danica/operator/chained'
-
 module Danica
-  class Product < Operator::Chained
+  class Operator::Multiplication < Operator::Chained
     default_value :priority, 2
 
     def *(other)

data/lib/danica/{power.rb → operator/power.rb}

@@ -1,5 +1,5 @@
 module Danica
-  class Power < Operator
+  class Operator::Power < Operator
     variables :base, :exponent
     default_value :is_grouped?, false
 

data/lib/danica/operator/sin.rb

@@ -0,0 +1,5 @@
+module Danica
+  class Operator::Sin < Operator::Functional.build(operator: :sin)
+  end
+end
+

data/lib/danica/operator/squared_root.rb

@@ -0,0 +1,5 @@
+module Danica
+  class Operator::SquaredRoot < Operator::Functional.build(operator: :sqrt, tex: '\sqrt{:value:}')
+  end
+end
+

data/lib/danica/variables_holder/variables_builder.rb

@@ -1,5 +1,3 @@
-require 'darthjee/core_ext'
-
 module Danica::VariablesHolder
   class VariablesBuilder
     attr_reader :instance, :attr_names

data/lib/danica/version.rb

@@ -1,3 +1,3 @@
 module Danica
-  VERSION = '2.2.1'
+  VERSION = '2.3.0'
 end

data/lib/danica/wrapper.rb

@@ -0,0 +1,10 @@
+module Danica
+  module Wrapper
+    autoload :Number,    'danica/wrapper/number'
+    autoload :Group,     'danica/wrapper/group'
+    autoload :Negative,  'danica/wrapper/negative'
+    autoload :PlusMinus, 'danica/wrapper/plus_minus'
+    autoload :Constant,  'danica/wrapper/constant'
+    autoload :Variable,  'danica/wrapper/variable'
+  end
+end

data/lib/danica/{constant.rb → wrapper/constant.rb}

@@ -1,5 +1,5 @@
 module Danica
-  class Constant
+  class Wrapper::Constant
     include BaseOperations
     include Common
 
@@ -32,5 +32,8 @@ module Danica
       gnu.to_s
     end
   end
+
+  E = Wrapper::Constant.new(Math::E, :e, 'exp(1)')
+  PI = Wrapper::Constant.new(Math::PI, '\pi', :pi)
 end