/// <summary>
/// Tries to convert each axis of the metric of the quantity once.
/// </summary>
/// <returns>true if a change has been made</returns>
private bool canonicalize(ref Quantity quantity)
{
List<Metric.Axis> axes = new List<Metric.Axis>();
Exponential value = quantity.Value;
bool modified = false;
foreach (Metric.Axis axis in quantity.Metric.Axes)
{
Conversion conversion = Find(axis.Unit);
if (conversion != null)
{
Quantity part = conversion.Convert(1);
part.Metric = part.Metric.MultiplyExponents(axis.Exponent);
part.Value = Exponential.Power(part.Value, axis.Exponent);
axes.AddRange(part.Metric.Axes);
value *= part.Value;
modified = true;
}
else
{
axes.Add(Metric.Axis.CopyOf(axis));
}
}
Metric metric = new Metric(axes);
if (modified)
quantity = new Quantity(value, new Metric(axes));
return modified;
}
public bool Approximates(Quantity q)
{
Quantity a = this.UnPrefixed();
Quantity b = q.UnPrefixed();
bool met = a.Metric.Equals(b.Metric);
bool val = a.Value.Approximates(b.Value);
return met && val;
}
public Quantity Convert(Quantity quantity, Conversion conversion)
{
Quantity baseq = quantity.UnPrefixed();
if (!baseq.Metric.Equals(conversion.To))
throw new InvalidCastException(string.Format("Quantity {0} cannot be converted to {1}", quantity, conversion.To));
Quantity output = conversion.Convert(baseq.Value);
return output;
}
public static bool SameDimension(Quantity a, Quantity b)
{
return(a.Metric.Equals(b.Metric));
}
public static Quantity operator -(Quantity a, Quantity b)
{
return(Quantity.Substract(a, b));
}
public Quantity Convert(Quantity quantity, Metric metric)
{
return Conversions.Convert(quantity, metric);
}
public Quantity Convert(Quantity quantity, Metric metric)
{
return(Conversions.Convert(quantity, metric));
}
/// <summary>
/// Converts a quantity to standardized units without a prefix
/// </summary>
public Quantity Canonical(Quantity quantity)
{
Quantity outcome = Conversions.Canonical(quantity);
return(outcome.UnPrefixed());
}
public Quantity Convert(Quantity quantity, Metric metric)
{
throw new NotImplementedException();
}
public static Quantity CopyOf(Quantity q)
{
return new Quantity(q.Value, q.Metric);
}
public static bool SameDimension(Quantity a, Quantity b)
{
return a.Metric.Equals(b.Metric);
}
public static Quantity Substract(Quantity a, Quantity b)
{
if (!Quantity.SameDimension(a, b))
throw new ArgumentException("Quantities of a different dimension cannot be added ");
a = a.UnPrefixed();
b = b.UnPrefixed();
Exponential value = Exponential.Substract(a.Value, b.Value);
return new Quantity(value, a.Metric);
}
public static Quantity Divide(Quantity a, Quantity b)
{
Exponential value = Exponential.Divide(a.Value, b.Value);
Metric metric = Metric.Divide(a.Metric, b.Metric);
return new Quantity(value, metric);
}
public Quantity Convert(Quantity quantity, string metric)
{
Metric m = Metrics.ParseMetric(metric);
return this.Convert(quantity, m);
}
public static Quantity CopyOf(Quantity q)
{
return(new Quantity(q.Value, q.Metric));
}
/// <summary>
/// Converts a Quantity to it's canonical form in base units without prefixes
/// </summary>
public Quantity Canonical(Quantity quantity)
{
Quantity output = Quantity.CopyOf(quantity).UnPrefixed();
bool canonicalized;
do
{
canonicalized = canonicalize(ref output);
output = output.UnPrefixed();
}
while (canonicalized);
if (!output.IsInBaseUnits())
throw new InvalidCastException("Quantity could not be converted to base units");
output.Metric = output.Metric.Reduced();
return output;
}
public static Quantity Multiply(Quantity a, Quantity b)
{
Exponential value = Exponential.Multiply(a.Value, b.Value);
Metric metric = Metric.Multiply(a.Metric, b.Metric);
return new Quantity(value, metric);
}
public Quantity Convert(Exponential value)
{
Exponential output = this.method(value);
Quantity quantity = new Quantity(output, To);
return quantity;
}
public static Quantity operator *(Quantity a, Quantity b)
{
return(Quantity.Multiply(a, b));
}
public Quantity Convert(Quantity quantity, Metric metric)
{
throw new NotImplementedException();
}
public static Quantity operator /(Quantity a, Quantity b)
{
return(Quantity.Divide(a, b));
}
/// <summary>
/// Interprets an expression as a quantity and converts this to standardized units without a prefix
/// </summary>
public Quantity Canonical(string expression)
{
Quantity quantity = this.Quantity(expression);
return(this.Canonical(quantity));
}
public static Quantity operator +(Quantity a, Quantity b)
{
return(Quantity.Add(a, b));
}
public Quantity Convert(Quantity quantity, string metric)
{
Metric m = Metrics.ParseMetric(metric);
return(this.Convert(quantity, m));
}
/// <summary>
/// Converts a quantity to standardized units without a prefix
/// </summary>
public Quantity Canonical(Quantity quantity)
{
Quantity outcome = Conversions.Canonical(quantity);
return outcome.UnPrefixed();
}
