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) || (input is byte) || (input is short) || (input is ushort) || (input is int) || (input is uint) || (input is long) || (input is ulong))
Value = new BigInteger((long)Convert.ChangeType(input, typeof(long)));
else if ((input is float) || (input is decimal))
Value = Convert.ChangeType(input, typeof(double));
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);
}
}
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;
}
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 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 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 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 ExpressionUnitsConversion(ExpressionUnits units) { fromUnits = toUnits = units; }
