lispcalc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d3bd15513f21262b90e05be035fae2c65f644001a5835f1840fc251387b46d68
+  data.tar.gz: c52f032e782db695565b123f116a868ba55be7a63ba5e258305384474ebdc0e4
+SHA512:
+  metadata.gz: 1bee5e657f2c7df3aa39c3cf1437d0287ea3340065ef44bdeb8bb02dc4a456f23bd6cbc25bcdcec52559ede2e6c8e8a1c5710e3627a05b2a01f4af2e75f2605a
+  data.tar.gz: c0cf4e79008462a3720997f658f11202c63243f3155b1dac103db24785d4324bc357af5212f15fc2865ed8f713171452bc1ecc6725d92fb7b3d12efbd8a82dc7

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vicente Romero Calero
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,58 @@
+# Lispcalc
+
+A Lisp-like calculator interpreter written in Ruby.
+
+Inspired by [Clojure](https://clojure.org/) and my [Casio fx-85GT CW](https://www.casio.co.uk/fx-85gt-cw) calculator, this library provides an interpreter that allows you to perform mathematical calculations using Lisp syntax. It uses Ruby's `BigDecimal` for all calculations, so it supports very accurate floating point numbers.
+
+## Installation
+
+```sh
+gem install lispcalc
+```
+
+## Usage
+
+This library is intended to be used via the `eval` method.
+
+Here are some examples:
+
+```sh
+irb(main):001> require 'lispcalc'
+=> true
+irb(main):002> Lispcalc.eval('(+ 1 2 3)')
+=> 0.6e1
+irb(main):003> Lispcalc.eval('(+ 1 2 3)').to_s('F')
+=> "6.0"
+irb(main):004> Lispcalc.eval('(+ (* 2 3) (/ 2 3))').to_s('F')
+=> "6.666666666666666666666666666666666667"
+irb(main):005' Lispcalc.eval('
+irb(main):006'   (do
+irb(main):007'     (>x 100)
+irb(main):008'     (>y 200)
+irb(main):009'     (*
+irb(main):010'       (+ x y)
+irb(main):011'       (- x y)
+irb(main):012>       (/ x y)))').to_s('F')
+=> "-15000.0"
+```
+
+## Features
+
+- [x] **Variables**: As in the fx-85GT CW calculator, there are 9 variables available: `A`, `B`, `C`, `D`, `E`, `F`, `x`, `y` and `z`, all of them initialized to `0`. You can set any of these variables to a specific value. For example, `(>A 100)` will set the variable `A` to the value `100`. You can also reference a variable's value like this: `(+ A B)`.
+- [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** (`->`, `->>`)
+
+## Why?
+
+I created this library for two purposes:
+
+1. Learning more about compilers and interpreters, and how to implement them.
+2. Practising my rusty Ruby skills.
+
+## License
+
+This software is released under MIT license.

data/lib/lispcalc/context.rb

@@ -0,0 +1,60 @@
+module Lispcalc
+  class Context
+    def initialize(variables = nil, constants = nil)
+      @variables = variables.dup || default_variables
+      @constants = constants.dup || default_constants
+      @constants.freeze
+
+      unless @variables.values.all?(BigDecimal) && @constants.values.all?(BigDecimal)
+        raise ArgumentError, 'variables and constants must be BigDecimal'
+      end
+
+      # constant names override variable names
+      common_keys = @variables.keys.to_set & @constants.keys.to_set
+      common_keys.each do |key|
+        @variables.delete(key)
+      end
+    end
+
+    def [](key)
+      @variables[key] || @constants[key]
+    end
+
+    def []=(key, value)
+      return unless @variables.key?(key) && value.instance_of?(BigDecimal)
+
+      @variables[key] = value
+    end
+
+    def var?(name)
+      @variables.key?(name)
+    end
+
+    def const?(name)
+      @constants.key?(name)
+    end
+
+    private
+
+    def default_variables
+      {
+        A: 0.to_d,
+        B: 0.to_d,
+        C: 0.to_d,
+        D: 0.to_d,
+        E: 0.to_d,
+        F: 0.to_d,
+        x: 0.to_d,
+        y: 0.to_d,
+        z: 0.to_d
+      }
+    end
+
+    def default_constants
+      {
+        pi: Math::PI.to_d,
+        e: Math::E.to_d
+      }
+    end
+  end
+end

data/lib/lispcalc/errors.rb

@@ -0,0 +1,11 @@
+module Lispcalc
+  class UnknownTokenError < StandardError; end
+
+  class UnknownFormError < StandardError; end
+
+  class UnknownFunctionError < StandardError; end
+
+  class SyntaxError < StandardError; end
+
+  class ContextError < StandardError; end
+end

data/lib/lispcalc/functions.rb

@@ -0,0 +1,43 @@
+module Lispcalc
+  class Functions
+    def initialize(ctx)
+      @ctx = ctx
+    end
+
+    def +(*args)
+      arithmetic_op(:+, args)
+    end
+
+    def -(*args)
+      arithmetic_op(:-, args)
+    end
+
+    def *(*args)
+      arithmetic_op(:*, args)
+    end
+
+    def /(*args)
+      arithmetic_op(:/, args)
+    end
+
+    def do(*args)
+      args.last unless args.empty?
+    end
+
+    private
+
+    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)
+
+      args.inject(op)
+    end
+
+    def set_var(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
+    end
+  end
+end

data/lib/lispcalc/interpreter.rb

@@ -0,0 +1,54 @@
+require_relative 'context'
+require_relative 'functions'
+
+module Lispcalc
+  class Interpreter
+    def initialize(ctx = Context.new)
+      @ctx = ctx
+      @functions = Functions.new(ctx)
+    end
+
+    def eval_list(list)
+      raise ArgumentError, 'expecting an instance of Array' unless list.instance_of?(Array)
+      raise SyntaxError, 'empty list' if list.empty?
+
+      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
+    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)
+      elsif Functions.public_method_defined?(fn, false)
+        @functions.send(fn, *args)
+      else
+        raise UnknownFunctionError, "undefined function '#{fn}'"
+      end
+    end
+  end
+end

data/lib/lispcalc/lexer.rb

@@ -0,0 +1,55 @@
+module Lispcalc
+  class Lexer
+    WS = /\A\s+/.freeze
+    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
+
+    def initialize(input)
+      @input = input
+    end
+
+    def next_token
+      if @input =~ WS
+        advance(Regexp.last_match(0).length)
+      end
+
+      return nil if @input.empty?
+
+      case @input
+      when OPEN_PAREN
+        advance
+        [:open_paren]
+      when CLOSE_PAREN
+        advance
+        [:close_paren]
+      when NUMBER
+        number = Regexp.last_match(0)
+        advance(number.length)
+        [:number, number]
+      when SYMBOL
+        symbol = Regexp.last_match(0)
+        advance(symbol.length)
+        [:symbol, symbol]
+      else
+        raise UnknownTokenError
+      end
+    end
+
+    def self.tokenize(input)
+      tokens = []
+      lexer = Lexer.new(input)
+      while (token = lexer.next_token)
+        tokens << token
+      end
+      tokens
+    end
+
+    private
+
+    def advance(steps = 1)
+      @input = @input[steps..]
+    end
+  end
+end

data/lib/lispcalc/parser.rb

@@ -0,0 +1,68 @@
+module Lispcalc
+  class Parser
+    def initialize(tokens)
+      raise ArgumentError, 'expecting an Array' unless tokens.instance_of?(Array)
+      raise ArgumentError, 'invalid token' unless tokens.all? { |t| valid_token?(t) }
+
+      @tokens = tokens
+    end
+
+    def parse
+      output = parse_list
+      raise SyntaxError, 'expecting a single top-level list' unless @tokens.empty?
+
+      output
+    end
+
+    private
+
+    def valid_token?(token)
+      token.instance_of?(Array) &&
+        token[0].instance_of?(Symbol) &&
+        (token[1].nil? || token[1].instance_of?(String))
+    end
+
+    def peek
+      @tokens.first
+    end
+
+    def next_token
+      @tokens.shift
+    end
+
+    def parse_list
+      return nil if @tokens.empty?
+      raise SyntaxError, "expecting '('" unless next_token[0] == :open_paren
+
+      list = []
+
+      until @tokens.empty?
+        if peek[0] == :open_paren
+          list << parse_list
+        else
+          token = next_token
+          case token[0]
+          when :close_paren
+            return list
+          when :symbol
+            list << parse_symbol(token[1])
+          when :number
+            list << parse_number(token[1])
+          else
+            raise UnknownTokenError
+          end
+        end
+      end
+
+      raise SyntaxError, "unclosed list; expecting ')'"
+    end
+
+    def parse_symbol(str)
+      str.to_sym
+    end
+
+    def parse_number(str)
+      BigDecimal(str)
+    end
+  end
+end

data/lib/lispcalc/version.rb

@@ -0,0 +1,3 @@
+module Lispcalc
+  VERSION = '0.1.0'.freeze
+end

data/lib/lispcalc.rb

@@ -0,0 +1,18 @@
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+require_relative 'lispcalc/errors'
+require_relative 'lispcalc/interpreter'
+require_relative 'lispcalc/lexer'
+require_relative 'lispcalc/parser'
+require_relative 'lispcalc/version'
+
+module Lispcalc
+  class << self
+    def eval(input, ctx = Context.new)
+      tokens = Lexer.tokenize(input)
+      forms = Parser.new(tokens).parse
+      Interpreter.new(ctx).eval(forms)
+    end
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: lispcalc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vicente Romero
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email: vteromero@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/lispcalc.rb
+- lib/lispcalc/context.rb
+- lib/lispcalc/errors.rb
+- lib/lispcalc/functions.rb
+- lib/lispcalc/interpreter.rb
+- lib/lispcalc/lexer.rb
+- lib/lispcalc/parser.rb
+- lib/lispcalc/version.rb
+homepage: https://github.com/vteromero/lispcalc
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Lisp-like calculator interpreter
+test_files: []