public virtual bool Overlaps(Range <T> range)
{
if (range == null || ReferenceEquals(range, Empty))
{
return(false);
}
bool overlaps = _lowerBound.Touches(range._upperBound) ||
_upperBound.Touches(range._lowerBound) ||
(LowerBound.IsLessThan(range.UpperBound) && UpperBound.IsMoreThan(range.LowerBound));
return(overlaps);
}
/// <inheritdoc />
public override int GetHashCode()
{
unchecked
{
var hash = 17;
hash = hash * 31 + LowerBound.GetHashCode();
if (UpperBound != null)
{
hash = hash * 31 + UpperBound.GetHashCode();
}
return(hash);
}
}
/// <summary>
/// Checks whether two Buckets are equal; this method tolerates a difference in lowerbound, upperbound
/// and count given by <seealso cref="Precision.AlmostEqual(double,double)"/>.
/// </summary>
public override bool Equals(object obj)
{
if (!(obj is Bucket))
{
return(false);
}
var bucket = (Bucket)obj;
return(LowerBound.AlmostEqual(bucket.LowerBound) &&
UpperBound.AlmostEqual(bucket.UpperBound) &&
Count.AlmostEqual(bucket.Count));
}
/// <summary>
/// Gets corresponding package floating version string.
/// </summary>
public string ToString(bool forcePreRelease)
{
if (LowerBound.HasValue || UpperBound.HasValue)
{
var value = new StringBuilder();
var suffix = (forcePreRelease || (LowerBound.HasValue ? LowerBound.IsPreRelease : UpperBound.IsPreRelease))
? "-*"
: "";
if (!UpperBound.HasValue && !LowerBoundExclusive)
{
// minimum version
return($"[{LowerBound.AnyToZero()}{suffix},]");
}
value.Append(LowerBoundExclusive ? '(' : '[');
if (LowerBound.HasValue)
{
value.Append(LowerBound.AnyToZero().ToString());
value.Append(suffix);
if (UpperBound.HasValue && !LowerBoundExclusive && LowerBound == UpperBound)
{
// exact [version]
value.Append(suffix.Length == 0 ? "]" : ",]");
return(value.ToString());
}
}
value.Append(',');
if (UpperBound.HasValue)
{
// upper bound does not allow asteriks
Debug.Assert(!UpperBound.IsAnyMajor && !UpperBound.IsAnyMinor && !UpperBound.IsAnyBuild);
value.Append(UpperBound.ToString());
}
value.Append(UpperBoundExclusive ? ')' : ']');
// [lower,upper]
return(value.ToString());
}
else
{
//
return(forcePreRelease ? "0.0.0-*" : "*");
}
}
protected override SqlStatement PrepareExpressions(ISqlExpressionPreparer preparer)
{
var lower = LowerBound.Prepare(preparer);
var upper = UpperBound.Prepare(preparer);
var loop = new ForLoopStatement(IndexName, lower, upper, Reverse);
foreach (var statement in Statements)
{
loop.Statements.Add(statement);
}
return(loop);
}
/// <summary>
/// Performs validation for this node.
/// </summary>
/// <param name="errors">The list of errors to add any validation errors.</param>
public override void Validate(IList <ValidationError> errors)
{
if (UpperBound != null && UpperBoundType != ValidationRangeBoundaryType.Ignore)
{
if (LowerBound != null && LowerBoundType != ValidationRangeBoundaryType.Ignore)
{
if (LowerBound.CompareTo(UpperBound) > 0)
{
errors.Add(new ValidationError(this, "UpperBound", Resources.UpperBoundShouldBeGeaterThanLowerBound));
}
}
}
base.Validate(errors);
}
/// <summary>
/// Whether an element is contained in the interval
/// </summary>
public bool Contains(T element)
{
var satisfyLowerConstraint = (LowerBoundType == IntervalBoundType.Unbounded) ||
(LowerBoundType == IntervalBoundType.Closed
? LowerBound.CompareTo(element) <= 0
: LowerBound.CompareTo(element) < 0);
var satisfyUpperConstraint = (UpperBoundType == IntervalBoundType.Unbounded) ||
(UpperBoundType == IntervalBoundType.Closed
? element.CompareTo(UpperBound) <= 0
: element.CompareTo(UpperBound) < 0);
return(satisfyLowerConstraint && satisfyUpperConstraint);
}
public bool Equals(BalancedBoundingNode other)
{
if (other == null)
{
return(false);
}
return(ReferenceEquals(UpperTree, other.UpperTree) &&
ReferenceEquals(LowerTree, other.LowerTree) &&
ReferenceEquals(Parent, other.Parent) &&
ReferenceEquals(Value, other.Value) &&
LowerBound.Equals(other.LowerBound) &&
UpperBound.Equals(other.UpperBound) &&
NodeColour.Equals(other.NodeColour));
}
public void LowerBoundLowerBoundCompare(LowerBound <int> a, LowerBound <int> b, int cmp)
{
if (cmp < 0)
{
AssertLess(a, b);
}
else if (cmp > 0)
{
AssertGreater(a, b);
}
else
{
AssertEquals(a, b);
}
}
public void LowerBound()
{
int[] data = new[] { 1, 2, 4, 5, 5, 6 };
var lowerBound = new LowerBound <int>(data);
int index = -1;
Assert.IsTrue(lowerBound.Find(0, out index) && index == 0);
Assert.IsTrue(lowerBound.Find(1, out index) && index == 0);
Assert.IsTrue(lowerBound.Find(2, out index) && index == 1);
Assert.IsTrue(lowerBound.Find(3, out index) && index == 2);
Assert.IsTrue(lowerBound.Find(4, out index) && index == 2);
Assert.IsTrue(lowerBound.Find(5, out index) && index == 3);
Assert.IsTrue(lowerBound.Find(6, out index) && index == 5);
Assert.IsTrue(false == lowerBound.Find(7, out index) && index == -1);
}
public string AsCsvString() =>
LoopIndex.ToString()
.ConcatCsv(MonitoringScheme.AsString())
.ConcatCsv(VectorLength.ToString())
.ConcatCsv(NumOfNodes.ToString())
.ConcatCsv(Approximation.AsString())
.ConcatCsv(Communication.Bandwidth.ToString())
.ConcatCsv(Communication.UdpBandwidth.ToString())
.ConcatCsv(Communication.Messages.ToString())
.ConcatCsv(Communication.UdpMessages.ToString())
.ConcatCsv(Communication.Latency.ToString())
.ConcatCsv(NumberOfFullSyncs.ToString())
.ConcatCsv(LowerBound.AsCsvString())
.ConcatCsv(FunctionValue.ToString(CultureInfo.InvariantCulture))
.ConcatCsv(UpperBound.AsCsvString())
.ConcatCsv(NodesFunctionValues.Aggregate("", (csv, value) => csv.ConcatCsv(value.ToString(CultureInfo.InvariantCulture))));
public override void SaveToXml(XmlElement xml)
{
base.SaveToXml(xml);
if (Expr != null)
{
Expr.SaveToXml(xml.AddChild("Expr"));
}
if (LowerBound != null)
{
LowerBound.SaveToXml(xml.AddChild("LowerBound"));
}
if (UpperBound != null)
{
UpperBound.SaveToXml(xml.AddChild("UpperBound"));
}
}
public override void ForEachChild(Action <IDmlfNode> action)
{
base.ForEachChild(action);
if (Expr != null)
{
Expr.ForEachChild(action);
}
if (LowerBound != null)
{
LowerBound.ForEachChild(action);
}
if (UpperBound != null)
{
UpperBound.ForEachChild(action);
}
}
public bool Contains(T point)
{
if (LowerBound.GetType() != typeof(T) ||
UpperBound.GetType() != typeof(T))
{
throw new ArgumentException("Type mismatch", "point");
}
var lower = LowerBoundIntervalType == IntervalType.Open
? LowerBound.CompareTo(point) < 0
: LowerBound.CompareTo(point) <= 0;
var upper = UpperBoundIntervalType == IntervalType.Open
? UpperBound.CompareTo(point) > 0
: UpperBound.CompareTo(point) >= 0;
return(lower && upper);
}
public override double GetValue(double x, double y, double z)
{
double value = SourceModule.GetValue(x, y, z);
double lower = LowerBound.GetValue(x, y, z);
double upper = UpperBound.GetValue(x, y, z);
if (value < lower)
{
return(lower);
}
else if (value > upper)
{
return(upper);
}
return(value);
}
public override double GetWrapped(double x, double y, int wrap)
{
double value = SourceModule.GetWrapped(x, y, wrap);
double lower = LowerBound.GetWrapped(x, y, wrap);
double upper = UpperBound.GetWrapped(x, y, wrap);
if (value < lower)
{
return(lower);
}
else if (value > upper)
{
return(upper);
}
return(value);
}
/// <summary>
/// Splits the range into two.
/// </summary>
/// <param name="position">The position to split the range at.</param>
/// <returns>The split ranges.</returns>
/// <exception cref="System.ArgumentNullException"><code>position</code> is null.</exception>
/// <exception cref="System.ArgumentException"><code>position</code> is not contained within the range.</exception>
public IEnumerable <Range <T> > Split(T position)
{
Assert.NotNull("position", (object)position);
Assert.IsTrue("position", Contains(position));
if ((LowerBound.CompareTo(position) == 0) || (UpperBound.CompareTo(position) == 0))
{
// The position is at a boundary, so a split does not happen
yield return(this);
}
else
{
yield return(Range.Create(LowerBound, position));
yield return(Range.Create(position, UpperBound));
}
}
/// <summary>
/// Splits the range into two.
/// </summary>
/// <param name="position">The position to split the range at.</param>
/// <returns>The split ranges.</returns>
/// <exception cref="System.ArgumentNullException"><code>position</code> is null.</exception>
/// <exception cref="System.ArgumentException"><code>position</code> is not contained within the range.</exception>
public IEnumerable <Range <T> > Split(T position)
{
Guard.IsNotNull(position, "position");
Guard.IsTrue(Contains(position), "position");
if ((LowerBound.CompareTo(position) == 0) || (UpperBound.CompareTo(position) == 0))
{
// The position is at a boundary, so a split does not happen
yield return(this);
}
else
{
yield return(Range.Create(LowerBound, position));
yield return(Range.Create(position, UpperBound));
}
}
bool EvaluateExtracted(object extracted)
{
if (extracted == null || LowerBound == null || UpperBound == null)
{
return(false);
}
var lower = LowerBound.CompareTo(extracted);
if (lower > 0 || (!IsLowerBoundInclusive && lower == 0))
{
return(false);
}
var upper = UpperBound.CompareTo(extracted);
return(upper > 0 || (IsUpperBoundInclusive && upper == 0));
}
/// <summary>
/// Returns the range that represents the union of this range and <code>value</code>.
/// </summary>
/// <param name="value">The range to union with.</param>
/// <returns>A range that contains both ranges, or null if there is no union.</returns>
/// <exception cref="System.ArgumentNullException"><code>value</code> is null.</exception>
/// <exception cref="System.ArgumentException"><code>value</code> is not contiguous with the range.</exception>
public Range <T> Union(Range <T> value)
{
Guard.IsNotNull(value, "value");
Guard.IsTrue(IsContiguousWith(value), "value"); // Union makes no sense unless there is a contiguous border
// If either one is a subset of the other, then is it the union
if (Contains(value))
{
return(this);
}
if (value.Contains(this))
{
return(value);
}
var start = LowerBound.CompareTo(value.LowerBound) < 0 ? LowerBound : value.LowerBound;
return(UpperBound.CompareTo(value.UpperBound) > 0 ? new Range <T>(start, UpperBound) : new Range <T>(start, value.UpperBound));
}
public override string ToString()
{
if (IsTop)
{
return("_TOP_");
}
if (IsBottom)
{
return("_BOTTOM_");
}
var result = String.Format(CultureInfo.InvariantCulture, "[{0}..{1}]", LowerBound, UpperBound);
if (LowerBound == UpperBound)
{
result = LowerBound.ToString();
}
return(result);
}
public int CompareTo(NumericRangeFilter other)
{
if (ReferenceEquals(this, other))
{
return(0);
}
if (ReferenceEquals(null, other))
{
return(1);
}
var lowerBoundComparison = LowerBound.CompareTo(other.LowerBound);
return(lowerBoundComparison != 0
? lowerBoundComparison
: UpperBound.CompareTo(other.UpperBound));
}
/// <summary>
/// Perform one optimization run and return the best found solution.
/// </summary>
/// <param name="parameters">Control parameters for the optimizer.</param>
public override Result Optimize(double[] parameters)
{
Debug.Assert(parameters != null && parameters.Length == Dimensionality);
// Signal beginning of optimization run.
Problem.BeginOptimizationRun();
// Retrieve parameter specific to this optimizer.
int numIterationsPerDim = GetNumIterationsPerDim(parameters);
Debug.Assert(numIterationsPerDim >= 1);
// Get problem-context.
double[] lowerBound = Problem.LowerBound;
double[] upperBound = Problem.UpperBound;
int n = Problem.Dimensionality;
// Allocate mesh position and mesh-incremental values.
double[] x = new double[n]; // Mesh position.
double[] delta = new double[n]; // Mesh incremental values.
double[] g = new double[n]; // Best found position for this run.
double gFitness = Problem.MaxFitness; // Fitness for best found position.
bool gFeasible = false; // Feasibility for best found position.
// Initialize mesh position to the lower boundary.
LowerBound.CopyTo(x, 0);
// Compute mesh incremental values for all dimensions.
for (int i = 0; i < n; i++)
{
delta[i] = (upperBound[i] - lowerBound[i]) / (numIterationsPerDim - 1);
}
// Start recursive traversal of mesh.
Recursive(0, numIterationsPerDim, delta, ref x, ref g, ref gFitness, ref gFeasible);
// Signal end of optimization run.
Problem.EndOptimizationRun();
// Return best-found solution and fitness.
return(new Result(g, gFitness, gFeasible, (int)System.Math.Pow(numIterationsPerDim, n)));
}
protected override async Task InitializeAsync(StatementContext context)
{
var lowerBound = await LowerBound.ReduceToConstantAsync(context);
var upperBound = await UpperBound.ReduceToConstantAsync(context);
context.Metadata["lowerBound"] = lowerBound;
context.Metadata["upperBound"] = upperBound;
if (Reverse)
{
context.AssignVariable(IndexName, SqlExpression.Constant(upperBound));
}
else
{
context.AssignVariable(IndexName, SqlExpression.Constant(lowerBound));
}
await base.InitializeAsync(context);
}
/// <summary>
/// Comparison of two disjoint buckets. The buckets cannot be overlapping.
/// </summary>
public int CompareTo(Bucket bucket)
{
if (UpperBound > bucket.LowerBound && LowerBound < bucket.LowerBound)
{
throw new ArgumentException(Resource.PartialOrderException);
}
if (UpperBound.AlmostEqual(bucket.UpperBound) &&
LowerBound.AlmostEqual(bucket.LowerBound))
{
return(0);
}
if (bucket.UpperBound <= LowerBound)
{
return(1);
}
return(-1);
}
/// <summary>
/// Compares this instance to a specified <see cref="Interval<T>"/> and returns an indication of their relative values.
/// </summary>
/// <param name="other">A <see cref="Interval<T>"/> to compare to this instance.</param>
/// <returns>
/// A signed number indicating the relative values of this instance and the <paramref name="other"/>.
/// <list type="table">
/// <listheader>
/// <term>Value Type</term>
/// <description>Condition</description>
/// </listheader>
/// <item>
/// <term>Less than zero</term>
/// <description>This instance is less than the <paramref name="other"/>.</description>
/// </item>
/// <item>
/// <term>Zero</term>
/// <description>This instance is equal to the <paramref name="other"/>.</description>
/// </item>
/// <item>
/// <term>Greater than zero</term>
/// <description>This instance is greater than the <paramref name="other"/>.</description>
/// </item>
///</list>
/// </returns>
/// <remarks>
/// Comparison does not rely on the number of elements contained in the <see cref="Interval<T>"/>
/// but it is rather based on first the <see cref="LowerBound"/> and then the <see cref="UpperBound"/>.
/// </remarks>
/// <exception cref="ArgumentNullException"><paramref name="other"/> is null.</exception>
public int CompareTo(Interval <T> other)
{
if (other == null)
{
throw new ArgumentNullException("other");
}
if (this.IsEmpty && !other.IsEmpty)
{
return(-1);
}
if (!this.IsEmpty && other.IsEmpty)
{
return(1);
}
return((LowerBound.CompareTo(other.LowerBound) == 0)
? UpperBound.CompareTo(other.UpperBound)
: LowerBound.CompareTo(other.LowerBound));
}
/// <summary>
/// Comparison of two disjoint buckets. The buckets cannot be overlapping.
/// </summary>
/// <returns>
/// 0 if <c>UpperBound</c> and <c>LowerBound</c> are bit-for-bit equal
/// 1 if This bucket is lower that the compared bucket
/// -1 otherwise
/// </returns>
public int CompareTo(Bucket bucket)
{
if (UpperBound > bucket.LowerBound && LowerBound < bucket.LowerBound)
{
throw new ArgumentException("The two arguments can\'t be compared (maybe they are part of a partial ordering?)");
}
if (UpperBound.Equals(bucket.UpperBound) &&
LowerBound.Equals(bucket.LowerBound))
{
return(0);
}
if (bucket.UpperBound <= LowerBound)
{
return(1);
}
return(-1);
}
public StyblinskiTang()
{
this.Dimension = 10;
this.LowerBound = new double[Dimension];
LowerBound = LowerBound.Select(i => - 10.0).ToArray();
this.UpperBound = new double[Dimension];
UpperBound = UpperBound.Select(i => 10.0).ToArray();
this.ObjectiveFunction = (x) =>
{
double f = 0.0;
for (int i = 0; i < x.Length; i++)
{
f += Math.Pow(x[i], 4) - 16 * Math.Pow(x[i], 2) + 5 * x[i];
}
return(f / 2.0);
};
}
public Sphere()
{
this.Dimension = 10;
this.LowerBound = new double[Dimension];
LowerBound = LowerBound.Select(i => - 10.0).ToArray();
this.UpperBound = new double[Dimension];
UpperBound = UpperBound.Select(i => 10.0).ToArray();
this.ObjectiveFunction = (x) =>
{
double f = 0.0;
for (int i = 0; i < x.Length; i++)
{
f += x[i] * x[i];
}
return(f);
};
}
/// <summary>
/// Validate the range data for the given <paramref name="instance"/> and the <paramref name="propertyInfo"/>.
/// </summary>
/// <param name="instance">
/// The instance to validate.
/// </param>
/// <param name="propertyInfo">
/// The property containing the value to validate.
/// </param>
/// <param name="errors">
/// The collection to add any errors that occur durring the validation.
/// </param>
protected override void ValidateCore(object instance, PropertyInfo propertyInfo, IList <ValidationError> errors)
{
object propertyValue = propertyInfo.GetValue(instance, null);
if (propertyValue == null)
{
return;
}
IComparable compareToObject = (IComparable)propertyValue;
int lowerBoundGreaterThanValue = LowerBound.CompareTo(compareToObject);
int upperBoundLessThanValue = UpperBound.CompareTo(compareToObject);
bool addError = false;
if ((lowerBoundGreaterThanValue != 0) && (LowerBoundType != RangeBoundaryType.Exclusive))
{
addError = true;
}
if (lowerBoundGreaterThanValue < 0)
{
addError = true;
}
if ((upperBoundLessThanValue != 0) && (UpperBoundType != RangeBoundaryType.Exclusive))
{
addError = true;
}
if (upperBoundLessThanValue > 0)
{
addError = true;
}
if (addError)
{
string name = propertyInfo.Name;
errors.Add(new ValidationError(instance as ConfigurationNode, name, string.Format(CultureInfo.CurrentUICulture, Resources.ValueOutsideRangeErrorMessage, name)));
}
}
public LowerBound Tighten(LowerBound newBound)
{
base.Validate(newBound);
return newBound > this ? newBound : this;
}
