public void dotProduct_AllGreaterThanTen()
{
vector = new Vector(12.0, 15.0, 20.0);
vector2 = new Vector(20.0, 20.0, 20.0);
Assert.AreEqual(((12.0 * 20.0) + (15.0 * 20.0) + (20.0 * 20.0)), vector.dotProduct(vector2));
}
public void dotProduct_WithNull()
{
vector = new Vector(1.0, 2.0, 3.0);
vector2 = null;
Assert.AreEqual(0.0, vector.dotProduct(vector2));
vector2.dotProduct(vector);
}
public void dotProduct_NegativeValue()
{
vector = new Vector(1.0, 2.0, 3.0);
vector2 = new Vector(-4.0, -25.0, -1.0);
Assert.AreEqual((-4.0 -50.0 -3.0), vector.dotProduct(vector2));
vector2 = new Vector(-4.0, 5.0, 1.0);
Assert.AreEqual((-4.0 + 10.0 + 3.0), vector.dotProduct(vector2));
}
/// <summary>
/// Calculate the dotProduct between this vector and another vector.
/// </summary>
/// <param name="vector">The other vector</param>
/// <returns>The dotproduct</returns>
public double dotProduct(Vector vector)
{
double returnValue = 0.0;
if (vector != null)
{
returnValue = (this.x * vector.x) + (this.y * vector.y) + (this.z * vector.z);
}
return returnValue;
}
public void additionOperator()
{
vector = new Vector(1.0, 2.0, 3.0);
vector2 = new Vector(15.0, 6.0, 0.0);
checkVector = new Vector(16.0, 8.0, 3.0);
Assert.IsTrue((vector + vector2).Equals(checkVector));
Assert.IsTrue((vector2 + vector).Equals(checkVector));
vector = new Vector(-1.0, -2.0, -3.0);
checkVector = new Vector(14.0, 4.0, -3.0);
Assert.IsTrue((vector + vector2).Equals(checkVector));
Assert.IsTrue((vector2 + vector).Equals(checkVector));
}
/// <summary>
/// Implements the mental workload (MWL) formula as defined in the scientific literature
/// </summary>
/// <param name="lipValue">The level of information processing</param>
/// <param name="moValue">The mental occupancy</param>
/// <param name="tssValue">The task set switches</param>
/// <param name="frameCount">Number of tasks in the calculation frame</param>
/// <returns>The calculated MWL-value</returns>
public static double calculateMentalWorkLoad(double lipValue, double moValue, double tssValue, int frameCount)
{
//Console.WriteLine("lip = " + lipValue + " mo = " + moValue + " tss = " + tssValue);
double mwlValue = 0;
double normalizedTssValue = 0;
// Define the bounds as tuples (lower bound, upper bound)
Tuple<int, int> lipBounds = Tuple.Create(1, 3);
Tuple<int, int> moBounds = Tuple.Create(0, 1);
Tuple<int, int> tssBounds = Tuple.Create(0, Math.Max(frameCount - 1, 0));
// Project all metrics on the [0, 1] interval
double normalizedLipValue = (lipValue - lipBounds.Item1) / lipBounds.Item2;
double normalizedMoValue = (moValue - moBounds.Item1) / moBounds.Item2;
// Avoid NaN values!
if (tssBounds.Item2 != 0)
{
normalizedTssValue = (tssValue - tssBounds.Item1) / tssBounds.Item2;
Console.WriteLine(normalizedTssValue);
}
Vector diagonalVector = new Vector(1.0, 1.0, 1.0);
Vector mwlVector = new Vector(normalizedLipValue, normalizedMoValue, normalizedTssValue);
// The distance to the origin (the length of the input vector)
// For now we use this as MWL value, since the formula appeared to be unuseable
double distanceToOrigin = mwlVector.length();
Vector mwlProjDiagonal = mwlVector.orthogonalProjection(diagonalVector);
Vector zVector = mwlVector - mwlProjDiagonal;
double distanceToDiagonal = zVector.length();
mwlValue = distanceToOrigin - (distanceToDiagonal/2);
return mwlValue;
}
public void dotProduct_AllZero()
{
vector = new Vector(0.0, 0.0, 0.0);
Assert.AreEqual(0.0, vector.dotProduct(vector));
}
public void equalityTest_PerValue()
{
vector = new Vector(1.0, 2.0, 3.0);
vector2 = new Vector(1.0, 2.0, 3.0);
Assert.IsTrue(vector.Equals(vector2));
vector2 = new Vector(0.0, 2.0, 3.0);
Assert.IsFalse(vector.Equals(vector2));
vector2 = new Vector(1.0, 0.0, 3.0);
Assert.IsFalse(vector.Equals(vector2));
vector2 = new Vector(1.0, 2.0, 0.0);
Assert.IsFalse(vector.Equals(vector2));
}
public void orthogonalProjection_NegativeValues()
{
vector = new Vector(1.0, 2.0, 3.0);
vector2 = new Vector(-4.0, -25.0, -1.0);
double fraction = vector.dotProduct(vector2)/vector2.dotProduct(vector2);
Vector newVector = new Vector (fraction*(-4.0), (-25.0) * fraction, (-1.0)* fraction);
Assert.IsTrue(newVector.Equals(vector.orthogonalProjection(vector2)));
}
public void orthogonalProjection_AllZero()
{
vector = new Vector(0.0, 0.0, 0.0);
Assert.IsNull(vector.orthogonalProjection(vector));
Assert.IsNotNull(vector.orthogonalProjection((new Vector(1.0, 1.0, 1.0))));
Assert.AreEqual(new Vector(0.0, 0.0, 0.0), vector.orthogonalProjection((new Vector(1.0, 1.0, 1.0))));
}
public void orthogonalProjection_AllGreaterThanTen()
{
vector = new Vector(12.0, 15.0, 20.0);
vector2 = new Vector(20.0, 20.0, 20.0);
double fraction = vector.dotProduct(vector2) / vector.dotProduct(vector);
Vector newVector = new Vector(12 * fraction, 15 * fraction, 20 * fraction);
}
public void length_ValidInput()
{
vector = new Vector(-4.0, -25.0, -1.0);
double expected = Math.Sqrt(vector.dotProduct(vector));
Assert.AreEqual(expected, vector.length());
vector2 = new Vector(12.0, 15.0, 20.0);
expected = Math.Sqrt(vector2.dotProduct(vector2));
Assert.AreEqual(expected, vector2.length());
}
public void length_NullInput()
{
vector = null;
vector.length();
}
public void length_AllZero()
{
vector = new Vector(0.0, 0.0, 0.0);
Assert.AreEqual(0.0, vector.length());
}
public void dotProduct_WithSelf()
{
vector = new Vector(1.0, 2.0, 3.0);
Assert.AreEqual(1+4+9, vector.dotProduct(vector));
}
/// <summary>
/// Calculates the orthogonal projection of a vector on a differnet vector
/// </summary>
/// <param name="toVector">The vector which is projected upon</param>
/// <returns>The projected vector</returns>
public Vector orthogonalProjection(Vector toVector)
{
Vector returnVector = null;
if (!((toVector.x == 0) && (toVector.y == 0) && (toVector.z == 0)))
{
double fraction = this.dotProduct(toVector) / toVector.dotProduct(toVector);
returnVector = new Vector(fraction * toVector.x, fraction * toVector.y, fraction * toVector.z);
}
return returnVector;
}
public void orthogonalProjection_Self()
{
vector = new Vector(1.0, 2.0, 3.0);
Assert.IsTrue(vector.Equals(vector.orthogonalProjection(vector)));
}
public void substractionOperator()
{
vector = new Vector(1.0, 2.0, 3.0);
vector2 = new Vector(15.0, 6.0, 0.0);
checkVector = new Vector(-14.0, -4.0, 3.0);
Assert.IsTrue((vector - vector2).Equals(checkVector));
Assert.IsFalse((vector2 - vector).Equals(checkVector));
vector = new Vector(-1.0, -2.0, -3.0);
checkVector = new Vector(16.0, 8.0, 3.0);
Assert.IsTrue((vector2 - vector).Equals(checkVector));
Assert.IsFalse((vector - vector2).Equals(checkVector));
}
public void equalityTest_Logic()
{
vector = new Vector(1.0, 2.0, 3.0);
vector2 = new Vector(15.0, 6.0, 0.0);
Assert.IsTrue(vector.Equals(vector));
Assert.AreEqual(vector.Equals(vector2), vector2.Equals(vector));
Assert.IsFalse(vector.Equals(null));
}
