field_test 0.8.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70d3fdf1a39390631baa12589f108d99852f02009daaaf9ca0d50756630bb3c9
-  data.tar.gz: ba0700b9b9eaed0610d7343e7dff096e6e0e3572919832e8deae189fe5833df8
+  metadata.gz: 613be253211f115808fccbc17aba8eae3a6bf2a713eaee82d3c0a8d27ad02330
+  data.tar.gz: 11f3a88aa737f8c69dde0760863a6ec2a25995172a478f32afeb262276dcdbe8
 SHA512:
-  metadata.gz: 4f6c1c6c82b05b4373ef899c1c53ee4d788eb5d9eabc90d827db7e04ee66ec8bc398047f2d080be14af031fd461632078cfa88dcbe9a776ef64d0647f7854cbe
-  data.tar.gz: 768f3018bbb87d22f4d39b41b09ec02914f2a7c4de679236675a2280fbee7bf90c64f09e4645f8966dbc79204ed267a2dcf03df6cfecc432b3103e15eeb5a4cd
+  metadata.gz: a9daeb6b4dcff1b8deb97c94e3cab45c046137bf3c6665f1ba2833bcf43fd4f772b5f0c2f91e471824a394f3261baa9c712160f6fb521e3878716161f054fbb7
+  data.tar.gz: c3c77d85c8eb6eef81a7b8d545e51c086635b6ed509b354e7f8473d1b6064fadca790411668c783dd6044d45b8ab55d17ceeddaaf5bee4dabf9b0e3f810eb00e

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 1.0.0 (2026-04-01)
+
+- Improved installation time
+- Dropped support for Ruby < 3.3 and Rails < 7.2
+
 ## 0.8.0 (2025-05-05)
 
 - Dropped support for Ruby < 3.2 and Rails < 7.1

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2016-2024 Andrew Kane
+Copyright (c) 2016-2026 Andrew Kane
 
 MIT License
 

data/README.md

@@ -189,8 +189,8 @@ Keep track of when experiments started and ended. Use any format `Time.parse` ac
 ```yml
 experiments:
   button_color:
-    started_at: Dec 1, 2024 8 am PST
-    ended_at: Dec 8, 2024 2 pm PST
+    started_at: Dec 1, 2025 8 am PST
+    ended_at: Dec 8, 2025 2 pm PST
 ```
 
 Add a friendlier name and description with:

data/app/controllers/field_test/base_controller.rb

@@ -1,9 +1,9 @@
 module FieldTest
   class BaseController < ActionController::Base
-    layout "field_test/application"
+    http_basic_authenticate_with name: ENV["FIELD_TEST_USERNAME"], password: ENV["FIELD_TEST_PASSWORD"] if ENV["FIELD_TEST_PASSWORD"]
 
     protect_from_forgery with: :exception
 
-    http_basic_authenticate_with name: ENV["FIELD_TEST_USERNAME"], password: ENV["FIELD_TEST_PASSWORD"] if ENV["FIELD_TEST_PASSWORD"]
+    layout "field_test/application"
   end
 end

data/ext/field_test/bayestest.h

@@ -0,0 +1,381 @@
+/*
+ * BayesTest C v0.1.1
+ * https://github.com/ankane/bayestest-c
+ * MIT License
+ */
+
+#pragma once
+
+#include <limits.h>
+#include <math.h>
+#include <stdlib.h>
+
+/// @private
+static inline double bayestest_logbeta(double a, double b) {
+    // TODO use lgamma_r when available
+    return lgamma(a) + lgamma(b) - lgamma(a + b);
+}
+
+/// @private
+static inline double bayestest_prob_b_beats_a(int alpha_a, int beta_a, int alpha_b, int beta_b) {
+    double total = 0.0;
+    double logbeta_aa_ba = bayestest_logbeta(alpha_a, beta_a);
+    double beta_ba = beta_b + beta_a;
+
+    for (int i = 0; i < alpha_b; i++) {
+        total += exp(
+            bayestest_logbeta(alpha_a + i, beta_ba) - log(beta_b + i)
+            - bayestest_logbeta(1 + i, beta_b) - logbeta_aa_ba
+        );
+    }
+
+    return total;
+}
+
+/// @private
+static inline double bayestest_prob_c_beats_ab(
+    int alpha_a,
+    int beta_a,
+    int alpha_b,
+    int beta_b,
+    int alpha_c,
+    int beta_c
+) {
+    double* log_bb_j_logbeta_j_bb = malloc(sizeof(double) * (unsigned int) alpha_b);
+    double* logbeta_ac_i_j = malloc(sizeof(double) * (unsigned int) (alpha_a + alpha_b));
+
+    if (log_bb_j_logbeta_j_bb == NULL || logbeta_ac_i_j == NULL) {
+        free(log_bb_j_logbeta_j_bb);
+        free(logbeta_ac_i_j);
+        return NAN;
+    }
+
+    double total = 0.0;
+    double logbeta_ac_bc = bayestest_logbeta(alpha_c, beta_c);
+
+    for (int j = 0; j < alpha_b; j++) {
+        log_bb_j_logbeta_j_bb[j] = log(beta_b + j) + bayestest_logbeta(1 + j, beta_b);
+    }
+
+    double abc = beta_a + beta_b + beta_c;
+    for (int i = 0; i < alpha_a + alpha_b; i++) {
+        logbeta_ac_i_j[i] = bayestest_logbeta(alpha_c + i, abc);
+    }
+
+    for (int i = 0; i < alpha_a; i++) {
+        double sum_i = -log(beta_a + i) - bayestest_logbeta(1 + i, beta_a) - logbeta_ac_bc;
+
+        for (int j = 0; j < alpha_b; j++) {
+            total += exp(sum_i + logbeta_ac_i_j[i + j] - log_bb_j_logbeta_j_bb[j]);
+        }
+    }
+
+    free(log_bb_j_logbeta_j_bb);
+    free(logbeta_ac_i_j);
+
+    return 1 - bayestest_prob_b_beats_a(alpha_c, beta_c, alpha_a, beta_a)
+        - bayestest_prob_b_beats_a(alpha_c, beta_c, alpha_b, beta_b) + total;
+}
+
+/// @private
+static inline double bayestest_prob_d_beats_abc(
+    int alpha_a,
+    int beta_a,
+    int alpha_b,
+    int beta_b,
+    int alpha_c,
+    int beta_c,
+    int alpha_d,
+    int beta_d
+) {
+    double* log_bb_j_logbeta_j_bb = malloc(sizeof(double) * (unsigned int) alpha_b);
+    double* log_bc_k_logbeta_k_bc = malloc(sizeof(double) * (unsigned int) alpha_c);
+    double* logbeta_bd_i_j_k = malloc(
+        sizeof(double) * (unsigned int) (alpha_a + alpha_b + alpha_c)
+    );
+
+    if (log_bb_j_logbeta_j_bb == NULL || log_bc_k_logbeta_k_bc == NULL
+        || logbeta_bd_i_j_k == NULL) {
+        free(log_bb_j_logbeta_j_bb);
+        free(log_bc_k_logbeta_k_bc);
+        free(logbeta_bd_i_j_k);
+        return NAN;
+    }
+
+    double total = 0.0;
+    double logbeta_ad_bd = bayestest_logbeta(alpha_d, beta_d);
+
+    for (int j = 0; j < alpha_b; j++) {
+        log_bb_j_logbeta_j_bb[j] = log(beta_b + j) + bayestest_logbeta(1 + j, beta_b);
+    }
+
+    for (int k = 0; k < alpha_c; k++) {
+        log_bc_k_logbeta_k_bc[k] = log(beta_c + k) + bayestest_logbeta(1 + k, beta_c);
+    }
+
+    double abcd = beta_a + beta_b + beta_c + beta_d;
+    for (int i = 0; i < alpha_a + alpha_b + alpha_c; i++) {
+        logbeta_bd_i_j_k[i] = bayestest_logbeta(alpha_d + i, abcd);
+    }
+
+    for (int i = 0; i < alpha_a; i++) {
+        double sum_i = -log(beta_a + i) - bayestest_logbeta(1 + i, beta_a) - logbeta_ad_bd;
+
+        for (int j = 0; j < alpha_b; j++) {
+            double sum_j = sum_i - log_bb_j_logbeta_j_bb[j];
+
+            for (int k = 0; k < alpha_c; k++) {
+                total += exp(sum_j + logbeta_bd_i_j_k[i + j + k] - log_bc_k_logbeta_k_bc[k]);
+            }
+        }
+    }
+
+    free(log_bb_j_logbeta_j_bb);
+    free(log_bc_k_logbeta_k_bc);
+    free(logbeta_bd_i_j_k);
+
+    return 1 - bayestest_prob_b_beats_a(alpha_a, beta_a, alpha_d, beta_d)
+        - bayestest_prob_b_beats_a(alpha_b, beta_b, alpha_d, beta_d)
+        - bayestest_prob_b_beats_a(alpha_c, beta_c, alpha_d, beta_d)
+        + bayestest_prob_c_beats_ab(alpha_a, beta_a, alpha_b, beta_b, alpha_d, beta_d)
+        + bayestest_prob_c_beats_ab(alpha_a, beta_a, alpha_c, beta_c, alpha_d, beta_d)
+        + bayestest_prob_c_beats_ab(alpha_b, beta_b, alpha_c, beta_c, alpha_d, beta_d) - total;
+}
+
+/// Returns the winning probability of each variant for binary outcomes.
+static inline int bayestest_binary(
+    int variants,
+    const int* participants,
+    const int* conversions,
+    double* probabilities
+) {
+    if (variants < 0 || variants > 4) {
+        return -1;
+    }
+
+    for (int i = 0; i < variants; i++) {
+        if (participants[i] < 0) {
+            return -1;
+        }
+
+        if (participants[i] > INT_MAX / (int) sizeof(double) / 4) {
+            return -1;
+        }
+
+        if (conversions[i] < 0) {
+            return -1;
+        }
+
+        if (conversions[i] > INT_MAX / (int) sizeof(double) / 4) {
+            return -1;
+        }
+
+        if (conversions[i] > participants[i]) {
+            return -1;
+        }
+    }
+
+    switch (variants) {
+        case 0: {
+            break;
+        }
+        case 1: {
+            probabilities[0] = 1;
+            break;
+        }
+        case 2: {
+            int a = 1;
+            int b = 0;
+            double prob = bayestest_prob_b_beats_a(
+                1 + conversions[a],
+                1 + participants[a] - conversions[a],
+                1 + conversions[b],
+                1 + participants[b] - conversions[b]
+            );
+
+            if (isnan(prob)) {
+                return -1;
+            }
+            probabilities[0] = prob;
+            probabilities[1] = 1 - prob;
+            break;
+        }
+        case 3: {
+            double total = 0.0;
+            for (int i = 0; i < 2; i++) {
+                int c = i;
+                int b = (i + 1) % 3;
+                int a = (i + 2) % 3;
+
+                double prob = bayestest_prob_c_beats_ab(
+                    1 + conversions[a],
+                    1 + participants[a] - conversions[a],
+                    1 + conversions[b],
+                    1 + participants[b] - conversions[b],
+                    1 + conversions[c],
+                    1 + participants[c] - conversions[c]
+                );
+
+                if (isnan(prob)) {
+                    return -1;
+                }
+                probabilities[i] = prob;
+                total += prob;
+            }
+            probabilities[2] = 1 - total;
+            break;
+        }
+        case 4: {
+            double total = 0.0;
+            for (int i = 0; i < 3; i++) {
+                int d = i;
+                int c = (i + 1) % 4;
+                int b = (i + 2) % 4;
+                int a = (i + 3) % 4;
+
+                double prob = bayestest_prob_d_beats_abc(
+                    1 + conversions[a],
+                    1 + participants[a] - conversions[a],
+                    1 + conversions[b],
+                    1 + participants[b] - conversions[b],
+                    1 + conversions[c],
+                    1 + participants[c] - conversions[c],
+                    1 + conversions[d],
+                    1 + participants[d] - conversions[d]
+                );
+
+                if (isnan(prob)) {
+                    return -1;
+                }
+                probabilities[i] = prob;
+                total += prob;
+            }
+            probabilities[3] = 1 - total;
+            break;
+        }
+        default: {
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+/// @private
+static inline double bayestest_prob_1_beats_2(int alpha_1, int beta_1, int alpha_2, int beta_2) {
+    double total = 0.0;
+    double log_b1 = log(beta_1);
+    double a2_log_b2 = alpha_2 * log(beta_2);
+    double log_b1_b2 = log(beta_1 + beta_2);
+
+    for (int k = 0; k < alpha_1; k++) {
+        total += exp(
+            k * log_b1 + a2_log_b2 - (k + alpha_2) * log_b1_b2 - log(k + alpha_2)
+            - bayestest_logbeta(k + 1, alpha_2)
+        );
+    }
+
+    return total;
+}
+
+/// @private
+static inline double bayestest_prob_1_beats_23(
+    int alpha_1,
+    int beta_1,
+    int alpha_2,
+    int beta_2,
+    int alpha_3,
+    int beta_3
+) {
+    double total = 0.0;
+    double log_b1_b2_b3 = log(beta_1 + beta_2 + beta_3);
+    double a1_log_b1 = alpha_1 * log(beta_1);
+    double log_b2 = log(beta_2);
+    double log_b3 = log(beta_3);
+    double loggamma_a1 = lgamma(alpha_1);
+
+    for (int k = 0; k < alpha_2; k++) {
+        double sum_k = a1_log_b1 + k * log_b2 - lgamma(k + 1);
+
+        for (int l = 0; l < alpha_3; l++) {
+            total += exp(
+                sum_k + l * log_b3 - (k + l + alpha_1) * log_b1_b2_b3 + lgamma(k + l + alpha_1)
+                - lgamma(l + 1) - loggamma_a1
+            );
+        }
+    }
+
+    return 1 - bayestest_prob_1_beats_2(alpha_2, beta_2, alpha_1, beta_1)
+        - bayestest_prob_1_beats_2(alpha_3, beta_3, alpha_1, beta_1) + total;
+}
+
+/// Returns the winning probability of each variant for count data.
+static inline int bayestest_count(
+    int variants,
+    const int* events,
+    const int* exposure,
+    double* probabilities
+) {
+    if (variants < 0 || variants > 3) {
+        return -1;
+    }
+
+    for (int i = 0; i < variants; i++) {
+        if (events[i] < 0) {
+            return -1;
+        }
+
+        if (events[i] > INT_MAX / 4) {
+            return -1;
+        }
+
+        if (exposure[i] < 0) {
+            return -1;
+        }
+
+        if (exposure[i] > INT_MAX / 4) {
+            return -1;
+        }
+    }
+
+    switch (variants) {
+        case 0: {
+            break;
+        }
+        case 1: {
+            probabilities[0] = 1;
+            break;
+        }
+        case 2: {
+            int a = 0;
+            int b = 1;
+            double prob = bayestest_prob_1_beats_2(events[a], exposure[a], events[b], exposure[b]);
+
+            probabilities[0] = prob;
+            probabilities[1] = 1 - prob;
+            break;
+        }
+        case 3: {
+            double total = 0.0;
+            for (int i = 0; i < 2; i++) {
+                int a = i;
+                int b = (i + 1) % 3;
+                int c = (i + 2) % 3;
+
+                double prob = bayestest_prob_1_beats_23(
+                    events[a], exposure[a], events[b], exposure[b], events[c], exposure[c]
+                );
+
+                probabilities[i] = prob;
+                total += prob;
+            }
+            probabilities[2] = 1 - total;
+            break;
+        }
+        default: {
+            return -1;
+        }
+    }
+
+    return 0;
+}

data/ext/field_test/ext.c

@@ -0,0 +1,42 @@
+#include <ruby.h>
+
+#include "bayestest.h"
+
+static VALUE probabilities(VALUE self, VALUE results)
+{
+    Check_Type(results, T_ARRAY);
+
+    long count = RARRAY_LEN(results);
+    if (count > 4) {
+        rb_raise(rb_eArgError, "too many variants");
+    }
+
+    int participants[4];
+    int conversions[4];
+    double probabilities[4];
+
+    VALUE *results_ptr = RARRAY_PTR(results);
+    for (long i = 0; i < count; i++) {
+        VALUE v = results_ptr[i];
+        participants[i] = NUM2INT(rb_hash_aref(v, ID2SYM(rb_intern("participated"))));
+        conversions[i] = NUM2INT(rb_hash_aref(v, ID2SYM(rb_intern("converted"))));
+    }
+
+    int status = bayestest_binary((int) count, participants, conversions, probabilities);
+    if (status != 0) {
+        rb_raise(rb_eRuntimeError, "bad status");
+    }
+
+    VALUE rb_probabilities = rb_ary_new_capa(count);
+    for (long i = 0; i < count; i++) {
+        rb_ary_push(rb_probabilities, DBL2NUM(probabilities[i]));
+    }
+    return rb_probabilities;
+}
+
+void Init_ext(void)
+{
+    VALUE rb_mFieldTest = rb_define_module("FieldTest");
+    VALUE rb_mBinaryTest = rb_define_module_under(rb_mFieldTest, "BinaryTest");
+    rb_define_singleton_method(rb_mBinaryTest, "probabilities", probabilities, 1);
+}

data/ext/field_test/extconf.rb

@@ -1,5 +1,7 @@
-require "mkmf-rice"
+require "mkmf"
 
-$CXXFLAGS << " -std=c++17 $(optflags)"
+$CFLAGS << " $(optflags)"
+
+$CFLAGS += " -Wall -Wextra -Wconversion"
 
 create_makefile("field_test/ext")

data/lib/field_test/controller.rb

@@ -11,7 +11,7 @@ module FieldTest
       end
     end
 
-    def field_test_upgrade_memberships(options = {})
+    def field_test_upgrade_memberships(**options)
       participants = FieldTest::Participant.standardize(options[:participant] || field_test_participant)
       preferred = participants.first
       Array(participants[1..-1]).each do |participant|

data/lib/field_test/experiment.rb

@@ -9,9 +9,7 @@ module FieldTest
       @description = attributes[:description]
       @variants = attributes[:variants]
       if @variants.any? { |v| !v.is_a?(String) }
-        # TODO add support for more types (including query parameters)
-        # or raise error in 0.6
-        warn "[field_test] Only string variants are supported (#{id})"
+        raise Error, "Only string variants are supported (#{id})"
       end
       @weights = @variants.size.times.map { |i| attributes[:weights].to_a[i] || 1 }
       @winner = attributes[:winner]
@@ -24,7 +22,7 @@ module FieldTest
       @use_events = attributes[:use_events]
     end
 
-    def variant(participants, options = {})
+    def variant(participants, **options)
       return winner if winner && !keep_variant?
       return control if options[:exclude]
 
@@ -149,11 +147,7 @@ module FieldTest
       if variants.size <= 3
         probabilities =
           cache_fetch(["field_test", "probabilities"] + results.flat_map { |_, v| [v[:participated], v[:converted]] }) do
-            binary_test = BinaryTest.new
-            results.each do |_, v|
-              binary_test.add(v[:participated], v[:converted])
-            end
-            binary_test.probabilities.to_a
+            BinaryTest.probabilities(results.values)
           end
 
         results.each_key.zip(probabilities) do |variant, prob_winning|

data/lib/field_test/helpers.rb

@@ -27,10 +27,9 @@ module FieldTest
         params_variant
       else
         # cache results for request
-        # TODO possibly remove in 0.4.0
         cache_key = [exp.id, participants.map(&:where_values), options.slice(:variant, :exclude)]
         @field_test_cache ||= {}
-        @field_test_cache[cache_key] ||= exp.variant(participants, options)
+        @field_test_cache[cache_key] ||= exp.variant(participants, **options)
       end
     end
 

data/lib/field_test/version.rb

@@ -1,3 +1,3 @@
 module FieldTest
-  VERSION = "0.8.0"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: field_test
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -15,28 +15,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: browser
   requirement: !ruby/object:Gem::Requirement
@@ -51,20 +51,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '2'
-- !ruby/object:Gem::Dependency
-  name: rice
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.3.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.3.3
 email: andrew@ankane.org
 executables: []
 extensions:
@@ -87,8 +73,8 @@ files:
 - app/views/field_test/participants/show.html.erb
 - app/views/layouts/field_test/application.html.erb
 - config/routes.rb
-- ext/field_test/bayestest.hpp
-- ext/field_test/ext.cpp
+- ext/field_test/bayestest.h
+- ext/field_test/ext.c
 - ext/field_test/extconf.rb
 - lib/field_test.rb
 - lib/field_test/controller.rb
@@ -114,14 +100,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 4.0.6
 specification_version: 4
 summary: A/B testing for Rails
 test_files: []

data/ext/field_test/bayestest.hpp

@@ -1,329 +0,0 @@
-/*!
- * BayesTest C++ v0.1.2
- * https://github.com/ankane/bayestest-cpp
- * MIT License
- */
-
-#pragma once
-
-#include <cmath>
-#include <vector>
-
-namespace bayestest {
-
-namespace {
-
-double logbeta(double a, double b) {
-  return std::lgamma(a) + std::lgamma(b) - std::lgamma(a + b);
-}
-
-double prob_b_beats_a(int alpha_a, int beta_a, int alpha_b, int beta_b) {
-  double total = 0.0;
-  double logbeta_aa_ba = logbeta(alpha_a, beta_a);
-  double beta_ba = beta_b + beta_a;
-
-  for (auto i = 0; i < alpha_b; i++) {
-    total += std::exp(logbeta(alpha_a + i, beta_ba) - std::log(beta_b + i) - logbeta(1 + i, beta_b) - logbeta_aa_ba);
-  }
-
-  return total;
-}
-
-double prob_c_beats_ab(int alpha_a, int beta_a, int alpha_b, int beta_b, int alpha_c, int beta_c) {
-  double total = 0.0;
-
-  double logbeta_ac_bc = logbeta(alpha_c, beta_c);
-
-  std::vector<double> log_bb_j_logbeta_j_bb;
-  log_bb_j_logbeta_j_bb.reserve(alpha_b);
-
-  for (auto j = 0; j < alpha_b; j++) {
-    log_bb_j_logbeta_j_bb.push_back(std::log(beta_b + j) + logbeta(1 + j, beta_b));
-  }
-
-  double abc = beta_a + beta_b + beta_c;
-  std::vector<double> logbeta_ac_i_j;
-  logbeta_ac_i_j.reserve(alpha_a + alpha_b);
-
-  for (auto i = 0; i < alpha_a + alpha_b; i++) {
-    logbeta_ac_i_j.push_back(logbeta(alpha_c + i, abc));
-  }
-
-  for (auto i = 0; i < alpha_a; i++) {
-    double sum_i = -std::log(beta_a + i) - logbeta(1 + i, beta_a) - logbeta_ac_bc;
-
-    for (auto j = 0; j < alpha_b; j++) {
-      total += std::exp(sum_i + logbeta_ac_i_j[i + j] - log_bb_j_logbeta_j_bb[j]);
-    }
-  }
-
-  return 1
-    - prob_b_beats_a(alpha_c, beta_c, alpha_a, beta_a)
-    - prob_b_beats_a(alpha_c, beta_c, alpha_b, beta_b)
-    + total;
-}
-
-double prob_d_beats_abc(int alpha_a, int beta_a, int alpha_b, int beta_b, int alpha_c, int beta_c, int alpha_d, int beta_d) {
-  double total = 0.0;
-
-  double logbeta_ad_bd = logbeta(alpha_d, beta_d);
-
-  std::vector<double> log_bb_j_logbeta_j_bb;
-  log_bb_j_logbeta_j_bb.reserve(alpha_b);
-
-  for (auto j = 0; j < alpha_b; j++) {
-    log_bb_j_logbeta_j_bb.push_back(std::log(beta_b + j) + logbeta(1 + j, beta_b));
-  }
-
-  std::vector<double> log_bc_k_logbeta_k_bc;
-  log_bc_k_logbeta_k_bc.reserve(alpha_c);
-
-  for (auto k = 0; k < alpha_c; k++) {
-    log_bc_k_logbeta_k_bc.push_back(std::log(beta_c + k) + logbeta(1 + k, beta_c));
-  }
-
-  double abcd = beta_a + beta_b + beta_c + beta_d;
-  std::vector<double> logbeta_bd_i_j_k;
-  logbeta_bd_i_j_k.reserve(alpha_a + alpha_b + alpha_c);
-
-  for (auto i = 0; i < alpha_a + alpha_b + alpha_c; i++) {
-    logbeta_bd_i_j_k.push_back(logbeta(alpha_d + i, abcd));
-  }
-
-  for (auto i = 0; i < alpha_a; i++) {
-    double sum_i = -std::log(beta_a + i) - logbeta(1 + i, beta_a) - logbeta_ad_bd;
-
-    for (auto j = 0; j < alpha_b; j++) {
-      double sum_j = sum_i - log_bb_j_logbeta_j_bb[j];
-
-      for (auto k = 0; k < alpha_c; k++) {
-        total += std::exp(sum_j + logbeta_bd_i_j_k[i + j + k] - log_bc_k_logbeta_k_bc[k]);
-      }
-    }
-  }
-
-  return 1
-    - prob_b_beats_a(alpha_a, beta_a, alpha_d, beta_d)
-    - prob_b_beats_a(alpha_b, beta_b, alpha_d, beta_d)
-    - prob_b_beats_a(alpha_c, beta_c, alpha_d, beta_d)
-    + prob_c_beats_ab(alpha_a, beta_a, alpha_b, beta_b, alpha_d, beta_d)
-    + prob_c_beats_ab(alpha_a, beta_a, alpha_c, beta_c, alpha_d, beta_d)
-    + prob_c_beats_ab(alpha_b, beta_b, alpha_c, beta_c, alpha_d, beta_d)
-    - total;
-}
-
-double prob_1_beats_2(int alpha_1, int beta_1, int alpha_2, int beta_2) {
-  double total = 0.0;
-  double log_b1 = std::log(beta_1);
-  double a2_log_b2 = alpha_2 * std::log(beta_2);
-  double log_b1_b2 = std::log(beta_1 + beta_2);
-
-  for (auto k = 0; k < alpha_1; k++) {
-    total += std::exp(k * log_b1 +
-      a2_log_b2 -
-      (k + alpha_2) * log_b1_b2 -
-      std::log(k + alpha_2) -
-      logbeta(k + 1, alpha_2));
-  }
-
-  return total;
-}
-
-double prob_1_beats_23(int alpha_1, int beta_1, int alpha_2, int beta_2, int alpha_3, int beta_3) {
-  double total = 0.0;
-
-  double log_b1_b2_b3 = std::log(beta_1 + beta_2 + beta_3);
-  double a1_log_b1 = alpha_1 * std::log(beta_1);
-  double log_b2 = std::log(beta_2);
-  double log_b3 = std::log(beta_3);
-  double loggamma_a1 = std::lgamma(alpha_1);
-
-  for (auto k = 0; k < alpha_2; k++) {
-    double sum_k = a1_log_b1 + k * log_b2 - std::lgamma(k + 1);
-
-    for (auto l = 0; l < alpha_3; l++) {
-      total += std::exp(sum_k + l * log_b3
-        - (k + l + alpha_1) * log_b1_b2_b3
-        + std::lgamma(k + l + alpha_1) - std::lgamma(l + 1) - loggamma_a1);
-    }
-  }
-
-  return 1
-    - prob_1_beats_2(alpha_2, beta_2, alpha_1, beta_1)
-    - prob_1_beats_2(alpha_3, beta_3, alpha_1, beta_1)
-    + total;
-}
-
-}
-
-/// A test for binary outcomes.
-class BinaryTest {
-public:
-  /// Adds a new variant.
-  void add(int participants, int conversions) {
-    variants.emplace_back(participants, conversions);
-  }
-
-  /// Returns the winning probability of each variant.
-  std::vector<double> probabilities() const {
-    std::vector<double> probs;
-    probs.reserve(variants.size());
-
-    switch (variants.size()) {
-      case 0: {
-        break;
-      }
-      case 1: {
-        probs.push_back(1);
-
-        break;
-      }
-      case 2: {
-        auto b = variants[0];
-        auto a = variants[1];
-
-        auto prob = prob_b_beats_a(
-          1 + a.conversions,
-          1 + a.participants - a.conversions,
-          1 + b.conversions,
-          1 + b.participants - b.conversions
-        );
-        probs.push_back(prob);
-        probs.push_back(1 - prob);
-
-        break;
-      }
-      case 3: {
-        auto total = 0.0;
-        for (auto i = 0; i < 2; i++) {
-            auto c = variants[i];
-            auto b = variants[(i + 1) % 3];
-            auto a = variants[(i + 2) % 3];
-
-            auto prob = prob_c_beats_ab(
-              1 + a.conversions,
-              1 + a.participants - a.conversions,
-              1 + b.conversions,
-              1 + b.participants - b.conversions,
-              1 + c.conversions,
-              1 + c.participants - c.conversions
-            );
-
-            probs.push_back(prob);
-            total += prob;
-        }
-        probs.push_back(1 - total);
-
-        break;
-      }
-      default: {
-        auto total = 0.0;
-        for (auto i = 0; i < 3; i++) {
-            auto d = variants[i];
-            auto c = variants[(i + 1) % 4];
-            auto b = variants[(i + 2) % 4];
-            auto a = variants[(i + 3) % 4];
-
-            auto prob = prob_d_beats_abc(
-              1 + a.conversions,
-              1 + a.participants - a.conversions,
-              1 + b.conversions,
-              1 + b.participants - b.conversions,
-              1 + c.conversions,
-              1 + c.participants - c.conversions,
-              1 + d.conversions,
-              1 + d.participants - d.conversions
-            );
-
-            probs.push_back(prob);
-            total += prob;
-        }
-        probs.push_back(1 - total);
-      }
-    }
-    return probs;
-  }
-
-private:
-  struct Variant {
-    Variant(int participants, int conversions) : participants(participants), conversions(conversions) {}
-    int participants;
-    int conversions;
-  };
-
-  std::vector<Variant> variants;
-};
-
-/// A test for count data.
-class CountTest {
-public:
-  /// Adds a new variant.
-  void add(int events, int exposure) {
-    variants.emplace_back(events, exposure);
-  }
-
-  /// Returns the winning probability of each variant.
-  std::vector<double> probabilities() const {
-    std::vector<double> probs;
-    probs.reserve(variants.size());
-
-    switch (variants.size()) {
-      case 0: {
-        break;
-      }
-      case 1: {
-        probs.push_back(1);
-
-        break;
-      }
-      case 2: {
-        auto a = variants[0];
-        auto b = variants[1];
-
-        auto prob = prob_1_beats_2(
-          a.events,
-          a.exposure,
-          b.events,
-          b.exposure
-        );
-        probs.push_back(prob);
-        probs.push_back(1 - prob);
-
-        break;
-      }
-      default: {
-        auto total = 0.0;
-        for (auto i = 0; i < 2; i++) {
-            auto a = variants[i];
-            auto b = variants[(i + 1) % 3];
-            auto c = variants[(i + 2) % 3];
-
-            auto prob = prob_1_beats_23(
-              a.events,
-              a.exposure,
-              b.events,
-              b.exposure,
-              c.events,
-              c.exposure
-            );
-
-            probs.push_back(prob);
-            total += prob;
-        }
-        probs.push_back(1 - total);
-      }
-    }
-    return probs;
-  }
-
-private:
-  struct Variant {
-    Variant(int events, int exposure) : events(events), exposure(exposure) {}
-    int events;
-    int exposure;
-  };
-
-  std::vector<Variant> variants;
-};
-
-}

data/ext/field_test/ext.cpp

@@ -1,16 +0,0 @@
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
-
-#include "bayestest.hpp"
-
-using bayestest::BinaryTest;
-
-extern "C"
-void Init_ext() {
-  auto rb_mFieldTest = Rice::define_module("FieldTest");
-
-  Rice::define_class_under<BinaryTest>(rb_mFieldTest, "BinaryTest")
-    .define_constructor(Rice::Constructor<BinaryTest>())
-    .define_method("add", &BinaryTest::add)
-    .define_method("probabilities", &BinaryTest::probabilities);
-}