This release is small, but adds one tiny method to BitConversion so it can be emulated on GWT, adds constants for the vertices and faces of the five Platonic solids in 3D, and adds some more "filling methods" to ArrayTools. The new BitConversion method is int imul(int, int), which acts exactly like int multiplication on non-GWT platforms. But, GWT defaults to behaving strangely when both ints are fairly large -- where on desktop, 0x7fffffff * 0x7fffffff overflows and returns 1, on GWT it vastly exceeds the normal limits for an int and returns 4611686014132420600. The new BitConversion.imul() method calls the JS method Math.imul(), and so it acts like that does and like desktop Java does, overflowing and returning 1 in the aforementioned case. The constants for the Platonic solids, like the icosahedron and cube, are in ShapeTools; there's double and float variants, and versions with an edge length of 1 as well as versions that are inscribed in a unit sphere. The filling methods in ArrayTools allow you to get various placeholder Strings (useful for testing), in arrays or random-accessed. You can access Greek letter names, names of demons from the Ars Goetia, and the names of 118 chemical elements, either all at once or in individual sets. Many of these Strings were used already to seed the 428 Hasher instances in Hasher.predefined, and there are more than twice as many Hashers as there were.

This release breaks some backwards compatibility in order to fix compatibility (and avoid parser bugs) in related libraries. Changes are mostly limited to Base:

• Base86 had its digits change because some were invalid in the String serialization juniper uses.
• Scrambled bases also can use different digits, because some were invalid sometimes.
• Writing an unsigned float or double prefixes with . now (they are still read by readDouble()).
• Writing a signed float or double is often much shorter, doesn't have a prefix, and uses a reversed byte order (it is read the same way).

There are some added APIs:

• BitConversion.doubleToReversedLongBits() and BitConversion.reversedLongBitsToDouble() are just like their float-int counterparts, but for double-long conversions.
• AlternateRandom is here for code that doesn't use juniper but does use ArrayTools.shuffle() a lot. It uses the same algorithm as PasarRandom, which should be in juniper 0.1.5 soon, but doesn't have as many added features.
• MathTools.boundedInt() and MathTools.boundedLong() allow taking a typically-random number and getting a typically-smaller, bounded random number from it with some guarantee of somewhat random results for random inputs.

Even though this is a point release, it should probably be 0.2.0 because it changes some behavior. Whoops. The behavior was broken, so a fix was required.

This release almost entirely affects TrigTools. The lookup table it uses for sin() and cos() is now more precise, and for the times when a LUT isn't appropriate (such as when cache isn't readily available, or the limited possible return values are a noticeable issue), there are now sinSmooth() and cosSmooth() versions of sin() and cos() that don't use a table. These also have float and double versions, as well as versions that use radians, degrees, and turns. Big thanks to 7th-century astronomer Bhaskara I for the basis for the smooth function, and WimC from Stack Exchange for improving on it.

This release only changes the TrigTools.tan() methods and related versions in turns and degrees. The earlier version used an optimization on sin()/cos(), but even small errors in the sine table became grossly magnified in the tan() results. This was starkly noticeable in a demo for juniper's random number distributions, where the Cauchy distribution (which uses tan() in its calculation) went from looking like this with the old tan(), to looking like this with the new tan(). The measured absolute, relative, and maximum error values are all better with the current tan(), though it isn't as fast on Java 8 (still an improvement over Math.tan() in speed). Like the old tan(), the error gets significantly worse as the correct result gets larger, but not as badly as before.

This release is very small; it adds a quick way to calculate the nth Fibonacci number and a more-precise way to calculate the nth root of a float. The MathTools.fibonacci() method takes an int or long and returns that type; it uses something close to Binet's algorithm. However, it has been subtly adjusted to counteract floating-point error, so it can return correct results for inputs up to and including 77 instead of 71 (which is what it would manage without adjustment). The MathTools.nthrt() method gets raises the first input to the reciprocal of the second input, just as you would normally do for something that gets the nth root. It then goes beyond that to correct results that are within a tolerance of an integer, returning the close-by int value rather than a potentially-slightly-off float value.

That's all there is here! Mostly I wanted to keep digital up-to-date as I update related libraries.

This release has much more support for shuffling 1D arrays, 2D arrays, and sections of 1D arrays in the ArrayTools class. In MathTools, there's lots more commonly-defined constants for things like the square roots of 2, 3, and 5, almost all contributed by @jmcwilliams403 (thanks!). That's about it! The shuffling should make some code in other libraries a little simpler.

This release mostly adds double variants on... well, almost all methods that were previously float-only. It also improves some behavior in ArrayTools (avoiding unexpected copying in some places), and adds ArrayTools.set() and ArrayTools.fill3D, plus generic methods that can alter 2D and 3D Object arrays in some cases. In MathTools, most versions of floor() and ceil() gave incorrect results for negative integers; this has been fixed. The variants on floor() that have a smaller valid domain are now uniformly called fastFloor(); there's also fastCeil().

So, in general, a nicely-sized set of fixes and additions.

This release improves the 2D hashing support in Hasher and rounds out the methods copied or slightly-changed from libGDX's MathUtils to our MathTools. The docs are also improved for the precision of methods in TrigTools. It doesn't do much else new!

This is the first release of digital on GitHub, though 0.0.1 was released to Maven Central. Relative to 0.0.1, this is mostly a bugfix release and provides only a few new features. If you're just looking at this for the first time, though, it has a fair amount of features for its low number. Base should be useful for zero-dependency parsing of numbers in almost-arbitrary base systems, including some Java-8-compatible methods with near-equivalents that only were added to the JDK in later versions. TrigTools has trigonometry methods in radians, degrees, and (my preference) turns, including inverse trigonometric methods like asin() and atan2(); it also has a lookup table for sin()/cos() that is publicly available. MathTools has a grab bag of methods, many from libGDX. It goes on for a bit; anyway, I hope this is useful!