public void Example1()
{
StandardMeasure <Mass> initialWgt = new StandardMeasure <Mass>(75.0);
StandardMeasure <Mass> gainedWgt = new StandardMeasure <Mass>(2.5, Mass.HectoGram);
StandardMeasure <Mass> newWgt = initialWgt + gainedWgt;
Measure <Mass> newWgtInGram = newWgt[Mass.Gram];
Measure <Mass> initialWgtInGram = newWgtInGram - gainedWgt;
Console.WriteLine("Initial weight: {0}", initialWgtInGram);
Measure <Length> height = new Measure <Length>(30.0, Length.CentiMeter);
StandardMeasure <Area> area = (StandardMeasure <Area>) 0.02;
StandardMeasure <Volume> vol; ArithmeticOperations.Times(height, area, out vol);
var maxVol = new StandardMeasure <Volume>(10.0, Volume.Liter);
if (vol < maxVol)
{
Console.WriteLine("Calculated volume is within limits, actual volume: {0}", vol[Volume.Liter]);
}
#if NUNIT24
Assert.Ignore();
#else
Assert.Pass();
#endif
}
public void TimesOperator_MultiplyNumberRhs_AllMeasuresEquallyScaled()
{
var expected = new StandardMeasureTriplet <Time, Power, ElectricPotential>(15.0, 0.36, 1.8);;
var actual = new StandardMeasure <Number>(3.0) * _instance;
IMeasureTripletAssert.AreEqual(expected, actual);
}
public void Constructor_WithNonReferenceUnit_InitializesMeasureInReferenceUnit()
{
var expected = new Measure <Time>(180.0, Time.Second);
var actual = new StandardMeasure <Time>(3.0, Time.Minute);
MeasureAssert.MeasuresAreEqual(expected, actual);
}
public void GetAmount_UsingIUnit_ValidConversion()
{
var expected = AmountConverter.ToAmountType(500.0);
var instance = new StandardMeasure <Length>(5.0);
var actual = instance.GetAmount(Length.CentiMeter);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Multiply two measures to return a resulting measure of a specified quantity
/// </summary>
/// <typeparam name="Q">Quantity type of resulting measure</typeparam>
/// <typeparam name="Q1">Quantity type of first factor</typeparam>
/// <typeparam name="Q2">Quantity type of second factor</typeparam>
/// <param name="iFirst">First measure to multiply</param>
/// <param name="iSecond">Second measure to multiply</param>
/// <param name="oResult">Measure resulting from multiplication, given in standard unit of quantity</param>
public static void Times <Q, Q1, Q2>(IMeasure <Q1> iFirst, IMeasure <Q2> iSecond, out StandardMeasure <Q> oResult)
where Q : struct, IQuantity <Q>
where Q1 : struct, IQuantity <Q1>
where Q2 : struct, IQuantity <Q2>
{
AssertMatchingQuantities <Q, Q1, Q2>(1, 1);
oResult = new StandardMeasure <Q>(iFirst.StandardAmount * iSecond.StandardAmount);
}
/// <summary>
/// Divide two measures to return a resulting measure of a specified quantity
/// </summary>
/// <typeparam name="Q">Quantity type of resulting measure</typeparam>
/// <typeparam name="Q1">Quantity type of numerator</typeparam>
/// <typeparam name="Q2">Quantity type of denominator</typeparam>
/// <param name="iNumerator">Numerator measure</param>
/// <param name="iDenominator">Denominator measure</param>
/// <param name="oResult">Resulting measure quotient, given in standard unit of quantity</param>
public static void Divide <Q, Q1, Q2>(IMeasure <Q1> iNumerator, IMeasure <Q2> iDenominator, out StandardMeasure <Q> oResult)
where Q : struct, IQuantity <Q>
where Q1 : struct, IQuantity <Q1>
where Q2 : struct, IQuantity <Q2>
{
AssertMatchingQuantities <Q, Q1, Q2>(1, -1);
oResult = new StandardMeasure <Q>(iNumerator.StandardAmount / iDenominator.StandardAmount);
}
public void Indexer_SameQuantityNonGenericInterface_YieldsValidMeasureOBject()
{
var expected = new Measure <Volume>(5000.0, Volume.Liter);
IMeasure meas = new StandardMeasure <Volume>(5.0);
var actual = meas[Volume.Liter];
MeasureAssert.MeasuresAreEqual(expected, actual);
}
public void DivisionOperator_DivideGenericSameQuantity_ReturnsScalar()
{
var expected = 1.0;
var numerator = new StandardMeasure <Area>(500.0, Area.SquareCentiMeter);
var denominator = new StandardMeasure <Area>(5.0, Area.SquareDeciMeter);
var actual = (double)(numerator / denominator);
Assert.AreEqual(expected, actual, 1.0e-6);
}
public void Divide_DivideVolumeAndLength_ReturnsArea()
{
var expected = new StandardMeasure <Area>(4.0);
var numerator = new StandardMeasure <Volume>(8.0);
var denominator = new StandardMeasure <Length>(200.0, Length.CentiMeter);
StandardMeasure <Area> actual; ArithmeticOperations.Divide(numerator, denominator, out actual);
MeasureAssert.MeasuresAreEqual(expected, actual);
}
public void Times_MultiplyAreaAndLength_ReturnsVolume()
{
var expected = new StandardMeasure <Volume>(6.0);
var lhs = new StandardMeasure <Area>(2.0);
var rhs = new StandardMeasure <Length>(3.0);
StandardMeasure <Volume> actual; ArithmeticOperations.Times(lhs, rhs, out actual);
MeasureAssert.MeasuresAreEqual(expected, actual);
}
public void AreEqual_NoArgumentHasValue_ReturnsFalse()
{
StandardMeasure <AmountConcentration>?lhs = null;
StandardMeasure <AmountConcentration>?rhs = null;
StandardMeasure <AmountConcentration> tol = StandardMeasure <AmountConcentration> .Zero;
var expected = false;
var actual = StandardMeasure.AreEqual(lhs, rhs, tol);
Assert.AreEqual(expected, actual);
}
public void AreEqual_BothArgumentsHaveValuesValuesNotWithinTolerance_ReturnsFalse()
{
StandardMeasure <AmountConcentration>?lhs = new StandardMeasure <AmountConcentration>(5.0);
StandardMeasure <AmountConcentration>?rhs = new StandardMeasure <AmountConcentration>(5.001);
StandardMeasure <AmountConcentration> tol = new StandardMeasure <AmountConcentration>(0.0001);
var expected = false;
var actual = StandardMeasure.AreEqual(lhs, rhs, tol);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Raise the specified measure to the specified integer power
/// </summary>
/// <typeparam name="Q">Quantity type of the resulting measure</typeparam>
/// <typeparam name="Q1">Quantity type of the base measure</typeparam>
/// <param name="iBase">Base measure</param>
/// <param name="iExponent">Exponent</param>
/// <param name="oResult">Resulting measure, given in standard unit of the specified quantity</param>
public static void Power <Q, Q1>(IMeasure <Q1> iBase, int iExponent, out StandardMeasure <Q> oResult)
where Q : struct, IQuantity <Q>
where Q1 : struct, IQuantity <Q1>
{
AssertMatchingQuantities <Q, Q1>(iExponent);
#if DOUBLE
oResult = new StandardMeasure <Q>(Math.Pow(iBase.StandardAmount, iExponent));
#else
oResult = new StandardMeasure <Q>(Math.Pow((double)iBase.StandardAmount, iExponent));
#endif
}
public void TimeMeasureAdditionsStandardUnitWithStandardMeasure()
{
PerformTiming(() =>
{
var val = new Measure <Mass>(0.0);
for (double i = 0.0; i < no; ++i)
{
val += new StandardMeasure <Mass>(i);
}
return(val);
});
}
public void TimeStandardMeasureAdditions()
{
PerformTiming(() =>
{
var val = new StandardMeasure <Length>(0.0);
for (double i = 0.0; i < no; ++i)
{
val += new StandardMeasure <Length>(i);
}
return(val);
});
}
public void TimeMeasureAdditionsNonStandardUnitWithStandardMeasure()
{
PerformTiming(() =>
{
var val = new Measure <Length>(0.0, Length.CentiMeter);
for (double i = 0.0; i < no; ++i)
{
val += new StandardMeasure <Length>(i);
}
return(val);
});
}
/// <summary>
/// Multiply two measures, each raised to a specific power, to return a resulting measure of a specified quantity
/// </summary>
/// <typeparam name="Q">Quantity type of resulting measure</typeparam>
/// <typeparam name="Q1">Quantity type of first factor</typeparam>
/// <typeparam name="Q2">Quantity type of second factor</typeparam>
/// <param name="iFirst">First measure to raise and multiply</param>
/// <param name="iFirstExponent">Exponent to which the first measure should be raised</param>
/// <param name="iSecond">Second measure to raise and multiply</param>
/// <param name="iSecondExponent">Exponent to which the second measure should be raised</param>
/// <param name="oResult">Measure resulting from multiplication, given in standard unit of quantity</param>
public static void Product <Q, Q1, Q2>(IMeasure <Q1> iFirst, int iFirstExponent, IMeasure <Q2> iSecond,
int iSecondExponent, out StandardMeasure <Q> oResult)
where Q : struct, IQuantity <Q>
where Q1 : struct, IQuantity <Q1>
where Q2 : struct, IQuantity <Q2>
{
AssertMatchingQuantities <Q, Q1, Q2>(iFirstExponent, iSecondExponent);
#if DOUBLE
oResult =
new StandardMeasure <Q>(Math.Pow(iFirst.StandardAmount, iFirstExponent) *
Math.Pow(iSecond.StandardAmount, iSecondExponent));
#else
oResult =
new StandardMeasure <Q>(Math.Pow((double)iFirst.StandardAmount, iFirstExponent) *
Math.Pow((double)iSecond.StandardAmount, iSecondExponent));
#endif
}
/// <summary>
/// Initializes a triplet of standard measures from three standard measure objects
/// </summary>
/// <param name="iX">First measure object</param>
/// <param name="iY">Second measure object</param>
/// <param name="iZ">Third measure object</param>
public StandardMeasureTriplet(StandardMeasure <Q1> iX, StandardMeasure <Q2> iY, StandardMeasure <Q3> iZ)
{
mX = iX;
mY = iY;
mZ = iZ;
}
/// <summary>
/// Initializes a pair of standard measures from two standard measure objects
/// </summary>
/// <param name="iX">First measure object</param>
/// <param name="iY">Second measure object</param>
public StandardMeasureDoublet(StandardMeasure <Q1> iX, StandardMeasure <Q2> iY)
{
mX = iX;
mY = iY;
}
/// <summary>
/// Initializes a triplet of standard measures from a triplet of standard unit amounts
/// </summary>
/// <param name="iAmount1">Amount in standard units of the first measure object</param>
/// <param name="iAmount2">Amount in standard units of the second measure object</param>
/// <param name="iAmount3">Amount in standard units of the third measure object</param>
public StandardMeasureTriplet(double iAmount1, double iAmount2, double iAmount3)
{
mX = new StandardMeasure <Q1>(iAmount1);
mY = new StandardMeasure <Q2>(iAmount2);
mZ = new StandardMeasure <Q3>(iAmount3);
}
/// <summary>
/// Initializes a triplet of standard measures
/// </summary>
/// <param name="iMeasure1">First measure object</param>
/// <param name="iMeasure2">Second measure object</param>
/// <param name="iMeasure3">Third measure object</param>
public StandardMeasureTriplet(IMeasure <Q1> iMeasure1, IMeasure <Q2> iMeasure2, IMeasure <Q3> iMeasure3)
{
mX = new StandardMeasure <Q1>(iMeasure1);
mY = new StandardMeasure <Q2>(iMeasure2);
mZ = new StandardMeasure <Q3>(iMeasure3);
}
/// <summary>
/// Initializes a triplet of standard measures from a triplet of standard unit amounts
/// </summary>
/// <param name="iAmount1">Amount in standard units of the first measure object</param>
/// <param name="iAmount2">Amount in standard units of the second measure object</param>
/// <param name="iAmount3">Amount in standard units of the third measure object</param>
public StandardMeasureTriplet(float iAmount1, float iAmount2, float iAmount3)
{
mX = new StandardMeasure <Q1>(iAmount1);
mY = new StandardMeasure <Q2>(iAmount2);
mZ = new StandardMeasure <Q3>(iAmount3);
}
/// <summary>
/// Indicates whether the current object is equal to another object of the same type.
/// </summary>
/// <param name="other">An object to compare with this object.</param>
/// <returns>true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.</returns>
public bool Equals(StandardMeasure <Q> other)
{
return(mAmount.Equals(other.mAmount));
}
/// <summary>
/// Compares the current object with another object of the same type.
/// </summary>
/// <param name="other">An object to compare with this object.</param>
/// <returns>
/// A 32-bit signed integer that indicates the relative order of the objects being compared. The return value has the following meanings:
/// Value Meaning
/// Less than zero This object is less than the <paramref name="other"/> parameter.
/// Zero This object is equal to <paramref name="other"/>.
/// Greater than zero This object is greater than <paramref name="other"/>.
/// </returns>
public int CompareTo(StandardMeasure <Q> other)
{
return(mAmount.CompareTo(other.mAmount));
}
public void Indexer_DifferentQuantitiesNonGenericInterface_Throws()
{
IMeasure meas = new StandardMeasure <SpecificVolume>(1.0);
var throws = meas[Volume.CubicMeter];
}
/// <summary>
/// Initializes a pair of standard measures from a pair of standard unit amounts
/// </summary>
/// <param name="iAmount1">Amount in standard units of the first measure object</param>
/// <param name="iAmount2">Amount in standard units of the second measure object</param>
public StandardMeasureDoublet(decimal iAmount1, decimal iAmount2)
{
mX = new StandardMeasure <Q1>(iAmount1);
mY = new StandardMeasure <Q2>(iAmount2);
}
/// <summary>
/// Indicates whether the current measure is equal to another measure of the same quantity within a given tolerance
/// </summary>
/// <param name="other">A measure to compare with this measure</param>
/// <param name="tol">The tolerance with which the compared measures may differ</param>
/// <returns>true if this and other are equal within the given tolerance, false otherwise</returns>
public bool Equals(StandardMeasure <Q> other, StandardMeasure <Q> tol)
{
return(Math.Abs(mAmount - other.mAmount) <= tol.mAmount);
}
/// <summary>
/// Initializes a pair of standard measures
/// </summary>
/// <param name="iMeasure1">First measure object</param>
/// <param name="iMeasure2">Second measure object</param>
public StandardMeasureDoublet(IMeasure <Q1> iMeasure1, IMeasure <Q2> iMeasure2)
{
mX = new StandardMeasure <Q1>(iMeasure1);
mY = new StandardMeasure <Q2>(iMeasure2);
}
/// <summary>
/// Static constructor for defining static class properties
/// </summary>
static StandardMeasure()
{
Zero = new StandardMeasure <Q>(Constants.Zero);
Epsilon = new StandardMeasure <Q>(Constants.MachineEpsilon);
}
/// <summary>
/// Initializes a pair of standard measures from a pair of standard unit amounts
/// </summary>
/// <param name="iAmount1">Amount in standard units of the first measure object</param>
/// <param name="iAmount2">Amount in standard units of the second measure object</param>
public StandardMeasureDoublet(float iAmount1, float iAmount2)
{
mX = new StandardMeasure <Q1>(iAmount1);
mY = new StandardMeasure <Q2>(iAmount2);
}
