//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class) public void testFunctionIndexOutOfRange2()
public virtual void testFunctionIndexOutOfRange2()
{
BasisFunctionKnots k = BasisFunctionKnots.fromKnots(KNOTS, 5);
int nS = k.NumSplines;
GENERATOR.generate(k, nS);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testInternalKnots()
public virtual void testInternalKnots()
{
BasisFunctionKnots knots = BasisFunctionKnots.fromInternalKnots(KNOTS, 2);
assertEquals(2, knots.Degree);
assertEquals(15, knots.NumKnots);
assertEquals(12, knots.NumSplines);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testUniform()
public virtual void testUniform()
{
BasisFunctionKnots knots = BasisFunctionKnots.fromUniform(1.0, 2.0, 10, 3);
assertEquals(3, knots.Degree);
assertEquals(16, knots.NumKnots);
assertEquals(12, knots.NumSplines);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testKnots()
public virtual void testKnots()
{
BasisFunctionKnots knots = BasisFunctionKnots.fromKnots(KNOTS, 3);
assertEquals(3, knots.Degree);
assertEquals(11, knots.NumKnots);
assertEquals(7, knots.NumSplines);
ArrayAsserts.assertArrayEquals(KNOTS, knots.Knots, 1e-15);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testFirstOrder()
public virtual void testFirstOrder()
{
BasisFunctionKnots knots = BasisFunctionKnots.fromInternalKnots(KNOTS, 1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.function.Function<double, double> func = GENERATOR.generate(knots, 3);
System.Func <double, double> func = GENERATOR.generate(knots, 3);
assertEquals(0.0, func(1.76), 0.0);
assertEquals(1.0, func(3.0), 0.0);
assertEquals(0, func(4.0), 0.0);
assertEquals(0.5, func(2.5), 0.0);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testThreeD()
public virtual void testThreeD()
{
BasisFunctionKnots knots1 = BasisFunctionKnots.fromInternalKnots(KNOTS, 2);
BasisFunctionKnots knots2 = BasisFunctionKnots.fromInternalKnots(KNOTS, 3);
BasisFunctionKnots knots3 = BasisFunctionKnots.fromInternalKnots(KNOTS, 1);
IList <System.Func <double[], double> > set = GENERATOR.generateSet(new BasisFunctionKnots[] { knots1, knots2, knots3 });
//pick of one of the basis functions for testing
int index = FunctionUtils.toTensorIndex(new int[] { 3, 3, 3 }, new int[] { knots1.NumSplines, knots2.NumSplines, knots3.NumSplines });
System.Func <double[], double> func = set[index];
assertEquals(1.0 / 3.0, func(new double[] { 2.0, 2.0, 3.0 }), 0.0);
}
/// <summary>
/// Generate a set of b-splines with a given polynomial degree on the specified knots. </summary>
/// <param name="knots"> holder for the knots and degree </param>
/// <returns> a List of functions </returns>
public virtual IList <System.Func <double, double> > generateSet(BasisFunctionKnots knots)
{
ArgChecker.notNull(knots, "knots");
double[] k = knots.Knots;
IList <System.Func <double, double> > set = null;
for (int d = 0; d <= knots.Degree; d++)
{
set = generateSet(k, d, set);
}
return(set);
}
/// <summary>
/// Given a set of data {x_i ,y_i} where each x_i is a vector and the y_i are scalars, we wish to find a function (represented
/// by B-splines) that fits the data while maintaining smoothness in each direction. </summary>
/// <param name="x"> The independent (vector) variables, as List<double[]> </param>
/// <param name="y"> The dependent variables, as List<Double> y </param>
/// <param name="sigma"> The error (or tolerance) on the y variables </param>
/// <param name="xa"> The lowest value of x in each dimension </param>
/// <param name="xb"> The highest value of x in each dimension </param>
/// <param name="nKnots"> Number of knots in each dimension (note, the actual number of basis splines and thus fitted weights,
/// equals nKnots + degree-1) </param>
/// <param name="degree"> The degree of the basis function in each dimension - 0 is piecewise constant, 1 is a sawtooth function
/// (i.e. two straight lines joined in the middle), 2 gives three quadratic sections joined together, etc. For a large
/// value of degree, the basis function tends to a gaussian </param>
/// <param name="lambda"> The weight given to the penalty function in each dimension </param>
/// <param name="differenceOrder"> applies the penalty the nth order difference in the weights, so a differenceOrder of 2
/// will penalize large 2nd derivatives etc. A difference differenceOrder can be used in each dimension </param>
/// <returns> The results of the fit </returns>
public virtual GeneralizedLeastSquareResults <double[]> solve(IList <double[]> x, IList <double> y, IList <double> sigma, double[] xa, double[] xb, int[] nKnots, int[] degree, double[] lambda, int[] differenceOrder)
{
BasisFunctionKnots[] knots = new BasisFunctionKnots[xa.Length];
for (int i = 0; i < xa.Length; i++)
{
knots[i] = BasisFunctionKnots.fromUniform(xa[i], xb[i], nKnots[i], degree[i]);
}
IList <System.Func <double[], double> > bSplines = _generator.generateSet(knots);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int dim = xa.length;
int dim = xa.Length;
int[] sizes = new int[dim];
for (int i = 0; i < dim; i++)
{
sizes[i] = nKnots[i] + degree[i] - 1;
}
return(_gls.solve(x, y, sigma, bSplines, sizes, lambda, differenceOrder));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class) public void testDegreeToHigh2()
public virtual void testDegreeToHigh2()
{
BasisFunctionKnots.fromInternalKnots(KNOTS, 11);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class) public void testDegreeToHigh1()
public virtual void testDegreeToHigh1()
{
BasisFunctionKnots.fromUniform(0.0, 10.0, 11, 11);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class) public void testWrongOrderInternalKnots()
public virtual void testWrongOrderInternalKnots()
{
BasisFunctionKnots.fromInternalKnots(WRONG_ORDER_KNOTS, 3);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class) public void testWrongOrderUniform()
public virtual void testWrongOrderUniform()
{
BasisFunctionKnots.fromUniform(2.0, 1.0, 10, 3);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class) public void testNegDegree2()
public virtual void testNegDegree2()
{
BasisFunctionKnots.fromInternalKnots(KNOTS, -1);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class) public void testNegDegree()
public virtual void testNegDegree()
{
BasisFunctionKnots.fromKnots(KNOTS, -1);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class) public void testNullInternalKnots()
public virtual void testNullInternalKnots()
{
BasisFunctionKnots.fromInternalKnots(null, 2);
}
/// <summary>
/// Fits a curve to x-y data. </summary>
/// <param name="x"> The independent variables </param>
/// <param name="y"> The dependent variables </param>
/// <param name="sigma"> The error (or tolerance) on the y variables </param>
/// <param name="xa"> The lowest value of x </param>
/// <param name="xb"> The highest value of x </param>
/// <param name="nKnots"> Number of knots (note, the actual number of basis splines and thus fitted weights, equals nKnots + degree-1) </param>
/// <param name="degree"> The degree of the basis function - 0 is piecewise constant, 1 is a sawtooth function (i.e. two straight lines joined in the middle), 2 gives three
/// quadratic sections joined together, etc. For a large value of degree, the basis function tends to a gaussian </param>
/// <param name="lambda"> The weight given to the penalty function </param>
/// <param name="differenceOrder"> applies the penalty the nth order difference in the weights, so a differenceOrder of 2 will penalise large 2nd derivatives etc </param>
/// <returns> The results of the fit </returns>
public virtual GeneralizedLeastSquareResults <double> solve(IList <double> x, IList <double> y, IList <double> sigma, double xa, double xb, int nKnots, int degree, double lambda, int differenceOrder)
{
IList <System.Func <double, double> > bSplines = _generator.generateSet(BasisFunctionKnots.fromUniform(xa, xb, nKnots, degree));
return(_gls.solve(x, y, sigma, bSplines, lambda, differenceOrder));
}
/// <summary>
/// Generate the i^th basis function </summary>
/// <param name="data"> Container for the knots and degree of the basis function </param>
/// <param name="index"> The index (from zero) of the function. Must be in range 0 to data.getNumSplines() (exclusive)
/// For example if the degree is 1, and index is 0, this will cover the first three knots. </param>
/// <returns> The i^th basis function </returns>
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: protected java.util.function.Function<double, double> generate(BasisFunctionKnots data, final int index)
protected internal virtual System.Func <double, double> generate(BasisFunctionKnots data, int index)
{
ArgChecker.notNull(data, "data");
ArgChecker.isTrue(index >= 0 && index < data.NumSplines, "index must be in range {} to {} (exclusive)", 0, data.NumSplines);
return(generate(data.Knots, data.Degree, index));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class) public void testDegreeToHigh3()
public virtual void testDegreeToHigh3()
{
BasisFunctionKnots.fromKnots(KNOTS, 11);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class) public void testFunctionIndexOutOfRange1()
public virtual void testFunctionIndexOutOfRange1()
{
BasisFunctionKnots k = BasisFunctionKnots.fromKnots(KNOTS, 2);
GENERATOR.generate(k, -1);
}