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