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