keisan 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca29cf77de26f26d32436c705ad47f229e215c43
-  data.tar.gz: cedc1ffcca1d1a46fbca4cee21750f2398c84ee5
+  metadata.gz: 32b53dd19dc29bced6d98d110f7d11c0a7d22ea5
+  data.tar.gz: d55ec179a6f8b1e597cb322e42bab4ed0b959fed
 SHA512:
-  metadata.gz: fae0c6a0db729b392ea89440dc0b4dff033a9f0e7159f725ba7bcaa0b3e16861c1aebfec2d2cdcfc5cde719aee995caabfb7fafa865797732a8db6c4b184ced7
-  data.tar.gz: 02257ba4395e73e2950ff09eefa272cdd49e1299f4bcec5a558c73e3a87147a3e09b4cde59bc4fa1ab935d801d88e9282dc4cea97e53b497cb94155154c23fd8
+  metadata.gz: a4c87fabd551121df563306488410003e9291b1569330ca3da65d833b9e9e97f925dcbc3d07e23cb9c5e05272b8fe74028766388064e0713ff66d625261a5752
+  data.tar.gz: cdfef6449002d021fe83b10457959e5d1bccf81aa569be908e6ba98026f0adc2df44eeb3a60b6d013126e6d278992cd8a50b4c397c11460656a33574f0234ad7

data/README.md

@@ -112,9 +112,14 @@ calculator.evaluate("n") # n only exists in the definition of f(x)
 #=> Keisan::Exceptions::UndefinedVariableError: n
 ```
 
-This form even supports recursion!
+This form even supports recursion, but you must explicitly allow it.
 
 ```ruby
+calculator = Keisan::Calculator.new(allow_recursive: false)
+calculator.evaluate("my_fact(n) = if (n > 1, n*my_fact(n-1), 1)")
+#=> Keisan::Exceptions::InvalidExpression: Unbound function definitions are not allowed by current context
+
+calculator = Keisan::Calculator.new(allow_recursive: true)
 calculator.evaluate("my_fact(n) = if (n > 1, n*my_fact(n-1), 1)")
 calculator.evaluate("my_fact(0)")
 #=> 1
@@ -190,7 +195,7 @@ Using the prefixes `0b`, `0o`, and `0x` (standard in Ruby) indicates binary, oct
 calculator.evaluate("0b1100")
 #=> 12
 calculator.evaluate("0o775")
-#=> 504
+#=> 509
 calculator.evaluate("0x1f0")
 #=> 496
 ```
@@ -209,8 +214,8 @@ calculator.evaluate("sample([2, 4, 6, 8])")
 If you want reproducibility, you can pass in your own `Random` object to the calculator's context.
 
 ```ruby
-calculator1 = Keisan::Calculator.new(Keisan::Context.new(random: Random.new(1234)))
-calculator2 = Keisan::Calculator.new(Keisan::Context.new(random: Random.new(1234)))
+calculator1 = Keisan::Calculator.new(context: Keisan::Context.new(random: Random.new(1234)))
+calculator2 = Keisan::Calculator.new(context: Keisan::Context.new(random: Random.new(1234)))
 5.times.map {calculator1.evaluate("rand(1000)")}
 #=> [815, 723, 294, 53, 204]
 5.times.map {calculator2.evaluate("rand(1000)")}
@@ -229,24 +234,48 @@ calculator.evaluate("log10(1000)")
 Furthermore, the following builtin constants are defined
 
 ```ruby
-calculator.evaluate("pi")
+calculator.evaluate("PI")
 #=> 3.141592653589793
-calculator.evaluate("e")
+calculator.evaluate("E")
 #=> 2.718281828459045
-calculator.evaluate("i")
+calculator.evaluate("I")
 #=> (0+1i)
 ```
 
 This allows for simple calculations like
 
 ```ruby
-calculator.evaluate("e**(i*pi)+1")
+calculator.evaluate("E**(I*PI)+1")
 => (0.0+0.0i)
 ```
 
+There is a `replace` method that can replace instances of a variable in an expression with another expression.  The form is `replace(original_expression, variable_to_replace, replacement_expression)`.  Before the replacement is carried out, the `original_expression` and `replacement_expression` are `evaluate`d, then instances in the original expression of the given variable are replaced by the replacement expression.
+
+```ruby
+calculator.evaluate("replace(x**2, x, 3)")
+#=> 9
+```
+
+When using `Calculator` class, all variables must be replaced before an expression can be calculated, but the ability to replace any expression is useful when working directly with the AST.
+
+```ruby
+ast = Keisan::AST.parse("replace(replace(x**2 + y**2, x, sin(theta)), y, cos(theta))")
+ast.evaluate.to_s
+#=> "(sin(theta)**2)+(cos(theta)**2)"
+```
+
+The derivative operation is also builtin to Keisan as the `diff` function.
+
+```ruby
+calculator = Keisan::Calculator.new
+calculator.evaluate("diff(4*x, x)")
+calculator.evaluate("replace(diff(4*x**2, x), x, 3)")
+#=> 24
+```
+
 ### Adding custom variables and functions
 
-The `Keisan::Calculator` class has a single `Keisan::Context` object in its `context` attribute.  This class is used to store local variables and functions.  As an example of pre-defining some variables and functions, see the following
+The `Keisan::Calculator` class has a single `Keisan::Context` object in its `context` attribute.  This class is used to store local variables and functions.  These can be stored using either the `define_variable!` or `define_function!` methods, or by using the assignment operator `=` in an expression that is evaluated.  As an example of pre-defining some variables and functions, see the following
 
 ```ruby
 calculator.define_variable!("x", 5)
@@ -257,11 +286,21 @@ calculator.evaluate("x + 1", x: 10)
 #=> 11
 calculator.evaluate("x + 1")
 #=> 6
+
+calculator.evaluate("x = y = 10")
+#=> 10
+calculator.evaluate("x + y")
+#=> 20
+calculator.evaluate("x + y", y: 100)
+#=> 110
+calculator.evaluate("x + y")
+#=> 20
 ```
 
 Notice how when passing variable values directly to the `evaluate` method, it only shadows the value of 5 for that specific calculation.  The same thing works for functions
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.define_function!("f", Proc.new {|x| 3*x})
 #=> #<Keisan::Function:0x005570f935ecc8 @function_proc=#<Proc:0x005570f935ecf0@(pry):6>, @name="f">
 calculator.evaluate("f(2)")
@@ -270,6 +309,15 @@ calculator.evaluate("f(2)", f: Proc.new {|x| 10*x})
 #=> 20
 calculator.evaluate("f(2)")
 #=> 6
+
+calculator.evaluate("f(x) = x + x**2")
+#=> nil
+calculator.evaluate("f(3)")
+#=> 12
+calculator.evaluate("f(3)", f: Proc.new {|x| 10*x})
+#=> 30
+calculator.evaluate("f(3)")
+#=> 12
 ```
 
 ## Supported elements/operators

data/lib/keisan.rb

@@ -4,32 +4,26 @@ require "active_support/core_ext"
 require "keisan/version"
 require "keisan/exceptions"
 
-require "keisan/function"
-require "keisan/functions/registry"
-require "keisan/functions/default_registry"
-require "keisan/variables/registry"
-require "keisan/variables/default_registry"
-require "keisan/context"
-
-require "keisan/ast/priorities"
 require "keisan/ast/node"
 
 require "keisan/ast/literal"
+require "keisan/ast/variable"
+require "keisan/ast/constant_literal"
 require "keisan/ast/number"
 require "keisan/ast/string"
 require "keisan/ast/null"
 require "keisan/ast/boolean"
-require "keisan/ast/variable"
 
 require "keisan/ast/parent"
+require "keisan/ast/operator"
+require "keisan/ast/assignment"
 require "keisan/ast/unary_operator"
+require "keisan/ast/unary_identity"
 require "keisan/ast/unary_plus"
 require "keisan/ast/unary_minus"
 require "keisan/ast/unary_inverse"
 require "keisan/ast/unary_bitwise_not"
 require "keisan/ast/unary_logical_not"
-require "keisan/ast/unary_identity"
-require "keisan/ast/operator"
 require "keisan/ast/arithmetic_operator"
 require "keisan/ast/plus"
 require "keisan/ast/times"
@@ -54,6 +48,17 @@ require "keisan/ast/list"
 require "keisan/ast/indexing"
 
 require "keisan/ast/builder"
+require "keisan/ast"
+
+require "keisan/function"
+require "keisan/functions/proc_function"
+require "keisan/functions/expression_function"
+require "keisan/functions/registry"
+require "keisan/functions/default_registry"
+require "keisan/variables/registry"
+require "keisan/variables/default_registry"
+require "keisan/context"
+require "keisan/function_definition_context"
 
 require "keisan/token"
 require "keisan/tokens/comma"
@@ -64,6 +69,7 @@ require "keisan/tokens/operator"
 require "keisan/tokens/string"
 require "keisan/tokens/null"
 require "keisan/tokens/boolean"
+require "keisan/tokens/assignment"
 require "keisan/tokens/arithmetic_operator"
 require "keisan/tokens/logical_operator"
 require "keisan/tokens/bitwise_operator"
@@ -90,11 +96,14 @@ require "keisan/parsing/list"
 require "keisan/parsing/indexing"
 require "keisan/parsing/argument"
 
+require "keisan/parsing/operator"
+
+require "keisan/parsing/assignment"
+
 require "keisan/parsing/unary_operator"
 require "keisan/parsing/unary_plus"
 require "keisan/parsing/unary_minus"
 
-require "keisan/parsing/operator"
 require "keisan/parsing/arithmetic_operator"
 require "keisan/parsing/plus"
 require "keisan/parsing/minus"

data/lib/keisan/ast.rb

@@ -0,0 +1,50 @@
+module Keisan
+  module AST
+    def self.parse(expression)
+      AST::Builder.new(string: expression).ast
+    end
+  end
+end
+
+module KeisanNumeric
+  def to_node
+    Keisan::AST::Number.new(self)
+  end
+end
+
+module KeisanString
+  def to_node
+    Keisan::AST::String.new(self)
+  end
+end
+
+module KeisanTrueClass
+  def to_node
+    Keisan::AST::Boolean.new(true)
+  end
+end
+
+module KeisanFalseClass
+  def to_node
+    Keisan::AST::Boolean.new(false)
+  end
+end
+
+module KeisanNilClass
+  def to_node
+    Keisan::AST::Null.new
+  end
+end
+
+module KeisanArray
+  def to_node
+    Keisan::AST::List.new(map {|n| n.to_node})
+  end
+end
+
+class Numeric; prepend KeisanNumeric; end
+class String; prepend KeisanString; end
+class TrueClass; prepend KeisanTrueClass; end
+class FalseClass; prepend KeisanFalseClass; end
+class NilClass; prepend KeisanNilClass; end
+class Array; prepend KeisanArray; end

data/lib/keisan/ast/arithmetic_operator.rb

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

data/lib/keisan/ast/assignment.rb

@@ -0,0 +1,72 @@
+module Keisan
+  module AST
+    class Assignment < Operator
+      def self.symbol
+        :"="
+      end
+
+      def evaluate(context = nil)
+        context ||= Keisan::Context.new
+
+        lhs = children.first
+        rhs = children.last
+
+        case lhs
+        when Keisan::AST::Variable
+          evaluate_variable(context, lhs, rhs)
+        when Keisan::AST::Function
+          evaluate_function(context, lhs, rhs)
+        else
+          raise Keisan::Exceptions::InvalidExpression.new("Unhandled left hand side #{lhs} in assignment")
+        end
+      end
+
+      private
+
+      def evaluate_variable(context, lhs, rhs)
+        rhs = rhs.evaluate(context)
+
+        unless rhs.well_defined?
+          raise Keisan::Exceptions::InvalidExpression.new("Right hand side of assignment to variable must be well defined")
+        end
+
+        rhs_value = rhs.value(context)
+        context.register_variable!(lhs.name, rhs_value)
+        rhs
+      end
+
+      def evaluate_function(context, lhs, rhs)
+        unless lhs.children.all? {|arg| arg.is_a?(Keisan::AST::Variable)}
+          raise Keisan::Exceptions::InvalidExpression.new("Left hand side function must have variables as arguments")
+        end
+
+        argument_names = lhs.children.map(&:name)
+        function_definition_context = Keisan::FunctionDefinitionContext.new(
+          parent: context,
+          arguments: argument_names
+        )
+        rhs = rhs.evaluate(function_definition_context)
+
+        unless rhs.unbound_variables(context) <= Set.new(argument_names)
+          raise Keisan::Exceptions::InvalidExpression.new("Unbound variables found in function definition")
+        end
+
+        unless context.allow_recursive || rhs.unbound_functions(context).empty?
+          raise Keisan::Exceptions::InvalidExpression.new("Unbound function definitions are not allowed by current context")
+        end
+
+        context.register_function!(
+          lhs.name,
+          Keisan::Functions::ExpressionFunction.new(
+            lhs.name,
+            argument_names,
+            rhs,
+            function_definition_context
+          )
+        )
+
+        rhs
+      end
+    end
+  end
+end

data/lib/keisan/ast/bitwise_and.rb

@@ -1,10 +1,6 @@
 module Keisan
   module AST
     class BitwiseAnd < BitwiseOperator
-      def arity
-        2..Float::INFINITY
-      end
-
       def self.symbol
         :"&"
       end
@@ -12,6 +8,10 @@ module Keisan
       def blank_value
         ~0
       end
+
+      def evaluate(context = nil)
+        children[1..-1].inject(children.first.evaluate(context)) {|total, child| total & child.evaluate(context)}
+      end
     end
   end
 end

data/lib/keisan/ast/bitwise_operator.rb

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

data/lib/keisan/ast/bitwise_or.rb

@@ -1,10 +1,6 @@
 module Keisan
   module AST
     class BitwiseOr < BitwiseOperator
-      def arity
-        2..Float::INFINITY
-      end
-
       def self.symbol
         :"|"
       end
@@ -12,6 +8,10 @@ module Keisan
       def blank_value
         0
       end
+
+      def evaluate(context = nil)
+        children[1..-1].inject(children.first.evaluate(context)) {|total, child| total | child.evaluate(context)}
+      end
     end
   end
 end

data/lib/keisan/ast/bitwise_xor.rb

@@ -1,10 +1,6 @@
 module Keisan
   module AST
     class BitwiseXor < BitwiseOperator
-      def arity
-        2..Float::INFINITY
-      end
-
       def self.symbol
         :"^"
       end
@@ -12,6 +8,10 @@ module Keisan
       def blank_value
         0
       end
+
+      def evaluate(context = nil)
+        children[1..-1].inject(children.first.evaluate(context)) {|total, child| total ^ child.evaluate(context)}
+      end
     end
   end
 end

data/lib/keisan/ast/boolean.rb

@@ -1,6 +1,6 @@
 module Keisan
   module AST
-    class Boolean < Literal
+    class Boolean < ConstantLiteral
       attr_reader :bool
 
       def initialize(bool)
@@ -10,6 +10,30 @@ module Keisan
       def value(context = nil)
         bool
       end
+
+      def !
+        AST::Boolean.new(!bool)
+      end
+
+      def and(other)
+        other = other.to_node
+        case other
+        when AST::Boolean
+          AST::Boolean.new(bool && other.bool)
+        else
+          super
+        end
+      end
+
+      def or(other)
+        other = other.to_node
+        case other
+        when AST::Boolean
+          AST::Boolean.new(bool || other.bool)
+        else
+          super
+        end
+      end
     end
   end
 end