public void TestInner()
{
Vector a = Vector.Create(1.0, 2.0);
Vector b = Vector.Create(-1.0, 3.0);
Assert.IsTrue(FloatComparison.Close(VectorOperations.Inner(a, b), 5.0, FloatComparison.DefaultEps));
}
/// <summary>
/// Select axis by cycling through dimensions at each depth level of tree
/// </summary>
public int Select <T> (KdNode <T> target) where T : IVector
{
IVector diagonal = target.InternalBounds.Diagonal;
int dims = target.InternalBounds.Dimensions;
// Setup initial axis
// On root level this is zero on each other level it the depth of the node module its dimensions
int axis = target.Depth % dims;
double spread = diagonal[axis];
int i = 0;
while (FloatComparison.CloseZero(spread, FloatComparison.DefaultEps) && i < dims)
{
axis = (axis + 1) % dims;
spread = diagonal[axis];
i += 1;
}
if (i == dims)
{
// Cycle completed without finding an axis that has a spread greater than zero
throw new DegenerateDatasetException();
}
return(axis);
}
public void Creating_a_DefaultComparison()
{
"When creating a DefaultComparison".x(() =>
SUT = new FloatComparison(0.1d, 0.1f)
);
"Then is should implement IComparison".x(() =>
SUT.ShouldBeAssignableTo <IComparison>()
);
}
/// <summary>
/// Select axis of maximum spread and test for degenerate data sets.
/// </summary>
public int Select <T> (KdNode <T> target) where T : IVector
{
// Use the internal bounds to detect degenerate data sets.
IVector diagonal = target.InternalBounds.Diagonal;
int max_spread_id = VectorReductions.IndexNormInf(diagonal);
// Sanity check for degenerate data-sets
if (FloatComparison.CloseZero(diagonal[max_spread_id], FloatComparison.DefaultEps))
{
throw new DegenerateDatasetException();
}
return(max_spread_id);
}
public void Can_compare_float_types(Type type1, Type type2, bool canCompare)
{
"Given a DefaultComparison".x(() =>
SUT = new FloatComparison(0.1d, 0.1f)
);
"When calling CanCompare".x(() =>
CanCompareResult = SUT.CanCompare(type1, type2)
);
"Then the result should be {2}".x(() =>
CanCompareResult.ShouldBe(canCompare)
);
}
/// <summary>
///
/// </summary>
/// <param name="valueA"></param>
/// <param name="valueB"></param>
/// <param name="floatComparison"></param>
/// <returns></returns>
private bool CompareFloat(float valueA, float valueB, FloatComparison floatComparison)
{
switch (floatComparison)
{
case FloatComparison.LessThan:
return(valueA < valueB); // float is less than value
case FloatComparison.EqualTo:
return(valueA == valueB); // float is equal to value
case FloatComparison.GreaterThan:
return(valueA > valueB); // float is greater than value
}
return(false);
}
private bool CompareFloat(float valueA, float valueB, FloatComparison floatComparison)
{
switch (floatComparison)
{
case FloatComparison.LessThan:
return(valueA < valueB);
case FloatComparison.EqualTo:
return(valueA == valueB);
case FloatComparison.GreaterThan:
return(valueA > valueB);
}
return(false);
}
/// <summary>
/// Selects the split location based on the median of the coordinates of all
/// elements in the split dimension.
/// </summary>
public double Select <T>(KdNode <T> target, int split_dimension) where T : IVector
{
// Sort based on chosen split-dimension
List <T> vecs = target.Vectors;
vecs.Sort(new SingleDimensionComparer <T>(split_dimension));
// Fetch median
int median_location = MedianLocation(vecs.Count);
double median_value = vecs[median_location][split_dimension];
// Verify that the coordinate of the last element has a value greater than the
// median value.
if (FloatComparison.Close(vecs[vecs.Count - 1][split_dimension], median_value, FloatComparison.DefaultEps))
{
throw new DegenerateDatasetException();
}
return(median_value);
}
public void Compares_floats_within_tolarance(
double doubleTolerance,
float singleTolerance,
object value1,
object value2,
ComparisonResult result)
{
"Given a DefaultComparison".x(() =>
SUT = new FloatComparison(doubleTolerance, singleTolerance)
);
"And a Comparison context object".x(() =>
Context = new ComparisonContext()
);
"When calling Compare".x(() =>
(Result, _) = SUT.Compare(Context, value1, value2)
);
"And it should return Pass".x(() =>
Result.ShouldBe(result)
);
}
/// <summary>
///
/// </summary>
/// <param name="blackboard"></param>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="floatComparison"></param>
/// <returns></returns>
public bool EvaluateBlackboardVsValue(Blackboard blackboard, string key, float value, FloatComparison floatComparison)
{
Blackboard sceneBlackboard = FindBlackboard(blackboard);
Value valueA = sceneBlackboard.GetValue(key);
return(CompareFloat(valueA.m_float, value, floatComparison));
}
/// <summary>
///
/// </summary>
/// <param name="blackboardA"></param>
/// <param name="keyA"></param>
/// <param name="blackboardB"></param>
/// <param name="keyB"></param>
/// <param name="floatComparison"></param>
/// <returns></returns>
public bool EvaluateBlackboardVsBlackboard(Blackboard blackboardA, string keyA, Blackboard blackboardB, string keyB, FloatComparison floatComparison)
{
Blackboard sceneBlackboardA = FindBlackboard(blackboardA);
Value valueA = sceneBlackboardA.GetValue(keyA);
Blackboard sceneBlackboardB = FindBlackboard(blackboardB);
Value valueB = sceneBlackboardB.GetValue(keyB);
return(CompareFloat(valueA.m_float, valueB.m_float, floatComparison));
}
public void TestL2Norm()
{
Vector a = Vector.Create(1.0, 2.0);
Assert.IsTrue(FloatComparison.Close(VectorReductions.L2Norm(a), (double)Math.Sqrt(5.0), FloatComparison.DefaultEps));
}
public void TestSquaredL2Norm()
{
Vector a = Vector.Create(1.0, 2.0);
Assert.IsTrue(FloatComparison.Close(VectorReductions.SquaredL2Norm(a), 5.0, FloatComparison.DefaultEps));
}
