/// <summary>Creates a quantity with the provided value in the given prefixed unit.</summary>
/// <param name="value">The value of the created quantity.</param>
/// <param name="prefix">The prefix of the unit.</param>
/// <param name="unit">The unit of the created quantity.</param>
public DimensionfulQuantity(double value, SIPrefix prefix, IUnit unit)
{
if (null == unit)
{
throw new ArgumentNullException(nameof(unit));
}
if (unit is IPrefixedUnit punit)
{
_unit = punit.Unit;
(var newPrefix, var remainingFactor) = SIPrefix.FromMultiplication(prefix, punit.Prefix);
_prefix = newPrefix;
_value = value * remainingFactor;
}
else
{
_value = value;
_prefix = prefix ?? SIPrefix.None;
_unit = unit;
}
if (_unit is IPrefixedUnit)
{
throw new ArgumentException("Nested IPrefixedUnit is not supported");
}
if (_unit is IBiasedUnit && _prefix != SIPrefix.None)
{
throw new ArgumentException("Biased units must not have a prefix!");
}
}
/// <summary>Converts this quantity to its numerical value in the given unit, with the given prefix.</summary>
/// <param name="prefix">The prefix of the unit in which to get the numerical value of this quantity.</param>
/// <param name="unit">The unit in which to get the numerical value of this quantity.</param>
/// <returns>Numerical value of this quantity in the provided unit with the provided prefix.</returns>
public double AsValueIn(SIPrefix prefix, IUnit unit)
{
if (double.IsNaN(_value))
{
return(_value);
}
if (null == unit)
{
throw new ArgumentNullException("unit");
}
if (null == prefix)
{
throw new ArgumentNullException("prefix");
}
if (null == _unit)
{
throw new InvalidOperationException("This instance is empty");
}
if (unit.SIUnit != _unit.SIUnit)
{
throw new ArgumentException(string.Format("Provided unit ({0}) is incompatible with this unit ({1})", unit.SIUnit, _unit));
}
return(prefix.FromSIUnit(unit.FromSIUnit(AsValueInSIUnits)));
}
public UnitRatioComposite(SIPrefix nominatorPrefix, IUnit nominatorUnit, SIPrefix denominatorPrefix, IUnit denominatorUnit)
{
_nominatorPrefix = nominatorPrefix ?? SIPrefix.None;
_nominatorUnit = nominatorUnit ?? throw new ArgumentException(nameof(nominatorUnit));
_denominatorPrefix = denominatorPrefix ?? SIPrefix.None;
_denominatorUnit = denominatorUnit ?? throw new ArgumentException(nameof(denominatorUnit));
}
public static DimensionfulQuantity operator *(DimensionfulQuantity a, DimensionfulQuantity b)
{
(var newPrefix, var remainingFactor) = SIPrefix.FromMultiplication(a.Prefix, b.Prefix);
return(new DimensionfulQuantity(
remainingFactor * a.AsValueInSIUnits * b.AsValueInSIUnits,
newPrefix,
a.Unit.SIUnit * b.Unit.SIUnit));
}
public static DimensionfulQuantity operator /(double a, DimensionfulQuantity b)
{
b = b.TreatedAsUnbiasedDifference;
(var newPrefix, var remainingFactor) = SIPrefix.FromDivision(SIPrefix.None, b.Prefix);
return(new DimensionfulQuantity(
remainingFactor * a / b.AsValueInSIUnits,
newPrefix,
Dimensionless.Unity.Instance / b.Unit.SIUnit));
}
public static DimensionfulQuantity operator /(DimensionfulQuantity a, DimensionfulQuantity b)
{
a = a.TreatedAsUnbiasedDifference;
b = b.TreatedAsUnbiasedDifference;
(var newPrefix, var remainingFactor) = SIPrefix.FromDivision(a.Prefix, b.Prefix);
return(new DimensionfulQuantity(
remainingFactor * a.AsValueInSIUnits / b.AsValueInSIUnits,
newPrefix,
a.Unit.SIUnit / b.Unit.SIUnit));
}
public object Deserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent)
{
int count = info.OpenArray("PrefixList");
var list = new SIPrefix[count];
for (int i = 0; i < count; ++i)
{
list[i] = (SIPrefix)info.GetValue("e", parent);
}
info.CloseArray(count);
return(new SIPrefixList(list));
}
public object Deserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent)
{
var exponent = info.GetInt32("Exponent");
var name = info.GetString("Name");
var shortcut = info.GetString("Shortcut");
if (SIPrefix.TryGetPrefixFromExponent(exponent, out var prefix))
{
return(prefix);
}
else
{
return(new SIPrefix(name, shortcut, exponent));
}
}
public PrefixedUnit(SIPrefix prefix, IUnit unit)
{
if (unit is IPrefixedUnit punit)
{
if (punit.Unit is IPrefixedUnit)
{
throw new ArgumentException("Multiple nesting of IPrefixedUnit is not supported", nameof(unit));
}
(var newPrefix, var factor) = SIPrefix.FromMultiplication(prefix, punit.Prefix);
if (1 != factor)
{
throw new ArgumentException(string.Format("Can not combine prefix {0} with prefix {1} to a new prefix without additional factor", prefix.Name, punit.Prefix.Name));
}
_unit = punit.Unit;
_prefix = newPrefix;
}
else
{
_prefix = prefix;
_unit = unit;
}
}
/// <summary>Creates a quantity with the provided value in the given prefixed unit.</summary>
/// <param name="value">The value of the created quantity.</param>
/// <param name="prefixedUnit">The prefixed unit of the created quanity.</param>
public DimensionfulQuantity(double value, IPrefixedUnit prefixedUnit)
{
_value = value;
_prefix = prefixedUnit.Prefix;
_unit = prefixedUnit.Unit;
}
/// <summary>Converts this quantity to another quantity in the provided unit, with the provided prefix.</summary>
/// <param name="prefix">The prefix of the unit to convert the quantity to.</param>
/// <param name="unit">The unit to convert the quantity to.</param>
/// <returns>New instance of a quantity in the provided unit with the provided prefix.</returns>
public DimensionfulQuantity AsQuantityIn(SIPrefix prefix, IUnit unit)
{
return(new DimensionfulQuantity(AsValueIn(prefix, unit), prefix, unit));
}
