Right now, an area {minimumX=0, maximumX=10, minimumY=0, maximumY=10} is considered to overlap an area {minimumX=10, maximumX=20, minimumY=10, maximumY=20}. This is incorrect! maximumX and maximumY are exclusive upper bounds.

An area of an area size can be constructed by assuming that the area size is an area at the origin.

See #12

The problem is the same!

size :: ∀S. PAreaL<S> → PAreaSizeL<S>

size :: AreaL → AreaSizeL

.. etc.

This is a serious issue:

  @Test
  public void testBugOverlapsL()
  {
    final AreaL area0 =
      AreaL.of(0L, 10L, 0L, 10L);
    final AreaL area1 =
      AreasL.create(0L, 0L, 0L, 0L);
    Assert.assertTrue(AreasL.overlaps(area1, area0));
  }

... fails!

relax :: ∀S. PAreaL<S> → AreaL

strengthen :: ∀S. AreaL → PAreaL<S>

...etc.

The clamp function ensures that the minimums and maximums of a region are always less than and greater than those of another region.

We're using jqwik in projects now, instead of the unmaintained Java quickcheck.

Convert the generators to jqwik arbitraries.

This is likely just an issue of numerical imprecision in the tests. The algorithm is correct.

This is wanted by jspatial.

io7m-com/jspatial#5

This ascribes meaning to axes that programmers using jregions may not be using.

width -> sizeX
height -> sizeY
depth -> sizeZ

Removes any possibility of ambiguity.

APIs such as jcanephora need to be able to work with area types regardless of whether the concrete implementation is a PArea or plain Area. In other words, right now an API such as jcanephora will end up forcing the user to use either PAreas or Areas even though the types are functionally identical.

They were left out of the previous releases.

The package currently defines 2D areas.

This could easily be generalized to 3D volumes.

io7m-com/jspatial#5

Depends on io7m-com/primogenitor#10

Most of the unit tests are generated anyway, so it's just a matter of using the newer annotations and the Assertions class.

We currently have:

  /**
   * Move the given area by {@code (x, y)}.
   *
   * @param area The area
   * @param x    The amount to move on the X axis
   * @param y    The amount to move on the Y axis
   * @param <S>  The coordinate space of the area
   *
   * @return A moved area
   */

  public static <S> PAreaD<S> moveRelative(
    final PAreaD<S> area,
    final double x,
    final double y)
  {

I'd like a:

  /**
   * Move the given area by {@code (x, y)}, without allowing {@code area} to leave {@code container}.
   *
   * @param area The area
   * @param container The container area
   * @param x    The amount to move on the X axis
   * @param y    The amount to move on the Y axis
   * @param <S>  The coordinate space of the area
   *
   * @return A moved area
   */

  public static <S> PAreaD<S> moveRelativeClamped(
    final PAreaD<S> area,
    final PAreaD<S> container,
    final double x,
    final double y)
  {

If container doesn't contain area, the function throws PreconditionViolationException. The function
maintains the invariants:

• ∀ a b x y. contains(b, a) = contains(b, moveRelativeClamped(a, b, x, y)).
• ∀ a b x y. size(a) = size(moveRelativeClamped(a, b, x, y)).

Areas should also extend AreaSizeValues*Type.