private static NamedComposition <IUnit> GetComposition(DerivedQuantity quant) { return(NamedComposition <IUnit> . CreateFromExistingBaseComposition( quant.BaseQuantityComposition, baseQuantity => baseQuantity.FundamentalUnit)); }
/// <summary> /// To be called only from <see cref="Quantity.GetFromBaseComposition(NamedComposition{BaseQuantity})"/> /// </summary> /// <param name="composition"></param> internal DerivedQuantity(NamedComposition <BaseQuantity> composition) : base(null, null) { BaseQuantityComposition = composition; FundamentalUnit = new DerivedUnit(this); Init(); }
public bool Equals(NamedComposition <T>?other) { if (other is null) { return(false); } if (Composition.Count != other.Composition.Count) { return(false); } // check if any keys in this that are not in other // don't need to do the reverse since we already know there // are the same number of keys in each if (Composition.Keys.Except(other.Composition.Keys).Any()) { return(false); } foreach (var kvp in Composition) { var(key, power) = kvp; if (other.Composition[key] != power) { return(false); } } return(true); }
public static NamedComposition <IUnit> MultiplyOrDivide(bool multiplication, params IUnit[] units) { var res = units[0].UnitComposition; for (int i = 1; i < units.Length; ++i) { res = NamedComposition <IUnit> .MultiplyOrDivide(res, units[i].UnitComposition, multiplication); } return(res); }
protected Unit( string?name, IUnit otherUnit, decimal multiplier, decimal offset, string?symbol) : base(name, symbol) { Quantity = otherUnit.Quantity; FundamentalMultiplier = otherUnit.FundamentalMultiplier * multiplier; FundamentalOffset = (otherUnit.FundamentalOffset / multiplier) + offset; UnitComposition = new(this); }
// only to be called when defining fundamental units for new // quantities, and thus offset will always be 0 protected Unit( string?name, Quantity quantity, decimal fundamentalMultiplier, NamedComposition <IUnit>?composition = null, string?symbol = null) : base(name, symbol) { Quantity = quantity; FundamentalMultiplier = fundamentalMultiplier; FundamentalOffset = 0; UnitComposition = composition ?? new(this); }
public static Unit DefineFromComposition(string name, NamedComposition <IUnit> composition) { var quantity = Quantity.GetFromBaseComposition(composition); if (quantity is BaseQuantity) { return(new BaseUnit(name, composition)); } else { return(new DerivedUnit(name, composition)); } }
internal static NamedComposition <T> CreateFromExistingBaseComposition <TExistingBase>( NamedComposition <TExistingBase> existingBaseComposition, Func <TExistingBase, T> convertor) where TExistingBase : IBase, IComparable <TExistingBase>, IEquatable <TExistingBase> { SortedDictionary <T, decimal> convertedComposition = new(); foreach (var(existingBase, power) in existingBaseComposition.Composition) { var convertedBase = convertor(existingBase); convertedComposition.Add(convertedBase, power); } return(new(convertedComposition.AsReadOnly())); }
// for defining from a chain of operations protected Unit(string name, NamedComposition <IUnit> composition) : base(name) { // TODO: notify user that offsets will be ignored //var offsetQuery = // from baseUnit in composition.Composition.Keys // where baseUnit.FundamentalOffset != 0m // select baseUnit; UnitComposition = composition; Quantity = Quantity.GetFromBaseComposition(UnitComposition); FundamentalMultiplier = 1m; FundamentalOffset = 0; foreach (var(unit, power) in UnitComposition.Composition) { var multiplier = DecimalEx.Pow(unit.FundamentalMultiplier, power); FundamentalMultiplier *= multiplier; } }
public static NamedComposition <T> MultiplyOrDivide( NamedComposition <T> lhs, NamedComposition <T> rhs, bool multiplication) { var multiplyFactor = multiplication ? 1.0m : -1.0m; SortedDictionary <T, decimal> resultingComposition = new(); var keysInBothSides = lhs.Composition.Keys.Intersect(rhs.Composition.Keys); foreach (var bothSidesKey in keysInBothSides) { var resultingPower = lhs.Composition[bothSidesKey] + (multiplyFactor * rhs.Composition[bothSidesKey]); if (resultingPower != 0.0m) { resultingComposition[bothSidesKey] = resultingPower; } } var keysInLhs = lhs.Composition.Keys.Except(keysInBothSides); foreach (var lhsKey in keysInLhs) { resultingComposition[lhsKey] = lhs.Composition[lhsKey]; } var keysInRhs = rhs.Composition.Keys.Except(keysInBothSides); foreach (var rhsKey in keysInRhs) { resultingComposition[rhsKey] = rhs.Composition[rhsKey] * multiplyFactor; } if (resultingComposition.Count == 0) { return(Empty); } return(new NamedComposition <T>(resultingComposition.AsReadOnly())); }
private BaseQuantity(string name, string?symbol) : base(name, symbol) { BaseQuantityComposition = new NamedComposition <BaseQuantity>(this); Init(); }
// for defining from a chain of operations internal DerivedUnit(string name, NamedComposition <IUnit> composition) : base(name, composition) { }
static NamedComposition() { Empty = new NamedComposition <T>( new Dictionary <T, decimal>().AsReadOnly()); }