# Class LongAdditionStrategy

java.lang.Object
org.apfloat.internal.LongBaseMath
org.apfloat.internal.LongAdditionStrategy

All Implemented Interfaces:
  `Serializable, AdditionStrategy<Long>`

public class LongAdditionStrategy extends LongBaseMath implements AdditionStrategy<Long>
Basic addition strategy for the `long` element type.

Since:
  1.7.0
Version:
  1.7.0
Author:
  Mikko Tommila
See Also:
  - Serialized Form

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `LongAdditionStrategy(int radix)`
  Creates an addition strategy using the specified radix.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `Long`
  `add(DataStorage.Iterator src1, DataStorage.Iterator src2, Long carry, DataStorage.Iterator dst, long size)`
  Addition in some base.
  `Long`
  `divide(DataStorage.Iterator src1, Long src2, Long carry, DataStorage.Iterator dst, long size)`
  Division in some base.
  `Long`
  `multiplyAdd(DataStorage.Iterator src1, DataStorage.Iterator src2, Long src3, Long carry, DataStorage.Iterator dst, long size)`
  Multiplication and addition in some base.
  `Long`
  `subtract(DataStorage.Iterator src1, DataStorage.Iterator src2, Long carry, DataStorage.Iterator dst, long size)`
  Subtraction in some base.
  `Long`
  `zero()`
  Returns the zero element.

  ### Methods inherited from class LongBaseMath

  `baseAdd, baseDivide, baseMultiplyAdd, baseSubtract`

  ### Methods inherited from class Object

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

- ## Constructor Details

  - ### LongAdditionStrategy

    public LongAdditionStrategy(int radix)
    Creates an addition strategy using the specified radix.
    Parameters:
      `radix` - The radix that will be used.

- ## Method Details

  - ### add

    public Long add(DataStorage.Iterator src1, DataStorage.Iterator src2, Long carry, DataStorage.Iterator dst, long size) throws ApfloatRuntimeException
    Description copied from interface: `AdditionStrategy`
    Addition in some base. Adds the data words of `src1` and `src2` and stores the result to `dst`. `src2` may be `null`, in which case it is ignored (only the carry is propagated).

    Essentially calculates `dst[i] = src1[i] + src2[i]`.

    Specified by:
      `add` in interface `AdditionStrategy<Long>`
    Parameters:
      `src1` - First source data sequence. Can be `null`, in which case it's ignored.
      `src2` - Second source data sequence. Can be `null`, in which case it's ignored.
      `carry` - Input carry bit. This is added to the first (rightmost) word in the accessed sequence.
      `dst` - Destination data sequence.
      `size` - Number of elements to process.
    Returns:
      Overflow carry bit. Propagated carry bit from the addition of the last (leftmost) word in the accessed sequence.
    Throws:
      `ApfloatRuntimeException`

  - ### subtract

    public Long subtract(DataStorage.Iterator src1, DataStorage.Iterator src2, Long carry, DataStorage.Iterator dst, long size) throws ApfloatRuntimeException
    Description copied from interface: `AdditionStrategy`
    Subtraction in some base. Subtracts the data words of `src1` and `src2` and stores the result to `dst`. `src1` and `src2` may be `null`, in which case they are ignored (the values are assumed to be zero and only the carry is propagated).

    Essentially calculates `dst[i] = src1[i] - src2[i]`.

    Specified by:
      `subtract` in interface `AdditionStrategy<Long>`
    Parameters:
      `src1` - First source data sequence. Can be `null`, in which case the input values are assumed to be zero.
      `src2` - Second source data sequence. Can be `null`, in which case it's ignored, or can be the same as `dst`.
      `carry` - Input carry bit. This is subtracted from the first (rightmost) word in the accessed sequence.
      `dst` - Destination data sequence.
      `size` - Number of elements to process.
    Returns:
      Overflow carry bit. Propagated carry bit from the subtraction of the last (leftmost) word in the accessed sequence. The value is `1` if the carry is set, and `0` otherwise.
    Throws:
      `ApfloatRuntimeException`

  - ### multiplyAdd

    public Long multiplyAdd(DataStorage.Iterator src1, DataStorage.Iterator src2, Long src3, Long carry, DataStorage.Iterator dst, long size) throws ApfloatRuntimeException
    Description copied from interface: `AdditionStrategy`
    Multiplication and addition in some base. Multiplies the data words of `src1` by `src3` and adds the result to the words in `src2`, and stores the result to `dst`. `src2` may be `null`, in which case it is ignored (the values are assumed to be zero).

    Assumes that the result from the addition doesn't overflow the upper result word (to larger than the base). This is the case e.g. when using this method to perform an arbitrary precision multiplication.

    Essentially calculates `dst[i] = src1[i] * src3 + src2[i]`.

    Specified by:
      `multiplyAdd` in interface `AdditionStrategy<Long>`
    Parameters:
      `src1` - First source data sequence.
      `src2` - Second source data sequence. Can be `null`, in which case it's ignored, or can be the same as `dst`.
      `src3` - Multiplicand. All elements of `src1` are multiplied by this value.
      `carry` - Input carry word. This is added to the first (rightmost) word in the accessed sequence.
      `dst` - Destination data sequence.
      `size` - Number of elements to process.
    Returns:
      Overflow carry word. Propagated carry word from the multiplication and addition of the last (leftmost) word in the accessed sequence.
    Throws:
      `ApfloatRuntimeException`

  - ### divide

    public Long divide(DataStorage.Iterator src1, Long src2, Long carry, DataStorage.Iterator dst, long size) throws ApfloatRuntimeException
    Description copied from interface: `AdditionStrategy`
    Division in some base. Divides the data words of `src1` by `src2` and stores the result to `dst`. `src1` may be `null`, in which case it is ignored (the values are assumed to be zero and only the carry division is propagated).

    Essentially calculates `dst[i] = src1[i] / src2`.

    Specified by:
      `divide` in interface `AdditionStrategy<Long>`
    Parameters:
      `src1` - First source data sequence. Can be `null`, in which case the input values are assumed to be zero.
      `src2` - Divisor. All elements of `src1` are divided by this value.
      `carry` - Input carry word. Used as the upper word for the division of the first input element. This should be the remainder word returned from the previous block processed.
      `dst` - Destination data sequence. Can be `null`, in which case only the remainder is computed.
      `size` - Number of elements to process.
    Returns:
      Remainder word of the propagated division of the last (rightmost) word in the accessed sequence.
    Throws:
      `ApfloatRuntimeException`

  - ### zero

    public Long zero()
    Description copied from interface: `AdditionStrategy`
    Returns the zero element.
    Specified by:
      `zero` in interface `AdditionStrategy<Long>`
    Returns:
      Zero of the correct element type.