keisan 0.3.0 → 0.4.0

data/lib/keisan/ast/functions/if.rb

@@ -0,0 +1,47 @@
+module Keisan
+  module AST
+    module Functions
+      class If < AST::Function
+        def value(context = nil)
+          unless (2..3).cover? children.size
+            raise Keisan::Exceptions::InvalidFunctionError.new("Require 2 or 3 arguments to if")
+          end
+
+          context ||= Context.new
+
+          bool = children[0].value(context)
+
+          if bool
+            children[1].value(context)
+          else
+            children.size == 3 ? children[2].value(context) : nil
+          end
+        end
+
+        def simplify(context = nil)
+          context ||= Context.new
+          @children = children.map {|child| child.simplify(context)}
+
+          if children[0].is_a?(AST::Boolean)
+            if children[0].value
+              children[1]
+            else
+              # If no third argument, then children[2] gives nil, and to_node makes this AST::Null
+              children[2].to_node
+            end
+          else
+            self
+          end
+        end
+
+        def unbound_functions(context = nil)
+          context ||= Context.new
+
+          children.inject(Set.new) do |res, child|
+            res | child.unbound_functions(context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/keisan/ast/indexing.rb

@@ -1,15 +1,55 @@
 module Keisan
   module AST
     class Indexing < UnaryOperator
-      attr_reader :arguments
+      attr_reader :indexes
 
-      def initialize(child, arguments = [])
+      def initialize(child, indexes = [])
         @children = [child]
-        @arguments = arguments
+        @indexes = indexes
       end
 
       def value(context = nil)
-        return children.first.value(context).send(:[], *arguments.map {|arg| arg.value(context)})
+        return child.value(context).send(:[], *indexes.map {|index| index.value(context)})
+      end
+
+      def to_s
+        "(#{child.to_s})[#{indexes.map(&:to_s).join(',')}]"
+      end
+
+      def evaluate(context = nil)
+        context ||= Keisan::Context.new
+        @children = children.map {|child| child.evaluate(context)}
+        @indexes = indexes.map {|index| index.evaluate(context)}
+
+        case child
+        when AST::List
+          if @indexes.size == 1 && @indexes.first.is_a?(AST::Number)
+            return child.children[@indexes.first.value(context)].evaluate(context)
+          end
+        end
+
+        self
+      end
+
+      def simplify(context = nil)
+        context ||= Context.new
+
+        @indexes = indexes.map {|index| index.simplify(context)}
+        @children = [child.simplify(context)]
+
+        case child
+        when AST::List
+          if @indexes.size == 1 && @indexes.first.is_a?(AST::Number)
+            return child.children[@indexes.first.value(context)].simplify(context)
+          end
+        end
+
+        self
+      end
+
+      def replace(variable, replacement)
+        super
+        @indexes = indexes.map {|index| index.replace(variable, replacement)}
       end
     end
   end

data/lib/keisan/ast/list.rb

@@ -5,6 +5,10 @@ module Keisan
         context = Keisan::Context.new if context.nil?
         children.map {|child| child.value(context)}
       end
+
+      def to_s
+        "[#{children.map(&:to_s).join(',')}]"
+      end
     end
   end
 end

data/lib/keisan/ast/literal.rb

@@ -1,6 +1,14 @@
 module Keisan
   module AST
     class Literal < Node
+      def ==(other)
+        case other
+        when Literal
+          value == other.value
+        else
+          false
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/logical_and.rb

@@ -1,17 +1,22 @@
 module Keisan
   module AST
     class LogicalAnd < LogicalOperator
-      def arity
-        2..Float::INFINITY
+      def self.symbol
+        :"&&"
       end
 
-      def self.symbol
-        :"&"
+      def evaluate(context = nil)
+        children[0].evaluate(context).and(children[1].evaluate(context))
       end
 
       def blank_value
         true
       end
+
+      def value(context = nil)
+        context ||= Keisan::Context.new
+        children[0].value(context) && children[1].value(context)
+      end
     end
   end
 end

data/lib/keisan/ast/logical_equal.rb

@@ -1,14 +1,14 @@
 module Keisan
   module AST
     class LogicalEqual < LogicalOperator
-      def arity
-        2..2
-      end
-
       def self.symbol
         :"=="
       end
 
+      def evaluate(context = nil)
+        children[0].evaluate(context).equal(children[1].evaluate(context))
+      end
+
       def value(context=nil)
         context ||= Context.new
         children[0].value(context) == children[1].value(context)

data/lib/keisan/ast/logical_greater_than.rb

@@ -1,14 +1,14 @@
 module Keisan
   module AST
     class LogicalGreaterThan < LogicalOperator
-      def arity
-        2..2
-      end
-
       def self.symbol
         :">"
       end
 
+      def evaluate(context = nil)
+        children[0].evaluate(context) > children[1].evaluate(context)
+      end
+
       def value(context = nil)
         children.first.value(context) > children.last.value(context)
       end

data/lib/keisan/ast/logical_greater_than_or_equal_to.rb

@@ -1,14 +1,14 @@
 module Keisan
   module AST
     class LogicalGreaterThanOrEqualTo < LogicalOperator
-      def arity
-        2..2
-      end
-
       def self.symbol
         :">="
       end
 
+      def evaluate(context = nil)
+        children[0].evaluate(context) >= children[1].evaluate(context)
+      end
+
       def value(context = nil)
         children.first.value(context) >= children.last.value(context)
       end

data/lib/keisan/ast/logical_less_than.rb

@@ -1,14 +1,14 @@
 module Keisan
   module AST
     class LogicalLessThan < LogicalOperator
-      def arity
-        2..2
-      end
-
       def self.symbol
         :"<"
       end
 
+      def evaluate(context = nil)
+        children[0].evaluate(context) < children[1].evaluate(context)
+      end
+
       def value(context = nil)
         children.first.value(context) < children.last.value(context)
       end

data/lib/keisan/ast/logical_less_than_or_equal_to.rb

@@ -1,14 +1,14 @@
 module Keisan
   module AST
     class LogicalLessThanOrEqualTo < LogicalOperator
-      def arity
-        2..2
-      end
-
       def self.symbol
         :"<="
       end
 
+      def evaluate(context = nil)
+        children[0].evaluate(context) <= children[1].evaluate(context)
+      end
+
       def value(context = nil)
         children.first.value(context) <= children.last.value(context)
       end

data/lib/keisan/ast/logical_not_equal.rb

@@ -1,14 +1,14 @@
 module Keisan
   module AST
     class LogicalNotEqual < LogicalOperator
-      def arity
-        2..2
-      end
-
       def self.symbol
         :"!="
       end
 
+      def evaluate(context = nil)
+        children[0].evaluate(context).not_equal(children[1].evaluate(context))
+      end
+
       def value(context=nil)
         context ||= Context.new
         children[0].value(context) != children[1].value(context)

data/lib/keisan/ast/logical_operator.rb

@@ -1,9 +1,6 @@
 module Keisan
   module AST
     class LogicalOperator < Operator
-      def associativity
-        :left
-      end
     end
   end
 end

data/lib/keisan/ast/logical_or.rb

@@ -1,17 +1,22 @@
 module Keisan
   module AST
     class LogicalOr < LogicalOperator
-      def arity
-        2..Float::INFINITY
-      end
-
       def self.symbol
-        :"|"
+        :"||"
       end
 
       def blank_value
         false
       end
+
+      def evaluate(context = nil)
+        children[0].evaluate(context).or(children[1].evaluate(context))
+      end
+
+      def value(context = nil)
+        context ||= Keisan::Context.new
+        children[0].value(context) || children[1].value(context)
+      end
     end
   end
 end

data/lib/keisan/ast/modulo.rb

@@ -1,14 +1,14 @@
 module Keisan
   module AST
     class Modulo < ArithmeticOperator
-      def arity
-        2..Float::INFINITY
-      end
-
       def self.symbol
         :%
       end
 
+      def evaluate(context = nil)
+        children[1..-1].inject(children.first.evaluate(context)) {|total, child| total % child.evaluate(context)}
+      end
+
       def value(context = nil)
         children_values = children.map {|child| child.value(context)}
         children_values[1..-1].inject(children_values[0], &:%)

data/lib/keisan/ast/node.rb

@@ -6,29 +6,141 @@ module Keisan
       end
 
       def unbound_variables(context = nil)
-        context ||= Keisan::Context.new
-
-        case self
-        when Parent
-          children.inject(Set.new) do |vars, child|
-            vars | child.unbound_variables(context)
-          end
-        else
-          Set.new
-        end
+        Set.new
       end
 
       def unbound_functions(context = nil)
-        context ||= Keisan::Context.new
-
-        case self
-        when Parent
-          children.inject(Set.new) do |fns, child|
-            fns | child.unbound_functions(context)
-          end
-        else
-          Set.new
-        end
+        Set.new
+      end
+
+      def well_defined?(context = nil)
+        unbound_variables(context).empty? && unbound_functions(context).empty?
+      end
+
+      def deep_dup
+        dup
+      end
+
+      def simplified(context = nil)
+        deep_dup.simplify(context)
+      end
+
+      def simplify(context = nil)
+        self
+      end
+
+      def evaluate(context = nil)
+        self
+      end
+
+      def differentiate(variable, context = nil)
+        raise Keisan::Exceptions::NonDifferentiableError.new
+      end
+
+      def replace(variable, replacement)
+        self
+      end
+
+      def coerce(other)
+        [other.to_node, self]
+      end
+
+      def to_node
+        self
+      end
+
+      def +(other)
+        AST::Plus.new(
+          [self, other.to_node]
+        )
+      end
+
+      def -(other)
+        AST::Plus.new(
+          [self, AST::UnaryMinus.new(other.to_node)]
+        )
+      end
+
+      def *(other)
+        AST::Times.new(
+          [self, other.to_node]
+        )
+      end
+
+      def /(other)
+        AST::Times.new(
+          [self, AST::UnaryInverse.new(other.to_node)]
+        )
+      end
+
+      def %(other)
+        AST::Modulo.new(
+          [self, other.to_node]
+        )
+      end
+
+      def !
+        AST::LogicalNot.new(self)
+      end
+
+      def ~
+        AST::UnaryBitwiseNot.new(self)
+      end
+
+      def +@
+        self
+      end
+
+      def -@
+        AST::UnaryMinus.new(self)
+      end
+
+      def **(other)
+        AST::Exponent.new([self, other.to_node])
+      end
+
+      def &(other)
+        AST::BitwiseAnd.new([self, other.to_node])
+      end
+
+      def ^(other)
+        AST::BitwiseXor.new([self, other.to_node])
+      end
+
+      def |(other)
+        AST::BitwiseOr.new([self, other.to_node])
+      end
+
+      def >(other)
+        AST::LogicalGreaterThan.new([self, other.to_node])
+      end
+
+      def >=(other)
+        AST::LogicalGreaterThanOrEqualTo.new([self, other.to_node])
+      end
+
+      def <(other)
+        AST::LogicalLessThan.new([self, other.to_node])
+      end
+
+      def <=(other)
+        AST::LogicalLessThanOrEqualTo.new([self, other.to_node])
+      end
+
+      def equal(other)
+        AST::LogicalEqual.new([self, other.to_node])
+      end
+
+      def not_equal(other)
+        AST::LogicalNotEqual.new([self, other.to_node])
+      end
+
+      def and(other)
+        AST::LogicalAnd.new([self, other.to_node])
+      end
+
+      def or(other)
+        AST::LogicalOr.new([self, other.to_node])
       end
     end
   end