stride-align 0.6.0

data/ext/stride_align/vendor/stride_align/wratio.hpp

@@ -0,0 +1,363 @@
+#pragma once
+
+// Compatibility-style WRatio kernel.
+//
+// Reimplements rapidfuzz's documented WRatio recipe in C++ so the
+// whole computation (ratio + len-ratio branch + token variants +
+// partial variants) crosses the Python boundary exactly once instead
+// of once per component. Closes the ~4× WRatio gap on x86/ARM that
+// was driven entirely by Python wrapper overhead and intermediate
+// ``float()`` / ``max()`` work in the previous Python recipe.
+//
+// Recipe (matches the compatibility reference bit-exactly):
+//
+//   base = indel_normalized(a, b)        # range [0, 1]
+//   len_ratio = max(|a|, |b|) / min(|a|, |b|)
+//   UNBASE_SCALE = 0.95
+//
+//   if len_ratio < 1.5:
+//     # similar-length regime — token-based variants
+//     token_sort = token_sort_ratio(a, b) * UNBASE_SCALE
+//     token_set  = token_set_ratio(a, b)  * UNBASE_SCALE
+//     score      = max(base, token_sort, token_set)
+//   else:
+//     # length-mismatched regime — partial variants dominate
+//     partial_scale = 0.6 if len_ratio > 8 else 0.9
+//     partial             = partial_ratio(a, b)             * partial_scale
+//     partial_token_sort  = partial_token_sort_ratio(a, b)  * UNBASE_SCALE * partial_scale
+//     partial_token_set   = partial_token_set_ratio(a, b)   * UNBASE_SCALE * partial_scale
+//     score = max(base, partial, partial_token_sort, partial_token_set)
+//
+//   return score
+//
+// **Short-circuit logic.** Every non-base component is multiplied by
+// a scale factor ``<= 0.95`` (in the similar-length branch) or
+// ``<= 0.9 / 0.6`` (in the length-mismatched branch). The component
+// value itself is in ``[0, 1]``, so the scaled value is bounded by
+// the scale factor. Once ``base`` is already at least the maximum
+// possible component score, no further computation can change the
+// answer — return ``base`` and skip the (expensive) token / partial
+// passes. This is the dominant fast path for high-quality matches.
+//
+// All component subroutines (token_sort, token_set, partial,
+// partial_token_sort, partial_token_set) are inlined from
+// ``token_ratios.hpp`` and ``partial_ratio.hpp`` so the whole
+// recipe is a single function instantiation per Token type. The native
+// stride-align contract is implemented separately at the end of this file.
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <span>
+#include <type_traits>
+#include <vector>
+
+#include "stride_align/indel.hpp"
+#include "stride_align/lcs.hpp"
+#include "stride_align/partial_ratio.hpp"
+#include "stride_align/token_ratios.hpp"
+
+namespace stride_align::wratio {
+
+using Codepoint = ::stride_align::lcs::Codepoint;
+
+// Combined ``partial_token_sort_ratio`` on already-tokenised inputs.
+// Sorts the tokens, joins, hands off to ``partial_ratio``.
+template <typename Token>
+inline double partial_token_sort_ratio_engine(
+    std::span<const Token> a,
+    std::span<const Token> b) {
+  auto ta = ::stride_align::token_ratios::tokens_of(a);
+  auto tb = ::stride_align::token_ratios::tokens_of(b);
+  std::sort(ta.begin(), ta.end(),
+            ::stride_align::token_ratios::LexLess<Token>{});
+  std::sort(tb.begin(), tb.end(),
+            ::stride_align::token_ratios::LexLess<Token>{});
+  std::vector<Token> ja, jb;
+  ::stride_align::token_ratios::join_with_space(ta, ja);
+  ::stride_align::token_ratios::join_with_space(tb, jb);
+  if (ja.empty() && jb.empty()) return 1.0;
+  if (ja.empty() || jb.empty()) return 0.0;
+
+  // Byte inputs go straight through partial_ratio_bytes (the fast path
+  // fuzz.partial_ratio already uses) — no uint8->codepoint widening, and
+  // the byte partial_ratio kernel rather than the codepoint one.
+  if constexpr (std::is_same_v<Token, std::uint8_t>) {
+    return ::stride_align::partial_ratio::partial_ratio_bytes(
+        std::span<const std::uint8_t>(ja), std::span<const std::uint8_t>(jb));
+  } else {
+    std::vector<Codepoint> ja_cp(ja.begin(), ja.end());
+    std::vector<Codepoint> jb_cp(jb.begin(), jb.end());
+    return ::stride_align::partial_ratio::partial_ratio(ja_cp, jb_cp);
+  }
+}
+
+// Combined ``partial_token_set_ratio``. Builds the three set
+// candidates exactly as ``token_set_ratio_engine`` does, then runs
+// ``partial_ratio`` over each pair and returns the max.
+template <typename Token>
+inline double partial_token_set_ratio_engine(
+    std::span<const Token> a,
+    std::span<const Token> b) {
+  using namespace ::stride_align::token_ratios;
+  auto ta = tokens_of(a);
+  auto tb = tokens_of(b);
+  if (ta.empty() || tb.empty()) return 0.0;
+
+  const LexLess<Token> lt;
+  std::sort(ta.begin(), ta.end(), lt);
+  ta.erase(std::unique(ta.begin(), ta.end(), LexEqual<Token>{}), ta.end());
+  std::sort(tb.begin(), tb.end(), lt);
+  tb.erase(std::unique(tb.begin(), tb.end(), LexEqual<Token>{}), tb.end());
+
+  std::vector<std::span<const Token>> intersect, diff_a, diff_b;
+  std::size_t i = 0, j = 0;
+  while (i < ta.size() && j < tb.size()) {
+    if (lt(ta[i], tb[j])) { diff_a.push_back(ta[i]); ++i; }
+    else if (lt(tb[j], ta[i])) { diff_b.push_back(tb[j]); ++j; }
+    else { intersect.push_back(ta[i]); ++i; ++j; }
+  }
+  while (i < ta.size()) diff_a.push_back(ta[i++]);
+  while (j < tb.size()) diff_b.push_back(tb[j++]);
+
+  if (diff_a.empty() && diff_b.empty()) return 1.0;
+
+  std::vector<std::span<const Token>> t1_parts(intersect);
+  t1_parts.insert(t1_parts.end(), diff_a.begin(), diff_a.end());
+  std::vector<std::span<const Token>> t2_parts(intersect);
+  t2_parts.insert(t2_parts.end(), diff_b.begin(), diff_b.end());
+
+  std::vector<Token> t0, t1, t2;
+  join_with_space(intersect, t0);
+  join_with_space(t1_parts, t1);
+  join_with_space(t2_parts, t2);
+
+  // Run partial_ratio on each pair (codepoint widening per pair).
+  auto pr = [](const std::vector<Token>& x, const std::vector<Token>& y) -> double {
+    if (x.empty() && y.empty()) return 1.0;
+    if (x.empty() || y.empty()) return 0.0;
+    if constexpr (std::is_same_v<Token, std::uint8_t>) {
+      return ::stride_align::partial_ratio::partial_ratio_bytes(
+          std::span<const std::uint8_t>(x), std::span<const std::uint8_t>(y));
+    } else {
+      std::vector<Codepoint> xc(x.begin(), x.end());
+      std::vector<Codepoint> yc(y.begin(), y.end());
+      return ::stride_align::partial_ratio::partial_ratio(xc, yc);
+    }
+  };
+  const double r0 = pr(t0, t1);
+  if (r0 >= 1.0) return 1.0;
+  const double r1 = pr(t0, t2);
+  if (r1 >= 1.0) return 1.0;
+  const double r2 = pr(t1, t2);
+  return std::max({r0, r1, r2});
+}
+
+// WRatio engine. Returns the WRatio score in ``[0, 1]`` (caller
+// multiplies by 100 for the rapidfuzz convention).
+//
+// ``score_cutoff`` is interpreted as a *normalised* cutoff in
+// ``[0, 1]`` — values at or below this threshold are returned as 0.
+// This mirrors rapidfuzz's documented behaviour on WRatio.
+template <typename Token>
+inline double wratio_engine(
+    std::span<const Token> a,
+    std::span<const Token> b,
+    double score_cutoff /* normalised, [0, 1]; 0 == no cutoff */) {
+  if (a.empty() || b.empty()) return 0.0;
+
+  constexpr double UNBASE_SCALE = 0.95;
+
+  const double base = ::stride_align::token_ratios::indel_normalized<Token>(a, b);
+  const double len_a = static_cast<double>(a.size());
+  const double len_b = static_cast<double>(b.size());
+  const double len_ratio = (len_a > len_b ? len_a / len_b : len_b / len_a);
+
+  double best = base;
+
+  if (len_ratio < 1.5) {
+    // Similar-length regime. Token variants scale by 0.95, so once
+    // ``base >= 0.95`` no scaled token component can exceed it.
+    if (best >= UNBASE_SCALE) {
+      return best > score_cutoff ? best : 0.0;
+    }
+    // token_sort and token_set are both needed here. Use the combined
+    // engine that tokenises a/b once, sorts once, and shares the
+    // thread-local scratch buffers across the 1 + 3 indel calls.
+    double ts = 0.0, tx = 0.0;
+    ::stride_align::token_ratios::compute_token_sort_and_set_ratio<Token>(
+        a, b, ts, tx);
+    const double ts_scaled = ts * UNBASE_SCALE;
+    if (ts_scaled > best) best = ts_scaled;
+    const double tx_scaled = tx * UNBASE_SCALE;
+    if (tx_scaled > best) best = tx_scaled;
+    return best > score_cutoff ? best : 0.0;
+  }
+
+  // Length-mismatched regime. The dominant variant is ``partial`` (no
+  // unbase penalty), so its scaling factor caps the achievable score.
+  // rapidfuzz/fuzzywuzzy: ``partial_scale = 0.6 if len_ratio > 8 else 0.9`` —
+  // len_ratio == 8 stays in the 0.9 bucket. (Was ``< 8.0``, which put the
+  // exact-8 boundary in the 0.6 bucket and diverged from rapidfuzz, ~30 pts.)
+  const double partial_scale = (len_ratio > 8.0) ? 0.6 : 0.9;
+  // partial_token_* are scaled by UNBASE_SCALE * partial_scale, which
+  // is strictly less than ``partial_scale``. So ``partial_scale`` is
+  // the true ceiling for any non-base component here.
+  if (best >= partial_scale) {
+    return best > score_cutoff ? best : 0.0;
+  }
+
+  // Byte tokens go straight through the byte partial_ratio path
+  // (no uint8→codepoint widen / re-narrow). Wider tokens still
+  // widen once into codepoints for the public entry.
+  double pr;
+  if constexpr (std::is_same_v<Token, std::uint8_t>) {
+    pr = ::stride_align::partial_ratio::partial_ratio_bytes(a, b);
+  } else {
+    std::vector<Codepoint> a_cp(a.begin(), a.end());
+    std::vector<Codepoint> b_cp(b.begin(), b.end());
+    pr = ::stride_align::partial_ratio::partial_ratio(a_cp, b_cp);
+  }
+  const double pr_scaled = pr * partial_scale;
+  if (pr_scaled > best) best = pr_scaled;
+  // After ``partial`` the ceiling drops to ``UNBASE_SCALE *
+  // partial_scale`` because the remaining variants pay both penalties.
+  const double remaining_ceiling = UNBASE_SCALE * partial_scale;
+  if (best >= remaining_ceiling) {
+    return best > score_cutoff ? best : 0.0;
+  }
+
+  const double pts = partial_token_sort_ratio_engine<Token>(a, b);
+  const double pts_scaled = pts * remaining_ceiling;
+  if (pts_scaled > best) best = pts_scaled;
+  if (best >= remaining_ceiling) {
+    return best > score_cutoff ? best : 0.0;
+  }
+
+  const double pset = partial_token_set_ratio_engine<Token>(a, b);
+  const double pset_scaled = pset * remaining_ceiling;
+  if (pset_scaled > best) best = pset_scaled;
+  return best > score_cutoff ? best : 0.0;
+}
+
+// Byte fast path: caller has already established byte-compatible
+// inputs.
+inline double wratio_bytes(
+    std::span<const std::uint8_t> a,
+    std::span<const std::uint8_t> b,
+    double score_cutoff = 0.0) {
+  return wratio_engine<std::uint8_t>(a, b, score_cutoff);
+}
+inline double partial_token_sort_ratio_bytes(
+    std::span<const std::uint8_t> a,
+    std::span<const std::uint8_t> b) {
+  return partial_token_sort_ratio_engine<std::uint8_t>(a, b);
+}
+inline double partial_token_set_ratio_bytes(
+    std::span<const std::uint8_t> a,
+    std::span<const std::uint8_t> b) {
+  return partial_token_set_ratio_engine<std::uint8_t>(a, b);
+}
+
+// Public byte-fast-path-or-codepoint dispatcher.
+inline double wratio(
+    const std::vector<Codepoint>& a,
+    const std::vector<Codepoint>& b,
+    double score_cutoff = 0.0) {
+  if (a.empty() || b.empty()) return 0.0;
+  bool fits_in_byte = true;
+  for (const auto cp : a) { if (cp >= 256U) { fits_in_byte = false; break; } }
+  if (fits_in_byte) {
+    for (const auto cp : b) { if (cp >= 256U) { fits_in_byte = false; break; } }
+  }
+  if (fits_in_byte) {
+    std::vector<std::uint8_t> ab(a.begin(), a.end());
+    std::vector<std::uint8_t> bb(b.begin(), b.end());
+    return wratio_engine<std::uint8_t>(
+        std::span<const std::uint8_t>(ab),
+        std::span<const std::uint8_t>(bb),
+        score_cutoff);
+  }
+  return wratio_engine<Codepoint>(
+      std::span<const Codepoint>(a),
+      std::span<const Codepoint>(b),
+      score_cutoff);
+}
+
+// stride-align's top-level WRatio contract predates the compatibility shim:
+// it evaluates partial and token candidates in both length regimes. Keep the
+// optimized compatibility recipe above available to the shim, while native
+// language adapters call this complete recipe.
+template <typename Token>
+inline double native_wratio_engine(
+    std::span<const Token> a,
+    std::span<const Token> b) {
+  if (a.empty() || b.empty()) return a.empty() && b.empty() ? 1.0 : 0.0;
+
+  constexpr double kUnbaseScale = 0.95;
+  double partial_scale = 0.9;
+  double unbase_scale = kUnbaseScale;
+  const double len_a = static_cast<double>(a.size());
+  const double len_b = static_cast<double>(b.size());
+  const double len_ratio = len_a > len_b ? len_a / len_b : len_b / len_a;
+  if (len_ratio < 1.5) {
+    partial_scale = kUnbaseScale;
+  } else if (len_ratio >= 8.0) {
+    unbase_scale = 0.6;
+  }
+
+  double best = ::stride_align::token_ratios::indel_normalized<Token>(a, b);
+  if (best >= 1.0) return best;
+
+  double partial;
+  if constexpr (std::is_same_v<Token, std::uint8_t>) {
+    partial = ::stride_align::partial_ratio::partial_ratio_bytes(a, b);
+  } else {
+    std::vector<Codepoint> a_cp(a.begin(), a.end());
+    std::vector<Codepoint> b_cp(b.begin(), b.end());
+    partial = ::stride_align::partial_ratio::partial_ratio(a_cp, b_cp);
+  }
+  best = std::max(best, partial * partial_scale);
+
+  double token_sort = 0.0;
+  double token_set = 0.0;
+  ::stride_align::token_ratios::compute_token_sort_and_set_ratio<Token>(
+      a, b, token_sort, token_set);
+  best = std::max(best, token_sort * unbase_scale);
+  best = std::max(best, token_set * unbase_scale);
+
+  const double combined_scale = partial_scale * unbase_scale;
+  best = std::max(
+      best, partial_token_sort_ratio_engine<Token>(a, b) * combined_scale);
+  best = std::max(
+      best, partial_token_set_ratio_engine<Token>(a, b) * combined_scale);
+  return best;
+}
+
+inline double native_wratio(
+    const std::vector<Codepoint>& a,
+    const std::vector<Codepoint>& b) {
+  bool fits_in_byte = true;
+  for (const auto codepoint : a) {
+    if (codepoint >= 256U) {
+      fits_in_byte = false;
+      break;
+    }
+  }
+  if (fits_in_byte) {
+    for (const auto codepoint : b) {
+      if (codepoint >= 256U) {
+        fits_in_byte = false;
+        break;
+      }
+    }
+  }
+  if (fits_in_byte) {
+    const std::vector<std::uint8_t> left(a.begin(), a.end());
+    const std::vector<std::uint8_t> right(b.begin(), b.end());
+    return native_wratio_engine<std::uint8_t>(left, right);
+  }
+  return native_wratio_engine<Codepoint>(a, b);
+}
+
+}  // namespace stride_align::wratio

data/lib/stride_align/algorithms.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+module StrideAlign
+  module MetaphoneVariant
+    PHILIPS = 0
+    JELLYFISH = 1
+  end
+
+  module DoubleMetaphoneVariant
+    COMMONS = 0
+    PYTHON = 1
+  end
+
+  module BmpmRuleType
+    APPROX = 0
+    EXACT = 1
+  end
+
+  class << self
+    def lcs_length(query, target)
+      pairwise(query, target) { |left, right| __primary_backend.lcs_length(left, right) }
+    end
+
+    def lcs_substring_length(query, target)
+      pairwise(query, target) do |left, right|
+        __primary_backend.lcs_substring_length(left, right)
+      end
+    end
+
+    def lcs_substring(query, target)
+      pairwise(query, target) { |left, right| __primary_backend.lcs_substring(left, right) }
+    end
+
+    def jaccard(query, target, n: 2)
+      pairwise(query, target) { |left, right| __primary_backend.jaccard(left, right, n) }
+    end
+
+    def dice(query, target, n: 2)
+      pairwise(query, target) { |left, right| __primary_backend.dice(left, right, n) }
+    end
+
+    def cosine(query, target, n: 2)
+      pairwise(query, target) { |left, right| __primary_backend.cosine(left, right, n) }
+    end
+
+    def overlap(query, target, n: 2)
+      pairwise(query, target) { |left, right| __primary_backend.overlap(left, right, n) }
+    end
+
+    def jaccard_similarities(query, targets, n: 2)
+      one_to_many(query, targets) { |left, right| jaccard(left, right, n: n) }
+    end
+
+    def dice_similarities(query, targets, n: 2)
+      one_to_many(query, targets) { |left, right| dice(left, right, n: n) }
+    end
+
+    def cosine_similarities(query, targets, n: 2)
+      one_to_many(query, targets) { |left, right| cosine(left, right, n: n) }
+    end
+
+    def overlap_similarities(query, targets, n: 2)
+      one_to_many(query, targets) { |left, right| overlap(left, right, n: n) }
+    end
+
+    def ratcliff_obershelp_similarity(query, target)
+      pairwise(query, target) do |left, right|
+        __primary_backend.ratcliff_obershelp(left, right)
+      end
+    end
+
+    def ratcliff_obershelp_similarities(query, targets)
+      one_to_many(query, targets) do |left, right|
+        ratcliff_obershelp_similarity(left, right)
+      end
+    end
+
+    def partial_ratio(query, target, processor: nil)
+      processed_pairwise(query, target, processor) do |left, right|
+        __primary_backend.partial_ratio(left, right)
+      end
+    end
+
+    def token_sort_ratio(query, target, processor: nil)
+      processed_pairwise(query, target, processor) do |left, right|
+        __primary_backend.token_sort_ratio(left, right)
+      end
+    end
+
+    def token_set_ratio(query, target, processor: nil)
+      processed_pairwise(query, target, processor) do |left, right|
+        __primary_backend.token_set_ratio(left, right)
+      end
+    end
+
+    def partial_token_sort_ratio(query, target, processor: nil)
+      processed_pairwise(query, target, processor) do |left, right|
+        __primary_backend.partial_token_sort_ratio(left, right)
+      end
+    end
+
+    def partial_token_set_ratio(query, target, processor: nil)
+      processed_pairwise(query, target, processor) do |left, right|
+        __primary_backend.partial_token_set_ratio(left, right)
+      end
+    end
+
+    def WRatio(query, target, processor: nil)
+      processed_pairwise(query, target, processor) do |left, right|
+        if left.nil? || right.nil?
+          nil
+        elsif left.empty? && right.empty?
+          1.0
+        else
+          __primary_backend.wratio(left, right)
+        end
+      end
+    end
+
+    def monge_elkan(query, target, inner: :jaro, processor: nil,
+                    symmetric: false)
+      query = scalar_query(query)
+      target = scalar_query(target)
+      raise ArgumentError, "query and target cannot be nil" if query.nil? || target.nil?
+      query = apply_processor(query, processor)
+      target = apply_processor(target, processor)
+      scorer = resolve_inner_scorer(inner)
+      left = query.split
+      right = target.split
+      return 1.0 if left.empty? && right.empty?
+      return 0.0 if left.empty? || right.empty?
+
+      forward = monge_direction(left, right, scorer)
+      return forward unless symmetric
+      (forward + monge_direction(right, left, scorer)) / 2.0
+    end
+
+    def soundex(input)
+      unary(input) { |value| __primary_backend.soundex(value) }
+    end
+
+    def soundex_equal(query, target)
+      phonetic_equal(query, target, :soundex, MetaphoneVariant::PHILIPS)
+    end
+
+    def metaphone(input, variant: MetaphoneVariant::PHILIPS)
+      unary(input) { |value| __primary_backend.metaphone(value, variant) }
+    end
+
+    def metaphone_equal(query, target, variant: MetaphoneVariant::PHILIPS)
+      phonetic_equal(query, target, :metaphone, variant)
+    end
+
+    def nysiis(input)
+      unary(input) { |value| __primary_backend.nysiis(value) }
+    end
+
+    def nysiis_equal(query, target)
+      phonetic_equal(query, target, :nysiis, MetaphoneVariant::PHILIPS)
+    end
+
+    def match_rating_codex(input)
+      unary(input) { |value| __primary_backend.match_rating_codex(value) }
+    end
+
+    def match_rating_compare(query, target)
+      pairwise(query, target) do |left, right|
+        __primary_backend.match_rating_compare(left, right)
+      end
+    end
+
+    def caverphone(input)
+      unary(input) { |value| __primary_backend.caverphone(value) }
+    end
+
+    def cologne_phonetic(input)
+      unary(input) { |value| __primary_backend.cologne_phonetic(value) }
+    end
+
+    def daitch_mokotoff(input, branching: true, folding: true)
+      unary(input) do |value|
+        __primary_backend.daitch_mokotoff(value, branching, folding)
+      end
+    end
+
+    def double_metaphone(input, max_length: 64,
+                         variant: DoubleMetaphoneVariant::COMMONS)
+      unary(input) do |value|
+        result = __primary_backend.double_metaphone(value, max_length, variant)
+        result.nil? ? nil : { primary: result[0], alternate: result[1] }
+      end
+    end
+
+    def beider_morse(input, rule_type: BmpmRuleType::APPROX,
+                     concat: true, max_phonemes: 20)
+      register_bmpm_resources
+      unary(input) do |value|
+        __primary_backend.beider_morse(value, rule_type, concat, max_phonemes)
+      end
+    end
+
+    def dtw(query, target, window: nil, distance: nil, score_cutoff: nil)
+      unless query.is_a?(Array) && target.is_a?(Array)
+        raise ArgumentError, "query and target must be numeric Arrays"
+      end
+      distance ||= query.all? { |value| value.is_a?(Integer) } ? "l1" : "l2_squared"
+      __primary_backend.dtw(query, target, window, distance.to_s, score_cutoff)
+    end
+
+    def dtw_distances(query, targets, window: nil, distance: nil,
+                      score_cutoff: nil)
+      raise ArgumentError, "targets must be an Array of numeric Arrays" unless targets.is_a?(Array)
+      targets.map do |target|
+        dtw(
+          query, target, window: window, distance: distance,
+          score_cutoff: score_cutoff
+        )
+      end
+    end
+
+    private
+
+    def apply_processor(value, processor)
+      return value if processor.nil? || value.nil?
+      raise ArgumentError, "processor must respond to call or be nil" unless processor.respond_to?(:call)
+      result = processor.call(value)
+      raise ArgumentError, "processor must return one non-nil String" unless result.is_a?(String)
+      result.encode(Encoding::UTF_8)
+    end
+
+    def processed_pairwise(query, target, processor)
+      pairwise(query, target) do |left, right|
+        yield(apply_processor(left, processor), apply_processor(right, processor))
+      end
+    end
+
+    def resolve_inner_scorer(inner)
+      return inner if inner.respond_to?(:call)
+      case inner.to_s
+      when "jaro" then method(:jaro_similarity)
+      when "jaro_winkler" then method(:jaro_winkler_similarity)
+      when "levenshtein_ratio" then method(:levenshtein_normalized_score)
+      when "indel_ratio" then method(:indel_normalized_score)
+      else
+        raise ArgumentError, "unknown inner similarity: #{inner}"
+      end
+    end
+
+    def monge_direction(left, right, scorer)
+      left.sum do |token|
+        right.map do |candidate|
+          value = scorer.call(token, candidate)
+          unless value.is_a?(Numeric) && value.finite?
+            raise ArgumentError, "inner must return one finite numeric score"
+          end
+          value.to_f
+        end.max
+      end / left.length.to_f
+    end
+
+    def phonetic_equal(query, target, algorithm, variant)
+      pairwise(query, target) do |left, right|
+        if left.nil? || right.nil?
+          nil
+        else
+          left_code, right_code, equal = case algorithm
+                                         when :soundex
+                                           [__primary_backend.soundex(left),
+                                            __primary_backend.soundex(right),
+                                            __primary_backend.soundex_equal(left, right)]
+                                         when :metaphone
+                                           [__primary_backend.metaphone(left, variant),
+                                            __primary_backend.metaphone(right, variant),
+                                            __primary_backend.metaphone_equal(left, right, variant)]
+                                         else
+                                           [__primary_backend.nysiis(left),
+                                            __primary_backend.nysiis(right),
+                                            __primary_backend.nysiis_equal(left, right)]
+                                         end
+          !left_code.empty? && !right_code.empty? && equal
+        end
+      end
+    end
+
+    def register_bmpm_resources
+      return if @bmpm_registered
+      directory = __data_directory("bmpm_data")
+      resources = Dir[File.join(directory, "*.txt")].each_with_object({}) do |path, output|
+        output[File.basename(path, ".txt")] = File.binread(path)
+      end
+      raise LoadError, "stride-align BMPM rule resources are missing" if resources.empty?
+      __primary_backend.bmpm_register(resources)
+      @bmpm_registered = true
+    end
+  end
+end