Mr.CAS 0.2.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 62a33629bd1fe8154be4964e99dccd87cd7c060c
+  data.tar.gz: 6842feded0a74f326b81a6d5513527df10ab3d96
+SHA512:
+  metadata.gz: a3d0c46c099e1bb90d2d5a1087b286d079712777e92ed1d5d9c7a1ab7947fac0f98a82414128eadd92d76b1ead31b3fe704b8f0048ed1686e3ef08220a5614cf
+  data.tar.gz: 07ccfad775f154afff75a097b9c0e0b9233ac023452176dbbbc429417da3fb810c02796ab52d601366d672e7025c9cf8ed4fa95ce2527c4cb878e0816887c39b

checksums.yaml.gz.sig

@@ -0,0 +1 @@
+�

data.tar.gz.sig

@@ -0,0 +1,2 @@
+Q��A}E
�Vv9�~���Z�V�f+�'}��+Jt(#��&�F��=��W��tH*Z���;(��q��n��	�$_�	OD�u��G��ڹj��ݓÍ��ϫ|"\������Lh�Q�/�Đ����1쎇�1[Y�p��m+�I��f�,l]��i�+�q2�Rp�ī�aп��"����{M���DPn��(��}a������BC���*�ʫ���[�"
+�#9�	?�����s	�tIn���ErUD�

data/lib/Mr.CAS.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+##
+# 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
+# in a symbolic way.
+#
+# Mathematically, this is an implementation of the
+# forward chain rule for automatic differentiaition.
+# Each function is a container of function and the
+# derivation is in the form:
+#
+# ```
+#   d(f(g(x))
+#   --------- = g'(x) * f'(g(x))
+#      dx
+# ```
+#
+# Author:: Matteo Ragni (mailto:info@ragni.me)
+# Copyright:: Copyright (c) 2016 Matteo Ragni
+# License:: Distributed under MIT license terms
+module CAS
+
+  # Support functions are in this separate Helper class
+  module Help
+    # Check input `obj.class` against a `type` class
+    # raises an `ArgumentError` if check fails
+    #
+    #  * **argument**: object to be cecked
+    #  * **argument**: type to be checked against
+    #  * **returns**: `TrueClass`, or raises an `ArgumentError`
+    def self.assert(obj, type)
+      raise ArgumentError, "required #{type}, received #{obj.class}" unless obj.is_a? type
+      return true
+    end
+
+    # Check if input object is feasible to be a name of a `CAS::Variable` or a `CAS::Function`
+    # raise an `ArgumentError` if the check fails. To be feasible the object must be a `String`
+    # instance or `Symbol` instance
+    #
+    #  * **argument**: object to be checked
+    #  * **returns**: `TrueClass` or raises `ArgumentError`
+    def self.assert_name(obj)
+      raise ArgumentError, "Input name must be a String/Symbol" unless [Symbol, String].include? obj.class
+      return true
+    end
+  end
+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
+   version.rb|.each do |r|
+  require File.expand_path(r, File.dirname(__FILE__))
+end
+
+module CAS
+  CAS::NumericToConst[-Math::PI] = (-CAS::Pi)
+  CAS::NumericToConst[-Math::E] = (-CAS::E)
+  CAS::NumericToConst[(-1.0/0.0)]  = (CAS::NegInfinity)
+end

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