ragni-cas 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 84aec56cb941ff1f7b44e118dc3bed327272591d
-  data.tar.gz: 350d3a2064312c08c3a900633e2b0672bf140aa3
+  metadata.gz: 435c49ab6e4a5cbd771acfc5c6afc16a5334141b
+  data.tar.gz: 1a94331f8b29fc383ab7f411ff065ff2d9230a22
 SHA512:
-  metadata.gz: e2a944fe15271c1ef65184a6ab5dd8610617294648cfdb0d67efd351167f4a4e1bd764eeadb0f0c7bfbaf1c35f9d00ff16ca2cca2458c94039faf4018eb6d00c
-  data.tar.gz: 519a211ffcc69806c6c8b366a588e0258a73114f73dd0e8fd5445c9118e93c4f9ae2f71b75ff7682f3ad2ed3ae32bb9bf50726e715f8255f371035249d09dcc9
+  metadata.gz: d56a2fe673ef2e00b4574a39f683050c034838af81a5b822e0d8c6b87288ef09a5ad40848d57fcb2d5e81ffe7e32f1ebbb05e159eb3af283b7ce1bb34cf2c6e3
+  data.tar.gz: ff85830bb67960b656e31a3b6579993f6e40211ad06a3894223029bd99daf4a29210b94053880a9bcaf3c2f2201c76a8e78ed2d9ae753807a6cb8ad510beca4e

data.tar.gz.sig

@@ -1,2 +1 @@
-`��O�
-�֘��	�dT	ܦ%��ͱW�O0�Q
m���q��bbVY`��}���b��`����悔�~�g��n>A5�]�p�K)��;�������
+Sk���q�8~t��6c�i��e�;�tE���m�H��Z��T`�IZ�V�����s�`����m����.��r��L��g��m~�+mE��@"��pC�qD

data/lib/{ragni-cas.rb → Mr.CAS.rb}

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 
 ##
-# ragni-cas
-# A very simple CAS engine with encapsuled graph
+# Mr.CAS
+# A minmalistic CAS engine with encapsuled graph
 # representation. This will make impossible to
 # perform complex high level simplifications, but
 # it is powerful enough to define simple algorithm
@@ -58,6 +58,7 @@ end
 
 %w|operators/op.rb operators/bary-op.rb operators/nary-op.rb
    numbers/constants.rb numbers/variables.rb numbers/functions.rb
+   functions/fnc-sum.rb functions/fnc-prod.rb
    functions/fnc-base.rb functions/fnc-trig.rb functions/fnc-trsc.rb
    functions/fnc-conditions.rb functions/fnc-box-conditions.rb functions/fnc-piecewise.rb
    overloading/fixnum.rb overloading/float.rb

data/lib/Mr.CAS/auto-diff.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+
+module CAS
+  module AutoDiff
+    class DualNumber
+      include Math
+      attr_reader :x, :y
+
+      def initialize(x, y)
+        @x, @y = x, y
+      end
+
+      def +(v)
+        DualNumber.new @x + v.x, @y + v.y
+      end
+
+      def -(v)
+        DualNumber.new @x - v.x, @y - v.y
+      end
+
+      def *(v)
+        DualNumber.new @x * v.x, @y * v.x + @x * v.y
+      end
+
+      def /(v)
+        DualNumber.new @x / v.x, (@y * v.x - @x * v.y) / (v.x ** 2)
+      end
+
+      def -@
+        DualNumber.new -@x, -@y
+      end
+
+      def **(v)
+        t = (v.y == 0 ? 0 : @x * log(@x) * v.y)
+        DualNumber.new @x ** v.x, (@x ** (v.x - 1)) * (v.x * @y + t)
+      end
+
+      def abs
+        return DualNumber.new(0, 0) if @x == 0
+        DualNumber.new @x.abs, @y * (@x <=> 0)
+      end
+
+      def to_s;    self.inspect;  end
+      def inspect; "<#{@x},#{@y}>"; end
+      def real; @x; end
+      def diff; @y; end
+    end # DualNumbers
+
+    def self.const(x)
+      DualNumber.new x, 0
+    end
+
+    def self.vars(x)
+      DualNumber.new x, 1
+    end
+
+    Zero = self.const 0
+    One  = self.const 1
+    Two  = self.const 2
+    E    = self.const Math::E
+    Pi   = self.const Math::PI
+  end
+
+
+  {
+    # Terminal nodes
+    CAS::Variable => Proc.new { |fd| CAS::AutoDiff.vars (fd[CAS::Variable[@name]] || fd[@name]) },
+    CAS::Constant => Proc.new { |_fd| CAS::AutoDiff.const @x },
+    CAS::Function => Proc.new { |_fd| raise RuntimeError, "Impossible for implicit functions" },
+
+    # Base functions
+    CAS::Sum    => Proc.new { |fd| @x.auto_diff(fd) + @y.auto_diff(fd) },
+    CAS::Diff   => Proc.new { |fd| @x.auto_diff(fd) - @y.auto_diff(fd) },
+    CAS::Prod   => Proc.new { |fd| @x.auto_diff(fd) * @y.auto_diff(fd) },
+    CAS::Pow    => Proc.new { |fd| @x.auto_diff(fd) ** @y.auto_diff(fd) },
+    CAS::Div    => Proc.new { |fd| @x.auto_diff(fd) / @y.auto_diff(fd) },
+    CAS::Sqrt   => Proc.new { |fd| @x.auto_diff(fd) ** (CAS::AutoDiff::One / CAS::AutoDiff::Two) },
+    CAS::Invert => Proc.new { |fd| -@x.auto_diff(fd) },
+    CAS::Abs    => Proc.new { |fd| @x.auto_diff(fd).abs },
+
+    # Trigonometric functions
+    CAS::Sin    => Proc.new { |fd|
+      u = @x.auto_diff(fd)
+      CAS::AutoDiff::DualNumber.new Math.sin(u.x), Math.cos(u.x) * u.y
+    },
+    CAS::Asin   => Proc.new { |fd|
+      u = @x.auto_diff(fd)
+      CAS::AutoDiff::DualNumber.new Math.asin(u.x), -(Math.sin(u.x) * u.y)
+    },
+    CAS::Cos    => Proc.new { |fd|
+      u = @x.auto_diff(fd)
+      CAS::AutoDiff::DualNumber.new Math.cos(u.x), -(Math.sin(u.x) * u.y)
+    },
+    CAS::Acos   => Proc.new { |fd|
+      u = @x.auto_diff(fd)
+      CAS::AutoDiff::DualNumber.new Math.acos(u.x), -u.y / Math.sqrt(1 + u.x ** 2)
+    },
+    CAS::Tan    => Proc.new { |fd|
+      u = @x.auto_diff(fd)
+      CAS::AutoDiff::DualNumber.new Math.tan(u.x),  u.y / (Math.cos(u.x) ** 2)
+    },
+    CAS::Atan   => Proc.new { |fd|
+      u = @x.auto_diff(fd)
+      CAS::AutoDiff::DualNumber.new Math.atan(u.x), u.y / (1 + u.x ** 2)
+    },
+
+    # Trascendent functions
+    CAS::Exp    => Proc.new { |fd| CAS::AutoDiff::E ** @x.auto_diff(fd) },
+    CAS::Ln     => Proc.new { |fd|
+      u = @x.auto_diff(fd)
+      CAS::AutoDiff::DualNumber.new Math.log(u.x), u.y / u.x
+    },
+
+    # Piecewise
+    CAS::Piecewise => Proc.new { |_fd| raise RuntimeError, "Not implemented auto_diff for Piecewise" },
+    CAS::Max       => Proc.new { |fd|
+      a = @x.auto_diff(fd)
+      b = @y.auto_diff(fd)
+      (a.x >= b.x ? a : b)
+    },
+    CAS::Min       => Proc.new { |fd|
+      a = @x.auto_diff(fd)
+      b = @y.auto_diff(fd)
+      (a.x >= b.x ? a : b)
+    }
+  }.each do |cls, blk|
+    cls.send(:define_method, "auto_diff", &blk)
+  end
+end

data/lib/Mr.CAS/c-opt.rb

@@ -0,0 +1,225 @@
+#!/usr/bin/env ruby
+
+#   ___   ___ _           _
+#  / __| | _ \ |_  _ __ _(_)_ _
+# | (__  |  _/ | || / _` | | ' \
+#  \___| |_| |_|\_,_\__, |_|_||_|
+#                   |___/
+
+require 'pry'
+
+module CAS
+  class CLib < Hash
+    def self.create(name, &blk)
+      a = CLib.new(name)
+      a.instance_eval(&blk)
+      return a
+    end
+
+    def initialize(name)
+      raise ArgumentError, "Name for the library undefined" unless name.is_a? String
+      @name            = name
+      @define          = {}
+      @include         = {}
+      @include[:std]   = []
+      @include[:local] = []
+      @type            = "double"
+
+      # Default definitions
+      # self.define "M_PI", Math::PI
+      # self.define "M_INFINITY","HUGE_VAL"
+      # self.define "M_E", Math::E
+      # self.define "M_EPSILON", 1E-16
+
+      # Default inclusions
+      self.include "math.h"
+    end
+
+    def as_double;   @type = "double";   end
+    def as_float;    @type = "float";    end
+    def as_int;      @type = "int";      end
+    def as_long_int; @type = "long int"; end
+
+    def define(k, v)
+      raise ArgumentError, "k must be a String, received a #{k.class}" unless k.is_a? String
+      @define[k] = v.to_s
+      @define
+    end
+
+    def undefine(k)
+      @define.delete k
+      return @define
+    end
+
+    def include_type(type, lib)
+      raise ArgumentError, "type must be a Symbol (:std, :local), received #{type}" unless [:std, :local].include? type
+      raise ArgumentError, "lib must be a String, received a #{lib.class}" unless lib.is_a? String
+      @include[type] << lib unless @include[type].include? lib
+    end
+    def include(lib); self.include_type(:std, lib); end
+    def include_local(lib); self.include_type(:local, lib); end
+
+    def implements_as(name, op); self[name] = op; end
+
+    def header
+      <<-TO_HEADER
+// Header file for library: #{@name}.c
+
+#ifndef #{@name}_H
+#define #{@name}_H
+
+// Standard Libraries
+#{ @include[:std].map { |e| "#include <#{e}>" }.join("\n") }
+
+// Local Libraries
+#{ @include[:local].map { |e| "#include \"#{e}\"" }.join("\n") }
+
+// Definitions
+#{ @define.map { |k, v| "#define #{k} #{v}" }.join("\n") }
+
+// Functions
+#{
+  self.keys.map do |fname|
+    "#{@type} #{fname}(#{ self[fname].args.map { |x| "#{@type} #{x.name}" }.join(", ")});"
+  end.join("\n")
+}
+
+#endif // #{@name}_H
+      TO_HEADER
+    end
+
+    def source
+      functions = []
+
+      self.each do |fname, op|
+        c_op = op.to_c.sort_by { |_k, c| c[:id] }
+        nf = <<-NEWFUNCTION
+#{@type} #{fname}(#{ op.args.map { |x| "#{@type} #{x.name}" }.join(", ")}) {
+#{c_op.map { |e| "  double #{e[1][:var]} = #{e[1][:def]};"}.join("\n")}
+
+  return #{c_op[-1][1][:var]};
+}
+NEWFUNCTION
+        functions << nf
+      end
+
+      <<-TO_SOURCE
+// Source file for library: #{@name}.c
+
+#include "#{@name}.h"
+
+#{functions.join("\n")}
+// end of #{@name}.c
+      TO_SOURCE
+    end
+  end
+
+  {
+    # Terminal nodes
+    CAS::Constant              => Proc.new { |_v| "#{@x}" },
+    CAS::Variable              => Proc.new { |_v| "#{@name}" },
+    CAS::PI_CONSTANT           => Proc.new { |_v| "M_PI" },
+    CAS::INFINITY_CONSTANT     => Proc.new { |_v| "M_INFINITY" },
+    CAS::NEG_INFINITY_CONSTANT => Proc.new { |_v| "(-M_INFINITY)" },
+    CAS::E_CONSTANT            => Proc.new { |_v| "M_E" }
+  }.each do |cls, blk|
+    cls.send(:define_method, "__to_c", &blk)
+  end.each do |cls, _blk|
+    cls.send(:define_method, "to_c", &Proc.new do
+      v = {}; self.__to_c(v); v
+    end)
+  end
+
+  {
+    # Base functions
+    CAS::Sum    => Proc.new { |v| "(#{@x.map { |e| e.__to_c(v) }.join(" + ")})" },
+    CAS::Diff   => Proc.new { |v| "(#{@x.__to_c(v)} - #{@y.__to_c(v)})" },
+    CAS::Prod   => Proc.new { |v| "(#{@x.map { |e| e.__to_c(v) }.join(" + ")})" },
+    CAS::Pow    => Proc.new { |v| "pow(#{@x.__to_c(v)}, #{@y.__to_c(v)})" },
+    CAS::Div    => Proc.new { |v| "(#{@x.__to_c(v)}) / (#{@y.__to_c(v)} + M_EPSILON)" },
+    CAS::Sqrt   => Proc.new { |v| "sqrt(#{@x.__to_c(v)})" },
+    CAS::Invert => Proc.new { |v| "(-#{@x.__to_c(v)})" },
+    CAS::Abs    => Proc.new { |v| "fabs(#{@x.__to_c(v)})" },
+
+    # Trigonometric functions
+    CAS::Sin    => Proc.new { |v| "sin(#{@x.__to_c(v)})" },
+    CAS::Asin   => Proc.new { |v| "asin(#{@x.__to_c(v)})" },
+    CAS::Cos    => Proc.new { |v| "cos(#{@x.__to_c(v)})" },
+    CAS::Acos   => Proc.new { |v| "acos(#{@x.__to_c(v)})" },
+    CAS::Tan    => Proc.new { |v| "tan(#{@x.__to_c(v)})" },
+    CAS::Atan   => Proc.new { |v| "atan(#{@x.__to_c(v)})" },
+
+    # Trascendent functions
+    CAS::Exp    => Proc.new { |v| "exp(#{@x.__to_c(v)})" },
+    CAS::Ln     => Proc.new { |v| "log(#{@x.__to_c(v)})" },
+
+    # # Box Conditions
+    # CAS::BoxConditionOpen => Proc.new {
+    #   ["double __t_#{x.object_id} = #{x.__to_c(v)};",
+    #    "(__t_#{x.object_id} > #{lower.latex} && __t_#{x.object_id} < #{upper.latex})"]
+    # },
+    # CAS::BoxConditionUpperClosed => Proc.new {
+    #   ["double __t_#{x.object_id} = #{x.__to_c(v)};",
+    #    "(__t_#{x.object_id} > #{lower.latex} && __t_#{x.object_id} <= #{upper.latex})"]
+    # },
+    # CAS::BoxConditionLowerClosed => Proc.new {
+    #   ["double __t_#{x.object_id} = #{x.__to_c(v)};",
+    #    "(__t_#{x.object_id} >= #{lower.latex} && __t_#{x.object_id} < #{upper.latex})"]
+    # },
+    # CAS::BoxConditionClosed => Proc.new {
+    #   ["double __t_#{x.object_id} = #{x.__to_c(v)};",
+    #    "(__t_#{x.object_id} >= #{lower.latex} && __t_#{x.object_id} <= #{upper.latex})"]
+    # },
+
+    # Conditions
+    # CAS::Equal        => Proc.new { "(#{x.__to_c(v)} == #{y.__to_c(v)})" },
+    # CAS::Smaller      => Proc.new { "(#{x.__to_c(v)} < #{y.__to_c(v)})" },
+    # CAS::Greater      => Proc.new { "(#{x.__to_c(v)} > #{y.__to_c(v)})" },
+    # CAS::SmallerEqual => Proc.new { "(#{x.__to_c(v)} <= #{y.__to_c(v)})" },
+    # CAS::GreaterEqual => Proc.new { "(#{x.__to_c(v)} >= #{y.__to_c(v)})" },
+    # TODO there is no sense in exporting conditions in C...
+
+    # Piecewise
+    # CAS::Piecewise => Proc.new { raise CASError, "Not implemented yet" },
+    # CAS::Max       => Proc.new { raise CASError, "Not implemented yet" },
+    # CAS::Min       => Proc.new { raise CASError, "Not implemented yet" }
+    CAS::Function    => Proc.new { |v| "#{@c_name}(#{@x.map {|e| e.__to_c(v)}.join(", ")})" }
+  }.each do |cls, blk|
+    cls.send(:define_method, "__to_c_impl", &blk)
+  end.each do |cls, _blk|
+    cls.send(:define_method, "__to_c", &Proc.new do |v|
+      sym = self.to_s.to_sym
+      v[sym] = {
+        :def => "#{self.__to_c_impl(v)}",
+        :var => "__t_#{v.keys.size}",
+        :id => v.keys.size
+      } unless v[sym] # Pleas note that the order here is foundamental!
+      v[sym][:var]
+    end)
+  end.each do |cls, _blk|
+    cls.send(:define_method, "to_c", &Proc.new do
+      v = {}; self.__to_c(v); v
+    end)
+  end
+
+  class Op
+    def to_c_lib(name)
+      CAS::Help.assert(name, String)
+      [CAS::C_PLUGIN.write_header(self, name), CAS::C_PLUGIN.write_source(self, name)]
+    end
+  end
+
+  class Function
+    def c_name=(s)
+      CAS::Help.assert_name s
+      @c_name = s
+    end
+
+    def Function.new(name, *xs)
+      a = super
+      a.c_name = name
+      return a
+    end
+  end
+  Function.list.each do |k, v| v.c_name = k; end
+end

data/lib/Mr.CAS/c.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+
+#   ___   ___ _           _
+#  / __| | _ \ |_  _ __ _(_)_ _
+# | (__  |  _/ | || / _` | | ' \
+#  \___| |_| |_|\_,_\__, |_|_||_|
+#                   |___/
+
+module CAS
+  module C_PLUGIN
+    C_STD_LIBRARIES = [
+      "math.h"
+    ]
+
+    C_LOCAL_LIBRARIES = [ ]
+
+    C_DEFINES = {
+      "M_PI"       => Math::PI.to_s,
+      "M_INFINITY" => "HUGE_VAL",
+      "M_E"        => Math::E.to_s,
+      "M_EPSILON"  => (1E-16).to_s
+    }
+
+    def self.write_header(op, name)
+      <<-TO_HEADER
+#ifndef #{name}_HEADER
+#define #{name}_HEADER
+
+// Standard Libraries
+#{ CAS::C_PLUGIN::C_STD_LIBRARIES.map { |e| "#include <#{e}>" }.join("\n") }
+
+// Local Libraries
+#{ CAS::C_PLUGIN::C_LOCAL_LIBRARIES.map { |e| "#include <#{e}>" }.join("\n") }
+
+// Definitions
+#{ CAS::C_PLUGIN::C_DEFINES.map { |k, v| "#define #{k} #{v}" }.join("\n") }
+
+// Function
+double #{name}(#{ op.args.map { |x| "double #{x.name}"}.join(", ") });
+
+#endif // #{name}_HEADER
+      TO_HEADER
+    end
+
+    def self.write_source(op, name)
+      <<-TO_SOURCE
+#include "#{name}.h"
+
+double #{name}(#{ op.args.map { |x| "double #{x.name}"}.join(", ") }) {
+  return #{op.to_c};
+}
+      TO_SOURCE
+    end
+  end
+
+  {
+    # Terminal nodes
+    CAS::Constant              => Proc.new { "#{x}" },
+    CAS::Variable              => Proc.new { "#{name}" },
+    CAS::PI_CONSTANT           => Proc.new { "M_PI" },
+    CAS::INFINITY_CONSTANT     => Proc.new { "M_INFINITY" },
+    CAS::NEG_INFINITY_CONSTANT => Proc.new { "(-M_INFINITY)" },
+    CAS::E_CONSTANT            => Proc.new { "M_E" },
+    # Base functions
+    CAS::Sum    => Proc.new { "(#{x.to_c} + #{y.to_c})" },
+    CAS::Diff   => Proc.new { "(#{x.to_c} - #{y.to_c})" },
+    CAS::Prod   => Proc.new { "(#{x.to_c} * #{y.to_c})" },
+    CAS::Pow    => Proc.new { "pow(#{x.to_c}, #{y.to_c})" },
+    CAS::Div    => Proc.new { "(#{x.to_c}) / (#{y.to_c} + )" },
+    CAS::Sqrt   => Proc.new { "sqrt(#{x.to_c})" },
+    CAS::Invert => Proc.new { "(-#{x.to_c})" },
+    CAS::Abs    => Proc.new { "fabs(#{x.to_c})" },
+
+    # Trigonometric functions
+    CAS::Sin    => Proc.new { "sin(#{x.to_c})" },
+    CAS::Asin   => Proc.new { "asin(#{x.to_c})" },
+    CAS::Cos    => Proc.new { "cos(#{x.to_c})" },
+    CAS::Acos   => Proc.new { "acos(#{x.to_c})" },
+    CAS::Tan    => Proc.new { "tan(#{x.to_c})" },
+    CAS::Atan   => Proc.new { "atan(#{x.to_c})" },
+
+    # Trascendent functions
+    CAS::Exp    => Proc.new { "exp(#{x.to_c})" },
+    CAS::Ln     => Proc.new { "log(#{x.to_c})" },
+
+    # Box Conditions
+    CAS::BoxConditionOpen => Proc.new {
+      ["double __t_#{x.object_id} = #{x.to_c};",
+       "(__t_#{x.object_id} > #{lower.latex} && __t_#{x.object_id} < #{upper.latex})"]
+    },
+    CAS::BoxConditionUpperClosed => Proc.new {
+      ["double __t_#{x.object_id} = #{x.to_c};",
+       "(__t_#{x.object_id} > #{lower.latex} && __t_#{x.object_id} <= #{upper.latex})"]
+    },
+    CAS::BoxConditionLowerClosed => Proc.new {
+      ["double __t_#{x.object_id} = #{x.to_c};",
+       "(__t_#{x.object_id} >= #{lower.latex} && __t_#{x.object_id} < #{upper.latex})"]
+    },
+    CAS::BoxConditionClosed => Proc.new {
+      ["double __t_#{x.object_id} = #{x.to_c};",
+       "(__t_#{x.object_id} >= #{lower.latex} && __t_#{x.object_id} <= #{upper.latex})"]
+    },
+
+    # Conditions
+    CAS::Equal        => Proc.new { "(#{x.to_c} == #{y.to_c})" },
+    CAS::Smaller      => Proc.new { "(#{x.to_c} < #{y.to_c})" },
+    CAS::Greater      => Proc.new { "(#{x.to_c} > #{y.to_c})" },
+    CAS::SmallerEqual => Proc.new { "(#{x.to_c} <= #{y.to_c})" },
+    CAS::GreaterEqual => Proc.new { "(#{x.to_c} >= #{y.to_c})" },
+
+    # Piecewise
+    CAS::Piecewise => Proc.new { raise CASError, "Not implemented yet" },
+    CAS::Max       => Proc.new { raise CASError, "Not implemented yet" },
+    CAS::Min       => Proc.new { raise CASError, "Not implemented yet" }
+  }.each do |cls, blk|
+    cls.send(:define_method, "to_c", &blk)
+  end
+
+  class Op
+    def to_c_lib(name)
+      CAS::Help.assert(name, String)
+      [CAS::C_PLUGIN.write_header(self, name), CAS::C_PLUGIN.write_source(self, name)]
+    end
+  end
+
+end