# crush depth

jtensors implementation

The jtensors implementation is basically done. I need to release the `1.0.0` version of the primogenitor, though, and I can't do this until the `0.10.0` version of japicmp is released.

I like this sort of pure code because it allows for property-based testing ala QuickCheck. The general idea is to specify mathematical properties of the code abstractly and then check to see if those properties hold concretely for a large set of randomly selected inputs. In the absense of tools to formally prove properties about code, this kind of property-based testing is useful for checking the likelihood that the code is correct. For example, the test suite now has methods such as:

```/**
*/

@Test
@PercentagePassing
{
final Generator<Vector4D> gen = createGenerator();

final Vector4D v0 = gen.next();
final Vector4D v1 = gen.next();

final Vector4D vr0 = Vectors4D.add(v0, v1);
final Vector4D vr1 = Vectors4D.add(v1, v0);

checkAlmostEquals(vr0.x(), vr1.x());
checkAlmostEquals(vr0.y(), vr1.y());
checkAlmostEquals(vr0.z(), vr1.z());
checkAlmostEquals(vr0.w(), vr1.w());
}
```

Of course, in Haskell this would be somewhat less verbose:

```quickCheck (\(v0, v1) -> almostEquals (add v0 v1) (add v1 v0))
```

The `@PercentagePassing` annotation marks the test as being executed `2000` times (by default) with at least `95%` (by default) of the executions being required to pass in order for the test to pass as a whole. The reason that the percentage isn't `100%` is due to numerical imprecision: The nature of floating point numbers means that it's really only practical to try to determine if two numbers are equal to each other within an acceptable margin of error. Small (acceptable) errors can creep in during intermediate calculations such that if the two results were to be compared for exact equality, the tests would almost always fail. Sometimes, the errors are large enough that although the results are "correct", they fall outside of the acceptable range of error for the almost equals check to succeed.

There's a classic (and pretty mathematically intense) paper on this called "What Every Computer Scientist Should Know About Floating-Point Arithmetic". This was given an extensive treatment by Bruce Dawson and his explanations formed the basis for my jequality package. I actually tried to use junit's built-in floating point comparison assertions for the test suite at first, but they turned out to be way too unreliable.

Update: Without even an hour having passed since this post was published, japicmp 0.10.0 has been released!