keisan 0.5.0 → 0.6.0

data/lib/keisan/ast/parent.rb

@@ -6,20 +6,20 @@ module Keisan
       def initialize(children = [])
         children = Array.wrap(children).map(&:to_node)
         unless children.is_a?(Array) && children.all? {|children| children.is_a?(Node)}
-          raise Keisan::Exceptions::InternalError.new
+          raise Exceptions::InternalError.new
         end
         @children = children
       end
 
       def unbound_variables(context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
         children.inject(Set.new) do |vars, child|
           vars | child.unbound_variables(context)
         end
       end
 
       def unbound_functions(context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
         children.inject(Set.new) do |fns, child|
           fns | child.unbound_functions(context)
         end
@@ -45,7 +45,7 @@ module Keisan
       end
 
       def evaluate(context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
         @children = children.map {|child| child.evaluate(context)}
         self
       end

data/lib/keisan/ast/plus.rb

@@ -39,25 +39,25 @@ module Keisan
         # Commutative, so pull in operands of any `Plus` operators
         @children = children.inject([]) do |new_children, cur_child|
           case cur_child
-          when AST::Plus
+          when Plus
             new_children + cur_child.children
           else
             new_children << cur_child
           end
         end
 
-        if children.all? {|child| child.is_a?(Keisan::AST::String)}
-          return Keisan::AST::String.new(children.inject("") do |result, child|
+        if children.all? {|child| child.is_a?(String)}
+          return String.new(children.inject("") do |result, child|
             result + child.value
           end)
-        elsif children.all? {|child| child.is_a?(Keisan::AST::List)}
-          return Keisan::AST::List.new(children.inject([]) do |result, child|
+        elsif children.all? {|child| child.is_a?(List)}
+          return List.new(children.inject([]) do |result, child|
             result + child.value
           end)
         end
 
-        constants, non_constants = *children.partition {|child| child.is_a?(AST::Number)}
-        constant = constants.inject(AST::Number.new(0), &:+).simplify(context)
+        constants, non_constants = *children.partition {|child| child.is_a?(Number)}
+        constant = constants.inject(Number.new(0), &:+).simplify(context)
 
         if non_constants.empty?
           constant
@@ -72,15 +72,15 @@ module Keisan
       end
 
       def differentiate(variable, context = nil)
-        AST::Plus.new(children.map {|child| child.differentiate(variable, context)}).simplify(context)
+        Plus.new(children.map {|child| child.differentiate(variable, context)}).simplify(context)
       end
 
       private
 
       def convert_minus_to_plus!
         @parsing_operators.each.with_index do |parsing_operator, index|
-          if parsing_operator.is_a?(Keisan::Parsing::Minus)
-            @children[index+1] = Keisan::AST::UnaryMinus.new(@children[index+1])
+          if parsing_operator.is_a?(Parsing::Minus)
+            @children[index+1] = UnaryMinus.new(@children[index+1])
           end
         end
       end

data/lib/keisan/ast/string.rb

@@ -13,10 +13,10 @@ module Keisan
 
       def +(other)
         case other
-        when AST::String
-          AST::String.new(value + other.value)
+        when String
+          String.new(value + other.value)
         else
-          raise Keisan::Exceptions::TypeError.new("#{other}'s type is invalid, #{other.class}")
+          raise Exceptions::TypeError.new("#{other}'s type is invalid, #{other.class}")
         end
       end
 

data/lib/keisan/ast/times.rb

@@ -26,17 +26,17 @@ module Keisan
         # Commutative, so pull in operands of any `Times` operators
         @children = children.inject([]) do |new_children, cur_child|
           case cur_child
-          when AST::Times
+          when Times
             new_children + cur_child.children
           else
             new_children << cur_child
           end
         end
 
-        constants, non_constants = *children.partition {|child| child.is_a?(AST::Number)}
-        constant = constants.inject(AST::Number.new(1), &:*).simplify(context)
+        constants, non_constants = *children.partition {|child| child.is_a?(Number)}
+        constant = constants.inject(Number.new(1), &:*).simplify(context)
 
-        return Keisan::AST::Number.new(0) if constant.value(context) == 0
+        return Number.new(0) if constant.value(context) == 0
 
         if non_constants.empty?
           constant
@@ -52,9 +52,9 @@ module Keisan
 
       def differentiate(variable, context = nil)
         # Product rule
-        AST::Plus.new(
+        Plus.new(
           children.map.with_index do |child,i|
-            AST::Times.new(
+            Times.new(
               children.slice(0,i) + [child.differentiate(variable, context)] + children.slice(i+1,children.size)
             )
           end
@@ -65,8 +65,8 @@ module Keisan
 
       def convert_divide_to_inverse!
         @parsing_operators.each.with_index do |parsing_operator, index|
-          if parsing_operator.is_a?(Keisan::Parsing::Divide)
-            @children[index+1] = Keisan::AST::UnaryInverse.new(@children[index+1])
+          if parsing_operator.is_a?(Parsing::Divide)
+            @children[index+1] = UnaryInverse.new(@children[index+1])
           end
         end
       end

data/lib/keisan/ast/unary_identity.rb

@@ -2,7 +2,7 @@ module Keisan
   module AST
     class UnaryIdentity < UnaryOperator
       def value(context = nil)
-        return child.value(context)
+        child.value(context)
       end
 
       def evaluate(context = nil)

data/lib/keisan/ast/unary_inverse.rb

@@ -18,8 +18,8 @@ module Keisan
 
         @children = [child.simplify(context)]
         case child
-        when AST::Number
-          AST::Number.new(Rational(1,child.value(context))).simplify(context)
+        when Number
+          Number.new(Rational(1,child.value(context))).simplify(context)
         else
           (child ** -1).simplify(context)
         end
@@ -27,12 +27,12 @@ module Keisan
 
       def differentiate(variable, context = nil)
         context ||= Context.new
-        AST::Times.new(
+        Times.new(
           [
-            AST::UnaryMinus.new(child.differentiate(variable, context)),
-            AST::UnaryInverse.new(
-              AST::Exponent.new([
-                child.deep_dup, AST::Number.new(2)
+            UnaryMinus.new(child.differentiate(variable, context)),
+            UnaryInverse.new(
+              Exponent.new([
+                child.deep_dup, Number.new(2)
               ])
             )
           ]

data/lib/keisan/ast/unary_minus.rb

@@ -17,11 +17,11 @@ module Keisan
         context ||= Context.new
 
         case child
-        when AST::Number
-          AST::Number.new(-child.value(context)).simplify(context)
+        when Number
+          Number.new(-child.value(context)).simplify(context)
         else
-          AST::Times.new([
-            AST::Number.new(-1),
+          Times.new([
+            Number.new(-1),
             child
           ]).simplify(context)
         end
@@ -29,7 +29,7 @@ module Keisan
 
       def differentiate(variable, context = nil)
         context ||= Context.new
-        AST::Times.new([
+        Times.new([
           -1.to_node,
           child.differentiate(variable, context)
         ]).simplify(context)

data/lib/keisan/ast/unary_operator.rb

@@ -5,7 +5,7 @@ module Keisan
         children = Array.wrap(children)
         super(children)
         if children.count != 1
-          raise Keisan::Exceptions::ASTError.new("Unary operator takes has a single child")
+          raise Exceptions::ASTError.new("Unary operator takes has a single child")
         end
       end
 
@@ -26,7 +26,7 @@ module Keisan
       end
 
       def to_s
-        if child.is_a?(AST::Operator)
+        if child.is_a?(Operator)
           "#{symbol.to_s}(#{child.to_s})"
         else
           "#{symbol.to_s}#{child.to_s}"

data/lib/keisan/ast/unary_plus.rb

@@ -11,8 +11,8 @@ module Keisan
 
       def simplify(context = nil)
         case child
-        when AST::Number
-          AST::Number.new(child.value(context)).simplify(context)
+        when Number
+          Number.new(child.value(context)).simplify(context)
         else
           super
         end

data/lib/keisan/ast/variable.rb

@@ -8,17 +8,22 @@ module Keisan
       end
 
       def value(context = nil)
-        context = Keisan::Context.new if context.nil?
-        context.variable(name).value(context)
+        context ||= Context.new
+        variable_node_from_context(context).value(context)
       end
 
       def unbound_variables(context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
         context.has_variable?(name) ? Set.new : Set.new([name])
       end
 
       def ==(other)
-        name == other.name
+        case other
+        when Variable
+          name == other.name
+        else
+          false
+        end
       end
 
       def to_s
@@ -26,12 +31,13 @@ module Keisan
       end
 
       def evaluate(context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
         if context.has_variable?(name)
-          variable = context.variable(name)
+          variable = variable_node_from_context(context)
+
           # The variable might just be a variable, i.e. probably in function definition
-          if variable.is_a?(AST::Node)
-            variable.is_a?(AST::Variable) ? variable : variable.evaluate(context)
+          if variable.is_a?(Node)
+            variable.is_a?(Variable) ? variable : variable.evaluate(context)
           else
             variable
           end
@@ -41,7 +47,7 @@ module Keisan
       end
 
       def simplify(context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
         if context.has_variable?(name)
           context.variable(name).to_node.simplify(context)
         else
@@ -58,7 +64,7 @@ module Keisan
       end
 
       def differentiate(variable, context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
 
         if name == variable.name && !context.has_variable?(name)
           1.to_node
@@ -66,6 +72,16 @@ module Keisan
           0.to_node
         end
       end
+
+      private
+
+      def variable_node_from_context(context)
+        variable = context.variable(name)
+        if variable.is_a?(Cell)
+          variable = variable.node
+        end
+        variable
+      end
     end
   end
 end

data/lib/keisan/context.rb

@@ -26,7 +26,7 @@ module Keisan
         case value
         when Proc
           child.register_function!(name, value)
-        when Keisan::Functions::ProcFunction
+        when Functions::ProcFunction
           child.register_function!(name, value.function_proc)
         else
           child.register_variable!(name, value)
@@ -61,8 +61,8 @@ module Keisan
       @variable_registry.has?(name)
     end
 
-    def register_variable!(name, value)
-      if !@variable_registry.shadowed.member?(name) && transient?
+    def register_variable!(name, value, local: false)
+      if !@variable_registry.shadowed.member?(name) && (transient? || !local && @parent&.has_variable?(name))
         @parent.register_variable!(name, value)
       else
         @variable_registry.register!(name, value)
@@ -77,8 +77,8 @@ module Keisan
       @function_registry.has?(name)
     end
 
-    def register_function!(name, function)
-      if transient?
+    def register_function!(name, function, local: false)
+      if transient? || !local && @parent&.has_function?(name)
         @parent.register_function!(name, function)
       else
         @function_registry.register!(name.to_s, function)

data/lib/keisan/evaluator.rb

@@ -8,13 +8,14 @@ module Keisan
 
     def evaluate(expression, definitions = {})
       context = calculator.context.spawn_child(definitions: definitions, transient: true)
-      ast = Keisan::AST.parse(expression)
-      evaluation = ast.evaluate(context)
+      ast = ast(expression)
+      last_line = last_line(ast)
 
-      case ast
-      when Keisan::AST::Assignment
-        if ast.children.first.is_a?(Keisan::AST::Variable)
-          context.variable(ast.children.first.name).value(context)
+      evaluation = ast.evaluated(context)
+
+      if last_line.is_a?(AST::Assignment)
+        if last_line.children.first.is_a?(AST::Variable)
+          context.variable(last_line.children.first.name).value(context)
         end
       else
         evaluation.value(context)
@@ -23,12 +24,18 @@ module Keisan
 
     def simplify(expression, definitions = {})
       context = calculator.context.spawn_child(definitions: definitions, transient: true)
-      ast = Keisan::AST.parse(expression)
+      ast = AST.parse(expression)
       ast.simplify(context)
     end
 
     def ast(expression)
-      Keisan::AST.parse(expression)
+      AST.parse(expression)
+    end
+
+    private
+
+    def last_line(ast)
+      ast.is_a?(AST::MultiLine) ? ast.children.last : ast
     end
   end
 end

data/lib/keisan/function.rb

@@ -1,25 +1,43 @@
 module Keisan
   class Function
-    attr_reader :name
+    attr_reader :name, :arity
 
-    def initialize(name)
+    def initialize(name, arity = 1)
       @name = name
+      @arity = arity
     end
 
     def value(ast_function, context = nil)
-      raise Keisan::Exceptions::NotImplementedError.new
+      raise Exceptions::NotImplementedError.new
     end
 
     def evaluate(ast_function, context = nil)
-      raise Keisan::Exceptions::NotImplementedError.new
+      raise Exceptions::NotImplementedError.new
     end
 
     def simplify(ast_function, context = nil)
-      raise Keisan::Exceptions::NotImplementedError.new
+      raise Exceptions::NotImplementedError.new
     end
 
     def differentiate(ast_function, variable, context = nil)
-      raise Keisan::Exceptions::NotImplementedError.new
+      raise Exceptions::NotImplementedError.new
+    end
+
+    protected
+
+    def validate_arguments!(count)
+      case arity
+      when Integer
+        if arity < 0 && count < arity.abs || arity >= 0 && count != arity
+          raise Keisan::Exceptions::InvalidFunctionError.new("Require #{arity} arguments to #{name}")
+        end
+      when Range
+        unless arity.include? count
+          raise Keisan::Exceptions::InvalidFunctionError.new("Require #{arity} arguments to #{name}")
+        end
+      else
+        raise Keisan::Exceptions::InternalError.new("Invalid arity: #{arity}")
+      end
     end
   end
 end

data/lib/keisan/functions/cbrt.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        Keisan::AST::Exponent.new([argument, Rational(-2,3)]) / 3
+        AST::Exponent.new([argument, Rational(-2,3)]) / 3
       end
     end
   end