hypothesis-specs 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e8eb07704e06280a79469b76b6b7267cf356797
-  data.tar.gz: edd8bb7476a3a84dedf2751016385dbe2d6afcac
+  metadata.gz: 2e49a69e84d999619c8b73873bc8dc92f4e9e534
+  data.tar.gz: d51bc24f3c230ec37a4a19ddcbd43ca5532646ee
 SHA512:
-  metadata.gz: 8e72ef276034266146155092d14827e75f5f20ec3986dd57245f94694e1f7da09d5cc62b74fced3829e0d8e5dbff522ad44d6fc88e2e49d274979eaae3f06e0e
-  data.tar.gz: b6917a3a24f98febffaab647ecec0393827e3f116390762d3163cd9d2fe7e1cac49cfd79bc2db1e448beb044e862b0c96c79a5e3e8d7aed986ff718eef755d40
+  metadata.gz: 1fc1e55701ebf1b24184f243ee232eb4528d85d6306fbe83e95bfd37a0f6f1328077181496620214f3674a2e3f8063bd628178539cbf3eca5af28a7dea86e1a1
+  data.tar.gz: 87772f4660cdef5a8a93df5eb81d2322896c58536d3aff5f2ea9a93ec973b83c0ee99c26b4e08467a91af7948dc46ec73a556cbdc3af3a725f075bcdd2b1e148

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## Hypothesis for Ruby 0.0.10 (2018-04-26)
+
+This release is another update to shrinking:
+
+* Cases where the value may be simplified without necessarily
+  becoming smaller will have better results.
+* Duplicated values can now sometimes be simultaneously shrunk.
+
 ## Hypothesis for Ruby 0.0.9 (2018-04-20)
 
 This improves Hypothesis for Ruby's shrinking to be much closer

data/Rakefile

@@ -16,7 +16,11 @@ begin
     t.verbose = true
   end
 
-  task test: %i[build spec minitests]
+  task :rust_tests do
+    sh 'cargo test'
+  end
+
+  task test: %i[build spec minitests rust_tests]
 rescue LoadError
 end
 

data/src/data.rs

@@ -39,6 +39,7 @@ pub struct Draw {
 pub struct DataSource {
     bitgenerator: BitGenerator,
     record: DataStream,
+    sizes: Vec<u64>,
     draws: Vec<DrawInProgress>,
     draw_stack: Vec<usize>,
     written_indices: HashSet<usize>,
@@ -49,6 +50,7 @@ impl DataSource {
         return DataSource {
             bitgenerator: generator,
             record: DataStream::new(),
+            sizes: Vec::new(),
             draws: Vec::new(),
             draw_stack: Vec::new(),
             written_indices: HashSet::new(),
@@ -88,6 +90,7 @@ impl DataSource {
         match self.bitgenerator {
             BitGenerator::Recorded(ref mut v) if self.record.len() >= v.len() => Err(FailedDraw),
             _ => {
+                self.sizes.push(0);
                 self.record.push(value);
                 Ok(())
             }
@@ -95,6 +98,7 @@ impl DataSource {
     }
 
     pub fn bits(&mut self, n_bits: u64) -> Result<u64, FailedDraw> {
+        self.sizes.push(n_bits);
         let mut result = match self.bitgenerator {
             BitGenerator::Random(ref mut random) => random.next_u64(),
             BitGenerator::Recorded(ref mut v) => if self.record.len() >= v.len() {
@@ -119,6 +123,7 @@ impl DataSource {
             record: self.record,
             status: status,
             written_indices: self.written_indices,
+            sizes: self.sizes,
             draws: self.draws
                 .drain(..)
                 .filter_map(|d| match d {
@@ -174,5 +179,6 @@ pub struct TestResult {
     pub record: DataStream,
     pub status: Status,
     pub draws: Vec<Draw>,
+    pub sizes: Vec<u64>,
     pub written_indices: HashSet<usize>,
 }

data/src/distributions.rs

@@ -1,8 +1,8 @@
 use data::{DataSource, FailedDraw};
 
+use std::cmp::{Ord, Ordering, PartialOrd, Reverse};
 use std::collections::BinaryHeap;
 use std::mem;
-use std::cmp::{Ord, Ordering, PartialOrd, Reverse};
 
 use std::u64::MAX as MAX64;
 
@@ -216,16 +216,71 @@ impl Sampler {
 }
 
 pub fn good_bitlengths() -> Sampler {
-    let weights = vec!(
-    4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, // 1 byte
-    2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, // 2 bytes
-    1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, // 3 bytes
-    0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, // 4 bytes
-    0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, // 5 bytes
-    0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, // 6 bytes
-    0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, // 7 bytes
-    0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1,      // 8 bytes (last bit spare for sign)
-  );
+    let weights = vec![
+        4.0,
+        4.0,
+        4.0,
+        4.0,
+        4.0,
+        4.0,
+        4.0,
+        4.0, // 1 byte
+        2.0,
+        2.0,
+        2.0,
+        2.0,
+        2.0,
+        2.0,
+        2.0,
+        2.0, // 2 bytes
+        1.0,
+        1.0,
+        1.0,
+        1.0,
+        1.0,
+        1.0,
+        1.0,
+        1.0, // 3 bytes
+        0.5,
+        0.5,
+        0.5,
+        0.5,
+        0.5,
+        0.5,
+        0.5,
+        0.5, // 4 bytes
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1, // 5 bytes
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1, // 6 bytes
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1, // 7 bytes
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1,
+        0.1, // 8 bytes (last bit spare for sign)
+    ];
     assert!(weights.len() == 63);
     Sampler::new(weights)
 }

data/src/engine.rs

@@ -3,11 +3,14 @@
 
 use rand::{ChaChaRng, Rng, SeedableRng};
 
+use std::cmp::Reverse;
+use std::collections::HashMap;
+use std::mem;
 use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
 use std::thread;
-use std::mem;
 
 use data::{DataSource, DataStream, Status, TestResult};
+use intminimize::minimize_integer;
 
 #[derive(Debug, Clone)]
 enum LoopExitReason {
@@ -153,7 +156,8 @@ where
         while prev != self.changes {
             prev = self.changes;
             self.adaptive_delete()?;
-            self.binary_search_blocks()?;
+            self.minimize_individual_blocks()?;
+            self.minimize_duplicated_blocks()?;
             if prev == self.changes {
                 self.expensive_passes_enabled = true;
             }
@@ -354,27 +358,14 @@ where
         }
     }
 
-    fn binary_search_blocks(&mut self) -> StepResult {
+    fn minimize_individual_blocks(&mut self) -> StepResult {
         let mut i = 0;
 
         while i < self.shrink_target.record.len() {
-            let mut hi = self.shrink_target.record[i];
-
-            if hi > 0 && !self.shrink_target.written_indices.contains(&i) {
-                let zeroed = self.try_lowering_value(i, 0)?;
-                if !zeroed {
-                    let mut lo = 0;
-                    // Binary search to find the smallest value we can
-                    // replace this with.
-                    while lo + 1 < hi {
-                        let mid = lo + (hi - lo) / 2;
-                        if self.try_lowering_value(i, mid)? {
-                            hi = mid;
-                        } else {
-                            lo = mid;
-                        }
-                    }
-                }
+            if !self.shrink_target.written_indices.contains(&i) {
+                minimize_integer(self.shrink_target.record[i], |v| {
+                    self.try_lowering_value(i, v)
+                })?;
             }
 
             i += 1;
@@ -383,6 +374,61 @@ where
         Ok(())
     }
 
+    fn calc_duplicates(&self) -> Vec<Vec<usize>> {
+        assert!(self.shrink_target.record.len() == self.shrink_target.sizes.len());
+        let mut duplicates: HashMap<(u64, u64), Vec<usize>> = HashMap::new();
+        for (i, (u, v)) in self.shrink_target
+            .record
+            .iter()
+            .zip(self.shrink_target.sizes.iter())
+            .enumerate()
+        {
+            if !self.shrink_target.written_indices.contains(&i) {
+                duplicates
+                    .entry((*u, *v))
+                    .or_insert_with(|| Vec::new())
+                    .push(i);
+            }
+        }
+
+        let mut result: Vec<Vec<usize>> = duplicates
+            .drain()
+            .filter_map(|(_, elements)| {
+                if elements.len() > 1 {
+                    Some(elements)
+                } else {
+                    None
+                }
+            })
+            .collect();
+        result.sort_by_key(|v| Reverse(v.len()));
+        result
+    }
+
+    fn minimize_duplicated_blocks(&mut self) -> StepResult {
+        let mut i = 0;
+        let mut targets = self.calc_duplicates();
+        while i < targets.len() {
+            let target = mem::replace(&mut targets[i], Vec::new());
+            i += 1;
+            assert!(target.len() > 0);
+            let v = self.shrink_target.record[target[0]];
+            let base = self.shrink_target.record.clone();
+
+            let w = minimize_integer(v, |t| {
+                let mut attempt = base.clone();
+                for i in &target {
+                    attempt[*i] = t
+                }
+                self.incorporate(&attempt)
+            })?;
+            if w != v {
+                targets = self.calc_duplicates();
+            }
+        }
+        Ok(())
+    }
+
     fn execute(&mut self, buf: &DataStream) -> Result<(bool, TestResult), LoopExitReason> {
         // TODO: Later there will be caching here
         let result = self.main_loop.execute(DataSource::from_vec(buf.clone()))?;

data/src/intminimize.rs

@@ -0,0 +1,149 @@
+use std::cmp::min;
+
+const SMALL: u64 = 5;
+
+struct Minimizer<'a, F: 'a> {
+    criterion: &'a mut F,
+    best: u64,
+}
+
+impl<'a, F, T> Minimizer<'a, F>
+where
+    F: 'a + FnMut(u64) -> Result<bool, T>,
+{
+    fn test(&mut self, candidate: u64) -> Result<bool, T> {
+        if candidate == self.best {
+            return Ok(true);
+        }
+        if candidate > self.best {
+            return Ok(false);
+        }
+        let result = (self.criterion)(candidate)?;
+        if result {
+            self.best = candidate;
+        }
+        Ok(result)
+    }
+
+    fn modify<G>(&mut self, g: G) -> Result<bool, T>
+    where
+        G: Fn(u64) -> u64,
+    {
+        let x = g(self.best);
+        self.test(x)
+    }
+}
+
+pub fn minimize_integer<F, T>(start: u64, mut criterion: F) -> Result<u64, T>
+where
+    F: FnMut(u64) -> Result<bool, T>,
+{
+    if start == 0 {
+        return Ok(start);
+    }
+
+    for i in 0..min(start, SMALL) {
+        if criterion(i)? {
+            return Ok(i);
+        }
+    }
+    if start <= SMALL {
+        return Ok(start);
+    }
+
+    let mut minimizer = Minimizer {
+        best: start,
+        criterion: &mut criterion,
+    };
+
+    loop {
+        if !minimizer.modify(|x| x >> 1)? {
+            break;
+        }
+    }
+
+    for i in 0..64 {
+        minimizer.modify(|x| x ^ (1 << i))?;
+    }
+
+    assert!(minimizer.best >= SMALL);
+
+    for i in 0..64 {
+        let left_mask = 1 << i;
+        let mut right_mask = left_mask >> 1;
+        while right_mask != 0 {
+            minimizer.modify(|x| {
+                if x & left_mask == 0 || x & right_mask != 0 {
+                    x
+                } else {
+                    x ^ (right_mask | left_mask)
+                }
+            })?;
+            right_mask >>= 1;
+        }
+    }
+
+    if !minimizer.modify(|x| x - 1)? {
+        return Ok(minimizer.best);
+    }
+
+    let mut lo = 0;
+    let mut hi = minimizer.best;
+    while lo + 1 < hi {
+        let mid = lo + (hi - lo) / 2;
+        if minimizer.test(mid)? {
+            hi = mid;
+        } else {
+            lo = mid;
+        }
+    }
+
+    Ok(minimizer.best)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn non_failing_minimize<F>(start: u64, criterion: F) -> u64
+    where
+        F: Fn(u64) -> bool,
+    {
+        let mut best = start;
+
+        loop {
+            let ran: Result<u64, ()> = minimize_integer(best, |x| Ok(criterion(x)));
+            let result = ran.unwrap();
+            assert!(result <= best);
+            if result == best {
+                return best;
+            }
+            best = result;
+        }
+    }
+
+    #[test]
+    fn minimize_down_to() {
+        let n = non_failing_minimize(100, |x| x >= 10);
+        assert_eq!(n, 10);
+    }
+
+    #[test]
+    fn unset_relevant_bits() {
+        let x = 0b101010101010;
+        let y = 0b111111111111;
+        let n = non_failing_minimize(y, |k| k & x == x);
+        assert_eq!(n, x);
+    }
+
+    #[test]
+    fn sort_bits() {
+        let x: u64 = 0b1011011011000111;
+        let y: u64 = 0b0000001111111111;
+        let c = x.count_ones();
+        assert_eq!(c, y.count_ones());
+
+        let n = non_failing_minimize(x, |k| k.count_ones() == c);
+        assert_eq!(y, n);
+    }
+}

data/src/lib.rs

@@ -12,15 +12,16 @@ extern crate core;
 extern crate helix;
 extern crate rand;
 
-mod engine;
 mod data;
 mod distributions;
+mod engine;
+mod intminimize;
 
 use std::mem;
 
-use engine::Engine;
 use data::{DataSource, Status};
 use distributions::Repeat;
+use engine::Engine;
 
 ruby! {
   class HypothesisCoreDataSource {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hypothesis-specs
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - David R. Maciver
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-20 00:00:00.000000000 Z
+date: 2018-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: helix_runtime
@@ -70,6 +70,7 @@ files:
 - src/data.rs
 - src/distributions.rs
 - src/engine.rs
+- src/intminimize.rs
 - src/lib.rs
 homepage: http://github.com/HypothesisWorks/hypothesis-ruby
 licenses: