/// <summary>
/// Divides the right unit from the left unit: <paramref name="Left"/>/<paramref name="Right"/>.
/// </summary>
/// <param name="Left">Left unit.</param>
/// <param name="Right">Right unit.</param>
/// <param name="ResidueExponent">Any residual exponent resulting from the division.</param>
/// <returns>Resulting unit.</returns>
public static Unit Divide(Unit Left, Unit Right, out int ResidueExponent)
{
LinkedList <KeyValuePair <AtomicUnit, int> > Result = new LinkedList <KeyValuePair <AtomicUnit, int> >();
int LeftExponent = Prefixes.PrefixToExponent(Left.prefix);
int RightExponent = Prefixes.PrefixToExponent(Right.prefix);
int ResultExponent = LeftExponent - RightExponent;
Prefix ResultPrefix = Prefixes.ExponentToPrefix(ResultExponent, out ResidueExponent);
LinkedListNode <KeyValuePair <AtomicUnit, int> > Loop;
string Name;
int Exponent;
bool Found;
foreach (KeyValuePair <AtomicUnit, int> Factor in Left.factors)
{
Result.AddLast(Factor);
}
foreach (KeyValuePair <AtomicUnit, int> Factor in Right.factors)
{
Name = Factor.Key.Name;
Loop = Result.First;
Found = false;
while (!(Loop is null) && !Found)
{
if (Loop.Value.Key.Name == Name)
{
Found = true;
Exponent = Loop.Value.Value - Factor.Value;
if (Exponent == 0)
{
Result.Remove(Loop);
}
else
{
Loop.Value = new KeyValuePair <AtomicUnit, int>(Loop.Value.Key, Exponent);
}
}
else
{
Loop = Loop.Next;
}
}
if (Found)
{
continue;
}
Result.AddLast(new KeyValuePair <AtomicUnit, int>(Factor.Key, -Factor.Value));
}
return(new Unit(ResultPrefix, Result));
}
/// <summary>
/// Inverts the unit.
/// </summary>
/// <param name="ResidueExponent">Any exponential residue. If this value is 0, it means the exponent corresponds exactly
/// to the returned prefix.</param>
/// <returns>Inverted unit.</returns>
public Unit Invert(out int ResidueExponent)
{
int Exponent = Prefixes.PrefixToExponent(this.prefix);
LinkedList <KeyValuePair <AtomicUnit, int> > Factors = new LinkedList <KeyValuePair <AtomicUnit, int> >();
foreach (KeyValuePair <AtomicUnit, int> Factor in this.factors)
{
Factors.AddLast(new KeyValuePair <AtomicUnit, int>(Factor.Key, -Factor.Value));
}
return(new Unit(Prefixes.ExponentToPrefix(-Exponent, out ResidueExponent), Factors));
}
/// <summary>
/// Converts the unit to a series of reference unit factors. (Unrecognized units will be assumed to be reference units.)
/// </summary>
/// <param name="Magnitude">Reference magnitude.</param>
/// <returns>Unit consisting of reference unit factors.</returns>
public Unit FromReferenceUnits(ref double Magnitude)
{
if (this.hasReferenceUnits)
{
return(this);
}
lock (synchObject)
{
if (baseUnits is null)
{
Search();
}
bool HasNonReference = false;
foreach (KeyValuePair <AtomicUnit, int> Factor in this.factors)
{
if (!referenceUnits.ContainsKey(Factor.Key.Name))
{
HasNonReference = true;
break;
}
}
if (HasNonReference)
{
LinkedList <KeyValuePair <AtomicUnit, int> > ReferenceFactors = new LinkedList <KeyValuePair <AtomicUnit, int> >();
int Exponent = Prefixes.PrefixToExponent(this.prefix);
int FactorExponent;
string Name;
foreach (KeyValuePair <AtomicUnit, int> Factor in this.factors)
{
FactorExponent = Factor.Value;
if (referenceUnits.ContainsKey(Name = Factor.Key.Name))
{
this.Add(ReferenceFactors, Factor.Key, Factor.Value);
}
else if (baseUnits.TryGetValue(Name, out IBaseQuantity BaseQuantity))
{
if (BaseQuantity.FromReferenceUnit(ref Magnitude, Name, FactorExponent))
{
this.Add(ReferenceFactors, BaseQuantity.ReferenceUnit, FactorExponent);
}
else
{
this.Add(ReferenceFactors, Factor.Key, Factor.Value);
}
}
else if (derivedUnits.TryGetValue(Name, out PhysicalQuantity Quantity))
{
Magnitude *= Math.Pow(Quantity.Magnitude, FactorExponent);
Exponent += Prefixes.PrefixToExponent(Quantity.Unit.prefix) * FactorExponent;
foreach (KeyValuePair <AtomicUnit, int> Segment in Quantity.Unit.factors)
{
if (referenceUnits.ContainsKey(Name = Segment.Key.Name))
{
this.Add(ReferenceFactors, Segment.Key, Segment.Value * FactorExponent);
}
else if (baseUnits.TryGetValue(Name, out BaseQuantity))
{
if (BaseQuantity.FromReferenceUnit(ref Magnitude, Name, Segment.Value * FactorExponent))
{
this.Add(ReferenceFactors, BaseQuantity.ReferenceUnit, Segment.Value * FactorExponent);
}
else
{
this.Add(ReferenceFactors, Segment.Key, Segment.Value * FactorExponent);
}
}
else
{
this.Add(ReferenceFactors, Segment.Key, Segment.Value * FactorExponent);
}
}
}
else if (compoundUnits.TryGetValue(Name, out KeyValuePair <AtomicUnit, int>[] Units))
{
foreach (KeyValuePair <AtomicUnit, int> Segment in Units)
{
if (referenceUnits.ContainsKey(Name = Segment.Key.Name))
{
this.Add(ReferenceFactors, Segment.Key, Segment.Value * FactorExponent);
}
else if (baseUnits.TryGetValue(Name, out BaseQuantity))
{
if (BaseQuantity.FromReferenceUnit(ref Magnitude, Name, Segment.Value * FactorExponent))
{
this.Add(ReferenceFactors, BaseQuantity.ReferenceUnit, Segment.Value * FactorExponent);
}
else
{
this.Add(ReferenceFactors, Segment.Key, Segment.Value * FactorExponent);
}
}
else
{
this.Add(ReferenceFactors, Segment.Key, Segment.Value * FactorExponent);
}
}
}
else
{
this.Add(ReferenceFactors, Factor.Key, Factor.Value);
}
}
Unit Result = new Unit(Prefixes.ExponentToPrefix(Exponent, out FactorExponent), ReferenceFactors);
if (FactorExponent != 0)
{
Magnitude *= Math.Pow(10, FactorExponent);
}
Result.hasBaseUnits = true;
Result.hasReferenceUnits = true;
return(Result);
}
else
{
this.hasBaseUnits = true;
this.hasReferenceUnits = true;
return(this);
}
}
}