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);
}
