public T Calculate(Connection connection) { var startPosition = _crossingPositionProvider.Get(connection.Start); var endPosition = _crossingPositionProvider.Get(connection.Start); return(_distanceCalculator.Calculate(startPosition, endPosition)); }
public JsonResult GetDistance(DistanceInput distanceInput) { double distance = 0; var airportsData = _cachingManager.GetFromCache(Constants.KEY_CACHE_LOCATIONS) as Location[]; if (airportsData == null) { return(Json(distance, JsonRequestBehavior.AllowGet)); } var source = airportsData.First(airport => airport.iata.Equals(distanceInput.SourceAirport)); var destination = airportsData.First(airport => airport.iata.Equals(distanceInput.DestinationAirport)); var sourceCoordinates = new Coordinates(); var destinationCoordinates = new Coordinates(); if (source != null && destination != null) { sourceCoordinates = new Coordinates { latitude = double.Parse(source.lat), longitude = double.Parse(source.lon) }; destinationCoordinates = new Coordinates { latitude = double.Parse(destination.lat), longitude = double.Parse(destination.lon) }; } distance = _distanceCalculator.Calculate(sourceCoordinates, destinationCoordinates); return(Json(distance, JsonRequestBehavior.AllowGet)); }
public async Task <Dictionary <string, double> > GetClosestUsersAsync(UserGpsInformation userGpsInformation, int selectedDistance = 100) { IEnumerable <UserGpsInformation> userGpsInformations = await _redisConnection.GetAllAsync(); Dictionary <string, double> closestUsers = new Dictionary <string, double>(); foreach (var otherUserCoordinates in userGpsInformations) { if (String.Equals(otherUserCoordinates.UserNickname, userGpsInformation.UserNickname)) { continue; } double distance = _distanceCalculator.Calculate(userGpsInformation.Latitude, userGpsInformation.Longitude, otherUserCoordinates.Latitude, otherUserCoordinates.Longitude); if (closestUsers.ContainsKey(otherUserCoordinates.UserNickname) && distance <= selectedDistance) { closestUsers[otherUserCoordinates.UserNickname] = distance; } else { if (distance <= selectedDistance) { closestUsers.Add(otherUserCoordinates.UserNickname, distance); } } } return(closestUsers); }
public IEnumerable <Distance> Calculate(string fromZipcode, IEnumerable <string> toZipcodes) { var notFoundDistances = new List <string>(); var foundDistances = new List <Distance>(); foreach (var toZipcode in toZipcodes) { var zipcodeDistance = _unitOfWork.ZipcodeDistances .All .FirstOrDefault(z => z.FromZipcode.Value == fromZipcode && z.ToZipcode.Value == toZipcode); if (zipcodeDistance == null) { notFoundDistances.Add(toZipcode); } else { var distance = new Distance(zipcodeDistance.DistinceInMinutes, toZipcode); foundDistances.Add(distance); } } if (notFoundDistances.Any()) { var calculatedDistances = _distanceCalculator.Calculate(fromZipcode, notFoundDistances); var toSaveDistances = calculatedDistances.Select(d => new ZipcodeDistance { CreatedOn = DateTime.Now, DistinceInMinutes = d.TravelDistanceInMinutes, FromZipcode = _unitOfWork.Zipcodes.All.FirstOrDefault(z => z.Value == fromZipcode) ?? new Zipcode { Value = fromZipcode }, ToZipcode = _unitOfWork.Zipcodes.All.FirstOrDefault(z => z.Value == d.Zipcode) ?? new Zipcode { Value = d.Zipcode } }); //Also create entries for the other way around: b -> a instead of only a -> b var toSaveDistancesReversed = toSaveDistances.Select(d => new ZipcodeDistance { CreatedOn = DateTime.Now, DistinceInMinutes = d.DistinceInMinutes, FromZipcode = d.ToZipcode, ToZipcode = d.FromZipcode }); _unitOfWork.ZipcodeDistances.Add(toSaveDistances); _unitOfWork.ZipcodeDistances.Add(toSaveDistancesReversed); _unitOfWork.SaveChanges(); foundDistances.AddRange(calculatedDistances); } return(foundDistances); }
string CalculationDistanceInPath(string route) { try { return(DistanceCalculationService.Calculate(route).ToString()); } catch (ValidationException ex) { return(ex.Message); } }
public ISquadsSetup Make(int numberOfSquads) { var source = _setupSourceFactory.New(); var players = source.Players.Shuffle(); var squadSetup = _squadSetupFactory.New(players, numberOfSquads); var distance = _distanceCalculator.Calculate(source.AverageSkills, squadSetup.Squads.Select(s => s.AverageSkills)); for (int i = 0; i < NumberOfIterations; i++) { var newPlayers = players.RandomSwap(); squadSetup = _squadSetupFactory.New(newPlayers, numberOfSquads); var newDistance = _distanceCalculator.Calculate(source.AverageSkills, squadSetup.Squads.Select(s => s.AverageSkills)); if (newDistance < distance) { players = newPlayers; distance = newDistance; } } return(_squadSetupFactory.New(players, numberOfSquads)); }
public Destination Calculate(Node start, IEnumerable <Intersection> intersections) { var destinations = intersections .Select(s => s.Nodes.First()) .Select(i => new Destination { Node = i, Distance = _calculator.Calculate(start, i) }) .Where(d => d.Distance != 0); var closest = destinations.OrderBy(o => o.Distance).FirstOrDefault(); return(closest); }
public ISquadsSetup Make(int numberOfSquads) { var setupSource = _setupSourceFactory.New(); var candidateSetups = Enumerable.Range(0, NumberOfShuffles) .Select(i => _squadSetupFactory.New(setupSource.Players.Shuffle(), numberOfSquads)) .Select(ss => new { SquadsSetup = ss, DistanceFromAverage = _distanceCalculator.Calculate(setupSource.AverageSkills, ss.Squads.Select(s => s.AverageSkills)) }) .ToArray(); var minDistanceFromAverageSkills = candidateSetups.Min(cs => cs.DistanceFromAverage); return(candidateSetups.First(cs => cs.DistanceFromAverage == minDistanceFromAverageSkills).SquadsSetup); }
private IQueryable <Vacancy> FilterByZipcodeDistance(IQueryable <Vacancy> vacancies, SearchCriteria criteria) { if (string.IsNullOrEmpty(criteria.Zipcode) || criteria.TravelTime <= 0) { return(vacancies); } var vacancyZipcodes = vacancies.Select(v => v.Zipcode.Value).ToList(); _distances = _distanceCalculator.Calculate(criteria.Zipcode, vacancyZipcodes); var matchingZipcodes = _distances .Where(d => d.TravelDistanceInMinutes <= criteria.TravelTime) .Select(d => d.Zipcode.ToLower()); var matchingVacancies = vacancies.Where(v => matchingZipcodes.Contains(v.Zipcode.Value.ToLower())); return(matchingVacancies); }
public AggregatedDistanceOutput Calculate(AircraftData aircraftData, IIntegrator integrator, int nrOfFailedEngines, double density, double gravitationalAcceleration, CalculationSettings calculationSettings) { if (aircraftData == null) { throw new ArgumentNullException(nameof(aircraftData)); } if (integrator == null) { throw new ArgumentNullException(nameof(integrator)); } if (calculationSettings == null) { throw new ArgumentNullException(nameof(calculationSettings)); } IDistanceCalculator abortedTakeOffCalculator = distanceCalculatorFactory.CreateAbortedTakeOffDistanceCalculator(aircraftData, integrator, density, gravitationalAcceleration, calculationSettings); IDistanceCalculator continuedTakeOffCalculator = distanceCalculatorFactory.CreateContinuedTakeOffDistanceCalculator(aircraftData, integrator, nrOfFailedEngines, density, gravitationalAcceleration, calculationSettings); DistanceCalculatorOutput abortedTakeOffOutput = abortedTakeOffCalculator.Calculate(); DistanceCalculatorOutput continuedTakeOffOutput = continuedTakeOffCalculator.Calculate(); return(new AggregatedDistanceOutput(calculationSettings.FailureSpeed, abortedTakeOffOutput.Distance, continuedTakeOffOutput.Distance)); }
public void CalculateNearestNeighbourDistances(Point[] points) { var numberOfPositiveMeasurePoints = points.Length; for (var i = 0; i < numberOfPositiveMeasurePoints; i++) { points[i].DistanceToNearestNeighbour = int.MaxValue; for (var j = 0; j < numberOfPositiveMeasurePoints; j++) { if (i == j) { continue; } var distanceBetweenPoints = _distanceCalculator.Calculate(points[i].Coordinates, points[j].Coordinates); if (distanceBetweenPoints < points[i].DistanceToNearestNeighbour) { points[i].DistanceToNearestNeighbour = distanceBetweenPoints; } } } }
//protected override Point GetAllowedPoint(Domain[] domains, Constraint[] constraints) //{ // var numberOfDimensions = domains.Length; // var numberOfConstraints = constraints.Length; // var point = new Point(numberOfDimensions, ClassificationType.Negative); // var isSatisfyingConstraints = true; // while (isSatisfyingConstraints == true) // { // isSatisfyingConstraints = false; // for (var i = 0; i < numberOfDimensions; i++) // point.Coordinates[i] = _randomGenerator.NextDouble(domains[i].LowerLimit, domains[i].UpperLimit); // if (constraints.IsSatisfyingConstraints(point)) // isSatisfyingConstraints = true; // //for (var i = 0; i < numberOfConstraints; i++) // //{ // // if (constraints[i].IsSatisfyingConstraint(point) == false) break; // // isSatsfyngConstraints = true; // // break; // //} // } // return point; //} private bool IsOutsideNeighbourhood(Point pointToCheck, Point centerPoint) { return(_distanceCalculator.Calculate(pointToCheck.Coordinates, centerPoint.Coordinates) > centerPoint.DistanceToNearestNeighbour); }