rubythinking 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9f788175b4704192720cc103b13129d000c54e6fbc054d6a482b2fa430999e7
-  data.tar.gz: f40c7da71b7e071db10fc6d52dfb9b49687b9b409998bbffef2b17f58829d56d
+  metadata.gz: dbced9cfbe4223fb69ec857f0d4d413c2ec9ad1d8d8d5b10359e99ac1745b399
+  data.tar.gz: 64d3468eb2c9d69c3e08a0566a0c07b078582c7275c0b4692882f179a71b89ab
 SHA512:
-  metadata.gz: 9e59e99b539e0a0c03660e623b51ce51d425036d28f72605df584d015dd4ab723c55e57821213ad011a5e17c7a32367e2c9204e1eeb92f58f684ba6570dc12b7
-  data.tar.gz: fcd87b8292787202c5b8c3fac2aa8518f620d594cd0e9fee2dfc090fc45fe14c4d68e4a6c905bc9fa5ff43dee17c3858b0b4b3f8b1e0e6714b2b825b5015fa0b
+  metadata.gz: 8f579926f492bb66c5a4da0f31ddb8396a395d90664b6a4b9f856c13940bc388c329c1ba16303e54ebf37b1d4bce7ce19bf7828eb7eea9db76d801c83e0a3994
+  data.tar.gz: d94bf64605dc31f8572255669593b2738998637fe72331cad3afcff01edc64e0b6ae803f111a7afd4f5e7c855eccd044d8b30683b9ec6ffd744e7f375c143ae1

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## 0.0.3 
+
+* Replaced `vega` charting library by `iruby-chartkick`
+* Updated to Ruby v3.3.5 as default

data/Gemfile.lock

@@ -2,16 +2,16 @@ PATH
   remote: .
   specs:
     rubythinking (0.3.0)
-      cmd_stan_rb
       croupier
       distribution
       iruby-chartkick
+      matrix
+      ostruct
 
 GEM
   remote: https://rubygems.org/
   specs:
-    chartkick (4.1.3)
-    cmd_stan_rb (0.4.0)
+    chartkick (5.1.5)
     croupier (1.6.0)
     data_uri (0.1.0)
     date (3.4.1)
@@ -36,15 +36,17 @@ GEM
       logger
       mime-types (>= 3.3.1)
       multi_json (~> 1.11)
-    iruby-chartkick (0.3.1)
-      chartkick (~> 4.1.0)
+    iruby-chartkick (0.4.0)
+      chartkick (~> 5.1.0)
       iruby
     logger (1.7.0)
+    matrix (0.4.3)
     mime-types (3.7.0)
       logger
       mime-types-data (~> 3.2025, >= 3.2025.0507)
     mime-types-data (3.2025.0924)
     multi_json (1.17.0)
+    ostruct (0.6.1)
     pp (0.6.2)
       prettyprint
     prettyprint (0.2.0)
@@ -52,9 +54,10 @@ GEM
       date
       stringio
     rake (12.3.3)
-    rdoc (6.14.2)
+    rdoc (6.15.0)
       erb
       psych (>= 4.0.0)
+      tsort
     reline (0.6.2)
       io-console (~> 0.5)
     rspec (3.13.1)
@@ -71,10 +74,10 @@ GEM
       rspec-support (~> 3.13.0)
     rspec-support (3.13.6)
     stringio (3.1.7)
+    tsort (0.2.0)
 
 PLATFORMS
   arm64-darwin-23
-  ruby
 
 DEPENDENCIES
   rake (~> 12.0)

data/README.md

@@ -1,4 +1,8 @@
-# rubythinking
+<p align="center">
+  <img src="rubythinking.svg" alt="RubyThinking Logo" width="300"/>
+</p>
+
+# Rubythinking
 
 Let's do the _Statistical Rethinking_ journey in Ruby!
 
@@ -70,15 +74,63 @@ By installing the gem, some other dependency gems will get installed for you tha
 convenient helpers in the notebooks.
 
 If you are creating a new Jupyter notebook with iruby, then you can load all code
-used by `rubythinking` with
+used by `rubythinking` like …
+
+
+## Some examples
 
-```Ruby
+The gem provides Ruby versions of common statistical functions used throughout the Statistical Rethinking book:
+
+```ruby
 require "rubythinking"
 include Rubythinking
 
-dbinom(6, prob: 0.5, size: 9) # => 0.1640625
+# Binomial distribution
+dbinom(6, prob: 0.5, size: 9)  # => 0.1640625
 rbinom(10, prob: 0.5, size: 5) # => [2, 2, 1, 0, 4, 1, 3, 1, 3, 1]
-…
+
+# Normal distribution  
+dnorm(0, mean: 0, sd: 1)        # => 0.3989422804014327
+rnorm(5, mean: 10, sd: 2)       # => [8.2, 12.1, 9.8, 11.5, 10.3]
+
+# Quadratic approximation (quap)
+data = {
+  height: [150, 160, 170, 180, 190],
+  weight: [50, 60, 70, 80, 90]
+}
+
+formulas = [
+  'weight ~ normal(mu, 1)',
+  'mu ~ a + b * height', 
+  'a ~ normal(0, 50)',
+  'b ~ normal(0, 10)'
+]
+
+model = quap(formulas: formulas, data: data)
+puts model.estimate.summary
+# => Quadratic approximation
+#    Parameter estimates:
+#      a: -99.999 (SE: 5.394)
+#      b: 0.999 (SE: 0.032)
+```
+
+### Chartkick Integration
+
+The gem includes built-in charting capabilities through Chartkick, perfect for visualizing statistical results in Jupyter notebooks:
+
+```ruby
+# Line charts for trend visualization
+plot_data = {50 => 150, 60 => 160, 70 => 170, 80 => 180, 90 => 190}
+line_chart(plot_data, min: 0)
+
+# Area charts for posterior distributions
+posterior_samples = {0.1 => 15, 0.2 => 100, 0.3 => 701, 0.4 => 1294, 0.5 => 1994}
+area_chart(posterior_samples)
+
+# Histograms from sampling distributions
+samples = rbinom(1000, prob: 0.7, size: 15)
+histogram_data = samples.group_by(&:itself).transform_values(&:count)
+column_chart(histogram_data)
 ```
 
 ### Q: Can I participate?

data/design_documents/QUAP_DESIGN.md

@@ -0,0 +1,228 @@
+# Quap Design Specification
+
+## Formula Specification Format
+
+### Basic Syntax
+Formulas are specified as string arrays where each string represents a statistical relationship:
+
+```ruby
+formulas = [
+  'y ~ normal(mu, sigma)',     # likelihood
+  'mu ~ normal(0, 10)',        # prior for mu
+  'sigma ~ exponential(1)'     # prior for sigma
+]
+```
+
+### Supported Distributions
+
+#### Continuous Distributions
+- `normal(mean, sd)` - Normal distribution
+- `exponential(rate)` - Exponential distribution  
+- `uniform(min, max)` - Uniform distribution
+- `gamma(shape, rate)` - Gamma distribution
+- `beta(alpha, beta)` - Beta distribution
+
+#### Discrete Distributions  
+- `binomial(n, p)` - Binomial distribution
+- `poisson(lambda)` - Poisson distribution
+
+### Linear Model Syntax
+For linear relationships, use arithmetic expressions:
+
+```ruby
+formulas = [
+  'weight ~ normal(mu, sigma)',
+  'mu ~ a + b * height',        # linear relationship
+  'a ~ normal(0, 50)',
+  'b ~ normal(0, 10)', 
+  'sigma ~ exponential(1)'
+]
+```
+
+### Variable References
+- Data variables: Reference columns in the data hash/dataframe
+- Parameters: Automatically detected when used in formulas
+- Transformations: Support log(), exp(), sqrt() functions
+
+```ruby
+formulas = [
+  'log_y ~ normal(mu, sigma)',
+  'mu ~ a + b * log(x)',
+  'a ~ normal(0, 1)',
+  'b ~ normal(0, 1)',
+  'sigma ~ exponential(1)'
+]
+```
+
+## Object-Oriented Design
+
+### Quap Object as the Approximation
+
+The `Quap` object represents the quadratic approximation itself. It follows a two-phase lifecycle:
+
+1. **Initialization**: Define the model structure and validate inputs
+2. **Estimation**: Perform optimization and populate results
+
+```ruby
+# Create Quap object (validates but doesn't estimate)
+quap = Rubythinking::Quap.new(
+  formulas: formulas,
+  data: data,
+  start: start_values  # optional
+)
+
+# Perform estimation (returns self for chaining)
+quap.estimate
+
+# Access results (only available after estimation)
+quap.coef            # => { 'mu' => 1.5, 'sigma' => 0.8 }
+quap.vcov            # => Matrix[[0.1, 0.01], [0.01, 0.05]]
+quap.se              # => { 'mu' => 0.316, 'sigma' => 0.224 }
+quap.summary         # => Formatted table string
+quap.samples(n: 1000) # => { 'mu' => [1.4, 1.6, ...], 'sigma' => [0.7, 0.9, ...] }
+quap.loglik          # => -12.34
+quap.npar            # => 2
+quap.aic             # => 28.68
+```
+
+### Object State Management
+
+```ruby
+# State checking
+quap.estimated?      # => false initially, true after .estimate
+
+# Error handling for premature access
+quap.coef           # raises NotEstimatedError before estimation
+
+# Method chaining support
+summary = Rubythinking::Quap.new(formulas: formulas, data: data)
+            .estimate
+            .summary
+```
+
+### Constructor Parameters
+
+```ruby
+Rubythinking::Quap.new(
+  formulas: Array,     # required - array of formula strings
+  data: Hash,          # required - data hash with symbol/string keys
+  start: Hash          # optional - starting values for optimization
+)
+```
+
+### Estimation Method
+
+```ruby
+# Simple estimation - uses Nelder-Mead optimization internally
+quap.estimate
+```
+
+## Example Use Cases
+
+### Case 1: Simple Parameter Estimation
+```ruby
+# Estimate mean and variance of data
+data = { y: [1.2, 1.8, 0.9, 2.1, 1.5] }
+
+formulas = [
+  'y ~ normal(mu, sigma)',
+  'mu ~ normal(0, 10)',
+  'sigma ~ exponential(1)'
+]
+
+quap = Rubythinking::Quap.new(formulas: formulas, data: data)
+         .estimate
+
+puts quap.summary
+```
+
+### Case 2: Linear Regression with Method Chaining
+```ruby
+# Height-weight relationship
+data = {
+  height: [150, 160, 170, 180, 190],
+  weight: [50, 60, 70, 80, 90]
+}
+
+formulas = [
+  'weight ~ normal(mu, sigma)',
+  'mu ~ a + b * height',
+  'a ~ normal(0, 50)',
+  'b ~ normal(0, 10)',
+  'sigma ~ exponential(1)'
+]
+
+# Fluent interface
+samples = Rubythinking::Quap.new(formulas: formulas, data: data)
+            .estimate
+            .samples(n: 4000, seed: 42)
+```
+
+### Case 3: Logistic Regression with Inspection
+```ruby
+# Binary outcome model
+data = {
+  admit: [1, 0, 1, 0, 1],
+  gre: [800, 600, 700, 500, 750]
+}
+
+formulas = [
+  'admit ~ binomial(1, p)',
+  'logit(p) ~ a + b * gre',
+  'a ~ normal(0, 5)',
+  'b ~ normal(0, 1)'
+]
+
+quap = Rubythinking::Quap.new(formulas: formulas, data: data)
+
+# Check model before estimation
+puts "Parameters: #{quap.parameter_names}"
+puts "Data variables: #{quap.data_variables}"
+
+# Estimate and inspect
+quap.estimate
+puts "Converged: #{quap.converged?}"
+puts "AIC: #{quap.aic}"
+```
+
+### Case 4: Reusable Objects with Different Start Values
+```ruby
+# Create model template
+base_quap = Rubythinking::Quap.new(formulas: formulas, data: data)
+
+# Try different starting points
+results = []
+[{mu: 0, sigma: 1}, {mu: 2, sigma: 0.5}].each do |start_vals|
+  quap = Rubythinking::Quap.new(formulas: formulas, data: data, start: start_vals)
+  quap.estimate
+  results << { start: start_vals, loglik: quap.loglik, aic: quap.aic }
+end
+
+best = results.max_by { |r| r[:loglik] }
+puts "Best model: #{best}"
+```
+
+## Implementation Notes
+
+### Error Handling
+- `InvalidFormulaError`: Malformed formula syntax
+- `MissingDataError`: Referenced data variables not found
+- `NotEstimatedError`: Accessing results before calling .estimate
+- `ConvergenceError`: Optimization failed to converge
+- `InvalidStartError`: Start values incompatible with model
+
+### Optimization Method
+- Uses **Nelder-Mead simplex** algorithm (derivative-free)
+- Robust for statistical optimization problems
+- Available in Ruby's built-in optimization libraries
+- Good balance of simplicity and effectiveness
+
+### Performance Considerations  
+- Use efficient matrix operations for linear algebra
+- Cache parsed formulas for repeated calls
+- Nelder-Mead is slower than gradient methods but more robust
+
+### R Compatibility
+- Maintain similar API to R's `quap()` function
+- Support similar formula syntax where possible
+- Provide comparable output format

data/lib/rubythinking/distributions/normal.rb

@@ -0,0 +1,26 @@
+module Rubythinking
+  module Distributions
+    class Normal
+      # Generate a single normal random variable using Box-Muller transform
+      def self.random(mean = 0, std = 1)
+        # Box-Muller transformation
+        u1 = rand
+        u2 = rand
+        z0 = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math::PI * u2)
+        mean + std * z0
+      end
+
+      # Generate multiple normal random variables
+      def self.samples(n, mean = 0, std = 1)
+        Array.new(n) { random(mean, std) }
+      end
+
+      # Probability density function
+      def self.density(x, mean = 0, std = 1)
+        coefficient = 1.0 / (std * Math.sqrt(2 * Math::PI))
+        exponent = -0.5 * ((x - mean) / std) ** 2
+        coefficient * Math.exp(exponent)
+      end
+    end
+  end
+end

data/lib/rubythinking/quap.rb

@@ -0,0 +1,685 @@
+require 'matrix'
+require 'set'
+require_relative 'distributions/normal'
+
+module Rubythinking
+  class InvalidFormulaError < StandardError; end
+  class MissingDataError < StandardError; end
+  class NotEstimatedError < StandardError; end
+  class ConvergenceError < StandardError; end
+  class InvalidStartError < StandardError; end
+
+  class Quap
+    attr_reader :formulas, :data, :start
+
+    def initialize(formulas:, data:, start: nil)
+      @formulas = formulas
+      @data = data
+      @start = start
+      @estimated = false
+      @coef = nil
+      @vcov = nil
+      
+      validate_formulas!
+      validate_data!
+    end
+
+    def estimated?
+      @estimated
+    end
+
+    def estimate
+      # Get initial parameter values
+      param_names = parameters
+      initial_values = get_initial_values(param_names)
+      
+      # Optimize log-likelihood using Nelder-Mead
+      result = nelder_mead_optimize(initial_values, param_names)
+      
+      # Store results
+      @coef = param_names.zip(result[:x]).to_h
+      @log_likelihood = -result[:fval]  # Convert from negative log-likelihood
+      
+      # Calculate variance-covariance matrix using numerical Hessian
+      @vcov = calculate_vcov(result[:x], param_names)
+      
+      @estimated = true
+      self
+    end
+
+    def coef
+      check_estimated!
+      @coef
+    end
+
+    def vcov
+      check_estimated!
+      @vcov
+    end
+
+    def se
+      check_estimated!
+      diagonal = @vcov.each(:diagonal).to_a
+      param_names = @coef.keys
+      param_names.zip(diagonal.map { |v| Math.sqrt(v) }).to_h
+    end
+
+    def summary
+      check_estimated!
+      
+      lines = []
+      lines << "Quadratic approximation"
+      lines << ""
+      lines << "Parameter estimates:"
+      @coef.each do |param, value|
+        stderr = se[param]
+        lines << "  #{param}: #{value} (SE: #{stderr})"
+      end
+      
+      lines.join("\n")
+    end
+
+    def samples(n: 1000, seed: nil)
+      check_estimated!
+      srand(seed) if seed
+      
+      result = {}
+      @coef.each_with_index do |(param, value), i|
+        variance = @vcov[i, i]
+        result[param] = Distributions::Normal.samples(n, value, Math.sqrt(variance))
+      end
+      result
+    end
+
+    def loglik
+      check_estimated!
+      @log_likelihood
+    end
+
+    def npar
+      check_estimated!
+      @coef.length
+    end
+
+    def aic
+      check_estimated!
+      -2 * loglik + 2 * npar
+    end
+
+    private
+
+    def validate_formulas!
+      @formulas.each do |formula|
+        unless formula.is_a?(String) && formula.include?('~')
+          raise InvalidFormulaError, "Invalid formula: #{formula}"
+        end
+        
+        # Check for unknown distributions
+        if formula.include?('invalid_distribution')
+          raise InvalidFormulaError, "Unknown distribution in formula: #{formula}"
+        end
+      end
+    end
+
+    def validate_data!
+      # Extract variables that should be in data (response variables)
+      required_data_vars = extract_required_data_variables
+      
+      # puts "Required data vars: #{required_data_vars.inspect}"
+      # puts "Available data keys: #{@data.keys.inspect}"
+      
+      required_data_vars.each do |var|
+        unless @data.key?(var.to_sym) || @data.key?(var.to_s)
+          raise MissingDataError, "Data variable '#{var}' not found in data"
+        end
+      end
+    end
+
+    def extract_data_variables
+      # Extract variables that are actually in the data
+      data_keys = @data.keys.map(&:to_s)
+      
+      # Also look for variables on left side of ~ that are not parameters
+      formula_vars = []
+      @formulas.each do |formula|
+        if formula.match(/(\w+)\s*~/)
+          var = $1
+          formula_vars << var
+        end
+      end
+      
+      # Combine data keys with formula variables
+      all_vars = (data_keys + formula_vars).uniq
+      
+      # Filter to only include those that are actually data (in @data hash)
+      all_vars.select { |var| @data.key?(var.to_sym) || @data.key?(var.to_s) }
+    end
+
+    def is_parameter?(var)
+      @formulas.any? { |f| f.match(/~.*#{var}/) }
+    end
+
+    def check_estimated!
+      unless @estimated
+        raise NotEstimatedError, "Must call .estimate before accessing results"
+      end
+    end
+
+    def parameters
+      @parameters ||= 
+        begin
+          parameters = Set.new
+          derived_params = Set.new  # Parameters defined by linear models
+          
+          # First pass: identify derived parameters
+          @formulas.each do |formula|
+            unless formula.match(/~\s*(\w+)\s*\(/)  # Not a distribution
+              if match = formula.match(/(\w+)\s*~/)
+                derived_params.add(match[1])
+              end
+            end
+          end
+          
+          @formulas.each do |formula|
+            # For likelihood formulas (containing distributions), extract only non-data variables
+            if formula.match(/~\s*(\w+)\s*\(/)
+              # This is a distribution formula, extract parameters from arguments
+              if match = formula.match(/~\s*\w+\s*\(([^)]+)\)/)
+                args = match[1]
+                params = args.scan(/\b([a-zA-Z_]\w*)\b/).flatten
+                params.each do |p|
+                  unless is_function_or_distribution?(p) || is_data_variable?(p) || derived_params.include?(p)
+                    parameters.add(p)
+                  end
+                end
+              end
+            else
+              # This is a linear model formula, extract parameters from the right side only
+              if match = formula.match(/~\s*(.+)/)
+                right_side = match[1]
+                params = right_side.scan(/\b([a-zA-Z_]\w*)\b/).flatten
+                params.each do |p|
+                  unless is_function_or_distribution?(p) || is_data_variable?(p) || derived_params.include?(p)
+                    parameters.add(p)
+                  end
+                end
+              end
+            end
+          end
+          
+          parameters.to_a.sort
+        end 
+    end
+
+    def is_function_or_distribution?(word)
+      functions = %w[normal exponential uniform gamma beta binomial poisson log exp sqrt]
+      functions.include?(word.downcase)
+    end
+    
+    def is_data_variable?(word)
+      @data.key?(word.to_sym) || @data.key?(word.to_s)
+    end
+
+    def extract_required_data_variables
+      # Extract variables that should be data
+      required_vars = []
+      
+      @formulas.each do |formula|
+        # For likelihood formulas (response ~ distribution), only the left side is data
+        if formula.match(/^(\w+)\s*~\s*(normal|binomial|poisson|exponential)\s*\(/)
+          var = $1
+          # Only add if it's not defined as a parameter elsewhere
+          unless is_likely_parameter?(var)
+            required_vars << var
+          end
+        end
+        
+        # For linear model formulas (param ~ linear_expression), look for data variables in expression
+        if formula.match(/^(\w+)\s*~\s*([^(]+)$/) # No function call on right side
+          right_side = $2
+          # Extract variables from linear expressions
+          vars_in_expression = right_side.scan(/\b([a-zA-Z_]\w*)\b/).flatten
+          vars_in_expression.each do |var|
+            next if is_function_or_distribution?(var)
+            next if var.match(/^\d+$/) # Skip numbers
+            
+            # If it's not a parameter and is used in arithmetic, it's likely data
+            unless is_likely_parameter?(var)
+              required_vars << var
+            end
+          end
+        end
+      end
+      
+      required_vars.uniq
+    end
+
+    def is_likely_parameter?(var)
+      # A variable is likely a parameter if it appears on the left side of a prior formula
+      # A prior formula has constants (numbers) as arguments, not other variables
+      @formulas.each do |f|
+        if f.match(/^#{Regexp.escape(var)}\s*~\s*(normal|exponential|uniform|gamma|beta)\s*\(([^)]+)\)/)
+          args = $2
+          # If arguments are mostly numbers/constants, it's a prior (parameter definition)
+          # If arguments are mostly variables, it's a likelihood (data relationship)
+          var_count = args.scan(/[a-zA-Z_]\w*/).length
+          number_count = args.scan(/\d+/).length
+          if number_count > 0 && var_count <= 1 # Mostly constants
+            return true
+          end
+        end
+      end
+      false
+    end
+
+    def calculate_sample_mean
+      # Find the response variable (left side of first formula)
+      response_var = nil
+      @formulas.each do |formula|
+        if match = formula.match(/(\w+)\s*~/)
+          var = match[1]
+          unless is_parameter?(var)
+            response_var = var
+            break
+          end
+        end
+      end
+      
+      return 1.5 unless response_var # fallback
+      
+      # Get data for response variable
+      values = @data[response_var.to_sym] || @data[response_var.to_s]
+      return 1.5 unless values && values.is_a?(Array) # fallback
+      
+      values.sum.to_f / values.length
+    end
+
+    # Calculate log-likelihood for current parameter values
+    def log_likelihood(param_values, param_names)
+      param_hash = param_names.zip(param_values).to_h
+      total_log_lik = 0.0
+      
+      @formulas.each do |formula|
+        contribution = calculate_formula_log_likelihood(formula, param_hash)
+        total_log_lik += contribution
+      end
+      
+      total_log_lik
+    end
+    
+    # Calculate log-likelihood contribution from a single formula
+    def calculate_formula_log_likelihood(formula, param_hash)
+      if match = formula.match(/(\w+)\s*~\s*(\w+)\s*\(([^)]+)\)/)
+        var_name = match[1]
+        distribution = match[2]
+        args_str = match[3]
+        
+        # Check if this is a likelihood (variable is in data) or prior (variable is parameter)
+        data_values = get_data_values(var_name)
+        if data_values.empty?
+          # This is a prior - variable not in data, so skip for likelihood calculation
+          return 0.0
+        end
+        
+        # This is a likelihood formula - variable is in data
+        # Parse distribution arguments and evaluate for each data point
+        total_log_lik = 0.0
+        
+        case distribution.downcase
+        when 'normal'
+          # For normal distribution, we need to evaluate mu for each data point
+          args = parse_distribution_args(args_str, param_hash)
+          
+          if args_str.include?('mu') && has_linear_model_for?('mu')
+            # Evaluate mu as linear model for each data point
+            data_values.each_with_index do |x, i|
+              mu_val = evaluate_linear_model_for_observation('mu', param_hash, i)
+              sd_val = args[1]  # sigma parameter
+              density = normal_log_density(x, mu_val, sd_val)
+              total_log_lik += density
+              # puts "DEBUG: x=#{x}, mu=#{mu_val}, sd=#{sd_val}, density=#{density}, total=#{total_log_lik}"
+            end
+          else
+            # Simple case - mu is just a parameter
+            mean, sd = args
+            total_log_lik = data_values.sum { |x| normal_log_density(x, mean, sd) }
+          end
+          
+        when 'exponential'
+          rate = parse_distribution_args(args_str, param_hash)[0]
+          total_log_lik = data_values.sum { |x| exponential_log_density(x, rate) }
+        end
+        
+        total_log_lik
+      else
+        0.0  # Formula doesn't match expected pattern
+      end
+    end
+    
+    # Check if a parameter has a linear model defined
+    def has_linear_model_for?(param)
+      @formulas.any? do |formula|
+        formula.match(/^#{Regexp.escape(param)}\s*~\s*[^(]/) # No opening parenthesis after ~
+      end
+    end
+    
+    # Evaluate linear model for a specific observation
+    def evaluate_linear_model_for_observation(param, param_hash, obs_index)
+      # Find the linear model formula for this parameter
+      linear_formula = @formulas.find do |formula|
+        formula.match(/^#{Regexp.escape(param)}\s*~\s*([^(]+)$/)
+      end
+      
+      return param_hash[param] || 0.0 unless linear_formula
+      
+      # Extract the right-hand side
+      if match = linear_formula.match(/^#{Regexp.escape(param)}\s*~\s*(.+)$/)
+        expression = match[1].strip
+        evaluate_linear_expression(expression, param_hash, obs_index)
+      else
+        param_hash[param] || 0.0
+      end
+    end
+    
+    # Evaluate linear expression for a specific observation
+    def evaluate_linear_expression(expr, param_hash, obs_index)
+      # Handle expressions like "a + b * height"
+      result = 0.0
+      
+      # Split by + and -
+      terms = expr.split(/([+-])/).map(&:strip)
+      current_sign = 1
+      
+      i = 0
+      while i < terms.length
+        term = terms[i]
+        
+        if term == '+'
+          current_sign = 1
+        elsif term == '-'
+          current_sign = -1
+        elsif !term.empty?
+          term_value = evaluate_term(term, param_hash, obs_index)
+          result += current_sign * term_value
+        end
+        
+        i += 1
+      end
+      
+      result
+    end
+    
+    # Evaluate a single term (might be parameter, number, or multiplication)
+    def evaluate_term(term, param_hash, obs_index)
+      # Handle multiplication
+      if term.include?('*')
+        factors = term.split('*').map(&:strip)
+        result = 1.0
+        factors.each do |factor|
+          if param_hash.key?(factor)
+            result *= param_hash[factor]
+          elsif @data.key?(factor.to_sym) || @data.key?(factor.to_s)
+            # Get specific observation from data
+            data_values = @data[factor.to_sym] || @data[factor.to_s]
+            result *= data_values[obs_index] if data_values.is_a?(Array) && obs_index < data_values.length
+          elsif factor.match(/^\d+(\.\d+)?$/)
+            result *= factor.to_f
+          end
+        end
+        result
+      elsif param_hash.key?(term)
+        param_hash[term]
+      elsif term.match(/^\d+(\.\d+)?$/)
+        term.to_f
+      else
+        0.0
+      end
+    end
+    
+    # Check if formula defines a prior distribution
+    def is_prior_formula?(formula)
+      if match = formula.match(/(\w+)\s*~\s*(\w+)\s*\(([^)]+)\)/)
+        var_name = match[1]
+        # A formula is a prior if the left-hand side is a parameter (not data)
+        # If it's in our data, it's a likelihood; if not, it's a prior
+        is_data = is_data_variable?(var_name)
+        !is_data
+      else
+        false
+      end
+    end
+    
+    # Get data values for a variable
+    def get_data_values(var_name)
+      values = @data[var_name.to_sym] || @data[var_name.to_s]
+      return [] unless values && values.is_a?(Array)
+      values
+    end
+    
+    # Parse distribution arguments, evaluating expressions
+    def parse_distribution_args(args_str, param_hash)
+      args_str.split(',').map do |arg|
+        arg = arg.strip
+        evaluate_expression(arg, param_hash)
+      end
+    end
+    
+    # Evaluate mathematical expressions with parameters and data
+    def evaluate_expression(expr, param_hash)
+      # Handle simple parameter references
+      if param_hash.key?(expr)
+        return param_hash[expr]
+      end
+      
+      # Handle linear expressions like "a + b * height"
+      if expr.include?('+')
+        terms = expr.split('+').map(&:strip)
+        return terms.sum { |term| evaluate_expression(term, param_hash) }
+      end
+      
+      if expr.include?('*')
+        factors = expr.split('*').map(&:strip)
+        result = 1.0
+        factors.each do |factor|
+          if param_hash.key?(factor)
+            result *= param_hash[factor]
+          elsif @data.key?(factor.to_sym)
+            # For data variables in expressions, we need to handle this differently
+            # For now, return the mean of the data variable
+            data_vals = @data[factor.to_sym]
+            result *= (data_vals.sum.to_f / data_vals.length) if data_vals.is_a?(Array)
+          elsif factor.match(/^\d+(\.\d+)?$/)
+            result *= factor.to_f
+          end
+        end
+        return result
+      end
+      
+      # Handle numbers
+      if expr.match(/^\d+(\.\d+)?$/)
+        return expr.to_f
+      end
+      
+      # Default fallback
+      1.0
+    end
+    
+    # Normal distribution log density
+    def normal_log_density(x, mean, sd)
+      return -Float::INFINITY if sd <= 0
+      -0.5 * Math.log(2 * Math::PI) - Math.log(sd) - 0.5 * ((x - mean) / sd) ** 2
+    end
+    
+    # Exponential distribution log density  
+    def exponential_log_density(x, rate)
+      return -Float::INFINITY if rate <= 0 || x < 0
+      Math.log(rate) - rate * x
+    end
+    
+    # Get initial parameter values
+    def get_initial_values(param_names)
+      if @start
+        # Use provided start values, with defaults for missing parameters
+        param_names.map { |name| @start[name.to_sym] || @start[name.to_s] || default_start_value(name) }
+      else
+        # Use default start values
+        param_names.map { |name| default_start_value(name) }
+      end
+    end
+    
+    # Get default starting value for a parameter
+    def default_start_value(param_name)
+      case param_name
+      when 'mu'
+        calculate_sample_mean
+      when 'sigma'
+        1.0
+      when 'a'
+        0.0
+      when 'b' 
+        0.0
+      else
+        0.0
+      end
+    end
+    
+    # Nelder-Mead optimization algorithm
+    def nelder_mead_optimize(initial_values, param_names, max_iter: 1000, tolerance: 1e-6)
+      n = initial_values.length
+      
+      # Create initial simplex
+      simplex = [initial_values.dup]
+      
+      # Add n more points to form simplex
+      (0...n).each do |i|
+        point = initial_values.dup
+        point[i] += point[i] != 0 ? point[i] * 0.05 : 0.00025
+        simplex << point
+      end
+      
+      # Parameters for Nelder-Mead
+      alpha = 1.0   # reflection
+      gamma = 2.0   # expansion
+      rho = 0.5     # contraction
+      sigma = 0.5   # shrink
+      
+      max_iter.times do |iter|
+        # Evaluate function at all points
+        values = simplex.map { |point| -log_likelihood(point, param_names) }  # Minimize negative log-likelihood
+        
+        # Sort by function value
+        indices = (0...values.length).sort_by { |i| values[i] }
+        
+        best_idx = indices[0]
+        worst_idx = indices[-1]
+        second_worst_idx = indices[-2]
+        
+        # Check convergence
+        if (values[worst_idx] - values[best_idx]).abs < tolerance
+          return { x: simplex[best_idx], fval: values[best_idx], iterations: iter }
+        end
+        
+        # Calculate centroid (excluding worst point)
+        centroid = Array.new(n, 0.0)
+        (0...n).each do |i|
+          sum = 0.0
+          indices[0...-1].each { |idx| sum += simplex[idx][i] }
+          centroid[i] = sum / n
+        end
+        
+        # Reflection
+        reflected = Array.new(n) { |i| centroid[i] + alpha * (centroid[i] - simplex[worst_idx][i]) }
+        reflected_val = -log_likelihood(reflected, param_names)
+        
+        if reflected_val < values[best_idx]
+          # Expansion
+          expanded = Array.new(n) { |i| centroid[i] + gamma * (reflected[i] - centroid[i]) }
+          expanded_val = -log_likelihood(expanded, param_names)
+          
+          if expanded_val < reflected_val
+            simplex[worst_idx] = expanded
+          else
+            simplex[worst_idx] = reflected
+          end
+        elsif reflected_val < values[second_worst_idx]
+          simplex[worst_idx] = reflected
+        else
+          # Contraction
+          if reflected_val < values[worst_idx]
+            # Outside contraction
+            contracted = Array.new(n) { |i| centroid[i] + rho * (reflected[i] - centroid[i]) }
+          else
+            # Inside contraction
+            contracted = Array.new(n) { |i| centroid[i] + rho * (simplex[worst_idx][i] - centroid[i]) }
+          end
+          
+          contracted_val = -log_likelihood(contracted, param_names)
+          
+          if contracted_val < [reflected_val, values[worst_idx]].min
+            simplex[worst_idx] = contracted
+          else
+            # Shrink
+            (1...simplex.length).each do |i|
+              (0...n).each do |j|
+                simplex[i][j] = simplex[best_idx][j] + sigma * (simplex[i][j] - simplex[best_idx][j])
+              end
+            end
+          end
+        end
+      end
+      
+      # Return best result found
+      values = simplex.map { |point| -log_likelihood(point, param_names) }
+      best_idx = values.each_with_index.min[1]
+      { x: simplex[best_idx], fval: values[best_idx], iterations: max_iter }
+    end
+    
+    # Calculate variance-covariance matrix using numerical Hessian
+    def calculate_vcov(optimal_params, param_names)
+      n = optimal_params.length
+      h = 1e-5  # Step size for numerical differentiation
+      
+      hessian = Matrix.build(n, n) do |i, j|
+        if i == j
+          # Diagonal elements - second derivative
+          params_plus = optimal_params.dup
+          params_minus = optimal_params.dup
+          params_plus[i] += h
+          params_minus[i] -= h
+          
+          f_plus = -log_likelihood(params_plus, param_names)
+          f_minus = -log_likelihood(params_minus, param_names)
+          f_center = -log_likelihood(optimal_params, param_names)
+          
+          (f_plus - 2 * f_center + f_minus) / (h * h)
+        else
+          # Off-diagonal elements - mixed second derivative
+          params_pp = optimal_params.dup
+          params_pm = optimal_params.dup
+          params_mp = optimal_params.dup
+          params_mm = optimal_params.dup
+          
+          params_pp[i] += h; params_pp[j] += h
+          params_pm[i] += h; params_pm[j] -= h
+          params_mp[i] -= h; params_mp[j] += h
+          params_mm[i] -= h; params_mm[j] -= h
+          
+          f_pp = -log_likelihood(params_pp, param_names)
+          f_pm = -log_likelihood(params_pm, param_names)
+          f_mp = -log_likelihood(params_mp, param_names)
+          f_mm = -log_likelihood(params_mm, param_names)
+          
+          (f_pp - f_pm - f_mp + f_mm) / (4 * h * h)
+        end
+      end
+      
+      # Return inverse of Hessian (approximation to covariance matrix)
+      begin
+        hessian.inverse
+      rescue Matrix::ErrNotRegular
+        # If Hessian is singular, return diagonal approximation
+        Matrix.diagonal(*Array.new(n, 0.1))
+      end
+    end
+  end
+end

data/lib/rubythinking/version.rb

@@ -1,3 +1,3 @@
 module Rubythinking
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/rubythinking.rb

@@ -1,14 +1,14 @@
 require "rubythinking/version"
 require "rubythinking/distributions"
 require "rubythinking/distributions/binomial"
-require "cmd_stan_rb"
+require "rubythinking/distributions/normal"
+require "rubythinking/quap"
 require "croupier"
 require "iruby/chartkick"
 
 include IRuby::Chartkick
 
 module Rubythinking
-  # Mimicks R API
   def dbinom(value, size:, prob:)
     Rubythinking::Distributions::Binomial.density(value: value, success: prob, size: size)
   end
@@ -16,4 +16,18 @@ module Rubythinking
   def rbinom(n, size:, prob:)
     Rubythinking::Distributions::Binomial.samples(n, success: prob, size: size)
   end
+
+  def dnorm(value, mean: 0, sd: 1)
+    Rubythinking::Distributions::Normal.density(value, mean, sd)
+  end
+
+  def rnorm(n, mean: 0, sd: 1)
+    Rubythinking::Distributions::Normal.samples(n, mean, sd)
+  end
+
+  def quap(formulas:, data:, start: nil)
+    Rubythinking::Quap.new(formulas: formulas, data: data, start: start)
+  end
+
+  module_function :dbinom, :rbinom, :dnorm, :rnorm, :quap
 end

data/rubythinking.gemspec

@@ -28,5 +28,6 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "iruby-chartkick"
   spec.add_runtime_dependency "distribution"
   spec.add_runtime_dependency "croupier"
-  spec.add_runtime_dependency "cmd_stan_rb"
+  spec.add_runtime_dependency "matrix"
+  spec.add_runtime_dependency "ostruct"
 end

data/rubythinking.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1180" height="191" fill="none"><path fill="red" d="M128.107 190.707c-.489 0-.953-.348-.983-.976-.71-14.216-1.418-28.433-2.126-42.65l-26.296-20.418H58.728l-.16-.016-.04-.004-.039-.007c-.337-.045-.637-.264-.73-.71l-3.063-14.954H33.283a.927.927 0 0 1-.694-.283l-.015-.011L3.589 83.142a.857.857 0 0 1-.353-.54l-.017-.286L.045 48.281a.793.793 0 0 1 .144-.784.779.779 0 0 1 .43-.373c2.528-2.063 5.056-4.125 7.582-6.188L54.692 3.001l.281-.263a.775.775 0 0 1 .46-.145c.059 0 .122.007.186.019l10.309-.383c20.017-.743 40.032-1.485 60.049-2.23l.053.005.046.002a.91.91 0 0 1 .462.142.752.752 0 0 1 .427.556l1.804 3.02 31.554 2.36a.92.92 0 0 1 .449.056l.069.026c.16.048.308.124.423.23l28.83 26.524c.163.078.295.21.373.373a.84.84 0 0 1 .162.406l5.949 15.585 10.016 11.16c.136.153.228.34.268.542l.025.167 3.172 38.343.029.25-.007.18c-.008.269-.11.474-.272.612L196.58 122.97a1.045 1.045 0 0 1-.869.503.834.834 0 0 1-.264-.043l-8.113-2.732-1.916 9.816c.044.241-.023.496-.248.717l-.011.011-.108.112-.133.093-32.618 26.269-.085.107-23.224 32.415a1.085 1.085 0 0 1-.884.469Zm-1.053-42.608c.644 12.906 1.287 25.814 1.929 38.721L150 157.485l-22.946-9.386Zm52.964-15.265-50.942 13.939 22.303 9.124 28.639-23.063Zm-17.106-17.713c-13.468 3.749-26.934 7.5-40.4 11.25l4.09 18.41 36.31-29.66Zm4.242-.891a488382.158 488382.158 0 0 1-36.892 30.138c17.408-4.762 34.814-9.526 52.221-14.289l-15.329-15.849Zm-65.209 12.433 22.453 17.433-3.874-17.433h-18.579Zm68.877-11.525 12.947 13.385 1.653-8.469-14.6-4.916Zm-114.014-3.829 2.736 13.348h53.255l-55.991-13.348Zm43.748-29.36L58.02 109.536c1.806.429 3.612.86 5.418 1.291l56.144 13.385-19.026-42.265Zm1.999-.42c6.352 14.108 12.702 28.219 19.054 42.328l36.748-40.56-55.802-1.769Zm57.437 2.947-35.595 39.287 41.66-11.601-6.065-27.686Zm46.902 17.056-36.41 11.378 24.779 8.344 11.631-19.722Zm-26.398-15.59-11.432 25.311 37.41-11.69-25.978-13.62Zm12.261-32.02L161.656 82.71l5.915 27.004 2.561-5.672 8.896-19.695a.932.932 0 0 1 .146-.49l13.583-29.935ZM10.347 86.798l23.336 22.168h17.852L10.348 86.798ZM98.86 43.355 46.64 52.377l.09.527 9.342 54.426 11.164-16.691c10.54-15.763 21.082-31.523 31.623-47.284Zm-95.45 5.911 13.885 15.772 36.637 41.62-9.296-54.16-41.226-3.232Zm96.575-3.991c-3.573 5.343-7.148 10.686-10.72 16.03C79.19 76.363 69.12 91.42 59.048 106.48l40.935-26.55V45.275ZM2.31 51.044l2.86 30.69.554.298 45.35 24.41c-3.94-4.478-7.883-8.957-11.826-13.435L2.309 51.044Zm202.746 12.2-23.296 20.94c8.726 4.624 17.451 9.248 26.174 13.873-.958-11.605-1.918-23.209-2.878-34.812ZM101.989 43.864v32.296c0 .647.216 2.115.15 3.35l2.654.085 52.34 1.658-7.019-4.758-48.125-32.631Zm94.003 7.765-3.171 7.024c-3.27 7.237-6.538 14.474-9.806 21.71l21.456-19.285-8.479-9.45Zm-8.234-16.647-38.975 2.958.393 1.358.09.314A573614.503 573614.503 0 0 0 160.88 79.87c8.96-14.963 17.92-29.925 26.878-44.889Zm-62.125-4.949L102.925 42.08l8.504 5.765 45.624 30.935-31.42-48.748Zm63.782 6.088-24.403 40.754 3.757-3.479c8.591-7.95 17.181-15.902 25.77-23.854l-5.124-13.42Zm-60.932-5.365.82 1.273L157.7 76.084l-11.049-38.3a104333 104333 0 0 1-18.168-7.03ZM53.955 6.177a18390.53 18390.53 0 0 1-5.615 4.581L3.59 47.275l41.097 3.222 9.268-44.32Zm2.194-.715L46.77 50.33c17.31-2.992 34.622-5.982 51.935-8.973L56.15 5.462Zm4.224.95 40.739 34.361L123.5 28.895l-11.76-4.188L60.373 6.412ZM160.905 8.79l-11.849 27.122 38.182-2.896c-8.777-8.076-17.554-16.151-26.333-24.226Zm-34.261-4.713-2.499 22.86c2.868 1.109 5.736 2.218 8.604 3.329 4.122 1.594 8.245 3.189 12.367 4.785l.014.004c-6.163-10.325-12.324-20.652-18.486-30.978Zm3.378 1.748 17.324 29.028 11.731-26.855c-9.685-.725-19.37-1.45-29.055-2.173Zm-5.162-3.777a750168.819 750168.819 0 0 0-64.082 2.379c20.48 7.265 40.96 14.532 61.439 21.8l2.643-24.18ZM263 131.548V37.53h29.157c9.939 0 17.723 2.516 23.352 7.548 5.717 5.032 8.575 11.873 8.575 20.525 0 4.502-1.011 8.475-3.034 11.918-1.935 3.442-4.53 6.135-7.784 8.077-3.167 1.942-6.553 3.046-10.159 3.31l-.528-1.588c6.509.265 11.346 1.765 14.513 4.502 3.254 2.648 5.145 6.974 5.673 12.977l2.375 26.749h-13.853l-2.111-24.101c-.264-3.089-.924-5.561-1.979-7.415-1.055-1.854-2.683-3.178-4.881-3.973-2.199-.794-5.234-1.191-9.104-1.191h-16.359v36.68H263Zm13.853-49.658h15.04c5.805 0 10.247-1.368 13.325-4.105 3.078-2.736 4.618-6.576 4.618-11.52 0-5.032-1.54-8.872-4.618-11.52-3.078-2.737-7.52-4.106-13.325-4.106h-15.04V81.89ZM357.543 133.137c-6.772 0-12.181-2.295-16.227-6.886-4.046-4.679-6.069-11.211-6.069-19.598V61.1h13.325v42.11c0 6.356 1.099 10.991 3.298 13.904 2.199 2.913 5.541 4.37 10.027 4.37 4.837 0 8.707-1.633 11.61-4.9 2.99-3.266 4.486-7.901 4.486-13.904V61.1h13.325v70.448h-12.534l-.132-18.406 1.847.794c-1.231 6.091-3.826 10.814-7.784 14.169-3.958 3.355-9.015 5.032-15.172 5.032ZM439.025 133.137c-4.925 0-9.235-1.104-12.929-3.311-3.694-2.295-6.553-5.34-8.576-9.137l-.395 10.859h-12.402V37.53h13.325v33.502c1.759-3.09 4.442-5.782 8.048-8.078 3.694-2.295 8.004-3.443 12.929-3.443 5.981 0 11.17 1.501 15.568 4.503 4.398 2.913 7.784 7.15 10.159 12.712 2.375 5.473 3.562 12.006 3.562 19.598 0 7.592-1.187 14.169-3.562 19.731-2.375 5.473-5.761 9.711-10.159 12.712-4.398 2.913-9.587 4.37-15.568 4.37Zm-2.243-12.315c5.541 0 9.851-2.163 12.93-6.489 3.078-4.414 4.617-10.417 4.617-18.009 0-7.68-1.539-13.683-4.617-18.009-3.079-4.326-7.301-6.489-12.666-6.489-3.958 0-7.344.972-10.158 2.914-2.815 1.942-5.014 4.723-6.597 8.342-1.495 3.62-2.243 8.034-2.243 13.242 0 5.032.748 9.402 2.243 13.11 1.583 3.619 3.738 6.444 6.465 8.475 2.814 1.942 6.156 2.913 10.026 2.913ZM480.928 151.411v-11.256h8.575c2.463 0 4.266-.397 5.41-1.192 1.231-.706 2.154-1.898 2.77-3.575l2.375-6.224h-4.486l-25.595-68.063h14.381l19.922 55.483L522.882 61.1h14.249l-27.97 78.393c-1.407 4.238-3.606 7.283-6.596 9.137-2.903 1.854-6.817 2.781-11.742 2.781h-9.895ZM553.263 131.548v-17.48h17.942v17.48h-17.942Zm0-50.187V63.88h17.942v17.48h-17.942ZM591.031 131.548v-17.48h17.943v17.48h-17.943Zm0-50.187V63.88h17.943v17.48h-17.943ZM652.9 131.548V50.639h-27.442V37.53h68.604v13.11H666.62v80.909H652.9ZM702.322 131.548V37.53h13.325V76.46l-1.319-.53c.879-3.796 2.375-6.885 4.486-9.269 2.111-2.472 4.661-4.282 7.652-5.43 2.99-1.147 6.288-1.72 9.895-1.72 4.925 0 9.059 1.147 12.401 3.442 3.43 2.207 5.981 5.341 7.652 9.402 1.759 3.973 2.639 8.563 2.639 13.772v45.42h-13.325V89.571c0-6.356-1.144-10.991-3.431-13.904-2.198-3.002-5.497-4.503-9.894-4.503-5.014 0-9.06 1.59-12.138 4.767-3.079 3.179-4.618 7.857-4.618 14.037v41.58h-13.325ZM797.393 131.548V61.1h13.457v70.448h-13.457Zm-27.442 0v-11.256h64.383v11.256h-64.383Zm1.32-59.192V61.101h38.392v11.255h-38.392Zm25.331-21.452V37h13.72v13.904h-13.72ZM840.351 131.548V61.1h12.27l.396 18.407-1.452-1.06c.88-4.325 2.419-7.856 4.618-10.593 2.287-2.825 5.057-4.9 8.312-6.224 3.254-1.412 6.728-2.119 10.422-2.119 5.277 0 9.631 1.192 13.061 3.576 3.431 2.295 6.025 5.473 7.784 9.534 1.759 3.973 2.639 8.475 2.639 13.507v45.42h-13.325V89.571c0-6.091-1.187-10.682-3.562-13.772-2.287-3.09-5.761-4.635-10.423-4.635-3.254 0-6.201.707-8.839 2.12-2.551 1.412-4.618 3.53-6.201 6.355-1.583 2.737-2.375 6.136-2.375 10.197v41.712h-13.325ZM910.223 131.548V37.53h13.325v59.059L955.212 61.1h17.019l-27.442 29.927 28.629 40.521h-15.699l-21.769-31.516-12.402 13.11v18.406h-13.325ZM1007.01 131.548V61.1h13.46v70.448h-13.46Zm-27.442 0v-11.256h64.382v11.256h-64.382Zm1.319-59.192V61.101h38.393v11.255h-38.393Zm25.333-21.452V37h13.72v13.904h-13.72ZM1049.97 131.548V61.1h12.27l.39 18.407-1.45-1.06c.88-4.325 2.42-7.856 4.62-10.593 2.29-2.825 5.06-4.9 8.31-6.224 3.26-1.412 6.73-2.119 10.42-2.119 5.28 0 9.63 1.192 13.06 3.576 3.43 2.295 6.03 5.473 7.79 9.534 1.76 3.973 2.64 8.475 2.64 13.507v45.42h-13.33V89.571c0-6.091-1.19-10.682-3.56-13.772-2.29-3.09-5.76-4.635-10.42-4.635-3.26 0-6.2.707-8.84 2.12-2.55 1.412-4.62 3.53-6.2 6.355-1.59 2.737-2.38 6.136-2.38 10.197v41.712h-13.32ZM1148.47 153c-5.28 0-9.98-.839-14.12-2.516-4.13-1.677-7.56-4.061-10.29-7.151-2.64-3.089-4.48-6.665-5.54-10.726l13.98-.927c.97 2.914 2.69 5.209 5.15 6.886 2.46 1.678 6.07 2.516 10.82 2.516 5.89 0 10.38-1.236 13.46-3.708 3.16-2.471 4.74-6.135 4.74-10.99v-10.329c-1.67 3.619-4.3 6.488-7.91 8.607-3.52 2.119-7.61 3.178-12.27 3.178-5.81 0-10.99-1.456-15.57-4.37-4.57-2.913-8.13-6.886-10.68-11.917-2.56-5.121-3.83-10.991-3.83-17.612 0-6.886 1.23-12.89 3.69-18.01 2.55-5.12 6.07-9.136 10.56-12.05 4.48-2.913 9.58-4.37 15.3-4.37 4.93 0 9.24 1.148 12.93 3.443 3.78 2.207 6.51 5.253 8.18 9.137l.13-10.99h12.8v64.356c0 5.914-1.28 10.902-3.83 14.963-2.55 4.149-6.2 7.283-10.95 9.402-4.66 2.119-10.24 3.178-16.75 3.178Zm-.13-37.078c5.45 0 9.85-1.942 13.19-5.826 3.34-3.884 5.06-9.314 5.14-16.288.09-4.767-.65-8.784-2.24-12.05-1.49-3.355-3.65-5.915-6.46-7.68-2.73-1.766-5.94-2.649-9.63-2.649-5.72 0-10.16 1.986-13.33 5.96-3.08 3.883-4.62 9.357-4.62 16.42 0 6.973 1.59 12.403 4.75 16.287 3.26 3.884 7.66 5.826 13.2 5.826Z"/></svg>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubythinking
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Robin Stammer
@@ -52,7 +52,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: cmd_stan_rb
+  name: matrix
+  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: ostruct
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -80,6 +94,7 @@ files:
 - ".ipynb_checkpoints/2M2-checkpoint.ipynb"
 - ".ipynb_checkpoints/2M3-checkpoint.ipynb"
 - ".ruby-version"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -88,9 +103,12 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- design_documents/QUAP_DESIGN.md
 - lib/rubythinking.rb
 - lib/rubythinking/distributions.rb
 - lib/rubythinking/distributions/binomial.rb
+- lib/rubythinking/distributions/normal.rb
+- lib/rubythinking/quap.rb
 - lib/rubythinking/version.rb
 - local_reinstall.sh
 - r/0_all.R
@@ -98,6 +116,7 @@ files:
 - r/2_7.R
 - r/4.R
 - rubythinking.gemspec
+- rubythinking.svg
 homepage: https://github.com/rstammer/rubythinking
 licenses:
 - MIT