more_math 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e49149cd5565cd37afbfbe28185a0fbd2a12b245fe19e81882b9df1a0808edb
-  data.tar.gz: be0a9ffffac8d705bc6aefb5643eb188abc35c38eefa905ce988c8369a5d676e
+  metadata.gz: 347b633c7b95cb4728828e2dcad06f04f824e340d72dc4192b0d81b7e3a2df6e
+  data.tar.gz: 5e1bd55c18723aa18ccab2b7c916811ba8c84f2fb251bcaeb323575da045f7d3
 SHA512:
-  metadata.gz: 2afb5b0fd78fe1becb079a653354103cef2a02ecd854d73b7e749a03b4f9fc1aee79da76c81f6b1a30060d614b7a76b33d81050672f44aadbfe8bb748bb0090b
-  data.tar.gz: 53e00124977ced033913b519606110c5d75f747c96d84ad80afd35683754dd8c963704afda44ffb7a5fc2138c80d99347199cd9df5d16dc0767b18706c44bd7d
+  metadata.gz: 41d4ce4dff93f65ef91cd5b414f205b8a64567d148586d2dd7d09f0327aafc802fb655ccdbe6e44da29241cb86f863ffa38104b0d13aa3cc34b2061049db18fe
+  data.tar.gz: bbd8bcfcb4fb17b3ad5ada2e069e1d969429de1f39c2d21305a4e8d7e56dbe3f96ec3d00411428711f82aa89293c2d15d5c028947250bc7f1670408971b1494d

data/CHANGES.md

@@ -1,5 +1,32 @@
 # Changes
 
+## 2025-09-30 v1.6.0
+
+- Replaced detailed feature sections in README with a concise bullet list of
+  MoreMath capabilities
+- Added documentation link to GitHub.io and updated installation instructions
+  to include both RubyGems and Bundler
+- Improved author and license formatting with proper markdown links
+- Added `.github/workflows/static.yml` to automate documentation generation and
+  deployment using Ruby **3.4**
+- Updated `Rakefile` to register new documentation workflow with GemHadar
+- Configured workflow to use Ruby **3.4** for documentation builds and deploy
+  to GitHub Pages on master branch pushes
+- Added `context_spook` as development dependency for YARD documentation
+- Added `cscope.out` to `.gitignore` and updated `Rakefile` to include it in
+  the ignore list
+- Added `code_indexer` configuration to `.utilsrc` with a list of gems
+  including **base64**, **bigdecimal**, **date**, **json**, **mize**,
+  **ostruct**, **rake**, **stringio**, **sync**, **test-unit**, and **tins**
+- Added `doc` and `.yardoc` directories to gitignore and rake configuration
+- Updated homepage URL to escape underscore character for proper rendering
+- Updated `gem_hadar` development dependency from version **2.4** to **2.6**
+- Modified `package_ignore` in Rakefile to explicitly include `.github` and
+  `.contexts` directories instead of using glob pattern `*.github/**/*`
+- Enhanced documentation for all methods in MoreMath module
+- Added documentation directories `.yardoc` and `doc` to `prune_dirs` in
+  utilsrc
+
 ## 2025-09-11 v1.5.0
 
 - Updated `VERSION` file and `lib/more_math/version.rb` from version **1.4.0** to **1.5.0**
@@ -9,7 +36,7 @@
 - Added runtime dependency on `mize` (">= 0")
 - Set rubygems version to **3.6.9**
 - Included all library files in `s.files` and `s.extra_rdoc_files`
-- Set homepage to "https://github.com/flori/more_math"
+- Set homepage to "https://github.com/flori/more\_math"
 - Set license to "MIT"
 - Added `yaml-dev` to dockerfile build dependencies
 - Installed `bundler` and `gem_hadar` gems in dockerfile

data/README.md

@@ -6,54 +6,22 @@ Ruby library that contains various mathematical functions and algorithms,
 extending Ruby's capabilities in domains such as statistics, numerical
 analysis, and combinatorics.
 
-### Core Features
-
-1. **Mathematical Functions**
-   - **Gamma Function**: Computes the gamma function for real numbers.
-   - **Beta Function**: Calculates the beta function and its regularized form.
-   - **Error Function (erf)**: Provides the error function used in probability
-     and statistics.
-
-2. **Special Functions**
-   - **Lambert W Function**: Solves equations of the form `x = a * exp(x)`.
-   - **Continued Fractions**: Evaluates continued fractions for various
-     mathematical expressions.
-
-3. **Statistical Tools**
-   - **Probability Distributions**: Implements distributions like Student's t,
-     chi-squared, and Fisher's z.
-   - **Random Number Generation**: Generates random numbers following specific
-     distributions.
-   - **Hypothesis Testing**: Performs tests like the Kolmogorov-Smirnov test
-     for distribution comparison.
-
-4. **Sequence Analysis**
-   - **Moving Averages**: Computes simple moving averages for time series data.
-   - **Autocorrelation and Autovariance**: Analyzes the correlation structure
-     of sequences.
-   - **Histograms**: Visualizes data distributions with customizable bins.
-
-5. **Combinatorics and Algorithms**
-   - **Permutations and Combinations**: Generates permutations, combinations,
-     and Cartesian products.
-   - **Graph Theory**: Includes algorithms for shortest paths (Dijkstra,
-     Floyd-Warshall) and minimum spanning trees.
-   - **Root Finding**: Uses Newton-Raphson and bisection methods to find roots
-     of functions.
-
-### Specialized Modules
-
-1. **String Numeral Conversion**
-   - Converts strings to Gödel numbers and vice versa using a specified
-   alphabet.
-
-2. **Cantor Pairing Function**
-   - Encodes tuples into a single integer and decodes them back, useful in set
-   theory and combinatorics.
-
-3. **Histograms**
-   - Creates histograms for data visualization with support for different
-   binning strategies.
+MoreMath provides a comprehensive set of mathematical tools including:
+- Advanced mathematical functions (gamma, beta, error functions)
+- Mathematical constants and precision utilities
+- Statistical distributions and hypothesis testing
+- Sequence analysis and time series operations
+- Combinatorial algorithms (permutations, subsets)
+- Special functions (continued fractions, Cantor pairing)
+- Data visualization tools (histograms)
+- String numeral conversion and Gödel numbering
+- Numerical integration methods
+- Statistical quality control tools
+- Information theory calculations
+
+## Documentation
+
+Complete API documentation is available at: [GitHub.io](https://flori.github.io/more_math/)
 
 ## Example Usage
 
@@ -86,21 +54,24 @@ Histogram.new([1, 2, 3, 4, 5, 1], bins: 3).display(STDOUT, 80) ; nil
 
 ## Installation
 
-To install `more_math`, run:
-
+### Using RubyGems
 ```bash
 gem install more_math
 ```
 
+### Using Bundler
+Add to your Gemfile:
+```ruby
+gem 'more_math'
+```
+
 ## Author
 
-Florian Frank  
-mailto:flori@ping.de
+[Florian Frank](mailto:flori@ping.de)
 
 ## License
 
-This software is licensed under the X11 (or MIT) license:
-http://www.xfree86.org/3.3.6/COPYRIGHT2.html#3
+This software is licensed under the [MIT License](./LICENSE).
 
 ## Homepage
 

data/Rakefile

@@ -11,11 +11,16 @@ GemHadar do
   description 'Library that provides more mathematical functions/algorithms than standard Ruby.'
   test_dir    'tests'
   ignore      '.*.sw[pon]', 'pkg', 'Gemfile.lock', 'coverage', '.rvmrc',
-    '.AppleDouble', 'tags', '.byebug_history', '.DS_Store', '.bundle'
+    '.AppleDouble', 'tags', '.byebug_history', '.DS_Store', '.bundle',
+    '.yardoc', 'doc', 'cscope.out'
   readme      'README.md'
   title       "#{name.camelize} -- More Math in Ruby"
   package_ignore '.all_images.yml', '.gitignore', 'VERSION', '.utilsrc',
-    *Dir['.github/**/*']
+    '.github', '.contexts', '.contexts'
+
+  github_workflows(
+    'static.yml' => { }
+  )
 
   required_ruby_version '>= 2.0'
   dependency  'tins', '~>1'
@@ -25,5 +30,6 @@ GemHadar do
   development_dependency 'test-unit'
   development_dependency 'debug'
   development_dependency 'all_images'
+  development_dependency 'context_spook'
   licenses << 'MIT'
 end

data/lib/more_math/cantor_pairing_function.rb

@@ -1,8 +1,39 @@
 module MoreMath
+  # Provides Cantor pairing function implementations for encoding tuples into
+  # natural numbers and decoding them back.
+  #
+  # The Cantor pairing function is a mathematical construct that uniquely
+  # encodes pairs of natural numbers into a single natural number, and vice
+  # versa. This module implements both the forward pairing function and its
+  # inverse for arbitrary tuples of integers.
+  #
+  # @example Pairing two numbers
+  #   CantorPairingFunction.cantor_pairing(5, 3) # => 39
+  #
+  # @example Pairing multiple numbers
+  #   CantorPairingFunction.cantor_pairing(1, 2, 3) # => 69
+  #
+  # @example Inverse pairing
+  #   CantorPairingFunction.cantor_pairing_inv(39) # => [5, 3]
+  #
+  # @example Inverse pairing for tuples
+  #   CantorPairingFunction.cantor_pairing_inv(69, 3) # => [1, 2, 3]
   module CantorPairingFunction
 
     module_function
 
+    # Encodes multiple integers into a single natural number using the Cantor
+    # pairing function.
+    #
+    # This method implements the Cantor pairing function, which provides a
+    # unique encoding of tuples of natural numbers into a single natural
+    # number. For two integers, it uses the standard Cantor pairing formula.
+    # For more than two integers, it recursively applies the pairing function
+    # to reduce the tuple to a single value.
+    #
+    # @param xs [Array<Integer>] An array of integers to pair
+    # @return [Integer] A unique natural number representing the input tuple
+    # @raise [ArgumentError] When fewer than two arguments are provided
     def cantor_pairing(*xs)
       if xs.size == 1 and xs.first.respond_to?(:to_ary)
         xs = xs.first.to_ary
@@ -18,10 +49,27 @@ module MoreMath
       end
     end
 
+    # Computes the cantor pairing function f(z) = z * (z + 1) / 2
+    #
+    # This helper method calculates a partial result used in the inverse cantor
+    # pairing function to compute the triangular number sequence that helps in
+    # decoding paired values
+    #
+    # @param z [Integer] The input value to compute the triangular number for
+    # @return [Integer] The computed triangular number value
     def self.cantor_pairing_inv_f(z)
       z * (z + 1) / 2
     end
 
+    # Computes the quotient used in the inverse Cantor pairing function
+    #
+    # This method calculates the largest value v such that the Cantor pairing
+    # function applied to v is less than or equal to the given value z. It's a
+    # helper method that supports the inverse pairing algorithm by determining
+    # the appropriate triangular number boundary for decoding.
+    #
+    # @param z [Integer] The value to compute the quotient for
+    # @return [Integer] The computed quotient value v where cantor_pairing_inv_f(v) <= z
     def self.cantor_pairing_inv_q(z)
       v = 0
       while cantor_pairing_inv_f(v) <= z
@@ -30,6 +78,17 @@ module MoreMath
       v - 1
     end
 
+    # Computes the inverse of the Cantor pairing function for a given value
+    #
+    # This method decodes a natural number back into its original tuple
+    # representation using the inverse Cantor pairing function. It supports
+    # decoding tuples of arbitrary length by recursively applying the inverse
+    # operation.
+    #
+    # @param c [Integer] The natural number to decode back into a tuple
+    # @param n [Integer] The length of the original tuple (default: 2)
+    # @return [Array<Integer>] The decoded tuple as an array of integers
+    # @raise [ArgumentError] When n is less than 2
     def cantor_pairing_inv(c, n = 2)
       raise ArgumentError, "n is required to be >= 2" unless n >= 2
       result = []

data/lib/more_math/constants/functions_constants.rb

@@ -1,6 +1,22 @@
 module MoreMath
+  # Contains constant values used in mathematical function implementations.
+  #
+  # These constants are essential for high-precision numerical computations,
+  # particularly in the Lanczos approximation for gamma functions and error
+  # function approximations. The constants are carefully chosen to balance
+  # accuracy and computational efficiency.
   module Constants
+    # Module containing mathematical constants used in function implementations
     module FunctionsConstants
+      # Lanczos coefficients for gamma function approximation
+      #
+      # These coefficients are part of the Lanczos approximation formula,
+      # which provides a highly accurate method for computing the logarithm
+      # of the gamma function. The Lanczos method is particularly effective
+      # for maintaining numerical stability across a wide range of inputs.
+      #
+      # @note These values are precomputed for optimal accuracy in the
+      #   Lanczos approximation algorithm
       LANCZOS_COEFFICIENTS = [
         0.99999999999999709182,
         57.156235665862923517,
@@ -19,10 +35,31 @@ module MoreMath
         0.36899182659531622704e-5,
       ]
 
+      # Precomputed value of half the natural logarithm of 2π
+      #
+      # This constant is used in Stirling's approximation and various
+      # statistical calculations. It's computed as:
+      #   0.5 * Math.log(2 * Math::PI)
+      #
+      # @note This value appears in the Lanczos approximation formula
+      #   and other mathematical identities involving the gamma function
       HALF_LOG_2_PI = 0.5 * Math.log(2 * Math::PI)
 
+      # Parameter for error function approximation
+      #
+      # This constant is used in the rational approximation of the error
+      # function. It's derived from the relationship:
+      #   ERF_A = -8 * (Math::PI - 3) / (3 * Math::PI * (Math::PI - 4))
+      #
+      # The value helps optimize the accuracy of the erf approximation
+      # for a wide range of input values
       ERF_A = -8 * (Math::PI - 3) / (3 * Math::PI * (Math::PI - 4))
 
+      # Square root of 2
+      #
+      # This constant is frequently used in statistics and probability,
+      # particularly in the normal distribution and error function
+      # calculations.
       ROOT2 = Math.sqrt(2)
     end
   end

data/lib/more_math/continued_fraction.rb

@@ -1,44 +1,88 @@
 module MoreMath
-  # This class implements a continued fraction of the form:
+  # A continued fraction implementation that supports both simple and
+  # generalized continued fractions.
   #
-  #                            b_1
-  # a_0 + -------------------------
-  #                            b_2
-  #      a_1 + --------------------
-  #                            b_3
-  #           a_2 + ---------------
-  #                            b_4
-  #                a_3 + ----------
-  #                            b_5
-  #                     a_4 + -----
-  #                            ...
+  # Continued fractions are represented in the form:
+  #   a₀ + b₁ / (a₁ + b₂ / (a₂ + b₃ / (a₃ + ...)))
   #
+  # For simple continued fractions, all `b` coefficients default to 1,
+  # and only `a` coefficients vary.
+  #
+  # @example Simple continued fraction for φ (golden ratio)
+  #   phi = ContinuedFraction.new
+  #   phi.() # => 1.618033988749895
+  #
+  # @example Generalized continued fraction for √2
+  #   sqrt_2 = ContinuedFraction.for_a { |n| n == 0 ? 1 : 2 }
+  #   sqrt_2.()  # => 1.4142135623730951
+  #
+  # @example Generalized continued fraction for π (finite)
+  #   pi = ContinuedFraction.for_a [3, 7, 15, 1, 292, 1, 1, 1, 2]
+  #   pi.() # => 3.141592653581078
+  #
+  # @example Continued fraction with variable coefficients
+  #   atan = ContinuedFraction.for_a do |n, x|
+  #     n == 0 ? 0 : 2 * n - 1
+  #   end.for_b do |n, x|
+  #     n <= 1 ? x : ((n - 1) * x) ** 2
+  #   end
+  #   atan.(0.5)  # => 0.4636476090008061
   class ContinuedFraction
+    # Default b coefficient generator (returns 1 for all indices)
     SIMPLE_B = proc { 1 }
 
-    # Creates a continued fraction instance. With the defaults for_a { 1 } and
-    # for_b { 1 } it approximates the golden ration phi if evaluated.
+    # Creates a new continued fraction with default coefficients.
+    # The defaults for `a` and `b` are both set to 1, which approximates
+    # the golden ratio when evaluated.
+    #
+    # @example Create a new instance
+    #   cf = ContinuedFraction.new
     def initialize
       @a = proc { 1 }
       @b = SIMPLE_B
     end
 
-    # Creates a ContinuedFraction instances and passes its arguments to a call
-    # to for_a.
+    # Creates a continued fraction instance and sets its `a` coefficients.
+    # This is a class method for convenience when building continued fractions.
+    #
+    # @example Using an array of values
+    #   cf = ContinuedFraction.for_a([1, 2, 3])
+    #
+    # @example Using a block
+    #   cf = ContinuedFraction.for_a { |n| n + 1 }
+    #
+    # @param arg [Array, nil] An array of coefficients or nil to use a block.
+    # @yield [index] A block that returns the coefficient for index `n`.
+    # @yieldparam index [Integer] The index of the coefficient to retrieve.
+    # @return [ContinuedFraction] A new continued fraction with specified `a` coefficients.
     def self.for_a(arg = nil, &block)
       new.for_a(arg, &block)
     end
 
-    # Creates a ContinuedFraction instances and passes its arguments to a call
-    # to for_b.
+    # Creates a continued fraction instance and sets its `b` coefficients.
+    # This is a class method for convenience when building continued fractions.
+    #
+    # @example Using an array of values
+    #   cf = ContinuedFraction.for_b([1, 2, 3])
+    #
+    # @example Using a block
+    #   cf = ContinuedFraction.for_b { |n| n + 1 }
+    #
+    # @param arg [Array, nil] An array of coefficients or nil to use a block.
+    # @yield [index] A block that returns the coefficient for index `n`.
+    # @yieldparam index [Integer] The index of the coefficient to retrieve.
+    # @return [ContinuedFraction] A new continued fraction with specified `b` coefficients.
     def self.for_b(arg = nil, &block)
       new.for_b(arg, &block)
     end
 
+    # Helper method to validate and process arguments for `for_a` and `for_b`.
+    #
+    # @api private
     def for_arg(arg = nil, &block)
-      if arg and !block
+      if arg && !block
         arg.freeze
-      elsif block and !arg
+      elsif block && !arg
         block
       else
         raise ArgumentError, "exactly one argument or one block required"
@@ -46,6 +90,13 @@ module MoreMath
     end
     private :for_arg
 
+    # Creates a continued fraction from a Rational number.
+    #
+    # @example Create a continued fraction for π
+    #   pi_cf = ContinuedFraction.from(Math::PI)
+    #
+    # @param number [Numeric] The number to convert into a continued fraction.
+    # @return [ContinuedFraction] A continued fraction representation of the number.
     def self.from(number)
       number = number.to_r
       n, d = number.numerator, number.denominator
@@ -57,41 +108,51 @@ module MoreMath
       for_a(as)
     end
 
-    # This method either takes a block or an argument +arg+. The argument +arg+
-    # has to respond to an integer index n >= 0 and return the value a_n. The
-    # block has to return the value for a_n when +n+ is passed as the first
-    # argument to the block. If a_n is dependent on an +x+ value (see the call
-    # method) the +x+ will be the second argument of the block.
+    # Sets the `a` coefficients for this continued fraction.
+    #
+    # @example Using an array of values
+    #   cf = ContinuedFraction.new.for_a([1, 2, 3])
+    #
+    # @example Using a block
+    #   cf = ContinuedFraction.new.for_a { |n| n + 1 }
+    #
+    # @param arg [Array, nil] An array of coefficients or nil to use a block.
+    # @yield [index] A block that returns the coefficient for index `n`.
+    # @yieldparam index [Integer] The index of the coefficient to retrieve.
+    # @return [ContinuedFraction] Returns self for chaining.
     def for_a(arg = nil, &block)
       @a = for_arg(arg, &block)
       self
     end
 
-    # This method either takes a block or an argument +arg+. The argument +arg+
-    # has to respond to an integer index n >= 1 and return the value b_n. The
-    # block has to return the value for b_n when +n+ is passed as the first
-    # argument to the block. If b_n is dependent on an +x+ value (see the call
-    # method) the +x+ will be the second argument of the block.
+    # Sets the `b` coefficients for this continued fraction.
+    #
+    # @example Using an array of values
+    #   cf = ContinuedFraction.new.for_b([1, 2, 3])
+    #
+    # @example Using a block
+    #   cf = ContinuedFraction.new.for_b { |n| n + 1 }
+    #
+    # @param arg [Array, nil] An array of coefficients or nil to use a block.
+    # @yield [index] A block that returns the coefficient for index `n`.
+    # @yieldparam index [Integer] The index of the coefficient to retrieve.
+    # @return [ContinuedFraction] Returns self for chaining.
     def for_b(arg = nil, &block)
       @b = for_arg(arg, &block)
       self
     end
 
+    # Checks if this is a simple continued fraction (all `b` coefficients are 1).
+    #
+    # @return [Boolean] True if all `b` coefficients are 1.
     def simple?
       @b == SIMPLE_B
     end
 
-    def inspect
-      "#<#{self.class} #{to_s}>"
-    end
-
-    include Enumerable
-    def each(&block)
-      if simple?
-        (0..Float::INFINITY).lazy.map { |i| @a[i] }.take_while { |x| x }.each(&block)
-      end
-    end
-
+    # Returns a string representation of the continued fraction.
+    #
+    # @param length [Integer] The number of terms to display for simple fractions.
+    # @return [String] A formatted string representation.
     def to_s(length: 10)
       if simple?
         convergents = take(length)
@@ -101,28 +162,44 @@ module MoreMath
       end
     end
 
-    def value(v, n, x = nil)
-      result = if x
-        v[n, x]
-      else
-        v[n]
-      end and result.to_f
+    # Returns a string representation of the continued fraction.
+    #
+    # @return [String] A detailed string representation for debugging.
+    def inspect
+      "#<#{self.class} #{to_s}>"
     end
-    private :value
 
-    # Returns the value for a_n or a_n(x).
-    def a(n, x = nil)
-      value(@a, n, x)
-    end
+    # Includes Enumerable module to allow iteration over convergents.
+    include Enumerable
 
-    # Returns the value for b_n or b_n(x).
-    def b(n, x = nil)
-      value(@b, n, x)
+    # Iterates over convergents of this continued fraction (only for simple fractions).
+    #
+    # @yield [convergent] Yields each convergent value.
+    # @yieldparam convergent [Float] The next convergent in the sequence.
+    def each(&block)
+      if simple?
+        (0..Float::INFINITY).lazy.map { |i| @a[i] }.take_while { |x| x }.each(&block)
+      end
     end
 
-    # Evaluates the continued fraction for the value +x+ (if any) with the
-    # accuracy +epsilon+ and +max_iterations+ as the maximum number of
-    # iterations using the Wallis-method with scaling.
+    # Evaluates the continued fraction for a given value `x`.
+    #
+    # For generalized continued fractions, the coefficients may depend on an external parameter `x`.
+    # The Wallis method with scaling is used for convergence.
+    #
+    # @example Evaluate the golden ratio
+    #   phi = ContinuedFraction.new
+    #   phi.()  # => 1.618033988749895
+    #
+    # @example Evaluate atan(0.5)
+    #   atan = ContinuedFraction.for_a { |n, x| n == 0 ? 0 : 2 * n - 1 }
+    #                        .for_b { |n, x| n <= 1 ? x : ((n - 1) * x) ** 2 }
+    #   atan.(0.5)  # => 0.4636476090008061
+    #
+    # @param x [Numeric, nil] Optional external parameter for variable coefficients.
+    # @param epsilon [Float] Convergence tolerance (default: 1e-16).
+    # @param max_iterations [Integer] Maximum number of iterations (default: 2^31).
+    # @return [Float] The evaluated result of the continued fraction.
     def call(x = nil, epsilon: 1E-16, max_iterations: 1 << 31)
       c_0, c_1 = 1.0, a(0, x)
       c_1 == nil and return 0 / 0.0
@@ -164,6 +241,9 @@ module MoreMath
       result
     end
 
+    # Returns the reciprocal of this continued fraction.
+    #
+    # @return [ContinuedFraction] A new continued fraction representing the reciprocal.
     def reciprocal
       if @a[0] > 0
         dup.for_a { |i| i == 0 ? 0 : @a[i - 1] }
@@ -172,14 +252,44 @@ module MoreMath
       end
     end
 
+    # Alias for the `call` method.
     alias [] call
 
+    # Alias for the `call` method.
     alias to_f call
 
-    # Returns this continued fraction as a Proc object which takes the same
-    # arguments like its call method does.
+    # Converts this continued fraction into a Proc that can be called directly.
+    #
+    # @return [Proc] A proc that accepts the same arguments as `call`.
     def to_proc
       proc { |*a| call(*a) }
     end
+
+    private
+
+    # Helper method for retrieving coefficient values, supporting both indexed access and block evaluation.
+    #
+    # @api private
+    def value(v, n, x = nil)
+      result = if x
+        v[n, x]
+      else
+        v[n]
+      end and result.to_f
+    end
+
+    # Returns the value for a_n or a_n(x).
+    #
+    # @api private
+    def a(n, x = nil)
+      value(@a, n, x)
+    end
+
+    # Returns the value for b_n or b_n(x).
+    #
+    # @api private
+    def b(n, x = nil)
+      value(@b, n, x)
+    end
   end
 end