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); }