/// <summary> /// Multiply two units to combine a new unit. The order of /// the arguments are arbitrary. /// </summary> /// <param name="left"></param> /// <param name="right"></param> /// <returns></returns> public static IUnit Multiply(IUnit left, IUnit right) { if (left == Unitless.Instance && right == Unitless.Instance) { return(Unitless.Instance); } if (left == Unitless.Instance) { return(right); } if (right == Unitless.Instance) { return(left); } if (left is CompoundUnit) { return(((CompoundUnit)left).Multiply(right)); } if (right is CompoundUnit) { return(((CompoundUnit)right).Multiply(left)); } CompoundUnit unit = new CompoundUnit(left); return(unit.Multiply(right)); }
public static double In(this UnitValue unitValue, CompoundUnit newUnit) { if (!unitValue.Unit.Equals(newUnit)) { throw new InvalidOperationException($"Cannot convert {unitValue.Unit} to {newUnit}"); } return(unitValue.Value); }
public static Vector2D In(this UnitVector2D unitPoint, CompoundUnit targetUnit) { var multiplier = new UnitValue(unitPoint.Unit, 1).In(targetUnit); return(new Vector2D( multiplier * unitPoint.X, multiplier * unitPoint.Y)); }
public static Point3D In(this UnitPoint3D unitPoint, CompoundUnit targetUnit) { var multiplier = new UnitValue(unitPoint.Unit, 1).In(targetUnit); return(new Point3D( multiplier * unitPoint.X, multiplier * unitPoint.Y, multiplier * unitPoint.Z)); }
public void Inverse_1overA_ReturnsA() { // Arrange IUnit a = CreateStubUnit("a"); CompoundUnit unit = new CompoundUnit(Unitless.Instance, a); // Act IUnit result = unit.Inverse(); // Assert Assert.AreSame(a, result); }
private void UpdateUnit(IUnit unit) { if (unit is CompoundUnit) { _unit = (CompoundUnit)unit; } else { _unit = new CompoundUnit(unit); } }
public void Inverse_A_Returns1OverA() { // Arrange IUnit a = CreateStubUnit("a"); CompoundUnit unit = new CompoundUnit(a); // Act IUnit result = unit.Inverse(); // Assert Assert.AreEqual(new CompoundUnit(Unitless.Instance, a), result); }
public void Divide_Aover1_ReturnsA() { // Arrange IUnit a = CreateStubUnit("a"); CompoundUnit unit = new CompoundUnit(a); // Act IUnit result = unit.Divide(Unitless.Instance); // Assert Assert.AreSame(a, result); }
public void Inverse_AoverB_ReturnsBoverA() { // Arrange IUnit a = CreateStubUnit("a"); IUnit b = CreateStubUnit("b"); CompoundUnit unit = new CompoundUnit(a, b); // Act IUnit result = unit.Inverse(); // Assert Assert.AreEqual(new CompoundUnit(b, a), result); }
public void CompoundUnitConversionRoundtripReturnsInput() { var unit = new CompoundUnit( new [] { SIBaseUnit.Kilogram, SIBaseUnit.Second, SIBaseUnit.Meter }, new [] { SIBaseUnit.Ampere, SIBaseUnit.Ampere }); var number = StaticRandom.Rng.NextDouble(); var unitValue = number.To(unit); var roundtripNumber = unitValue.In(unit); Assert.That(roundtripNumber, Is.EqualTo(number).Within(1e-5)); }
public void Divide_AoverB_ReturnsCompoundUnit() { // Arrange IUnit a = CreateStubUnit("a"); IUnit b = CreateStubUnit("b"); CompoundUnit unit = new CompoundUnit(a); // Act IUnit result = unit.Divide(b); // Assert Assert.IsInstanceOf(typeof(CompoundUnit), result); }
public void Multiply_AoverBx1_ReturnsSelf() { // Arrange IUnit a = CreateStubUnit("a"); IUnit b = CreateStubUnit("b"); CompoundUnit unit = new CompoundUnit(a, b); // Act IUnit result = unit.Multiply(Unitless.Instance); // Assert Assert.AreSame(unit, result); }
public void SerializationRoundTrip() { var sut = Unit.Pascal.CorrespondingCompoundUnit; var json = JsonConvert.SerializeObject(sut); CompoundUnit reconstructuedUnit = null; Assert.That(() => reconstructuedUnit = JsonConvert.DeserializeObject <CompoundUnit>(json), Throws.Nothing); Assert.That(reconstructuedUnit, Is.Not.Null); for (var idx = 0; idx < sut.UnitExponents.Length; idx++) { Assert.That(reconstructuedUnit.UnitExponents[idx], Is.EqualTo(sut.UnitExponents[idx])); } }
public void Multiply_AxBsquared_EqualsAxAxBxB() { // Arrange IUnit a = CreateStubUnit("a"); IUnit b = CreateStubUnit("b"); CompoundUnit unit = new CompoundUnit(a); CompoundUnit axb = (CompoundUnit)unit.Multiply(b); // Act IUnit axbsquared = axb.Multiply(axb); IUnit axaxbxb = unit.Multiply(a, b, b); // Assert Assert.AreEqual(axaxbxb, axbsquared); }
public void Multiply_AoverBxB_ReturnsA() { // Arrange IUnit a = CreateStubUnit("a"); IUnit b = CreateStubUnit("b"); CompoundUnit unit = new CompoundUnit(a); unit = (CompoundUnit)unit.Divide(b); // Act IUnit result = unit.Multiply(b); // Assert Assert.AreSame(a, result); }
static void Main(string[] args) { Quantity d1 = Factory.u(12, x.m); Quantity d2 = Factory.u(5, x.km); Quantity distance = d1 + d2; Quantity time = Factory.u(100, x.s) + d1; Console.WriteLine("Distance is " + distance.shortString()); Console.WriteLine("Time is " + time.shortString()); CompoundUnit mps = x.m / x.s; CompoundUnit kph = x.km / x.hr; Quantity windspeed = Factory.u(123, mps); Quantity carspeed = Factory.u(10, kph); Quantity total = windspeed + carspeed; Console.WriteLine("Speed is " + total.shortString()); Console.ReadLine(); }
/// <summary> /// Divides the first unit with the second to form a new unit. /// </summary> /// <param name="dividend"></param> /// <param name="divisor"></param> /// <returns></returns> public static IUnit Divide(IUnit dividend, IUnit divisor) { if (ReferenceEquals(dividend, divisor)) { return(Unitless.Instance); } if (dividend == Unitless.Instance && divisor == Unitless.Instance) { return(Unitless.Instance); } if (divisor == Unitless.Instance) { return(dividend); } if (dividend is CompoundUnit) { return(((CompoundUnit)dividend).Divide(divisor)); } CompoundUnit unit = new CompoundUnit(dividend); return(unit.Divide(divisor)); }
public static UnitVector2D To(this Vector2D point, CompoundUnit unit) { return(new UnitVector2D(unit, point.X, point.Y)); }
public PermeabilityOfFreeSpace() : base(4 * Math.PI, -7, CompoundUnit.NewCompoundUnit(new UnitPowerPair { Unit = new Webber(), Power = 1 }, new UnitPowerPair { Unit = new Ampere(), Power = -1 }, new UnitPowerPair { Unit = new Meter(), Power = -1 })) { }
public R() : base(8.3144621, CompoundUnit.NewCompoundUnit(new UnitPowerPair { Unit = new Joule(), Power = 1 }, new UnitPowerPair { Unit = new Moles(), Power = -1 }, new UnitPowerPair { Unit = new Kelvin(), Power = -1 })) { }
public k() : base(1.3806488, -23, CompoundUnit.NewCompoundUnit(new UnitPowerPair { Unit = new Joule(), Power = 1 }, new UnitPowerPair { Unit = new Kelvin(), Power = -1 })) { }
public h() : base(6.62606957, -34, CompoundUnit.NewCompoundUnit(new UnitPowerPair { Unit = new Joule(), Power = 1 }, new UnitPowerPair { Unit = new Second(), Power = 1 })) { }
public G() : base(6.67384, -11, CompoundUnit.NewCompoundUnit(new UnitPowerPair { Unit = new Newton(), Power = 1 }, new UnitPowerPair { Unit = new Meter(), Power = 2 }, new UnitPowerPair { Unit = new Kilogram(), Power = -2 })) { }
public PermittivityOfFreeSpace() : base(8.854187817, -12, CompoundUnit.NewCompoundUnit(new UnitPowerPair { Unit = new Coulomb(), Power = 2 }, new UnitPowerPair { Unit = new Newton(), Power = -1 }, new UnitPowerPair { Unit = new Meter(), Power = -2 })) { }
public static CompoundUnit Pow(this CompoundUnit unit, int pow) { return(new CompoundUnit(unit.UnitExponents.Select(x => pow * x))); }
public static UnitValue To(this double value, CompoundUnit unit) { return(new UnitValue(unit, value)); }
public static UnitPoint3D To(this Point3D point, CompoundUnit unit) { return(new UnitPoint3D(unit, point.X, point.Y, point.Z)); }
public void UnitsAndValues_Test() { Value length = new Value(10.25, Units.m); StandardValue stdLength = length.ToStandardValue(); Assert.AreEqual(length.Magnitude, stdLength.Magnitude * Math.Pow(10, stdLength.StandardPower)); Assert.AreEqual(length.Unit, stdLength.Unit); Value revertedLength = stdLength.ToValue(); Assert.AreEqual(length.Magnitude, revertedLength.Magnitude); Assert.AreEqual(length.Unit, revertedLength.Unit); CompoundUnit KgPERm3 = new CompoundUnit(new Tuple <Units, int>(Units.Kg, 1), new Tuple <Units, int>(Units.m, -3)); Value density = new Value(1.0 / 8.0, KgPERm3); Value volume = new Value(8, Units.m, 3); Value mass = density * volume; Assert.AreEqual(1, mass.Magnitude); CompoundUnit massUnit = new CompoundUnit(new Tuple <Units, int>(Units.Kg, 1)); Assert.AreEqual(true, massUnit == (CompoundUnit)mass.Unit); Value dist1 = new Value(2, Units.m); Value dist2 = new Value(1, Units.m); Value ratio = dist1 / dist2; Assert.AreEqual(2, ratio.Magnitude); CompoundUnit ratioUnit = new CompoundUnit(new Tuple <Units, int>(Units.NoUnit, 0)); Assert.AreEqual(true, ratioUnit == (CompoundUnit)ratio.Unit); Value velocity = new Value(2, new CompoundUnit(new Tuple <Units, int>(Units.m, 1), new Tuple <Units, int>(Units.s, -1))); Value time = new Value(1, Units.s); StandardValue acc = (velocity / time).ToStandardValue(); Assert.AreEqual(2, acc.Magnitude); CompoundUnit accUnit = new CompoundUnit(new Tuple <Units, int>(Units.m, 1), new Tuple <Units, int>(Units.s, -2)); Assert.AreEqual(true, accUnit == (CompoundUnit)acc.Unit); Print(velocity + " / " + time + " = " + acc); Assert.AreEqual("2 m s\u02C9\u00B9 / 1 s = 2 m s\u02C9\u00B2", velocity + " / " + time + " = " + acc); StandardValue sValue = new StandardValue(10.23, new CompoundUnit(new Tuple <Units, int>(Units.km, 1), new Tuple <Units, int>(Units.h, -1)), 2); Print(sValue); Assert.AreEqual("1.023 x 10\u00B3 km h\u02C9\u00B9", sValue.ToString()); Value r_1 = new Value(10, Units.m); Value r2_1 = r_1 ^ 2; Print(r2_1); StandardValue r_2 = new StandardValue(10, Units.m); StandardValue r2_2 = r_2 ^ 2; Print(r2_2); Value testConversion1 = new Value(1000, new Unit(Units.g)); Value gInKg = (Value)testConversion1.As(Units.Kg); Print(gInKg.ToString() + " in " + testConversion1.ToString()); Assert.AreEqual(1, gInKg.Magnitude); Value testConversion2 = new Value(1, new Unit(Units.g)); StandardValue oxInGrams = ((Value)testConversion2.As(Units.oz)).ToStandardValue(); Print(oxInGrams.ToString() + " in " + testConversion2.ToString()); Assert.AreEqual(Math.Round(0.0352739619495804, 6, MidpointRounding.AwayFromZero), Math.Round(oxInGrams.GetMagnitude(), 6, MidpointRounding.AwayFromZero)); StandardValue testConversion3 = new StandardValue(1, new CompoundUnit(new Unit(Units.m), new Unit(Units.km))); StandardValue m2Inmkm = ((Value)testConversion3.As(Units.m.Pow(2))).ToStandardValue(); Print(m2Inmkm.ToString() + " in " + testConversion3.ToString()); Assert.AreEqual(1000, m2Inmkm.GetMagnitude()); StandardValue testConversion4 = new StandardValue(1, new CompoundUnit((Unit)Units.Kg, (Unit)Units.m, Units.s.Pow(-1))); StandardValue noncenceConversion = ((Value)testConversion4.As(new CompoundUnit((Unit)Units.lb, (Unit)Units.m, Units.s.Pow(-1)))).ToStandardValue(); Print(noncenceConversion.Round(5).ToString() + " in " + testConversion4.ToString()); Print(new Value(16, Units.oz) + " in " + new Value(16, Units.oz).As((Unit)Units.lb)); }
public static UnitValue To(this double value, SIPrefix prefix, CompoundUnit unit) { var multiplier = GetMultiplier(prefix); return(new UnitValue(unit, multiplier * value)); }