public async Task <bool> Run(JobInfo jobInfo, CancellationToken cancelToken) { try { var subscriptionsSync = DB.ConnectionSync.Table <NotificationSubscription>().ToList(); foreach (var sub in subscriptionsSync) { var subLocation = new Location(sub.Latitude, sub.Longitude); var hash = await Hasher.GetHashData(DateTime.Today, subLocation); var nearBy = new List <Location>(hash.Data.Neighbours) { hash.Data }; var closest = nearBy.OrderBy(x => DistanceCalculator.CalculateDistance(subLocation, x)).FirstOrDefault(); var distance = DistanceCalculator.CalculateDistance(subLocation, closest); var message = $"Today's hash is {distance}km from {sub.Name} at ({sub.Latitude.ToString("0.###")},{sub.Longitude.ToString("0.###")})"; if (distance < sub.Radius) { await notificationManager.Send(new Notification { Title = $"Hash is close to {sub.Name}", Message = message + $". Alarm set for {sub.AlarmTime}" }); } } } catch (Exception ex) { //CrossLocalNotifications.Current.Show("Error", ex.ToString(), 5);//Never seen this } return(true); }
public void AnalyzeCollision_AnalyzesCollisionBetweenTwoFlights_ReturnsTrue(int distance, int altitude) { _fakeDistanceCalculator .CalculateDistance(Arg.Any <double>(), Arg.Any <double>(), Arg.Any <double>(), Arg.Any <double>()) .Returns(distance); _fakeAltitudeDistanceCalculator.CalculateAltitudeDistance(Arg.Any <int>(), Arg.Any <int>()).Returns(altitude); //Assert Assert.That(_uut.AnalyzeCollision(new Track(), new Track()), Is.EqualTo(true)); }
public void GivenCaseTest() { var point1 = new DistancePoint { Latitude = 53.297975, Longitude = -6.372663 }; var point2 = new DistancePoint { Latitude = 41.385101, Longitude = -81.440440 }; var result = instanceUnderTest.CalculateDistance(point1, point2, MeasureUnit.Km); Assert.AreEqual(5536.338682266685, result); }
public Vector <double> ProcessInput(Vector <double> input) { Vector <double> tmpValues = Vector <double> .Build.DenseOfArray(new double[RadialLayer.Count]); for (int i = 0; i < RadialLayer.Count; i++) { var diff = _distance.CalculateDistance(input, RadialLayer[i].Position); var width = RadialLayer[i].Width;// * ScalingCoefficient; tmpValues[i] = _gaussian.Calculate(diff, width); RadialLayer[i].Outputs.Add(tmpValues[i]); // radial output saving test } Vector <double> outputValues = Vector <double> .Build.DenseOfArray(new double[LinearLayer.Count]); for (int i = 0; i < LinearLayer.Count; i++) { var weights = LinearLayer[i].Weights; for (int j = 0; j < weights.Count; j++) { outputValues[i] += weights[j] * tmpValues[j]; } outputValues[i] += LinearLayer[i].BiasWeight * 1.0; } return(outputValues); }
public void AnalyzeCollision_PossibleCollision_ReturnsTrue(int distance, int altitude1, int altitude2) { _fakedistanceCalculator .CalculateDistance(Arg.Any <double>(), Arg.Any <double>(), Arg.Any <double>(), Arg.Any <double>()) .Returns(distance); Track trackOne = new Track() { Altitude = altitude1 }; Track trackTwo = new Track() { Altitude = altitude2 }; Assert.That(_collisionAnalyzer.AnalyzeCollision(trackOne, trackTwo), Is.EqualTo(true)); }
public bool AnalyzeCollision(Track flight1, Track flight2) { if (_horizontaDistanceCalculator.CalculateDistance(flight1.XCoordinate, flight2.XCoordinate, flight1.YCoordinate, flight2.YCoordinate) < 5000 && _altitudeDistanceCalculator.CalculateAltitudeDistance(flight1.Altitude, flight2.Altitude) < 300) { return(true); } return(false); }
/// <summary> /// Calculate distance between contigs using paired reads. /// </summary> /// <param name="contigMatePairs">Contig Mate Pair map.</param> /// <returns>Number of contig-read pairs</returns> protected int CalculateDistanceBetweenContigs(ContigMatePairs contigMatePairs) { if (contigMatePairs == null) { throw new ArgumentNullException("contigMatePairs"); } _distanceCalculator.CalculateDistance(contigMatePairs); // this dictionary is updated in this step return(contigMatePairs.Count); }
public void CalculateVelocity_CalculatingVelocity_VelocityIsCorrect(int seconds, int meters, double expectedVelocity) { var timeSpan = new TimeSpan(0, 0, seconds); _fakeTimeSpanCalculator.CalculateTimeDifference(Arg.Any <DateTime>(), Arg.Any <DateTime>()).Returns(timeSpan); _fakeDistanceCalculator .CalculateDistance(Arg.Any <double>(), Arg.Any <double>(), Arg.Any <double>(), Arg.Any <double>()) .Returns(meters); Track newTrack = new Track(); Track oldTrack = new Track(); _uut.CalculateVelocity(oldTrack, newTrack); Assert.That(newTrack.HorizontalVelocity, Is.EqualTo(expectedVelocity)); }
public void PythagorousCaseTest() { instanceUnderTest = new PythagorousDistanceCalculator(); var point1 = new DistancePoint { Latitude = 90, Longitude = 57.295779513082323 }; var point2 = new DistancePoint { Latitude = -90, Longitude = 57.295779513082323 }; var result = instanceUnderTest.CalculateDistance(point1, point2, MeasureUnit.Km); Assert.AreEqual(Math.Round(20015.08), Math.Round(result)); }
public Dictionary <Neuron, double> CalculateNeighborhoodValues(Neuron winner, Dictionary <Neuron, double> neuronDistances, IDistanceCalculator distanceCalculator, int k) { Dictionary <Neuron, double> neuronNeighborhoodValues = new Dictionary <Neuron, double>(); var currentRadius = Math.Abs(_radius.GetValue(k)) < 0.00001 ? 0.000001 : _radius.GetValue(k); foreach (var neuronDistancePair in neuronDistances) { var vecDiff = distanceCalculator.CalculateDistance(winner.CurrentWeights, neuronDistancePair.Key.CurrentWeights); var exponent = (-1.0) * ((vecDiff * vecDiff) / (2 * currentRadius * currentRadius)); var neighborhoodValue = Math.Exp(exponent); neuronNeighborhoodValues.Add(neuronDistancePair.Key, neighborhoodValue); } return(neuronNeighborhoodValues); }
public void CalculateVelocity_CalculatesVelocity_VelocityIsCorrect(int distance, int secondsBetweenTimestamps, double expectedVelocity) { _fakeDistanceCalculator .CalculateDistance(Arg.Any <double>(), Arg.Any <double>(), Arg.Any <double>(), Arg.Any <double>()) .Returns(distance); DateTime firstDateTime = DateTime.Now; DateTime secondDateTime = firstDateTime.AddSeconds(secondsBetweenTimestamps); Track trackOne = new Track() { TimeStamp = firstDateTime }; Track trackTwo = new Track() { TimeStamp = secondDateTime }; _velocityCalculator.CalculateVelocity(trackOne, trackTwo); Assert.That(trackTwo.HorizontalVelocity, Is.EqualTo(expectedVelocity).Within(0.5)); }
public Dictionary <Neuron, double> CalculateNeighborhoodValues(Neuron winner, Dictionary <Neuron, double> neuronDistances, IDistanceCalculator distanceCalculator, int k) { Dictionary <Neuron, double> neuronNeighborhoodValues = new Dictionary <Neuron, double>(); foreach (var neuronDistancePair in neuronDistances) { var neighborhoodValue = distanceCalculator.CalculateDistance(winner.CurrentWeights, neuronDistancePair.Key.CurrentWeights); neuronNeighborhoodValues.Add(neuronDistancePair.Key, neighborhoodValue < _radius.GetValue(k) ? 1 : 0); } return(neuronNeighborhoodValues); }
public void CalculateWidths(List <RadialNeuron> radialLayer) { for (int i = 0; i < radialLayer.Count; i++) { List <Tuple <RadialNeuron, double> > centersWithDistances = new List <Tuple <RadialNeuron, double> >(); for (int j = 0; j < radialLayer.Count; j++) { if (i != j) { var calculatedDistance = _distance.CalculateDistance(radialLayer[i].Position, radialLayer[j].Position); centersWithDistances.Add(new Tuple <RadialNeuron, double>(radialLayer[j], calculatedDistance)); } } var orderedByDistance = centersWithDistances.OrderBy(tuple => tuple.Item2).Take(KNeighbors); var toCount = ScalingCoefficient * Math.Sqrt((1.0 / KNeighbors) * orderedByDistance.Sum(elem => elem.Item2 * elem.Item2)); // sqrt( alpha * 1/p * SUM[(Dij)^2] ) radialLayer[i].Width = toCount; // should set wanted values } }
public void CalculateVelocity(Track oldTrack, Track newTrack) { newTrack.HorizontalVelocity = Calculate(_distanceCalculator.CalculateDistance(oldTrack.XCoordinate, newTrack.XCoordinate, oldTrack.YCoordinate, newTrack.YCoordinate), _timeSpanCalculator.CalculateTimeDifference(oldTrack.TimeStamp, newTrack.TimeStamp)); }
public IEnumerable <RouteModel> CalculateRoutes(IEnumerable <EventModel> events, string homeAddress) { events = FilterEvents(events); var routes = new List <RouteModel>(); // create routes from events // if an event has a previous event within 3 hours, use this as origin for (int i = 0; i < events.Count(); i++) { var currentEvent = events.ElementAt(i); // check for previous event var previousEvent = events.ElementAtOrDefault(i - 1); var previousEventIsWithin3Hours = previousEvent == null ? false : previousEvent.End >= currentEvent.Start.AddHours(-3); if (previousEventIsWithin3Hours) { // from previous location to this location routes.Add(new RouteModel() { Date = currentEvent.Start, Origin = previousEvent.Location, Destination = currentEvent.Location, OriginEvent = previousEvent, DestinationEvent = currentEvent }); } else { // from home to this location routes.Add(new RouteModel() { Date = currentEvent.Start, Origin = homeAddress, Destination = currentEvent.Location, DestinationEvent = currentEvent }); } var nextEvent = events.ElementAtOrDefault(i + 1); var nextEventIsWithin3Hours = nextEvent == null ? false : nextEvent.Start <= currentEvent.End.AddHours(3); if (nextEventIsWithin3Hours) { // already added } else { // from this location to home routes.Add(new RouteModel() { Date = currentEvent.End, Origin = currentEvent.Location, Destination = homeAddress, OriginEvent = currentEvent }); } } foreach (var route in routes) { var distanceInMeters = distanceCalculator.CalculateDistance(route.Origin, route.Destination); route.Distance = Math.Round(((decimal)distanceInMeters / 1000), 2); } return(routes); }
public List <int> Run(float vehicleCapacity, List <float> currentVehicleCapasity, int currentVehicleIndex) { var route = new List <int>(); int counter = 0; do { route.Clear(); int startPoint = 0; double currentTime = 0.0; route.Add(startPoint); dataset.FirstOrDefault(item => item.ID == startPoint).IsDone = true; while (!dataset.All(item => item.IsDone)) { var distDict = distanceCalculator.CalculateDistance(dataset, startPoint); if (distDict.Count == 0) { break; } double cMin = distDict.Min(x => x.Value); double cMax = distDict.Max(x => x.Value); double criteria = cMin + Parameters.ALPHA * (cMax - cMin); double demandCriteria = vehicleCapacity - currentVehicleCapasity[currentVehicleIndex]; var listWithGoodPoints = new List <Instance>(); foreach (var dist in distDict) { var tmp_inst = dataset.FirstOrDefault(item => item.ID == dist.Key); double futureTime = currentTime + dist.Value; bool timeWindowCriteria = (futureTime < tmp_inst.DueTime + Parameters.SOFT_DUE_WINDOW); if (dist.Value <= criteria && tmp_inst.Demand <= demandCriteria && timeWindowCriteria) { listWithGoodPoints.Add(tmp_inst); } } var RCL = new HashSet <int>(); foreach (var point in listWithGoodPoints) { double cMinReadyTime = listWithGoodPoints.Min(x => x.ReadyTime); double cMaxReadyTime = listWithGoodPoints.Max(x => x.ReadyTime); double criteriaReadyTime = cMinReadyTime + Parameters.ALPHA_READY_TIME * (cMaxReadyTime - cMinReadyTime); if (point.ReadyTime <= criteriaReadyTime) { RCL.Add(point.ID); } } if (RCL.Count == 0) { break; } else { var prevStartPoint = dataset.FirstOrDefault(item => item.ID == startPoint); Random random = new Random(); startPoint = RCL.ElementAt(random.Next(RCL.Count)); var inst = dataset.FirstOrDefault(item => item.ID == startPoint); currentVehicleCapasity[currentVehicleIndex] += inst.Demand; float dist = (float)distanceCalculator.FindLength(inst, prevStartPoint); double futureTime = currentTime + dist; if (futureTime < inst.ReadyTime) { currentTime = inst.ReadyTime; } currentTime += dist + inst.ServiceTime; route.Add(startPoint); dataset.FirstOrDefault(item => item.ID == startPoint).IsDone = true; } } route.Add(0); counter++; } while (!evaluator.CanExistWithCurrentTimeWindows(dataset, route, distanceCalculator) || route.Count <= 2); return(route); }