This is an automated email from the ASF dual-hosted git repository.
erans pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-math.git
The following commit(s) were added to refs/heads/master by this push:
new f94991f22 MATH-1589: Remove spurious "throws" clause.
f94991f22 is described below
commit f94991f224f01ba25c0677bf09e3f6e5861acd47
Author: Gilles Sadowski <gillese...@gmail.com>
AuthorDate: Wed Jul 20 14:47:45 2022 +0200
MATH-1589: Remove spurious "throws" clause.
---
.../differentiation/DerivativeStructure.java | 162 ++++++++-------------
.../MultivariateDifferentiableFunction.java | 12 +-
.../UnivariateDifferentiableFunction.java | 9 +-
3 files changed, 71 insertions(+), 112 deletions(-)
diff --git
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/DerivativeStructure.java
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/DerivativeStructure.java
index 1b7c06905..7812ca6c8 100644
---
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/DerivativeStructure.java
+++
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/DerivativeStructure.java
@@ -23,7 +23,6 @@ import org.apache.commons.math4.legacy.core.Field;
import org.apache.commons.math4.legacy.core.FieldElement;
import org.apache.commons.math4.legacy.core.RealFieldElement;
import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
-import org.apache.commons.math4.legacy.exception.MathArithmeticException;
import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
import org.apache.commons.math4.core.jdkmath.JdkMath;
import org.apache.commons.math4.legacy.core.MathArrays;
@@ -76,10 +75,9 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
/** Build an instance with all values and derivatives set to 0.
* @param parameters number of free parameters
* @param order derivation order
- * @throws NumberIsTooLargeException if order is too large
+ * @throws NumberIsTooLargeException if order is too large.
*/
- public DerivativeStructure(final int parameters, final int order)
- throws NumberIsTooLargeException {
+ public DerivativeStructure(final int parameters, final int order) {
this(DSCompiler.getCompiler(parameters, order));
}
@@ -87,11 +85,10 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
* @param parameters number of free parameters
* @param order derivation order
* @param value value of the constant
- * @throws NumberIsTooLargeException if order is too large
+ * @throws NumberIsTooLargeException if order is too large.
* @see #DerivativeStructure(int, int, int, double)
*/
- public DerivativeStructure(final int parameters, final int order, final
double value)
- throws NumberIsTooLargeException {
+ public DerivativeStructure(final int parameters, final int order, final
double value) {
this(parameters, order);
this.data[0] = value;
}
@@ -105,12 +102,11 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
* @param order derivation order
* @param index index of the variable (from 0 to {@code parameters - 1})
* @param value value of the variable
- * @exception NumberIsTooLargeException if {@code index ≥ parameters}.
+ * @throws NumberIsTooLargeException if {@code index ≥ parameters}.
* @see #DerivativeStructure(int, int, double)
*/
public DerivativeStructure(final int parameters, final int order,
- final int index, final double value)
- throws NumberIsTooLargeException {
+ final int index, final double value) {
this(parameters, order, value);
if (index >= parameters) {
@@ -130,11 +126,11 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
* @param ds1 first base (unscaled) derivative structure
* @param a2 second scale factor
* @param ds2 second base (unscaled) derivative structure
- * @exception DimensionMismatchException if number of free parameters or
orders are inconsistent
+ * @throws
org.apache.commons.math4.legacy.exception.DimensionMismatchException
+ * if number of free parameters or orders are inconsistent
*/
public DerivativeStructure(final double a1, final DerivativeStructure ds1,
- final double a2, final DerivativeStructure ds2)
- throws DimensionMismatchException {
+ final double a2, final DerivativeStructure ds2)
{
this(ds1.compiler);
compiler.checkCompatibility(ds2.compiler);
compiler.linearCombination(a1, ds1.data, 0, a2, ds2.data, 0, data, 0);
@@ -148,12 +144,12 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
* @param ds2 second base (unscaled) derivative structure
* @param a3 third scale factor
* @param ds3 third base (unscaled) derivative structure
- * @exception DimensionMismatchException if number of free parameters or
orders are inconsistent
+ * @throws
org.apache.commons.math4.legacy.exception.DimensionMismatchException
+ * if number of free parameters or orders are inconsistent.
*/
public DerivativeStructure(final double a1, final DerivativeStructure ds1,
final double a2, final DerivativeStructure ds2,
- final double a3, final DerivativeStructure ds3)
- throws DimensionMismatchException {
+ final double a3, final DerivativeStructure ds3)
{
this(ds1.compiler);
compiler.checkCompatibility(ds2.compiler);
compiler.checkCompatibility(ds3.compiler);
@@ -170,13 +166,12 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
* @param ds3 third base (unscaled) derivative structure
* @param a4 fourth scale factor
* @param ds4 fourth base (unscaled) derivative structure
- * @exception DimensionMismatchException if number of free parameters or
orders are inconsistent
+ * @throws DimensionMismatchException if number of free parameters or
orders are inconsistent.
*/
public DerivativeStructure(final double a1, final DerivativeStructure ds1,
final double a2, final DerivativeStructure ds2,
final double a3, final DerivativeStructure ds3,
- final double a4, final DerivativeStructure ds4)
- throws DimensionMismatchException {
+ final double a4, final DerivativeStructure ds4)
{
this(ds1.compiler);
compiler.checkCompatibility(ds2.compiler);
compiler.checkCompatibility(ds3.compiler);
@@ -191,13 +186,12 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
* @param order derivation order
* @param derivatives derivatives sorted according to
* {@link DSCompiler#getPartialDerivativeIndex(int...)}
- * @exception DimensionMismatchException if derivatives array does not
match the
- * {@link DSCompiler#getSize() size} expected by the compiler
- * @throws NumberIsTooLargeException if order is too large
+ * @throws DimensionMismatchException if derivatives array does not match
the
+ * {@link DSCompiler#getSize() size} expected by the compiler.
+ * @throws NumberIsTooLargeException if order is too large.
* @see #getAllDerivatives()
*/
- public DerivativeStructure(final int parameters, final int order, final
double ... derivatives)
- throws DimensionMismatchException, NumberIsTooLargeException {
+ public DerivativeStructure(final int parameters, final int order, final
double ... derivatives) {
this(parameters, order);
if (derivatives.length != data.length) {
throw new DimensionMismatchException(derivatives.length,
data.length);
@@ -262,13 +256,12 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
* the value is returned)
* @return partial derivative
* @see #getValue()
- * @exception DimensionMismatchException if the numbers of variables does
not
- * match the instance
- * @exception NumberIsTooLargeException if sum of derivation orders is
larger
- * than the instance limits
+ * @throws DimensionMismatchException if the numbers of variables does not
+ * match the instance.
+ * @throws NumberIsTooLargeException if the sum of derivation orders is
larger than
+ * the instance limits.
*/
- public double getPartialDerivative(final int ... orders)
- throws DimensionMismatchException, NumberIsTooLargeException {
+ public double getPartialDerivative(final int ... orders) {
return data[compiler.getPartialDerivativeIndex(orders)];
}
@@ -291,12 +284,11 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
- * or orders do not match
+ * @throws DimensionMismatchException if number of free parameters
+ * or orders do not match.
*/
@Override
- public DerivativeStructure add(final DerivativeStructure a)
- throws DimensionMismatchException {
+ public DerivativeStructure add(final DerivativeStructure a) {
compiler.checkCompatibility(a.compiler);
final DerivativeStructure ds = new DerivativeStructure(this);
compiler.add(data, 0, a.data, 0, ds.data, 0);
@@ -312,12 +304,11 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
*/
@Override
- public DerivativeStructure subtract(final DerivativeStructure a)
- throws DimensionMismatchException {
+ public DerivativeStructure subtract(final DerivativeStructure a) {
compiler.checkCompatibility(a.compiler);
final DerivativeStructure ds = new DerivativeStructure(this);
compiler.subtract(data, 0, a.data, 0, ds.data, 0);
@@ -343,12 +334,11 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
*/
@Override
- public DerivativeStructure multiply(final DerivativeStructure a)
- throws DimensionMismatchException {
+ public DerivativeStructure multiply(final DerivativeStructure a) {
compiler.checkCompatibility(a.compiler);
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.multiply(data, 0, a.data, 0, result.data, 0);
@@ -368,12 +358,11 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
*/
@Override
- public DerivativeStructure divide(final DerivativeStructure a)
- throws DimensionMismatchException {
+ public DerivativeStructure divide(final DerivativeStructure a) {
compiler.checkCompatibility(a.compiler);
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.divide(data, 0, a.data, 0, result.data, 0);
@@ -389,13 +378,12 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
* @since 3.2
*/
@Override
- public DerivativeStructure remainder(final DerivativeStructure a)
- throws DimensionMismatchException {
+ public DerivativeStructure remainder(final DerivativeStructure a) {
compiler.checkCompatibility(a.compiler);
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.remainder(data, 0, a.data, 0, result.data, 0);
@@ -522,14 +510,12 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
* @since 3.2
*/
@Override
- public DerivativeStructure hypot(final DerivativeStructure y)
- throws DimensionMismatchException {
-
+ public DerivativeStructure hypot(final DerivativeStructure y) {
compiler.checkCompatibility(y.compiler);
if (Double.isInfinite(data[0]) || Double.isInfinite(y.data[0])) {
@@ -584,12 +570,11 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
* @param x a value
* @param y a value
* @return sqrt(<i>x</i><sup>2</sup> +<i>y</i><sup>2</sup>)
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
* @since 3.2
*/
- public static DerivativeStructure hypot(final DerivativeStructure x, final
DerivativeStructure y)
- throws DimensionMismatchException {
+ public static DerivativeStructure hypot(final DerivativeStructure x, final
DerivativeStructure y) {
return x.hypot(y);
}
@@ -598,11 +583,10 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
* the current point (i.e. [f({@link #getValue()}),
* f'({@link #getValue()}), f''({@link #getValue()})...]).
* @return f(this)
- * @exception DimensionMismatchException if the number of derivatives
+ * @throws DimensionMismatchException if the number of derivatives
* in the array is not equal to {@link #getOrder() order} + 1
*/
- public DerivativeStructure compose(final double ... f)
- throws DimensionMismatchException {
+ public DerivativeStructure compose(final double ... f) {
if (f.length != getOrder() + 1) {
throw new DimensionMismatchException(f.length, getOrder() + 1);
}
@@ -704,13 +688,12 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
* @since 3.2
*/
@Override
- public DerivativeStructure pow(final DerivativeStructure e)
- throws DimensionMismatchException {
+ public DerivativeStructure pow(final DerivativeStructure e) {
compiler.checkCompatibility(e.compiler);
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.pow(data, 0, e.data, 0, result.data, 0);
@@ -831,8 +814,7 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
* @since 3.2
*/
@Override
- public DerivativeStructure atan2(final DerivativeStructure x)
- throws DimensionMismatchException {
+ public DerivativeStructure atan2(final DerivativeStructure x) {
compiler.checkCompatibility(x.compiler);
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.atan2(data, 0, x.data, 0, result.data, 0);
@@ -843,12 +825,11 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
* @param y first argument of the arc tangent
* @param x second argument of the arc tangent
* @return atan2(y, x)
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
* @since 3.2
*/
- public static DerivativeStructure atan2(final DerivativeStructure y, final
DerivativeStructure x)
- throws DimensionMismatchException {
+ public static DerivativeStructure atan2(final DerivativeStructure y, final
DerivativeStructure x) {
return y.atan2(x);
}
@@ -937,21 +918,20 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
/** Evaluate Taylor expansion a derivative structure.
* @param delta parameters offsets (Δx, Δy, ...)
* @return value of the Taylor expansion at x + Δx, y + Δy, ...
- * @throws MathArithmeticException if factorials becomes too large
+ * @throws
org.apache.commons.math4.legacy.exception.MathArithmeticException
+ * if factorials becomes too large
*/
- public double taylor(final double ... delta) throws
MathArithmeticException {
+ public double taylor(final double ... delta) {
return compiler.taylor(data, 0, delta);
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
* @since 3.2
*/
@Override
- public DerivativeStructure linearCombination(final DerivativeStructure[]
a, final DerivativeStructure[] b)
- throws DimensionMismatchException {
-
+ public DerivativeStructure linearCombination(final DerivativeStructure[]
a, final DerivativeStructure[] b) {
// compute an accurate value, taking care of cancellations
final double[] aDouble = new double[a.length];
for (int i = 0; i < a.length; ++i) {
@@ -977,14 +957,12 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
* @since 3.2
*/
@Override
- public DerivativeStructure linearCombination(final double[] a, final
DerivativeStructure[] b)
- throws DimensionMismatchException {
-
+ public DerivativeStructure linearCombination(final double[] a, final
DerivativeStructure[] b) {
// compute an accurate value, taking care of cancellations
final double[] bDouble = new double[b.length];
for (int i = 0; i < b.length; ++i) {
@@ -1006,15 +984,13 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
* @since 3.2
*/
@Override
public DerivativeStructure linearCombination(final DerivativeStructure a1,
final DerivativeStructure b1,
- final DerivativeStructure a2,
final DerivativeStructure b2)
- throws DimensionMismatchException {
-
+ final DerivativeStructure a2,
final DerivativeStructure b2) {
// compute an accurate value, taking care of cancellations
final double accurateValue = Sum.create()
.addProduct(a1.getValue(), b1.getValue())
@@ -1030,15 +1006,13 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
* @since 3.2
*/
@Override
public DerivativeStructure linearCombination(final double a1, final
DerivativeStructure b1,
- final double a2, final
DerivativeStructure b2)
- throws DimensionMismatchException {
-
+ final double a2, final
DerivativeStructure b2) {
// compute an accurate value, taking care of cancellations
final double accurateValue = Sum.create()
.addProduct(a1, b1.getValue())
@@ -1055,16 +1029,14 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
* @since 3.2
*/
@Override
public DerivativeStructure linearCombination(final DerivativeStructure a1,
final DerivativeStructure b1,
final DerivativeStructure a2,
final DerivativeStructure b2,
- final DerivativeStructure a3,
final DerivativeStructure b3)
- throws DimensionMismatchException {
-
+ final DerivativeStructure a3,
final DerivativeStructure b3) {
// compute an accurate value, taking care of cancellations
final double accurateValue = Sum.create()
.addProduct(a1.getValue(), b1.getValue())
@@ -1082,16 +1054,14 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
* @since 3.2
*/
@Override
public DerivativeStructure linearCombination(final double a1, final
DerivativeStructure b1,
final double a2, final
DerivativeStructure b2,
- final double a3, final
DerivativeStructure b3)
- throws DimensionMismatchException {
-
+ final double a3, final
DerivativeStructure b3) {
// compute an accurate value, taking care of cancellations
final double accurateValue = Sum.create()
.addProduct(a1, b1.getValue())
@@ -1108,7 +1078,7 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
* @since 3.2
*/
@@ -1116,9 +1086,7 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
public DerivativeStructure linearCombination(final DerivativeStructure a1,
final DerivativeStructure b1,
final DerivativeStructure a2,
final DerivativeStructure b2,
final DerivativeStructure a3,
final DerivativeStructure b3,
- final DerivativeStructure a4,
final DerivativeStructure b4)
- throws DimensionMismatchException {
-
+ final DerivativeStructure a4,
final DerivativeStructure b4) {
// compute an accurate value, taking care of cancellations
final double accurateValue = Sum.create()
.addProduct(a1.getValue(), b1.getValue())
@@ -1136,7 +1104,7 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
}
/** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
+ * @throws DimensionMismatchException if number of free parameters
* or orders do not match
* @since 3.2
*/
@@ -1144,9 +1112,7 @@ public class DerivativeStructure implements
RealFieldElement<DerivativeStructure
public DerivativeStructure linearCombination(final double a1, final
DerivativeStructure b1,
final double a2, final
DerivativeStructure b2,
final double a3, final
DerivativeStructure b3,
- final double a4, final
DerivativeStructure b4)
- throws DimensionMismatchException {
-
+ final double a4, final
DerivativeStructure b4) {
// compute an accurate value, taking care of cancellations
final double accurateValue = Sum.create()
.addProduct(a1, b1.getValue())
diff --git
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/MultivariateDifferentiableFunction.java
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/MultivariateDifferentiableFunction.java
index e6c050435..39a5437cf 100644
---
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/MultivariateDifferentiableFunction.java
+++
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/MultivariateDifferentiableFunction.java
@@ -18,7 +18,6 @@
package org.apache.commons.math4.legacy.analysis.differentiation;
import org.apache.commons.math4.legacy.analysis.MultivariateFunction;
-import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
/**
* Extension of {@link MultivariateFunction} representing a
@@ -26,17 +25,14 @@ import
org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
* @since 3.1
*/
public interface MultivariateDifferentiableFunction extends
MultivariateFunction {
-
/**
* Compute the value for the function at the given point.
*
* @param point Point at which the function must be evaluated.
* @return the function value for the given point.
- * @exception MathIllegalArgumentException if {@code point} does not
- * satisfy the function's constraints (wrong dimension, argument out of
bound,
- * or unsupported derivative order for example)
+ * @throws
org.apache.commons.math4.legacy.exception.MathIllegalArgumentException
+ * if {@code point} does not satisfy the function's constraints (wrong
dimension,
+ * argument out of bound, or unsupported derivative order for example).
*/
- DerivativeStructure value(DerivativeStructure[] point)
- throws MathIllegalArgumentException;
-
+ DerivativeStructure value(DerivativeStructure[] point);
}
diff --git
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/UnivariateDifferentiableFunction.java
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/UnivariateDifferentiableFunction.java
index 1adf189bc..e961da2be 100644
---
a/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/UnivariateDifferentiableFunction.java
+++
b/commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/analysis/differentiation/UnivariateDifferentiableFunction.java
@@ -17,7 +17,6 @@
package org.apache.commons.math4.legacy.analysis.differentiation;
import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
-import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
/** Interface for univariate functions derivatives.
* <p>This interface represents a simple function which computes
@@ -34,10 +33,8 @@ public interface UnivariateDifferentiableFunction extends
UnivariateFunction {
* value and the first derivative of the function.</p>
* @param t function input value
* @return function result
- * @exception DimensionMismatchException if t is inconsistent with the
- * function's free parameters or order
+ * @throws
org.apache.commons.math4.legacy.exception.DimensionMismatchException
+ * if {@code t} is inconsistent with the function's free parameters or
order.
*/
- DerivativeStructure value(DerivativeStructure t)
- throws DimensionMismatchException;
-
+ DerivativeStructure value(DerivativeStructure t);
}
