rb_maxima 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2001c84271ebb26844cf1217d8e5ae5c7844987c65d4fe14723700996e45d6a
-  data.tar.gz: 579008bc8d879af91514e27597a6887c9cbcb9aebfac62091b4354ce0e304b0c
+  metadata.gz: d7f8a7781dde39239a581fe9e88b9d127b93bdd7225bb027b361950c84f7ad6a
+  data.tar.gz: 5393dfa5952b36216eb717a7b47c00ac8cc144f96815c60675f29ef68fa224be
 SHA512:
-  metadata.gz: 4bee94b71cc6bb0e107c2f0408d88a6fada488868cdf4c25d005f5275f4ef212e1a75ea8212fea9a301daa703c0fb8849b0e9189a4a4e97cd7baadf702cae969
-  data.tar.gz: 46afece761a21a62d9d7d018317d2ca74470fe2069028c7af4d767ae2ced93a56ce2dd90da91c2a5c48fd3d0c7dbc830aa6bbe958fbe6d2f9b87df2d66036be2
+  metadata.gz: 9d195381e9231e60d11f5dc9b2f814e69a4478e79e2fd45185e459b3866c6e626c22c1b4c0741e63984f8ee68939589acd1ec1077dc91ae93032a9a46392d83d
+  data.tar.gz: 287a8b6257429192fb76706750eecbe1a1eade21a0d55da9dce3f8f586bd31a9d8da6ba45e845382d93f172ca20aaf54904db26a38b0afdbe0b518059fe86932

data/lib/maxima/command.rb

@@ -13,7 +13,7 @@ module Maxima
       Command.new()
         .with_options(
           use_fast_arrays: true,
-          float: true,
+          float: true
         ).tap do |c|
         yield c
       end.output_variables(*v)
@@ -34,10 +34,10 @@ module Maxima
 
     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)
+      expression = _apply_unary_operations(expression, *unary_operations, **unary_operations_options)
 
       _let(variable, expression)
     end
@@ -69,26 +69,28 @@ module Maxima
 
       [
         unary_operations.map { |unary_operation| "#{unary_operation}(" },
-        expression,
+        Maxima.mformat(expression),
         ")" * unary_operations.count
       ].join()
     end
 
     OPTIONS = {
       float:           -> (enabled) { "float: #{enabled}" },
-      use_fast_arrays: -> (enabled) { "use_fast_arrays: #{enabled}" }
+      use_fast_arrays: -> (enabled) { "use_fast_arrays: #{enabled}" },
+      real_only:       -> (enabled) { "realonly: #{enabled}" }
     }
 
     def options_commands()
       [].each do |commands|
         @options.each do |option, configuration|
+          # warn that option is not applicable
           next unless OPTIONS[option]
           commands << OPTIONS[option].call(configuration)
         end
       end
     end
 
-    def run_shell(extract_variables = nil, debug: ENV["DEBUG"])
+    def run_shell(extract_variables = nil, debug: ENV["DEBUG_RB_MAXIMA"])
       inputs = [*dependencies_input, *options_commands(), *@commands]
 
       inputs << "grind(#{extract_variables.join(', ')})" if extract_variables

data/lib/maxima/complex.rb

@@ -14,7 +14,7 @@ module Maxima
     end
 
     WHITESPACE_OR_PARENTHESES_REGEX = /(\s|\(|\))/
-    COMPLEX_REGEX = /(-?[0-9]*\.?[0-9]+(?:[eE][-+]?[0-9]+)?)((?:\*)?(?:%)?i)?/
+    COMPLEX_REGEX = /(-?[0-9]*\.?[0-9]+(?:[eE][-+]?[0-9]+)?)((?:\*)?(?:%)?\s*i)?|((?:\s*)-?%i)/
 
     def self.parse(maxima_output)
       maxima_output = maxima_output.to_s unless maxima_output.is_a?(String)
@@ -23,8 +23,10 @@ module Maxima
       real = 0
       imaginary = 0
 
-      string.scan(COMPLEX_REGEX) do |(float, is_imaginary)|
-        if is_imaginary
+      string.scan(COMPLEX_REGEX) do |(float, is_imaginary, is_just_imaginary_one)|
+        if is_just_imaginary_one
+          imaginary += (is_just_imaginary_one.start_with? "-") ? -1 : 1
+        elsif is_imaginary
           imaginary += float.to_f
         else
           real += float.to_f
@@ -38,15 +40,6 @@ module Maxima
       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
 
@@ -59,7 +52,6 @@ module Maxima
     end
 
     # Definitions are somewhat contrived and not per se mathematically accurate.
-
     def positive?
       !negative?
     end

data/lib/maxima/core.rb

@@ -3,22 +3,23 @@ module Maxima
     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)
+  ## Alternative minimization function that needs it's own testing etc.
+  # 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.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
+  #     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|
+  def self.lagrangian_interpolation(array)
+    Command.output(function: Function) do |c|
       c.dependencies << "interpol"
-      c.let :array, array.to_a
-      c.let_simplified :lagrangian, "lagrange(array)"
+      c.let :array, array
+      c.let_simplified :function, "lagrange(array)"
     end
   end
 
@@ -90,6 +91,7 @@ module Maxima
 
   def self.lagrangian(minimize_function, variables, constraint_function, initial_guess, iterations: 5)
     Command.output(variables => Unit) do |c|
+      variables           = mformat(variables)
       initial_guess       = mformat(initial_guess)
       constraint_function = mformat(Array(constraint_function))
       optional_args       = mformat(niter: iterations)
@@ -104,34 +106,39 @@ module Maxima
 
   def self.mformat(variable)
     case variable
-    when String, Symbol
+    when String
       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 Array, Histogram
+      "[" + variable.to_a.map { |v| mformat(v) }.join(",") + "]"
     when ::Complex
-      mformat Complex.new(variable, variable.real, variable.imag)
+      mformat Complex.new(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
+    else # Symbol, etc.
+      variable.to_s
     end
   end
 
   def self.solve_polynomial(equations, variables_to_solve_for, ignore: nil, real_only: false)
+    variables_to_solve_for = Array(variables_to_solve_for)
+    equations = Array(equations)
+
+    throw :all_equations_must_include_equivalence unless equations.all? { |e| e.include?("=") }
+
     # 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))
+    output = Command.output(output: Unit) do |c|
+      c.with_options(real_only: real_only)
+
+      variables = mformat(variables_to_solve_for)
+      equations = mformat(equations)
 
       c.let :output, "algsys(#{equations},#{variables})"
     end

data/lib/maxima/float.rb

@@ -17,10 +17,8 @@ module Maxima
 
     def <=>(other)
       case other
-      when ::Float
-        @real <=> other
-      when Float
-        @real <=> other.real
+      when ::Float, Float
+        @real <=> other.to_f
       else
         -1
       end

data/lib/maxima/histogram.rb

@@ -40,32 +40,34 @@ module Maxima
       @points = points
     end
 
+    def to_a
+      @points
+    end
+
+    # PDF
     def to_percentage()
       @to_percentage ||=
         begin
-          sum = points.sum(&:x)
+          sum = points.sum(&:last)
           Histogram.new(
-            points.map do |point|
-              Point.new(
-                point.x,
-                point.y.fdiv(sum)
-              )
+            points.map do |(x,y)|
+              [
+                x,
+                y.fdiv(sum)
+              ]
             end
           )
         end
     end
 
-    def to_a
-      @points
-    end
-
+    # literal CDF
     def integral()
       begin
         sum = 0
         Histogram.new(
-          points.map do |(one, two)|
-            sum += two
-            [one, sum]
+          points.map do |(x, y)|
+            sum += y
+            [x, sum]
           end
         )
       end
@@ -74,5 +76,14 @@ module Maxima
     def to_gnu_plot()
       [*points.map(&:to_a).transpose, w: "points"]
     end
+
+    def <=>(other)
+      case other
+      when Array, Histogram
+        self.to_a <=> other.to_a
+      else
+        -1
+      end
+    end
   end
 end

data/lib/maxima/polynomial.rb

@@ -3,6 +3,7 @@ module Maxima
 
     def self.fit(histogram, degrees)
       throw :degrees_must_be_zero_or_positive if degrees < 0
+      degrees += 1
 
       equation_string, variables = polynomial_equation(degrees)
       results = Maxima.lsquares_estimation(histogram.to_a, [:x, :y], "y = #{equation_string}", variables)
@@ -13,37 +14,32 @@ module Maxima
       end
 
       {
-        function: Maxima::Function.new(equation_string),
+        function: Maxima::Function.new(equation_string).simplified,
         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}" }
+      polynomials = []
+      constant_variables = []
+
+      degrees.times.each do |degree|
+        constant_variable = "c#{degree}"
+        constant_variables << constant_variable
 
-      free_polynomial = constant_variables.each do |degree|
         case degree
         when 0
-          "(#{constant_variable})"
+          polynomials << "(#{constant_variable})"
         when 1
-          "(#{constant_variable}) * #{f_of}"
+          polynomials << "(#{constant_variable}) * #{f_of}"
         else
-          "(#{constant_variable}) * #{f_of} ^ #{degree}"
+          polynomials << "(#{constant_variable}) * #{f_of} ^ #{degree}"
         end
       end
 
       [
-        free_polynomial.join(" + "),
-        variables
+        polynomials.join(" + "),
+        constant_variables
       ]
     end
   end

data/lib/maxima/rational.rb

@@ -3,22 +3,22 @@ module Maxima
 
     attr_accessor :numerator, :denominator
 
-    def initialize(string, numerator, denominator, title = nil)
-      super(string, title)
+    def initialize(numerator, denominator, **options)
+      super(**options)
       @numerator = numerator
       @denominator = denominator
     end
 
-    REGEX = /(\d+)\/(\d+)/
-    def self.parse(input_string)
-      _, numerator, denominator = REGEX.match(input_string).to_a
+    REGEX = /\s*(\d+)\s*\/\s*(\d+)\s*/
+    def self.parse(maxima_output)
+      _, numerator, denominator = REGEX.match(maxima_output).to_a
 
-      return nil if numerator.nil? || denominator.nil?
+      return if numerator.nil? || denominator.nil?
 
       if numerator == 0
-        Float.new(input_string, 0)
+        Float.new(0, maxima_output: maxima_output)
       else
-        Rational.new(input_string, numerator.to_i, denominator.to_i)
+        Rational.new(numerator.to_f, denominator.to_f, maxima_output: maxima_output)
       end
     rescue StandardError
       nil
@@ -35,5 +35,14 @@ module Maxima
     def to_f
       @to_f ||= numerator.fdiv(denominator)
     end
+
+    def <=>(other)
+      case other
+      when ::Float, ::Rational, Float, Rational
+        self.to_f <=> other.to_f
+      else
+        -1
+      end
+    end
   end
 end

data/lib/maxima/unit.rb

@@ -37,10 +37,6 @@ module Maxima
       end
     end
 
-    # def absolute_difference(other)
-    #   Function.new("abs(#{self - other})")
-    # end
-
     def simplified
       @simplified ||= through_maxima(:expand)
     end
@@ -52,10 +48,6 @@ module Maxima
       end[:itself]
     end
 
-    def simplified!
-      simplified.to_s
-    end
-
     def to_maxima_input
       to_s
     end

data/lib/maxima/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rb_maxima
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Daniel Ackerman
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-18 00:00:00.000000000 Z
+date: 2018-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -139,9 +139,9 @@ dependencies:
 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
+  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`!
+  is Maxima!
 email:
 - daniel.joseph.ackerman@gmail.com
 executables: []
@@ -161,7 +161,7 @@ files:
 - lib/maxima/rational.rb
 - lib/maxima/unit.rb
 - lib/maxima/version.rb
-homepage: 
+homepage: https://github.com/Danieth/rb_maxima
 licenses:
 - MIT
 metadata: {}
@@ -184,6 +184,6 @@ 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`
+summary: A gem that allows for mathematical calculations using the open source Maxima
   library!
 test_files: []