Paho Blog

Specializing tests

Tue, 11 Apr 2017 00:00:00 +0000

I recently published a new version of dimensioned, a Rust library for compile-time dimensional analysis. In so doing, I found a neat little pattern coupling specialization with test generation.

The Problem

Among other things, dimensioned defines various unit systems, and many constants in each unit system. All of this is performed by a build script that creates documentation at the same time. For example, from this code, this documentation is created.

In addition to generating documentation, we would like to generate some tests. One such test is to compare constants across unit systems. If the same constant is defined in two unit systems, then we should ensure that, when converted, they have the same value. This ensures both that the conversion does what it should and that we haven’t made a typo when defining one of the constants.

Given unit systems a and b, it should be as easy as

assert_ulps_eq!(a::CONST, b::CONST.into(),
                epsilon = a::A::new(0.0),
                max_ulps = 2);

Note: Due to the non-associativity of floating point math, we can’t use assert_eq!. Instead, we verify that the constants are within 2 ULPS using the approx crate.

Unfortunately, this fails. We can’t always convert from a to b. Or, sometimes we can convert from a to b, but we can’t go from b to a. For example, we can convert from SI to the centimeter-gram-second (CGS) system, but only from a subset of SI. We can’t convert a candela to CGS; there’s no unit to represent it. In addition, it makes no sense to convert from CGS to SI, as CGS represents electricity and magnitism units in terms of centimeters, grams, and seconds, so such a conversion would be ambiguous.

What this means is From isn’t implemented for all possible constants from all possible constants, so we’ll get unimplemented errors for some of those into() calls.

We could set up either a whitelist or blacklist of what constants to compare, but that would be a pain and a maintainibility nightmare. Fortunately, there’s a better way.

The Solution

First, let’s make a trait for performing these comparisons:

pub trait CmpConsts<B> {
    fn test_eq(self, b: B);
}

Then, let’s implement it for when we can perform the conversion:

impl<A, B> CmpConsts<B> for A where
    A: From<B> +
       fmt::Debug +
       Dimensioned<Value=f64> +
       ApproxEq<Epsilon=Self>
{
    fn test_eq(self, b: B) {
        assert_ulps_eq!(self, b.into(), epsilon = A::new(0.0), max_ulps = 2);
    }
}

So, when we call a.test_eq(b), we perform the same test as before, with the same problems. So far we have done nothing but added a useless layer of abstraction. Yay us!

However, with a default impl, it suddenly becomes useful:

impl<A, B> CmpConsts<B> for A {
    default fn test_eq(self, _: B) {
    }
}

Now, CmpConsts is implemented for any two types A and B. If we can convert from B to A, then we perform the test. If not, then we do nothing and move on. No more compiler errors, and we can generate all the comparison tests we want!

Feel free to discuss this on reddit.

Dimensioned 0.6.0

Fri, 03 Mar 2017 00:00:00 +0000

Dimensioned, the Rust library that I have written for compile-time dimensional analysis, has just reached version 0.6.0! This version change indicates a full rewrite of the library, and I think that it has made it much more usable.

I first started this crate before Rust had hit 1.0, and I fairly quickly realized that what I wanted was not possible. With the advent of associated types, it became possible, and two years ago I first announced its existence. It was really a proof of concept at that point; it was lacking in ergonomics and some pretty important features.

Today, I am excited to report that I believe it is more than a proof of concept, and is ready to be used.

Here are some notable changes:

No longer do we need a nightly compiler! Dimensioned now works fine on Rust stable, so long as it is at least version 1.15.
Before, units were expressed by parametrizing a Dim struct. That struct is gone, which brings a couple benefits. The first is ergonomics; a meter was expressed as Dim<Meter, V> in past verions, and now it is Meter<V>. The second benefit is in Rust’s orphan rules; if you create a unit system, you now create the outermost struct, and so have full control over what you can implement for it.
We no longer depend on std! Use dimensioned wherever you desire!
Thanks to type macros, derived units can now be defined without a build script or the extremely clunky syntax that was necessary before.
Unit systems! We have added unit systems and definitions for many derived units and constants. They are still incomplete, though, and an area where dimensioned should improve on soon.

If you have some time, check out the documentation, or the readme. I have tried to make these documents as clear and comprehensive as possible, but I am sure that I have failed in at least some ways.

Please feel free to submit an issue on GitHub or leave a comment on reddit or on the Rust user’s forum.

Hello, Internet

Sun, 15 Feb 2015 00:00:00 +0000

Hello, I am Paho and this is my blog.

I don’t have much to say here right now, so I’ll just leave you with a quotation:

On two occasions I have been asked, “Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out?” … I am not able rightly to apprehend the kind of confusion of ideas that could provoke such a question.

- Charles Babbage