public void GivenRepresentationAndUomWhenCreateVariableNumberShouldSetRepAndUom()
{
var representation = RepresentationInstanceList.vrAirTemperature.ToModelRepresentation();
var uom = InternalUnitSystemManager.Instance.UnitOfMeasures["C"].ToModelUom();
var numericValue = new NumericValue(uom, 1.23);
var numericRepresentationValue = new NumericRepresentationValue(representation, uom, numericValue);
Assert.AreEqual(representation.Code, numericRepresentationValue.Representation.Code);
Assert.AreEqual(uom.Code, numericRepresentationValue.UserProvidedUnitOfMeasure.Code);
}
public void GivenVariableNumberWhenSubtractVariableNumberFromSourceShouldDoThat()
{
var uom = _ftUnitOfMeasure.ToModelUom();
var firstValue = new NumericValue(uom, 24.68);
var secondValue = new NumericValue(uom, 10.11);
var firstNumber = new NumericRepresentationValue(RepresentationInstanceList.vrABShiftTrack.ToModelRepresentation(), firstValue);
var secondNumber = new NumericRepresentationValue(RepresentationInstanceList.vrABShiftTrack.ToModelRepresentation(), secondValue);
firstNumber.SubtractFromSource(secondNumber);
Assert.AreEqual(14.57, firstNumber.Value.Value);
}
public void GivenVariableNumberWhenDivideVariableNumberWithZeroValueThenDivideByZeroException()
{
var numeratorUom = _ftUnitOfMeasure.ToModelUom();
var numeratorValue = new NumericValue(numeratorUom, 3);
var numerator = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), numeratorValue);
var denominatorUom = InternalUnitSystemManager.Instance.UnitOfMeasures["sec"].ToModelUom();
var denominatorValue = new NumericValue(denominatorUom, 0);
var denominator = new NumericRepresentationValue(RepresentationInstanceList.vrDeltaTime.ToModelRepresentation(), denominatorValue);
Assert.Throws <DivideByZeroException>(() => numerator.Divide(denominator, RepresentationInstanceList.vrVehicleSpeed.ToModelRepresentation()));
}
public void GivenVariableNumberWhenDivideDoubleThenSourceValueIsQuotient()
{
var uom = InternalUnitSystemManager.Instance.UnitOfMeasures["mi"].ToModelUom();
var value = new NumericValue(uom, 3.62);
var number = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), value);
var result = number.Divide(1.23);
Assert.IsInstanceOf <NumericRepresentationValue>(result);
Assert.AreEqual(3.62 / 1.23, result.Value.Value, Epsilon);
}
public void GivenVariableNumberWhenAddDoubleShouldReturnNewVariableNumberWithSourceAddedToDouble()
{
var uom = InternalUnitSystemManager.Instance.UnitOfMeasures["mi"].ToModelUom();
var originalValue = new NumericValue(uom, 3.62);
var number = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), originalValue);
var result = number.Add(1.23);
Assert.IsInstanceOf <NumericRepresentationValue>(result);
Assert.AreEqual(4.85, result.Value.Value, Epsilon);
}
public void GivenVariableNumberWhenSubtractDoubleShouldReturnNewVariableNumberWithDoubleSubtractedFromSource()
{
var uom = InternalUnitSystemManager.Instance.UnitOfMeasures["mi"].ToModelUom();
var value = new NumericValue(uom, 3.62);
var number = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), value);
var result = number.Subtract(1.23);
Assert.IsInstanceOf <NumericRepresentationValue>(result);
Assert.AreEqual(2.39, result.Value.Value, Epsilon);
}
public static int?AsConvertedInt(this NumericRepresentationValue value, string targetUnitCode)
{
if (value == null)
{
return(null);
}
else
{
return((int)value.AsConvertedDouble(targetUnitCode).Value);
}
}
public void GivenTwoVariableNumbersWithSameUomWhenAddedThenSourceValueIsSum()
{
var uom = InternalUnitSystemManager.Instance.UnitOfMeasures["C"].ToModelUom();
var originalValue = new NumericValue(uom, 22);
var originalRep = new NumericRepresentationValue(RepresentationInstanceList.vrAirTemperature.ToModelRepresentation(), originalValue);
var secondNumber = new NumericValue(uom, 11);
var result = originalRep.Add(secondNumber);
Assert.IsInstanceOf <NumericRepresentationValue>(result);
Assert.AreEqual(33, result.Value.Value);
}
public void GivenVariableNumbersWithIncompatibleUnitsWhenSubtractThenException()
{
var originalUom = InternalUnitSystemManager.Instance.UnitOfMeasures["m"].ToModelUom();
var originalValue = new NumericValue(originalUom, 1.75);
var originalNumber = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), originalValue);
var secondUom = InternalUnitSystemManager.Instance.UnitOfMeasures["C"].ToModelUom();
var secondValue = new NumericValue(secondUom, 3.5);
var secondNumber = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), secondValue);
Assert.Throws <InvalidOperationException>(() => originalNumber.Subtract(secondNumber));
}
public void GivenSpatialRecordWithResolutionOfOneWhenMapThenValueIsReturned()
{
var numericRepresentationValue = new NumericRepresentationValue(RepresentationInstanceList.vrLongitude.ToModelRepresentation(), new NumericValue(UnitSystemManager.GetUnitOfMeasure("arcdeg"), 85));
_spatialRecord.SetMeterValue(_meter, numericRepresentationValue);
_representationMapperMock.Setup(x => x.Map(numericRepresentationValue.Representation)).Returns(116);
var result = _mapper.Map(_meter, _spatialRecord);
Assert.AreEqual(numericRepresentationValue.Value.Value, result);
}
private static void DescribeOffset(string offsetDescription, NumericRepresentationValue xOffset, NumericRepresentationValue yOffset, string referencePoint)
{
double inlineOffset = xOffset.Value.Value;
string inlineOffsetUnit = xOffset.Value.UnitOfMeasure.Code;
string inlineOffsetDirection = inlineOffset >= 0d ? "front" : "back";
double lateralOffset = yOffset.Value.Value;
string lateralOffsetUnit = yOffset.Value.UnitOfMeasure.Code;
string lateralOffsetDirection = lateralOffset >= 0d ? "right" : "left";
Console.WriteLine($"The {offsetDescription} is located {Math.Abs(inlineOffset)} {inlineOffsetUnit} in {inlineOffsetDirection} and {Math.Abs(lateralOffset)} {lateralOffsetUnit} to {lateralOffsetDirection} of the {referencePoint}.");
}
private static void WriteArea(XmlWriter writer, NumericRepresentationValue area)
{
if (area == null || area.Value == null || area.Value.Value < 0)
{
writer.WriteAttributeString("D", "0");
}
else
{
var fieldArea = area.Value.ConvertToUnit(new CompositeUnitOfMeasure("m2"));
writer.WriteAttributeString("D", fieldArea.ToString(CultureInfo.InvariantCulture));
}
}
public static NumericRepresentationValue GetNumericRepresentationValue(double d, string uomCode, string numericRepresentationCode)
{
NumericRepresentationValue numericRepresentationValue = new NumericRepresentationValue();
numericRepresentationValue.Representation = GetNumericRepresentation(numericRepresentationCode);
UnitOfMeasure uom = UnitInstance.UnitSystemManager.GetUnitOfMeasure(uomCode);
numericRepresentationValue.Value = new NumericValue(uom, d);
return(numericRepresentationValue);
}
public void GivenNumericRepresentationValueOfRateTypeWhenInterpolateThenRepresentationValueIsSameAsPrevious()
{
var previousRepresentationValue = new NumericRepresentationValue(RepresentationInstanceList.vrYieldMass.ToModelRepresentation(), new NumericValue(UnitSystemManager.GetUnitOfMeasure("m2"), 1.0));
_interpolator.SetMostRecentMeterValue(_numericMeter, previousRepresentationValue);
var result = _interpolator.Interpolate(_numericMeter);
var numericRepresentationValue = result as NumericRepresentationValue;
Assert.AreEqual(previousRepresentationValue.Value.Value, numericRepresentationValue.Value.Value);
}
private void SetNumericMeterValue(ISOSpatialRow isoSpatialRow, NumericWorkingData meter, SpatialRecord spatialRecord, Dictionary <string, List <ISOProductAllocation> > productAllocations)
{
var isoValue = isoSpatialRow.SpatialValues.FirstOrDefault(v =>
v.DataLogValue.ProcessDataDDI != "DFFE" &&
_workingDataMapper.DataLogValuesByWorkingDataID.ContainsKey(meter.Id.ReferenceId) &&
v.DataLogValue.DeviceElementIdRef == _workingDataMapper.DataLogValuesByWorkingDataID[meter.Id.ReferenceId].DeviceElementIdRef &&
v.DataLogValue.ProcessDataDDI == _workingDataMapper.DataLogValuesByWorkingDataID[meter.Id.ReferenceId].ProcessDataDDI);
if (isoValue != null)
{
var value = new NumericRepresentationValue(meter.Representation as NumericRepresentation, meter.UnitOfMeasure, new NumericValue(meter.UnitOfMeasure, isoValue.Value));
spatialRecord.SetMeterValue(meter, value);
var other = new NumericRepresentationValue(meter.Representation as NumericRepresentation, meter.UnitOfMeasure, new NumericValue(meter.UnitOfMeasure, isoValue.Value));
_representationValueInterpolator.SetMostRecentMeterValue(meter, other);
}
else if (meter.Representation.Code == "vrProductIndex")
{
string detID = _workingDataMapper.ISODeviceElementIDsByWorkingDataID[meter.Id.ReferenceId];
if (productAllocations.ContainsKey(detID)) //The DeviceElement for this meter exists in the list of allocations
{
double numericValue = 0d;
if (productAllocations[detID].Count == 1 || TimeLogMapper.GetDistinctProductIDs(_taskDataMapper, productAllocations).Count == 1)
{
//This product is consistent throughout the task on this device element
int?adaptProductID = _taskDataMapper.InstanceIDMap.GetADAPTID(productAllocations[detID].Single().ProductIdRef);
numericValue = adaptProductID.HasValue ? adaptProductID.Value : 0d;
}
else if (productAllocations[detID].Count > 1)
{
//There are multiple product allocations for the device element
//Find the product allocation that governs this timestamp
ISOProductAllocation relevantPan = productAllocations[detID].FirstOrDefault(p => Offset(p.AllocationStamp.Start) <= spatialRecord.Timestamp &&
(p.AllocationStamp.Stop == null ||
Offset(p.AllocationStamp.Stop) >= spatialRecord.Timestamp));
if (relevantPan != null)
{
int?adaptProductID = _taskDataMapper.InstanceIDMap.GetADAPTID(relevantPan.ProductIdRef);
numericValue = adaptProductID.HasValue ? adaptProductID.Value : 0d;
}
}
var value = new NumericRepresentationValue(meter.Representation as NumericRepresentation, meter.UnitOfMeasure, new NumericValue(meter.UnitOfMeasure, numericValue));
spatialRecord.SetMeterValue(meter, value);
}
}
else
{
var value = _representationValueInterpolator.Interpolate(meter) as NumericRepresentationValue;
spatialRecord.SetMeterValue(meter, value);
}
}
public void GivenVariableNumberWhenDivideVariableNumberThenUnitOfMeasuresCombined()
{
var uom = _ftUnitOfMeasure.ToModelUom();
var value = new NumericValue(uom, 12);
var numerator = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), value);
var denominator = new NumericValue(InternalUnitSystemManager.Instance.UnitOfMeasures["sec"].ToModelUom(), 5);
var quotient = numerator.Divide(denominator);
Assert.IsInstanceOf <NumericRepresentationValue>(quotient);
Assert.AreEqual("ft1sec-1", quotient.Value.UnitOfMeasure.Code);
Assert.AreEqual(2.4, quotient.Value.Value, Epsilon);
}
public void GivenVariableNumberWhenMultiplyNumberThenUnitOfMeasuresCombined()
{
var uom = _ftUnitOfMeasure.ToModelUom();
var leftValue = new NumericValue(uom, 12);
var left = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), leftValue);
var right = new NumericValue(uom, 4);
var product = left.Multiply(right);
Assert.IsInstanceOf <NumericRepresentationValue>(product);
Assert.AreEqual("ft2", product.Value.UnitOfMeasure.Code);
Assert.AreEqual(48, product.Value.Value);
}
public void GivenTwoVariableNubmersWhenSubtractedThenRepresentationIsOriginal()
{
var originalUom = _ftUnitOfMeasure.ToModelUom();
var originalValue = new NumericValue(originalUom, 22);
var originalNumber = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), originalValue);
var secondUom = InternalUnitSystemManager.Instance.UnitOfMeasures["m"].ToModelUom();
var secondValue = new NumericValue(secondUom, 11);
var secondNumber = new NumericRepresentationValue(RepresentationInstanceList.vrElevation.ToModelRepresentation(), secondValue);
var result = originalNumber.Subtract(secondNumber);
Assert.AreSame(RepresentationInstanceList.vrDistanceTraveled.DomainId, result.Representation.Code);
}
public void GivenVariableNumberWithCompositeUnitOfMeasureWhenMultiplyVariableNumberThenCombinedUnitOfMeasure()
{
var leftUom = InternalUnitSystemManager.Instance.UnitOfMeasures["ft1sec-1"].ToModelUom();
var leftValue = new NumericValue(leftUom, 47.5);
var left = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), leftValue);
var right = new NumericValue(_ftUnitOfMeasure.ToModelUom(), 3);
var product = left.Multiply(right);
Assert.IsInstanceOf <NumericRepresentationValue>(product);
Assert.AreEqual("ft2sec-1", product.Value.UnitOfMeasure.Code);
Assert.AreEqual(142.5, product.Value.Value);
}
public void GivenVariableNumberWhenDivideNumberWithSameUnitThenSourceValueIsQuotient()
{
var uom = _ftUnitOfMeasure.ToModelUom();
var value = new NumericValue(uom, 12);
var numerator = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), value);
var denominator = new NumericValue(_ftUnitOfMeasure.ToModelUom(), 6);
var quotient = numerator.Divide(denominator);
Assert.IsInstanceOf <NumericRepresentationValue>(quotient);
Assert.AreEqual("ratio", quotient.Value.UnitOfMeasure.Code);
Assert.AreEqual(2, quotient.Value.Value, Epsilon);
}
private List <ISOTime> ExportSummary(Summary summary)
{
List <ISOTime> times = new List <ISOTime>();
foreach (StampedMeteredValues values in summary.SummaryData)
{
ISOTime time = new ISOTime();
time.Start = values.Stamp.TimeStamp1;
time.Stop = values.Stamp.TimeStamp2;
if (values.Stamp.Duration.HasValue)
{
time.Duration = (uint)values.Stamp.Duration.Value.TotalSeconds;
}
time.Type = values.Stamp.DateContext == DateContextEnum.ProposedStart ? ISOEnumerations.ISOTimeType.Planned : ISOEnumerations.ISOTimeType.Effective;
foreach (MeteredValue value in values.Values)
{
if (value.Value != null && value.Value is NumericRepresentationValue)
{
NumericRepresentationValue numericValue = value.Value as NumericRepresentationValue;
ISODataLogValue dlv = new ISODataLogValue();
int?ddi = RepresentationMapper.Map(numericValue.Representation);
if (ddi.HasValue)
{
dlv.ProcessDataDDI = ddi.Value.AsHexDDI();
DdiDefinition DdiDefinition = DDIs[ddi.Value];
dlv.ProcessDataValue = (int)(numericValue.Value.Value / (DdiDefinition.Resolution != 0 ? DdiDefinition.Resolution : 1d));
}
else
{
if (numericValue.Representation.CodeSource == RepresentationCodeSourceEnum.ISO11783_DDI)
{
dlv.ProcessDataDDI = numericValue.Representation.Code;
dlv.ProcessDataValue = (int)numericValue.Value.Value;
}
}
if (value.DeviceConfigurationId.HasValue)
{
DeviceElementConfiguration config = DataModel.Catalog.DeviceElementConfigurations.FirstOrDefault(c => c.Id.ReferenceId == value.DeviceConfigurationId.Value);
if (config != null)
{
dlv.DeviceElementIdRef = TaskDataMapper.InstanceIDMap.GetISOID(config.DeviceElementId);
}
}
time.DataLogValues.Add(dlv);
}
}
times.Add(time);
}
return(times);
}
public void GivenVariableNumbersWithTypesThatSimplifyToScalarTypeWhenMultiplyThenShouldHaveScalarUnit()
{
var leftUom = InternalUnitSystemManager.Instance.UnitOfMeasures["ft1sec-1"].ToModelUom();
var leftValue = new NumericValue(leftUom, 21.848);
var left = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), leftValue);
var rightUom = InternalUnitSystemManager.Instance.UnitOfMeasures["sec"].ToModelUom();
var rightValue = new NumericValue(rightUom, 9.18);
var right = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), rightValue);
var product = left.Multiply(right, RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation());
Assert.AreEqual("ft", product.Value.UnitOfMeasure.Code);
//Assert.IsInstanceOf<ScalarUnitOfMeasure>(product.Value.UnitOfMeasure.Scale);??
}
public void GivenVariableNumberWithCompositeUnitOfMeasureWhenMultiplyVariableNumberWithCompositeUnitOfMeasureThenCombinedUnitOfMeasure()
{
var uom = InternalUnitSystemManager.Instance.UnitOfMeasures["ft1sec-1"].ToModelUom();
var leftValue = new NumericValue(uom, 21.848);
var left = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), leftValue);
var rightValue = new NumericValue(uom, 9.18);
var right = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), rightValue);
var product = left.Multiply(right, RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation());
Assert.AreSame(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation().Code, product.Representation.Code);
Assert.AreEqual("ft2[sec2]-1", product.Value.UnitOfMeasure.Code);
Assert.AreEqual(200.56464, product.Value.Value);
}
/// <summary>
/// Converts an ADAPT NumericRepresentation value with an included UnitOfMeasure to the requested units
/// </summary>
/// <param name="value"></param>
/// <param name="mapper"></param>
/// <returns></returns>
public static double?AsConvertedDouble(this NumericRepresentationValue value, string targetUnitCode)
{
if (value == null)
{
return(null);
}
else if (value.Value.UnitOfMeasure == null)
{
return(value.Value.Value); //Return the unconverted value
}
else
{
return(value.Value.Value.ConvertValue(value.Value.UnitOfMeasure.Code, targetUnitCode));
}
}
public void GivenVariableNumberWithCompositeUnitOfMeasureWhenMultiplyVariableNumberWithCompositeUnitOfMeasureThenUnitsCancel()
{
var leftUom = InternalUnitSystemManager.Instance.UnitOfMeasures["ft1sec1"].ToModelUom();
var leftValue = new NumericValue(leftUom, 5.15);
var left = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), leftValue);
var rightUom = InternalUnitSystemManager.Instance.UnitOfMeasures["ft1sec-1"].ToModelUom();
var rightValue = new NumericValue(rightUom, 7.89);
var right = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), rightValue);
var product = left.Multiply(right, RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation());
Assert.AreSame(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation().Code, product.Representation.Code);
Assert.AreEqual("ft2", product.Value.UnitOfMeasure.Code);
Assert.AreEqual(40.6335, product.Value.Value);
}
public void GivenVariableNumberWhenWhenDivideVariableNumberWithCompositeUnitOfMeasureThenUnitOfMeasuresSimplified()
{
var numeratorUom = _ftUnitOfMeasure.ToModelUom();
var numeratorValue = new NumericValue(numeratorUom, 12.54);
var numerator = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), numeratorValue);
var denominatorUom = InternalUnitSystemManager.Instance.UnitOfMeasures["[sec2]-1"].ToModelUom();
var denominatorValue = new NumericValue(denominatorUom, 5);
var denominator = new NumericRepresentationValue(RepresentationInstanceList.vrDeltaTime.ToModelRepresentation(), denominatorValue);
var quotient = numerator.Divide(denominator, RepresentationInstanceList.vrDeltaTime.ToModelRepresentation());
Assert.AreEqual("ft1sec2", quotient.Value.UnitOfMeasure.Code);
Assert.AreSame(RepresentationInstanceList.vrDeltaTime.ToModelRepresentation().Code, quotient.Representation.Code);
Assert.AreEqual(2.508, quotient.Value.Value, Epsilon);
}
public void GivenVariableNumberWithCompositeUnitOfMeasureWhenDivdeVariableNumberWithCompositeUnitOfMeasureThenUnitOfMeasuresSimplified()
{
var numeratorUom = InternalUnitSystemManager.Instance.UnitOfMeasures["ft1sec-1"].ToModelUom();
var numeratorValue = new NumericValue(numeratorUom, 52.15);
var numerator = new NumericRepresentationValue(RepresentationInstanceList.vrEngineSpeed.ToModelRepresentation(), numeratorValue);
var denominatorUom = InternalUnitSystemManager.Instance.UnitOfMeasures["gal1sec-1"].ToModelUom();
var denominatorValue = new NumericValue(denominatorUom, 12);
var denominator = new NumericRepresentationValue(RepresentationInstanceList.vrFuelRatePerHour.ToModelRepresentation(), denominatorValue);
var quotient = numerator.Divide(denominator, RepresentationInstanceList.vrEngineSpeed.ToModelRepresentation());
Assert.AreEqual("ft1gal-1", quotient.Value.UnitOfMeasure.Code);
Assert.AreSame(RepresentationInstanceList.vrEngineSpeed.ToModelRepresentation().Code, quotient.Representation.Code);
Assert.AreEqual(4.345833333333333, quotient.Value.Value, Epsilon);
}
private ISOProcessDataVariable ExportProcessDataVariable(NumericRepresentationValue value, string isoProductIdRef, ISOUnit unit)
{
if (value != null && value.Value != null)
{
UnitOfMeasure adaptUnit = unit.ToAdaptUnit();
var dataVariable = new ISOProcessDataVariable
{
ProductIdRef = isoProductIdRef,
ProcessDataValue = value.AsIntViaMappedDDI(RepresentationMapper),
ProcessDataDDI = DetermineVariableDDI(value.Representation, adaptUnit).AsHexDDI()
};
return(dataVariable);
}
return(null);
}
/// <summary>
/// Converts an ADAPT NumericRepresentation value with an included Representation mapped to a DDI to the appropriate int value for ISO
/// </summary>
/// <param name="value"></param>
/// <param name="mapper"></param>
/// <returns></returns>
public static int AsIntViaMappedDDI(this NumericRepresentationValue value, RepresentationMapper mapper)
{
int?ddi = mapper.Map(value.Representation);
if (ddi.HasValue)
{
ISOUnit unit = UnitFactory.Instance.GetUnitByDDI(ddi.Value);
return((int)unit.ConvertToIsoUnit(value.Value.Value));
}
else if (value.Representation != null && value.Representation.CodeSource == RepresentationCodeSourceEnum.ISO11783_DDI)
{
//No need to convert if the value is natively a DDI
return((int)value.Value.Value);
}
return(0);
}
public void GivenVariableNumberWhenSubtractVariableNumberThenResultIsInOriginalUom()
{
var originalUom = InternalUnitSystemManager.Instance.UnitOfMeasures["m"].ToModelUom();
var originalValue = new NumericValue(originalUom, 1.75);
var originalNumber = new NumericRepresentationValue(RepresentationInstanceList.vrDistanceTraveled.ToModelRepresentation(), originalValue);
var secondUom = _ftUnitOfMeasure.ToModelUom();
var secondNumber = new NumericValue(secondUom, 3.5);
var expected = 0.6832; //1.75m + (3.5ft -> m)
var actual = originalNumber.Subtract(secondNumber);
Assert.IsInstanceOf <NumericRepresentationValue>(actual);
Assert.AreEqual(expected, actual.Value.Value, Epsilon);
Assert.AreSame(originalUom, actual.Value.UnitOfMeasure);
}
