void myFunc(double x, string result)
{
var pc = new PrefixConversion();
var res = pc.UnitConversion(x);
Console.WriteLine(res);
Assert.AreEqual(res, result);
}
public void TestMethod1()
{
var pc = new PrefixConversion();
var res = pc.UnitConversion(1.0E7);
Console.WriteLine(res);
Assert.AreEqual(res, "10 M");
}
public void PrefixMicroConversion()
{
var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Metres, settings.Micro);
settings.Metres.PrefixConversions.Add(conversion);
Assert.AreEqual("micrometres/1000000", conversion.ToSi);
Assert.AreEqual("1000000*metres", conversion.FromSi);
Assert.AreEqual("1 µm = 1E-06 m", conversion.SymbolConversion);
Assert.AreEqual(true, conversion.CanRoundtrip);
}
public static void CreateMilligrams()
{
using var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Grams, settings.Milli);
settings.Grams.PrefixConversions.Add(conversion);
Assert.AreEqual("Milligrams", conversion.Name);
Assert.AreEqual("mg", conversion.Symbol);
Assert.AreEqual(1E-6, conversion.Factor);
}
public static void CreateMilliAmperes()
{
using var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Amperes, settings.Milli);
settings.Amperes.PrefixConversions.Add(conversion);
Assert.AreEqual("Milliamperes", conversion.Name);
Assert.AreEqual("mA", conversion.Symbol);
Assert.AreEqual(0.001, conversion.Factor);
}
public void NestedFactorConversion()
{
var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Grams, settings.Milli);
settings.Grams.PrefixConversions.Add(conversion);
Assert.AreEqual("milligrams/1000000", conversion.ToSi);
Assert.AreEqual("1000000*kilograms", conversion.FromSi);
Assert.AreEqual("1 mg = 1E-06 kg", conversion.SymbolConversion);
Assert.AreEqual(true, conversion.CanRoundtrip);
}
public async Task NestedFactorConversion()
{
var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Grams, settings.Milli);
settings.Grams.PrefixConversions.Add(conversion);
Assert.AreEqual("milligrams / 1000000", conversion.ToSi);
Assert.AreEqual("1000000 * kilograms", conversion.FromSi);
Assert.AreEqual("1 mg = 1E-06 kg", await conversion.GetSymbolConversionAsync().ConfigureAwait(false));
Assert.AreEqual(true, await conversion.CanRoundtripAsync().ConfigureAwait(false));
}
public async Task PrefixMicroConversion()
{
var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Metres, settings.Micro);
settings.Metres.PrefixConversions.Add(conversion);
Assert.AreEqual("micrometres / 1000000", conversion.ToSi);
Assert.AreEqual("1000000 * metres", conversion.FromSi);
Assert.AreEqual("1 µm = 1E-06 m", await conversion.GetSymbolConversionAsync().ConfigureAwait(false));
Assert.AreEqual(true, await conversion.CanRoundtripAsync().ConfigureAwait(false));
}
public void SquareMillimetres()
{
var settings = MockSettings.Create();
var millimetres = PrefixConversion.Create(settings.Metres, settings.Milli);
settings.Metres.PrefixConversions.Add(millimetres);
var millimetrePart = PartConversion.CreatePart(2, millimetres);
var conversion = PartConversion.Create(settings.Metres, millimetrePart);
Assert.AreEqual("mm²", conversion.Symbol);
Assert.AreEqual("SquareMillimetres", conversion.Name);
Assert.AreEqual(1E-6, conversion.Factor);
}
public void PartConversionPrefix()
{
var settings = MockSettings.Create();
var millimetreConversion = PrefixConversion.Create(settings.Metres, settings.Milli);
settings.Metres.PrefixConversions.Add(millimetreConversion);
var milliMetresPart = PartConversion.CreatePart(1, millimetreConversion);
var secondsPart = PartConversion.CreatePart(-1, settings.Seconds);
var conversion = PartConversion.Create(settings.MetresPerSecond, milliMetresPart, secondsPart);
settings.MetresPerSecond.PartConversions.Add(conversion);
Assert.AreEqual("millimetresPerSecond/1000", conversion.ToSi);
Assert.AreEqual("1000*metresPerSecond", conversion.FromSi);
Assert.AreEqual("1 mm/s = 0.001 m/s", conversion.SymbolConversion);
Assert.AreEqual(true, conversion.CanRoundtrip);
}
public void MilliGramsPerCubicMetre()
{
var settings = MockSettings.Create();
var milligram = PrefixConversion.Create(settings.Grams, settings.Milli);
settings.Grams.PrefixConversions.Add(milligram);
var milliGramPart = PartConversion.CreatePart(1, milligram);
var volumePart = PartConversion.CreatePart(-1, settings.CubicMetres);
var conversion = PartConversion.Create(settings.Kilograms, milliGramPart, volumePart);
Assert.AreEqual("mg/m³", conversion.Symbol);
Assert.AreEqual("MilligramsPerCubicMetre", conversion.Name);
Assert.AreEqual(1E-6, conversion.Factor);
}
public void SetIsUsedToTrueAddsConversion()
{
var settings = MockSettings.Create();
var prefixConversion = PrefixConversion.Create(settings.Amperes, settings.Milli);
var conversionVm = PrefixConversionVm.Create(settings.Amperes, settings.Milli);
Assert.IsFalse(conversionVm.IsUsed);
Assert.IsEmpty(settings.Amperes.PrefixConversions);
conversionVm.IsUsed = true;
var expected = new[] { prefixConversion };
CollectionAssert.AreEqual(expected, settings.Amperes.PrefixConversions, PrefixConversionComparer.Default);
}
public async Task MilliMetresPerSecondCubed()
{
var settings = MockSettings.Create();
var millimetres = PrefixConversion.Create(settings.Metres, settings.Milli);
settings.Metres.PrefixConversions.Add(millimetres);
var metrePart = PartConversion.CreatePart(1, millimetres);
var secondPart = PartConversion.CreatePart(-2, settings.Seconds);
var conversion = PartConversion.Create(settings.MetresPerSecondSquared, metrePart, secondPart);
Assert.AreEqual("mm/s²", conversion.Symbol);
Assert.AreEqual("MillimetresPerSecondSquared", conversion.Name);
Assert.AreEqual(0.001, conversion.Factor);
Assert.AreEqual(true, await conversion.CanRoundtripAsync().ConfigureAwait(false));
}
public static async Task CubicMillimetresAsync()
{
using var settings = MockSettings.Create();
var millimetres = PrefixConversion.Create(settings.Metres, settings.Milli);
settings.Metres.PrefixConversions.Add(millimetres);
var conversion = PartConversion.Create(settings.CubicMetres, new PowerPart(3, millimetres));
using var conversionVm = new PartConversionVm(settings.CubicMetres, conversion);
Assert.AreEqual(1E-9, ((PartConversion)conversionVm.Conversion).Factor);
Assert.AreEqual("cubicMillimetres / 1000000000", conversionVm.Conversion.ToSi);
Assert.AreEqual("1000000000 * cubicMetres", conversionVm.Conversion.FromSi);
Assert.AreEqual("1 mm³ = 1E-09 m³", await conversionVm.Conversion.GetSymbolConversionAsync().ConfigureAwait(false));
Assert.AreEqual(true, await conversionVm.Conversion.CanRoundtripAsync().ConfigureAwait(false));
}
public void CubicMillimetres()
{
var settings = MockSettings.Create();
var millimetres = PrefixConversion.Create(settings.Metres, settings.Milli);
settings.Metres.PrefixConversions.Add(millimetres);
var conversion = PartConversion.Create(settings.CubicMetres, new PartConversion.PowerPart(3, millimetres));
var conversionVm = new PartConversionVm(settings.CubicMetres, conversion);
Assert.AreEqual(1E-9, conversionVm.Conversion.Factor);
Assert.AreEqual("cubicMillimetres/1000000000", conversionVm.Conversion.ToSi);
Assert.AreEqual("1000000000*cubicMetres", conversionVm.Conversion.FromSi);
Assert.AreEqual("1 mm³ = 1E-09 m³", conversionVm.Conversion.SymbolConversion);
Assert.AreEqual(true, conversionVm.Conversion.CanRoundtrip);
}
public void IsUsed()
{
var settings = MockSettings.Create();
var millimetres = PrefixConversion.Create(settings.Metres, settings.Milli);
settings.Metres.PrefixConversions.Add(millimetres);
var conversion = PartConversion.Create(settings.CubicMetres, new PartConversion.PowerPart(3, millimetres));
var conversionVm = new PartConversionVm(settings.CubicMetres, conversion);
conversionVm.IsUsed = true;
CollectionAssert.Contains(settings.CubicMetres.PartConversions, conversion);
conversionVm.IsUsed = false;
CollectionAssert.DoesNotContain(settings.CubicMetres.PartConversions, conversion);
}
public async Task PartConversionPrefix()
{
var settings = MockSettings.Create();
var millimetreConversion = PrefixConversion.Create(settings.Metres, settings.Milli);
settings.Metres.PrefixConversions.Add(millimetreConversion);
var milliMetresPart = PartConversion.CreatePart(1, millimetreConversion);
var secondsPart = PartConversion.CreatePart(-1, settings.Seconds);
var conversion = PartConversion.Create(settings.MetresPerSecond, milliMetresPart, secondsPart);
settings.MetresPerSecond.PartConversions.Add(conversion);
Assert.AreEqual("millimetresPerSecond / 1000", conversion.ToSi);
Assert.AreEqual("1000 * metresPerSecond", conversion.FromSi);
Assert.AreEqual("1 mm/s = 0.001 m/s", await conversion.GetSymbolConversionAsync().ConfigureAwait(false));
Assert.AreEqual(true, await conversion.CanRoundtripAsync().ConfigureAwait(false));
}
public void CentimetresPerMinute()
{
var settings = MockSettings.Create();
var centi = new Prefix("Centi", "c", -2);
settings.Prefixes.Add(centi);
var centimetresConversion = PrefixConversion.Create(settings.Metres, centi);
var minuteConversion = new FactorConversion("Minute", "min", 60);
settings.Seconds.FactorConversions.Add(minuteConversion);
settings.Metres.PrefixConversions.Add(centimetresConversion);
var centiMetresPart = PartConversion.CreatePart(1, centimetresConversion);
var minutesPart = PartConversion.CreatePart(-1, minuteConversion);
var conversion = PartConversion.Create(settings.MetresPerSecond, centiMetresPart, minutesPart);
settings.MetresPerSecond.PartConversions.Add(conversion);
Assert.AreEqual("centimetresPerMinute/6000", conversion.ToSi);
Assert.AreEqual("6000*metresPerSecond", conversion.FromSi);
Assert.AreEqual("1 cm/min = 0.000166666666666667 m/s", conversion.SymbolConversion);
Assert.AreEqual(true, conversion.CanRoundtrip);
}
/// <summary>
/// Gets the conversion factor for the specified prefix conversion.
/// </summary>
/// <param name="prefConv"></param>
/// <returns></returns>
public static double GetPrefixConversionFactor(PrefixConversion prefConv)
{
return(_prefs[prefConv.ToString()]);
}
static void Main(string[] args)
{
// File paths
const string DATA_PATH = "./Data/Project 2_INFO_5101.csv";
const string XML_PATH = "./Data/Project2_INFO_5101.xml";
// Load data
List <Data> dataset = CSVFile.CSVDeserialize(DATA_PATH);
// Print infix equations
Console.WriteLine("\nSno \tInfix");
foreach (Data result in dataset)
{
Console.WriteLine(result.Sno + ":\t" + result.Infix);
}
// Convert to postfix and store it in the data and then print
PostfixConversion post = new PostfixConversion(dataset);
int count = 0;
Console.WriteLine("\nSno \tPostfix");
foreach (string result in post.Convert())
{
dataset[count].Postfix = result;
Console.WriteLine(dataset[count].Sno + ":\t" + dataset[count].Postfix);
count++;
}
// Convert to prefix and store it in the data and then print
PrefixConversion pre = new PrefixConversion(dataset);
count = 0;
Console.WriteLine("\nSno \tPrefix");
foreach (string result in pre.Convert())
{
dataset[count].Prefix = result;
Console.WriteLine(dataset[count].Sno + ":\t" + dataset[count].Prefix);
count++;
}
// Calculate postfix result and store it in the data and then print
count = 0;
Console.WriteLine("\nSno \tPostFix Results");
foreach (string result in ExpressionEvaluation.PostFixEvaluate(post.Convert()))
{
dataset[count].PostfixResult = result;
Console.WriteLine(count + ":\t" + result);
count++;
}
// Calculate prefix result and store it in the data and then print
count = 0;
Console.WriteLine("\nSno \tPrefix Results");
foreach (string result in ExpressionEvaluation.PrefixEvaluate(pre.Convert()))
{
dataset[count].PrefixResult = result;
Console.WriteLine(count + ":\t" + result);
count++;
}
// Display all results
CompareExpressions ce = new CompareExpressions();
Console.WriteLine($"\nSno\t{"Infix",-20} {"Prefix",-17} {"Postfix",-17} {"Prefix Result",-15} {"Postfix Result",-15} {"Match",-15}");
foreach (Data d in dataset)
{
Console.WriteLine($"{d.Sno}\t{d.Infix,-20} {d.Prefix,-17} {d.Postfix,-17} {d.PrefixResult,-15} {d.PostfixResult,-15} {(ce.Compare(d.PrefixResult, d.PostfixResult) == 1 ? "True" : "False"),-15}");
}
// Prompt user if they want to view the results in XML format
ConsoleKey response;
// Validation
do
{
Console.Write("\nWould you like to view the results in XML format? [Y/N]:");
response = Console.ReadKey(false).Key; // true is intercept key (dont show), false is show
if (response != ConsoleKey.Enter)
{
Console.WriteLine();
}
} while (response != ConsoleKey.Y && response != ConsoleKey.N);
// Generate XML if user selected yes, else don't
if (response == ConsoleKey.Y)
{
Console.WriteLine("XML Generated!");
// Uses XMLExtensions
using (StreamWriter outputFile = new StreamWriter(XML_PATH))
{
outputFile.WriteStartDocument();
outputFile.WriteStartRootElement();
foreach (Data d in dataset)
{
outputFile.WriteStartElement();
outputFile.WriteAttribute("sno", d.Sno.ToString());
outputFile.WriteAttribute("infix", d.Infix);
outputFile.WriteAttribute("prefix", d.Prefix);
outputFile.WriteAttribute("postfix", d.Postfix);
outputFile.WriteAttribute("evaluation", d.PostfixResult);
outputFile.WriteAttribute("comparison", (ce.Compare(d.PrefixResult, d.PostfixResult) == 1 ? "True" : "False"));
outputFile.WriteEndElement();
}
outputFile.WriteEndRootElement();
}
// Opens XML in Google Chrome browser
Process.Start(@"cmd.exe ", @$ "/c start chrome {XML_PATH}");
}
}
