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