keisan 0.4.0 → 0.5.0

data/lib/keisan/ast/builder.rb

@@ -22,7 +22,13 @@ module Keisan
 
         consume_operators!
 
-        unless @nodes.count == 1
+        case @nodes.count
+        when 0
+          # Empty string, set to just Null
+          @nodes = [Keisan::AST::Null.new]
+        when 1
+          # Good
+        else
           raise Keisan::Exceptions::ASTError.new("Should end up with a single node")
         end
       end

data/lib/keisan/ast/constant_literal.rb

@@ -6,7 +6,12 @@ module Keisan
       end
 
       def to_s
-        value.to_s
+        case value
+        when Rational
+          "(#{value.to_s})"
+        else
+          value.to_s
+        end
       end
     end
   end

data/lib/keisan/ast/exponent.rb

@@ -58,7 +58,7 @@ module Keisan
 
         # Special simple case where exponent is a pure number
         if exponent.is_a?(AST::Number)
-          return (exponent * base ** (exponent -1)).simplify(context)
+          return (exponent * base.differentiate(variable, context) * base ** (exponent -1)).simplify(context)
         end
 
         base_diff     = base.differentiate(variable, context)

data/lib/keisan/ast/function.rb

@@ -47,7 +47,7 @@ module Keisan
         if function_defined?(context)
           function_from_context(context).evaluate(self, context)
         else
-          @children = children.map {|child| child.evaluate(context)}
+          @children = children.map {|child| child.evaluate(context).to_node}
           self
         end
       end
@@ -58,7 +58,7 @@ module Keisan
         if function_defined?(context)
           function_from_context(context).simplify(self, context)
         else
-          @children = children.map {|child| child.simplify(context)}
+          @children = children.map {|child| child.simplify(context).to_node}
           self
         end
       end
@@ -68,10 +68,14 @@ module Keisan
       end
 
       def differentiate(variable, context = nil)
+        function = function_from_context(context)
+        function.differentiate(self, variable, context)
+
+      rescue Keisan::Exceptions::UndefinedFunctionError, Keisan::Exceptions::NotImplementedError
         unless unbound_variables(context).include?(variable.name)
           return AST::Number.new(0)
         end
-        # Do not know how to differentiate a function in general, so leave as derivative
+
         AST::Function.new([self, variable], "diff")
       end
     end

data/lib/keisan/ast/list.rb

@@ -2,7 +2,7 @@ module Keisan
   module AST
     class List < Parent
       def value(context = nil)
-        context = Keisan::Context.new if context.nil?
+        context ||= Keisan::Context.new
         children.map {|child| child.value(context)}
       end
 

data/lib/keisan/ast/node.rb

@@ -80,7 +80,7 @@ module Keisan
       end
 
       def !
-        AST::LogicalNot.new(self)
+        AST::UnaryLogicalNot.new(self)
       end
 
       def ~

data/lib/keisan/ast/parent.rb

@@ -4,7 +4,7 @@ module Keisan
       attr_reader :children
 
       def initialize(children = [])
-        children = Array.wrap(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
         end

data/lib/keisan/ast/plus.rb

@@ -24,7 +24,7 @@ module Keisan
           children_values.inject([], &:+)
         else
           children_values.inject(0, &:+)
-        end
+        end.to_node.value(context)
       end
 
       def evaluate(context = nil)
@@ -46,6 +46,16 @@ module Keisan
           end
         end
 
+        if children.all? {|child| child.is_a?(Keisan::AST::String)}
+          return Keisan::AST::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|
+            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)
 

data/lib/keisan/ast/string.rb

@@ -19,6 +19,14 @@ module Keisan
           raise Keisan::Exceptions::TypeError.new("#{other}'s type is invalid, #{other.class}")
         end
       end
+
+      def to_s
+        if value =~ /\"/
+          "\"#{value.gsub("\"", "\\\"")}\""
+        else
+          "\"#{value}\""
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/unary_operator.rb

@@ -3,7 +3,7 @@ module Keisan
     class UnaryOperator < Operator
       def initialize(children = [])
         children = Array.wrap(children)
-        super
+        super(children)
         if children.count != 1
           raise Keisan::Exceptions::ASTError.new("Unary operator takes has a single child")
         end

data/lib/keisan/ast/variable.rb

@@ -9,7 +9,7 @@ module Keisan
 
       def value(context = nil)
         context = Keisan::Context.new if context.nil?
-        context.variable(name)
+        context.variable(name).value(context)
       end
 
       def unbound_variables(context = nil)
@@ -28,7 +28,13 @@ module Keisan
       def evaluate(context = nil)
         context ||= Keisan::Context.new
         if context.has_variable?(name)
-          context.variable(name).to_node.evaluate(context)
+          variable = context.variable(name)
+          # 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)
+          else
+            variable
+          end
         else
           self
         end

data/lib/keisan/calculator.rb

@@ -6,10 +6,26 @@ module Keisan
       @context = context || Context.new(allow_recursive: allow_recursive)
     end
 
+    def allow_recursive
+      context.allow_recursive
+    end
+
+    def allow_recursive!
+      context.allow_recursive!
+    end
+
     def evaluate(expression, definitions = {})
       Evaluator.new(self).evaluate(expression, definitions)
     end
 
+    def simplify(expression, definitions = {})
+      Evaluator.new(self).simplify(expression, definitions)
+    end
+
+    def ast(expression)
+      Evaluator.new(self).ast(expression)
+    end
+
     def define_variable!(name, value)
       context.register_variable!(name, value)
     end

data/lib/keisan/context.rb

@@ -2,30 +2,57 @@ module Keisan
   class Context
     attr_reader :function_registry, :variable_registry, :allow_recursive
 
-    def initialize(parent: nil, random: nil, allow_recursive: false)
+    def initialize(parent: nil, random: nil, allow_recursive: false, shadowed: [])
       @parent = parent
       @function_registry = Functions::Registry.new(parent: @parent.try(:function_registry))
-      @variable_registry = Variables::Registry.new(parent: @parent.try(:variable_registry))
+      @variable_registry = Variables::Registry.new(parent: @parent.try(:variable_registry), shadowed: shadowed)
       @random            = random
       @allow_recursive   = allow_recursive
     end
 
-    def spawn_child(definitions: {}, transient: false)
-      child = Context.new(parent: self, allow_recursive: allow_recursive)
+    def allow_recursive!
+      @allow_recursive = true
+    end
+
+    # A transient context does not persist variables and functions in this context, but
+    # rather store them one level higher in the parent context.  When evaluating a string,
+    # the entire operation is done in a transient context that is unique from the calculators
+    # current context, but such that variable/function definitions can be persisted in
+    # the calculator.
+    def spawn_child(definitions: {}, shadowed: [], transient: nil)
+      child = pure_child(shadowed: shadowed)
 
       definitions.each do |name, value|
         case value
         when Proc
           child.register_function!(name, value)
+        when Keisan::Functions::ProcFunction
+          child.register_function!(name, value.function_proc)
         else
           child.register_variable!(name, value)
         end
       end
 
-      child.set_transient! if transient
+      if transient.nil? && self.transient? || transient == true
+        child.set_transient!
+      end
       child
     end
 
+    def transient_definitions
+      return {} unless @transient
+      parent_definitions = @parent.present? ? @parent.transient_definitions : {}
+      parent_definitions.merge(
+        @variable_registry.locals
+      ).merge(
+        @function_registry.locals
+      )
+    end
+
+    def transient?
+      !!@transient
+    end
+
     def variable(name)
       @variable_registry[name.to_s]
     end
@@ -35,10 +62,10 @@ module Keisan
     end
 
     def register_variable!(name, value)
-      if @transient
+      if !@variable_registry.shadowed.member?(name) && transient?
         @parent.register_variable!(name, value)
       else
-        @variable_registry.register!(name.to_s, value)
+        @variable_registry.register!(name, value)
       end
     end
 
@@ -51,7 +78,7 @@ module Keisan
     end
 
     def register_function!(name, function)
-      if @transient
+      if transient?
         @parent.register_function!(name, function)
       else
         @function_registry.register!(name.to_s, function)
@@ -67,5 +94,9 @@ module Keisan
     def set_transient!
       @transient = true
     end
+
+    def pure_child(shadowed: [])
+      self.class.new(parent: self, shadowed: shadowed, allow_recursive: allow_recursive)
+    end
   end
 end

data/lib/keisan/evaluator.rb

@@ -14,11 +14,21 @@ module Keisan
       case ast
       when Keisan::AST::Assignment
         if ast.children.first.is_a?(Keisan::AST::Variable)
-          context.variable(ast.children.first.name)
+          context.variable(ast.children.first.name).value(context)
         end
       else
         evaluation.value(context)
       end
     end
+
+    def simplify(expression, definitions = {})
+      context = calculator.context.spawn_child(definitions: definitions, transient: true)
+      ast = Keisan::AST.parse(expression)
+      ast.simplify(context)
+    end
+
+    def ast(expression)
+      Keisan::AST.parse(expression)
+    end
   end
 end

data/lib/keisan/function.rb

@@ -17,5 +17,9 @@ module Keisan
     def simplify(ast_function, context = nil)
       raise Keisan::Exceptions::NotImplementedError.new
     end
+
+    def differentiate(ast_function, variable, context = nil)
+      raise Keisan::Exceptions::NotImplementedError.new
+    end
   end
 end

data/lib/keisan/functions/abs.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module Functions
+    class Abs < CMathFunction
+      def initialize
+        super("abs", Proc.new {|arg| arg.abs})
+      end
+    end
+  end
+end

data/lib/keisan/functions/cbrt.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module Functions
+    class Cbrt < CMathFunction
+      def initialize
+        super("cbrt")
+      end
+
+      protected
+
+      def self.derivative(argument)
+        Keisan::AST::Exponent.new([argument, Rational(-2,3)]) / 3
+      end
+    end
+  end
+end

data/lib/keisan/functions/cmath_function.rb

@@ -0,0 +1,11 @@
+require "cmath"
+
+module Keisan
+  module Functions
+    class CMathFunction < MathFunction
+      def initialize(name, proc_function = nil)
+        super(name, proc_function || Proc.new {|arg| CMath.send(name, arg)})
+      end
+    end
+  end
+end

data/lib/keisan/functions/cos.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module Functions
+    class Cos < CMathFunction
+      def initialize
+        super("cos")
+      end
+
+      protected
+
+      def self.derivative(argument)
+        -Keisan::AST::Function.new([argument], "sin")
+      end
+    end
+  end
+end

data/lib/keisan/functions/cosh.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module Functions
+    class Cosh < CMathFunction
+      def initialize
+        super("cosh")
+      end
+
+      protected
+
+      def self.derivative(argument)
+        Keisan::AST::Function.new([argument], "sinh")
+      end
+    end
+  end
+end

data/lib/keisan/functions/cot.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module Functions
+    class Cot < CMathFunction
+      def initialize
+        super("cot", Proc.new {|arg| 1 / CMath::tan(arg)})
+      end
+
+      protected
+
+      def self.derivative(argument)
+        -Keisan::AST::Exponent.new([Keisan::AST::Function.new([argument], "sin"), -2])
+      end
+    end
+  end
+end

data/lib/keisan/functions/coth.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module Functions
+    class Coth < CMathFunction
+      def initialize
+        super("coth", Proc.new {|arg| 1 / CMath::tanh(arg)})
+      end
+
+      protected
+
+      def self.derivative(argument)
+        -Keisan::AST::Exponent.new([Keisan::AST::Function.new([argument], "sinh"), -2])
+      end
+    end
+  end
+end

data/lib/keisan/functions/csc.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module Functions
+    class Csc < CMathFunction
+      def initialize
+        super("csc", Proc.new {|arg| 1 / CMath::sin(arg)})
+      end
+
+      protected
+
+      def self.derivative(argument)
+        -Keisan::AST::Function.new([argument], "cos") * Keisan::AST::Exponent.new([Keisan::AST::Function.new([argument], "sin"), -2])
+      end
+    end
+  end
+end