rb_maxima 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c2001c84271ebb26844cf1217d8e5ae5c7844987c65d4fe14723700996e45d6a
+  data.tar.gz: 579008bc8d879af91514e27597a6887c9cbcb9aebfac62091b4354ce0e304b0c
+SHA512:
+  metadata.gz: 4bee94b71cc6bb0e107c2f0408d88a6fada488868cdf4c25d005f5275f4ef212e1a75ea8212fea9a301daa703c0fb8849b0e9189a4a4e97cd7baadf702cae969
+  data.tar.gz: 46afece761a21a62d9d7d018317d2ca74470fe2069028c7af4d767ae2ced93a56ce2dd90da91c2a5c48fd3d0c7dbc830aa6bbe958fbe6d2f9b87df2d66036be2

data/lib/maxima.rb

@@ -0,0 +1,22 @@
+require "securerandom"
+require "set"
+require "csv"
+require "numo/gnuplot"
+
+require "maxima/version"
+require "maxima/core"
+
+require "maxima/command"
+
+require "maxima/unit"
+require "maxima/float"
+require "maxima/rational"
+require "maxima/complex"
+require "maxima/boolean"
+
+require "maxima/function"
+
+require "maxima/histogram"
+require "maxima/polynomial"
+
+require "maxima/helper"

data/lib/maxima/boolean.rb

@@ -0,0 +1,12 @@
+module Maxima
+  class Boolean
+
+    TRUE_REGEX = /\s*true\s*/i
+
+    def self.parse(string)
+      !!(TRUE_REGEX =~ string)
+    rescue
+      nil
+    end
+  end
+end

data/lib/maxima/command.rb

@@ -0,0 +1,179 @@
+module Maxima
+  class Command
+    attr_accessor :dependencies, :commands, :assigned_variables, :options
+
+    def initialize
+      @dependencies = []
+      @assigned_variables = Set.new()
+      @commands = []
+      @options = {}
+    end
+
+    def self.output(*v)
+      Command.new()
+        .with_options(
+          use_fast_arrays: true,
+          float: true,
+        ).tap do |c|
+        yield c
+      end.output_variables(*v)
+    end
+
+    def with_options(options)
+      self.tap { @options.merge!(options) }
+    end
+
+    def add_variable(variable)
+      case variable
+      when Enumerable
+        @assigned_variables.merge(variable)
+      else
+        @assigned_variables.add(variable)
+      end
+    end
+
+    def let(variable_or_variables, expression, *unary_operations, **unary_operations_options)
+      add_variable(variable_or_variables)
+      expression = _apply_unary_operations(expression, *unary_operations, **unary_operations_options)
+
+      variable   = Maxima.mformat(variable_or_variables)
+      expression = Maxima.mformat(expression)
+
+      _let(variable, expression)
+    end
+
+    def let_simplified(variable, expression, *unary_operations, **unary_operations_options)
+      unary_operations_options[:expand] = true
+
+      let(
+        variable,
+        expression,
+        *unary_operations,
+        **unary_operations_options
+      )
+    end
+
+    def _let(variable, expression)
+      @commands << "#{variable} : #{expression}"
+    end
+
+    def <<(expression)
+      @commands << expression
+    end
+
+    def _apply_unary_operations(expression, *unary_operations, **unary_operations_options)
+      unary_operations = Set.new(unary_operations)
+      unary_operations_options.map do |option, is_enabled|
+        unary_operations.add(option) if is_enabled
+      end
+
+      [
+        unary_operations.map { |unary_operation| "#{unary_operation}(" },
+        expression,
+        ")" * unary_operations.count
+      ].join()
+    end
+
+    OPTIONS = {
+      float:           -> (enabled) { "float: #{enabled}" },
+      use_fast_arrays: -> (enabled) { "use_fast_arrays: #{enabled}" }
+    }
+
+    def options_commands()
+      [].each do |commands|
+        @options.each do |option, configuration|
+          next unless OPTIONS[option]
+          commands << OPTIONS[option].call(configuration)
+        end
+      end
+    end
+
+    def run_shell(extract_variables = nil, debug: ENV["DEBUG"])
+      inputs = [*dependencies_input, *options_commands(), *@commands]
+
+      inputs << "grind(#{extract_variables.join(', ')})" if extract_variables
+      input = inputs.join("$\n") + "$\n"
+
+      output = with_debug(debug, input) do
+        Helper.spawn_silenced_shell_process("maxima --quiet --run-string '#{input}'")
+      end
+
+      {
+        input:  input,
+        output: output
+      }
+    end
+
+    def with_debug(debug, input)
+      return yield unless debug
+
+      uuid = SecureRandom.uuid[0..6]
+      puts input.lines.map { |s| "#{uuid}>>>\t#{s}" }.join
+
+      yield.tap do |output|
+        puts output.lines.map { |s| "#{uuid}<<<\t#{s}" }.join
+      end
+    end
+
+    MATCH_REGEX = -> (eol_maxima_characters) { /(?<=\(%i#{eol_maxima_characters}\)).*(?=\$|\Z)/m.freeze }
+    GSUB_REGEX = Regexp.union(/\s+/, /\(%(i|o)\d\)|done/)
+    def self.extract_outputs(output, eol_maxima_characters)
+      MATCH_REGEX.call(eol_maxima_characters)
+        .match(output)[0]
+        .gsub(GSUB_REGEX, "")
+        .split("$")
+    end
+
+    def self.convert_output_to_variables(output_variable_map, raw_output)
+      {}.tap do |result|
+        output_variable_map.each_with_index do |(variable, klazz), index|
+          output = raw_output[index]
+          output = klazz.respond_to?(:parse) ? klazz.parse(output) : klazz.new(output)
+          result[variable] = output
+        end
+      end
+    end
+
+    def self.expand_output_variable_map(output_variable_map)
+      {}.tap do |expanded_output_variable_map|
+        add_key = -> (k,v) {
+          if expanded_output_variable_map.has_key?(k)
+            throw :key_used_twice
+          else
+            expanded_output_variable_map[k] = v
+          end
+        }
+
+        output_variable_map.each do |output_key, parsed_into_class|
+          case output_key
+          when Array
+            output_key.each do |output_subkey|
+              add_key.call(output_subkey, parsed_into_class)
+            end
+          else
+            add_key.call(output_key, parsed_into_class)
+          end
+        end
+      end
+    end
+
+    def self.eol_maxima_characters(input)
+      input.count("$") + input.count(";")
+    end
+
+    def output_variables(output_variable_map)
+      output_variable_map = Command.expand_output_variable_map(output_variable_map)
+
+      input, output = run_shell(output_variable_map.keys).values_at(:input, :output)
+
+      eol_maxima_characters = Command.eol_maxima_characters(input)
+      extracted_outputs = Command.extract_outputs(output, eol_maxima_characters)
+
+      Command.convert_output_to_variables(output_variable_map, extracted_outputs)
+    end
+
+    def dependencies_input
+      @dependencies.map { |s| "load(#{s})" }
+    end
+  end
+end

data/lib/maxima/complex.rb

@@ -0,0 +1,85 @@
+module Maxima
+
+  def self.Complex(real, imaginary)
+    Complex.new(real, imaginary)
+  end
+
+  class Complex < Unit
+    attr_accessor :real, :imaginary
+
+    def initialize(real, imaginary, **options)
+      super(**options)
+      @real = real
+      @imaginary = imaginary
+    end
+
+    WHITESPACE_OR_PARENTHESES_REGEX = /(\s|\(|\))/
+    COMPLEX_REGEX = /(-?[0-9]*\.?[0-9]+(?:[eE][-+]?[0-9]+)?)((?:\*)?(?:%)?i)?/
+
+    def self.parse(maxima_output)
+      maxima_output = maxima_output.to_s unless maxima_output.is_a?(String)
+      string = maxima_output.gsub(WHITESPACE_OR_PARENTHESES_REGEX, "")
+
+      real = 0
+      imaginary = 0
+
+      string.scan(COMPLEX_REGEX) do |(float, is_imaginary)|
+        if is_imaginary
+          imaginary += float.to_f
+        else
+          real += float.to_f
+        end
+      end
+
+      if imaginary == 0
+        Float.new(real, maxima_output: maxima_output)
+      else
+        Complex.new(real, imaginary, maxima_output: maxima_output)
+      end
+    end
+
+    def pretty_to_s
+      if real == 0
+        "#{@imaginary}i"
+      else
+        operand = @real.positive? ? '+' : '-'
+        "#{@imaginary}i #{operand} #{@real.abs}"
+      end
+    end
+
+    def to_maxima_input
+      return "#{@imaginary} * %i" if real == 0
+
+      operand = @real.positive? ? '+' : '-'
+      "(#{@imaginary} * %i #{operand} #{@real.abs})"
+    end
+
+    def ==(other)
+      @real == other.real && @imaginary == other.imaginary
+    end
+
+    # Definitions are somewhat contrived and not per se mathematically accurate.
+
+    def positive?
+      !negative?
+    end
+
+    # At least one scalar must be negative & the others non positive
+    def negative?
+      (@real < 0 && @imaginary <= 0) ||
+      (@imaginary < 0 && @real <= 0)
+    end
+
+    def zero?
+      @real == 0 && @imaginary == 0
+    end
+
+    def imaginary?
+      @imaginary != 0
+    end
+
+    def real?
+      @imaginary == 0
+    end
+  end
+end

data/lib/maxima/core.rb

@@ -0,0 +1,153 @@
+module Maxima
+  def self.bin_op(e_1, e_2, bin_op)
+    Maxima::Function.new("((#{Maxima.mformat(e_1)}) #{bin_op} (#{Maxima.mformat(e_2)}))")
+  end
+
+  def self.cobyla(minimize_function, variables, constraint_function, initial_guess)
+    Command.output(variables => Unit) do |c|
+      initial_guess = mformat(initial_guess)
+
+      c.dependencies << "cobyla"
+
+      c.let :output, "fmin_cobyla(#{minimize_function}, #{mformat(variables)}, #{initial_guess},constraints = #{constraint_function})"
+      c.let variables, "sublis(output[1], #{variables})"
+    end
+  end
+
+  def self.interpolate(array)
+    Command.output(lagrangian: Function) do |c|
+      c.dependencies << "interpol"
+      c.let :array, array.to_a
+      c.let_simplified :lagrangian, "lagrange(array)"
+    end
+  end
+
+  def self.integrate(function, t0 = nil, t1 = nil, v: "x")
+    expression = (t0 && t1) ? "integrate(function, #{v}, #{t0}, #{t1})" : "integrate(function, #{v})"
+
+    Command.output(integral: Function) do |c|
+      c.let :function, function
+      c.let :integral, expression
+    end
+  end
+
+  def self.diff(function, v: "x")
+    Command.output(diff: Function) do |c|
+      c.let :function, function
+      c.let :diff, "derivative(function, #{v})"
+    end
+  end
+
+  def self.plot(*maxima_objects, from_x: nil, from_y: nil)
+    maxima_objects << [[from_x.min, 0], [from_x.max, 0]] if from_x
+    maxima_objects << [[0, from_y.min], [0, to_y.max]] if from_y
+
+    maxima_objects = maxima_objects.map do |k|
+      if k.respond_to?(:to_gnu_plot)
+        k.to_gnu_plot
+      elsif k.is_a?(Array) && !k.first.is_a?(String)
+        [*k.transpose, w: "points"]
+      else
+        k
+      end
+    end
+
+    Helper.stfu do
+      Numo.gnuplot do |c|
+        c.debug_on
+        c.set title: "Maxima Plot"
+        c.plot(*maxima_objects)
+      end
+    end
+  end
+
+  def self.lsquares_estimation(points, variables, equation, outputs, equation_for_mse: equation)
+    Command.output(outputs => Complex, :mse => Float) do |c|
+      formatted_points    = points.map { |a| mformat(a) }.join(",")
+      formatted_variables = mformat(variables)
+      formatted_outputs   = mformat(outputs)
+
+      c.dependencies << "lsquares"
+      c.let :M, "matrix(#{formatted_points})"
+      c.let :lsquares_estimation, "lsquares_estimates(M, #{formatted_variables}, #{equation}, #{formatted_outputs})"
+      if outputs.count == 1
+        c << "map (lhs, lsquares_estimation) :: map (rhs, lsquares_estimation)"
+      else
+        c << "map (lhs, lsquares_estimation[1]) :: map (rhs, lsquares_estimation[1])"
+      end
+      c.let :mse, "lsquares_residual_mse(M, #{formatted_variables}, #{equation_for_mse}, first (lsquares_estimation))"
+    end
+  end
+
+  def self.equivalence(expression_one, expression_two)
+    Command.output(:is_equal => Boolean) do |c|
+      formatted_expression_one = mformat(expression_one)
+      formatted_expression_two = mformat(expression_two)
+
+      c.let :is_equal, "is(equal(#{formatted_expression_one}, #{formatted_expression_two}))"
+    end
+  end
+
+  def self.lagrangian(minimize_function, variables, constraint_function, initial_guess, iterations: 5)
+    Command.output(variables => Unit) do |c|
+      initial_guess       = mformat(initial_guess)
+      constraint_function = mformat(Array(constraint_function))
+      optional_args       = mformat(niter: iterations)
+
+      c.dependencies << "lbfgs"
+      c.dependencies << "augmented_lagrangian"
+
+      c.let :output, "augmented_lagrangian_method(#{minimize_function}, #{variables}, #{constraint_function}, #{initial_guess}, #{optional_args})"
+      c.let variables, "sublis(output[1], #{variables})"
+    end
+  end
+
+  def self.mformat(variable)
+    case variable
+    when String, Symbol
+      variable # the only truly `valid` input is a string
+    when Hash
+      variable.map do |key,value|
+        "#{mformat(key)} = #{mformat(value)}"
+      end.join(", ")
+    when Array
+      "[" + variable.map { |v| mformat(v) }.join(",") + "]"
+    when ::Complex
+      mformat Complex.new(variable, variable.real, variable.imag)
+    when Numeric
+      mformat Float(variable)
+    when Complex, Float, Function
+      variable.to_maxima_input
+    when nil
+      throw :cannot_format_nil
+    else
+      variable
+    end
+  end
+
+  def self.solve_polynomial(equations, variables_to_solve_for, ignore: nil, real_only: false)
+    # regex match extract
+    output = Command
+               .with_options(real_only: real_only)
+               .output(output: Unit) do |c|
+      variables = mformat(Array(variables_to_solve_for))
+      equations = mformat(Array(equations))
+
+      c.let :output, "algsys(#{equations},#{variables})"
+    end
+
+    output = output[:output]
+
+    variables_to_solve_for -= Array(ignore)
+
+    variable_regexes = variables_to_solve_for.map do |variable|
+      "#{variable}=(-?.*?)(?:\,|\\])"
+    end
+
+    regex = Regexp.new(variable_regexes.reduce(&:+))
+
+    output = output.to_s.gsub(" ", "")
+
+    output.scan(regex).map { |row| variables_to_solve_for.zip(row.map { |v| Unit.parse(v) }).to_h }
+  end
+end

data/lib/maxima/float.rb

@@ -0,0 +1,45 @@
+module Maxima
+
+  def self.Float(real)
+    Float.new(real)
+  end
+
+  class Float < Unit
+    ZERO = Float.new(0).freeze
+
+    attr_accessor :real
+
+    def initialize(real = nil, **options)
+      options[:maxima_output] ||= real&.to_s
+      super(**options)
+      @real = (real || @maxima_output).to_f
+    end
+
+    def <=>(other)
+      case other
+      when ::Float
+        @real <=> other
+      when Float
+        @real <=> other.real
+      else
+        -1
+      end
+    end
+
+    def to_f
+      @real
+    end
+
+    def real?
+      true
+    end
+
+    def imaginary?
+      false
+    end
+
+    def derivative(v: nil)
+      ZERO
+    end
+  end
+end

data/lib/maxima/function.rb

@@ -0,0 +1,91 @@
+module Maxima
+  class Function < Unit
+    attr_accessor :string, :variables
+
+    def initialize(string, variables = nil, **options)
+      string = string.to_s
+      options[:maxima_output] ||= string
+      super(**options)
+      @variables = variables || Function.variables_in_string(string)
+    end
+
+    # This strategy fails for functions (cos etc.). However, that does not impact it's actual usage.
+    VARIABLE_REGEX = /[%|a-z|A-Z]+/.freeze
+    IGNORE_VARIABLES = %w(%e %i).freeze
+    def self.variables_in_string(string)
+      (string.scan(VARIABLE_REGEX) - IGNORE_VARIABLES).to_set
+    end
+
+    def integral(t0 = nil, t1 = nil, v: "x")
+      if t0 && t1
+        Maxima.integrate(to_maxima_input, t0, t1, v: v)[:integral]
+      else
+        Maxima.integrate(to_maxima_input, v: v)[:integral]
+      end
+    end
+
+    def definite_integral(t0, t1, v: "x")
+      i_v = self.integral(v: v)
+      i_v.at(v => t1) - i_v.at(v => t0)
+    end
+
+    def derivative(variable = nil, v: "x")
+      Maxima.diff(to_maxima_input, v: (variable || v))[:diff]
+    end
+
+    def between(min, max, steps)
+      step = (max - min).fdiv(steps)
+
+      Command.output(r: Histogram) do |c|
+        c.let :r, "makelist([x,float(#{self})],x, #{min}, #{max}, #{step})"
+      end[:r]
+    end
+
+    # Assume what we get is what we need
+    def self.parse(string)
+      variables = variables_in_string(string)
+
+      if variables.any?
+        Function.new(string, variables)
+      else
+        Unit.parse_float(string)
+      end
+    rescue
+      nil
+    end
+
+    def gnu_plot_text
+      super.gsub("^", "**")
+    end
+
+    def gnu_plot_w
+      "lines"
+    end
+
+    def to_maxima_input
+      self.to_s
+    end
+
+    def at(v)
+      s = self.to_s.dup
+
+      case v
+      when Hash
+        v.each do |k,t|
+          k = k.to_s
+          if @variables.include?(k)
+            s.gsub!(k, "(#{t})")
+          end
+        end
+      else
+        throw :must_specify_variables_in_hash if @variables.length != 1
+        s.gsub!(@variables.first, "(#{v})")
+      end
+      Function.parse(s).simplified
+    end
+
+    def ==(other)
+      to_s == other.to_s
+    end
+  end
+end

data/lib/maxima/helper.rb

@@ -0,0 +1,63 @@
+$interrupted = false
+
+Signal.trap("INT") {
+  $interrupted = true
+}
+
+module Maxima
+  module Helper
+
+    def self.stfu
+      result = nil
+      begin
+        orig_stderr = $stderr.clone
+        orig_stdout = $stdout.clone
+        $stderr.reopen File.new('/dev/null', 'w')
+        $stdout.reopen File.new('/dev/null', 'w')
+        result = yield
+      rescue Exception => e
+        if $interrupted
+          throw :interrupted
+        else
+          $stdout.reopen orig_stdout
+          $stderr.reopen orig_stderr
+          raise e
+        end
+      ensure
+        if $interrupted
+          throw :interrupted
+        else
+          $stdout.reopen orig_stdout
+          $stderr.reopen orig_stderr
+        end
+      end
+      if $interrupted
+        throw :interrupted
+      else
+        result
+      end
+    end
+
+    def self.spawn_silenced_shell_process(shell_command)
+      stfu do
+        rout, wout = IO.pipe
+        result = nil
+        begin
+          pid = Process.spawn(shell_command, out: wout)
+          _, _ = Process.wait2(pid)
+        ensure
+          wout.close
+          if $interrupted
+            rout.close
+            throw :interrupted
+          else
+            result = rout.readlines.join("\n")
+            rout.close
+          end
+        end
+        result
+      end
+    end
+
+  end
+end

data/lib/maxima/histogram.rb

@@ -0,0 +1,78 @@
+module Maxima
+  class Histogram < Unit
+    attr_accessor :points
+
+    def self.between(min, max, function = ->(x) { x }, steps = 100)
+      Histogram.new(
+        *[].tap do |points|
+          (min..max).step((max - min).fdiv(steps)).each do |x|
+            points.push([x, function.call(x)])
+          end
+        end
+      )
+    end
+
+    def polynomial_fit(degrees)
+      Polynomial.fit(self, degrees)[:function]
+    end
+
+    def self.from_csv(csv)
+      Histogram.new(
+        *CSV.read(csv).map { |array| array.map(&:to_i) }
+      )
+    end
+
+    def self.parse(s)
+      Histogram.new((eval s), maxima_output: s)
+    end
+
+    def initialize(*points, **options)
+      super(**options)
+
+      while points.is_a?(Array) && points.first.is_a?(Array) && points.first.first.is_a?(Array)
+        points = points.flatten(1)
+      end
+
+      unless points.is_a?(Array) && points.first.is_a?(Array) && points.first.length == 2
+        throw :invalid_histogram_points
+      end
+
+      @points = points
+    end
+
+    def to_percentage()
+      @to_percentage ||=
+        begin
+          sum = points.sum(&:x)
+          Histogram.new(
+            points.map do |point|
+              Point.new(
+                point.x,
+                point.y.fdiv(sum)
+              )
+            end
+          )
+        end
+    end
+
+    def to_a
+      @points
+    end
+
+    def integral()
+      begin
+        sum = 0
+        Histogram.new(
+          points.map do |(one, two)|
+            sum += two
+            [one, sum]
+          end
+        )
+      end
+    end
+
+    def to_gnu_plot()
+      [*points.map(&:to_a).transpose, w: "points"]
+    end
+  end
+end

data/lib/maxima/polynomial.rb

@@ -0,0 +1,50 @@
+module Maxima
+  class Polynomial < Unit
+
+    def self.fit(histogram, degrees)
+      throw :degrees_must_be_zero_or_positive if degrees < 0
+
+      equation_string, variables = polynomial_equation(degrees)
+      results = Maxima.lsquares_estimation(histogram.to_a, [:x, :y], "y = #{equation_string}", variables)
+      mse = results.delete(:mse)
+
+      results.each do |variable, value|
+        equation_string.gsub!("(#{variable})", value.to_s)
+      end
+
+      {
+        function: Maxima::Function.new(equation_string),
+        mse: mse
+      }
+    end
+
+    def self.fit_function(min, max, x: "x")
+      Enumerator.new do |e|
+        (min..max).each do |degrees|
+          equation_string, variables = polynomial_equation(degrees, f_of: x)
+          e.<<(equation_string, variables)
+        end
+      end
+    end
+
+    def self.polynomial_equation(degrees, f_of: "x")
+      constant_variables = degrees.times.map { |degree| "c#{degree}" }
+
+      free_polynomial = constant_variables.each do |degree|
+        case degree
+        when 0
+          "(#{constant_variable})"
+        when 1
+          "(#{constant_variable}) * #{f_of}"
+        else
+          "(#{constant_variable}) * #{f_of} ^ #{degree}"
+        end
+      end
+
+      [
+        free_polynomial.join(" + "),
+        variables
+      ]
+    end
+  end
+end

data/lib/maxima/rational.rb

@@ -0,0 +1,39 @@
+module Maxima
+  class Rational < Unit
+
+    attr_accessor :numerator, :denominator
+
+    def initialize(string, numerator, denominator, title = nil)
+      super(string, title)
+      @numerator = numerator
+      @denominator = denominator
+    end
+
+    REGEX = /(\d+)\/(\d+)/
+    def self.parse(input_string)
+      _, numerator, denominator = REGEX.match(input_string).to_a
+
+      return nil if numerator.nil? || denominator.nil?
+
+      if numerator == 0
+        Float.new(input_string, 0)
+      else
+        Rational.new(input_string, numerator.to_i, denominator.to_i)
+      end
+    rescue StandardError
+      nil
+    end
+
+    def real?
+      true
+    end
+
+    def imaginary?
+      false
+    end
+
+    def to_f
+      @to_f ||= numerator.fdiv(denominator)
+    end
+  end
+end

data/lib/maxima/unit.rb

@@ -0,0 +1,124 @@
+module Maxima
+  class Unit
+    attr_accessor :maxima_output, :plot_title
+
+    def initialize(inline_maxima_output = nil, plot_title: nil, maxima_output: nil)
+      @maxima_output = inline_maxima_output || maxima_output
+      @plot_title    = plot_title
+    end
+
+    def inspect
+      if plot_title.nil? || plot_title == ""
+        "#{self.class}(#{self})"
+      else
+        "#{self.class}[#{plot_title}](#{self})"
+      end
+    end
+
+    def self.parse(m)
+      Function.parse(m)
+    end
+
+    def self.parse_float(m)
+      Rational.parse(m) || Complex.parse(m)
+    end
+
+    def to_s
+      @maxima_output
+    end
+
+    def with_plot_title(plot_title)
+      self.class.new(@maxima_output, plot_title)
+    end
+
+    %w(* / ** + -).each do |operation|
+      define_method(operation) do |other|
+        Maxima.bin_op(self, other, operation)
+      end
+    end
+
+    # def absolute_difference(other)
+    #   Function.new("abs(#{self - other})")
+    # end
+
+    def simplified
+      @simplified ||= through_maxima(:expand)
+    end
+
+    # ~~ *unary_operations, **unary_operations_options
+    def through_maxima(*array_options, **options)
+      @after_maxima ||= Command.output(itself: Unit) do |c|
+        c.let :itself, self.to_s, *array_options, **options
+      end[:itself]
+    end
+
+    def simplified!
+      simplified.to_s
+    end
+
+    def to_maxima_input
+      to_s
+    end
+
+    def to_gnu_plot
+      [gnu_plot_text, gnu_plot_options]
+    end
+
+    def at(_)
+      self
+    end
+
+    def to_pdf(t0, t1, v: "x")
+      (self / integral(t0, t1)).definite_integral(t0, v)
+    end
+
+    # private
+    def gnu_plot_text
+      to_s
+    end
+
+    def gnu_plot_options
+      { w: gnu_plot_w }.tap do |options|
+        options[:plot_title] = @plot_title if @plot_title
+      end
+    end
+
+    def gnu_plot_w
+      "points"
+    end
+
+    def to_f
+      throw "cannot_cast_#{self.class}_to_float"
+    end
+
+    def real?
+      throw "real_is_undecidable_for_#{self.class}"
+    end
+
+    def imaginary?
+      throw "imaginary_is_undecidable_for_#{self.class}"
+    end
+
+    def positive?
+      to_f > 0
+    end
+
+    def zero?
+      to_f == 0
+    end
+
+    def negative?
+      to_f < 0
+    end
+
+    # Basic string identity
+    def ==(other)
+      (self <=> other) == 0
+    end
+
+    # True mathematical equivalence
+    def ===(other)
+      (self == other) || Maxima.equivalence(self, other)[:is_equal]
+    end
+  end
+end

data/lib/maxima/version.rb

@@ -0,0 +1,3 @@
+module Maxima
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification
+name: rb_maxima
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Daniel Ackerman
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-06-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: numo-gnuplot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: Ruby developers have, for as long as I can remember, had a disheveled
+  heap of scientific and mathematical libraries - many of which operate in pure ruby
+  code. Given a problem we either kludge together some cobbled mess or turn to Python/R/etc.
+  And to this I say no more! `rb_maxima` allows a ruby developer to directly leverage
+  the unbridled power of the open source, lisp powered, computer algebra system that
+  is `Maxima`!
+email:
+- daniel.joseph.ackerman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/maxima.rb
+- lib/maxima/boolean.rb
+- lib/maxima/command.rb
+- lib/maxima/complex.rb
+- lib/maxima/core.rb
+- lib/maxima/float.rb
+- lib/maxima/function.rb
+- lib/maxima/helper.rb
+- lib/maxima/histogram.rb
+- lib/maxima/polynomial.rb
+- lib/maxima/rational.rb
+- lib/maxima/unit.rb
+- lib/maxima/version.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: A gem that allows for mathematical calculations using the open source `Maxima`
+  library!
+test_files: []