de.caff.generics.function

## Interface DoubleOperator2

- All Superinterfaces:
    java.util.function.DoubleBinaryOperator
  Functional Interface:
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

      @FunctionalInterface
      public interface DoubleOperator2
      extends java.util.function.DoubleBinaryOperator

  Binary operator with two double arguments and a double result.
  Since:
    October 31, 2019
  Author:
    Rammi

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static DoubleOperator2` | `DIV` Double operator which returns the division result of two arguments: `a / b`
    `static DoubleOperator2` | `MINUS` Double operator which returns the difference of two arguments: `a - b`
    `static DoubleOperator2` | `MOD` Double operator which returns the modulo result of two arguments: `a % b`.
    `static DoubleOperator2` | `MULT` Double operator which returns the product of two arguments: `a * b`
    `static DoubleOperator2` | `PLUS` Double operator which returns the sum of two arguments: `a + b`.
    `static DoubleOperator2` | `POWER` Double operator which returns the first argument to the power given by the second argument: `a ^ b`

  - ### Method Summary

    All Methods Static Methods Instance Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `default DoubleOperator2` | `andThen(DoubleOperator1 after)` Create a operator which applies this operator and feeds the result into the next operator.
    `default DoubleOperator2` | `combine(DoubleOperator1 firstArgHandler, DoubleOperator1 secondArgHandler)` Use this operator on the results of two other operators.
    `static DoubleOperator2` | `from(java.util.function.DoubleBinaryOperator operator)` Make a standard unary double operator usable as `DoubleOperator2`.
    `default DoubleOperator1` | `partialLeft(double argument)` Get a partially applied operator.
    `default DoubleOperator1` | `partialRight(double argument)` Get a partially applied operator.

    - ### Methods inherited from interface java.util.function.DoubleBinaryOperator

      `applyAsDouble`

- - ### Field Detail

    - #### PLUS

          static final DoubleOperator2 PLUS

      Double operator which returns the sum of two arguments: `a + b`.

    - #### MINUS

          static final DoubleOperator2 MINUS

      Double operator which returns the difference of two arguments: `a - b`

    - #### MULT

          static final DoubleOperator2 MULT

      Double operator which returns the product of two arguments: `a * b`

    - #### DIV

          static final DoubleOperator2 DIV

      Double operator which returns the division result of two arguments: `a / b`

    - #### MOD

          static final DoubleOperator2 MOD

      Double operator which returns the modulo result of two arguments: `a % b`.

    - #### POWER

          static final DoubleOperator2 POWER

      Double operator which returns the first argument to the power given by the second argument: `a ^ b`

  - ### Method Detail

    - #### partialLeft

          @NotNull
          default DoubleOperator1 partialLeft(double argument)

      Get a partially applied operator.
      Parameters:
        `argument` - value applied for first argument
      Returns:
        partially evaluated operator

    - #### partialRight

          @NotNull
          default DoubleOperator1 partialRight(double argument)

      Get a partially applied operator.
      Parameters:
        `argument` - value applied for second argument
      Returns:
        partially evaluated operator

    - #### andThen

          @NotNull
          default DoubleOperator2 andThen(@NotNull
                                                   DoubleOperator1 after)

      Create a operator which applies this operator and feeds the result into the next operator.
      Parameters:
        `after` - operator called with the result of this operator
      Returns:
        chained operator

    - #### combine

          @NotNull
          default DoubleOperator2 combine(@NotNull
                                                   DoubleOperator1 firstArgHandler,
                                                   @NotNull
                                                   DoubleOperator1 secondArgHandler)

      Use this operator on the results of two other operators. This will use the first argument handler on the first argument, the second argument handler on the second argument, and this operator on their results.

      Example: `combine(DoubleFunction1.SQUARE, DoubleFunction11.SQUARE).andThen(DoubleFunction1.SQUARE_ROOT)` creates a operator which calculates the length of a 2D vector.

      Parameters:
        `firstArgHandler` - handler for first argument
        `secondArgHandler` - handler for second argument
      Returns:
        resulting operator

    - #### from

          @NotNull
          static DoubleOperator2 from(@NotNull
                                               java.util.function.DoubleBinaryOperator operator)

      Make a standard unary double operator usable as `DoubleOperator2`. This is useful if you want to make use of the extended functionality of this implementation.
      Parameters:
        `operator` - operator to be used as a `DoubleOperator2`
      Returns:
        `DoubleOperator2` view of the incoming operator, or possibly just a cast if `operator` already has the correct type