lispcalc 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c7c0fed477b8bf5d13cef8946c4353f8471bed74f64411807276e5a33e8732d
-  data.tar.gz: 31d87e2d4881eed6a31d49a3052a9a5b1596522fb3efad0b8747e47a694fa2fe
+  metadata.gz: 356131522cd6dc5260a05d28d7f9777c99ddc9de820905a2efef5e47100f6bfe
+  data.tar.gz: 6c89731d470c30587d9fd46532d8ab45d43b764e33114df65d3a78adebefe1f2
 SHA512:
-  metadata.gz: 2055e5a74b6f446ec0aa4014d1db932518c87a9627b071f3ba114054c7d3adf34e2396a64293bbe557a47707437dd0e9821c0c38e3b6696b5c892c3fde572a2d
-  data.tar.gz: 2c3a80ab4b3274ca13d4f33d0e1fdeea50f5afc4e23c4fd57e47b6d171ed66b50808b60a4e8a9b9a1acd47c09fb2c46a1ac2a1d9b63995935cf1e1cd53493b37
+  metadata.gz: fe40bc59263dd45e64c724b5fa7cd3c1254ce436c8dbdbfd1f2fa66f3b508e7a2d9baef0c04bf4862f92c075e1bfacde45c9c2c12877e05d7e4c66b7f1ae244d
+  data.tar.gz: 62763e99f31d08b1f7e61ffecf0b7ef89e8211ab1bcd890a25178ce8ff70f296080890913dfc90731f9d9762dc8edaa35be3440274b5dd1a3595355806f794dc

data/README.md

@@ -42,9 +42,11 @@ irb(main):012>       (/ x y)))').to_s('F')
 - [x] **Constants**: There are 2 available constants: `pi` and `e`, which hold the values of the corresponding mathematical constants. Unlike variables, you cannot change the value of a constant.
 - [x] **Sequencing** (`(do expr1 expr2 ...)`): Evaluate each expression from left to right, returning the final value.
 - [x] **Arithmetic operations** (`+`, `-`, `*`, `/`)
-- [ ] **Powers, roots and logarithms** (`^`, `^2`, `sqrt`, `log`, `log2`, `log10`, `ln`)
-- [ ] **Trigonometric functions** (`sin`, `cos`, `tan`, etc.)
-- [ ] **Thread macros** (`->`, `->>`)
+- [x] **Powers** (`^`, `sq`)
+- [x] **Roots** (`sqrt`, `cbrt`)
+- [x] **Logarithms** (`log`, `log2`, `log10`, `ln`)
+- [x] **Trigonometric functions** (`sin`, `cos`, `tan`, `asin`, `acos`, `atan`)
+- [ ] **Clojure-style thread macros** (`->`, `->>`) ??
 
 ## Why?
 

data/lib/lispcalc/functions.rb

@@ -20,24 +20,88 @@ module Lispcalc
       arithmetic_op(:/, args)
     end
 
-    def do(*args)
-      args.last unless args.empty?
+    def ^(base, index)
+      resolve_symbol(base).to_d ** resolve_symbol(index).to_d
     end
 
-    private
+    def sq(x)
+      resolve_symbol(x).to_d ** 2.to_d
+    end
 
-    def arithmetic_op(op, args)
-      raise ArgumentError, "expecting at least 2 arguments, receiving #{args.size}" unless args.size >= 2
-      raise ArgumentError, 'expecting all arguments to be BigDecimal' unless args.all?(BigDecimal)
+    def sqrt(x)
+      Math.sqrt(resolve_symbol(x)).to_d
+    end
+
+    def cbrt(x)
+      Math.cbrt(resolve_symbol(x)).to_d
+    end
+
+    def log(base, x)
+      Math.log(resolve_symbol(x), resolve_symbol(base)).to_d
+    end
+
+    def log10(x)
+      Math.log10(resolve_symbol(x)).to_d
+    end
+
+    def log2(x)
+      Math.log2(resolve_symbol(x)).to_d
+    end
+
+    def ln(x)
+      log(Math::E, x)
+    end
+
+    def sin(x)
+      Math.sin(resolve_symbol(x)).to_d
+    end
+
+    def cos(x)
+      Math.cos(resolve_symbol(x)).to_d
+    end
+
+    def tan(x)
+      Math.tan(resolve_symbol(x)).to_d
+    end
+
+    def asin(x)
+      Math.asin(resolve_symbol(x)).to_d
+    end
 
-      args.inject(op)
+    def acos(x)
+      Math.acos(resolve_symbol(x)).to_d
+    end
+
+    def atan(x)
+      Math.atan(resolve_symbol(x)).to_d
+    end
+
+    def do(*args)
+      resolve_symbol(args.last).to_d unless args.empty?
     end
 
-    def set_var(name, value)
+    def set(name, value)
       raise ContextError, "trying to change the value of the constant '#{name}'" if @ctx.const?(name)
       raise ContextError, "undefined variable '#{name}'" unless @ctx.var?(name)
 
-      @ctx[name] = value
+      @ctx[name] = resolve_symbol(value).to_d
+    end
+
+    private
+
+    # TODO: raise exception if symbol is not found in context
+    def resolve_symbol(x)
+      if x.instance_of?(Symbol)
+        @ctx[x]
+      else
+        x
+      end
+    end
+
+    def arithmetic_op(op, args)
+      raise ArgumentError, "expecting at least 2 arguments, receiving #{args.size}" unless args.size >= 2
+
+      args.map { |x| resolve_symbol(x).to_d }.inject(op)
     end
   end
 end

data/lib/lispcalc/interpreter.rb

@@ -8,6 +8,17 @@ module Lispcalc
       @functions = Functions.new(ctx)
     end
 
+    def eval(form)
+      case form
+      when Array
+        eval_list(form)
+      when Symbol, BigDecimal
+        form
+      else
+        raise UnknownFormError
+      end
+    end
+
     def eval_list(list)
       raise ArgumentError, 'expecting an instance of Array' unless list.instance_of?(Array)
       raise SyntaxError, 'empty list' if list.empty?
@@ -15,35 +26,14 @@ module Lispcalc
       fn, *args = list
       raise SyntaxError, 'the first element of a list must be a symbol' unless fn.instance_of?(Symbol)
 
-      call(fn, eval_args(args))
-    end
-
-    alias eval eval_list
-
-    def eval_symbol(symbol)
-      @ctx[symbol] || symbol
+      call(fn, args.map { |arg| eval(arg) })
     end
 
     private
 
-    def eval_args(args)
-      args.map do |arg|
-        case arg
-        when Array
-          eval_list(arg)
-        when Symbol
-          eval_symbol(arg)
-        when BigDecimal
-          arg
-        else
-          raise UnknownFormError
-        end
-      end
-    end
-
     def call(fn, args)
       if fn =~ />(.+)/
-        @functions.send(:set_var, Regexp.last_match(1).to_sym, *args)
+        @functions.set(Regexp.last_match(1).to_sym, *args)
       elsif Functions.public_method_defined?(fn, false)
         @functions.send(fn, *args)
       else

data/lib/lispcalc/lexer.rb

@@ -4,7 +4,7 @@ module Lispcalc
     OPEN_PAREN = /\A\(/.freeze
     CLOSE_PAREN = /\A\)/.freeze
     NUMBER = /\A[+-]?([0-9]*[.])?[0-9]+/.freeze
-    SYMBOL = /\A[+\-*\/>a-zA-Z][+\-*\/>a-zA-Z0-9]*/.freeze # TODO: review this regexp
+    SYMBOL = /\A[+\-*\/>^a-zA-Z][+\-*\/>a-zA-Z0-9]*/.freeze # TODO: review this regexp
 
     def initialize(input)
       @input = input

data/lib/lispcalc/version.rb

@@ -1,3 +1,3 @@
 module Lispcalc
-  VERSION = '0.1.1'.freeze
+  VERSION = '0.2.1'.freeze
 end

data/lib/lispcalc.rb

@@ -12,7 +12,7 @@ module Lispcalc
     def eval(input, ctx = Context.new)
       tokens = Lexer.tokenize(input)
       forms = Parser.new(tokens).parse
-      Interpreter.new(ctx).eval(forms)
+      Interpreter.new(ctx).eval_list(forms)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lispcalc
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Vicente Romero
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-23 00:00:00.000000000 Z
+date: 2025-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal