public void Verify_that_second_order_derived_dimless_is_dimless()
{
/* Also should not matter that they are the same units per se, only that the dimensions
* themselves are considered dimensionless. This could easily be a more specialized version
* of the same unit test. */
var derivedQty = new Quantity(default(double), A.SquareKilometer, L.Meter.Invert(), L.Kilometer.Invert());
Assert.That(derivedQty.IsDimensionless);
}
/// <summary>
/// Protected Constructor
/// </summary>
protected TimeableClockBase()
{
const int infinite = Timeout.Infinite;
_timer = new Timer(ProtectedTimerCallback, null, infinite, infinite);
var s = T.Second;
TimePerStepQty = new Quantity(1d, s);
_timerIntervalQty = new Quantity(double.NegativeInfinity, s);
}
private static IQuantity CalculateAngular(IQuantity x, IQuantity y, IPlanarAngle desiredUnit,
Func<double, double, double> trigonometry)
{
//TODO: just dimensionless?
x.VerifyDimensionless();
y.VerifyDimensionless();
var radian = SiTheta.Radian;
desiredUnit = desiredUnit ?? radian;
IQuantity result = new Quantity(trigonometry(x.Value, y.Value), radian);
if (desiredUnit is SiTheta) return result;
return result.ConvertTo(desiredUnit);
}
public void VerifyResults(Quantity result, double a, IQuantity b, double expectedValue)
{
base.VerifyResults(result, b.Inverse(), a, expectedValue);
}
protected override void VerifyResults <TA, TB>(Quantity result, IQuantity a, IQuantity b, double expectedValue)
{
base.VerifyResults <TA, TB>(result, a, b.Inverse(), expectedValue);
}
public void Verify_that_second_order_derived_dimless_is_not_dimless()
{
var derivedQty = new Quantity(default(double), A.SquareKilometer, A.SquareKilometer);
Assert.That(derivedQty.IsDimensionless, Is.False);
}
public void Verify_that_first_order_derived_dimless_is_not_dimless()
{
var derivedQty = new Quantity(default(double), L.Kilometer, L.Meter, L.Kilometer);
Assert.That(derivedQty.IsDimensionless, Is.False);
}
public void Verify_that_first_order_derived_dimless_is_dimless()
{
var derivedQty = new Quantity(default(double), L.Meter, L.Meter.Invert());
Assert.That(derivedQty.IsDimensionless);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value"></param>
/// <param name="result"></param>
/// <returns></returns>
protected bool TryInvokeOperator <T>(T value, out Quantity result)
{
result = value.InvokeOperator <T, Quantity>(Operator, value);
return(result != null);
}
public void Verify_that_first_order_derived_dimless_is_dimless()
{
var derivedQty = new Quantity(default(double), L.Meter, L.Meter.Invert());
Assert.That(derivedQty.IsDimensionless);
}
/// <summary>
/// Initializes the quantities.
/// </summary>
protected override void InitializeQuantities()
{
// For purposes of this test, does not matter what dimensions themselves are, per se.
VerifyUnaryQuantity(A = new Quantity(Value, L.Meter));
VerifyUnaryQuantity(B = new Quantity(Value));
}
public void Verify_that_second_order_derived_dimless_is_not_dimless()
{
var derivedQty = new Quantity(default(double), A.SquareKilometer, A.SquareKilometer);
Assert.That(derivedQty.IsDimensionless, Is.False);
}
public void Verify_that_first_order_derived_dimless_is_not_dimless()
{
var derivedQty = new Quantity(default(double), L.Kilometer, L.Meter, L.Kilometer);
Assert.That(derivedQty.IsDimensionless, Is.False);
}
//private static bool IsDegree(this IQuantity angle, double expectedAngle)
//{
// angle.VerifyAngular();
// // TODO: might be better if we had an actual IEquatable<IQuantiy> here ...
// return angle.ConvertTo(UsTheta.Degree).Value.Equals(expectedAngle);
//}
private static IQuantity CalculateDimensionless(this IQuantity angle, Func<double, double> trigonometry)
{
angle.VerifyAngular();
var theta = angle.ConvertTo(SiTheta.Radian);
var result = new Quantity(trigonometry(theta.Value));
return result;
}
public void Verify_that_pure_dimless_is_dimless()
{
var qty = new Quantity();
Assert.That(qty.IsDimensionless);
}
public void Verify_area_squared_equivalent()
{
var a = new Quantity(Value, A.SquareMeter.Squared());
var b = new Quantity(Value, L.Meter.Squared().Squared());
Assert.That(a.Equals(b), "{{{0}}} did not equal {{{1}}}.", a, b);
}
public void Verify_that_pure_dimless_is_dimless()
{
var qty = new Quantity();
Assert.That(qty.IsDimensionless);
}