diceprop

A collection of mathematical properties for random testing.

It's based on dicetest.

Status of this crate

The author does not consider this crate as stable yet.

Examples

Associative binary operation

```rust use diceprop::{infixfun2, props, FateVarExt}; use dicetest::prelude::*;

[test]

fn addisassociativeforsmallf32() { Dicetest::repeatedly().run(|mut fate| { let smallf32die = dice::f32(-100.0..=100.0); let var = fate.rollvar3("f32 ∩ [-100,100]", ["x", "y", "z"], smallf32die); let add = infixfun_2("+", |x, y| x + y); props::binop::associative(var, add); }) } ```

The test fails with the following output:

``` The test failed after 22 passes.

Config

• seed: 9463254571221690676
• start limit: 0
• end limit: 100
• passes: 200

Counterexample

• run code: "+AmE1tbVveYGYlIjaeh8pudhxZe2x8PIexq8M9U/Xn4LAAAAAAAAAA=="
• limit: 11
• hints: - Is + associative? - x, y, z of f32 ∩ [-100,100] - x = 344.4662 - y = 503.5587 - z = 0.70710677 - (x + y) = 848.0249 - ((x + y) + z) = 848.732 - (y + z) = 504.26578 - (x + (y + z)) = 848.73193 - (((x + y) + z) == (x + (y + z))) = false
• error: assertion failed: (((x + y) + z) == (x + (y + z))) ```

Left inverse function

```rust use diceprop::{fun1, postfixfun_1, props, FateVarExt}; use dicetest::prelude::*;

[test]

fn sqrtisleftinverseofsqfornonnegativef32() { Dicetest::repeatedly().run(|mut fate| { let nonnegativef32die = dice::f32(0.0..); let var = fate.rollvar1("f32 ∩ [0,+∞]", "x", nonnegativef32die); let sq = postfixfun1("²", |x| x * x); let sqrt = fun1("√", |x: f32| x.sqrt()); props::fun::left_inverse(var, sq, sqrt); }) } ```

The test fails with the following output:

``` The test failed after 0 passes.

Config

• seed: 7632522237817347676
• start limit: 0
• end limit: 100
• passes: 200

Counterexample

• run code: "F2/nnlbX6qyCOm5MU7P8BSXdnJ4XNXJdihgwhtWxlzMAAAAAAAAAAA=="
• limit: 0
• hints: - Is √ left inverse of ²? - x of f32 ∩ [0,+∞] - x = 305770290000000000000000000000000000000.0 - (x)² = inf - √((x)²) = inf - (√((x)²) == x) = false
• error: assertion failed: (√((x)²) == x) ```

Partial order

```rust use diceprop::{infixfun2, props, FateVarExt}; use dicetest::prelude::*;

[test]

fn gtispartialorderforanyf32() { Dicetest::repeatedly().run(|mut fate| { let anyf32die = dice::anyf32(); let var = fate.rollvar3("f32", ["x", "y", "z"], anyf32die); let gt = infixfun2("≤", |x, y| x <= y); props::binrel::partialorder(var, gt); }) } ```

The test fails with the following output:

``` The test failed after 3 passes.

Config

• seed: 18374838706510982620
• start limit: 0
• end limit: 100
• passes: 200

Counterexample

• run code: "h6jQMNr6fi/j9OZOXmklXYAUATM96EpE6+DENMhSZHkBAAAAAAAAAA=="
• limit: 1
• hints: - Is ≤ a partial order? - Is ≤ reflexive? - x of f32 - x = NaN - (x ≤ x) = false
• error: assertion failed: (x ≤ x) ```

License

Licensed under either of

• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.