ragni-cas 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5050928caea86f26844bb7d526712ebbac3955bd
-  data.tar.gz: d65f4cc064b36c402cea4dc49a7ad983130af256
+  metadata.gz: 37f26b41c10ea87025194d269eca06dd324ab079
+  data.tar.gz: db0c443f3488b0229a8d3fac2d3e891815c80fd5
 SHA512:
-  metadata.gz: ad30cd4099786ab30fcfb02d2df868fdd2addf7ae69611c881f5cffaa2f46ba414bd66b4cb84c868582c92b1fce4c2b9a163379b194c2f717d83c5de3bb2a237
-  data.tar.gz: d5edfc457d09f2758d18108af41e96c4107634e7dcd9aaee0ce03b0eeb85b33ccab641890e9b8e0585268bbbee5242cba8f49cc505a37cc6c9c7c8f76ad62681
+  metadata.gz: 83557eef91cc4384d07fa82c835a33e8351465c38a84036af6f5eda0b08281f08e4152fc88fb0f91d4ecb03bf4d181b33facdc25d54d67822589a95002a0829d
+  data.tar.gz: 6ad9a1a6d43df4685db8468f0fe82bf6ff82047173ed60deec848b3a2709edd99a38363a24978ffadd32bbaa983e88707f6399a3376f452ca37efa255e389140

data/lib/fnc-branch.rb

@@ -45,7 +45,7 @@ module CAS
       cls = "#{self.class.to_s.gsub("CAS::", "")}_#{self.object_id}"
       "#{cls} -> #{@x.dot_graph node}\n  #{cls} -> #{@y.dot_graph node}\n  #{cls} -> #{@condition.dot_graph node}"
     end
-    
+
     def to_latex
       "\\left\\{ \\begin{array}{lr} #{@x.to_latex} & #{@condition.to_latex} \\\\ #{@y.to_latex} \\end{array} \\right."
     end
@@ -154,56 +154,192 @@ module CAS
       cls = "#{self.class.to_s.gsub("CAS::", "")}_#{self.object_id}"
       "#{cls} -> #{@x.dot_graph node}\n  #{cls} -> #{@y.dot_graph node}"
     end
-  end
+  end # Condition
 
   class Equal < CAS::Condition
     def initialize(x, y)
       super(:eq, x, y)
     end
-    
+
     def to_latex
       "#{@x.to_latex} = #{@y.to_latex}"
     end
-  end
+  end # Equal
 
   class Greater < CAS::Condition
     def initialize(x, y)
       super(:gt, x, y)
     end
-    
+
     def to_latex
       "#{@x.to_latex} > #{@y.to_latex}"
     end
-  end
+  end # Greater
 
   class GreaterEqual < CAS::Condition
     def initialize(x, y)
       super(:geq, x, y)
     end
-    
+
     def to_latex
       "#{@x.to_latex} \\geq #{@y.to_latex}"
     end
-  end
+  end # GreaterEqual
 
   class Smaller < CAS::Condition
     def initialize(x, y)
       super(:lt, x, y)
     end
-    
+
     def to_latex
       "#{@x.to_latex} < #{@y.to_latex}"
     end
-  end
+  end # Smaller
 
   class SmallerEqual < CAS::Condition
     def initialize(x, y)
       super(:leq, x, y)
     end
-    
+
     def to_latex
       "#{@x.to_latex} \\leq #{@y.to_latex}"
     end
+  end # SmallerEqual
+
+  class BoxCondition < CAS::Condition
+    attr_reader :x, :lower, :upper
+
+    def initialize(x, lower, upper, type=:closed)
+      if lower.is_a? Numeric
+        lower = CAS::const lower
+      end
+      if upper.is_a? Numeric
+        upper = CAS::const upper
+      end
+      CAS::Help.assert(lower, CAS::Constant)
+      CAS::Help.assert(upper, CAS::Constant)
+      CAS::Help.assert(x, CAS::Op)
+      CAS::Help.assert(type, Symbol)
+
+      lower, upper = upper, lower if lower.x > upper.x
+
+      @lower = lower
+      @upper = upper
+      @x = x
+
+      case type
+      when :open
+        self.define_singleton_method :call do |fd|
+          (@lower.call(fd) < @x.call(fd)) and (@x.call(fd) < @upper.call(fd))
+        end
+        self.define_singleton_method :inspect do
+          "#{@lower.inspect} < #{@x.inspect} < #{@upper.inspect}"
+        end
+        self.define_singleton_method :to_s do
+          "#{@lower} < #{@x} < #{@upper}"
+        end
+        self.define_singleton_method :to_code do
+          "(#{@lower.to_code} < #{@x.to_code} and #{@x.to_code} < #{@upper.to_code}"
+        end
+      when :closed
+        self.define_singleton_method :call do |fd|
+          (@lower.call(fd) <= @x.call(fd)) and (@x.call(fd) <= @upper.call(fd))
+        end
+        self.define_singleton_method :inspect do
+          "#{@lower.inspect} ≤ #{@x.inspect} ≤ #{@upper.inspect}"
+        end
+        self.define_singleton_method :to_s do
+          "#{@lower} ≤ #{@x} ≤ #{@upper}"
+        end
+        self.define_singleton_method :to_code do
+          "(#{@lower.to_code} <= #{@x.to_code} and #{@x.to_code} <= #{@upper.to_code}"
+        end
+      when :upper_closed
+        self.define_singleton_method :call do |fd|
+          (@lower.call(fd) < @x.call(fd)) and (@x.call(fd) <= @upper.call(fd))
+        end
+        self.define_singleton_method :inspect do
+          "#{@lower.inspect} < #{@x.inspect} ≤ #{@upper.inspect}"
+        end
+        self.define_singleton_method :to_s do
+          "#{@lower} < #{@x} ≤ #{@upper}"
+        end
+        self.define_singleton_method :to_code do
+          "(#{@lower.to_code} < #{@x.to_code} and #{@x.to_code} <= #{@upper.to_code}"
+        end
+      when :lower_closed
+        self.define_singleton_method :call do |fd|
+          (@lower.call(fd) <= @x.call(fd)) and (@x.call(fd) < @upper.call(fd))
+        end
+        self.define_singleton_method :inspect do
+          "#{@lower.inspect} ≤ #{@x.inspect} < #{@upper.inspect}"
+        end
+        self.define_singleton_method :to_s do
+          "#{@lower} ≤ #{@x} < #{@upper}"
+        end
+        self.define_singleton_method :to_code do
+          "(#{@lower.to_code} <= #{@x.to_code} and #{@x.to_code} < #{@upper.to_code}"
+        end
+      else
+        raise ArgumentError, "Unknown type of box condition"
+      end
+    end
+
+    def depend?(v)
+      @x.depend? v
+    end
+
+    def simplify
+      @x.simplify
+      return self
+    end
+
+    def subs(fd)
+      @x = @x.subs(fd)
+      return self
+    end
+
+    def diff(v)
+      CAS::equal(@x.diff(x).simplify, CAS::Zero)
+    end
+
+    def dot_graph(node)
+      cls = "#{self.class.to_s.gsub("CAS::", "")}_#{self.object_id}"
+      " #{cls} -> #{@lower.dot_graph node}\n #{cls} -> #{@x.dot_graph node}\n #{cls} -> #{@upper.dot_graph node}\n"
+    end
+
+    def ==(cond)
+      return false if not self.class != cond.class
+      return (@x == cond.x and @lower == cond.lower and @upper == cond.upper)
+    end
+
+    def !=(cond)
+      not self == cond
+    end
+  end # BoxCondition
+
+  class BoxConditionOpen < CAS::BoxCondition
+    def initialize(x, a, b)
+      super x, a, b, :open
+    end
+  end
+
+  class BoxConditionClosed < CAS::BoxCondition
+    def initialize(x, a, b)
+      super x, a, b, :closed
+    end
+  end
+
+  class BoxConditionUpperClosed < CAS::BoxCondition
+    def initialize(x, a, b)
+      super x, a, b, :upper_closed
+    end
+  end
+
+  class BoxConditionLowerClosed < CAS::BoxCondition
+    def initialize(x, a, b)
+      super x, a, b, :lower_closed
+    end
   end
 
   def self.equal(x, y); CAS::Equal.new(x, y); end
@@ -212,11 +348,28 @@ module CAS
   def self.smaller(x, y); CAS::Smaller.new(x, y); end
   def self.smaller_equal(x, y); CAS::SmallerEqual.new(x, y); end
 
+  def self.box(x, a, b, type=:closed)
+    case type
+    when :closed
+      return CAS::BoxConditionClosed.new(x, a, b)
+    when :open
+      return CAS::BoxConditionOpen.new(x, a, b)
+    when :upper_closed
+      return CAS::BoxConditionUpperClosed.new(x, a, b)
+    when :lower_closed
+      return CAS::BoxConditionLowerClosed.new(x, a, b)
+    else
+      raise CAS::CASError, "Unknown box condition type"
+    end
+  end
+
   class Op
     def equal(v); CAS.equal(self, v); end
     def greater(v); CAS.greater(self, v); end
     def smaller(v); CAS.smaller(self, v); end
     def greater_equal(v); CAS.greater_equal(self, v); end
     def smaller_equal(v); CAS.smaller_equal(self, v); end
+
+    def limit(a, b, type=:closed); CAS.box(self, a, b, type); end
   end
 end

data/lib/op.rb

@@ -237,8 +237,8 @@ module CAS
     def as_proc(bind=nil)
       args_ext = self.args.map { |e| "#{e} = fd[\"#{e}\"];" }
       code = "Proc.new do |fd|; #{args_ext.join " "} #{self.to_code}; end"
-      if bind
-        CAS::Help.assert(bind, Binding)
+      if bind # All objects have eval value, we bind when not nil
+        # CAS::Help.assert(bind, Binding)
         bind.eval(code)
       else
         eval(code)
@@ -260,7 +260,7 @@ module CAS
       cls = "#{self.class.to_s.gsub("CAS::", "")}_#{self.object_id}"
       "#{cls} -> #{@x.dot_graph node}\n"
     end
-    
+
     # Returns the latex representation of the current Op.
     #
     # -> `String`
@@ -443,7 +443,7 @@ module CAS
       cls = "#{self.class.to_s.gsub("CAS::", "")}_#{self.object_id}"
       "#{cls} -> #{@x.dot_graph node}\n  #{cls} -> #{@y.dot_graph node}"
     end
-    
+
     # Returns the latex representation of the current Op.
     #
     # -> `String`

data/lib/ragni-cas.rb

@@ -22,12 +22,15 @@
 # Copyright:: Copyright (c) 2016 Matteo Ragni
 # License:: Distributed under MIT license term
 
-require_relative 'op.rb'
-require_relative 'numbers.rb'
-require_relative 'fnc-base.rb'
-require_relative 'fnc-trig.rb'
-require_relative 'fnc-trsc.rb'
-require_relative 'fnc-branch.rb'
+#  ___               _
+# | _ \___ __ _ _  _(_)_ _ ___ ___
+# |   / -_) _` | || | | '_/ -_|_-<
+# |_|_\___\__, |\_,_|_|_| \___/__/
+#            |_|
+
+%w|op.rb numbers.rb fnc-base.rb fnc-trig.rb fnc-trsc.rb fnc-branch.rb version.rb|.each do |r|
+  require File.expand_path(r, File.dirname(__FILE__))
+end
 
 module CAS
 
@@ -118,3 +121,105 @@ digraph Op {
     end
   end
 end
+
+
+#   ___              _              _ _             _  _                    _
+#  / _ \__ _____ _ _| |___  __ _ __| (_)_ _  __ _  | \| |_  _ _ __  ___ _ _(_)__
+# | (_) \ V / -_) '_| / _ \/ _` / _` | | ' \/ _` | | .` | || | '  \/ -_) '_| / _|
+#  \___/ \_/\___|_| |_\___/\__,_\__,_|_|_||_\__, | |_|\_|\_,_|_|_|_\___|_| |_\__|
+#                                           |___/
+class Fixnum
+  alias :overloaded_plus  :+
+  alias :overloaded_minus :-
+  alias :overloaded_mul   :*
+  alias :overloaded_div   :/
+  alias :overloaded_pow   :**
+
+  def +(a)
+    if a.is_a? CAS::Op
+      CAS::const(self) + a
+    else
+      self.overloaded_plus a
+    end
+  end
+
+  def -(a)
+    if a.is_a? CAS::Op
+      CAS::const(self) - a
+    else
+      self.overloaded_minus a
+    end
+  end
+
+  def *(a)
+    if a.is_a? CAS::Op
+      CAS::const(self) * a
+    else
+      self.overloaded_mul a
+    end
+  end
+
+  def /(a)
+    if a.is_a? CAS::Op
+      CAS::const(self) / a
+    else
+      self.overloaded_div a
+    end
+  end
+
+  def **(a)
+    if a.is_a? CAS::Op
+      CAS::const(self) ** a
+    else
+      self.overloaded_pow a
+    end
+  end
+end
+
+class Float
+  alias :overloaded_plus  :+
+  alias :overloaded_minus :-
+  alias :overloaded_mul   :*
+  alias :overloaded_div   :/
+  alias :overloaded_pow   :**
+
+  def +(a)
+    if a.is_a? CAS::Op
+      CAS::const(self) + a
+    else
+      self.overloaded_plus a
+    end
+  end
+
+  def -(a)
+    if a.is_a? CAS::Op
+      CAS::const(self) - a
+    else
+      self.overloaded_minus a
+    end
+  end
+
+  def *(a)
+    if a.is_a? CAS::Op
+      CAS::const(self) * a
+    else
+      self.overloaded_mul a
+    end
+  end
+
+  def /(a)
+    if a.is_a? CAS::Op
+      CAS::const(self) / a
+    else
+      self.overloaded_div a
+    end
+  end
+
+  def **(a)
+    if a.is_a? CAS::Op
+      CAS::const(self) ** a
+    else
+      self.overloaded_pow a
+    end
+  end
+end

data/lib/version.rb

@@ -2,6 +2,6 @@
 #!/usr/bin/env ruby
 
 module CAS
-  VERSION = [0, 2, 0]
+  VERSION = [0, 2, 1]
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ragni-cas
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Matteo Ragni
@@ -29,7 +29,7 @@ cert_chain:
   XorZtzkkLImvKFj35xKLFfVkv0Vd8tGQoiL8vdmQNJjAjtE+C+Y7OI4dpiZPKO4G
   R/8JOvUuk9jPbyLxjQH/sFaFqqYGX2xo1zk2CRy/A0WhJrSaXVw1r5lEi7b0W5gg
   -----END CERTIFICATE-----
-date: 2016-07-27 00:00:00.000000000 Z
+date: 2016-07-28 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: info@ragni.me
@@ -68,5 +68,5 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: An extremely simple CAS system for my optimizers
+summary: An extremely simple CAS, for rapid prototyping and meta-programming
 test_files: []