public String CalculatePriceInEuroForEnergiConsumed() { BaseUnit Euro = null; ConvertibleUnit Cent = null; UnitSystem EuroUnitSystem = new UnitSystem("Euros", Prefixes.UnitPrefixes, (us) => { Euro = new BaseUnit(us, (SByte)MonetaryBaseUnitKind.Currency, "Euro", "€"); return(new BaseUnit[] { Euro }); }, null, (us) => { Cent = new ConvertibleUnit("Euro-cent", "¢", us.BaseUnits[0], new ScaledValueConversion(100)); return(new ConvertibleUnit[] { Cent }); /* [¢] = 100 * [€] */ }); Unit EurosAndCents = new MixedUnit(Euro, " ", Cent, "00", true); Unit kWh = Prefixes.k * W * SI.h; // Kilo Watt hour Quantity EnergyUnitPrice = 31.75 * Cent / kWh; Quantity EnergyConsumed = 1234.56 * kWh; Quantity PriceEnergyConsumed = EnergyConsumed * EnergyUnitPrice; Quantity PriceEnergyConsumedEurosAndCents = PriceEnergyConsumed.ConvertTo(EurosAndCents); Double PriceInEuroForEnergyConsumed = PriceEnergyConsumed.ConvertTo(Euro).Value; String PriceInEuroForEnergyConsumedStr = PriceEnergyConsumedEurosAndCents.ToString(); Debug.Assert(PriceInEuroForEnergyConsumed == 31.75 / 100 * 1234.56); Debug.Assert(PriceInEuroForEnergyConsumedStr == "391 € 97 ¢"); return(PriceInEuroForEnergyConsumedStr); }
public override String ToListString(String name) { String Unitname = name; if ((pu == null) || (pu.Kind == UnitKind.BaseUnit)) { return($"unit {Unitname}"); } else { if (pu.Kind == UnitKind.ConvertibleUnit) { ConvertibleUnit cu = (ConvertibleUnit)pu; Double val = cu.Conversion.ConvertToPrimaryUnit(1); if (val != 1.0 && name.Equals(cu.Symbol)) { // User defined scaled unit CultureInfo cultureInfo = null; if (Environment != null) { cultureInfo = Environment.CurrentCultureInfo; } return($"unit {Unitname} = {val.ToString(cultureInfo)} {cu.PrimaryUnit}"); } } return($"unit {Unitname} = {pu}"); } }
private static ConvertibleUnit MakeScaledUnit(String name, String unitSymbol, IUnitSystem unitSystem, Unit primaryUnit, Double scaleFactor) { if (unitSystem == null) { ConvertibleUnit[] convertibleunitarray = new ConvertibleUnit[] { new ConvertibleUnit(name, unitSymbol, primaryUnit, new ScaledValueConversion(1.0 / scaleFactor)) }; unitSystem = new UnitSystem(name + "_system", null, (unitsystem) => null, (unitsystem) => null, (unitsystem) => convertibleunitarray); return(convertibleunitarray[0]); } else { int NoOfConvertibleUnits = 0; if (unitSystem.ConvertibleUnits != null) { NoOfConvertibleUnits = unitSystem.ConvertibleUnits.Length; } ConvertibleUnit[] convertibleunitarray = new ConvertibleUnit[NoOfConvertibleUnits + 1]; if (NoOfConvertibleUnits > 0) { unitSystem.ConvertibleUnits.CopyTo(convertibleunitarray, 0); } convertibleunitarray[NoOfConvertibleUnits] = new ConvertibleUnit(name, unitSymbol, primaryUnit, new ScaledValueConversion(1.0 / scaleFactor)); UnitSystem uso = unitSystem as UnitSystem; uso.ConvertibleUnits = convertibleunitarray; return(convertibleunitarray[NoOfConvertibleUnits]); } }
public void StaticsTest_CalculatePriceInEuroForEnergiConsumed() { // using static PhysicalMeasure.SI; // using static Prefix; BaseUnit Euro = new BaseUnit(null, (SByte)MonetaryBaseQuantityKind.Currency, "Euro", "€"); ConvertibleUnit Cent = new ConvertibleUnit("Euro-cent", "¢", Euro, new ScaledValueConversion(100)); /* [¢] = 100 * [€] */ UnitSystem EuroUnitSystem = new UnitSystem("Euros", Physics.UnitPrefixes, Euro, null, new ConvertibleUnit[] { Cent }); Unit EurosAndCents = new MixedUnit(Euro, " ", Cent, "00", true); Unit kWh = Prefix.k * W * SI.h; // Kilo Watt hour Quantity EnergyUnitPrice = 31.75 * Cent / kWh; Quantity EnergyConsumed = 1234.56 * kWh; Quantity PriceEnergyConsumed = EnergyConsumed * EnergyUnitPrice; Quantity PriceEnergyConsumedEurosAndCents = PriceEnergyConsumed.ConvertTo(EurosAndCents); Double PriceInEuroForEnergyConsumed = PriceEnergyConsumed.ConvertTo(Euro).Value; String PriceInEuroForEnergyConsumedStr = PriceEnergyConsumedEurosAndCents.ToString(); Assert.AreEqual(PriceInEuroForEnergyConsumed, 31.75 / 100 * 1234.56); Assert.AreEqual(PriceInEuroForEnergyConsumedStr, "391 € 97 ¢"); }
public override String ToListString(String name) { String Unitname = String.Format("{0}", name); if ((pu == null) || (pu.Kind == UnitKind.BaseUnit)) { return(String.Format("unit {0}", Unitname)); } else { if (pu.Kind == UnitKind.ConvertibleUnit) { ConvertibleUnit cu = (ConvertibleUnit)pu; Double val = cu.Conversion.ConvertToPrimaryUnit(1); if (val != 1.0 && name.Equals(cu.Symbol)) { // User defined scaled unit CultureInfo cultureInfo = null; if (Environment != null) { cultureInfo = Environment.CurrentCultureInfo; } return(String.Format("unit {0} = {1} {2}", Unitname, val.ToString(cultureInfo), cu.PrimaryUnit.ToString())); } } return(String.Format("unit {0} = {1}", Unitname, pu.ToString())); } }
public (bool, String) UpdateUnit(String unitName, Quantity unitValue) { bool wasBaseUnit = this.pu.Kind == UnitKind.BaseUnit; bool isBaseUnit = (unitValue == null || (unitValue.Unit?.Kind == UnitKind.BaseUnit && (unitValue.Value == 0 || unitValue.Value == 1))); if (wasBaseUnit && isBaseUnit) { // OK: Nothing to update return(true, ""); } if (wasBaseUnit || isBaseUnit) { // Error: Can't update to or from BaseUnit return(false, "Can't update to or from BaseUnit"); } bool wasScaledUnit = this.pu.Kind == UnitKind.ConvertibleUnit; bool isScaledUnit = (unitValue != null && (unitValue.Value != 0 && unitValue.Value != 1)); if (!wasScaledUnit && !isScaledUnit) { // OK: Update pu to new unit this.pu = unitValue.Unit; return(true, ""); } // Update of ConvertibleUnit ConvertibleUnit cu = (ConvertibleUnit)this.pu; bool isSameCoversion = (unitValue.Unit == cu.PrimaryUnit) && (unitValue.Value == 1.0 / cu.Conversion.LinearScale); if (isSameCoversion) { // OK: Nothing to update return(true, ""); } // Error: Can't update to or from ScaledUnit return(false, "Can't update to or from ScaledUnit"); /*** * if (!wasScaledUnit || !isScaledUnit) * { * // Error: Can't update to or from ScaledUnit * return (false, "Can't update to or from ScaledUnit"); * } * * // OK: Update pu with new PrimaryUnit and LinearScale * ConvertibleUnit cu = (ConvertibleUnit)this.pu; * cu.PrimaryUnit = unitValue.Unit; Readonly!! * cu.Conversion.LinearScale = unitValue.Value; Readonly!! * * return (true, ""); ***/ }
public void QuantityOfConvertibleUnitBasedOnDerivedUnitConvertToDerivedUnit_kWh() { Unit kWh = new ConvertibleUnit("kiloWattHour", "kWh", SI.J, new ScaledValueConversion(1.0 / 3600000)); /* [kWh] = 1/3600000 * [J] */ Quantity consumed = new Quantity(1, kWh); Quantity actual = consumed.ConvertTo(SI.J); Quantity expected = new Quantity(3600000, SI.J); Assert.AreEqual(expected, actual); }
public void QuantityOfConvertibleUnitBasedOnDerivedUnitConvertToDerivedUnit_Wh() { Unit Wh = new ConvertibleUnit("WattHour", "Wh", SI.J, new ScaledValueConversion(1.0 / 3600)); /* [Wh] = 1/3600 * [J] */ Quantity E_1 = new Quantity(1, Prefix.K * Wh); Quantity E_2 = new Quantity(0.001, Prefix.M * Wh); IQuantity actual_1 = E_1.ConvertTo(SI.J); IQuantity actual_2 = E_2.ConvertTo(SI.J); Quantity expected = new Quantity(3600000, SI.J); Assert.AreEqual(expected, actual_1); Assert.AreEqual(expected, actual_2); }
public void QuantityLitreTest() { Unit hl = new ConvertibleUnit("hectolitre", "hl", SI.l, new ScaledValueConversion(1.0 / 100)); /* [hl] = 1/100 * [l] */ Quantity _10_hectolitre = new Quantity(10, hl); IUnit cubicmeter = SI.m ^ 3; IQuantity _10_hektoLiterIncubicmeters = _10_hectolitre.ConvertTo(SI.m ^ 3); Quantity expected = new Quantity(1, SI.m ^ 3); Assert.AreEqual(expected, _10_hektoLiterIncubicmeters); }
public void QuantityTest_WattHourUnitTest() { Unit WattHour_example1 = SI.W * SI.h; Unit WattHour_example2 = new ConvertibleUnit("WattHour", "Wh", SI.J, new ScaledValueConversion(1.0 / 3600)); /* [Wh] = 1/3600 * [J] */ Quantity E_1 = new Quantity(1, WattHour_example1); // 1 Wh Quantity E_2 = new Quantity(0.001, Prefix.K * WattHour_example2); // 0.001 KWh //IQuantity actual_1 = E_1.ConvertTo(SI.J); //IQuantity actual_2 = E_2.ConvertTo(SI.J); Quantity expected = new Quantity(3600, SI.J); Assert.AreEqual(expected, E_1); Assert.AreEqual(expected, E_2); }
public void QuantityHectoLitreTest() { Unit cubicmeter = new NamedDerivedUnit(Physics.SI_Units, "cubicmeter", "m3", new SByte[] { 3, 0, 0, 0, 0, 0, 0 }); // Unit hl = new ConvertibleUnit("hectolitre", "hl", SI.m3, new ScaledValueConversion(1/10)); //Unit kWh = (Unit)new ConvertibleUnit("kiloWattHour", "kWh", Wh, new ScaledValueConversion(1.0 / 1000)); /* [kWh] = 1/1000 * [Wh] */ Unit hl = new ConvertibleUnit("hectolitre", "hl", cubicmeter, new ScaledValueConversion(10)); /* [hl] = 10 * [cubicmeter] */ Quantity _10_hectolitre = new Quantity(10, hl); //IQuantity hektoLiterIncubicmeters = _10_hectolitre.ConvertTo(SI.m3); IQuantity _10_hektoLiterIncubicmeters = _10_hectolitre.ConvertTo(cubicmeter); Quantity expected = new Quantity(1, Physics.SI_Units.UnitFromSymbol("m").Pow(3)); Assert.AreEqual(expected, _10_hektoLiterIncubicmeters); }
public void QuantityOfConvertibleUnitBasedOnConvertibleUnitConvertToDerivedUnitSquareOperator() { /* It is NOT encouraged to do like this. Just for test */ Unit Wh = new ConvertibleUnit("WattHour", "Wh", SI.J, new ScaledValueConversion(1.0 / 3600)); /* [Wh] = 1/3600 * [J] */ Unit kWh = new ConvertibleUnit("kiloWattHour", "kWh", Wh, new ScaledValueConversion(1.0 / 1000)); /* [kWh] = 1/1000 * [Wh] */ Unit MWh = new ConvertibleUnit("MegaWattHour", "MWh", kWh, new ScaledValueConversion(1.0 / 1000)); /* [MWh] = 1/1000 * [kWh] */ Quantity E_1 = new Quantity(1000, Wh); Quantity E_2 = new Quantity(1, kWh); Quantity E_3 = new Quantity(0.001, MWh); Quantity actual_1 = E_1 [SI.J]; Quantity actual_2 = E_2 [SI.J]; Quantity actual_3 = E_3 [SI.J]; Quantity expected = new Quantity(3600000, SI.J); Assert.AreEqual(expected, actual_1); Assert.AreEqual(expected, actual_2); Assert.AreEqual(expected, actual_3); }