/// <summary> /// Creates the quantity with the given numeric value and unit. /// </summary> /// <param name="value">The numeric value to construct this quantity with.</param> /// <param name="unit">The unit representation to construct this quantity with.</param> /// <remarks>Value parameter cannot be named 'value' due to constraint when targeting Windows Runtime Component.</remarks> /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception> private VolumeConcentration(double value, VolumeConcentrationUnit unit) { if (unit == VolumeConcentrationUnit.Undefined) { throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit)); } _value = value; _unit = unit; }
/// <summary> /// Creates the quantity with the given numeric value and unit. /// </summary> /// <param name="numericValue">The numeric value to contruct this quantity with.</param> /// <param name="unit">The unit representation to contruct this quantity with.</param> /// <remarks>Value parameter cannot be named 'value' due to constraint when targeting Windows Runtime Component.</remarks> /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception> private VolumeConcentration(double numericValue, VolumeConcentrationUnit unit) { if (unit == VolumeConcentrationUnit.Undefined) { throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit)); } _value = Guard.EnsureValidNumber(numericValue, nameof(numericValue)); _unit = unit; }
private decimal AsBaseNumericType(VolumeConcentrationUnit unit) { if (Unit == unit) { return(_value); } var baseUnitValue = AsBaseUnit(); switch (unit) { case VolumeConcentrationUnit.CentilitersPerLiter: return((baseUnitValue) / 1e-2m); case VolumeConcentrationUnit.CentilitersPerMililiter: return((baseUnitValue * 1e-3m) / 1e-2m); case VolumeConcentrationUnit.DecilitersPerLiter: return((baseUnitValue) / 1e-1m); case VolumeConcentrationUnit.DecilitersPerMililiter: return((baseUnitValue * 1e-3m) / 1e-1m); case VolumeConcentrationUnit.DecimalFraction: return(baseUnitValue); case VolumeConcentrationUnit.LitersPerLiter: return(baseUnitValue); case VolumeConcentrationUnit.LitersPerMililiter: return(baseUnitValue * 1e-3m); case VolumeConcentrationUnit.MicrolitersPerLiter: return((baseUnitValue) / 1e-6m); case VolumeConcentrationUnit.MicrolitersPerMililiter: return((baseUnitValue * 1e-3m) / 1e-6m); case VolumeConcentrationUnit.MillilitersPerLiter: return((baseUnitValue) / 1e-3m); case VolumeConcentrationUnit.MillilitersPerMililiter: return((baseUnitValue * 1e-3m) / 1e-3m); case VolumeConcentrationUnit.NanolitersPerLiter: return((baseUnitValue) / 1e-9m); case VolumeConcentrationUnit.NanolitersPerMililiter: return((baseUnitValue * 1e-3m) / 1e-9m); case VolumeConcentrationUnit.PartPerBillion: return(baseUnitValue * 1e9m); case VolumeConcentrationUnit.PartPerMillion: return(baseUnitValue * 1e6m); case VolumeConcentrationUnit.PartPerThousand: return(baseUnitValue * 1e3m); case VolumeConcentrationUnit.PartPerTrillion: return(baseUnitValue * 1e12m); case VolumeConcentrationUnit.Percent: return(baseUnitValue * 1e2m); case VolumeConcentrationUnit.PicolitersPerLiter: return((baseUnitValue) / 1e-12m); case VolumeConcentrationUnit.PicolitersPerMililiter: return((baseUnitValue * 1e-3m) / 1e-12m); default: throw new NotImplementedException($"Can not convert {Unit} to {unit}."); } }
private double GetValueAs(VolumeConcentrationUnit unit) { if (Unit == unit) { return(_value); } var baseUnitValue = GetValueInBaseUnit(); switch (unit) { case VolumeConcentrationUnit.CentilitersPerLiter: return((baseUnitValue) / 1e-2d); case VolumeConcentrationUnit.CentilitersPerMililiter: return((baseUnitValue * 1e-3) / 1e-2d); case VolumeConcentrationUnit.DecilitersPerLiter: return((baseUnitValue) / 1e-1d); case VolumeConcentrationUnit.DecilitersPerMililiter: return((baseUnitValue * 1e-3) / 1e-1d); case VolumeConcentrationUnit.DecimalFraction: return(baseUnitValue); case VolumeConcentrationUnit.LitersPerLiter: return(baseUnitValue); case VolumeConcentrationUnit.LitersPerMililiter: return(baseUnitValue * 1e-3); case VolumeConcentrationUnit.MicrolitersPerLiter: return((baseUnitValue) / 1e-6d); case VolumeConcentrationUnit.MicrolitersPerMililiter: return((baseUnitValue * 1e-3) / 1e-6d); case VolumeConcentrationUnit.MillilitersPerLiter: return((baseUnitValue) / 1e-3d); case VolumeConcentrationUnit.MillilitersPerMililiter: return((baseUnitValue * 1e-3) / 1e-3d); case VolumeConcentrationUnit.NanolitersPerLiter: return((baseUnitValue) / 1e-9d); case VolumeConcentrationUnit.NanolitersPerMililiter: return((baseUnitValue * 1e-3) / 1e-9d); case VolumeConcentrationUnit.PartPerBillion: return(baseUnitValue * 1e9); case VolumeConcentrationUnit.PartPerMillion: return(baseUnitValue * 1e6); case VolumeConcentrationUnit.PartPerThousand: return(baseUnitValue * 1e3); case VolumeConcentrationUnit.PartPerTrillion: return(baseUnitValue * 1e12); case VolumeConcentrationUnit.Percent: return(baseUnitValue * 1e2); case VolumeConcentrationUnit.PicolitersPerLiter: return((baseUnitValue) / 1e-12d); case VolumeConcentrationUnit.PicolitersPerMililiter: return((baseUnitValue * 1e-3) / 1e-12d); default: throw new NotImplementedException($"Can not convert {Unit} to {unit}."); } }
/// <summary> /// Convert to the unit representation <paramref name="unit" />. /// </summary> /// <returns>Value converted to the specified unit.</returns> public double As(VolumeConcentrationUnit unit) { if (Unit == unit) { return(Convert.ToDouble(Value)); } var converted = AsBaseNumericType(unit); return(Convert.ToDouble(converted)); }
0.01142805, MolarityUnit.MolePerLiter)] // 10 % dilution of HCL public void MolarityFromDilutedSolution( double startingMolarityValue, MolarityUnit startingMolarityUnit, double newConcentration, VolumeConcentrationUnit newConcentrationUnit, double expectedMolarityValue, MolarityUnit expectedMolarityUnit, double tolerence = 1e-5) { var startingMolarity = new Molarity(startingMolarityValue, startingMolarityUnit); var newVolumeConc = new VolumeConcentration(newConcentration, newConcentrationUnit); Molarity dilutedMolarity = startingMolarity * newVolumeConc; AssertEx.EqualTolerance(expectedMolarityValue, dilutedMolarity.As(expectedMolarityUnit), tolerence); }
0.5, VolumeConcentrationUnit.DecimalFraction)] // synthetic data public void VolumeConcentrationFromMassConcentrationAndDensity( double componentDensityValue, DensityUnit componentDensityUnit, double massConcValue, MassConcentrationUnit masConcUnit, double expectedVolumeConcValue, VolumeConcentrationUnit expectedVolumeConcUnit, double tolerence = 1e-5) { var density = new Density(componentDensityValue, componentDensityUnit); var massConcentration = new MassConcentration(massConcValue, masConcUnit); VolumeConcentration volumeConcentration = massConcentration.ToVolumeConcentration(density); // massConcentration / density; AssertEx.EqualTolerance(expectedVolumeConcValue, volumeConcentration.As(expectedVolumeConcUnit), tolerence); }
23.03422, MassConcentrationUnit.GramPerLiter)] // 29.19419518377693 = VolumeConcentration_0_5M_Ethanol public void MassConcentrationFromVolumeConcentrationAndComponentDensity( double volumeConcValue, VolumeConcentrationUnit volumeConcUnit, double componentDensityValue, DensityUnit componentDensityUnit, double expectedMassConcValue, MassConcentrationUnit expectedMassConcUnit, double tolerence = 1e-5) { var volumeConcentration = new VolumeConcentration(volumeConcValue, volumeConcUnit); var componentDensity = new Density(componentDensityValue, componentDensityUnit); MassConcentration massConcentration = volumeConcentration.ToMassConcentration(componentDensity); // volumeConcentration * density AssertEx.EqualTolerance(expectedMassConcValue, massConcentration.As(expectedMassConcUnit), tolerence); }
0.5, MolarityUnit.MolesPerLiter)] // 29.19419518377693 = VolumeConcentration_0_5M_Ethanol public void MolarityFromVolumeConcentrationAndComponentDensityAndMolarMass( double volumeConcValue, VolumeConcentrationUnit volumeConcUnit, double componentDensityValue, DensityUnit componetDensityUnit, double componentMolarMassValue, MolarMassUnit componentMolarMassUnit, double expectedMolarityValue, MolarityUnit expectedMolarityUnit, double tolerence = 1e-5) { var volumeConcentration = new VolumeConcentration(volumeConcValue, volumeConcUnit); var componentDensity = new Density(componentDensityValue, componetDensityUnit); var componentMolarMass = new MolarMass(componentMolarMassValue, componentMolarMassUnit); Molarity molarity = volumeConcentration.ToMolarity(componentDensity, componentMolarMass); // volumeConcentration * density / molarMass AssertEx.EqualTolerance(expectedMolarityValue, molarity.As(expectedMolarityUnit), tolerence); }
29.19419518377693, VolumeConcentrationUnit.MillilitersPerLiter)] // 0.5M ethanol public void VolumeConcentrationFromComponentDensityAndMolarity( double molarityValue, MolarityUnit molarityUnit, double componentDensityValue, DensityUnit componentDensityUnit, double componentMolarMassValue, MolarMassUnit compontMolarMassUnit, double expectedVolumeConcValue, VolumeConcentrationUnit expectedVolumeConcUnit, double tolerence = 1e-5) { var molarity = new Molarity(molarityValue, molarityUnit); var componentDensity = new Density(componentDensityValue, componentDensityUnit); var componentMolarMass = new MolarMass(componentMolarMassValue, compontMolarMassUnit); VolumeConcentration volumeConcentration = molarity.ToVolumeConcentration(componentDensity, componentMolarMass); AssertEx.EqualTolerance(expectedVolumeConcValue, volumeConcentration.As(expectedVolumeConcUnit), tolerence); }
/// <summary> /// Creates the quantity with the given numeric value and unit. /// </summary> /// <param name="value">The numeric value to construct this quantity with.</param> /// <param name="unit">The unit representation to construct this quantity with.</param> /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception> public VolumeConcentration(double value, VolumeConcentrationUnit unit) { _value = value; _unit = unit; }
public static void HasConversion(this PropertyBuilder <VolumeConcentration> propertyBuilder, VolumeConcentrationUnit unit) => propertyBuilder.HasConversion(v => v.As(unit), v => new VolumeConcentration(v, unit));
/// <summary> /// Converts this Duration to another Duration with the unit representation <paramref name="unit" />. /// </summary> /// <returns>A Duration with the specified unit.</returns> public VolumeConcentration ToUnit(VolumeConcentrationUnit unit) { var convertedValue = GetValueAs(unit); return(new VolumeConcentration(convertedValue, unit)); }
/// <summary> /// Convert to the unit representation <paramref name="unit" />. /// </summary> /// <returns>Value converted to the specified unit.</returns> public double As(VolumeConcentrationUnit unit) => GetValueAs(unit);
/// <summary> /// Dynamically convert from value and unit enum <see cref="VolumeConcentrationUnit" /> to <see cref="VolumeConcentration" />. /// </summary> /// <param name="value">Value to convert from.</param> /// <param name="fromUnit">Unit to convert from.</param> /// <returns>VolumeConcentration unit value.</returns> public static VolumeConcentration From(double value, VolumeConcentrationUnit fromUnit) { return(new VolumeConcentration(value, fromUnit)); }
/// <summary> /// Get unit abbreviation string. /// </summary> /// <param name="unit">Unit to get abbreviation for.</param> /// <returns>Unit abbreviation string.</returns> public static string GetAbbreviation(VolumeConcentrationUnit unit) { return(GetAbbreviation(unit, null)); }
/// <summary> /// Get unit abbreviation string. /// </summary> /// <param name="unit">Unit to get abbreviation for.</param> /// <returns>Unit abbreviation string.</returns> /// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param> public static string GetAbbreviation(VolumeConcentrationUnit unit, [CanBeNull] string cultureName) { IFormatProvider provider = GetFormatProviderFromCultureName(cultureName); return(UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider)); }
public static bool TryParseUnit(string str, out VolumeConcentrationUnit unit) { return(TryParseUnit(str, null, out unit)); }
/// <summary> /// Parse a unit string. /// </summary> /// <param name="str">String to parse. Typically in the form: {number} {unit}</param> /// <param name="unit">The parsed unit if successful.</param> /// <returns>True if successful, otherwise false.</returns> /// <example> /// Length.TryParseUnit("m", new CultureInfo("en-US")); /// </example> /// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param> public static bool TryParseUnit(string str, [CanBeNull] string cultureName, out VolumeConcentrationUnit unit) { IFormatProvider provider = GetFormatProviderFromCultureName(cultureName); return(UnitParser.Default.TryParse <VolumeConcentrationUnit>(str, provider, out unit)); }
/// <summary> /// Converts this VolumeConcentration to another VolumeConcentration with the unit representation <paramref name="unit" />. /// </summary> /// <returns>A VolumeConcentration with the specified unit.</returns> public VolumeConcentration ToUnit(VolumeConcentrationUnit unit) { var convertedValue = AsBaseNumericType(unit); return(new VolumeConcentration(convertedValue, unit)); }
public static VolumeConcentration From(decimal value, VolumeConcentrationUnit fromUnit) { return(new VolumeConcentration((decimal)value, fromUnit)); }