public void VerifyAllEnums()
{
var acceleration = new Acceleration(1, AccelerationUnit.BaseUnit);
var angle = new Angle(1, AngleUnit.BaseUnit);
var angularAcceleration = new AngularAcceleration(1, AngularAccelerationUnit.BaseUnit);
var area = new Area(1, AreaUnit.BaseUnit);
var density = new MassDensity(1, MassDensityUnit.BaseUnit);
var electricCurrent = new ElectricCurrent(1, ElectricCurrentUnit.BaseUnit);
var electricResistance = new ElectricResistance(1, ElectricResistanceUnit.BaseUnit);
var electricVoltage = new ElectricPotential(1, ElectricPotentialUnit.BaseUnit);
var energy = new Energy(1, EnergyUnit.BaseUnit);
var force = new Force(1, ForceUnit.BaseUnit);
var frequency = new Frequency(1, FrequencyUnit.BaseUnit);
var jerk = new Jerk(1, JerkUnit.BaseUnit);
var length = new Length(1, LengthUnit.BaseUnit);
var mass = new Mass(1, MassUnit.BaseUnit);
var massFlowRate = new MassFlowRate(1, MassFlowRateUnit.BaseUnit);
var momentum = new Momentum(1, MomentumUnit.BaseUnit);
var numeric = new Numeric(1, NumericUnit.BaseUnit);
var power = new Power(1, PowerUnit.BaseUnit);
var pressure = new Pressure(1, PressureUnit.BaseUnit);
var speed = new Speed(1, SpeedUnit.BaseUnit);
var temperature = new Temperature(1, TemperatureUnit.BaseUnit);
var time = new Time(1, TimeUnit.BaseUnit);
var torque = new Torque(1, TorqueUnit.BaseUnit);
var volume = new Volume(1, VolumeUnit.BaseUnit);
var volumetricFlowRate = new VolumetricFlowRate(1, VolumetricFlowRateUnit.BaseUnit);
}
public void OpAddition()
{
var jerk1 = new Jerk(1000, JerkUnit.MetersPerSecondCubed);
var jerk2 = new Jerk(1, JerkUnit.KiloMetersPerSecondCubed);
var expected = new Jerk(2000, JerkUnit.MetersPerSecondCubed);
(jerk1 + jerk2).ShouldEqual(expected);
(jerk2 + jerk1).ShouldEqual(expected);
}
public void OpDivision()
{
var jerk1 = new Jerk(1000, JerkUnit.MetersPerSecondCubed);
var jerk2 = new Jerk(1, JerkUnit.KiloMetersPerSecondCubed);
(jerk1 / jerk2).ShouldBeWithinEpsilonOf(1);
(jerk2 / jerk1).ShouldBeWithinEpsilonOf(1);
(jerk1 / 2).ShouldEqual(new Jerk(500, JerkUnit.MetersPerSecondCubed));
(jerk2 / 2).ShouldEqual(new Jerk(.5, JerkUnit.KiloMetersPerSecondCubed));
}
public void OpGreaterThanOrEqual()
{
var jerk1 = new Jerk(3000, JerkUnit.MetersPerSecondCubed);
var jerk2 = new Jerk(3, JerkUnit.KiloMetersPerSecondCubed);
var jerk3 = new Jerk(4, JerkUnit.KiloMetersPerSecondCubed);
(jerk1 >= jerk3).ShouldBeFalse();
(jerk3 >= jerk1).ShouldBeTrue();
(jerk1 >= jerk2).ShouldBeTrue();
(jerk2 >= jerk1).ShouldBeTrue();
}
public void OpInverseEquals()
{
var jerk1 = new Jerk(3000, JerkUnit.MetersPerSecondCubed);
var jerk2 = new Jerk(3, JerkUnit.KiloMetersPerSecondCubed);
var jerk3 = new Jerk(4, JerkUnit.KiloMetersPerSecondCubed);
(jerk1 != jerk2).ShouldBeFalse();
(jerk2 != jerk1).ShouldBeFalse();
(jerk1 != jerk3).ShouldBeTrue();
(jerk3 != jerk1).ShouldBeTrue();
}
/// <summary>
/// Dynamically constructs a quantity of the given <see cref="QuantityInfo"/> with the value in the quantity's base units.
/// </summary>
/// <param name="quantityInfo">The <see cref="QuantityInfo"/> of the quantity to create.</param>
/// <param name="value">The value to construct the quantity with.</param>
/// <returns>The created quantity.</returns>
public static IQuantity FromQuantityInfo(QuantityInfo quantityInfo, QuantityValue value)
{
switch (quantityInfo.Name)
{
case "Depth":
return(Depth.From(value, Depth.BaseUnit));
case "Jerk":
return(Jerk.From(value, Jerk.BaseUnit));
default:
throw new ArgumentException($"{quantityInfo.Name} is not a supported quantity.");
}
}
public void OpEquals()
{
var jerk1 = new Jerk(3000, JerkUnit.MetersPerSecondCubed);
var jerk2 = new Jerk(3, JerkUnit.KiloMetersPerSecondCubed);
var jerk3 = new Jerk(4, JerkUnit.KiloMetersPerSecondCubed);
(jerk1 == jerk2).ShouldBeTrue();
(jerk2 == jerk1).ShouldBeTrue();
(jerk1 == jerk3).ShouldBeFalse();
(jerk3 == jerk1).ShouldBeFalse();
jerk1.Equals(jerk2)
.ShouldBeTrue();
jerk1.Equals((object)jerk2)
.ShouldBeTrue();
jerk2.Equals(jerk1)
.ShouldBeTrue();
jerk2.Equals((object)jerk1)
.ShouldBeTrue();
}
//Function to create new Enemes
public TownsPeople GetTownsPeople(TownsPeopleType type)
{
switch (type)
{
case TownsPeopleType.Hero:
TownsPeople hero = new Hero();
return(hero);
case TownsPeopleType.Jerk:
TownsPeople jerk = new Jerk();
return(jerk);
case TownsPeopleType.Toast:
TownsPeople toast = new Toast();
return(toast);
}
return(null);
}
/// <summary>
/// Try to dynamically construct a quantity.
/// </summary>
/// <param name="value">Numeric value.</param>
/// <param name="unit">Unit enum value.</param>
/// <param name="quantity">The resulting quantity if successful, otherwise <c>default</c>.</param>
/// <returns><c>True</c> if successful with <paramref name="quantity"/> assigned the value, otherwise <c>false</c>.</returns>
public static bool TryFrom(QuantityValue value, Enum unit, out IQuantity quantity)
{
switch (unit)
{
case DepthUnit depthUnit:
quantity = Depth.From(value, depthUnit);
return(true);
case JerkUnit jerkUnit:
quantity = Jerk.From(value, jerkUnit);
return(true);
default:
{
quantity = default(IQuantity);
return(false);
}
}
}
public void OpLessThan()
{
var jerk1 = new Jerk(3000, JerkUnit.MetersPerSecondCubed);
var jerk2 = new Jerk(3, JerkUnit.KiloMetersPerSecondCubed);
var jerk3 = new Jerk(4, JerkUnit.KiloMetersPerSecondCubed);
(jerk1 < jerk3).ShouldBeTrue();
(jerk3 < jerk1).ShouldBeFalse();
(jerk1 < jerk2).ShouldBeFalse();
(jerk2 < jerk1).ShouldBeFalse();
}
public static Jerk FeetPerSecondCubed <T>(this T value) => Jerk.FromFeetPerSecondCubed(Convert.ToDouble(value));
public void NumberToInchesPerSecondCubedTest() => Assert.Equal(Jerk.FromInchesPerSecondCubed(2), 2.InchesPerSecondCubed());
public void NumberToFeetPerSecondCubedTest() => Assert.Equal(Jerk.FromFeetPerSecondCubed(2), 2.FeetPerSecondCubed());
public void NumberToNanometersPerSecondCubedTest() => Assert.Equal(Jerk.FromNanometersPerSecondCubed(2), 2.NanometersPerSecondCubed());
public void NumberToMillimetersPerSecondCubedTest() => Assert.Equal(Jerk.FromMillimetersPerSecondCubed(2), 2.MillimetersPerSecondCubed());
public void OpMultiplicationScaler()
{
var jerk = new Jerk(1, JerkUnit.KiloMetersPerSecondCubed);
var expected = new Jerk(2, JerkUnit.KiloMetersPerSecondCubed);
(jerk * 2).ShouldEqual(expected);
(2 * jerk).ShouldEqual(expected);
}
protected void SetScalarValue(DependencyProperty property, Jerk? quantity)
{
// we set this flag to prevent from setting scalar value changing quantity values.
this.isUpdatingScalarValue = true;
var value = quantity != null
? this.Unit.GetScalarValue(quantity.Value)
: (double?)null;
this.SetCurrentValue(property, value);
this.isUpdatingScalarValue = false;
}
public override object ReadJson(JsonReader reader, Type objectType, object?existingValue, JsonSerializer serializer)
{
var stringValue = (string)reader.Value !;
return(Jerk.Parse(stringValue, serializer.Culture));
}
public void NumberToDecimetersPerSecondCubedTest() => Assert.Equal(Jerk.FromDecimetersPerSecondCubed(2), 2.DecimetersPerSecondCubed());
public static Jerk StandardGravitiesPerSecond <T>(this T value) => Jerk.FromStandardGravitiesPerSecond(Convert.ToDouble(value));
public void NumberToStandardGravitiesPerSecondTest() => Assert.Equal(Jerk.FromStandardGravitiesPerSecond(2), 2.StandardGravitiesPerSecond());
protected virtual void OnMaxValueChanged(Jerk? oldValue, Jerk? newValue)
{
this.SetScalarValue(ScalarMaxValueProperty, newValue);
}
public static Jerk InchesPerSecondCubed <T>(this T value) => Jerk.FromInchesPerSecondCubed(Convert.ToDouble(value));
public void OpSubtraction()
{
var jerk1 = new Jerk(2000, JerkUnit.MetersPerSecondCubed);
var jerk2 = new Jerk(1, JerkUnit.KiloMetersPerSecondCubed);
(jerk1 - jerk2).ShouldEqual(new Jerk(1000, JerkUnit.MetersPerSecondCubed));
(jerk2 - jerk1).ShouldEqual(new Jerk(-1, JerkUnit.KiloMetersPerSecondCubed));
}
public static Jerk NanometersPerSecondCubed <T>(this T value) => Jerk.FromNanometersPerSecondCubed(Convert.ToDouble(value));
/// <inheritdoc />
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
if (!this.initialized)
{
this.Initialize();
}
var message = this.errorText.ToString();
if (!(targetType == typeof(Jerk) || targetType == typeof(Jerk?)))
{
message += $"{this.GetType().Name} does not support converting to {targetType.Name}";
}
if (message != string.Empty)
{
message = message.TrimEnd('\r', '\n');
if (Is.DesignMode)
{
throw new InvalidOperationException(message);
}
return(message);
}
if (value == null)
{
return(null);
}
if (value is double)
{
return(new Jerk((double)value, this.unit.Value));
}
var text = value as string;
if (string.IsNullOrEmpty(text))
{
return(null);
}
var unitInput = this.UnitInput ?? Wpf.UnitInput.ScalarOnly;
switch (unitInput)
{
case Wpf.UnitInput.ScalarOnly:
{
double d;
if (double.TryParse(text, NumberStyles.Float, culture, out d))
{
return(new Jerk(d, this.unit.Value));
}
Jerk result;
if (Jerk.TryParse(text, NumberStyles.Float, culture, out result))
{
return($"#{text}#"); // returning modified text so that TypeConverter fails and we get an error
}
return(text); // returning raw to trigger error
}
case Wpf.UnitInput.SymbolAllowed:
{
double d;
int pos = 0;
WhiteSpaceReader.TryRead(text, ref pos);
if (DoubleReader.TryRead(text, ref pos, NumberStyles.Float, culture, out d))
{
WhiteSpaceReader.TryRead(text, ref pos);
if (pos == text.Length)
{
return(new Jerk(d, this.unit.Value));
}
}
goto case Wpf.UnitInput.SymbolRequired;
}
case Wpf.UnitInput.SymbolRequired:
{
Jerk result;
if (Jerk.TryParse(text, NumberStyles.Float, culture, out result))
{
return(result);
}
return(text);
}
default:
throw new ArgumentOutOfRangeException();
}
}
public void AccelerationDividedByDurationEqualsJerk()
{
Jerk jerk = Acceleration.FromMetersPerSecondSquared(10) / Duration.FromSeconds(2);
Assert.Equal(Jerk.FromMetersPerSecondCubed(5), jerk);
}
public void Update(double deltaTime)
{
if (CurrentNotch != InNotch)
{
CurrentTime = 0.0;
CurrentNotch = InNotch;
}
if (CurrentTime < TransitionDuration)
{
OutFuelCurrent = MinimumFuelCurrent;
CurrentTime += deltaTime;
return;
}
var notch = Math.Max(Math.Min(CurrentNotch, FuelTable.Length), 0);
if ((LastNotch > 0) && (CurrentNotch == 0))
{
IsCutOffFuel = true;
}
else if (CurrentNotch > 0)
{
IsCutOffFuel = false;
}
if (IsCutOffFuel)
{
if (InRpm >= FuelTable[0] * MaximumRpm)
{
CurrentTimeForCutOff = 0.0;
}
if (CurrentTimeForCutOff < TransitonDurationForCutOff)
{
CurrentTimeForCutOff += deltaTime;
}
else
{
IsCutOffFuel = false;
}
}
if (InFuelInjectionCurrent == 0.0)
{
Jerk.U = IsCutOffFuel ? FuelValueOnCutOff : FuelTable[notch];
if (CurrentNotch > LastNotch)
{
Jerk.Tp = ((LastNotch == 0) && (CurrentNotch == 1)) ? 1.0 : 9000.0;
}
else if (CurrentNotch < LastNotch)
{
Jerk.Tp = 3500.0;
}
}
else
{
Jerk.U = InFuelInjectionCurrent;
Jerk.Tp = 1000.0;
}
Jerk.Calculate(deltaTime);
OutFuelCurrent = Jerk.Y;
LastNotch = CurrentNotch;
}
/// <summary>
/// Initializes a new instance of the <see cref="Gu.Units.Wpf.JerkExtension"/> class.
/// </summary>
/// <param name="value"><see cref="Gu.Units.Jerk"/>.</param>
public JerkExtension(Jerk value)
{
this.Value = value;
}
public void NumberToCentimetersPerSecondCubedTest() => Assert.Equal(Jerk.FromCentimetersPerSecondCubed(2), 2.CentimetersPerSecondCubed());
