keisan 0.5.0 → 0.6.0

data/lib/keisan/functions/filter.rb

@@ -1,15 +1,15 @@
 module Keisan
   module Functions
-    class Filter < Keisan::Function
+    class Filter < Function
       # Filters (list, variable, expression)
       # e.g. filter([1,2,3,4], x, x % 2 == 0)
       # should give [2,4]
       def initialize
-        @name = "filter"
+        super("filter", 3)
       end
 
       def value(ast_function, context = nil)
-        evaluate(ast_function, context = nil)
+        evaluate(ast_function, context)
       end
 
       def evaluate(ast_function, context = nil)
@@ -18,21 +18,23 @@ module Keisan
       end
 
       def simplify(ast_function, context = nil)
+        validate_arguments!(ast_function.children.count)
+
+        context ||= Context.new
         list, variable, expression = list_variable_expression_for(ast_function, context)
 
-        context ||= Keisan::Context.new
         local = context.spawn_child(transient: false, shadowed: [variable.name])
 
-        Keisan::AST::List.new(
+        AST::List.new(
           list.children.select do |element|
             local.register_variable!(variable, element)
             result = expression.evaluate(local)
 
             case result
-            when Keisan::AST::Boolean
+            when AST::Boolean
               result.value
             else
-              raise Keisan::Exceptions::InvalidFunctionError.new("Filter requires expression to be a logical expression")
+              raise Exceptions::InvalidFunctionError.new("Filter requires expression to be a logical expression")
             end
           end
         )
@@ -41,20 +43,16 @@ module Keisan
       private
 
       def list_variable_expression_for(ast_function, context)
-        unless ast_function.children.size == 3
-          raise Keisan::Exceptions::InvalidFunctionError.new("Require 3 arguments to filter")
-        end
-
         list = ast_function.children[0].simplify(context)
         variable = ast_function.children[1]
         expression = ast_function.children[2]
 
-        unless list.is_a?(Keisan::AST::List)
-          raise Keisan::Exceptions::InvalidFunctionError.new("First argument to filter must be a list")
+        unless list.is_a?(AST::List)
+          raise Exceptions::InvalidFunctionError.new("First argument to filter must be a list")
         end
 
-        unless variable.is_a?(Keisan::AST::Variable)
-          raise Keisan::Exceptions::InvalidFunctionError.new("Second argument to filter must be a variable")
+        unless variable.is_a?(AST::Variable)
+          raise Exceptions::InvalidFunctionError.new("Second argument to filter must be a variable")
         end
 
         [list, variable, expression]

data/lib/keisan/functions/if.rb

@@ -1,32 +1,22 @@
 module Keisan
   module Functions
-    class If < Keisan::Function
+    class If < Function
       def initialize
-        @name = "if"
+        super("if", ::Range.new(2,3))
       end
 
       def value(ast_function, context = nil)
-        context ||= Keisan::Context.new
-
-        unless (2..3).cover? ast_function.children.size
-          raise Keisan::Exceptions::InvalidFunctionError.new("Require 2 or 3 arguments to if")
-        end
-
-        bool = ast_function.children[0].value(context)
-
-        if bool
-          ast_function.children[1].value(context)
-        else
-          ast_function.children.size == 3 ? ast_function.children[2].value(context) : nil
-        end
+        validate_arguments!(ast_function.children.count)
+        evaluate(ast_function, context)
       end
 
       def evaluate(ast_function, context = nil)
-        context ||= Keisan::Context.new
+        validate_arguments!(ast_function.children.count)
+        context ||= Context.new
 
         bool = ast_function.children[0].evaluate(context)
 
-        if bool.is_a?(Keisan::AST::Boolean)
+        if bool.is_a?(AST::Boolean)
           node = bool.value ? ast_function.children[1] : ast_function.children[2]
           node.to_node.evaluate(context)
         else
@@ -35,14 +25,17 @@ module Keisan
       end
 
       def simplify(ast_function, context = nil)
+        validate_arguments!(ast_function.children.count)
         context ||= Context.new
         bool = ast_function.children[0].simplify(context)
 
-        if bool.is_a?(Keisan::AST::Boolean)
+        if bool.is_a?(AST::Boolean)
           if bool.value
             ast_function.children[1].to_node.simplify(context)
-          else
+          elsif ast_function.children.size >= 2
             ast_function.children[2].to_node.simplify(context)
+          else
+            Keisan::AST::Null.new
           end
         else
           ast_function
@@ -50,8 +43,9 @@ module Keisan
       end
 
       def differentiate(ast_function, variable, context = nil)
+        validate_arguments!(ast_function.children.count)
         context ||= Context.new
-        Keisan::AST::Function.new(
+        AST::Function.new(
           [
             ast_function.children[0],
             ast_function.children[1].differentiate(variable, context),

data/lib/keisan/functions/let.rb

@@ -0,0 +1,36 @@
+module Keisan
+  module Functions
+    class Let < Function
+      def initialize
+        super("let", ::Range.new(1,2))
+      end
+
+      def value(ast_function, context = nil)
+        evaluate(ast_function, context)
+      end
+
+      def evaluate(ast_function, context = nil)
+        validate_arguments!(ast_function.children.count)
+        assignment(ast_function).evaluate(context)
+      end
+
+      def simplify(ast_function, context = nil)
+        evaluate(ast_function, context)
+      end
+
+      private
+
+      def assignment(ast_function)
+        if ast_function.children.count == 1
+          unless ast_function.children.first.is_a?(AST::Assignment)
+            raise Exceptions::InvalidFunctionError.new("`let` must accept assignment if given one argument")
+          end
+
+          AST::Assignment.new(ast_function.children.first.children, local: true)
+        else
+          AST::Assignment.new(ast_function.children, local: true)
+        end
+      end
+    end
+  end
+end

data/lib/keisan/functions/map.rb

@@ -1,15 +1,15 @@
 module Keisan
   module Functions
-    class Map < Keisan::Function
+    class Map < Function
       # Maps (list, variable, expression)
       # e.g. map([1,2,3], x, 2*x)
       # should give [2,4,6]
       def initialize
-        @name = "map"
+        super("map", 3)
       end
 
       def value(ast_function, context = nil)
-        evaluate(ast_function, context = nil)
+        evaluate(ast_function, context)
       end
 
       def evaluate(ast_function, context = nil)
@@ -18,12 +18,14 @@ module Keisan
       end
 
       def simplify(ast_function, context = nil)
-        context ||= Keisan::Context.new
+        validate_arguments!(ast_function.children.count)
+
+        context ||= Context.new
         list, variable, expression = list_variable_expression_for(ast_function, context)
 
         local = context.spawn_child(transient: false, shadowed: [variable.name])
 
-        Keisan::AST::List.new(
+        AST::List.new(
           list.children.map do |element|
             local.register_variable!(variable, element)
             expression.simplified(local)
@@ -34,20 +36,16 @@ module Keisan
       private
 
       def list_variable_expression_for(ast_function, context)
-        unless ast_function.children.size == 3
-          raise Keisan::Exceptions::InvalidFunctionError.new("Require 3 arguments to map")
-        end
-
         list = ast_function.children[0].simplify(context)
         variable = ast_function.children[1]
         expression = ast_function.children[2]
 
-        unless list.is_a?(Keisan::AST::List)
-          raise Keisan::Exceptions::InvalidFunctionError.new("First argument to map must be a list")
+        unless list.is_a?(AST::List)
+          raise Exceptions::InvalidFunctionError.new("First argument to map must be a list")
         end
 
-        unless variable.is_a?(Keisan::AST::Variable)
-          raise Keisan::Exceptions::InvalidFunctionError.new("Second argument to map must be a variable")
+        unless variable.is_a?(AST::Variable)
+          raise Exceptions::InvalidFunctionError.new("Second argument to map must be a variable")
         end
 
         [list, variable, expression]

data/lib/keisan/functions/math_function.rb

@@ -11,7 +11,7 @@ module Keisan
       end
 
       def differentiate(ast_function, variable, context = nil)
-        raise Keisan::Exceptions::InvalidFunctionError.new unless ast_function.children.count == 1
+        raise Exceptions::InvalidFunctionError.new unless ast_function.children.count == 1
         context ||= Context.new
 
         argument_simplified = ast_function.children.first.simplify(context)
@@ -23,7 +23,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        raise Keisan::Exceptions::NotImplementedError.new
+        raise Exceptions::NotImplementedError.new
       end
 
       def self.apply_simplifications(simplified)

data/lib/keisan/functions/proc_function.rb

@@ -1,27 +1,30 @@
 module Keisan
   module Functions
-    class ProcFunction < Keisan::Function
+    class ProcFunction < Function
       attr_reader :function_proc
 
       def initialize(name, function_proc)
-        raise Keisan::Exceptions::InvalidFunctionError.new unless function_proc.is_a?(Proc)
+        raise Exceptions::InvalidFunctionError.new unless function_proc.is_a?(Proc)
 
-        super(name)
+        super(name, function_proc.arity)
         @function_proc = function_proc
       end
 
       def call(context, *args)
+        validate_arguments!(args.count)
         function_proc.call(*args).to_node
       end
 
       def value(ast_function, context = nil)
-        context ||= Keisan::Context.new
+        validate_arguments!(ast_function.children.count)
+        context ||= Context.new
         argument_values = ast_function.children.map {|child| child.value(context)}
         call(context, *argument_values).value(context)
       end
 
       def evaluate(ast_function, context = nil)
-        context ||= Keisan::Context.new
+        validate_arguments!(ast_function.children.count)
+        context ||= Context.new
 
         ast_function.instance_variable_set(
           :@children,
@@ -36,6 +39,7 @@ module Keisan
       end
 
       def simplify(ast_function, context = nil)
+        validate_arguments!(ast_function.children.count)
         context ||= Context.new
 
         ast_function.instance_variable_set(
@@ -43,7 +47,7 @@ module Keisan
           ast_function.children.map {|child| child.evaluate(context)}
         )
 
-        if ast_function.children.all? {|child| child.is_a?(Keisan::AST::ConstantLiteral)}
+        if ast_function.children.all? {|child| child.is_a?(AST::ConstantLiteral)}
           value(ast_function, context).to_node.simplify(context)
         else
           ast_function

data/lib/keisan/functions/rand.rb

@@ -3,6 +3,7 @@ module Keisan
     class Rand < ProcFunction
       def initialize
         @name = "rand"
+        @arity = ::Range.new(1,2)
       end
 
       # Single argument: integer in range [0, max)
@@ -14,7 +15,7 @@ module Keisan
         when 2
           context.random.rand(args.first...args.last)
         else
-          raise Keisan::Exceptions::InvalidFunctionError.new
+          raise Exceptions::InvalidFunctionError.new
         end
       end
     end

data/lib/keisan/functions/range.rb

@@ -0,0 +1,74 @@
+module Keisan
+  module Functions
+    class Range < Function
+      def initialize
+        super("range", ::Range.new(1,3))
+      end
+
+      def call(context, *args)
+        start, finish, shift = start_finish_shift_from_args(*args)
+
+        if shift == 1
+          start_finish_range(start, finish)
+        else
+          start_finish_shift_range(start, finish, shift)
+        end
+      end
+
+      def value(ast_function, context = nil)
+        validate_arguments!(ast_function.children.count)
+        evaluate(ast_function, context)
+      end
+
+      def evaluate(ast_function, context = nil)
+        validate_arguments!(ast_function.children.count)
+        context ||= Keisan::Context.new
+        simplify(ast_function, context)
+      end
+
+      def simplify(ast_function, context = nil)
+        validate_arguments!(ast_function.children.count)
+        context ||= Context.new
+
+        simplified_children = ast_function.children.map {|child| child.simplify(context)}
+
+        if simplified_children.all? {|child| child.is_a?(Keisan::AST::Number)}
+          Keisan::AST::List.new(call(context, *simplified_children.map(&:value)))
+        else
+          Keisan::AST::Function.new(simplified_children, "range")
+        end
+      end
+
+      private
+
+      def start_finish_shift_from_args(*args)
+        case args.count
+        when 1
+          [0, args[0], 1]
+        when 2
+          [args[0], args[1], 1]
+        when 3
+          [args[0], args[1], args[2]]
+        else
+          [0, 0, 0]
+        end
+      end
+
+      def start_finish_range(start, finish)
+        (start...finish).to_a
+      end
+
+      def start_finish_shift_range(start, finish, shift)
+        if shift == 0 or !shift.is_a?(Integer)
+          raise Keisan::Exceptions::InvalidFunctionError.new("shift argument for Range must be non-zero integer")
+        end
+
+        if shift > 0
+          (start...finish).select {|i| (i - start) % shift == 0}
+        else
+          (finish+1...start+1).select {|i| (i - finish) % shift == 0}.reverse
+        end
+      end
+    end
+  end
+end

data/lib/keisan/functions/reduce.rb

@@ -1,15 +1,15 @@
 module Keisan
   module Functions
-    class Reduce < Keisan::Function
+    class Reduce < Function
       # Reduces (list, initial, accumulator, variable, expression)
       # e.g. reduce([1,2,3,4], 0, total, x, total+x)
       # should give 10
       def initialize
-        @name = "reduce"
+        super("reduce", 5)
       end
 
       def value(ast_function, context = nil)
-        evaluate(ast_function, context = nil)
+        evaluate(ast_function, context)
       end
 
       def evaluate(ast_function, context = nil)
@@ -18,7 +18,9 @@ module Keisan
       end
 
       def simplify(ast_function, context = nil)
-        context ||= Keisan::Context.new
+        validate_arguments!(ast_function.children.count)
+
+        context ||= Context.new
         list, initial, accumulator, variable, expression = list_initial_accumulator_variable_expression_for(ast_function, context)
 
         local = context.spawn_child(transient: false, shadowed: [accumulator.name, variable.name])
@@ -36,26 +38,22 @@ module Keisan
       private
 
       def list_initial_accumulator_variable_expression_for(ast_function, context)
-        unless ast_function.children.size == 5
-          raise Keisan::Exceptions::InvalidFunctionError.new("Require 5 arguments to reduce")
-        end
-
         list = ast_function.children[0].simplify(context)
         initial = ast_function.children[1]
         accumulator = ast_function.children[2]
         variable = ast_function.children[3]
         expression = ast_function.children[4]
 
-        unless list.is_a?(Keisan::AST::List)
-          raise Keisan::Exceptions::InvalidFunctionError.new("First argument to reduce must be a list")
+        unless list.is_a?(AST::List)
+          raise Exceptions::InvalidFunctionError.new("First argument to reduce must be a list")
         end
 
-        unless accumulator.is_a?(Keisan::AST::Variable)
-          raise Keisan::Exceptions::InvalidFunctionError.new("Third argument to reduce is accumulator and must be a variable")
+        unless accumulator.is_a?(AST::Variable)
+          raise Exceptions::InvalidFunctionError.new("Third argument to reduce is accumulator and must be a variable")
         end
 
-        unless variable.is_a?(Keisan::AST::Variable)
-          raise Keisan::Exceptions::InvalidFunctionError.new("Fourth argument to reduce is variable and must be a variable")
+        unless variable.is_a?(AST::Variable)
+          raise Exceptions::InvalidFunctionError.new("Fourth argument to reduce is variable and must be a variable")
         end
 
         [list, initial, accumulator, variable, expression]