public Settings() { this.allowedShapes = Shapes.All; this.customSpeed = 0; this.drawSpeed = Speed.Normal; this.useTransparency = true; }
public void TestConstructorValue() { Speed speed = new Speed("5 m/s"); Assert.AreEqual(5, speed.Value); Assert.AreEqual(SpeedUnit.MetersPerSecond, speed.Units); }
public Decoded(GeoPosition currentLocation, DateTime currentTime, Heading currentHeading, Speed currentSpeed) { CurrentLocation = currentLocation; CurrentTime = currentTime; CurrentHeading = currentHeading; CurrentSpeed = currentSpeed; }
public Fan(Cpu.PWMChannel pin) { this.pwmChannel = pin; this.speed = Speed.None; this.frequency = (double)100; Start(); }
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 TestConstructorValueCultureException() { Speed speed = new Speed("5", CultureInfo.CurrentCulture); Assert.AreEqual(5, speed.Value); Assert.AreEqual(SpeedUnit.MetersPerSecond, speed.Units); }
public Hover(Speed p_xMove, Speed p_yMove, int p_duration, bool p_relativeToPlayer) { this.relativeToPlayer = p_relativeToPlayer; this.duration = p_duration; this.yMove = p_yMove; this.xMove = p_xMove; }
public void ConvertToSi(Speed v, string dimension) { if (dimension != "m/s" ) { if (dimension == "km/h") { v.Value *= 0.277778; } if (dimension == "mph") { v.Value *= 0.44704; } if (dimension == "knot") { v.Value *= 0.514444; } if (dimension == "ft/s") { v.Value *= 0.3048; } else { throw new IncorrectDimensionOfSpeedException(); } } }
public Datum(DateTime time, Latitude latitude, Longitude longitude, Length altitude = null, Speed speed = null, Heading heading = null) { _time = time; _location = new GeoPosition(latitude, longitude, altitude); _speed = speed; _heading = heading; }
public Hover(Speed p_xMove, Speed p_yMove, int p_duration) { this.relativeToPlayer = false; this.duration = p_duration; this.yMove = p_yMove; this.xMove = p_xMove; }
public CollidingParticle(GameState game, Position2 position, Velocity2 velocity, Unit z, Speed vz, bool collideWithProjectileColliders) : base(game) { this.data = new Data(position, velocity, z, vz, collideWithProjectileColliders); }
public Data(Position2 p, Velocity2 v, Unit z, Speed vz, bool collideWithProjectileColliders) { this.position = p; this.velocity = v; this.z = z; this.vz = vz; this.collideWithProjectileColliders = collideWithProjectileColliders; }
public MeterAtSecond ConvertToMeterAtSecond(Speed speed) { if(speed is MeterAtSecond) { return new MeterAtSecond(speed.value); } return new MeterAtSecond((speed.value * 1000) / 3600); }
public void OpAddition() { var speed1 = new Speed(3600, SpeedUnit.MetersPerHour); var speed2 = new Speed(1, SpeedUnit.MetersPerMinute); var expected = new Speed(3660, SpeedUnit.MetersPerHour); (speed1 + speed2).ShouldEqual(expected); (speed2 + speed1).ShouldEqual(expected); }
// Use this for initialization void Start() { speedEnum = Speed.faster; startSpeed = speed; startVector = transform.position; player = GameObject.FindGameObjectWithTag("Player").GetComponent<Player>(); moveCamera = GameObject.FindGameObjectWithTag("MainCamera").GetComponent<MoveCamera>(); }
/// <summary> /// Initializes a new instance of the <see cref="ShipMoveOrder" /> class. /// </summary> /// <param name="source">The source of the order.</param> /// <param name="target">The move target.</param> /// <param name="speed">The move speed.</param> /// <param name="isFleetwide">if set to <c>true</c> the move should be coordinated as a fleet.</param> /// <param name="targetStandoffDistance">When the ship arrives at the target, this is the distance /// from the target it should strive to achieve.</param> public ShipMoveOrder(OrderSource source, IShipNavigable target, Speed speed, bool isFleetwide, float targetStandoffDistance) : base(ShipDirective.Move, source, false, target) { Utility.ValidateNotNull(target); D.AssertNotDefault((int)speed); Utility.ValidateNotNegative(targetStandoffDistance); Speed = speed; IsFleetwide = isFleetwide; TargetStandoffDistance = targetStandoffDistance; }
public void OpInverseEquals() { var speed1 = new Speed(3600, SpeedUnit.MetersPerHour); var speed2 = new Speed(60, SpeedUnit.MetersPerMinute); var speed3 = new Speed(120, SpeedUnit.MetersPerMinute); (speed1 != speed2).ShouldBeFalse(); (speed2 != speed1).ShouldBeFalse(); (speed1 != speed3).ShouldBeTrue(); (speed3 != speed1).ShouldBeTrue(); }
public void OpDivision() { var speed1 = new Speed(3600, SpeedUnit.MetersPerHour); var speed2 = new Speed(60, SpeedUnit.MetersPerMinute); (speed1 / speed2).ShouldBeWithinEpsilonOf(1); (speed2 / speed1).ShouldBeWithinEpsilonOf(1); (speed1 / 2).ShouldEqual(new Speed(1800, SpeedUnit.MetersPerHour)); (speed2 / 2).ShouldEqual(new Speed(30, SpeedUnit.MetersPerMinute)); }
public void OpGreaterThanOrEqual() { var speed1 = new Speed(3600, SpeedUnit.MetersPerHour); var speed2 = new Speed(60, SpeedUnit.MetersPerMinute); var speed3 = new Speed(120, SpeedUnit.MetersPerMinute); (speed1 >= speed3).ShouldBeFalse(); (speed3 >= speed1).ShouldBeTrue(); (speed1 >= speed2).ShouldBeTrue(); (speed2 >= speed1).ShouldBeTrue(); }
static void Main(string[] args) { Time t = new Time(5); Speed v = new Speed(10); Distance s = new Distance(10); Acceleration a = new Acceleration(3); s = 2 + (a * (t^2)) / 2; Converter conv = new Converter(); Console.WriteLine(a.GiveValueInSI()); Console.ReadLine(); }
public static void EnableSpaceNavigator(this SceneView sceneView, Speed move = Speed.Normal, Speed zoom = Speed.Normal, Speed rotation = Speed.Normal, Speed tilt = Speed.Normal) { if (_device == null) { _device = new Device(); _device.Connect(); } var sensor = _device.Sensor; sensor.SensorInput += () => sceneView.Update(sensor, move.Translate(4000000), zoom.Translate(4000000), rotation.Translate(50000), tilt.Translate(40)); }
public Jump(Speed p_xspeed, Speed p_yspeed, bool playJumpAnim, bool dequeueOnLand) { this.horizontal = true; this.vertical = true; this.dqOnLand = true; this.horizontal = true; this.vertical = true; this.dqOnLand = dequeueOnLand; this.playAnim = playJumpAnim; this.xSpeed = p_xspeed; this.ySpeed = p_yspeed; }
public SpeedRangeTarget(double minUnitsPerHour, double maxUnitsPerHour, Length.Units speedUnit, Speed.Units speedPace, BaseSpeedTarget baseTarget) : this(baseTarget) { if (speedPace == Speed.Units.Pace) { SetRangeInMinutesPerUnit(minUnitsPerHour, maxUnitsPerHour, speedUnit); } else { SetRangeInUnitsPerHour(minUnitsPerHour, maxUnitsPerHour, speedUnit); } }
public void Update() { if (Input.GetKeyDown(KeyCode.P)) currentSpeed = Speed.Paused; if (Input.GetKeyDown(KeyCode.Alpha1)) currentSpeed = Speed.Normal; if (Input.GetKeyDown(KeyCode.Alpha2)) currentSpeed = Speed.Fast; if (Input.GetKeyDown(KeyCode.Alpha3)) currentSpeed = Speed.Super; }
public Weapon CreateWeapon(int minRange, int range, int damage, string name, AttributeEnum attribute, int cost, bool availlable, Speed speed, ISession session) { var weapon = new Weapon(); weapon.Damage = damage; weapon.MinRange = minRange; weapon.MaxRange = range; weapon.Name = name; weapon.ScalingAttribute = attribute; weapon.Cost = cost; weapon.Available = availlable; weapon.Speed = speed; session.Save(weapon); return weapon; }
private static void Main(string[] args) { var vehicleMass = new Mass(2500, MassUnit.Pounds); var startSpeed = new Speed(72, SpeedUnit.MilesPerHour); var endSpeed = new Speed(0, SpeedUnit.MilesPerHour); var stoppingDistance = new Length(1234, LengthUnit.Foot); Acceleration deceleration = ((endSpeed * endSpeed) - (startSpeed * startSpeed)) / (2 * stoppingDistance); Force stoppingForceRequired = vehicleMass * deceleration; Console.WriteLine("The stopping force required is:"); Console.WriteLine("\t{0}", stoppingForceRequired.ToString(ForceUnit.Newtons, 3)); Console.WriteLine("\t{0}", stoppingForceRequired.ToString(ForceUnit.KilogramForce, 3)); Console.WriteLine("\t{0}", stoppingForceRequired.ToString(ForceUnit.PoundForce, 3)); Console.ReadLine(); }
public override void Execute(Speed speed) { SlowDownAndPaint(speed); Script.Player.Mouse.UseOn(Control); if(Args == "Click") { Script.Player.Mouse.Click(); } SlowDownAndPaint(speed); Script.Player.Mouse.Dispose(); }
public override void Execute(Speed speed) { SlowDownAndPaint(speed); Script.Player.Keyboard.UseOn(Control); string TypeCommand = "Type "; if(Args.StartsWith(TypeCommand)) { Script.Player.Keyboard.Type(Args.Substring(TypeCommand.Length)); } SlowDownAndPaint(speed); Script.Player.Keyboard.Dispose(); }
public void OpEquals() { var speed1 = new Speed(3600, SpeedUnit.MetersPerHour); var speed2 = new Speed(60, SpeedUnit.MetersPerMinute); var speed3 = new Speed(120, SpeedUnit.MetersPerMinute); (speed1 == speed2).ShouldBeTrue(); (speed2 == speed1).ShouldBeTrue(); (speed1 == speed3).ShouldBeFalse(); (speed3 == speed1).ShouldBeFalse(); speed1.Equals(speed2) .ShouldBeTrue(); speed1.Equals((object)speed2) .ShouldBeTrue(); speed2.Equals(speed1) .ShouldBeTrue(); speed2.Equals((object)speed1) .ShouldBeTrue(); }
public Jump(Speed p_speed, bool p_horizontal, bool playJumpAnim, bool dequeueOnLand) { this.horizontal = true; this.vertical = true; this.dqOnLand = true; this.dqOnLand = dequeueOnLand; this.playAnim = playJumpAnim; if (p_horizontal) { this.vertical = false; this.horizontal = true; this.xSpeed = p_speed; } else { this.vertical = true; this.horizontal = false; this.ySpeed = p_speed; } }
public void MassFluxDividedByDensityEqualsSpeed() { Speed speed = MassFlux.FromKilogramsPerSecondPerSquareMeter(20) / Density.FromKilogramsPerCubicMeter(2); Assert.Equal(speed, Speed.FromMetersPerSecond(10)); }
public static void KinematicViscosityDividedByLengthEqualsSpeed() { Speed speed = KinematicViscosity.FromSquareMetersPerSecond(4) / Length.FromMeters(2); Assert.AreEqual(speed, Speed.FromMetersPerSecond(2)); }
internal static double CalculateTime(Speed initialSpeed, Speed desiredSpeed, Acceleration acceleration, int stepCountLimit, out Speed reachedSpeed, out int stepCount) { if (stepCountLimit == 0) { reachedSpeed = Speed.Zero; stepCount = 0; return(0); } checked { var absStepCountLimit = Math.Abs(stepCountLimit); //TODO verify/improve precision var timeScale = Configuration.TimerFrequency; var initialSpeedF = initialSpeed.Ticks == 0 ? 0.0 : 1.0 * initialSpeed.StepCount / initialSpeed.Ticks * timeScale; var desiredSpeedF = desiredSpeed.Ticks == 0 ? 0.0 : 1.0 * desiredSpeed.StepCount / desiredSpeed.Ticks * timeScale; var accelerationF = 1.0 * acceleration.Speed.StepCount / acceleration.Speed.Ticks / acceleration.Ticks * timeScale * timeScale; var desiredAccelerationTime = Math.Abs(desiredSpeedF - initialSpeedF) / accelerationF; var isDeceleration = initialSpeedF > desiredSpeedF; var decelerationCoefficient = isDeceleration ? -1 : 1; var a = 0.5 * accelerationF; var b = initialSpeedF * decelerationCoefficient; var c = -absStepCountLimit; var availableAccelerationTime = (-b + Math.Sqrt(b * b - 4 * a * c)) / 2 / a; var accelerationTime = Math.Min(desiredAccelerationTime, availableAccelerationTime); var accelerationDistanceF = (initialSpeedF * accelerationTime + 0.5 * decelerationCoefficient * accelerationF * accelerationTime * accelerationTime); stepCount = (int)accelerationDistanceF * Math.Sign(stepCountLimit); var reachedSpeedF = initialSpeedF + decelerationCoefficient * accelerationF * accelerationTime; reachedSpeed = new Speed((int)reachedSpeedF, timeScale); return(accelerationTime); } }
public SpeedHandler(Speed speed) { speedAdjust = setSpeedAdjust(speed); }
public Speed(Speed obj) : base(obj) { }
public override string ExecuteReadOption(string Option) { switch (Option) { case ("MoveTo"): throw new InvalidOperationException("Executeable"); case ("MoveRelativeTo"): throw new InvalidOperationException("Executeable"); case ("MoveFor"): throw new InvalidOperationException("Executeable"); case ("RunOn"): throw new InvalidOperationException("Executeable"); case ("RunAt"): throw new InvalidOperationException("Executeable"); case ("Stop"): throw new InvalidOperationException("Executeable"); case ("Reset"): throw new InvalidOperationException("Executeable"); case ("Address"): return(Address); case ("MaxSpeed"): return(Max_Speed.ToString()); case ("Speed"): return(Speed.ToString()); case ("Position"): return(Position.ToString()); case ("Dutycycle"): return(Dutycycle.ToString()); case ("RampUpSpeed"): return(RampUpSpeed.ToString()); case ("RampDownSpeed"): return(RampDownSpeed.ToString()); case ("Polarity"): return(TachoMotor_Polarity_To_String(Polarity)); case ("RPM"): return(RPM.ToString()); case ("DriverName"): return(DriverName); case ("LastCommand"): return(TachoMotor_Commands_To_String(LastCommand)); case ("State"): return(TachoMotor_States_To_String(State)); case ("StopAction"): return(TachoMotor_StopActions_To_String(StopAction)); case ("Command"): throw new InvalidOperationException("WriteOnly"); default: throw new ArgumentOutOfRangeException(); } }
public void AreaTimesSpeedEqualsVolumeFlow() { VolumeFlow volumeFlow = Area.FromSquareMeters(20) * Speed.FromMetersPerSecond(2); Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(40), volumeFlow); }
/// <summary> /// Adds ramped line with specified number of steps. /// </summary> /// <param name="xSteps">Number of steps along x.</param> /// <param name="ySteps">Numer of steps along y.</param> /// <param name="planeAcceleration">Acceleration used for ramping - calculated for both axis combined.</param> /// <param name="planeSpeedLimit">Maximal speed that could be achieved for both axis combined.</param> public void AddRampedLineXY(int xSteps, int ySteps, Acceleration planeAcceleration, Speed planeSpeedLimit) { if (xSteps == 0 && ySteps == 0) { //nothing to do return; } Speed speedLimitX, speedLimitY; DecomposeXY(xSteps, ySteps, planeSpeedLimit, out speedLimitX, out speedLimitY); Acceleration accelerationX, accelerationY; DecomposeXY(xSteps, ySteps, planeAcceleration, out accelerationX, out accelerationY); Speed reachedX, reachedY; int accelerationStepsX, accelerationStepsY; var timeX = AccelerationBuilder.CalculateTime(Speed.Zero, speedLimitX, accelerationX, xSteps / 2, out reachedX, out accelerationStepsX); var timeY = AccelerationBuilder.CalculateTime(Speed.Zero, speedLimitY, accelerationY, ySteps / 2, out reachedY, out accelerationStepsY); //take acceleration time according to axis with more precision var accelerationTime = Math.Max(timeX, timeY); var accelerationProfileX = AccelerationBuilder.FromTo(Speed.Zero, reachedX, accelerationStepsX, accelerationTime); var accelerationProfileY = AccelerationBuilder.FromTo(Speed.Zero, reachedY, accelerationStepsY, accelerationTime); var reachedSpeedX = Speed.FromDeltaT(accelerationProfileX.EndDelta + accelerationProfileX.BaseDeltaT); var reachedSpeedY = Speed.FromDeltaT(accelerationProfileY.EndDelta + accelerationProfileY.BaseDeltaT); var reachedSpeed = ComposeSpeeds(reachedSpeedX, reachedSpeedY); var decelerationProfileX = AccelerationBuilder.FromTo(reachedX, Speed.Zero, accelerationStepsX, accelerationTime); var decelerationProfileY = AccelerationBuilder.FromTo(reachedY, Speed.Zero, accelerationStepsY, accelerationTime); var remainingX = xSteps - accelerationProfileX.StepCount - decelerationProfileX.StepCount; var remainingY = ySteps - accelerationProfileY.StepCount - decelerationProfileY.StepCount; //send ramp AddAccelerationXY(accelerationProfileX, accelerationProfileY); AddConstantSpeedTransitionXY(remainingX, remainingY, reachedSpeed); AddAccelerationXY(decelerationProfileX, decelerationProfileY); }
/// <summary> /// Adds 4D transition with constant speed. /// </summary> /// <param name="distanceU">Distance along U axis in steps.</param> /// <param name="distanceV">Distance along V axis in steps.</param> /// <param name="transitionSpeedUV">Speed of the transition in uv plane.</param> /// <param name="distanceX">Distance along X axis in steps.</param> /// <param name="distanceY">Distance along Y axis in steps.</param> /// <param name="transitionSpeedXY">Speed of the transition in xy plane.</param> public void AddConstantSpeedTransitionUVXY(int distanceU, int distanceV, Speed transitionSpeedUV, int distanceX, int distanceY, Speed transitionSpeedXY) { checked { var sqrtUV = Math.Sqrt(1.0 * distanceU * distanceU + 1.0 * distanceV * distanceV); var sqrtXY = Math.Sqrt(1.0 * distanceX * distanceX + 1.0 * distanceY * distanceY); var transitionTimeUV = sqrtUV == 0 ? 0 : (long)(sqrtUV * transitionSpeedUV.Ticks / transitionSpeedUV.StepCount); var transitionTimeXY = sqrtXY == 0 ? 0 : (long)(sqrtXY * transitionSpeedXY.Ticks / transitionSpeedXY.StepCount); var transitionTime = Math.Max(transitionTimeUV, transitionTimeXY); var remainingStepsU = distanceU; var remainingStepsV = distanceV; var remainingStepsX = distanceX; var remainingStepsY = distanceY; var chunkLengthLimit = Constants.MaxStepInstructionLimit; var maxUV = Math.Max(Math.Abs(distanceU), Math.Abs(distanceV)); var maxXY = Math.Max(Math.Abs(distanceX), Math.Abs(distanceY)); var chunkCount = (int)Math.Ceiling(1.0 * Math.Max(maxUV, maxXY) / chunkLengthLimit); var doneDistanceU = 0L; var doneDistanceV = 0L; var doneDistanceX = 0L; var doneDistanceY = 0L; var doneTime = 0.0; for (var doneChunks = 1; doneChunks <= chunkCount; ++doneChunks) { var chunkDistanceU = 1.0 * distanceU * doneChunks / chunkCount; var chunkDistanceV = 1.0 * distanceV * doneChunks / chunkCount; var chunkDistanceX = 1.0 * distanceX * doneChunks / chunkCount; var chunkDistanceY = 1.0 * distanceY * doneChunks / chunkCount; var chunkTime = 1.0 * transitionTime * doneChunks / chunkCount; var stepCountUD = chunkDistanceU - doneDistanceU; var stepCountVD = chunkDistanceV - doneDistanceV; var stepCountXD = chunkDistanceX - doneDistanceX; var stepCountYD = chunkDistanceY - doneDistanceY; var stepsTime = chunkTime - doneTime; var stepCountU = (Int16)Math.Round(stepCountUD); var stepCountV = (Int16)Math.Round(stepCountVD); var stepCountX = (Int16)Math.Round(stepCountXD); var stepCountY = (Int16)Math.Round(stepCountYD); doneDistanceU += stepCountU; doneDistanceV += stepCountV; doneDistanceX += stepCountX; doneDistanceY += stepCountY; //we DON'T want to round here - this way we can distribute time precisely via time remainders var stepTimeU = stepCountU == 0 ? 0 : (int)(stepsTime / Math.Abs(stepCountU)); var stepTimeV = stepCountV == 0 ? 0 : (int)(stepsTime / Math.Abs(stepCountV)); var stepTimeX = stepCountX == 0 ? 0 : (int)(stepsTime / Math.Abs(stepCountX)); var stepTimeY = stepCountY == 0 ? 0 : (int)(stepsTime / Math.Abs(stepCountY)); var timeRemainderU = Math.Abs(stepCountUD) <= 1 ? (UInt16)0 : (UInt16)(stepsTime % Math.Abs(stepCountUD)); var timeRemainderV = Math.Abs(stepCountVD) <= 1 ? (UInt16)0 : (UInt16)(stepsTime % Math.Abs(stepCountVD)); var timeRemainderX = Math.Abs(stepCountXD) <= 1 ? (UInt16)0 : (UInt16)(stepsTime % Math.Abs(stepCountXD)); var timeRemainderY = Math.Abs(stepCountYD) <= 1 ? (UInt16)0 : (UInt16)(stepsTime % Math.Abs(stepCountYD)); if (stepTimeU == 0 && stepTimeV == 0 && stepTimeX == 0 && stepTimeY == 0) { if (doneDistanceU == distanceU && doneDistanceV == distanceV && doneDistanceX == distanceX && doneDistanceY == distanceY) { break; } throw new NotImplementedException("Send wait signal"); } doneTime += stepsTime; var uPart = createConstant(stepCountU, stepTimeU, timeRemainderU); var vPart = createConstant(stepCountV, stepTimeV, timeRemainderV); var xPart = createConstant(stepCountX, stepTimeX, timeRemainderX); var yPart = createConstant(stepCountY, stepTimeY, timeRemainderY); AddUVXY(uPart, vPart, xPart, yPart); } if ( distanceU != doneDistanceU || distanceV != doneDistanceV || distanceX != doneDistanceX || distanceY != doneDistanceY ) { throw new NotImplementedException("Distance was not calculated precisely. Needs to be fixed."); } } }
/// <summary> /// Adds line with specified initial and desired speed. /// </summary> /// <param name="xSteps">Number of steps along x.</param> /// <param name="ySteps">Numer of steps along y.</param> /// <param name="planeAcceleration">Acceleration used for getting desired speed out of initial.</param> public Speed AddLineXY(int xSteps, int ySteps, Speed initialSpeed, Acceleration planeAcceleration, Speed desiredEndSpeed) { if (xSteps == 0 && ySteps == 0) { //nothing to do return(initialSpeed); } Speed speedLimitX, speedLimitY; DecomposeXY(xSteps, ySteps, desiredEndSpeed, out speedLimitX, out speedLimitY); Speed initialSpeedX, initialSpeedY; DecomposeXY(xSteps, ySteps, initialSpeed, out initialSpeedX, out initialSpeedY); Acceleration accelerationX, accelerationY; DecomposeXY(xSteps, ySteps, planeAcceleration, out accelerationX, out accelerationY); Speed reachedX, reachedY; int accelerationStepsX, accelerationStepsY; var timeX = AccelerationBuilder.CalculateTime(initialSpeedX, speedLimitX, accelerationX, xSteps, out reachedX, out accelerationStepsX); var timeY = AccelerationBuilder.CalculateTime(initialSpeedY, speedLimitY, accelerationY, ySteps, out reachedY, out accelerationStepsY); //take acceleration time according to axis with more precision var accelerationTime = Math.Max(timeX, timeY); var accelerationProfileX = AccelerationBuilder.FromTo(initialSpeedX, reachedX, accelerationStepsX, accelerationTime); var accelerationProfileY = AccelerationBuilder.FromTo(initialSpeedY, reachedY, accelerationStepsY, accelerationTime); var reachedSpeedX = Speed.FromDeltaT(accelerationProfileX.EndDelta + accelerationProfileX.BaseDeltaT); var reachedSpeedY = Speed.FromDeltaT(accelerationProfileY.EndDelta + accelerationProfileY.BaseDeltaT); var reachedSpeed = ComposeSpeeds(reachedSpeedX, reachedSpeedY); var remainingX = xSteps - accelerationProfileX.StepCount; var remainingY = ySteps - accelerationProfileY.StepCount; if (accelerationProfileX.StepCount == 0 && accelerationProfileY.StepCount == 0) { reachedSpeed = initialSpeed; } //send profile AddAccelerationXY(accelerationProfileX, accelerationProfileY); AddConstantSpeedTransitionXY(remainingX, remainingY, reachedSpeed); return(reachedSpeed); }
/// <summary> /// Adds ramped line with specified number of steps. /// </summary> /// <param name="uSteps">Number of steps along u.</param> /// <param name="vSteps">Numer of steps along v.</param> /// <param name="xSteps">Number of steps along x.</param> /// <param name="ySteps">Numer of steps along y.</param> /// <param name="planeAcceleration">Acceleration used for ramping - calculated for both axis combined.</param> /// <param name="planeSpeedLimit">Maximal speed that could be achieved for both axis combined.</param> public void AddRampedLineUVXY(int uSteps, int vSteps, int xSteps, int ySteps, Acceleration planeAcceleration, Speed planeSpeedLimit) { if (uSteps == 0 && vSteps == 0 && xSteps == 0 && ySteps == 0) { //nothing to do return; } Speed speedLimitU, speedLimitV; DecomposeXY(uSteps, vSteps, planeSpeedLimit, out speedLimitU, out speedLimitV); Acceleration accelerationU, accelerationV; DecomposeXY(uSteps, vSteps, planeAcceleration, out accelerationU, out accelerationV); Speed speedLimitX, speedLimitY; DecomposeXY(xSteps, ySteps, planeSpeedLimit, out speedLimitX, out speedLimitY); Acceleration accelerationX, accelerationY; DecomposeXY(xSteps, ySteps, planeAcceleration, out accelerationX, out accelerationY); Speed reachedU, reachedV, reachedX, reachedY; int accelerationStepsU, accelerationStepsV, accelerationStepsX, accelerationStepsY; var timeU = AccelerationBuilder.CalculateTime(Speed.Zero, speedLimitU, accelerationU, uSteps / 2, out reachedU, out accelerationStepsU); var timeV = AccelerationBuilder.CalculateTime(Speed.Zero, speedLimitV, accelerationV, vSteps / 2, out reachedV, out accelerationStepsV); var timeX = AccelerationBuilder.CalculateTime(Speed.Zero, speedLimitX, accelerationX, xSteps / 2, out reachedX, out accelerationStepsX); var timeY = AccelerationBuilder.CalculateTime(Speed.Zero, speedLimitY, accelerationY, ySteps / 2, out reachedY, out accelerationStepsY); //take acceleration time according to axis with more precision var accelerationTime = Math.Max(Math.Max(timeU, timeV), Math.Max(timeX, timeY)); var accelerationProfileU = AccelerationBuilder.FromTo(Speed.Zero, reachedU, accelerationStepsU, accelerationTime); var accelerationProfileV = AccelerationBuilder.FromTo(Speed.Zero, reachedV, accelerationStepsV, accelerationTime); var accelerationProfileX = AccelerationBuilder.FromTo(Speed.Zero, reachedX, accelerationStepsX, accelerationTime); var accelerationProfileY = AccelerationBuilder.FromTo(Speed.Zero, reachedY, accelerationStepsY, accelerationTime); var reachedSpeedU = Speed.FromDeltaT(accelerationProfileU.EndDelta + accelerationProfileU.BaseDeltaT); var reachedSpeedV = Speed.FromDeltaT(accelerationProfileV.EndDelta + accelerationProfileV.BaseDeltaT); var reachedSpeedX = Speed.FromDeltaT(accelerationProfileX.EndDelta + accelerationProfileX.BaseDeltaT); var reachedSpeedY = Speed.FromDeltaT(accelerationProfileY.EndDelta + accelerationProfileY.BaseDeltaT); var reachedSpeedUV = ComposeSpeeds(reachedSpeedU, reachedSpeedV); var reachedSpeedXY = ComposeSpeeds(reachedSpeedX, reachedSpeedY); var decelerationProfileU = AccelerationBuilder.FromTo(reachedU, Speed.Zero, accelerationStepsU, accelerationTime); var decelerationProfileV = AccelerationBuilder.FromTo(reachedV, Speed.Zero, accelerationStepsV, accelerationTime); var decelerationProfileX = AccelerationBuilder.FromTo(reachedX, Speed.Zero, accelerationStepsX, accelerationTime); var decelerationProfileY = AccelerationBuilder.FromTo(reachedY, Speed.Zero, accelerationStepsY, accelerationTime); var remainingU = uSteps - accelerationProfileU.StepCount - decelerationProfileU.StepCount; var remainingV = vSteps - accelerationProfileV.StepCount - decelerationProfileV.StepCount; var remainingX = xSteps - accelerationProfileX.StepCount - decelerationProfileX.StepCount; var remainingY = ySteps - accelerationProfileY.StepCount - decelerationProfileY.StepCount; //send ramp AddAccelerationUVXY(accelerationProfileU, accelerationProfileV, accelerationProfileX, accelerationProfileY); AddConstantSpeedTransitionUVXY(remainingU, remainingV, reachedSpeedUV, remainingX, remainingY, reachedSpeedXY); AddAccelerationUVXY(decelerationProfileU, decelerationProfileV, decelerationProfileX, decelerationProfileY); }
/// <summary> /// Decomposes plane speed into separate axes speeds in a direction specified by step counts. /// </summary> /// <param name="planeSpeed">Speed within the plane</param> /// <param name="speedX">Output speed for x axis.</param> /// <param name="speedY">Output speed for y axis.</param> public void DecomposeXY(int stepsX, int stepsY, Speed planeSpeed, out Speed speedX, out Speed speedY) { //TODO verify/improve precision checked { if (stepsX == 0 && stepsY == 0) { speedX = Speed.Zero; speedY = Speed.Zero; return; } var direction = new Vector(stepsX, stepsY); direction.Normalize(); var speedVector = direction * planeSpeed.StepCount / planeSpeed.Ticks; var resolution = Constants.TimerFrequency; speedX = new Speed((long)Math.Round(Math.Abs(speedVector.X * resolution)), resolution); speedY = new Speed((long)Math.Round(Math.Abs(speedVector.Y * resolution)), resolution); } }
} // time zulu private void addToRoute(GeoCoord location, Waypoint wpt, Earthquake eq) { rteptNumber++; string wptName = "" + rteptNumber; if (m_routeTrack == null) { // first route-making click on the map, create track to hold the new route string newTrackSource = "route - user created " + DateTime.Now; Project.trackId++; rteptNumber = 1; m_lastWpt = null; string newTrackName = "Route-" + Project.trackId; CreateInfo createInfo = new CreateInfo(); createInfo.init("rte"); createInfo.id = Project.trackId; createInfo.name = newTrackName; createInfo.source = newTrackSource; createInfo.par1 = "" + rteNumber; rteNumber++; if (rteNumber > 20) { rteNumber = 1; } m_routeTrack = new Track(createInfo); m_routeTrack.isRoute = true; WaypointsCache.TracksAll.Add(m_routeTrack); wptName = "Start route"; } m_speed = null; if (m_lastWpt != null && m_lastWpt.HasSpeed) { m_speed = new Speed(m_lastWpt.Speed); } else { m_speed = new Speed(Project.routeSpeed); } TimeSpan dur = new TimeSpan(100000); Waypoint routeWpt = null; bool wasNew = false; if (wpt != null) { routeWpt = new Waypoint(wpt); routeWpt.LiveObjectType = LiveObjectTypes.LiveObjectTypeRoutepoint; routeWpt.DateTime = m_dateTimeRte; } else if (eq != null) { //wptName = eq.ToString(); wptName = string.Format("{0:F1} - ", eq.Magn) + eq.sDateTime + " - " + eq.Comment; routeWpt = new Waypoint(eq.Location, m_dateTimeRte, LiveObjectTypes.LiveObjectTypeRoutepoint, Project.trackId, wptName, eq.Source, eq.Url); } else { // location must not be null then: routeWpt = new Waypoint(location, m_dateTimeRte, LiveObjectTypes.LiveObjectTypeRoutepoint, Project.trackId, "", "user created", ""); // no URL routeWpt.NameDisplayed = wptName; wasNew = true; } if (m_speed != null) { routeWpt.Speed = (float)m_speed.Meters; } if (m_lastWpt != null && m_lastWpt.TrackId == Project.trackId) { Distance dist = routeWpt.distanceFrom(m_lastWpt.Location); double durSeconds = m_speed.Meters <= 0.0d ? 0.000001d : (dist.Meters / m_speed.Meters * 3600.0d); dur = new TimeSpan((long)(durSeconds * 10000000.0d)); m_dateTimeRte += dur; } routeWpt.DateTime = m_dateTimeRte; m_lastWpt = routeWpt; // we need to make sure that the point added is different from the last point in track. // Magellan will not accept routes with zero-length legs. Waypoint lastWpt = null; if (m_routeTrack.Trackpoints.Count > 0) { lastWpt = (Waypoint)m_routeTrack.Trackpoints.GetByIndex(m_routeTrack.Trackpoints.Count - 1); } if (lastWpt == null || lastWpt.Location.distanceFrom(routeWpt.Location).Meters > 2.0d) { if (wasNew && lastWpt != null) { routeWpt.Location.Elev = lastWpt.Location.Elev; } m_routeTrack.Trackpoints.Add(routeWpt.DateTime, routeWpt); m_routeTrack.PutOnMap(this, null, this); if (wptName.Length > 2) { //m_cameraManager.MarkLocation(mouseGeoLocation, 0); m_cameraManager.ProcessCameraMove(); // make sure label is positionsed on the map } else { // invalidate picture region around just created leg: Waypoint prevWpt = (Waypoint)m_routeTrack.Trackpoints.GetByIndex(m_routeTrack.Trackpoints.Count - 2); Point p1 = m_cameraManager.toPixelLocation(routeWpt.Location, null); Point p2 = m_cameraManager.toPixelLocation(prevWpt.Location, null); int x = Math.Min(p1.X, p2.X); int y = Math.Min(p1.Y, p2.Y); int w = Math.Abs(p1.X - p2.X); int h = Math.Abs(p1.Y - p2.Y); Rectangle toInv = new Rectangle(x, y, w, h); toInv.Offset(-5, -5); toInv.Inflate(10, 10); m_pictureManager.Invalidate(toInv); } } }
/// <summary> /// Signals the start of the transmission. /// </summary> public void Begin() { MessageRate.Start(); Speed.Start(); }
/// <summary> /// Sets new measurement speed /// </summary> /// <param name="speed">Speed</param> public void SetSpeed(Speed speed) { Set(Commands.Speed, (int)speed); }
/// <summary> /// Adds 2D transition with constant speed. /// </summary> /// <param name="distanceX">Distance along X axis in steps.</param> /// <param name="distanceY">Distance along Y axis in steps.</param> /// <param name="transitionSpeed">Speed of the transition.</param> public void AddConstantSpeedTransitionXY(int distanceX, int distanceY, Speed transitionSpeed) { checked { var sqrt = Math.Sqrt(1.0 * distanceX * distanceX + 1.0 * distanceY * distanceY); var transitionTime = (long)(sqrt * transitionSpeed.Ticks / transitionSpeed.StepCount); var remainingStepsX = distanceX; var remainingStepsY = distanceY; var chunkLengthLimit = 31500; var chunkCount = 1.0 * Math.Max(Math.Abs(distanceX), Math.Abs(distanceY)) / chunkLengthLimit; chunkCount = Math.Max(1, chunkCount); var doneDistanceX = 0L; var doneDistanceY = 0L; var doneTime = 0.0; var i = Math.Min(1.0, chunkCount); while (Math.Abs(remainingStepsX) > 0 || Math.Abs(remainingStepsY) > 0) { var chunkDistanceX = distanceX * i / chunkCount; var chunkDistanceY = distanceY * i / chunkCount; var chunkTime = transitionTime * i / chunkCount; var stepCountXD = chunkDistanceX - doneDistanceX; var stepCountYD = chunkDistanceY - doneDistanceY; var stepsTime = chunkTime - doneTime; var stepCountX = (Int16)Math.Round(stepCountXD); var stepCountY = (Int16)Math.Round(stepCountYD); doneDistanceX += stepCountX; doneDistanceY += stepCountY; //we DON'T want to round here - this way we can distribute time precisely var stepTimeX = stepCountX == 0 ? 0 : (int)(stepsTime / Math.Abs(stepCountX)); var stepTimeY = stepCountY == 0 ? 0 : (int)(stepsTime / Math.Abs(stepCountY)); var timeRemainderX = Math.Abs(stepCountXD) <= 1 ? (UInt16)0 : (UInt16)(stepsTime % Math.Abs(stepCountXD)); var timeRemainderY = Math.Abs(stepCountYD) <= 1 ? (UInt16)0 : (UInt16)(stepsTime % Math.Abs(stepCountYD)); if (stepTimeX == 0 && stepTimeY == 0) { if (doneDistanceX == distanceX && doneDistanceY == distanceY) { break; } throw new NotImplementedException("Send wait signal"); } doneTime += stepsTime; var xPart = createConstant(stepCountX, stepTimeX, timeRemainderX); var yPart = createConstant(stepCountY, stepTimeY, timeRemainderY); AddXY(xPart, yPart); i = i + 1 > chunkCount ? chunkCount : i + 1; } } }
public void DensityTimesSpeedEqualsMassFlux() { MassFlux massFlux = Density.FromKilogramsPerCubicMeter(20) * Speed.FromMetersPerSecond(2); Assert.Equal(massFlux, MassFlux.FromKilogramsPerSecondPerSquareMeter(40)); }
private string FormatSpeed() { return(Speed.ToString("0.00", CultureInfo.InvariantCulture.NumberFormat)); }
public static void DragFromTo(this AndroidApp app, float xStart, float yStart, float xEnd, float yEnd, Speed speed = Speed.Fast) { // No effect on Android app.DragCoordinates(xStart, yStart, xEnd, yEnd); }
/// <summary> /// Serializes the specified fields of the position record into a string suitable for logging or transmitting. /// </summary> /// <param name="fields">A <see cref="GeoFixField" /> bitmap describing the fields to be written.</param> /// <returns>The serialized record.</returns> public string ToString(GeoFixField fields) { return(string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9}", (fields & GeoFixField.TimeUtc) != 0 && TimeUtc.HasValue ? Serialize.ToString(TimeUtc.Value) : string.Empty, (fields & GeoFixField.Latitude) != 0 && !double.IsNaN(Latitude) ? Latitude.ToString() : string.Empty, (fields & GeoFixField.Longitude) != 0 && !double.IsNaN(Longitude) ? Longitude.ToString() : string.Empty, (fields & GeoFixField.Altitude) != 0 && !double.IsNaN(Altitude) ? Altitude.ToString() : string.Empty, (fields & GeoFixField.Course) != 0 && !double.IsNaN(Course) ? Course.ToString() : string.Empty, (fields & GeoFixField.Speed) != 0 && !double.IsNaN(Speed) ? Speed.ToString() : string.Empty, (fields & GeoFixField.HorizontalAccuracy) != 0 && !double.IsNaN(HorizontalAccuracy) ? HorizontalAccuracy.ToString() : string.Empty, (fields & GeoFixField.VerticalAccurancy) != 0 && !double.IsNaN(VerticalAccurancy) ? VerticalAccurancy.ToString() : string.Empty, (fields & GeoFixField.Technology) != 0 && Technology != GeoFixTechnology.Unknown ? Technology.ToString() : string.Empty, (fields & GeoFixField.NetworkStatus) != 0 && NetworkStatus != NetworkStatus.Unknown ? NetworkStatus.ToString() : string.Empty)); }
/// <summary>Initializes a new instance of the <seealso cref="SpeedSegment"/> class.</summary> /// <param name="speed">The speed of the speed segment.</param> /// <param name="x">The starting X of the speed segment.</param> public SpeedSegment(Speed speed, double x) { Speed = speed; X = x; }
public Pickup(float x, float y, Int16 type) : base(x, y) { this.PickupType = type; switch (type) { case (int)PickupManager.PICKUPTYPES.UPGRADE_WEAPON_PRIMARY: img = new Image(Assets.GRAPHIC_PICKUP_UPGRADE_WEAPON_PRIMARY); break; case (int)PickupManager.PICKUPTYPES.AMMO_ROCKET: img = new Image(Assets.GRAPHIC_PICKUP_AMMO_ROCKET); break; case (int)PickupManager.PICKUPTYPES.POWERUP_INV: img = new Image(Assets.GRAPHIC_PICKUP_POWERUP_INV); break; case (int)PickupManager.PICKUPTYPES.POWERUP_HEALTH: img = new Image(Assets.GRAPHIC_PICKUP_POWERUP_HEALTH); break; case (int)PickupManager.PICKUPTYPES.POWERUP_LEVEL_UP: img = new Image(Assets.GRAPHIC_PICKUP_POWERUP_LEVEL_UP); break; case (int)PickupManager.PICKUPTYPES.POWERUP_PLAYER_SHIP: img = new Image(Assets.GRAPHIC_PICKUP_POWERUP_PLAYER_SHIP); break; case (int)PickupManager.PICKUPTYPES.DEGRADE_WEAPON_PRIMARY: img = new Image(Assets.GRAPHIC_PICKUP_DEGRADE_WEAPON_PRIMARY); break; case (int)PickupManager.PICKUPTYPES.AMMO_ROCKET_LOOSE: img = new Image(Assets.GRAPHIC_PICKUP_AMMO_ROCKET_LOOSE); break; case (int)PickupManager.PICKUPTYPES.DEGRADE_50HEALTH: img = new Image(Assets.GRAPHIC_PICKUP_DEGRADE_50HEALTH); break; case (int)PickupManager.PICKUPTYPES.UPGRADE_SPEED: img = new Image(Assets.GRAPHIC_PICKUP_UPGRADE_SPEED); break; case (int)PickupManager.PICKUPTYPES.DEGRAGE_SPEED: img = new Image(Assets.GRAPHIC_PICKUP_DEGRADE_SPEED); break; default: img = Image.CreateRectangle(5, Color.Red); break; } this.X = x; this.Y = y; this.speed = new Speed(Global.SPEED_PICKUP_MAX); this.speed.Y = Rand.Int(2, Global.SPEED_PICKUP_MAX); img.CenterOrigin(); this.SetGraphic(img); CircleCollider col = new CircleCollider((int)this.img.HalfWidth, (int)Global.HIT_TYPES.PICKUP); col.CenterOrigin(); this.AddCollider(col); }
public HumanMouse(DeviceControl control, Speed speed) { this.speed = speed; this.control = control; }
/// <summary> /// Creates a GprmcSentence from the specified parameters /// </summary> /// <param name="utcDateTime"></param> /// <param name="isFixAcquired"></param> /// <param name="position"></param> /// <param name="speed"></param> /// <param name="bearing"></param> /// <param name="magneticVariation"></param> public GprmcSentence(DateTime utcDateTime, bool isFixAcquired, Position position, Speed speed, Azimuth bearing, Longitude magneticVariation) { // Use a string builder to create the sentence text StringBuilder builder = new StringBuilder(128); /* GPRMC sentences have the following format: * * $GPRMC,040302.663,A,3939.7,N,10506.6,W,0.27,358.86,200804,,*1A */ // Append the command word, $GPRMC builder.Append("$GPRMC"); // Append a comma builder.Append(','); #region Append the UTC time builder.Append(utcDateTime.Hour.ToString("0#", NmeaCultureInfo)); builder.Append(utcDateTime.Minute.ToString("0#", NmeaCultureInfo)); builder.Append(utcDateTime.Second.ToString("0#", NmeaCultureInfo)); builder.Append("."); builder.Append(utcDateTime.Millisecond.ToString("00#", NmeaCultureInfo)); #endregion // Append a comma builder.Append(','); #region Append the fix status // Write fix information if (isFixAcquired) { builder.Append("A"); } else { builder.Append("V"); } #endregion // Append a comma builder.Append(','); #region Append the position // Append latitude in the format HHMM.MMMM. builder.Append(position.Latitude.ToString("HHMM.MMMM,I,", NmeaCultureInfo)); // Append Longitude in the format HHHMM.MMMM. builder.Append(position.Longitude.ToString("HHHMM.MMMM,I,", NmeaCultureInfo)); #endregion // Append the speed (in knots) builder.Append(speed.ToKnots().ToString("v.v", NmeaCultureInfo)); // Append a comma builder.Append(','); // Append the bearing builder.Append(bearing.ToString("d.d", NmeaCultureInfo)); // Append a comma builder.Append(','); #region Append the UTC date // Append UTC date builder.Append(utcDateTime.Day.ToString("0#", NmeaCultureInfo)); builder.Append(utcDateTime.Month.ToString("0#", NmeaCultureInfo)); // Append the year (year minus 2000) int year = utcDateTime.Year - 2000; builder.Append(year.ToString("0#", NmeaCultureInfo)); #endregion // Append a comma builder.Append(','); // Append magnetic variation builder.Append(magneticVariation.ToString("d.d", NmeaCultureInfo)); // Set this object's sentence SetSentence(builder.ToString()); // Finally, append the checksum AppendChecksum(); }
public override void Update(GameForm form) { if (Speed.Length > 0) { Speed -= Speed.Normalize() * 1.5; } if (Speed.Length > 8) { Speed = Speed.Normalize() * 8; } if (form.GameSpace.Map[Column, Row].Block is Ladder) { if (Spacing.Length < 10) { Speed = Vector.Zero; } if (actions.Contains(Action.Climb)) { if (direction == Direction.Up) { if (Speed.Y > -4) { Speed += new Vector(0, -4); } } if (direction == Direction.Down) { if (Speed.Y < 4) { Speed += new Vector(0, 4); } } if (direction == Direction.Left) { if (Speed.X > -4) { Speed += new Vector(-4, 0); } } if (direction == Direction.Right) { if (Speed.X < 4) { Speed += new Vector(4, 0); } } } } else { Speed += new Vector(0, 3); if (actions.Contains(Action.Run)) { if (direction == Direction.Left) { if (Speed.X > -4) { Speed += new Vector(-4, 0); } } if (direction == Direction.Right) { if (Speed.X < 4) { Speed += new Vector(4, 0); } } } if (actions.Contains(Action.Jump)) { if (form.GameSpace.Map[Column, Row].Bottom != null) { if (!form.GameSpace.Map[Column, Row].Bottom.IsPermeable && Spacing.Y < 3) { Jump(); } } } } Move(form); if (Row == 11) { Destroy(); } base.Update(form); }
protected override void OnSentenceChanged() { // First, process the basic info for the sentence base.OnSentenceChanged(); // Cache the sentence words string[] words = base.Words; int wordCount = words.Length; /* * $GPRMC * * Recommended minimum specific GPS/Transit data * * eg1. $GPRMC,081836,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E*62 * eg2. $GPRMC,225446,A,4916.45,N,12311.12,W,000.5,054.7,191194,020.3,E*68 * * * 225446 Time of fix 22:54:46 UTC * A Navigation receiver warning A = OK, V = warning * 4916.45,N Latitude 49 deg. 16.45 min North * 12311.12,W Longitude 123 deg. 11.12 min West * 000.5 Speed over ground, Knots * 054.7 Course Made Good, True * 191194 Date of fix 19 November 1994 * 020.3,E Magnetic variation 20.3 deg East * 68 mandatory checksum * * * eg3. $GPRMC,220516,A,5133.82,N,00042.24,W,173.8,231.8,130694,004.2,W*70 * 1 2 3 4 5 6 7 8 9 10 11 12 * * * 1 220516 Time Stamp * 2 A validity - A-ok, V-invalid * 3 5133.82 current Latitude * 4 N North/South * 5 00042.24 current Longitude * 6 W East/West * 7 173.8 Speed in knots * 8 231.8 True course * 9 130694 Date Stamp * 10 004.2 Variation * 11 W East/West * 12 *70 checksum * * * eg4. $GPRMC,hhmmss.ss,A,llll.ll,a,yyyyy.yy,a,x.x,x.x,ddmmyy,x.x,a*hh * 1 = UTC of position fix * 2 = Data status (V=navigation receiver warning) * 3 = Latitude of fix * 4 = N or S * 5 = Longitude of fix * 6 = E or W * 7 = Speed over ground in knots * 8 = Track made good in degrees True * 9 = UT date * 10 = Magnetic variation degrees (Easterly var. subtracts from true course) * 11 = E or W * 12 = Checksum */ // Do we have enough words to parse the fix status? if (wordCount >= 2 && words[1].Length != 0) { #region Fix status // Get the fix flag _FixStatus = words[1].Equals("A", StringComparison.OrdinalIgnoreCase) ? FixStatus.Fix : FixStatus.NoFix; #endregion } else { // The fix status is invalid _FixStatus = FixStatus.Unknown; } // Do we have enough words to parse the UTC date/time? if (wordCount >= 9 && words[0].Length != 0 && words[8].Length != 0) { #region Parse the UTC time string utcTimeWord = words[0]; int utcHours = int.Parse(utcTimeWord.Substring(0, 2), NmeaCultureInfo); // AA int utcMinutes = int.Parse(utcTimeWord.Substring(2, 2), NmeaCultureInfo); // BB int utcSeconds = int.Parse(utcTimeWord.Substring(4, 2), NmeaCultureInfo); // CC int utcMilliseconds = 0; if (utcTimeWord.Length > 6) { utcMilliseconds = Convert.ToInt32(float.Parse(utcTimeWord.Substring(6), NmeaCultureInfo) * 1000, NmeaCultureInfo); // DDDD } #endregion #region Parse the UTC date string utcDateWord = words[8]; int utcDay = int.Parse(utcDateWord.Substring(0, 2), NmeaCultureInfo); int utcMonth = int.Parse(utcDateWord.Substring(2, 2), NmeaCultureInfo); int utcYear = int.Parse(utcDateWord.Substring(4, 2), NmeaCultureInfo) + 2000; #endregion #region Build a UTC date/time _UtcDateTime = new DateTime(utcYear, utcMonth, utcDay, utcHours, utcMinutes, utcSeconds, utcMilliseconds, DateTimeKind.Utc); #endregion } else { // The UTC date/time is invalid _UtcDateTime = DateTime.MinValue; } // Do we have enough data to parse the location? if (wordCount >= 6 && words[2].Length != 0 && words[3].Length != 0 && words[4].Length != 0 && words[5].Length != 0) { #region Parse the latitude string latitudeWord = words[2]; int latitudeHours = int.Parse(latitudeWord.Substring(0, 2), NmeaCultureInfo); double latitudeDecimalMinutes = double.Parse(latitudeWord.Substring(2), NmeaCultureInfo); LatitudeHemisphere latitudeHemisphere = words[3].Equals("N", StringComparison.Ordinal) ? LatitudeHemisphere.North : LatitudeHemisphere.South; #endregion #region Parse the longitude string longitudeWord = words[4]; int longitudeHours = int.Parse(longitudeWord.Substring(0, 3), NmeaCultureInfo); double longitudeDecimalMinutes = double.Parse(longitudeWord.Substring(3), NmeaCultureInfo); LongitudeHemisphere longitudeHemisphere = words[5].Equals("E", StringComparison.Ordinal) ? LongitudeHemisphere.East : LongitudeHemisphere.West; #endregion #region Build a Position from the latitude and longitude _Position = new Position( new Latitude(latitudeHours, latitudeDecimalMinutes, latitudeHemisphere), new Longitude(longitudeHours, longitudeDecimalMinutes, longitudeHemisphere)); #endregion } else { _Position = Position.Invalid; } // Do we have enough info to process speed? if (wordCount >= 7 && words[6].Length != 0) { #region Speed // The speed is the sixth word, expressed in knots _Speed = new Speed(double.Parse(words[6], NmeaCultureInfo), SpeedUnit.Knots); #endregion } else { // The speed is invalid _Speed = Speed.Invalid; } // do we have enough info to process the bearing? if (wordCount >= 8 && words[7].Length != 0) { #region Bearing // The bearing is the seventh word _Bearing = new Azimuth(double.Parse(words[7], NmeaCultureInfo)); #endregion } else { // The bearing is invalid _Bearing = Azimuth.Invalid; } // Do we have enough info for magnetic variation? if (wordCount >= 10 && words[9].Length != 0) { // Parse the value _MagneticVariation = new Longitude(double.Parse(words[9], NmeaCultureInfo)); } else { // The magnetic variation is invalid _MagneticVariation = Longitude.Invalid; } }
protected override void SolveInstance(IGH_DataAccess DA) { DA.GetData("Calculate", ref this._calc); if (!this._calc) { DA.SetDataList("Targets", this._targets); DA.SetData("Path", this._path); //DA.SetDataList("Planes", this._planes); DA.SetData("debug", this._debug); return; } this._debug = ""; this._path = null; this._targets = null; this._planes = null; Plane frame_t = new Plane(); this._toolpaths = new List <Polyline>(); // collect inputs DA.GetData("Workplane", ref this._workplane); DA.GetData("External axes", ref this._extern); DA.GetData("Configuration", ref this._config); if (!DA.GetData("Frame", ref frame_t)) { _frame = Frame.Default; } //_frame = new Frame(Plane.WorldXY, "tasFrame"); else { _frame = new Frame(frame_t, -1, -1, "tasFrame"); } Robots.Grasshopper.GH_Tool toolGH = null; DA.GetData("Tool", ref toolGH); this._tool = toolGH?.Value; this._debug += toolGH.ToString() + "\n"; this._debug += toolGH.GetType().ToString() + "\n"; if (this._tool == null) { this._debug += "Tool conversion failed...\n"; } else { this._debug += this._tool.ToString() + "\n"; this._debug += this._tool.GetType().ToString() + "\n"; } // gather and convert, if necessary, input curves List <Curve> in_crvs = new List <Curve>(); if (!DA.GetDataList("Toolpaths", in_crvs)) { return; } this._toolpaths = tasUtility.CurvesToPolylines(in_crvs, 1.0); this._is_drive_surface = DA.GetData("DriveSurface", ref this._drive_surface); DA.GetData("Safe Z", ref this._safe_z); DA.GetData("Rapid Z", ref this._rapid_z); DA.GetData("Feed rate", ref this._feedrate); DA.GetData("Rapid rate", ref this._rapidrate); DA.GetData("Ramp height", ref this._ramp_height); DA.GetData("Tool twist", ref this._tooltwist); // /collect inputs // set up speeds Speed sp_feed = new Speed(this._feedrate, Math.PI, "feed"); Speed sp_rapid = new Speed(this._rapidrate, Math.PI, "rapid"); // rotate workplane to account for tool twist Transform rot = Transform.Rotation(this._tooltwist, _workplane.ZAxis, _workplane.Origin); _workplane.Transform(rot); // init toolpath Toolpath prog = new Toolpath(); prog.External2 = this._extern; prog.External1 = this._extern; prog.Configuration = (Target.RobotConfigurations) this._config; prog.DefFrame = _frame; if (this._tool != null) { prog.DefTool = this._tool; } else { this._debug += "Tool conversion failed again...\n"; } prog.DefSpeed = sp_rapid; prog.DefMotion = Target.Motions.Linear; if (this._is_drive_surface) { prog.InputSurface = this._drive_surface; } prog.Orientation = Toolpath.ToolOrientation.SurfaceNormal; prog.Workplane = this._workplane; for (int i = 0; i < this._toolpaths.Count; ++i) { if (this._toolpaths[i] == null) { continue; } // lead in Polyline ramp = (Polyline)Util.CreateRamp(this._toolpaths[i], this._workplane, this._ramp_height, this._ramp_height * 5); Point3d p = Util.ProjectToPlane(ramp[0], prog.Workplane); prog.CreateTarget(p + prog.Workplane.ZAxis * (this._safe_z + this._rapid_z)); prog.CreateTarget(p + prog.Workplane.ZAxis * (this._safe_z)); // machining speed prog.DefSpeed = sp_feed; prog.DefMotion = Target.Motions.Linear; for (int j = 0; j < ramp.Count; ++j) { prog.CreateTarget(ramp[j], Toolpath.ToolOrientation.ZAxis); } /* * Point3d p = tasUtility.ProjectToPlane(this._toolpaths[i][0], prog.Workplane); * Vector3d d2p = new Vector3d(p - this._toolpaths[i][0]); * Vector3d ramp = new Vector3d(tasUtility.ProjectToPlane(this._toolpaths[i][1], prog.Workplane) - p); * if (ramp.Length < this._ramp_height) * ramp = new Vector3d(tasUtility.ProjectToPlane(this._toolpaths[i][this._toolpaths[i].Count - 2], prog.Workplane) - p); * ramp.Unitize(); * p += ramp * this._ramp_height; * p += prog.Workplane.ZAxis * (this._safe_z + this._rapid_z); * prog.CreateTarget(p, Toolpath.ToolOrientation.ZAxis); * p -= prog.Workplane.ZAxis * this._rapid_z; * p -= d2p; * prog.CreateTarget(p, Toolpath.ToolOrientation.ZAxis); */ // make toolpath targets for (int j = 0; j < this._toolpaths[i].Count; ++j) { prog.CreateTarget(this._toolpaths[i][j]); } // lead out Point3d p2 = Util.ProjectToPlane(this._toolpaths[i][this._toolpaths[i].Count - 1], prog.Workplane); p2 += prog.Workplane.ZAxis * this._safe_z; prog.DefSpeed = sp_rapid; prog.CreateTarget(p2, Toolpath.ToolOrientation.ZAxis); p2 += prog.Workplane.ZAxis * this._rapid_z; //prog.DefSpeed = spr; prog.CreateTarget(p2, Toolpath.ToolOrientation.ZAxis); } // yield toolpath this._targets = prog.Targets; this._path = prog.Path(); this._planes = prog.Planes; DA.SetDataList("Targets", this._targets); DA.SetData("Path", this._path); //DA.SetDataList("Planes", this._planes); DA.SetData("debug", this._debug); }
public void StartRace(params Car[] cars) { int distance; bool status; do { Console.Write("Enter distance (meters): "); string d = Console.ReadLine(); status = int.TryParse(d, out distance); if (status) { distance = int.Parse(d); } } while (!status || distance == 0); // Starting timer here >> Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); string s = String.Format("{0} ", "TIME".PadRight(10)); int i = 0; foreach (Car car in cars) { s += String.Format("{0} {1} | {2} ", car.Brand.PadLeft(10), "SPEED".PadRight(10), "DISTANCE".PadRight(5)); } Console.WriteLine(s); s = ""; Random rand = new Random(); while (!this.IsOver(distance, cars)) { i++; s = String.Format("{0, 7}{1:3}", (i + 1) * 10000, Time.Format.SEC.ToString().ToLower()); foreach (Car car in cars) { car.Acceleration = rand.Next(-20, 21); if (car.Speed + car.Acceleration > 0) { car.Speed += car.Acceleration; car.DistanceTravelled += car.SetDistanceTravelled(car.Speed); } else { car.Speed = 0; car.DistanceTravelled += car.SetDistanceTravelled(car.Speed); } s += String.Format("{0} {1} {2} | {3}M", "".PadRight(10), car.Speed.ToString().PadRight(5), Speed.KMxHR().Value, car.DistanceTravelled.ToString().PadRight(4)); // change this } Thread.Sleep(500); Console.WriteLine(s); s = ""; } // Ending timer here >> stopwatch.Stop(); Console.WriteLine(stopwatch.Elapsed); }
public void MassFluxDividedBySpeedEqualsDensity() { Density density = MassFlux.FromKilogramsPerSecondPerSquareMeter(20) / Speed.FromMetersPerSecond(2); Assert.Equal(density, Density.FromKilogramsPerCubicMeter(10)); }
public Wind() { Speed = new Speed(); }