keisan 0.1.0

data/lib/keisan/ast/number.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module AST
+    class Number < Literal
+      attr_reader :number
+
+      def initialize(number)
+        @number = number
+      end
+
+      def value(context = nil)
+        number
+      end
+    end
+  end
+end

data/lib/keisan/ast/operator.rb

@@ -0,0 +1,50 @@
+module Keisan
+  module AST
+    class Operator < Parent
+      def initialize(children = [], parsing_operators = [])
+        unless children.count == parsing_operators.count + 1
+          raise Keisan::Exceptions::ASTError.new("Mismatch of children and operators")
+        end
+
+        unless arity.include?(children.count)
+          raise Keisan::Exceptions::ASTError.new("Invalid number of arguments")
+        end
+
+        children = Array.wrap(children)
+        super(children)
+
+        @parsing_operators = parsing_operators
+      end
+
+
+      def arity
+        raise Keisan::Exceptions::NotImplementedError.new
+      end
+
+      def associativity
+        raise Keisan::Exceptions::NotImplementedError.new
+      end
+
+      def symbol
+        raise Keisan::Exceptions::NotImplementedError.new
+      end
+
+      def blank_value
+        raise Keisan::Exceptions::NotImplementedError.new
+      end
+
+      def value(context = nil)
+        args = children
+        args = args.reverse if associativity == :right
+
+        args.inject(blank_value) do |result, child|
+          if associativity == :left
+            result.send(symbol, child.value(context))
+          else
+            child.value(context).send(symbol, result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/keisan/ast/parent.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module AST
+    class Parent < Node
+      attr_reader :children
+
+      def initialize(children = [])
+        children = Array.wrap(children)
+        unless children.is_a?(Array) && children.all? {|children| children.is_a?(Node)}
+          raise Keisan::Exceptions::InternalError.new
+        end
+        @children = children
+      end
+    end
+  end
+end

data/lib/keisan/ast/plus.rb

@@ -0,0 +1,49 @@
+module Keisan
+  module AST
+    class Plus < ArithmeticOperator
+      def initialize(children = [], parsing_operators = [])
+        super
+        convert_minus_to_plus!
+      end
+
+      def self.priority
+        10
+      end
+
+      def arity
+        2..Float::INFINITY
+      end
+
+      def symbol
+        :+
+      end
+
+      def blank_value
+        0
+      end
+
+      def value(context = nil)
+        children_values = children.map {|child| child.value(context)}
+        # Special case of string concatenation
+        if children_values.all? {|child| child.is_a?(::String)}
+          children_values.join
+        # Special case of array concatenation
+        elsif children_values.all? {|child| child.is_a?(::Array)}
+          children_values.inject([], &:+)
+        else
+          children_values.inject(0, &:+)
+        end
+      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])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/keisan/ast/string.rb

@@ -0,0 +1,15 @@
+module Keisan
+  module AST
+    class String < Literal
+      attr_reader :content
+
+      def initialize(content)
+        @content = content
+      end
+
+      def value(context = nil)
+        content
+      end
+    end
+  end
+end

data/lib/keisan/ast/times.rb

@@ -0,0 +1,36 @@
+module Keisan
+  module AST
+    class Times < ArithmeticOperator
+      def initialize(children = [], parsing_operators = [])
+        super
+        convert_divide_to_inverse!
+      end
+
+      def self.priority
+        20
+      end
+
+      def arity
+        2..Float::INFINITY
+      end
+
+      def symbol
+        :*
+      end
+
+      def blank_value
+        1
+      end
+
+      private
+
+      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])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/keisan/ast/unary_bitwise_not.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module AST
+    class UnaryBitwiseNot < UnaryOperator
+      def value(context = nil)
+        return ~children.first.value(context)
+      end
+    end
+  end
+end

data/lib/keisan/ast/unary_identity.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module AST
+    class UnaryIdentity < UnaryOperator
+      def value(context = nil)
+        return children.first.value(context)
+      end
+    end
+  end
+end

data/lib/keisan/ast/unary_inverse.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module AST
+    class UnaryInverse < UnaryOperator
+      def value(context = nil)
+        return Rational(1, children.first.value(context))
+      end
+    end
+  end
+end

data/lib/keisan/ast/unary_logical_not.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module AST
+    class UnaryLogicalNot < UnaryOperator
+      def value(context = nil)
+        return !children.first.value(context)
+      end
+    end
+  end
+end

data/lib/keisan/ast/unary_minus.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module AST
+    class UnaryMinus < UnaryOperator
+      def value(context = nil)
+        return -1 * children.first.value(context)
+      end
+    end
+  end
+end

data/lib/keisan/ast/unary_operator.rb

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

data/lib/keisan/ast/unary_plus.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module AST
+    class UnaryPlus < UnaryOperator
+      def value(context = nil)
+        return children.first.value(context)
+      end
+    end
+  end
+end

data/lib/keisan/ast/variable.rb

@@ -0,0 +1,16 @@
+module Keisan
+  module AST
+    class Variable < Literal
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def value(context = nil)
+        context = Keisan::Context.new if context.nil?
+        context.variable(name)
+      end
+    end
+  end
+end

data/lib/keisan/calculator.rb

@@ -0,0 +1,30 @@
+module Keisan
+  class Calculator
+    attr_reader :context
+
+    def initialize(context = nil)
+      @context = context || Context.new
+    end
+
+    def evaluate(expression, definitions = {})
+      local_context = context.spawn_child
+      definitions.each do |name, value|
+        case value
+        when Proc
+          local_context.register_function!(name, value)
+        else
+          local_context.register_variable!(name, value)
+        end
+      end
+      Keisan::AST::Builder.new(string: expression).ast.value(local_context)
+    end
+
+    def define_variable!(name, value)
+      context.register_variable!(name, value)
+    end
+
+    def define_function!(name, function)
+      context.register_function!(name, function)
+    end
+  end
+end

data/lib/keisan/context.rb

@@ -0,0 +1,36 @@
+module Keisan
+  class Context
+    attr_reader :function_registry, :variable_registry
+
+    def initialize(parent: nil, random: nil)
+      @parent = parent
+      @function_registry = Functions::Registry.new(parent: @parent.try(:function_registry))
+      @variable_registry = Variables::Registry.new(parent: @parent.try(:variable_registry))
+      @random            = random
+    end
+
+    def spawn_child
+      self.class.new(parent: self)
+    end
+
+    def function(name)
+      @function_registry[name.to_s]
+    end
+
+    def register_function!(name, function)
+      @function_registry.register!(name.to_s, function)
+    end
+
+    def variable(name)
+      @variable_registry[name.to_s]
+    end
+
+    def register_variable!(name, value)
+      @variable_registry.register!(name.to_s, value)
+    end
+
+    def random
+      @random || @parent.try(:random) || Random.new
+    end
+  end
+end

data/lib/keisan/exceptions.rb

@@ -0,0 +1,19 @@
+module Keisan
+  module Exceptions
+    class BaseError < ::StandardError; end
+
+    class InternalError < BaseError; end
+    class StandardError < BaseError; end
+
+    class NotImplementedError < InternalError; end
+
+    class InvalidToken < StandardError; end
+    class TokenizingError < StandardError; end
+    class ParseError < StandardError; end
+    class ASTError < StandardError; end
+    class InvalidFunctionError < StandardError; end
+    class UndefinedFunctionError < StandardError; end
+    class UndefinedVariableError < StandardError; end
+    class UnmodifiableError < StandardError; end
+  end
+end

data/lib/keisan/function.rb

@@ -0,0 +1,15 @@
+module Keisan
+  class Function
+    attr_reader :name
+
+    def initialize(name, function_proc)
+      raise Keisan::Exceptions::InvalidFunctionError.new unless function_proc.is_a?(Proc)
+      @name = name
+      @function_proc = function_proc
+    end
+
+    def call(context, *args)
+      @function_proc.call(*args)
+    end
+  end
+end

data/lib/keisan/functions/default_registry.rb

@@ -0,0 +1,58 @@
+require_relative "rand"
+require_relative "sample"
+
+module Keisan
+  module Functions
+    class DefaultRegistry
+      def self.registry
+        @registry ||= Registry.new.tap do |r|
+          register_defaults!(r)
+        end.freeze
+      end
+
+      private
+
+      def self.register_defaults!(registry)
+        register_builtin_math!(registry)
+        register_branch_methods!(registry)
+        register_array_methods!(registry)
+        register_random_methods!(registry)
+      end
+
+      def self.register_builtin_math!(registry)
+        Math.methods(false).each do |method|
+          registry.register!(
+            method,
+            Proc.new do |*args|
+              Math.send(method, *args)
+            end
+          )
+        end
+
+        %i(exp sin cos).each do |method|
+          registry.register!(
+            :"c#{method}",
+            Proc.new do |z|
+              CMath.send(method, z)
+            end
+          )
+        end
+      end
+
+      def self.register_branch_methods!(registry)
+        registry.register!(:if, Proc.new {|bool, a, b=nil| bool ? a : b })
+      end
+
+      def self.register_array_methods!(registry)
+        %i(min max size).each do |method|
+          registry.register!(method, Proc.new {|a| a.send(method)})
+        end
+      end
+
+      def self.register_random_methods!(registry)
+        registry.register!(:rand, Keisan::Functions::Rand.new)
+        registry.register!(:sample, Keisan::Functions::Sample.new)
+      end
+    end
+  end
+end