ragni-cas 0.1.7 → 0.1.8

data/lib/fnc-trig.rb

@@ -14,14 +14,19 @@ module CAS
       end
     end
 
+    # Same as `CAS::Op`
     def call(f)
+      CAS::Help.assert(f, Hash)
+
       Math::sin @x.call(f)
     end
 
+    # Same as `CAS::Op`
     def to_s
       "sin(#{@x})"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero
@@ -36,6 +41,7 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def to_code
       "Math::sin(#{@x.to_code})"
     end
@@ -58,14 +64,19 @@ module CAS
       end
     end
 
+    # Same as `CAS::Op`
     def call(f)
+      CAS::Help.assert(f, Hash)
+
       Math::acos @x.call(f)
     end
 
+    # Same as `CAS::Op`
     def to_s
       "asin(#{@x})"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero
@@ -80,6 +91,7 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def to_code
       "Math::asin(#{@x.to_code})"
     end
@@ -102,14 +114,19 @@ module CAS
       end
     end
 
+    # Same as `CAS::Op`
     def call(f)
-      Math::cos self.x.call(f)
+      CAS::Help.assert(f, Hash)
+
+      Math::cos @x.call(f)
     end
 
+    # Same as `CAS::Op`
     def to_s
-      "cos(#{self.x})"
+      "cos(#{@x})"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero
@@ -124,6 +141,7 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def to_code
       "Math::cos(#{@x.to_code})"
     end
@@ -146,14 +164,19 @@ module CAS
       end
     end
 
+    # Same as `CAS::Op`
     def call(f)
+      CAS::Help.assert(f, Hash)
 
+      return Math::acos @x
     end
 
+    # Same as `CAS::Op`
     def to_s
-      "acos(#{self.x})"
+      "acos(#{@x})"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero
@@ -168,6 +191,7 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def to_code
       "Math::acos(#{@x.to_code})"
     end
@@ -190,14 +214,19 @@ module CAS
       end
     end
 
+    # Same as `CAS::Op`
     def call(f)
-      Math::tan self.x.call
+      CAS::Help.assert(f, Hash)
+
+      Math::tan @x.call
     end
 
+    # Same as `CAS::Op`
     def to_s
-      "tan(#{self.x})"
+      "tan(#{@x})"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero
@@ -212,6 +241,7 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def to_code
       "Math::tan(#{@x.to_code})"
     end
@@ -234,14 +264,19 @@ module CAS
       end
     end
 
-    def call
-      Math::atan self.x.call
+    # Same as `CAS::Op`
+    def call(f)
+      CAS::Help.assert(f, Hash)
+
+      Math::atan @x.call
     end
 
+    # Same as `CAS::Op`
     def to_s
-      "atan(#{self.x})"
+      "atan(#{@x})"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero
@@ -259,6 +294,7 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def to_code
       "Math::atan(#{@x.to_code})"
     end

data/lib/fnc-trsc.rb

@@ -15,14 +15,19 @@ module CAS
       end
     end
 
+    # Same as `CAS::Op`
     def call(f)
+      CAS::Help.assert(f, Hash)
+
       Math::exp @x.call(f)
     end
 
+    # Same as `CAS::Op`
     def to_s
       "exp(#{@x})"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero
@@ -40,6 +45,7 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def to_code
       "Math::exp(#{@x.to_code})"
     end
@@ -63,16 +69,21 @@ module CAS
       end
     end
 
+    # Same as `CAS::Op`
     def call(f)
       # I'm leaving to Math the honor
       # of handling negative values...
+      CAS::Help.assert(f, Hash)
+
       Math::log @x.call(f)
     end
 
+    # Same as `CAS::Op`
     def to_s
       "log(#{@x})"
     end
 
+    # Same as `CAS::Op`
     def simplify
       super
       if @x == CAS::Zero
@@ -90,6 +101,7 @@ module CAS
       return self
     end
 
+    # Same as `CAS::Op`
     def to_code
       "Math::log(#{@x.to_code})"
     end

data/lib/numbers.rb

@@ -10,16 +10,29 @@ module CAS
       @x = x
     end
 
-    def diff(v); CAS::Zero; end
+    # The derivative of a constant is always zero
+    def diff(v)
+      CAS::Zero
+    end
 
-    def call(f); @x; end
+    # Same as `CAS::Op`
+    def call(f)
+      @x
+    end
 
-    def depend?(v); false; end
+    # Same as `CAS::Op`
+    def depend?(v)
+      false
+    end
 
-    def to_s; "#{@x}"; end
+    # Same as `CAS::Op`
+    def to_s
+      "#{@x}"
+    end
 
+    # Same as `CAS::Op`
     def simplify
-      case x
+      case @x
       when 0
         return CAS::Zero
       when 1
@@ -35,31 +48,46 @@ module CAS
       end
     end
 
+    # Same as `CAS::Op`
     def args
       []
     end
 
+    # Same as `CAS::Op`
     def ==(op)
-      @x == op.x
+      CAS::Help.assert(op, CAS::Op)
+
+      if op.is_a? CAS::Constant
+        return @x == op.x
+      else
+        return false
+      end
     end
 
+    # Same as `CAS::Op`
     def inspect
       "Const(#{@x})"
     end
 
+    # Same as `CAS::Op`
     def dot_graph(node)
       "#{self.class.to_s.gsub("CAS::", "")}_#{self.object_id};"
     end
   end
 
-  def self.const(f)
-    CAS::Constant.new f
-  end
+  # Allows to define a series of new constants.
+  #
+  # ``` ruby
+  # a, b = CAS::const 1.0, 100
+  # ```
+  #
+  # <- `Array` of Numeric
+  # -> `Array` of `CAS::Contant`
   def self.const(*val)
     (return CAS::Constant.new(val[0])) if val.size == 1
     ret = []
     val.each do |n|
-      ret << CAS::Variable.new(n)
+      ret << CAS::Constant.new(n)
     end
     return ret
   end
@@ -69,59 +97,107 @@ module CAS
   #  \ V / _` | '_| / _` | '_ \ / -_)
   #   \_/\__,_|_| |_\__,_|_.__/_\___|
   class Variable < CAS::Op
+    # Contains all define variable, in an hash. Variables are
+    # accessible through variable name.
     @@vars = {}
-    @@counter = 0
 
-    def self.list; @@vars; end
-    def self.size; @@counter; end
+    # Returns the `Hash` that contains all the variable
+    #
+    # -> `Hash`
+    def self.list
+      @@vars
+    end
+
+    # Return the number of variable defined
+    #
+    # -> `Fixnum`
+    def self.size
+      @@vars.keys.size
+    end
+
+    # Returns `true` if a variable already exists
+    #
+    # <- `Object` that represent the variable
+    # -> `TrueClass` if variable exists, `FalseClass` if not
     def self.exist?(name)
       @@vars.keys.include? name
     end
 
+    attr_reader :name
+    # Variable is a container for an atomic simbol that becomes a number
+    # when `CAS::Op#call` method is used.
+    #
+    # <- `Object` that is a identifier for the variable
+    # -> `CAS::Variable` instance
     def initialize(name)
       raise CASError, "Variable #{name} already exists" if CAS::Variable.exist? name
       @name = name
       @@vars[@name] = self
-      @@counter = @@counter + 1
     end
 
+    # Returns the derivative of a variable
+    #
+    # ```
+    #  dx      dx
+    #  -- = 1; -- = 0
+    #  dx      dy
+    # ```
+    #
+    # <- `CAS::Op` for the derivative denominator
+    # -> `CAS::Constant`, 0 if not depended, 1 if dependent
     def diff(v)
       CAS::One
     end
 
+    # Same as `CAS::Op`
     def depend?(v)
       self == v
     end
 
+    # Same as `CAS::Op`
     def ==(op)
-      self.inspect == op.inspect
+      CAS::Help.assert(op, CAS::Op)
+      if op.is_a? CAS::Variable
+        return self.inspect == op.inspect
+      else
+        false
+      end
     end
 
+    # Same as `CAS::Op`
     def call(f)
+      CAS::Help.assert(f, Hash)
+
       return f[self] if f[self]
       return f[@name] if f[@name]
     end
 
+    # Same as `CAS::Op`
     def to_s
       "#{@name}"
     end
 
+    # Same as `CAS::Op`
     def to_code
       "#{@name}"
     end
 
+    # Same as `CAS::Op`
     def args
       [self]
     end
 
+    # Same as `CAS::Op`
     def inspect
       "Var(#{@name})"
     end
 
+    # Same as `CAS::Op`
     def simplify
       self
     end
 
+    # Same as `CAS::Op`
     def dot_graph(node)
       "#{@name};"
     end