public Unit CreateUnit(IUnitSystem system, double factor, Dimension dimension)
{
Check.SystemKnowsDimension(system, dimension);
var unit = new DerivedUnit(system, factor, dimension);
return unit;
}
private static BaseUnit MakeBaseUnit(String name, String unitSymbol, IUnitSystem unitSystem)
{
if (unitSystem == null)
{
unitSystem = new UnitSystem(name + "_system", null, (unitsystem) => new BaseUnit[] { new BaseUnit(unitsystem, 0, name, unitSymbol) });
return(unitSystem.BaseUnits[0]);
}
else
{
int NoOfBaseUnits = 0;
if (unitSystem.BaseUnits != null)
{
NoOfBaseUnits = unitSystem.BaseUnits.Length;
}
BaseUnit[] baseunitarray = new BaseUnit[NoOfBaseUnits + 1];
if (NoOfBaseUnits > 0)
{
unitSystem.BaseUnits.CopyTo(baseunitarray, 0);
}
baseunitarray[NoOfBaseUnits] = new BaseUnit(unitSystem, (sbyte)(NoOfBaseUnits), name, unitSymbol);
UnitSystem uso = unitSystem as UnitSystem;
uso.BaseUnits = baseunitarray;
return(baseunitarray[NoOfBaseUnits]);
}
}
public void LengthTimesLength_Returns_AreaQuantity()
{
// Arrange
SiUnitSystemFactory siFactory = new SiUnitSystemFactory();
IUnitSystem siSystem = siFactory.Create();
StandardQuantitiesCatalog.Setup();
// Act
Quantity <float> width = new Quantity <float>(2.0f, StandardUnitsCatalog.Meter);
Quantity <float> height = new Quantity <float>(4.0f, StandardUnitsCatalog.Meter);
Quantity <float> resultm2 = (Quantity <float>)(width * height);
IValueConverter converter = siSystem.CreateConverter(resultm2.Unit, StandardUnitsCatalog.SquareCentimeter);
Assert.NotNull(converter);
Quantity <float> resultcm2 = new Quantity <float>(converter.Convert(resultm2.Value), converter.Target);
// Assert
Assert.AreEqual(8.0f, resultm2.Value);
Assert.AreEqual(StandardUnitsCatalog.SquareMeter, resultm2.Unit);
Assert.AreEqual(StandardDimensionsCatalog.Area, resultm2.Dimension);
Assert.AreEqual(StandardDimensionsCatalog.Area, resultcm2.Dimension);
Assert.AreEqual(resultm2.Value * 100.0f * 100.0f, resultcm2.Value);
}
public KnownUnit CreateUnit(IUnitSystem system, double factor, Dimension dimension, string symbol, string name,
bool inherentPrefix)
{
var unit = new KnownUnit(system, factor, dimension, symbol, name, inherentPrefix);
return(unit);
}
public Program()
{
SiUnitSystemFactory siFactory = new SiUnitSystemFactory();
_siSystem = siFactory.Create();
StandardQuantitiesCatalog.Setup();
}
/// <summary>
/// Creates an unit system from the given prototype. This can be useful when
/// e.g. extending one of the standard unit systems with custom units.
/// If the prototype is an UnitSystem the created unit system will be an
/// identical copy of the unit system. If not, only units that are convertible
/// to the base unit will be added.
/// </summary>
/// <param name="prototype"></param>
/// <returns></returns>
public static UnitSystem CreateFrom(IUnitSystem prototype)
{
if (prototype is UnitSystem)
{
return((UnitSystem)((UnitSystem)prototype).Clone());
}
UnitSystem system = new UnitSystem();
foreach (IDimension dimension in prototype.Dimensions)
{
system.AddDimension(dimension);
// Register base unit
IUnit baseUnit = prototype.GetBaseUnit(dimension);
system.AddBaseUnit(baseUnit);
// Register scaled units
foreach (IUnit unit in prototype.GetSupportedUnits(dimension))
{
if (!ReferenceEquals(unit, baseUnit) && prototype.CanConvert(baseUnit, unit))
{
system.AddScaledUnit(baseUnit, unit, prototype.CreateConverter(baseUnit, unit));
}
}
}
return(system);
}
private static ConvertibleUnit MakeScaledUnit(String name, IUnitSystem unitSystem, Unit primaryUnit, Double scaleFactor)
{
if (unitSystem == null)
{
ConvertibleUnit[] convertibleunitarray = new ConvertibleUnit[1];
convertibleunitarray[0] = new ConvertibleUnit(name, name, primaryUnit, new ScaledValueConversion(1.0 / scaleFactor));
unitSystem = new UnitSystem(name + "_system", null, (BaseUnit[])null, null, 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, name, primaryUnit, new ScaledValueConversion(1.0 / scaleFactor));
UnitSystem uso = unitSystem as UnitSystem;
uso.ConvertibleUnits = convertibleunitarray;
return(convertibleunitarray[NoOfConvertibleUnits]);
}
}
private static BaseUnit MakeBaseUnit(String name, IUnitSystem unitSystem)
{
if (unitSystem == null)
{
unitSystem = new UnitSystem(name + "_system", false);
}
if (unitSystem != null)
{
int NoOfBaseUnits = 0;
if (unitSystem.BaseUnits != null)
{
NoOfBaseUnits = unitSystem.BaseUnits.Length;
}
BaseUnit[] baseunitarray = new BaseUnit[NoOfBaseUnits + 1];
if (NoOfBaseUnits > 0)
{
unitSystem.BaseUnits.CopyTo(baseunitarray, 0);
}
baseunitarray[NoOfBaseUnits] = new BaseUnit(unitSystem, (sbyte)(NoOfBaseUnits), name, name);
UnitSystem uso = unitSystem as UnitSystem;
uso.BaseUnits = baseunitarray;
return(baseunitarray[NoOfBaseUnits]);
}
return(null);
}
public KnownUnit CreateUnit(IUnitSystem system, double factor, Dimension dimension, string symbol, string name,
bool inherentPrefix)
{
var unit = new KnownUnit(system, factor, dimension, symbol, name, inherentPrefix);
return unit;
}
public Unit CreateUnit(IUnitSystem system, double factor, Dimension dimension)
{
Check.SystemKnowsDimension(system, dimension);
var unit = new DerivedUnit(system, factor, dimension);
return(unit);
}
public static void SystemKnowsDimension(IUnitSystem system, Dimension dimension)
{
if (system.NumberOfDimensions < dimension.Count)
{
throw new InvalidOperationException(Messages.DimensionUnknown.FormatWith(system.Name,
system.NumberOfDimensions));
}
}
public void StaticTest_GetUnitSystemConversionTest()
{
IUnitSystem SomeUnitSystem = SI.Units;
IUnitSystem SomeOtherUnitSystem = MGD_Units.Units;
UnitSystemConversion expected = UnitSystems.SItoMGDConversion;
UnitSystemConversion actual = UnitSystems.Conversions.GetUnitSystemConversion(SomeUnitSystem, SomeOtherUnitSystem);
Assert.AreEqual(expected, actual);
}
internal Unit(IUnitSystem system, double factor, Dimension dimension)
{
Check.Argument(dimension, nameof(dimension)).IsNotNull();
this.System = system;
this.Dimension = dimension;
this.Factor = factor;
this.hashCode = GenerateHashCode();
}
public void StaticTest_GetUnitSystemCombinedReversedConversionTest()
{
IUnitSystem SomeUnitSystem = MGM_Units.Units;
IUnitSystem SomeOtherUnitSystem = CGS_Units.Units;
//UnitSystemConversion expected = UnitSystems.SItoMGDConversion;
UnitSystemConversion actual = UnitSystems.Conversions.GetUnitSystemConversion(SomeUnitSystem, SomeOtherUnitSystem);
Assert.AreEqual(actual.BaseUnitSystem, SomeUnitSystem);
Assert.AreEqual(actual.ConvertedUnitSystem, SomeOtherUnitSystem);
}
public Boolean UnitSet(IUnitSystem unitSystem, String unitName, Quantity unitValue, String unitSymbol, out INametableItem unitItem, out string errorMessage)
{
// Find identifier
Boolean Found = FindIdentifier(unitName, out IEnvironment context, out unitItem);
if (Found && (context == this) && (unitItem.Identifierkind != IdentifierKind.Unit))
{ // Found locally, but is not a unit; Can't set as unit
errorMessage = unitName + " is found locally but is not a unit; Can't set as unit";
return(false);
}
if (context == null)
{
context = this;
}
(bool OK, String errormessage)updateRes;
if (unitItem == null)
{
// Either is identifier an unit in some context; set it to specified value
// or identifier not found; No local identifier with that name, Declare local unit
if (unitSystem == null)
{
if (unitValue != null && unitValue.Unit != null)
{ // Is same system as values unit
unitSystem = unitValue.Unit.ExponentsSystem;
}
/**
* if (unitSystem == null)
* { // Is first unit in a new system
* if (SystemSet(unitName + "_system", out INametableItem SystemItem))
* {
* unitSystem = ((NamedSystem)SystemItem).UnitSystem;
* }
* }
**/
}
unitItem = new NamedUnit(unitSystem, unitName, unitSymbol, unitValue, this);
updateRes = (true, "");
}
else
{
NamedUnit nui = (NamedUnit)unitItem;
updateRes = nui.UpdateUnit(unitName, unitValue);
}
errorMessage = updateRes.errormessage;
if (!updateRes.OK)
{
return(false);
}
return(context.SetLocalIdentifier(unitName, unitItem));
}
public NamedUnit(IUnitSystem unitSystem, String name, String unitSymbol, Unit physicalUnit, CalculatorEnvironment environment = null /* = null */)
{
this.Environment = environment;
if (physicalUnit != null)
{
this.pu = physicalUnit;
}
else
{
this.pu = MakeBaseUnit(name, unitSymbol, unitSystem);
}
}
/// <summary>
/// Enumerates all available units in all available dimensions checking for consistency.
/// Checks that available units include standard units,
/// and that Dimensions of units correspond to what was requested.
/// </summary>
public static void ShouldBeConsistent(this IUnitSystem system)
{
system.Dimensions.Should().NotBeEmpty();
foreach (var dimension in system.Dimensions)
{
var standardUnit = system[dimension];
var availableUnits = system.GetUnits(dimension);
availableUnits.Should().Contain(standardUnit);
foreach (var unit in availableUnits)
{
unit.Dimension.Should().Be(dimension);
}
}
}
public UnitInterpretor(IUnitSystem system, IUnitDialect dialect)
{
this.system = system;
this.dialect = dialect;
this.unitRegex = BuildUnitRegex();
this.baseUnits = new List<KnownUnit>(this.system.BaseUnits);
foreach (var unit in system)
{
if (unit.Symbol != unit.BaseSymbol)
{
this.prefixedUnits.Add(unit.BaseSymbol, unit);
}
}
}
public UnitInterpretor(IUnitSystem system, IUnitDialect dialect)
{
this.system = system;
this.dialect = dialect;
this.unitRegex = BuildUnitRegex();
this.baseUnits = new List <KnownUnit>(this.system.BaseUnits);
foreach (var unit in system)
{
if (unit.Symbol != unit.BaseSymbol)
{
this.prefixedUnits.Add(unit.BaseSymbol, unit);
}
}
}
public void Create_ResultSupportsAllDerivedSiDimensions()
{
// Arrange
SiUnitSystemFactory factory = new SiUnitSystemFactory();
// Act
IUnitSystem system = factory.Create();
// Assert
Assert.True(system.SupportsDimension(StandardDimensionsCatalog.Area));
Assert.True(system.SupportsDimension(StandardDimensionsCatalog.Pressure));
Assert.True(system.SupportsDimension(StandardDimensionsCatalog.Volume));
Assert.True(system.SupportsDimension(StandardDimensionsCatalog.Speed));
Assert.True(system.SupportsDimension(StandardDimensionsCatalog.Force));
Assert.True(system.SupportsDimension(StandardDimensionsCatalog.Energy));
}
public void Create_ResultSupportsAllBaseSiDimensions()
{
// Arrange
SiUnitSystemFactory factory = new SiUnitSystemFactory();
// Act
IUnitSystem system = factory.Create();
// Assert
Assert.True(system.SupportsDimension(StandardDimensionsCatalog.AmountOfSubstance));
Assert.True(system.SupportsDimension(StandardDimensionsCatalog.ElectricCurrent));
Assert.True(system.SupportsDimension(StandardDimensionsCatalog.Length));
Assert.True(system.SupportsDimension(StandardDimensionsCatalog.LuminousIntensity));
Assert.True(system.SupportsDimension(StandardDimensionsCatalog.Mass));
Assert.True(system.SupportsDimension(StandardDimensionsCatalog.Time));
Assert.True(system.SupportsDimension(StandardDimensionsCatalog.Temperature));
}
public static Quantity FromInfo(this IUnitSystem system, QuantityInfo info)
{
var unit = system.NoUnit;
var symbols = info.Unit.Keys.ToArray();
var exponents = info.Unit.Values.ToArray();
for (var i = 0; i < info.Unit.Count; i++)
{
var baseUnit = system[symbols[i]];
if (ReferenceEquals(baseUnit, null) || !baseUnit.IsCoherent)
{
throw new InvalidOperationException(Messages.UnitsNotSameSystem);
}
unit = unit * (baseUnit ^ exponents[i]);
}
return(new Quantity(info.Amount, unit));
}
internal KnownUnit(IUnitSystem system, double factor, Dimension dimension, string symbol, string name,
bool inherentPrefix)
: base(system, factor, dimension)
{
Check.Argument(symbol, nameof(symbol)).IsNotNull();
Check.Argument(name, nameof(name)).IsNotNull();
this.Symbol = symbol;
this.Name = name;
if (inherentPrefix)
{
this.DeriveInherentFactorAndBaseSymbol(symbol);
}
else
{
this.InherentFactor = 1;
this.BaseSymbol = symbol;
}
}
internal KnownUnit(IUnitSystem system, double factor, Dimension dimension, string symbol, string name,
bool inherentPrefix)
: base(system, factor, dimension)
{
Check.Argument(symbol, nameof(symbol)).IsNotNull();
Check.Argument(name, nameof(name)).IsNotNull();
this.Symbol = symbol;
this.Name = name;
if (inherentPrefix)
{
this.DeriveInherentFactorAndBaseSymbol(symbol);
}
else
{
this.InherentFactor = 1;
this.BaseSymbol = symbol;
}
}
public Boolean UnitSet(IUnitSystem unitSystem, String unitName, Quantity unitValue, out INametableItem unitItem)
{
// Find identifier
IEnvironment context;
Boolean Found = FindIdentifier(unitName, out context, out unitItem);
if (Found && (context == this) && (unitItem.Identifierkind != IdentifierKind.Unit))
{ // Found locally but is not a unit; Can't set as unit
return(false);
}
if (context == null)
{
context = this;
}
// Either is identifier an unit in some context; set it to specified value
// or identifier not found; No local identifier with that name, Declare local unit
if (unitSystem == null)
{
if (unitValue != null && unitValue.Unit != null)
{ // Is same system as values unit
unitSystem = unitValue.Unit.ExponentsSystem;
}
if (unitSystem == null)
{ // Is first unit in a new system
INametableItem SystemItem;
if (SystemSet(unitName + "_system", out SystemItem))
{
unitSystem = ((NamedSystem)SystemItem).UnitSystem;
}
}
}
unitItem = new NamedUnit(unitSystem, unitName, unitValue, this);
return(context.SetLocalIdentifier(unitName, unitItem));
}
public NamedUnit(IUnitSystem unitSystem, String name, Quantity physicalQuantity, CalculatorEnvironment environment /* = null */)
{
this.Environment = environment;
if (physicalQuantity != null)
{
if ((unitSystem == null) && (physicalQuantity.Unit != null))
{
unitSystem = physicalQuantity.Unit.ExponentsSystem;
}
if (physicalQuantity.Value != 0 && physicalQuantity.Value != 1)
{
this.pu = MakeScaledUnit(name, unitSystem, physicalQuantity.Unit, physicalQuantity.Value);
}
else
{
this.pu = physicalQuantity.Unit;
}
}
else
{
this.pu = MakeBaseUnit(name, unitSystem);
}
}
public NamedUnit(IUnitSystem unitSystem, String name, String unitSymbol, Quantity unitValue, CalculatorEnvironment environment /* = null */)
{
this.Environment = environment;
if (unitValue != null)
{
if ((unitSystem == null) && (unitValue.Unit != null))
{
unitSystem = unitValue.Unit.ExponentsSystem;
}
if (unitValue.Value != 0 && unitValue.Value != 1)
{
this.pu = MakeScaledUnit(name, unitSymbol, unitSystem, unitValue.Unit, unitValue.Value);
}
else
{
this.pu = unitValue.Unit;
}
}
else
{
this.pu = MakeBaseUnit(name, unitSymbol, unitSystem);
}
}
internal KnownUnit(IUnitSystem system, double factor, Dimension dimension, string symbol, string name)
: this(system, factor, dimension, symbol, name, false)
{
this.Symbol = symbol;
}
internal DerivedUnit(IUnitSystem system, double factor, Dimension dimension)
: base(system, factor, dimension)
{
}
public NamedSystem(String name)
{
UnitSystem = new UnitSystem(name, true);
}
public UsersService(IUnitSystem sys)
{
this.system = sys;
}
public UserService(IUnitSystem realEstateSystem)
{
this.system = realEstateSystem;
}
public CarsService(IUnitSystem sytem)
{
this.carsSystem = sytem;
}
internal KnownUnit(IUnitSystem system, double factor, Dimension dimension, string symbol, string name)
: this(system, factor, dimension, symbol, name, false)
{
this.Symbol = symbol;
}
