public ExpressionUnitsConversion(ExpressionUnits fromUnits, ExpressionUnits toUnits, double mult, double add)
{
this.fromUnits = fromUnits;
this.toUnits = toUnits;
this.mult = mult;
this.add = add;
}
public NumericValue ConvertUnits(ExpressionUnits units)
{
var conversion = ExpressionUnitsConversion.GetConversion(Units, units);
var mult = new NumericValue(conversion.mult, conversion.toUnits / conversion.fromUnits);
var add = new NumericValue(conversion.add, conversion.toUnits);
return(this * mult + add);
}
public bool Equals(ExpressionUnits testObj)
{
if (units.Count != testObj.units.Count)
{
return(false);
}
return(!(this / testObj).HasUnits);
}
public static ExpressionUnits GetSimple(ExpressionUnits units)
{
var match = conversionConstants.Values.Where(pair => pair.toUnits.Equals(units)).OrderBy(pair => pair.fromUnits.ToString().Length).FirstOrDefault();
if (match == null)
{
return(units);
}
return(match.fromUnits);
}
public static ExpressionUnitsConversion GetBaseConversion(ExpressionUnits units)
{
var conversion = new ExpressionUnitsConversion(units);
foreach (var unit in units)
{
var unitConversion = conversionConstants.ContainsKey(unit.Unit) ? conversionConstants[unit.Unit] : new ExpressionUnitsConversion(new ExpressionUnits(unit.Unit));
conversion *= unitConversion ^ unit.Exp;
}
return(conversion);
}
public static ExpressionUnitsConversion GetConversion(ExpressionUnits units1, ExpressionUnits units2)
{
var conversion1 = ExpressionUnitsConversion.GetBaseConversion(units1);
var conversion2 = ExpressionUnitsConversion.GetBaseConversion(units2.IsSI ? conversion1.toUnits : units2.IsSimple ? ExpressionUnitsConversion.GetSimple(conversion1.toUnits) : units2);
if (!conversion1.toUnits.Equals(conversion2.toUnits))
{
throw new Exception("Cannot convert units");
}
return(conversion1 / conversion2);
}
public NumericValue(object input, ExpressionUnits units)
{
if (input == null)
{
Value = BigInteger.Zero;
}
else if ((input is BigInteger) || (input is double))
{
Value = input;
}
else if (input is bool)
{
Value = (bool)input ? BigInteger.One : BigInteger.Zero;
}
else if (input is sbyte)
{
Value = new BigInteger((sbyte)input);
}
else if (input is byte)
{
Value = new BigInteger((byte)input);
}
else if (input is short)
{
Value = new BigInteger((short)input);
}
else if (input is ushort)
{
Value = new BigInteger((ushort)input);
}
else if (input is int)
{
Value = new BigInteger((int)input);
}
else if (input is uint)
{
Value = new BigInteger((uint)input);
}
else if (input is long)
{
Value = new BigInteger((long)input);
}
else if (input is ulong)
{
Value = new BigInteger((ulong)input);
}
else if (input is float)
{
Value = (double)(float)input;
}
else if (input is decimal)
{
Value = (double)(decimal)input;
}
else if (input is string)
{
var str = (string)input;
if (str.IsNumeric())
{
Value = BigInteger.Parse(str);
}
else
{
Value = double.Parse(str);
}
}
else
{
throw new Exception("Value is not numeric");
}
Units = units;
if (Value is double)
{
var d = (double)Value;
if ((!double.IsInfinity(d)) && (!double.IsNaN(d)) && (Math.Floor(d) == d))
{
Value = new BigInteger(d);
}
}
}
static void AddConversionConstant(string fromUnitStr, ExpressionUnits toUnit, double mult, double add = 0, ConversionConstantAttr attr = ConversionConstantAttr.None)
{
var fromUnit = new ExpressionUnits(fromUnitStr);
conversionConstants[fromUnitStr] = new ExpressionUnitsConversion(fromUnit, toUnit, mult, add);
List <Tuple <string, double> > addList = null;
switch (attr)
{
case ConversionConstantAttr.SIPrefix:
addList = new List <Tuple <string, double> >
{
Tuple.Create("da", 1e1d),
Tuple.Create("h", 1e2d),
Tuple.Create("k", 1e3d),
Tuple.Create("M", 1e6d),
Tuple.Create("G", 1e9d),
Tuple.Create("g", 1e9d),
Tuple.Create("T", 1e12d),
Tuple.Create("t", 1e12d),
Tuple.Create("P", 1e15d),
Tuple.Create("E", 1e18d),
Tuple.Create("e", 1e18d),
Tuple.Create("Z", 1e21d),
Tuple.Create("Y", 1e24d),
Tuple.Create("d", 1e-1d),
Tuple.Create("c", 1e-2d),
Tuple.Create("m", 1e-3d),
Tuple.Create("µ", 1e-6d),
Tuple.Create("n", 1e-9d),
Tuple.Create("p", 1e-12d),
Tuple.Create("f", 1e-15d),
Tuple.Create("a", 1e-18d),
Tuple.Create("z", 1e-21d),
Tuple.Create("y", 1e-24d),
};
break;
case ConversionConstantAttr.SILongPrefix:
addList = new List <Tuple <string, double> >
{
Tuple.Create("deca", 1e1d),
Tuple.Create("hecto", 1e2d),
Tuple.Create("kilo", 1e3d),
Tuple.Create("mega", 1e6d),
Tuple.Create("giga", 1e9d),
Tuple.Create("tera", 1e12d),
Tuple.Create("peta", 1e15d),
Tuple.Create("exa", 1e18d),
Tuple.Create("zetta", 1e21d),
Tuple.Create("yotta", 1e24d),
Tuple.Create("deci", 1e-1d),
Tuple.Create("centi", 1e-2d),
Tuple.Create("milli", 1e-3d),
Tuple.Create("micro", 1e-6d),
Tuple.Create("nano", 1e-9d),
Tuple.Create("pico", 1e-12d),
Tuple.Create("femto", 1e-15d),
Tuple.Create("atto", 1e-18d),
Tuple.Create("zepto", 1e-21d),
Tuple.Create("yocto", 1e-24d),
};
break;
case ConversionConstantAttr.CPrefix:
addList = new List <Tuple <string, double> >
{
Tuple.Create("K", 1024d),
Tuple.Create("k", 1024d),
Tuple.Create("M", 1048576d),
Tuple.Create("m", 1048576d),
Tuple.Create("G", 1073741824d),
Tuple.Create("g", 1073741824d),
Tuple.Create("T", 1099511627776d),
Tuple.Create("t", 1099511627776d),
Tuple.Create("P", 1125899906842624d),
Tuple.Create("p", 1125899906842624d),
Tuple.Create("E", 1152921504606846976d),
Tuple.Create("e", 1152921504606846976d),
Tuple.Create("Z", 1180591620717411303424d),
Tuple.Create("z", 1180591620717411303424d),
Tuple.Create("Y", 1208925819614629174706176d),
Tuple.Create("y", 1208925819614629174706176d),
};
break;
case ConversionConstantAttr.CLongPrefix:
addList = new List <Tuple <string, double> >
{
Tuple.Create("kilo", 1024d),
Tuple.Create("mega", 1048576d),
Tuple.Create("giga", 1073741824d),
Tuple.Create("tera", 1099511627776d),
Tuple.Create("peta", 1125899906842624d),
Tuple.Create("exa", 1152921504606846976d),
Tuple.Create("zetta", 1180591620717411303424d),
Tuple.Create("yotta", 1208925819614629174706176d),
};
break;
default: return;
}
foreach (var tuple in addList)
{
var newFromUnit = new ExpressionUnits(tuple.Item1 + fromUnitStr);
conversionConstants[newFromUnit.Single().Unit] = new ExpressionUnitsConversion(newFromUnit, fromUnit, tuple.Item2, add);
}
}
public ExpressionUnitsConversion(ExpressionUnits units)
{
fromUnits = toUnits = units;
}
