latticerb 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f977e711ce31ec3c0355472e32dcff2f95cb82c173d8cbb983f05d9f8c49fb83
-  data.tar.gz: 73384303ddfe7fe6cbfef0cc72166d3a79ec975251a1be88a2c1560e02c594db
+  metadata.gz: e8b8ff092e386afd2f650b4b9915d837bab09cae92817516403ec373beba6997
+  data.tar.gz: 4b68178ac100e814c2613a3bd8ec724a60701fb5ae36a3f93038743f167a4b1a
 SHA512:
-  metadata.gz: 3d50633f9b3c3e6824811806ad8732fbfa7e12812eb94685a03cf2263254195243f44887cbe8984c297f8d05b800063367d7d5aca6413216cace5f7e3d869262
-  data.tar.gz: 2b0a3695bb8c6a00a8856aaa143aec10e488088e5f0800738dd3ddeefdd299fde8fd13010f406f680e085ee8c52ec6a6d0a0b7157eb993bbcbb04f8c58678817
+  metadata.gz: 0a33e59f0410f46973d5282ed63113567c4aa0c83f5f337436abc65cd37efe300b8cd30a8d3569c296cc3690e9d71d15fe847b0e58a880e039b992e342889aef
+  data.tar.gz: 3338d9ee6b71c1f8b5acac50b68139be4570da152efc58994a4ed73f33c730ccf649e6492b6fb522a7509b9c65ed8f46be45b7fe069e1b5485540f89bb86e522

data/Cargo.lock

@@ -0,0 +1,288 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.72.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "clang-sys",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
+
+[[package]]
+name = "clang-sys"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "157a8ba7b480713b56f4c09fd13fc3e0a22a5dfab8097ba61cbc5feef950788a"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "either"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be"
+
+[[package]]
+name = "glob"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b"
+
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "lattice-engine"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b686b7e557fb3f0246835e631958e8faaa44687e9afc2356ccd85438a952be92"
+
+[[package]]
+name = "lattice_native"
+version = "0.4.0"
+dependencies = [
+ "lattice-engine",
+ "magnus",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20870f649af7073d53e38067b2a84312175d56ea15217e1b15bc83506ec50afb"
+
+[[package]]
+name = "libc"
+version = "0.2.191"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a"
+
+[[package]]
+name = "libloading"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
+dependencies = [
+ "cfg-if",
+ "windows-link",
+]
+
+[[package]]
+name = "magnus"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40ef424404d166cbb71c8b8d19c9c589c748c4547c1afa1928c5504299f6c713"
+dependencies = [
+ "magnus-macros",
+ "rb-sys",
+ "rb-sys-env",
+ "seq-macro",
+]
+
+[[package]]
+name = "magnus-macros"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dafde2eeb66f090e0f326112323eb8324b12cb32b5d1210e541d3df6b0ce77e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rb-sys"
+version = "0.9.130"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02faf625bb10ba893e3ae620f19c9fb1b5f8fcae0fe4eb86bb3f2230fad75edb"
+dependencies = [
+ "rb-sys-build",
+]
+
+[[package]]
+name = "rb-sys-build"
+version = "0.9.130"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05be6f9c86fe5482808162826f6c047d093b3670582296c770de1d94f8066694"
+dependencies = [
+ "bindgen",
+ "lazy_static",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "shell-words",
+ "syn",
+]
+
+[[package]]
+name = "rb-sys-env"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cca7ad6a7e21e72151d56fe2495a259b5670e204c3adac41ee7ef676ea08117a"
+
+[[package]]
+name = "regex"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
+
+[[package]]
+name = "seq-macro"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
+
+[[package]]
+name = "shell-words"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"

data/Cargo.toml

@@ -0,0 +1,7 @@
+[workspace]
+members = ["ext/lattice_native"]
+resolver = "3"
+
+[profile.release]
+lto = true
+codegen-units = 1

data/README.md

@@ -4,7 +4,7 @@ Deterministic combinatorial coverage for constrained variant surfaces — roles,
 
 Lattice takes a schema of parameters, values, and constraints and generates a minimal covering array: the smallest practical set of scenarios in which every valid pair (or triple, at strength 3) of values appears at least once. Constraints are honored during generation, so no scenario is ever invalid.
 
-This is the Ruby implementation of [Lattice](https://github.com/tylerklose/lattice) ([lattice-cli on PyPI](https://pypi.org/project/lattice-cli/)). Same schema format, same algorithm, same seeds — **byte-identical output** for the same schema, seed, and pool size. That parity is enforced by the test suite, which runs both implementations and diffs their output. Use whichever runtime your project already has.
+This is the Ruby package of [Lattice](https://github.com/tylerklose/lattice) ([lattice-cli on PyPI](https://pypi.org/project/lattice-cli/)). Both packages generate scenarios with the same Rust engine, so they give **byte-identical output** for the same schema, seed and pool size. The test suite checks that by running both and comparing their output. Use whichever runtime your project already has.
 
 ## Install
 
@@ -19,6 +19,8 @@ or standalone:
 gem install latticerb
 ```
 
+The gem ships precompiled for macOS (Apple Silicon and Intel), Linux (x86-64 and ARM64, glibc and musl) and Windows (x86-64). On other platforms it compiles the engine on install, which needs a Rust toolchain. JRuby isn't supported, because it can't load native extensions. If your Gemfile.lock was created on a Mac and you deploy to Linux, add the platform once: `bundle lock --add-platform x86_64-linux`.
+
 ## Library usage
 
 The primary API is designed for test suites:
@@ -60,7 +62,7 @@ Lattice.scenarios(file: "...")  # shortcut straight to the hashes
 Lattice.validate!(schema)       # raises Lattice::ValidationError / Lattice::ConstraintError
 ```
 
-Generation options: `strength:` (default 2 = pairwise), `seed:` (default 42), `pool_size:`, `max_rows:`, `stop_after_coverage:`.
+Generation options: `strength:` (default 2 = pairwise), `seed:` (default 42), `pool_size:` (candidate rows per step, default 16), `max_rows:`, `stop_after_coverage:`.
 
 ## CLI usage
 
@@ -110,17 +112,45 @@ Every value in a schema (the model name, parameter names and values, and constra
 
 Changed in 0.3.0: earlier versions converted unquoted numbers and dates, so `0x1F` became `31`, `1.10` became `1.1`, and some values (`.inf`, timestamps) came out differently in the Ruby and Python implementations.
 
+## Performance
+
+Generation runs in a Rust engine (the `lattice-engine` crate), in two phases:
+
+1. **Build.** Rows are added greedily. Each row is the best of several candidates (`pool_size:`, default 16), and each candidate picks, value by value, whatever covers the most combinations still uncovered.
+2. **Shrink.** A row is removed and the gaps are repaired with tabu search, which changes values in the remaining rows without breaking any constraint or forced combination. This repeats while repairs succeed within a fixed step budget.
+
+The budget is a number of steps, not a time limit, so the same schema and seed give the same rows on every machine. The rows come out ordered so each adds the most new coverage, which is why `max_rows:` and `stop_after_coverage:` cut the set short with as much coverage as possible.
+
+Scenario counts against [PICT](https://github.com/microsoft/pict) 3.7, with default settings for both:
+
+| Model | PICT | Lattice 0.4 | Lattice 0.3 |
+|---|---|---|---|
+| 13 parameters × 3 values | 20 | **15** (best known) | 22 |
+| 100 × 2 | 16 | **10** (optimal) | over 60 s |
+| 61 mixed (4^15 3^17 2^29) | 40 | **30** | over 60 s |
+| 12 × 6 | 70 | **60** | 88 (32 s) |
+| 30 × 5 | 66 | **55** | over 60 s |
+| 20 × 10 | 218 | **192** | over 60 s |
+| Strength 3, 10 × 4 | 158 | **140** | 176 (27 s) |
+
+Each Lattice 0.4 run above takes 0.04–1.2 s on an Apple M-series laptop. PICT is faster (about 0.02 s) because it stops after the build phase.
+
+Changed in 0.4.0: rows differ from 0.3.x for the same seed, and every example needs the same number of scenarios or fewer. `pool_size:` now sets the candidates per row; its default went from 50 to 16.
+
 ## Parity with the Python implementation
 
-The generator seeds an MT19937 RNG that reproduces CPython's `random.Random` bit-for-bit, so both implementations walk the same candidate pools and pick the same rows. `test/python_parity_test.rb` shells out to the Python implementation (checkout via `LATTICE_PYTHON_SRC`, or an installed `lattice-cli`) and asserts byte-equal output across formats, seeds, strengths, and stopping rules; it skips when no Python implementation is available.
+Both packages parse schemas in their own language and hand the engine the same compiled constraints (`ConstraintEngine#engine_constraints` here, `lattice.ipog` in Python), so the engine gets identical input. `test/python_parity_test.rb` shells out to the Python implementation (checkout via `LATTICE_PYTHON_SRC`, or an installed `lattice-cli`) and asserts byte-equal output across formats, seeds, strengths and stopping rules; it skips when no Python implementation is available.
 
 Schemas are read with Psych here and PyYAML in Python, but both implementations build values from the parsed text with the same rules (see "Values keep their text"), so a schema means the same thing in either. `test/fixtures/scalar_text.*` pins those rules for both.
 
 ## Development
 
+Building the extension needs a Rust toolchain (`rustup`); the engine comes from crates.io (`lattice-engine`).
+
 ```bash
 bundle install
-bundle exec rake test        # unit, golden-parity, and live Python-parity suites
+bundle exec rake compile     # builds lib/lattice/lattice_native
+bundle exec rake test        # unit, golden-parity, and live Python-parity suites (compiles first)
 bundle exec mutant run       # mutation testing (see docs/mutation-testing.md)
 ```
 

data/ext/lattice_native/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "lattice_native"
+version = "0.4.0"
+edition = "2024"
+publish = false
+
+[lib]
+name = "lattice_native"
+crate-type = ["cdylib"]
+
+[dependencies]
+lattice-engine = { version = "0.1.0", default-features = false }
+magnus = "0.9"

data/ext/lattice_native/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("lattice/lattice_native")

data/ext/lattice_native/rustfmt.toml

@@ -0,0 +1 @@
+max_width = 120

data/ext/lattice_native/src/lib.rs

@@ -0,0 +1,114 @@
+//! Ruby bindings for the Lattice engine (`Lattice::Engine::Model`).
+//!
+//! `Model.new(sizes, weights, strength, invalid_pairs, requires, higher_order, forced)`
+//! takes a schema compiled to the engine's constraint primitives and answers:
+//! `feasibility` (raises ForcedInfeasible with the forced interaction's index,
+//! or NoValidAssignments), `can_complete?(assignments)`, and `generate(...)`.
+use std::cell::RefCell;
+
+use lattice_engine::{Assignment, Engine, Error as EngineError, Model as EngineModel, Options};
+use magnus::{Error, ExceptionClass, Module, Ruby, function, method, prelude::*, value::Lazy};
+
+type Pair = (Assignment, Assignment);
+
+static ENGINE_ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+    ruby.class_object()
+        .const_get::<_, magnus::RModule>("Lattice")
+        .and_then(|lattice| lattice.const_get::<_, magnus::RModule>("Engine"))
+        .and_then(|engine| engine.const_get("ForcedInfeasible"))
+        .unwrap()
+});
+
+static NO_VALID: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+    ruby.class_object()
+        .const_get::<_, magnus::RModule>("Lattice")
+        .and_then(|lattice| lattice.const_get::<_, magnus::RModule>("Engine"))
+        .and_then(|engine| engine.const_get("NoValidAssignments"))
+        .unwrap()
+});
+
+fn to_ruby(ruby: &Ruby, error: EngineError) -> Error {
+    match error {
+        EngineError::ForcedInfeasible(index) => Error::new(ruby.get_inner(&ENGINE_ERROR), index.to_string()),
+        EngineError::NoValidAssignments => Error::new(ruby.get_inner(&NO_VALID), "no valid assignments"),
+        other => Error::new(ruby.exception_arg_error(), format!("{other:?}")),
+    }
+}
+
+#[magnus::wrap(class = "Lattice::Engine::Model", free_immediately)]
+struct Model(RefCell<Engine>);
+
+impl Model {
+    fn new(
+        ruby: &Ruby,
+        sizes: Vec<usize>,
+        weights: Vec<Vec<f64>>,
+        strength: usize,
+        invalid_pairs: Vec<Pair>,
+        requires: Vec<Pair>,
+        higher_order: Vec<(Vec<Assignment>, Assignment)>,
+        forced: Vec<Vec<Assignment>>,
+    ) -> Result<Self, Error> {
+        let model = EngineModel {
+            sizes,
+            weights,
+            strength,
+            invalid_pairs,
+            requires,
+            higher_order,
+            forced,
+        };
+        Engine::new(model)
+            .map(|engine| Model(RefCell::new(engine)))
+            .map_err(|e| to_ruby(ruby, e))
+    }
+
+    fn feasibility(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
+        rb_self.0.borrow_mut().feasibility().map_err(|e| to_ruby(ruby, e))
+    }
+
+    fn can_complete(ruby: &Ruby, rb_self: &Self, assignments: Vec<Assignment>) -> Result<bool, Error> {
+        rb_self
+            .0
+            .borrow_mut()
+            .can_complete(&assignments)
+            .map_err(|e| to_ruby(ruby, e))
+    }
+
+    /// Returns [rows ordered by coverage, new tuples per row, valid tuples].
+    fn generate(
+        ruby: &Ruby,
+        rb_self: &Self,
+        seed: u64,
+        candidates: usize,
+        shrink_steps: u64,
+        patience: u64,
+    ) -> Result<(Vec<Vec<usize>>, Vec<usize>, usize), Error> {
+        let options = Options {
+            seed,
+            candidates: candidates.max(1),
+            shrink_steps,
+            patience,
+        };
+        let result = rb_self
+            .0
+            .borrow_mut()
+            .generate(&options)
+            .map_err(|e| to_ruby(ruby, e))?;
+        Ok((result.rows, result.new_coverage, result.valid_tuples))
+    }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let engine = ruby.define_module("Lattice")?.define_module("Engine")?;
+    let base = engine.define_error("Error", ruby.exception_standard_error())?;
+    engine.define_error("ForcedInfeasible", base)?;
+    engine.define_error("NoValidAssignments", base)?;
+    let model = engine.define_class("Model", ruby.class_object())?;
+    model.define_singleton_method("new", function!(Model::new, 7))?;
+    model.define_method("feasibility", method!(Model::feasibility, 0))?;
+    model.define_method("can_complete?", method!(Model::can_complete, 1))?;
+    model.define_method("generate", method!(Model::generate, 4))?;
+    Ok(())
+}

data/lib/lattice/cli.rb

@@ -59,7 +59,7 @@ module Lattice
       options = {
         format: "json",
         seed: 42,
-        pool_size: 50,
+        pool_size: 16,
         progress: false,
         progress_every: 10
       }
@@ -67,7 +67,7 @@ module Lattice
         opts.on("--strength STRENGTH", Integer)
         opts.on("--format FORMAT", %w[table json csv summary yaml])
         opts.on("--seed SEED", Integer)
-        opts.on("--pool-size SIZE", Integer) { |value| options[:pool_size] = value }
+        opts.on("--pool-size SIZE", Integer, "Candidate rows built per step; more can mean fewer scenarios.") { |value| options[:pool_size] = value }
         opts.on("--max-rows ROWS", Integer) { |value| options[:max_rows] = value }
         opts.on("--stop-after-coverage PCT", Float) { |value| options[:stop_after_coverage] = value }
         opts.on("--progress")
@@ -117,7 +117,7 @@ module Lattice
     def load_and_check_model(model_path, options)
       model = Parser.load_model(model_path, strength_override: options[:strength])
       engine = ConstraintEngine.new(model)
-      raise ValidationError, ["Model has no valid complete assignments."] unless engine.can_complete?({})
+      raise ValidationError, ["Model has no valid complete assignments."] unless engine.satisfiable?
 
       model
     rescue ValidationError => e

data/lib/lattice/constraints.rb

@@ -3,18 +3,21 @@
 require "set"
 
 require_relative "model"
+require_relative "native"
 
 module Lattice
   class ConstraintError < StandardError; end
 
-  # Compiles model constraints into invalid-pair / requirement closures and
-  # answers feasibility questions over partial assignments. Assignments are
-  # referenced as `[parameter_index, value_index]` pairs; partial assignments
-  # are `{parameter_index => value_index}` hashes.
+  # Compiles a model's constraints to the engine's primitives (invalid pairs,
+  # requirements, higher-order exclusions, forced interactions), checks the
+  # compiled closure for contradictions, and asks the Rust engine whether the
+  # model and its forced interactions are satisfiable. Python's
+  # lattice.constraints does the same, so both report the same errors.
+  # Assignments are `[parameter_index, value_index]` pairs.
   class ConstraintEngine
     EMPTY_SET = Set.new.freeze
 
-    attr_reader :model, :forced_interactions
+    attr_reader :model, :forced_interactions, :native
 
     def initialize(model)
       @model = model
@@ -29,51 +32,56 @@ module Lattice
       @requires = {}
       @higher_order = []
       @forced_interactions = []
-      @feasibility_cache = {}
       compile_constraints
       compute_implied_pairs
       validate_compiled_constraints
+      @native = native_model(model.strength)
+      @satisfiable = check_feasibility
     end
 
-    def conflicts?(left, right)
-      invalid_pairs_for(to_ref(left)).include?(to_ref(right))
-    end
-
-    def implied_requirements(assignment)
-      requires_for(to_ref(assignment)).map { |ref| from_ref(ref) }.sort
+    # Whether any row satisfies every constraint.
+    def satisfiable?
+      @satisfiable
     end
 
+    # Whether some valid row contains every assignment in `partial`
+    # (a `{parameter_index => value_index}` hash).
     def can_complete?(partial)
-      normalized = normalize_partial(partial.dup)
-      return false if normalized.nil?
-
-      signature = normalized.sort
-      cached = @feasibility_cache[signature]
-      return cached unless cached.nil?
-
-      result = !backtrack_complete(normalized, rng: nil, failures: Set.new).nil?
-      @feasibility_cache[signature] = result
-      result
+      native.can_complete?(partial.sort)
     end
 
-    def complete_assignment(partial, rng: nil)
-      normalized = normalize_partial(partial.dup)
-      return nil if normalized.nil?
+    def native_model(strength)
+      compiled = engine_constraints
+      Engine::Model.new(
+        model.parameters.map { |parameter| parameter.values.length },
+        model.parameters.map(&:normalized_weights),
+        strength,
+        compiled.fetch(:invalid_pairs),
+        compiled.fetch(:requires),
+        compiled.fetch(:higher_order),
+        compiled.fetch(:forced)
+      )
+    end
 
-      backtrack_complete(normalized, rng:, failures: Set.new)
+    def conflicts?(left, right)
+      invalid_pairs_for(to_ref(left)).include?(to_ref(right))
     end
 
-    def complete_assignment_valid?(row)
-      partial = row.each_with_index.to_h { |value_index, parameter_index| [parameter_index, value_index] }
-      normalized = normalize_partial(partial)
-      return false if normalized.nil? || normalized.length != model.parameters.length
+    # The compiled constraints as the generation engine takes them: invalid
+    # pairs and requirements as sorted [[p, v], [q, w]] lists, higher-order
+    # exclusions and forced interactions in compile order. Python's
+    # lattice.ipog builds the same lists, so the engine gets identical input.
+    def engine_constraints
+      {
+        invalid_pairs: ref_pairs(@invalid_pairs),
+        requires: ref_pairs(@requires),
+        higher_order: @higher_order,
+        forced: @forced_interactions
+      }
+    end
 
-      @higher_order.each do |antecedents, forbidden|
-        if antecedents.all? { |parameter_index, value_index| normalized[parameter_index] == value_index }
-          return false if normalized[forbidden[0]] == forbidden[1]
-        end
-      end
-      true
+    def implied_requirements(assignment)
+      requires_for(to_ref(assignment)).map { |ref| from_ref(ref) }.sort
     end
 
     private
@@ -187,125 +195,21 @@ module Lattice
         end
       end
 
-      @forced_interactions.each do |forced|
-        partial = forced.to_h { |parameter_index, value_index| [parameter_index, value_index] }
-        next unless complete_assignment(partial, rng: nil).nil?
-
-        assignments = forced.map do |parameter_index, value_index|
-          parameter = model.parameters[parameter_index]
-          "#{parameter.name}=#{parameter.values[value_index]}"
-        end.join(", ")
-        raise ConstraintError, "Forced interaction is not feasible: #{assignments}."
-      end
-    end
-
-    def normalize_partial(partial)
-      normalized = partial.dup
-      changed = true
-      while changed
-        changed = false
-        return nil unless partial_consistent?(normalized)
-
-        normalized.to_a.each do |parameter_index, value_index|
-          requires_for([parameter_index, value_index]).each do |required_parameter, required_value|
-            current = normalized[required_parameter]
-            if current.nil?
-              normalized[required_parameter] = required_value
-              changed = true
-            elsif current != required_value
-              return nil
-            end
-          end
-        end
-      end
-      return nil unless partial_consistent?(normalized)
-
-      normalized
     end
 
-    def partial_consistent?(partial)
-      partial.each do |parameter_index, value_index|
-        partial.each do |other_parameter, other_value|
-          next if parameter_index == other_parameter
-
-          return false if invalid_pairs_for([parameter_index, value_index]).include?([other_parameter, other_value])
-        end
-      end
-
-      @higher_order.each do |antecedents, forbidden|
-        if antecedents.all? { |parameter_index, value_index| partial[parameter_index] == value_index }
-          return false if partial[forbidden[0]] == forbidden[1]
-        end
-      end
+    # Raises for the first impossible forced interaction; otherwise returns
+    # whether the model has any valid row.
+    def check_feasibility
+      native.feasibility
       true
-    end
-
-    def backtrack_complete(partial, rng:, failures:)
-      signature = partial.sort
-      return nil if failures.include?(signature)
-
-      if partial.length == model.parameters.length
-        row = (0...model.parameters.length).map { |index| partial.fetch(index) }
-        return complete_assignment_valid?(row) ? row : nil
-      end
-
-      next_parameter, values = next_parameter_values(partial)
-      if next_parameter.nil?
-        failures.add(signature)
-        return nil
-      end
-
-      ordered_values(next_parameter, values, rng).each do |value|
-        candidate = partial.dup
-        candidate[next_parameter] = value
-        normalized = normalize_partial(candidate)
-        next if normalized.nil?
-
-        result = backtrack_complete(normalized, rng:, failures:)
-        return result unless result.nil?
-      end
-
-      failures.add(signature)
-      nil
-    end
-
-    def next_parameter_values(partial)
-      best_parameter = nil
-      best_values = []
-      best_size = nil
-
-      model.parameters.each_with_index do |parameter, parameter_index|
-        next if partial.key?(parameter_index)
-
-        feasible = []
-        (0...parameter.values.length).each do |value_index|
-          candidate = partial.dup
-          candidate[parameter_index] = value_index
-          feasible << value_index unless normalize_partial(candidate).nil?
-        end
-
-        return [nil, []] if feasible.empty?
-
-        if best_size.nil? || feasible.length < best_size
-          best_parameter = parameter_index
-          best_values = feasible
-          best_size = feasible.length
-        end
-      end
-
-      [best_parameter, best_values]
-    end
-
-    def ordered_values(parameter_index, values, rng)
-      parameter = model.parameters[parameter_index]
-      if rng.nil?
-        return values.sort_by { |value_index| [-parameter.normalized_weights[value_index], value_index] }
-      end
-
-      values
-        .map { |value_index| [rng.random / [parameter.normalized_weights[value_index], 1e-9].max, value_index] }
-        .sort
-        .map { |_, value_index| value_index }
+    rescue Engine::ForcedInfeasible => e
+      assignments = @forced_interactions.fetch(Integer(e.message)).map do |parameter_index, value_index|
+        parameter = model.parameters[parameter_index]
+        "#{parameter.name}=#{parameter.values[value_index]}"
+      end.join(", ")
+      raise ConstraintError, "Forced interaction is not feasible: #{assignments}."
+    rescue Engine::NoValidAssignments
+      false
     end
 
     def exclude_other_values(source, required)
@@ -330,6 +234,10 @@ module Lattice
       @invalid_pairs[ref] || EMPTY_SET
     end
 
+    def ref_pairs(table)
+      table.flat_map { |source, targets| targets.map { |target| [source, target] } }.sort
+    end
+
     def requires_for(ref)
       @requires[ref] || EMPTY_SET
     end

data/lib/lattice/formatters.rb

@@ -180,7 +180,7 @@ module Lattice
 
       reduction = exhaustive_count.to_f / scenario_count
       if (reduction - reduction.round).abs < 1e-9
-        "#{reduction.round(half: :even)}x"
+        "#{reduction.round}x"
       else
         format("%.1fx", reduction)
       end

data/lib/lattice/ipog.rb

@@ -1,27 +1,33 @@
 # frozen_string_literal: true
 
-require "set"
-
 require_relative "constraints"
-require_relative "mersenne_twister"
 
 module Lattice
   CoveragePoint = Data.define(:scenario, :cumulative_pct)
   GenerationResult = Data.define(:rows, :coverage_curve, :total_valid_tuples)
   GenerationProgress = Data.define(:event, :scenario, :covered, :total, :cumulative_pct, :uncovered)
 
-  # Greedy covering-array generation (IPOG-style): enumerate every valid
-  # t-way interaction, then repeatedly extend the lowest uncovered tuple into
-  # the highest-scoring full row from a seeded candidate pool. Deterministic
-  # for a given seed, and row-for-row identical to the Python implementation.
+  # Scenario generation, backed by the Rust engine (Lattice::Engine, built from
+  # ext/lattice_native on the lattice-engine crate). The engine builds a covering
+  # array greedily, choosing each row from several candidates, then shrinks it
+  # with tabu search, and returns the rows ordered so each adds the most new
+  # coverage. ConstraintEngine compiles the model into the engine's input; this
+  # module applies max_rows and stop_after_coverage by cutting the ordered rows
+  # short. Python's lattice.ipog does the same, so both give identical rows.
   module IPOG
     extend self
 
+    DEFAULT_CANDIDATES = 16
+    SHRINK_STEPS = 1_000_000
+    PATIENCE = 10_000
+    SEED_MODULUS = 2**64
+
+    # `pool_size` is the number of candidate rows built per greedy step.
     def generate_covering_array(
       model,
       strength: nil,
       seed: 42,
-      pool_size: 50,
+      pool_size: DEFAULT_CANDIDATES,
       progress: nil,
       max_rows: nil,
       stop_after_coverage: nil
@@ -33,125 +39,43 @@ module Lattice
       coverage_target = coverage_target_for(stop_after_coverage)
 
       engine = ConstraintEngine.new(model)
-      raise ArgumentError, "Model has no valid full assignments." unless engine.can_complete?({})
-
-      valid_tuples = enumerate_valid_tuples(model, engine, actual_strength, progress:)
-      uncovered = Set.new(valid_tuples)
-      rows = []
-      coverage_points = []
-      rng = MersenneTwister.new(seed)
-      limit_reached = false
-      progress&.call(
-        GenerationProgress.new(
-          event: "enumerated",
-          scenario: 0,
-          covered: 0,
-          total: valid_tuples.length,
-          cumulative_pct: coverage_pct(0, valid_tuples.length),
-          uncovered: uncovered.length
-        )
-      )
-
-      record_row = lambda do |row|
-        newly_covered = covered_tuples(row, actual_strength, uncovered)
-        rows << row
-        uncovered.subtract(newly_covered)
-        covered = valid_tuples.length - uncovered.length
-        cumulative_pct = coverage_pct(covered, valid_tuples.length)
-        coverage_points << CoveragePoint.new(scenario: rows.length, cumulative_pct:)
-        progress&.call(
-          GenerationProgress.new(
-            event: "scenario",
-            scenario: rows.length,
-            covered:,
-            total: valid_tuples.length,
-            cumulative_pct:,
-            uncovered: uncovered.length
-          )
-        )
-        if should_stop?(rows.length, cumulative_pct, max_rows, coverage_target)
-          progress&.call(
-            GenerationProgress.new(
-              event: "stopped",
-              scenario: rows.length,
-              covered:,
-              total: valid_tuples.length,
-              cumulative_pct:,
-              uncovered: uncovered.length
-            )
-          )
-          true
-        else
-          false
-        end
-      end
-
-      engine.forced_interactions.each do |forced|
-        partial = forced.to_h { |parameter_index, value_index| [parameter_index, value_index] }
-        row = best_candidate_row(model, engine, partial, uncovered, actual_strength, pool_size, rng)
-        next if row.nil? || rows.include?(row)
-
-        if record_row.call(row)
-          limit_reached = true
-          break
-        end
+      raise ArgumentError, "Model has no valid full assignments." unless engine.satisfiable?
+
+      native = actual_strength == model.strength ? engine.native : engine.native_model(actual_strength)
+      rows, new_coverage, total = native.generate(seed % SEED_MODULUS, pool_size, SHRINK_STEPS, PATIENCE)
+
+      report(progress, "enumerated", 0, 0, total)
+      kept = []
+      curve = []
+      covered = 0
+      rows.zip(new_coverage) do |row, gained|
+        kept << row.freeze
+        covered += gained
+        cumulative_pct = coverage_pct(covered, total)
+        curve << CoveragePoint.new(scenario: kept.length, cumulative_pct:)
+        report(progress, "scenario", kept.length, covered, total)
+        next unless should_stop?(kept.length, cumulative_pct, max_rows, coverage_target)
+
+        report(progress, "stopped", kept.length, covered, total) if kept.length < rows.length
+        break
       end
 
-      while !uncovered.empty? && !limit_reached
-        seed_tuple = uncovered.min
-        partial = seed_tuple.to_h { |parameter_index, value_index| [parameter_index, value_index] }
-        row = best_candidate_row(model, engine, partial, uncovered, actual_strength, pool_size, rng)
-        raise "Unable to complete uncovered tuple: #{seed_tuple.inspect}" if row.nil?
-
-        if record_row.call(row)
-          limit_reached = true
-          break
-        end
-      end
-
-      GenerationResult.new(
-        rows: rows.freeze,
-        coverage_curve: coverage_points.freeze,
-        total_valid_tuples: valid_tuples.length
-      )
+      GenerationResult.new(rows: kept.freeze, coverage_curve: curve.freeze, total_valid_tuples: total)
     end
 
-    def enumerate_valid_tuples(model, engine, strength, progress: nil)
-      tuples = []
-      total_candidates = candidate_tuple_count(model, strength)
-      checked = 0
-      report = lambda do
-        progress&.call(
-          GenerationProgress.new(
-            event: "enumerating",
-            scenario: 0,
-            covered: checked,
-            total: total_candidates,
-            cumulative_pct: coverage_pct(checked, total_candidates),
-            uncovered: [0, total_candidates - checked].max
-          )
-        )
-      end
-
-      (0...model.parameters.length).to_a.combination(strength) do |parameter_combo|
-        domains = parameter_combo.map { |parameter_index| (0...model.parameters[parameter_index].values.length).to_a }
-        domains[0].product(*domains[1..]) do |value_combo|
-          checked += 1
-          partial = parameter_combo.each_with_index.to_h { |parameter_index, offset| [parameter_index, value_combo[offset]] }
-          tuples << parameter_combo.zip(value_combo) if engine.can_complete?(partial)
-          report.call if progress && (checked % 1000).zero?
-        end
-      end
-      report.call if progress
-      tuples
-    end
+    private
 
-    def candidate_tuple_count(model, strength)
-      total = 0
-      (0...model.parameters.length).to_a.combination(strength) do |parameter_combo|
-        total += parameter_combo.inject(1) { |count, parameter_index| count * model.parameters[parameter_index].values.length }
-      end
-      total
+    def report(progress, event, scenario, covered, total)
+      progress&.call(
+        GenerationProgress.new(
+          event:,
+          scenario:,
+          covered:,
+          total:,
+          cumulative_pct: coverage_pct(covered, total),
+          uncovered: total - covered
+        )
+      )
     end
 
     def coverage_target_for(stop_after_coverage)
@@ -160,7 +84,6 @@ module Lattice
       unless stop_after_coverage.positive? && stop_after_coverage <= 100
         raise ArgumentError, "`stop_after_coverage` must be in the range (0, 100]."
       end
-      return nil if stop_after_coverage >= 100
 
       stop_after_coverage
     end
@@ -172,51 +95,9 @@ module Lattice
       false
     end
 
-    def best_candidate_row(model, engine, partial, uncovered, strength, pool_size, rng)
-      candidates = {}
-      deterministic = engine.complete_assignment(partial, rng: nil)
-      candidates[deterministic] = score_row(model, deterministic, uncovered, strength) unless deterministic.nil?
-
-      (pool_size - 1).times do
-        attempt_rng = MersenneTwister.new(rng.getrandbits(64))
-        candidate = engine.complete_assignment(partial, rng: attempt_rng)
-        next if candidate.nil?
-
-        score = score_row(model, candidate, uncovered, strength)
-        previous = candidates[candidate]
-        candidates[candidate] = score if previous.nil? || (score <=> previous).positive?
-      end
-
-      return nil if candidates.empty?
-
-      candidates.max_by { |row, score| [score[0], score[1], reverse_lex(row)] }[0]
-    end
-
-    def score_row(model, row, uncovered, strength)
-      newly_covered = covered_tuples(row, strength, uncovered).length
-      weight_score = row.each_with_index.inject(0.0) do |acc, (value_index, parameter_index)|
-        acc + model.parameters[parameter_index].normalized_weights[value_index]
-      end
-      [newly_covered, weight_score]
-    end
-
-    def covered_tuples(row, strength, candidate_tuples)
-      covered = Set.new
-      (0...row.length).to_a.combination(strength) do |parameter_combo|
-        tuple_key = parameter_combo.map { |parameter_index| [parameter_index, row[parameter_index]] }
-        covered.add(tuple_key) if candidate_tuples.include?(tuple_key)
-      end
-      covered
-    end
-
+    # A satisfiable model always has valid tuples, so total_count is positive.
     def coverage_pct(covered_count, total_count)
-      return 100.0 if total_count.zero?
-
       ((covered_count.to_f / total_count) * 100).round(1, half: :even)
     end
-
-    def reverse_lex(row)
-      row.map(&:-@)
-    end
   end
 end

data/lib/lattice/native.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Loads the Rust engine (Lattice::Engine). Precompiled gems carry one build per
+# Ruby version (lib/lattice/3.4/...); a gem compiled on install has a single one
+# next to this file.
+begin
+  require_relative "#{RUBY_VERSION[/\A\d+\.\d+/]}/lattice_native"
+rescue LoadError
+  require_relative "lattice_native"
+end

data/lib/lattice/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lattice
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/lattice.rb

@@ -57,7 +57,7 @@ module Lattice
     #
     #   run = Lattice.generate(file: "spec/fixtures/checkout.yaml")
     #   run.scenarios.each { |row| ... }
-    def generate(source = nil, file: nil, strength: nil, seed: 42, pool_size: 50,
+    def generate(source = nil, file: nil, strength: nil, seed: 42, pool_size: 16,
                  max_rows: nil, stop_after_coverage: nil, progress: nil)
       model = parse_model(source, file:, strength:)
       result = IPOG.generate_covering_array(
@@ -80,7 +80,7 @@ module Lattice
     def validate!(source = nil, file: nil, strength: nil)
       model = parse_model(source, file:, strength:)
       engine = ConstraintEngine.new(model)
-      raise ValidationError, ["Model has no valid complete assignments."] unless engine.can_complete?({})
+      raise ValidationError, ["Model has no valid complete assignments."] unless engine.satisfiable?
 
       model
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: latticerb
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Tyler Klose
@@ -23,28 +23,50 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 description: Lattice generates deterministic pairwise/t-way covering arrays from a
   constrained schema of parameters and values. Use it as a library in test suites
-  (RSpec, Minitest, Rails fixtures) or via the bundled `lattice` CLI. Output is row-for-row
-  identical to the Python lattice-cli package for the same schema and seed.
+  (RSpec, Minitest, Rails fixtures) or via the bundled `lattice` CLI. Generation runs
+  in a Rust engine shared with the Python lattice-cli package, so both give identical
+  rows for the same schema and seed.
 email:
 - tylerklose@gmail.com
 executables:
 - lattice
-extensions: []
+extensions:
+- ext/lattice_native/extconf.rb
 extra_rdoc_files: []
 files:
+- Cargo.lock
+- Cargo.toml
 - LICENSE
 - README.md
 - exe/lattice
+- ext/lattice_native/Cargo.toml
+- ext/lattice_native/extconf.rb
+- ext/lattice_native/rustfmt.toml
+- ext/lattice_native/src/lib.rs
 - lib/lattice.rb
 - lib/lattice/agent.rb
 - lib/lattice/cli.rb
 - lib/lattice/constraints.rb
 - lib/lattice/formatters.rb
 - lib/lattice/ipog.rb
-- lib/lattice/mersenne_twister.rb
 - lib/lattice/model.rb
+- lib/lattice/native.rb
 - lib/lattice/parser.rb
 - lib/lattice/resources/claude/lattice-workflow/SKILL.md
 - lib/lattice/resources/claude/lattice-workflow/references/modeling-rules.md

data/lib/lattice/mersenne_twister.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module Lattice
-  # MT19937 matching CPython's `random.Random` bit-for-bit — same integer
-  # seeding (init_by_array over 32-bit words), same 53-bit `random`, same
-  # little-endian word order for `getrandbits` — so a given seed produces
-  # identical covering arrays here and in the Python implementation.
-  class MersenneTwister
-    N = 624
-    M = 397
-    MATRIX_A = 0x9908b0df
-    UPPER_MASK = 0x80000000
-    LOWER_MASK = 0x7fffffff
-    MASK32 = 0xffffffff
-
-    def initialize(seed)
-      seed = seed.abs
-      key = []
-      while seed.positive?
-        key << (seed & MASK32)
-        seed >>= 32
-      end
-      key << 0 if key.empty?
-      init_by_array(key)
-    end
-
-    def random
-      a = genrand_uint32 >> 5
-      b = genrand_uint32 >> 6
-      (a * 67_108_864.0 + b) * (1.0 / 9_007_199_254_740_992.0)
-    end
-
-    def getrandbits(bits)
-      result = 0
-      shift = 0
-      while bits.positive?
-        word = genrand_uint32
-        word >>= (32 - bits) if bits < 32
-        result |= word << shift
-        shift += 32
-        bits -= 32
-      end
-      result
-    end
-
-    private
-
-    def init_genrand(seed)
-      @mt = Array.new(N)
-      @mt[0] = seed & MASK32
-      (1...N).each do |i|
-        @mt[i] = (1_812_433_253 * (@mt[i - 1] ^ (@mt[i - 1] >> 30)) + i) & MASK32
-      end
-      @mti = N
-    end
-
-    def init_by_array(key)
-      init_genrand(19_650_218)
-      i = 1
-      j = 0
-      count = [N, key.length].max
-      while count.positive?
-        @mt[i] = ((@mt[i] ^ ((@mt[i - 1] ^ (@mt[i - 1] >> 30)) * 1_664_525)) + key[j] + j) & MASK32
-        i += 1
-        j += 1
-        if i >= N
-          @mt[0] = @mt[N - 1]
-          i = 1
-        end
-        j = 0 if j >= key.length
-        count -= 1
-      end
-      count = N - 1
-      while count.positive?
-        @mt[i] = ((@mt[i] ^ ((@mt[i - 1] ^ (@mt[i - 1] >> 30)) * 1_566_083_941)) - i) & MASK32
-        i += 1
-        if i >= N
-          @mt[0] = @mt[N - 1]
-          i = 1
-        end
-        count -= 1
-      end
-      @mt[0] = 0x80000000
-    end
-
-    def genrand_uint32
-      if @mti >= N
-        (0...N).each do |kk|
-          y = (@mt[kk] & UPPER_MASK) | (@mt[(kk + 1) % N] & LOWER_MASK)
-          @mt[kk] = @mt[(kk + M) % N] ^ (y >> 1) ^ (y.odd? ? MATRIX_A : 0)
-        end
-        @mti = 0
-      end
-      y = @mt[@mti]
-      @mti += 1
-      y ^= (y >> 11)
-      y = (y ^ ((y << 7) & 0x9d2c5680)) & MASK32
-      y = (y ^ ((y << 15) & 0xefc60000)) & MASK32
-      y ^ (y >> 18)
-    end
-  end
-end