Package com.io7m.jregions.core.parameterized.areas

# Class PAreasBI

java.lang.Object
com.io7m.jregions.core.parameterized.areas.PAreasBI

public final class PAreasBI extends Object

Functions over areas.

These functions operate using the concepts of minimum-x, maximum-x, minimum-y, and maximum-y edges. It is up to individual applications to assign meaning to these edges such as "left" for minimum-x and "top" for minimum-y.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static <S> PAreaBI<S>`
  `alignCenter(PAreaBI<S> outer, PAreaBI<S> inner)`
  Align the area `inner` such that the center of the area is equal to the center of `outer`.
  `static <S> PAreaBI<S>`
  `alignHorizontallyCenter(PAreaBI<S> outer, PAreaBI<S> inner)`
  Deprecated.
  Use `alignOnXCenter(PAreaBI, PAreaBI)`
  `static <S> PAreaBI<S>`
  `alignHorizontallyMaxX(PAreaBI<S> outer, PAreaBI<S> inner)`
  Deprecated.
  Use `alignOnXMaxX(PAreaBI, PAreaBI)`
  `static <S> PAreaBI<S>`
  `alignHorizontallyMaxXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)`
  Deprecated.
  Use `alignOnXMaxXOffset(PAreaBI, PAreaBI, java.math.BigInteger)`
  `static <S> PAreaBI<S>`
  `alignHorizontallyMinX(PAreaBI<S> outer, PAreaBI<S> inner)`
  Deprecated.
  Use `alignOnXMinX(PAreaBI, PAreaBI)`
  `static <S> PAreaBI<S>`
  `alignHorizontallyMinXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)`
  Deprecated.
  Use `alignOnXMinXOffset(PAreaBI, PAreaBI, java.math.BigInteger)`
  `static <S> PAreaBI<S>`
  `alignMaxYMaxX(PAreaBI<S> outer, PAreaBI<S> inner)`
  Equivalent to calling `alignMaxYMaxXOffset(PAreaBI, PAreaBI, java.math.BigInteger, java.math.BigInteger)` with zero offsets.
  `static <S> PAreaBI<S>`
  `alignMaxYMaxXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset_x, BigInteger offset_y)`
  Align the area `inner` such that the maximum-y edge is at least `offset_y` from the inside maximum-y edge of `outer` and the maximum-x edge is at least `offset_x` from the inside maximum-x edge of `outer`.
  `static <S> PAreaBI<S>`
  `alignMaxYMinX(PAreaBI<S> outer, PAreaBI<S> inner)`
  Equivalent to calling `alignMaxYMinXOffset(PAreaBI, PAreaBI, java.math.BigInteger, java.math.BigInteger)` with zero offsets.
  `static <S> PAreaBI<S>`
  `alignMaxYMinXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset_x, BigInteger offset_y)`
  Align the area `inner` such that the maximum-y edge is at least `offset_y` from the inside maximum-y edge of `outer` and the minimum-x edge is at least `offset_x` from the inside minimum-x edge of `outer`.
  `static <S> PAreaBI<S>`
  `alignMinYMaxX(PAreaBI<S> outer, PAreaBI<S> inner)`
  Equivalent to calling `alignMinYMaxXOffset(PAreaBI, PAreaBI, java.math.BigInteger, java.math.BigInteger)` with zero offsets.
  `static <S> PAreaBI<S>`
  `alignMinYMaxXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset_x, BigInteger offset_y)`
  Align the area `inner` such that the minimum-y edge is at least `offset_y` from the inside minimum-y edge of `outer` and the maximum-x edge is at least `offset_x` from the inside maximum-x edge of `outer`.
  `static <S> PAreaBI<S>`
  `alignMinYMinX(PAreaBI<S> outer, PAreaBI<S> inner)`
  Equivalent to calling `alignMinYMinXOffset(PAreaBI, PAreaBI, java.math.BigInteger, java.math.BigInteger)` with zero offsets.
  `static <S> PAreaBI<S>`
  `alignMinYMinXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset_x, BigInteger offset_y)`
  Align the area `inner` such that the minimum-y edge is at least `offset_y` from the inside minimum-y edge of `outer` and the minimum-x edge is at least `offset_x` from the inside minimum-x edge of `outer`.
  `static <S> PAreaBI<S>`
  `alignOnXCenter(PAreaBI<S> outer, PAreaBI<S> inner)`
  Align the area `inner` along the X axis in the center of `outer`.
  `static <S> PAreaBI<S>`
  `alignOnXMaxX(PAreaBI<S> outer, PAreaBI<S> inner)`
  Equivalent to calling `alignOnXMaxXOffset(PAreaBI, PAreaBI, java.math.BigInteger)` with a zero offset.
  `static <S> PAreaBI<S>`
  `alignOnXMaxXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)`
  Align the area `inner` along the X axis against the inside maximum-x edge of `outer`.
  `static <S> PAreaBI<S>`
  `alignOnXMinX(PAreaBI<S> outer, PAreaBI<S> inner)`
  Equivalent to calling `alignOnXMinXOffset(PAreaBI, PAreaBI, java.math.BigInteger)` with a zero offset.
  `static <S> PAreaBI<S>`
  `alignOnXMinXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)`
  Align the area `inner` along the X axis against the inside minimum-x edge of `outer`.
  `static <S> PAreaBI<S>`
  `alignOnYCenter(PAreaBI<S> outer, PAreaBI<S> inner)`
  Align the area `inner` along the Y axis in the center of `outer`.
  `static <S> PAreaBI<S>`
  `alignOnYMaxY(PAreaBI<S> outer, PAreaBI<S> inner)`
  Equivalent to calling `alignOnYMaxYOffset(PAreaBI, PAreaBI, java.math.BigInteger)` with a zero offset.
  `static <S> PAreaBI<S>`
  `alignOnYMaxYOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)`
  Align the area `inner` along the Y axis against the inside maximum-y edge of `outer`.
  `static <S> PAreaBI<S>`
  `alignOnYMinY(PAreaBI<S> outer, PAreaBI<S> inner)`
  Equivalent to calling `alignOnYMinYOffset(PAreaBI, PAreaBI, java.math.BigInteger)` with a zero offset.
  `static <S> PAreaBI<S>`
  `alignOnYMinYOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)`
  Align the area `inner` along the Y axis against the inside minimum-y edge of `outer`.
  `static <S> PAreaBI<S>`
  `alignVerticallyCenter(PAreaBI<S> outer, PAreaBI<S> inner)`
  Deprecated.
  Use `alignOnYCenter(PAreaBI, PAreaBI)`
  `static <S> PAreaBI<S>`
  `alignVerticallyMaxY(PAreaBI<S> outer, PAreaBI<S> inner)`
  Deprecated.
  Use `alignOnYMaxY(PAreaBI, PAreaBI)`
  `static <S> PAreaBI<S>`
  `alignVerticallyMaxYOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)`
  Deprecated.
  Use `alignOnYMaxYOffset(PAreaBI, PAreaBI, java.math.BigInteger)`
  `static <S> PAreaBI<S>`
  `alignVerticallyMinY(PAreaBI<S> outer, PAreaBI<S> inner)`
  Deprecated.
  Use `alignOnYMinY(PAreaBI, PAreaBI)`
  `static <S> PAreaBI<S>`
  `alignVerticallyMinYOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)`
  Deprecated.
  Use `alignOnYMinYOffset(PAreaBI, PAreaBI, java.math.BigInteger)`
  `static <S, T> PAreaBI<T>`
  `cast(PAreaBI<S> area)`
  Brand a given area as belonging to a different coordinate space.
  `static <S> PAreaBI<S>`
  `containing(PAreaBI<S> a, PAreaBI<S> b)`
  Construct a area that will contain both `a` and `b`.
  `static <S> boolean`
  `contains(PAreaBI<S> a, PAreaBI<S> b)`
  Determine whether or not one area contains another.
  `static <S> boolean`
  `containsPoint(PAreaBI<S> a, BigInteger x, BigInteger y)`
  Determine whether or not a area contains a given point.
  `static <S> boolean`
  `couldFitInside(PAreaBI<S> a, PAreaBI<S> b)`
  Determine whether or not one area could fit inside another.
  `static <S> PAreaBI<S>`
  `create(BigInteger x, BigInteger y, BigInteger size_x, BigInteger size_y)`
  Create an area of size `size_x` on the X axis and size `size_y` on the Y axis, placing the minimum corner at `(x, y)`.
  `static <S> PAreaBI<S>`
  `fitBetweenHorizontal(PAreaBI<S> fit, PAreaBI<S> a, PAreaBI<S> b)`
  Deprecated.
  Use `fitBetweenOnX(PAreaBI, PAreaBI, PAreaBI)`
  `static <S> PAreaBI<S>`
  `fitBetweenOnX(PAreaBI<S> fit, PAreaBI<S> a, PAreaBI<S> b)`
  Attempt to fit `fit` between `a` and `b`, horizontally.
  `static <S> PAreaBI<S>`
  `fitBetweenOnY(PAreaBI<S> fit, PAreaBI<S> a, PAreaBI<S> b)`
  Attempt to fit `fit` between `a` and `b`, vertically.
  `static <S> PAreaBI<S>`
  `fitBetweenVertical(PAreaBI<S> fit, PAreaBI<S> a, PAreaBI<S> b)`
  Deprecated.
  Use `fitBetweenOnY(PAreaBI, PAreaBI, PAreaBI)`
  `static <S> PAreaBI<S>`
  `hollowOut(PAreaBI<S> outer, BigInteger min_x_offset, BigInteger max_x_offset, BigInteger min_y_offset, BigInteger max_y_offset)`
  Construct a new area that fits inside `outer` based on the given offsets from each edge.
  `static <S> PAreaBI<S>`
  `hollowOutEvenly(PAreaBI<S> outer, BigInteger offset)`
  Equivalent to calling `hollowOut(PAreaBI, java.math.BigInteger, java.math.BigInteger, java.math.BigInteger, java.math.BigInteger)` with `offset` for all offset parameters.
  `static <S> PAreaBI<S>`
  `moveAbsolute(PAreaBI<S> area, BigInteger x, BigInteger y)`
  Move the given area to `(x, y)`.
  `static <S> PAreaBI<S>`
  `moveRelative(PAreaBI<S> area, BigInteger x, BigInteger y)`
  Move the given area by `(x, y)`.
  `static <S> PAreaBI<S>`
  `moveRelativeClamped(PAreaBI<S> container, PAreaBI<S> area, BigInteger x, BigInteger y)`
  Move the given area by `(x, y)`, without allowing `area` to leave `container`.
  `static <S> PAreaBI<S>`
  `moveRelativeClampedX(PAreaBI<S> container, PAreaBI<S> area, BigInteger x)`
  Move the given area by `x`, without allowing `area` to leave `container`.
  `static <S> PAreaBI<S>`
  `moveRelativeClampedY(PAreaBI<S> container, PAreaBI<S> area, BigInteger y)`
  Move the given area by `y`, without allowing `area` to leave `container`.
  `static <S> PAreaBI<S>`
  `moveToOrigin(PAreaBI<S> area)`
  Move the given area to `(0, 0)`.
  `static <S> boolean`
  `overlaps(PAreaBI<S> a, PAreaBI<S> b)`
  Determine whether or not two areas overlap.
  `static <S> PAreaBI<S>`
  `scaleFromCenter(PAreaBI<S> area, BigInteger x_diff, BigInteger y_diff)`
  Scale `area` by adding `x_diff` to the sizeX, and `y_diff` to the sizeY.
  `static <S> PAreaBI<S>`
  `scaleFromMaxYMaxX(PAreaBI<S> area, BigInteger x_diff, BigInteger y_diff)`
  Scale `area` by adding `x_diff` to the sizeX, and `y_diff` to the sizeY.
  `static <S> PAreaBI<S>`
  `scaleFromMaxYMinX(PAreaBI<S> area, BigInteger x_diff, BigInteger y_diff)`
  Scale `area` by adding `x_diff` to the sizeX, and `y_diff` to the sizeY.
  `static <S> PAreaBI<S>`
  `scaleFromMinYMaxX(PAreaBI<S> area, BigInteger x_diff, BigInteger y_diff)`
  Scale `area` by adding `x_diff` to the sizeX, and `y_diff` to the sizeY.
  `static <S> PAreaBI<S>`
  `scaleFromMinYMinX(PAreaBI<S> area, BigInteger x_diff, BigInteger y_diff)`
  Scale `area` by adding `x_diff` to the sizeX, and `y_diff` to the sizeY.
  `static <S> PAreaBI<S>`
  `setSizeFromCenter(PAreaBI<S> area, BigInteger sizeX, BigInteger sizeY)`
  Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.
  `static <S> PAreaBI<S>`
  `setSizeFromMaxYMaxX(PAreaBI<S> area, BigInteger sizeX, BigInteger sizeY)`
  Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.
  `static <S> PAreaBI<S>`
  `setSizeFromMaxYMinX(PAreaBI<S> area, BigInteger sizeX, BigInteger sizeY)`
  Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.
  `static <S> PAreaBI<S>`
  `setSizeFromMinYMaxX(PAreaBI<S> area, BigInteger sizeX, BigInteger sizeY)`
  Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.
  `static <S> PAreaBI<S>`
  `setSizeFromMinYMinX(PAreaBI<S> area, BigInteger sizeX, BigInteger sizeY)`
  Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.
  `static <S> String`
  `show(PAreaBI<S> area)`
  `static <S> String`
  `showToBuilder(PAreaBI<S> area, StringBuilder sb)`
  `static <S> PAreaSizeBI<S>`
  `size(PAreaBI<S> area)`
  `static <S> PAreaXSplitBI<S,PAreaBI<S>>`
  `splitAlongParallelToX(PAreaBI<S> area, BigInteger y)`
  Split `area` along a line parallel to the X axis placed at `y` units from its own minimum-y edge.
  `static <S> PAreaYSplitBI<S,PAreaBI<S>>`
  `splitAlongParallelToY(PAreaBI<S> area, BigInteger x)`
  Split `area` along a line parallel to the Y axis placed at `x` units from its own minimum-x edge.
  `static <S> PAreaXYSplitBI<S,PAreaBI<S>>`
  `splitAlongXY(PAreaBI<S> area, BigInteger x, BigInteger y)`
  Split `area` along a two axis-aligned perpendicular lines that intercept at `(x, y)`.

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Method Details

  - ### create

    public static <S> PAreaBI<S> create(BigInteger x, BigInteger y, BigInteger size_x, BigInteger size_y)
    Create an area of size `size_x` on the X axis and size `size_y` on the Y axis, placing the minimum corner at `(x, y)`.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `x` - The X value of the minimum corner
      `y` - The Y value of the minimum corner
      `size_x` - The size of the area on the X axis
      `size_y` - The size of the area on the Y axis
    Returns:
      An area

  - ### contains

    public static <S> boolean contains(PAreaBI<S> a, PAreaBI<S> b)

    Determine whether or not one area contains another.

    Containing is reflexive: `contains(a, a) == true`.

    Containing is transitive: `contains(a, b) → contains(b, c) → contains(a, c)`.

    Containing is not necessarily symmetric.

    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `a` - Area A
      `b` - Area B
    Returns:
      `true` iff `a` contains `b`

  - ### moveRelative

    public static <S> PAreaBI<S> moveRelative(PAreaBI<S> area, BigInteger x, BigInteger y)
    Move the given area by `(x, y)`.
    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
      `x` - The amount to move on the X axis
      `y` - The amount to move on the Y axis
    Returns:
      A moved area

  - ### moveRelativeClampedX

    public static <S> PAreaBI<S> moveRelativeClampedX(PAreaBI<S> container, PAreaBI<S> area, BigInteger x)
    Move the given area by `x`, without allowing `area` to leave `container`.
    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `container` - The container area
      `area` - The area
      `x` - The amount to move on the X axis
    Returns:
      A moved area
    Since:
      3.0.0

  - ### moveRelativeClampedY

    public static <S> PAreaBI<S> moveRelativeClampedY(PAreaBI<S> container, PAreaBI<S> area, BigInteger y)
    Move the given area by `y`, without allowing `area` to leave `container`.
    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `container` - The container area
      `area` - The area
      `y` - The amount to move on the Y axis
    Returns:
      A moved area
    Since:
      3.0.0

  - ### moveRelativeClamped

    public static <S> PAreaBI<S> moveRelativeClamped(PAreaBI<S> container, PAreaBI<S> area, BigInteger x, BigInteger y)
    Move the given area by `(x, y)`, without allowing `area` to leave `container`.
    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `container` - The container area
      `area` - The area
      `x` - The amount to move on the X axis
      `y` - The amount to move on the Y axis
    Returns:
      A moved area
    Since:
      3.0.0

  - ### moveAbsolute

    public static <S> PAreaBI<S> moveAbsolute(PAreaBI<S> area, BigInteger x, BigInteger y)
    Move the given area to `(x, y)`.
    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
      `x` - The position to which to move on the X axis
      `y` - The position to which to move on the Y axis
    Returns:
      A moved area

  - ### moveToOrigin

    public static <S> PAreaBI<S> moveToOrigin(PAreaBI<S> area)
    Move the given area to `(0, 0)`.
    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
    Returns:
      A moved area

  - ### cast

    public static <S, T> PAreaBI<T> cast(PAreaBI<S> area)
    Brand a given area as belonging to a different coordinate space. Mixing up coordinate spaces is a common source of difficult-to-locate bugs. Use at your own risk.
    Type Parameters:
      `S` - The starting coordinate space
      `T` - The resulting coordinate space
    Parameters:
      `area` - An area
    Returns:
      `area`

  - ### alignHorizontallyCenter

    @Deprecated public static <S> PAreaBI<S> alignHorizontallyCenter(PAreaBI<S> outer, PAreaBI<S> inner)
    Deprecated.
    Use `alignOnXCenter(PAreaBI, PAreaBI)`
    Align the area `inner` horizontally in the center of `outer`.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area

  - ### alignHorizontallyMinX

    @Deprecated public static <S> PAreaBI<S> alignHorizontallyMinX(PAreaBI<S> outer, PAreaBI<S> inner)
    Deprecated.
    Use `alignOnXMinX(PAreaBI, PAreaBI)`
    Equivalent to calling `alignHorizontallyMinXOffset(PAreaBI, PAreaBI, java.math.BigInteger)` with a zero offset.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area

  - ### alignHorizontallyMinXOffset

    @Deprecated public static <S> PAreaBI<S> alignHorizontallyMinXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)
    Deprecated.
    Use `alignOnXMinXOffset(PAreaBI, PAreaBI, java.math.BigInteger)`
    Align the area `inner` horizontally against the inside minimum-x edge of `outer`. The area will be at least `offset` units from the minimum-x edge.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
      `offset` - The offset from the edge
    Returns:
      An aligned area

  - ### alignHorizontallyMaxX

    @Deprecated public static <S> PAreaBI<S> alignHorizontallyMaxX(PAreaBI<S> outer, PAreaBI<S> inner)
    Deprecated.
    Use `alignOnXMaxX(PAreaBI, PAreaBI)`
    Equivalent to calling `alignHorizontallyMaxXOffset(PAreaBI, PAreaBI, java.math.BigInteger)` with a zero offset.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area

  - ### alignHorizontallyMaxXOffset

    @Deprecated public static <S> PAreaBI<S> alignHorizontallyMaxXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)
    Deprecated.
    Use `alignOnXMaxXOffset(PAreaBI, PAreaBI, java.math.BigInteger)`
    Align the area `inner` horizontally against the inside maximum-x edge of `outer`. The area will be at least `offset` units from the maximum-x edge.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
      `offset` - The offset from the edge
    Returns:
      An aligned area

  - ### alignVerticallyMinY

    @Deprecated public static <S> PAreaBI<S> alignVerticallyMinY(PAreaBI<S> outer, PAreaBI<S> inner)
    Deprecated.
    Use `alignOnYMinY(PAreaBI, PAreaBI)`
    Equivalent to calling `alignVerticallyMinYOffset(PAreaBI, PAreaBI, java.math.BigInteger)` with a zero offset.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area

  - ### alignVerticallyMinYOffset

    @Deprecated public static <S> PAreaBI<S> alignVerticallyMinYOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)
    Deprecated.
    Use `alignOnYMinYOffset(PAreaBI, PAreaBI, java.math.BigInteger)`
    Align the area `inner` vertically against the inside minimum-y edge of `outer`. The area will be at least `offset` units from the minimum-y edge.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
      `offset` - The offset from the edge
    Returns:
      An aligned area

  - ### alignVerticallyMaxY

    @Deprecated public static <S> PAreaBI<S> alignVerticallyMaxY(PAreaBI<S> outer, PAreaBI<S> inner)
    Deprecated.
    Use `alignOnYMaxY(PAreaBI, PAreaBI)`
    Equivalent to calling `alignVerticallyMaxYOffset(PAreaBI, PAreaBI, java.math.BigInteger)` with a zero offset.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area

  - ### alignVerticallyMaxYOffset

    @Deprecated public static <S> PAreaBI<S> alignVerticallyMaxYOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)
    Deprecated.
    Use `alignOnYMaxYOffset(PAreaBI, PAreaBI, java.math.BigInteger)`
    Align the area `inner` vertically against the inside maximum-y edge of `outer`. The area will be at least `offset` units from the maximum-y edge.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
      `offset` - The offset from the edge
    Returns:
      An aligned area

  - ### alignVerticallyCenter

    @Deprecated public static <S> PAreaBI<S> alignVerticallyCenter(PAreaBI<S> outer, PAreaBI<S> inner)
    Deprecated.
    Use `alignOnYCenter(PAreaBI, PAreaBI)`
    Align the area `inner` vertically in the center of `outer`.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area

  - ### alignOnXCenter

    public static <S> PAreaBI<S> alignOnXCenter(PAreaBI<S> outer, PAreaBI<S> inner)
    Align the area `inner` along the X axis in the center of `outer`.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area
    Since:
      1.1.0

  - ### alignOnXMinX

    public static <S> PAreaBI<S> alignOnXMinX(PAreaBI<S> outer, PAreaBI<S> inner)
    Equivalent to calling `alignOnXMinXOffset(PAreaBI, PAreaBI, java.math.BigInteger)` with a zero offset.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area
    Since:
      1.1.0

  - ### alignOnXMinXOffset

    public static <S> PAreaBI<S> alignOnXMinXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)
    Align the area `inner` along the X axis against the inside minimum-x edge of `outer`. The area will be at least `offset` units from the minimum-x edge.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
      `offset` - The offset from the edge
    Returns:
      An aligned area
    Since:
      1.1.0

  - ### alignOnXMaxX

    public static <S> PAreaBI<S> alignOnXMaxX(PAreaBI<S> outer, PAreaBI<S> inner)
    Equivalent to calling `alignOnXMaxXOffset(PAreaBI, PAreaBI, java.math.BigInteger)` with a zero offset.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area
    Since:
      1.1.0

  - ### alignOnXMaxXOffset

    public static <S> PAreaBI<S> alignOnXMaxXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)
    Align the area `inner` along the X axis against the inside maximum-x edge of `outer`. The area will be at least `offset` units from the maximum-x edge.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
      `offset` - The offset from the edge
    Returns:
      An aligned area
    Since:
      1.1.0

  - ### alignOnYMinY

    public static <S> PAreaBI<S> alignOnYMinY(PAreaBI<S> outer, PAreaBI<S> inner)
    Equivalent to calling `alignOnYMinYOffset(PAreaBI, PAreaBI, java.math.BigInteger)` with a zero offset.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area
    Since:
      1.1.0

  - ### alignOnYMinYOffset

    public static <S> PAreaBI<S> alignOnYMinYOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)
    Align the area `inner` along the Y axis against the inside minimum-y edge of `outer`. The area will be at least `offset` units from the minimum-y edge.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
      `offset` - The offset from the edge
    Returns:
      An aligned area
    Since:
      1.1.0

  - ### alignOnYMaxY

    public static <S> PAreaBI<S> alignOnYMaxY(PAreaBI<S> outer, PAreaBI<S> inner)
    Equivalent to calling `alignOnYMaxYOffset(PAreaBI, PAreaBI, java.math.BigInteger)` with a zero offset.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area
    Since:
      1.1.0

  - ### alignOnYMaxYOffset

    public static <S> PAreaBI<S> alignOnYMaxYOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset)
    Align the area `inner` along the Y axis against the inside maximum-y edge of `outer`. The area will be at least `offset` units from the maximum-y edge.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
      `offset` - The offset from the edge
    Returns:
      An aligned area
    Since:
      1.1.0

  - ### alignOnYCenter

    public static <S> PAreaBI<S> alignOnYCenter(PAreaBI<S> outer, PAreaBI<S> inner)
    Align the area `inner` along the Y axis in the center of `outer`.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area
    Since:
      1.1.0

  - ### alignMinYMinX

    public static <S> PAreaBI<S> alignMinYMinX(PAreaBI<S> outer, PAreaBI<S> inner)
    Equivalent to calling `alignMinYMinXOffset(PAreaBI, PAreaBI, java.math.BigInteger, java.math.BigInteger)` with zero offsets.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area

  - ### alignMinYMinXOffset

    public static <S> PAreaBI<S> alignMinYMinXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset_x, BigInteger offset_y)
    Align the area `inner` such that the minimum-y edge is at least `offset_y` from the inside minimum-y edge of `outer` and the minimum-x edge is at least `offset_x` from the inside minimum-x edge of `outer`.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
      `offset_x` - The offset from the minimum-x edge
      `offset_y` - The offset from the minimum-y edge
    Returns:
      An aligned area

  - ### alignMinYMaxX

    public static <S> PAreaBI<S> alignMinYMaxX(PAreaBI<S> outer, PAreaBI<S> inner)
    Equivalent to calling `alignMinYMaxXOffset(PAreaBI, PAreaBI, java.math.BigInteger, java.math.BigInteger)` with zero offsets.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area

  - ### alignMinYMaxXOffset

    public static <S> PAreaBI<S> alignMinYMaxXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset_x, BigInteger offset_y)
    Align the area `inner` such that the minimum-y edge is at least `offset_y` from the inside minimum-y edge of `outer` and the maximum-x edge is at least `offset_x` from the inside maximum-x edge of `outer`.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
      `offset_x` - The offset from the maximum-x edge
      `offset_y` - The offset from the minimum-y edge
    Returns:
      An aligned area

  - ### alignMaxYMinX

    public static <S> PAreaBI<S> alignMaxYMinX(PAreaBI<S> outer, PAreaBI<S> inner)
    Equivalent to calling `alignMaxYMinXOffset(PAreaBI, PAreaBI, java.math.BigInteger, java.math.BigInteger)` with zero offsets.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area

  - ### alignMaxYMinXOffset

    public static <S> PAreaBI<S> alignMaxYMinXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset_x, BigInteger offset_y)
    Align the area `inner` such that the maximum-y edge is at least `offset_y` from the inside maximum-y edge of `outer` and the minimum-x edge is at least `offset_x` from the inside minimum-x edge of `outer`.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
      `offset_x` - The offset from the minimum-x edge
      `offset_y` - The offset from the maximum-y edge
    Returns:
      An aligned area

  - ### alignMaxYMaxX

    public static <S> PAreaBI<S> alignMaxYMaxX(PAreaBI<S> outer, PAreaBI<S> inner)
    Equivalent to calling `alignMaxYMaxXOffset(PAreaBI, PAreaBI, java.math.BigInteger, java.math.BigInteger)` with zero offsets.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area

  - ### alignMaxYMaxXOffset

    public static <S> PAreaBI<S> alignMaxYMaxXOffset(PAreaBI<S> outer, PAreaBI<S> inner, BigInteger offset_x, BigInteger offset_y)
    Align the area `inner` such that the maximum-y edge is at least `offset_y` from the inside maximum-y edge of `outer` and the maximum-x edge is at least `offset_x` from the inside maximum-x edge of `outer`.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
      `offset_x` - The offset from the maximum-x edge
      `offset_y` - The offset from the maximum-y edge
    Returns:
      An aligned area

  - ### alignCenter

    public static <S> PAreaBI<S> alignCenter(PAreaBI<S> outer, PAreaBI<S> inner)
    Align the area `inner` such that the center of the area is equal to the center of `outer`.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The outer area
      `inner` - The inner area
    Returns:
      An aligned area

  - ### hollowOut

    public static <S> PAreaBI<S> hollowOut(PAreaBI<S> outer, BigInteger min_x_offset, BigInteger max_x_offset, BigInteger min_y_offset, BigInteger max_y_offset)
    Construct a new area that fits inside `outer` based on the given offsets from each edge.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The containing area
      `min_x_offset` - The offset from the minimum-x edge (must be non-negative)
      `max_x_offset` - The offset from the maximum-x edge (must be non-negative)
      `min_y_offset` - The offset from the minimum-y edge (must be non-negative)
      `max_y_offset` - The offset from the maximum-y edge (must be non-negative)
    Returns:
      A new area

  - ### hollowOutEvenly

    public static <S> PAreaBI<S> hollowOutEvenly(PAreaBI<S> outer, BigInteger offset)
    Equivalent to calling `hollowOut(PAreaBI, java.math.BigInteger, java.math.BigInteger, java.math.BigInteger, java.math.BigInteger)` with `offset` for all offset parameters.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `outer` - The containing area
      `offset` - The offset from each edge (must be non-negative)
    Returns:
      A new area

  - ### setSizeFromCenter

    public static <S> PAreaBI<S> setSizeFromCenter(PAreaBI<S> area, BigInteger sizeX, BigInteger sizeY)

    Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.

    The area is resized from its own center.

    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
      `sizeX` - The new sizeX (must be non-negative)
      `sizeY` - The new sizeY (must be non-negative)
    Returns:
      A resized area

  - ### setSizeFromMinYMinX

    public static <S> PAreaBI<S> setSizeFromMinYMinX(PAreaBI<S> area, BigInteger sizeX, BigInteger sizeY)

    Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.

    The area is resized by moving its minimum-y-minimum-x corner.

    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
      `sizeX` - The new sizeX (must be non-negative)
      `sizeY` - The new sizeY (must be non-negative)
    Returns:
      A resized area

  - ### setSizeFromMinYMaxX

    public static <S> PAreaBI<S> setSizeFromMinYMaxX(PAreaBI<S> area, BigInteger sizeX, BigInteger sizeY)

    Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.

    The area is resized by moving its minimum-y-maximum-x corner.

    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
      `sizeX` - The new sizeX (must be non-negative)
      `sizeY` - The new sizeY (must be non-negative)
    Returns:
      A resized area

  - ### setSizeFromMaxYMaxX

    public static <S> PAreaBI<S> setSizeFromMaxYMaxX(PAreaBI<S> area, BigInteger sizeX, BigInteger sizeY)

    Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.

    The area is resized by moving its maximum-y-maximum-x corner.

    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
      `sizeX` - The new sizeX (must be non-negative)
      `sizeY` - The new sizeY (must be non-negative)
    Returns:
      A resized area

  - ### setSizeFromMaxYMinX

    public static <S> PAreaBI<S> setSizeFromMaxYMinX(PAreaBI<S> area, BigInteger sizeX, BigInteger sizeY)

    Set the sizeX and sizeY of `area` to `sizeX` and `sizeY`, respectively.

    The area is resized by moving its maximum-y-minimum-x corner.

    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
      `sizeX` - The new sizeX (must be non-negative)
      `sizeY` - The new sizeY (must be non-negative)
    Returns:
      A resized area

  - ### scaleFromMinYMinX

    public static <S> PAreaBI<S> scaleFromMinYMinX(PAreaBI<S> area, BigInteger x_diff, BigInteger y_diff)

    Scale `area` by adding `x_diff` to the sizeX, and `y_diff` to the sizeY. The size of the resulting area is clamped so that its sizeX and sizeY are always non-negative.

    The area is resized by moving its minimum-y-minimum-x corner.

    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
      `x_diff` - The X difference
      `y_diff` - The Y difference
    Returns:
      A resized area

  - ### scaleFromMinYMaxX

    public static <S> PAreaBI<S> scaleFromMinYMaxX(PAreaBI<S> area, BigInteger x_diff, BigInteger y_diff)

    Scale `area` by adding `x_diff` to the sizeX, and `y_diff` to the sizeY. The size of the resulting area is clamped so that its sizeX and sizeY are always non-negative.

    The area is resized by moving its minimum-y-maximum-x corner.

    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
      `x_diff` - The X difference
      `y_diff` - The Y difference
    Returns:
      A resized area

  - ### scaleFromMaxYMinX

    public static <S> PAreaBI<S> scaleFromMaxYMinX(PAreaBI<S> area, BigInteger x_diff, BigInteger y_diff)

    Scale `area` by adding `x_diff` to the sizeX, and `y_diff` to the sizeY. The size of the resulting area is clamped so that its sizeX and sizeY are always non-negative.

    The area is resized by moving its maximum-y-minimum-x corner.

    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
      `x_diff` - The X difference
      `y_diff` - The Y difference
    Returns:
      A resized area

  - ### scaleFromMaxYMaxX

    public static <S> PAreaBI<S> scaleFromMaxYMaxX(PAreaBI<S> area, BigInteger x_diff, BigInteger y_diff)

    Scale `area` by adding `x_diff` to the sizeX, and `y_diff` to the sizeY. The size of the resulting area is clamped so that its sizeX and sizeY are always non-negative.

    The area is resized by moving its maximum-y-maximum-x corner.

    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
      `x_diff` - The X difference
      `y_diff` - The Y difference
    Returns:
      A resized area

  - ### scaleFromCenter

    public static <S> PAreaBI<S> scaleFromCenter(PAreaBI<S> area, BigInteger x_diff, BigInteger y_diff)

    Scale `area` by adding `x_diff` to the sizeX, and `y_diff` to the sizeY. The size of the resulting area is clamped so that its sizeX and sizeY are always non-negative.

    The area is resized from its own center.

    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
      `x_diff` - The X difference
      `y_diff` - The Y difference
    Returns:
      A resized area

  - ### overlaps

    public static <S> boolean overlaps(PAreaBI<S> a, PAreaBI<S> b)

    Determine whether or not two areas overlap.

    Overlapping is reflexive: `overlaps(a, a) == true`.

    Overlapping is symmetric: `overlaps(a, b) == overlaps(b, a)`.

    Overlapping is not necessarily transitive.

    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `a` - An area
      `b` - An area
    Returns:
      `true` iff `a` overlaps `b`

  - ### couldFitInside

    public static <S> boolean couldFitInside(PAreaBI<S> a, PAreaBI<S> b)

    Determine whether or not one area could fit inside another.

    Fitting is reflexive: `couldFitInside(a, a) == true`.

    Fitting is transitive: `couldFitInside(a, b) → couldFitInside(b, c) → couldFitInside(a, c)`.

    Fitting is not necessarily symmetric.

    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `a` - An area
      `b` - An area
    Returns:
      `true` iff `a` could fit inside `b`

  - ### containing

    public static <S> PAreaBI<S> containing(PAreaBI<S> a, PAreaBI<S> b)
    Construct a area that will contain both `a` and `b`.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `a` - An area
      `b` - An area
    Returns:
      An area containing `a` and `b`

  - ### containsPoint

    public static <S> boolean containsPoint(PAreaBI<S> a, BigInteger x, BigInteger y)

    Determine whether or not a area contains a given point.

    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `a` - An area
      `x` - The X coordinate of the point
      `y` - The Y coordinate of the point
    Returns:
      `true` iff `a` contains `(x, y)`

  - ### fitBetweenHorizontal

    @Deprecated public static <S> PAreaBI<S> fitBetweenHorizontal(PAreaBI<S> fit, PAreaBI<S> a, PAreaBI<S> b)
    Deprecated.
    Use `fitBetweenOnX(PAreaBI, PAreaBI, PAreaBI)`
    Attempt to fit `fit` between `a` and `b`, horizontally.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `fit` - The area to be fitted
      `a` - An area
      `b` - An area
    Returns:
      A fitted area

  - ### fitBetweenVertical

    @Deprecated public static <S> PAreaBI<S> fitBetweenVertical(PAreaBI<S> fit, PAreaBI<S> a, PAreaBI<S> b)
    Deprecated.
    Use `fitBetweenOnY(PAreaBI, PAreaBI, PAreaBI)`
    Attempt to fit `fit` between `a` and `b`, vertically.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `fit` - The area to be fitted
      `a` - An area
      `b` - An area
    Returns:
      A fitted area

  - ### fitBetweenOnX

    public static <S> PAreaBI<S> fitBetweenOnX(PAreaBI<S> fit, PAreaBI<S> a, PAreaBI<S> b)
    Attempt to fit `fit` between `a` and `b`, horizontally.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `fit` - The area to be fitted
      `a` - An area
      `b` - An area
    Returns:
      A fitted area

  - ### fitBetweenOnY

    public static <S> PAreaBI<S> fitBetweenOnY(PAreaBI<S> fit, PAreaBI<S> a, PAreaBI<S> b)
    Attempt to fit `fit` between `a` and `b`, vertically.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `fit` - The area to be fitted
      `a` - An area
      `b` - An area
    Returns:
      A fitted area

  - ### splitAlongParallelToX

    public static <S> PAreaXSplitBI<S,PAreaBI<S>> splitAlongParallelToX(PAreaBI<S> area, BigInteger y)
    Split `area` along a line parallel to the X axis placed at `y` units from its own minimum-y edge.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `area` - The area to be split
      `y` - The relative Y coordinate of the splitting edge
    Returns:
      A pair of areas

  - ### splitAlongParallelToY

    public static <S> PAreaYSplitBI<S,PAreaBI<S>> splitAlongParallelToY(PAreaBI<S> area, BigInteger x)
    Split `area` along a line parallel to the Y axis placed at `x` units from its own minimum-x edge.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `area` - The area to be split
      `x` - The relative X coordinate of the splitting edge
    Returns:
      A pair of areas

  - ### splitAlongXY

    public static <S> PAreaXYSplitBI<S,PAreaBI<S>> splitAlongXY(PAreaBI<S> area, BigInteger x, BigInteger y)
    Split `area` along a two axis-aligned perpendicular lines that intercept at `(x, y)`.
    Type Parameters:
      `S` - The coordinate space of the areas
    Parameters:
      `area` - The area to be split
      `x` - The relative X coordinate of the splitting edge
      `y` - The relative Y coordinate of the splitting edge
    Returns:
      The four resulting quadrants
    Since:
      1.1.0

  - ### show

    public static <S> String show(PAreaBI<S> area)
    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
    Returns:
      A terse string describing the position and size of the area

  - ### size

    public static <S> PAreaSizeBI<S> size(PAreaBI<S> area)
    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
    Returns:
      The size of the area

  - ### showToBuilder

    public static <S> String showToBuilder(PAreaBI<S> area, StringBuilder sb)
    Type Parameters:
      `S` - The coordinate space of the area
    Parameters:
      `area` - The area
      `sb` - A string builder
    Returns:
      A terse string describing the position and size of the area