Package org.apache.commons.math3.analysis.differentiation

# Class SparseGradient

java.lang.Object
org.apache.commons.math3.analysis.differentiation.SparseGradient

All Implemented Interfaces:
  `Serializable`, `FieldElement<SparseGradient>`, `RealFieldElement<SparseGradient>`

public class SparseGradient extends Object implements RealFieldElement<SparseGradient>, Serializable
First derivative computation with large number of variables.

This class plays a similar role to `DerivativeStructure`, with a focus on efficiency when dealing with large number of independent variables and most computation depend only on a few of them, and when only first derivative is desired. When these conditions are met, this class should be much faster than `DerivativeStructure` and use less memory.

Since:
  3.3
See Also:
  - Serialized Form

## Method Summary

Modifier and Type
Method
Description
`SparseGradient`
`abs()`
absolute value.
`SparseGradient`
`acos()`
Arc cosine operation.
`SparseGradient`
`acosh()`
Inverse hyperbolic cosine operation.
`SparseGradient`
`add(double c)`
'+' operator.
`SparseGradient`
`add(SparseGradient a)`
Compute this + a.
`void`
`addInPlace(SparseGradient a)`
Add in place.
`SparseGradient`
`asin()`
Arc sine operation.
`SparseGradient`
`asinh()`
Inverse hyperbolic sine operation.
`SparseGradient`
`atan()`
Arc tangent operation.
`SparseGradient`
`atan2(SparseGradient x)`
Two arguments arc tangent operation.
`static SparseGradient`
`atan2(SparseGradient y, SparseGradient x)`
Two arguments arc tangent operation.
`SparseGradient`
`atanh()`
Inverse hyperbolic tangent operation.
`SparseGradient`
`cbrt()`
Cubic root.
`SparseGradient`
`ceil()`
Get the smallest whole number larger than instance.
`SparseGradient`
`compose(double f0, double f1)`
Compute composition of the instance by a univariate function.
`SparseGradient`
`copySign(double sign)`
Returns the instance with the sign of the argument.
`SparseGradient`
`copySign(SparseGradient sign)`
Returns the instance with the sign of the argument.
`SparseGradient`
`cos()`
Cosine operation.
`SparseGradient`
`cosh()`
Hyperbolic cosine operation.
`static SparseGradient`
`createConstant(double value)`
Factory method creating a constant.
`static SparseGradient`
`createVariable(int idx, double value)`
Factory method creating an independent variable.
`SparseGradient`
`divide(double c)`
'÷' operator.
`SparseGradient`
`divide(SparseGradient a)`
Compute this ÷ a.
`boolean`
`equals(Object other)`
Test for the equality of two sparse gradients.
`SparseGradient`
`exp()`
Exponential.
`SparseGradient`
`expm1()`
Exponential minus 1.
`SparseGradient`
`floor()`
Get the largest whole number smaller than instance.
`double`
`getDerivative(int index)`
Get the derivative with respect to a particular index variable.
`Field<SparseGradient>`
`getField()`
Get the `Field` to which the instance belongs.
`double`
`getReal()`
Get the real value of the number.
`double`
`getValue()`
Get the value of the function.
`int`
`hashCode()`
Get a hashCode for the derivative structure.
`SparseGradient`
`hypot(SparseGradient y)`
Returns the hypotenuse of a triangle with sides `this` and `y` - sqrt(this2 +y2) avoiding intermediate overflow or underflow.
`static SparseGradient`
`hypot(SparseGradient x, SparseGradient y)`
Returns the hypotenuse of a triangle with sides `x` and `y` - sqrt(x2 +y2) avoiding intermediate overflow or underflow.
`SparseGradient`
`linearCombination(double[] a, SparseGradient[] b)`
Compute a linear combination.
`SparseGradient`
`linearCombination(double a1, SparseGradient b1, double a2, SparseGradient b2)`
Compute a linear combination.
`SparseGradient`
`linearCombination(double a1, SparseGradient b1, double a2, SparseGradient b2, double a3, SparseGradient b3)`
Compute a linear combination.
`SparseGradient`
`linearCombination(double a1, SparseGradient b1, double a2, SparseGradient b2, double a3, SparseGradient b3, double a4, SparseGradient b4)`
Compute a linear combination.
`SparseGradient`
`linearCombination(SparseGradient[] a, SparseGradient[] b)`
Compute a linear combination.
`SparseGradient`
`linearCombination(SparseGradient a1, SparseGradient b1, SparseGradient a2, SparseGradient b2)`
Compute a linear combination.
`SparseGradient`
`linearCombination(SparseGradient a1, SparseGradient b1, SparseGradient a2, SparseGradient b2, SparseGradient a3, SparseGradient b3)`
Compute a linear combination.
`SparseGradient`
`linearCombination(SparseGradient a1, SparseGradient b1, SparseGradient a2, SparseGradient b2, SparseGradient a3, SparseGradient b3, SparseGradient a4, SparseGradient b4)`
Compute a linear combination.
`SparseGradient`
`log()`
Natural logarithm.
`SparseGradient`
`log10()`
Base 10 logarithm.
`SparseGradient`
`log1p()`
Shifted natural logarithm.
`SparseGradient`
`multiply(double c)`
'×' operator.
`SparseGradient`
`multiply(int n)`
Compute n × this.
`SparseGradient`
`multiply(SparseGradient a)`
Compute this × a.
`void`
`multiplyInPlace(SparseGradient a)`
Multiply in place.
`SparseGradient`
`negate()`
Returns the additive inverse of `this` element.
`int`
`numVars()`
Find the number of variables.
`SparseGradient`
`pow(double p)`
Power operation.
`static SparseGradient`
`pow(double a, SparseGradient x)`
Compute ax where a is a double and x a `SparseGradient`
`SparseGradient`
`pow(int n)`
Integer power operation.
`SparseGradient`
`pow(SparseGradient e)`
Power operation.
`SparseGradient`
`reciprocal()`
Returns the multiplicative inverse of `this` element.
`SparseGradient`
`remainder(double a)`
IEEE remainder operator.
`SparseGradient`
`remainder(SparseGradient a)`
IEEE remainder operator.
`SparseGradient`
`rint()`
Get the whole number that is the nearest to the instance, or the even one if x is exactly half way between two integers.
`SparseGradient`
`rootN(int n)`
Nth root.
`long`
`round()`
Get the closest long to instance value.
`SparseGradient`
`scalb(int n)`
Multiply the instance by a power of 2.
`SparseGradient`
`signum()`
Compute the signum of the instance.
`SparseGradient`
`sin()`
Sine operation.
`SparseGradient`
`sinh()`
Hyperbolic sine operation.
`SparseGradient`
`sqrt()`
Square root.
`SparseGradient`
`subtract(double c)`
'-' operator.
`SparseGradient`
`subtract(SparseGradient a)`
Compute this - a.
`SparseGradient`
`tan()`
Tangent operation.
`SparseGradient`
`tanh()`
Hyperbolic tangent operation.
`double`
`taylor(double... delta)`
Evaluate Taylor expansion of a sparse gradient.
`SparseGradient`
`toDegrees()`
Convert radians to degrees, with error of less than 0.5 ULP
`SparseGradient`
`toRadians()`
Convert degrees to radians, with error of less than 0.5 ULP

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

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

## Method Details

### createConstant

public static SparseGradient createConstant(double value)
Factory method creating a constant.

Parameters:
  `value` - value of the constant
Returns:
  a new instance

### createVariable

public static SparseGradient createVariable(int idx, double value)
Factory method creating an independent variable.

Parameters:
  `idx` - index of the variable
  `value` - value of the variable
Returns:
  a new instance

### numVars

public int numVars()
Find the number of variables.

Returns:
  number of variables

### getDerivative

public double getDerivative(int index)
Get the derivative with respect to a particular index variable.

Parameters:
  `index` - index to differentiate with.
Returns:
  derivative with respect to a particular index variable

### getValue

public double getValue()
Get the value of the function.

Returns:
  value of the function.

### getReal

public double getReal()
Get the real value of the number.

Specified by:
  `getReal` in interface `RealFieldElement<SparseGradient>`
Returns:
  real value

### add

public SparseGradient add(SparseGradient a)
Compute this + a.

Specified by:
  `add` in interface `FieldElement<SparseGradient>`
Parameters:
  `a` - element to add
Returns:
  a new element representing this + a

### addInPlace

public void addInPlace(SparseGradient a)
Add in place.

This method is designed to be faster when used multiple times in a loop.

The instance is changed here, in order to not change the instance the `add(SparseGradient)` method should be used.

Parameters:
  `a` - instance to add

### add

public SparseGradient add(double c)
'+' operator.

Specified by:
  `add` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `c` - right hand side parameter of the operator
Returns:
  this+a

### subtract

public SparseGradient subtract(SparseGradient a)
Compute this - a.

Specified by:
  `subtract` in interface `FieldElement<SparseGradient>`
Parameters:
  `a` - element to subtract
Returns:
  a new element representing this - a

### subtract

public SparseGradient subtract(double c)
'-' operator.

Specified by:
  `subtract` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `c` - right hand side parameter of the operator
Returns:
  this-a

### multiply

public SparseGradient multiply(SparseGradient a)
Compute this × a.

Specified by:
  `multiply` in interface `FieldElement<SparseGradient>`
Parameters:
  `a` - element to multiply
Returns:
  a new element representing this × a

### multiplyInPlace

public void multiplyInPlace(SparseGradient a)
Multiply in place.

This method is designed to be faster when used multiple times in a loop.

The instance is changed here, in order to not change the instance the `add(SparseGradient)` method should be used.

Parameters:
  `a` - instance to multiply

### multiply

public SparseGradient multiply(double c)
'×' operator.

Specified by:
  `multiply` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `c` - right hand side parameter of the operator
Returns:
  this×a

### multiply

public SparseGradient multiply(int n)
Compute n × this. Multiplication by an integer number is defined as the following sum
n × this = ∑i=1n this.

Specified by:
  `multiply` in interface `FieldElement<SparseGradient>`
Parameters:
  `n` - Number of times `this` must be added to itself.
Returns:
  A new element representing n × this.

### divide

public SparseGradient divide(SparseGradient a)
Compute this ÷ a.

Specified by:
  `divide` in interface `FieldElement<SparseGradient>`
Parameters:
  `a` - element to divide by
Returns:
  a new element representing this ÷ a

### divide

public SparseGradient divide(double c)
'÷' operator.

Specified by:
  `divide` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `c` - right hand side parameter of the operator
Returns:
  this÷a

### negate

public SparseGradient negate()
Returns the additive inverse of `this` element.

Specified by:
  `negate` in interface `FieldElement<SparseGradient>`
Returns:
  the opposite of `this`.

### getField

public Field<SparseGradient> getField()
Get the `Field` to which the instance belongs.

Specified by:
  `getField` in interface `FieldElement<SparseGradient>`
Returns:
  `Field` to which the instance belongs

### remainder

public SparseGradient remainder(double a)
IEEE remainder operator.

Specified by:
  `remainder` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `a` - right hand side parameter of the operator
Returns:
  this - n × a where n is the closest integer to this/a (the even integer is chosen for n if this/a is halfway between two integers)

### remainder

public SparseGradient remainder(SparseGradient a)
IEEE remainder operator.

Specified by:
  `remainder` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `a` - right hand side parameter of the operator
Returns:
  this - n × a where n is the closest integer to this/a (the even integer is chosen for n if this/a is halfway between two integers)

### abs

public SparseGradient abs()
absolute value.

Specified by:
  `abs` in interface `RealFieldElement<SparseGradient>`
Returns:
  abs(this)

### ceil

public SparseGradient ceil()
Get the smallest whole number larger than instance.

Specified by:
  `ceil` in interface `RealFieldElement<SparseGradient>`
Returns:
  ceil(this)

### floor

public SparseGradient floor()
Get the largest whole number smaller than instance.

Specified by:
  `floor` in interface `RealFieldElement<SparseGradient>`
Returns:
  floor(this)

### rint

public SparseGradient rint()
Get the whole number that is the nearest to the instance, or the even one if x is exactly half way between two integers.

Specified by:
  `rint` in interface `RealFieldElement<SparseGradient>`
Returns:
  a double number r such that r is an integer r - 0.5 ≤ this ≤ r + 0.5

### round

public long round()
Get the closest long to instance value.

Specified by:
  `round` in interface `RealFieldElement<SparseGradient>`
Returns:
  closest long to `RealFieldElement.getReal()`

### signum

public SparseGradient signum()
Compute the signum of the instance. The signum is -1 for negative numbers, +1 for positive numbers and 0 otherwise

Specified by:
  `signum` in interface `RealFieldElement<SparseGradient>`
Returns:
  -1.0, -0.0, +0.0, +1.0 or NaN depending on sign of a

### copySign

public SparseGradient copySign(SparseGradient sign)
Returns the instance with the sign of the argument. A NaN `sign` argument is treated as positive.

Specified by:
  `copySign` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `sign` - the sign for the returned value
Returns:
  the instance with the same sign as the `sign` argument

### copySign

public SparseGradient copySign(double sign)
Returns the instance with the sign of the argument. A NaN `sign` argument is treated as positive.

Specified by:
  `copySign` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `sign` - the sign for the returned value
Returns:
  the instance with the same sign as the `sign` argument

### scalb

public SparseGradient scalb(int n)
Multiply the instance by a power of 2.

Specified by:
  `scalb` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `n` - power of 2
Returns:
  this × 2n

### hypot

public SparseGradient hypot(SparseGradient y)
Returns the hypotenuse of a triangle with sides `this` and `y` - sqrt(this2 +y2) avoiding intermediate overflow or underflow.

- If either argument is infinite, then the result is positive infinity.
- else, if either argument is NaN then the result is NaN.

Specified by:
  `hypot` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `y` - a value
Returns:
  sqrt(this2 +y2)

### hypot

public static SparseGradient hypot(SparseGradient x, SparseGradient y)
Returns the hypotenuse of a triangle with sides `x` and `y` - sqrt(x2 +y2) avoiding intermediate overflow or underflow.

- If either argument is infinite, then the result is positive infinity.
- else, if either argument is NaN then the result is NaN.

Parameters:
  `x` - a value
  `y` - a value
Returns:
  sqrt(x2 +y2)

### reciprocal

public SparseGradient reciprocal()
Returns the multiplicative inverse of `this` element.

Specified by:
  `reciprocal` in interface `FieldElement<SparseGradient>`
Specified by:
  `reciprocal` in interface `RealFieldElement<SparseGradient>`
Returns:
  the inverse of `this`.

### sqrt

public SparseGradient sqrt()
Square root.

Specified by:
  `sqrt` in interface `RealFieldElement<SparseGradient>`
Returns:
  square root of the instance

### cbrt

public SparseGradient cbrt()
Cubic root.

Specified by:
  `cbrt` in interface `RealFieldElement<SparseGradient>`
Returns:
  cubic root of the instance

### rootN

public SparseGradient rootN(int n)
Nth root.

Specified by:
  `rootN` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `n` - order of the root
Returns:
  nth root of the instance

### pow

public SparseGradient pow(double p)
Power operation.

Specified by:
  `pow` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `p` - power to apply
Returns:
  thisp

### pow

public SparseGradient pow(int n)
Integer power operation.

Specified by:
  `pow` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `n` - power to apply
Returns:
  thisn

### pow

public SparseGradient pow(SparseGradient e)
Power operation.

Specified by:
  `pow` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `e` - exponent
Returns:
  thise

### pow

public static SparseGradient pow(double a, SparseGradient x)
Compute ax where a is a double and x a `SparseGradient`

Parameters:
  `a` - number to exponentiate
  `x` - power to apply
Returns:
  ax

### exp

public SparseGradient exp()
Exponential.

Specified by:
  `exp` in interface `RealFieldElement<SparseGradient>`
Returns:
  exponential of the instance

### expm1

public SparseGradient expm1()
Exponential minus 1.

Specified by:
  `expm1` in interface `RealFieldElement<SparseGradient>`
Returns:
  exponential minus one of the instance

### log

public SparseGradient log()
Natural logarithm.

Specified by:
  `log` in interface `RealFieldElement<SparseGradient>`
Returns:
  logarithm of the instance

### log10

public SparseGradient log10()
Base 10 logarithm.

Returns:
  base 10 logarithm of the instance

### log1p

public SparseGradient log1p()
Shifted natural logarithm.

Specified by:
  `log1p` in interface `RealFieldElement<SparseGradient>`
Returns:
  logarithm of one plus the instance

### cos

public SparseGradient cos()
Cosine operation.

Specified by:
  `cos` in interface `RealFieldElement<SparseGradient>`
Returns:
  cos(this)

### sin

public SparseGradient sin()
Sine operation.

Specified by:
  `sin` in interface `RealFieldElement<SparseGradient>`
Returns:
  sin(this)

### tan

public SparseGradient tan()
Tangent operation.

Specified by:
  `tan` in interface `RealFieldElement<SparseGradient>`
Returns:
  tan(this)

### acos

public SparseGradient acos()
Arc cosine operation.

Specified by:
  `acos` in interface `RealFieldElement<SparseGradient>`
Returns:
  acos(this)

### asin

public SparseGradient asin()
Arc sine operation.

Specified by:
  `asin` in interface `RealFieldElement<SparseGradient>`
Returns:
  asin(this)

### atan

public SparseGradient atan()
Arc tangent operation.

Specified by:
  `atan` in interface `RealFieldElement<SparseGradient>`
Returns:
  atan(this)

### atan2

public SparseGradient atan2(SparseGradient x)
Two arguments arc tangent operation.

Specified by:
  `atan2` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `x` - second argument of the arc tangent
Returns:
  atan2(this, x)

### atan2

public static SparseGradient atan2(SparseGradient y, SparseGradient x)
Two arguments arc tangent operation.

Parameters:
  `y` - first argument of the arc tangent
  `x` - second argument of the arc tangent
Returns:
  atan2(y, x)

### cosh

public SparseGradient cosh()
Hyperbolic cosine operation.

Specified by:
  `cosh` in interface `RealFieldElement<SparseGradient>`
Returns:
  cosh(this)

### sinh

public SparseGradient sinh()
Hyperbolic sine operation.

Specified by:
  `sinh` in interface `RealFieldElement<SparseGradient>`
Returns:
  sinh(this)

### tanh

public SparseGradient tanh()
Hyperbolic tangent operation.

Specified by:
  `tanh` in interface `RealFieldElement<SparseGradient>`
Returns:
  tanh(this)

### acosh

public SparseGradient acosh()
Inverse hyperbolic cosine operation.

Specified by:
  `acosh` in interface `RealFieldElement<SparseGradient>`
Returns:
  acosh(this)

### asinh

public SparseGradient asinh()
Inverse hyperbolic sine operation.

Specified by:
  `asinh` in interface `RealFieldElement<SparseGradient>`
Returns:
  asin(this)

### atanh

public SparseGradient atanh()
Inverse hyperbolic tangent operation.

Specified by:
  `atanh` in interface `RealFieldElement<SparseGradient>`
Returns:
  atanh(this)

### toDegrees

public SparseGradient toDegrees()
Convert radians to degrees, with error of less than 0.5 ULP

Returns:
  instance converted into degrees

### toRadians

public SparseGradient toRadians()
Convert degrees to radians, with error of less than 0.5 ULP

Returns:
  instance converted into radians

### taylor

public double taylor(double... delta)
Evaluate Taylor expansion of a sparse gradient.

Parameters:
  `delta` - parameters offsets (Δx, Δy, ...)
Returns:
  value of the Taylor expansion at x + Δx, y + Δy, ...

### compose

public SparseGradient compose(double f0, double f1)
Compute composition of the instance by a univariate function.

Parameters:
  `f0` - value of the function at (i.e. f(`getValue()`))
  `f1` - first derivative of the function at the current point (i.e. f'(`getValue()`))
Returns:
  f(this)

### linearCombination

public SparseGradient linearCombination(SparseGradient[] a, SparseGradient[] b) throws DimensionMismatchException
Compute a linear combination.

Specified by:
  `linearCombination` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `a` - Factors.
  `b` - Factors.
Returns:
  `Σi ai bi`.
Throws:
  `DimensionMismatchException` - if arrays dimensions don't match

### linearCombination

public SparseGradient linearCombination(double[] a, SparseGradient[] b)
Compute a linear combination.

Specified by:
  `linearCombination` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `a` - Factors.
  `b` - Factors.
Returns:
  `Σi ai bi`.

### linearCombination

public SparseGradient linearCombination(SparseGradient a1, SparseGradient b1, SparseGradient a2, SparseGradient b2)
Compute a linear combination.

Specified by:
  `linearCombination` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `a1` - first factor of the first term
  `b1` - second factor of the first term
  `a2` - first factor of the second term
  `b2` - second factor of the second term
Returns:
  a1×b1 + a2×b2
See Also:
  - `RealFieldElement.linearCombination(Object, Object, Object, Object, Object, Object)`
  - `RealFieldElement.linearCombination(Object, Object, Object, Object, Object, Object, Object, Object)`

### linearCombination

public SparseGradient linearCombination(double a1, SparseGradient b1, double a2, SparseGradient b2)
Compute a linear combination.

Specified by:
  `linearCombination` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `a1` - first factor of the first term
  `b1` - second factor of the first term
  `a2` - first factor of the second term
  `b2` - second factor of the second term
Returns:
  a1×b1 + a2×b2
See Also:
  - `RealFieldElement.linearCombination(double, Object, double, Object, double, Object)`
  - `RealFieldElement.linearCombination(double, Object, double, Object, double, Object, double, Object)`

### linearCombination

public SparseGradient linearCombination(SparseGradient a1, SparseGradient b1, SparseGradient a2, SparseGradient b2, SparseGradient a3, SparseGradient b3)
Compute a linear combination.

Specified by:
  `linearCombination` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `a1` - first factor of the first term
  `b1` - second factor of the first term
  `a2` - first factor of the second term
  `b2` - second factor of the second term
  `a3` - first factor of the third term
  `b3` - second factor of the third term
Returns:
  a1×b1 + a2×b2 + a3×b3
See Also:
  - `RealFieldElement.linearCombination(Object, Object, Object, Object)`
  - `RealFieldElement.linearCombination(Object, Object, Object, Object, Object, Object, Object, Object)`

### linearCombination

public SparseGradient linearCombination(double a1, SparseGradient b1, double a2, SparseGradient b2, double a3, SparseGradient b3)
Compute a linear combination.

Specified by:
  `linearCombination` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `a1` - first factor of the first term
  `b1` - second factor of the first term
  `a2` - first factor of the second term
  `b2` - second factor of the second term
  `a3` - first factor of the third term
  `b3` - second factor of the third term
Returns:
  a1×b1 + a2×b2 + a3×b3
See Also:
  - `RealFieldElement.linearCombination(double, Object, double, Object)`
  - `RealFieldElement.linearCombination(double, Object, double, Object, double, Object, double, Object)`

### linearCombination

public SparseGradient linearCombination(SparseGradient a1, SparseGradient b1, SparseGradient a2, SparseGradient b2, SparseGradient a3, SparseGradient b3, SparseGradient a4, SparseGradient b4)
Compute a linear combination.

Specified by:
  `linearCombination` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `a1` - first factor of the first term
  `b1` - second factor of the first term
  `a2` - first factor of the second term
  `b2` - second factor of the second term
  `a3` - first factor of the third term
  `b3` - second factor of the third term
  `a4` - first factor of the third term
  `b4` - second factor of the third term
Returns:
  a1×b1 + a2×b2 + a3×b3 + a4×b4
See Also:
  - `RealFieldElement.linearCombination(Object, Object, Object, Object)`
  - `RealFieldElement.linearCombination(Object, Object, Object, Object, Object, Object)`

### linearCombination

public SparseGradient linearCombination(double a1, SparseGradient b1, double a2, SparseGradient b2, double a3, SparseGradient b3, double a4, SparseGradient b4)
Compute a linear combination.

Specified by:
  `linearCombination` in interface `RealFieldElement<SparseGradient>`
Parameters:
  `a1` - first factor of the first term
  `b1` - second factor of the first term
  `a2` - first factor of the second term
  `b2` - second factor of the second term
  `a3` - first factor of the third term
  `b3` - second factor of the third term
  `a4` - first factor of the third term
  `b4` - second factor of the third term
Returns:
  a1×b1 + a2×b2 + a3×b3 + a4×b4
See Also:
  - `RealFieldElement.linearCombination(double, Object, double, Object)`
  - `RealFieldElement.linearCombination(double, Object, double, Object, double, Object)`

### equals

public boolean equals(Object other)
Test for the equality of two sparse gradients.

Sparse gradients are considered equal if they have the same value and the same derivatives.

Overrides:
  `equals` in class `Object`
Parameters:
  `other` - Object to test for equality to this
Returns:
  true if two sparse gradients are equal

### hashCode

public int hashCode()
Get a hashCode for the derivative structure.

Overrides:
  `hashCode` in class `Object`
Returns:
  a hash code value for this object
Since:
  3.2