/// <summary>Creates a new <see cref="MultiDimOptimizer.IConstraint"/> object.
/// </summary>
/// <param name="polynomialConstraint">The specific constraints in its <see cref="MultiDimRegion.Polynomial"/> representation.</param>
/// <returns>A specific <see cref="MultiDimOptimizer.IConstraint"/> object with respect to the specified optimization algorithm.</returns>
/// <exception cref="InvalidOperationException">Thrown, if the optimization algorithm does not support this kind of constraints.</exception>
public MultiDimOptimizer.IConstraint Create(MultiDimRegion.Polynomial polynomialConstraint)
{
if (SupportedConstraints.HasFlag(ConstraintType.Polynomial) == true)
{
return(new MultiDimOptimizerConstraint(this, polynomialConstraint));
}
throw new InvalidOperationException();
}
/// <summary>Creates a specific (one-side) NLopt constraint which is specified in its <see cref="MultiDimRegion.Polynomial"/> representation.
/// </summary>
/// <param name="polynomialConstraint">The polynomial constraint.</param>
/// <param name="lowerBound">The lower bound.</param>
/// <param name="sign">The sign.</param>
/// <returns>The specific <see cref="NLoptConstraint"/> object.</returns>
private NLoptConstraint CreateSingle(MultiDimRegion.Polynomial polynomialConstraint, double lowerBound, int sign = 1)
{
NLoptInequalityConstraintFunction c = (n, x, grad, data) =>
{
double polynomialValue = 0.0;
foreach (var term in polynomialConstraint.Terms)
{
double temp = 0.0;
foreach (var monomial in term.Item2)
{
temp += DoMath.Pow(x[monomial.ArgumentIndex], monomial.Power);
}
polynomialValue += term.Item1 * temp;
}
if (grad != null)
{
for (int j = 0; j < n; j++)
{
grad[j] = 0.0;
}
foreach (var term in polynomialConstraint.Terms)
{
foreach (var monomial in term.Item2)
{
grad[monomial.ArgumentIndex] -= term.Item1 * monomial.Power * DoMath.Pow(x[monomial.ArgumentIndex], monomial.Power - 1);
}
}
}
return(sign * (lowerBound - polynomialValue));
};
return(new NLoptConstraint(this,
polynomialConstraint.Dimension,
"Polynomial constraint",
nloptPtr =>
{
var code = nloptPtr.AddInequalityConstraint(c, MachineConsts.Epsilon);
if (code != NLoptResultCode.Success)
{
throw new InvalidOperationException(String.Format("Constraint can not be set to NLopt algorithm {0}; error code: {1}.", nloptPtr.ToString(), code));
}
}
));
}
/// <summary>Creates a new <see cref="NLoptConstraint"/> object.
/// </summary>
/// <param name="polynomialConstraint">The specific constraints in its <see cref="MultiDimRegion.Polynomial"/> representation.</param>
/// <returns>A specific <see cref="NLoptConstraint"/> object with respect to the specified optimization algorithm.</returns>
/// <exception cref="InvalidOperationException">Thrown, if the optimization algorithm does not support this kind of constraints.</exception>
public NLoptConstraint Create(MultiDimRegion.Polynomial polynomialConstraint)
{
if (polynomialConstraint == null)
{
throw new ArgumentNullException(nameof(polynomialConstraint));
}
if (nloptMultiDimOptimizer.Configuration.NonlinearConstraintRequirement.HasFlag(NLoptNonlinearConstraintRequirement.SupportsInequalityConstraints) == false)
{
throw new InvalidOperationException("The NLopt algorithm does not support linear inequality for polynomial constraints");
}
/* we split the constraint to at most two NLopt constraints c_1(x) <= \epsilon and c_2(x) <= \epsilon, where
* c_1(x) = P(x) - upper bound,
* c_2(x) = lower bound - P(x),
* where P(x) is the polynomial representation of the constraint.
*
* We use the NLopt vector constraint representation to combine both constraint, because the evaluation is almost identically.
*/
if ((Double.IsNegativeInfinity(polynomialConstraint.LowerBound) == false) && (Double.IsPositiveInfinity(polynomialConstraint.UpperBound) == false))
{
NLoptVectorInequalityConstraintFunction c = (m, result, n, x, grad, data) =>
{
double polynomialValue = 0.0;
foreach (var term in polynomialConstraint.Terms)
{
double temp = 0.0;
foreach (var monomial in term.Item2)
{
temp += DoMath.Pow(x[monomial.ArgumentIndex], monomial.Power);
}
polynomialValue += term.Item1 * temp;
}
if (grad != null)
{
for (int j = 0; j < n; j++)
{
grad[j] = 0.0;
}
foreach (var term in polynomialConstraint.Terms)
{
foreach (var monomial in term.Item2)
{
grad[monomial.ArgumentIndex] -= term.Item1 * monomial.Power * DoMath.Pow(x[monomial.ArgumentIndex], monomial.Power - 1);
}
}
}
result[0] = polynomialValue - polynomialConstraint.UpperBound;
result[1] = polynomialConstraint.LowerBound - polynomialValue;
};
var tolerance = new[] { MachineConsts.Epsilon, MachineConsts.Epsilon };
return(new NLoptConstraint(this,
polynomialConstraint.Dimension,
"Polynomial constraint",
nloptPtr =>
{
var code = nloptPtr.AddInequalityConstraint(c, 2, tolerance);
if (code != NLoptResultCode.Success)
{
throw new InvalidOperationException(String.Format("Constraint can not be set to NLopt algorithm {0}; error code: {1}.", nloptPtr.ToString(), code));
}
}
));
}
else if (Double.IsNegativeInfinity(polynomialConstraint.LowerBound) == false)
{
return(CreateSingle(polynomialConstraint, polynomialConstraint.LowerBound, sign: 1));
}
else
{
return(CreateSingle(polynomialConstraint, polynomialConstraint.UpperBound, sign: -1));
}
}
/// <summary>Creates a new <see cref="MultiDimOptimizer.IConstraint"/> object.
/// </summary>
/// <param name="polynomialConstraint">The specific constraints in its <see cref="MultiDimRegion.Polynomial"/> representation.</param>
/// <returns>A specific <see cref="MultiDimOptimizer.IConstraint"/> object with respect to the specified optimization algorithm.</returns>
/// <exception cref="InvalidOperationException">Thrown, if the optimization algorithm does not support this kind of constraints.</exception>
MultiDimOptimizer.IConstraint MultiDimOptimizer.IConstraintFactory.Create(MultiDimRegion.Polynomial polynomialConstraint)
{
return(this.Create(polynomialConstraint));
}
