static DistanceCalculator()
{
var calculator = new DistanceCalculator();
var distanceData = new DistanceData { DistanceM = 1, Calc = "kilometers" };
calculator.Calculate(distanceData);
MilesToKilometers = distanceData.DistanceKm.Value;
distanceData.DistanceKm = 1;
distanceData.Calc = "miles";
calculator.Calculate(distanceData);
KilometersToMiles = distanceData.DistanceM.Value;
}
static DistanceCalculator()
{
var calculator = new DistanceCalculator();
var distanceData = new DistanceData {
DistanceM = 1, Calc = "kilometers"
};
calculator.Calculate(distanceData);
MilesToKilometers = distanceData.DistanceKm.Value;
distanceData.DistanceKm = 1;
distanceData.Calc = "miles";
calculator.Calculate(distanceData);
KilometersToMiles = distanceData.DistanceM.Value;
}
public virtual async Task <IList <CityEntity> > GetCitiesAsync(int cityId)
{
var cityE = await CityRepository.FindAsync(cityId) ?? throw new EntityNotFoundException();
var radius = Config.GetValue <float>("GeoDistance:MaxRadius");
if (radius <= 0)
{
throw new BusinessException();
}
var point01 = GetPoint(cityE.Geolocation);
var selectedList = new List <CityEntity>();
var cityEsList = await CityRepository.GetListAsync();
foreach (var cityEntity in cityEsList)
{
var point02 = GetPoint(cityEntity.Geolocation);
var distance = DistanceCalculator.Calculate(point01, point02);
if (distance <= radius)
{
selectedList.Add(cityEntity);
}
}
return(selectedList);
}
IEnumerator GPSChecker()
{
int counter = 0;
for (;;)
{
Info.text = Input.location.status.ToString() + " " + counter.ToString();
counter++;
//if (Input.location.status == LocationServiceStatus.Running) {
//Info.text = Input.location.status.ToString ();
lat = Input.location.lastData.latitude;
lon = Input.location.lastData.longitude;
SetClosestHeritage();
distance = DistanceCalculator.Calculate(
lat,
lon,
heritages.WarsawHeritage [heritages.activeOne].position.x,
heritages.WarsawHeritage [heritages.activeOne].position.y) * 1000f;
Latitude.text = "Lat: " + lat.ToString();
Longitude.text = "Lon: " + lon.ToString();
Distance.text = "Dist: " + distance.ToString();
funPlacer.Place(this);
yield return(new WaitForSeconds(1));
//}
}
}
public Distance(double distance, DistanceUnits units)
{
var calculator = new DistanceCalculator();
var distanceData = new DistanceData {
DistanceM = distance, DistanceKm = distance
};
switch (units)
{
case DistanceUnits.Miles:
distanceData.Calc = "kilometers";
break;
case DistanceUnits.Kilometers:
distanceData.Calc = "miles";
break;
default:
throw new ArgumentException("Unknown units: " + units, "units");
}
calculator.Calculate(distanceData);
DistanceInM = distanceData.DistanceM.Value;
DistanceInKm = distanceData.DistanceKm.Value;
BaseDistance = distance;
BaseUnits = units;
}
/// <summary>
/// The build route settings.
/// </summary>
/// <param name="calc">
/// The calc.
/// </param>
/// <param name="fleetToStore">
/// The fleet to store.
/// </param>
/// <param name="storeToClient">
/// The store to client.
/// </param>
/// <param name="distanceToClient">
/// The distance to client.
/// </param>
/// <returns>
/// The <see cref="RouteSettings"/>.
/// </returns>
public static RouteSettings BuildRouteSettings(
DistanceCalculator calc,
RouteDistance fleetToStore,
RouteDistance storeToClient,
double distanceToClient)
{
var result = new RouteSettings();
result.ClientLocation = storeToClient.LocationToAddress;
result.StoreLocation = storeToClient.LocationFromAddress;
result.DroneLocation = fleetToStore.LocationFromAddress;
result.DistanceToClient = distanceToClient;
result.DroneFlyDistance = result.DistanceToClient + calc.Calculate(
result.ClientLocation.Coordinates,
result.DroneLocation.Coordinates);
result.ClientWaitingTimeSec = (result.DistanceToClient * 1000) / 16.6667d;
result.DroneFlyTimeSec = (result.DroneFlyDistance * 1000) / 16.6667d;
result.ClientWaitingTimeMin = result.ClientWaitingTimeSec / 60;
result.DroneFlyTimeMin = result.DroneFlyTimeSec / 60;
return(result);
}
public void GivenCalculator_WhenCalculatingAndSolutionConvergesWithHeightAboveScreenHeightDuringNormalTakeOff_ThenCallsInExpectedOrderAndThrowsCalculatorException()
{
// Given
var random = new Random(21);
const double screenHeight = 10.7;
int nrOfTimeSteps = random.Next(2, int.MaxValue);
double timeStep = random.NextDouble();
int failureSpeed = random.Next();
AircraftState[] states =
{
CreateAircraftStateWithHeight(screenHeight - 0.1),
CreateAircraftStateWithHeight(screenHeight + 0.1),
CreateAircraftStateWithHeight(screenHeight + 0.2)
};
AircraftAccelerations[] accelerations =
{
CreateAircraftAccelerations(),
CreateAircraftAccelerations()
};
var normalTakeOffDynamicsCalculator = Substitute.For <INormalTakeOffDynamicsCalculator>();
normalTakeOffDynamicsCalculator.Calculate(Arg.Any <AircraftState>())
.Returns(accelerations[0], accelerations[1]);
var failureTakeOffDynamicsCalculator = Substitute.For <IFailureTakeOffDynamicsCalculator>();
var integrator = Substitute.For <IIntegrator>();
integrator.Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep)
.Returns(states[0], states[1], states[2]);
var calculatorSettings = new CalculationSettings(failureSpeed, nrOfTimeSteps, timeStep);
var calculator = new DistanceCalculator(normalTakeOffDynamicsCalculator, failureTakeOffDynamicsCalculator,
integrator, calculatorSettings);
// When
TestDelegate call = () => calculator.Calculate();
// Then
var exception = Assert.Throws <CalculatorException>(call);
Assert.AreEqual("Calculation converged before failure occurred.", exception.Message);
failureTakeOffDynamicsCalculator.DidNotReceiveWithAnyArgs().Calculate(Arg.Any <AircraftState>());
normalTakeOffDynamicsCalculator.Received(2).Calculate(Arg.Any <AircraftState>());
integrator.Received(2).Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep);
Received.InOrder(() =>
{
normalTakeOffDynamicsCalculator.Calculate(Arg.Is <AircraftState>(state => IsZeroAircraftState(state)));
integrator.Integrate(Arg.Is <AircraftState>(state => IsZeroAircraftState(state)), accelerations[0], timeStep);
normalTakeOffDynamicsCalculator.Calculate(states[0]);
integrator.Integrate(states[0], accelerations[1], timeStep);
// Do not expect additional calls after the second state was returned
});
}
public void Calculate_NormalDynamicsCalculatorThrowsException_ThenExceptionRethrown()
{
// Setup
var calculatorException = new CalculatorException();
var normalTakeOffDynamicsCalculator = Substitute.For <INormalTakeOffDynamicsCalculator>();
normalTakeOffDynamicsCalculator.Calculate(Arg.Any <AircraftState>())
.Throws(calculatorException);
var failureTakeOffDynamicsCalculator = Substitute.For <IFailureTakeOffDynamicsCalculator>();
var integrator = Substitute.For <IIntegrator>();
var calculator = new DistanceCalculator(normalTakeOffDynamicsCalculator,
failureTakeOffDynamicsCalculator,
integrator,
CalculationSettingsTestFactory.CreateDistanceCalculatorSettings());
// Call
TestDelegate call = () => calculator.Calculate();
// Assert
var exception = Assert.Throws <CalculatorException>(call);
Assert.AreSame(calculatorException, exception);
}
public void Valid_Distance_For_A_Path(string path, int expected)
{
var distanceCalculator = new DistanceCalculator(Map);
var actual = distanceCalculator.Calculate(path);
Assert.AreEqual(expected, actual);
}
private double?CalculateDistance(double?originLatitude, double?originLongitude, double?destinationLatitude, double?destinationLongitude)
{
if (originLatitude.HasValue && originLongitude.HasValue && destinationLatitude.HasValue && destinationLongitude.HasValue)
{
return(Math.Round(DistanceCalculator.Calculate(originLatitude.Value, originLongitude.Value, destinationLatitude.Value, destinationLongitude.Value, 'K'), 2));
}
else
{
return(null);
}
}
public ActionResult CalcDistance(DistanceData distanceCalculation)
{
if (!ModelState.IsValid)
{
return(Json(distanceCalculation));
}
distanceCalc.Calculate(distanceCalculation);
return(Json(distanceCalculation));
}
public void TEST_CALCULATE_DISTANCE_THROWS_EXCEPTION_WHEN_COORDINATES_ARE_NULL()
{
Exception expectedExp = null;
var service = new DistanceCalculator();
try
{
service.Calculate(null, null);
}
catch (AssertFailedException ex)
{
expectedExp = ex;
}
Assert.IsNotNull(expectedExp);
}
static void Main()
{
Point3D p = Point3D.StartPoint;
Point3D q = new Point3D(1, 2, 3);
System.Console.WriteLine("Distance: {0:F4}", DistanceCalculator.Calculate(p, q));
Path path = new Path();
path.AddPoints(p, q);
System.Console.WriteLine(path);
PathStorage.Save(path, "firstPath");
System.Console.WriteLine(PathStorage.Load("firstPath"));
System.Console.WriteLine(PathStorage.Load("somePath"));
}
static void Main(string[] args)
{
//////////////////////---HERE STARTS PROBLEM 1---//////////////////////////
Console.WriteLine();
Console.WriteLine("---HERE STARTS PROBLEM 1---");
Point3D p1 = new Point3D(1, 2, 3);
p1.ToString();
Point3D p2 = Point3D.StartingPoint;
//////////////////////---HERE STARTS PROBLEM 2---//////////////////////////
Console.WriteLine();
Console.WriteLine("---HERE STARTS PROBLEM 2---");
double d1 = DistanceCalculator.Calculate(p1, p2);
Point3D p3 = new Point3D(5, 2, 99);
double d2 = DistanceCalculator.Calculate(p1, p3);
Console.WriteLine(d1 + " " + d2);
}
public void Verify_DistanceIsAccuratelyCalculatedBetweenTwoLocations()
{
double expectedDistance = 10.57;
var location1 = new GPSLocation
{
Longitude = -6.257664,
Latitude = 53.339428
};
var location2 = new GPSLocation
{
Longitude = -6.238335,
Latitude = 53.2451022
};
double actualDistance = DistanceCalculator.Calculate(location1, location2);
Assert.Equal(expectedDistance, actualDistance, 2);
}
public void TEST_CALCULATE_DISTANCE_RETURNS_DISTANCE()
{
var expected = 0;
var service = new DistanceCalculator();
var source = new Coordinates
{
latitude = 10
,
longitude = 10
};
var destination = new Coordinates
{
latitude = 10
,
longitude = 10
};
var actual = service.Calculate(source, destination);
Assert.AreEqual(expected, actual);
}
public void Calculate_MaximumIterationsHit_ThrowsCalculatorException()
{
// Setup
var random = new Random(21);
int nrOfTimeSteps = random.Next(1, 10);
double timeStep = random.NextDouble();
int failureSpeed = random.Next();
var normalTakeOffDynamicsCalculator = Substitute.For <INormalTakeOffDynamicsCalculator>();
var calculatorException = new CalculatorException();
var failureTakeOffDynamicsCalculator = Substitute.For <IFailureTakeOffDynamicsCalculator>();
failureTakeOffDynamicsCalculator.Calculate(Arg.Any <AircraftState>())
.Throws(calculatorException);
var integrator = Substitute.For <IIntegrator>();
integrator.Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep)
.Returns(CreateAircraftStateWithVelocity(failureSpeed));
var calculatorSettings = new CalculationSettings(failureSpeed, nrOfTimeSteps, timeStep);
var calculator = new DistanceCalculator(normalTakeOffDynamicsCalculator, failureTakeOffDynamicsCalculator,
integrator, calculatorSettings);
// Call
TestDelegate call = () => calculator.Calculate();
// Assert
var exception = Assert.Throws <CalculatorException>(call);
Assert.AreEqual("Calculation did not converge.", exception.Message);
integrator.ReceivedWithAnyArgs(nrOfTimeSteps)
.Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep);
}
public void Calculate_FailureDynamicsCalculatorThrowsException_ThenExceptionRethrown()
{
// Setup
var random = new Random(21);
double timeStep = random.NextDouble();
int failureSpeed = random.Next();
var normalTakeOffDynamicsCalculator = Substitute.For <INormalTakeOffDynamicsCalculator>();
var calculatorException = new CalculatorException();
var failureTakeOffDynamicsCalculator = Substitute.For <IFailureTakeOffDynamicsCalculator>();
failureTakeOffDynamicsCalculator.Calculate(Arg.Any <AircraftState>())
.Throws(calculatorException);
var integrator = Substitute.For <IIntegrator>();
integrator.Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep)
.Returns(CreateAircraftStateWithVelocity(failureSpeed + 0.1));
var calculatorSettings = new CalculationSettings(failureSpeed,
random.Next(),
timeStep);
var calculator = new DistanceCalculator(normalTakeOffDynamicsCalculator,
failureTakeOffDynamicsCalculator,
integrator,
calculatorSettings);
// Call
TestDelegate call = () => calculator.Calculate();
// Assert
var exception = Assert.Throws <CalculatorException>(call);
Assert.AreSame(calculatorException, exception);
}
public async Task <IActionResult> GetForAll()
{
// get stores
var stores = this.storeFinder.GetStoresToServe().ToList();
var fleets = this.droneService.GetDroneFleets().ToList();
var clientAddresses = await this.locationFinder.GetAllClientLocationAsync();
var result = new List <RouteSettings>();
if (!stores.AnySafe() || !fleets.AnySafe() || !clientAddresses.AnySafe())
{
return(null);
}
var calc = new DistanceCalculator();
var fleetStoreDistanceArr = new List <List <double> >();
var line = new LinkedList <double>();
foreach (var fleet in fleets)
{
line.Clear();
foreach (var store in stores)
{
line.AddLast(calc.Calculate(fleet.Coordinates, store.Coordinates));
}
fleetStoreDistanceArr.Add(line.ToList());
}
var ways = new List <BestWay>();
var distance = new List <double>();
var bestWay = new BestWay();
foreach (var client in clientAddresses)
{
distance.Clear();
foreach (var store in stores)
{
distance.Add(calc.Calculate(client.Coordinates, store.Coordinates));
}
bestWay = new BestWay
{
Distance = double.MaxValue,
FleetIndex = 0,
StoreIndex = 0,
Client = client
};
var availableDrones = await this.droneService.GetAvailableDronesAsync();
for (var i = 0; i < fleetStoreDistanceArr.Count; i++)
{
// for loop bellow fleetStoreDistanceArr line length will be the same for all lines,
// so we don't need to calculate it for every line
for (var j = 0; j < fleetStoreDistanceArr[0].Count; j++)
{
if (availableDrones.Any(
x => x.AddressLine.Equals(
fleets[i].AddressLine,
StringComparison.InvariantCultureIgnoreCase)))
{
if (fleetStoreDistanceArr[i][j] + distance[j] < bestWay.Distance)
{
bestWay.Distance = fleetStoreDistanceArr[i][j] + distance[j];
bestWay.FleetIndex = i;
bestWay.StoreIndex = j;
}
}
}
}
ways.Add(bestWay);
}
foreach (var way in ways)
{
result.Add(
BuildRouteHelper.BuildRouteSettings(
calc,
new RouteDistance
{
LocationFrom = fleets[way.FleetIndex].AddressLine,
LocationFromAddress = fleets[way.FleetIndex],
LocationTo = stores[way.StoreIndex].AddressLine,
LocationToAddress = stores[way.StoreIndex]
},
new RouteDistance
{
LocationFrom = stores[way.StoreIndex].AddressLine,
LocationFromAddress = stores[way.StoreIndex],
LocationTo = way.Client.AddressLine,
LocationToAddress = way.Client
},
way.Distance));
}
return(this.Ok(result));
}
public async Task <IActionResult> Get(string address)
{
// get stores
var stores = this.storeFinder.GetStoresToServe().ToList();
var fleets = this.droneService.GetAvailableDrones().ToList();
var clientAddress = await this.locationFinder.GetAddressCoordinatesAsync(address);
if (!stores.AnySafe() || !fleets.AnySafe() || clientAddress == null)
{
return(null);
}
var calc = new DistanceCalculator();
var fleetStoreDistanceArr = new List <List <double> >();
var line = new LinkedList <double>();
foreach (var fleet in fleets)
{
line.Clear();
foreach (var store in stores)
{
line.AddLast(calc.Calculate(fleet.Coordinates, store.Coordinates));
}
fleetStoreDistanceArr.Add(line.ToList());
}
var distance = new List <double>();
foreach (var store in stores)
{
distance.Add(calc.Calculate(clientAddress.Coordinates, store.Coordinates));
}
var bestWay = new BestWay
{
Distance = double.MaxValue,
FleetIndex = 0,
StoreIndex = 0,
Client = clientAddress
};
for (var i = 0; i < fleetStoreDistanceArr.Count; i++)
{
// for loop bellow fleetStoreDistanceArr line length will be the same for all lines,
// so we don't need to calculate it for every line
for (var j = 0; j < fleetStoreDistanceArr[0].Count; j++)
{
if (fleetStoreDistanceArr[i][j] + distance[j] < bestWay.Distance)
{
bestWay.Distance = fleetStoreDistanceArr[i][j] + distance[j];
bestWay.FleetIndex = i;
bestWay.StoreIndex = j;
}
}
}
return(this.Ok(BuildRouteHelper.BuildRouteSettings(
calc,
new RouteDistance
{
LocationFrom = fleets[bestWay.FleetIndex].AddressLine,
LocationFromAddress = fleets[bestWay.FleetIndex],
LocationTo = stores[bestWay.StoreIndex].AddressLine,
LocationToAddress = stores[bestWay.StoreIndex]
},
new RouteDistance
{
LocationFrom = stores[bestWay.StoreIndex].AddressLine,
LocationFromAddress = stores[bestWay.StoreIndex],
LocationTo = bestWay.Client.AddressLine,
LocationToAddress = bestWay.Client
},
bestWay.Distance)));
}
public void SortDataByDate(IList <CarStateModel> data, DateTime day)
{
ClearRoutes();
var first = data.OrderBy(o => o.Date).FirstOrDefault();
if (first == null)
{
return;
}
var curroute = RouteSelect.None;
var prev = new Location
{
Latitude = first.Lt / 10000.0,
Longitude = first.Ln / 10000.0,
FirstPoint = true
};
double dist = 0;
var dc = new DistanceCalculator();
var slowTask = new Task(delegate
{
var foundParking = true;
var nullDate = first.Spd < 6 || StateDateTimeHelper.EqualInterval(new DateTime(), first)
? first
: null;
foreach (var item in data.OrderBy(o => o.Date))
{
var itemtime = StateDateTimeHelper.GetTime(item);
var loc = new Location
{
Latitude = item.Lt / 10000.0,
Longitude = item.Ln / 10000.0
};
if (data.IndexOf(item) <= 0)
{
continue;
}
nullDate = nullDate ?? first;
var firsttime = StateDateTimeHelper.GetTime(nullDate);
var isParking = StateDateTimeHelper.IsParking(item, ref nullDate);
if (foundParking && isParking)
{
var selectedParkingModel = new ParkingModel(firsttime, itemtime, prev);
var trash = _routesModel.Parkings.FirstOrDefault(o => o.Equals(selectedParkingModel));
if (trash == null)
{
_routesModel.Parkings.Add(selectedParkingModel);
foundParking = false;
}
}
else if (!foundParking && !isParking)
{
foundParking = true;
nullDate = null;
if (_routesModel.Parkings.Count > 0)
{
_routesModel.Parkings[_routesModel.Parkings.Count - 1].SetEndDates(itemtime);
}
}
var curdist = dc.Calculate(first, item);
if (item.Spd > 0 && Math.Abs(curdist) > .001 && !(foundParking && isParking))
{
curroute = SortLocation(prev, loc, curroute, item.Spd / 10.0, item.Date);
dist += curdist;
prev = loc;
}
first = item;
}
var last = data.LastOrDefault();
if (last == null)
{
return;
}
if (!StateDateTimeHelper.EqualInterval(DateTime.Now, last))
{
return;
}
prev = new Location
{
Latitude = last.Lt / 10000.0,
Longitude = last.Ln / 10000.0,
};
if (StateDateTimeHelper.EqualInterval(day.AddDays(1), last))
{
_routesModel.Parkings.Add(new ParkingModel(StateDateTimeHelper.GetTime(last), day.AddDays(1), prev));
}
});
slowTask.ContinueWith(o => DispatherThreadRun(delegate { ContinueSortData((int)dist, data.Max(m => m.Spd / 10)); }));
slowTask.Start();
}
public void GivenCalculator_WhenCalculatingAndSolutionConvergesWithScreenHeightAfterFailureDynamics_ThenCallsInExpectedOrderAndOutputReturned()
{
// Given
var random = new Random(21);
const double screenHeight = 10.7;
int nrOfTimeSteps = random.Next(3, int.MaxValue);
double timeStep = random.NextDouble();
int failureSpeed = random.Next();
var failureState = new AircraftState(random.NextAngle(),
random.NextAngle(),
failureSpeed + 0.1,
random.NextDouble(),
random.NextDouble());
AircraftState[] states =
{
failureState,
CreateAircraftStateWithHeight(screenHeight - 0.2),
CreateAircraftStateWithHeight(screenHeight)
};
AircraftAccelerations[] accelerations =
{
CreateAircraftAccelerations(),
CreateAircraftAccelerations(),
CreateAircraftAccelerations()
};
var normalTakeOffDynamicsCalculator = Substitute.For <INormalTakeOffDynamicsCalculator>();
normalTakeOffDynamicsCalculator.Calculate(Arg.Any <AircraftState>())
.Returns(accelerations[0]);
var failureTakeOffDynamicsCalculator = Substitute.For <IFailureTakeOffDynamicsCalculator>();
failureTakeOffDynamicsCalculator.Calculate(Arg.Any <AircraftState>())
.Returns(accelerations[1], accelerations[2]);
var integrator = Substitute.For <IIntegrator>();
integrator.Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep)
.Returns(states[0], states[1], states[2]);
var calculatorSettings = new CalculationSettings(failureSpeed, nrOfTimeSteps, timeStep);
var calculator = new DistanceCalculator(normalTakeOffDynamicsCalculator, failureTakeOffDynamicsCalculator,
integrator, calculatorSettings);
// Call
DistanceCalculatorOutput output = calculator.Calculate();
// Assert
normalTakeOffDynamicsCalculator.Received(1).Calculate(Arg.Any <AircraftState>());
failureTakeOffDynamicsCalculator.Received(2).Calculate(Arg.Any <AircraftState>());
integrator.Received(3).Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep);
Received.InOrder(() =>
{
normalTakeOffDynamicsCalculator.Calculate(Arg.Is <AircraftState>(state => IsZeroAircraftState(state)));
integrator.Integrate(Arg.Is <AircraftState>(state => IsZeroAircraftState(state)), accelerations[0], timeStep);
failureTakeOffDynamicsCalculator.Calculate(states[0]);
integrator.Integrate(states[0], accelerations[1], timeStep);
failureTakeOffDynamicsCalculator.Calculate(states[1]);
integrator.Integrate(states[1], accelerations[2], timeStep);
});
Assert.AreEqual(states.Last().Distance, output.Distance);
Assert.AreEqual(failureSpeed, output.FailureSpeed);
}
static void Main()
{
#region Builder Sample
Console.WriteLine("Builder Sample");
var directorRoom = new DirectorRooms(new SimpleRoomBuilder());
var simpleRoom = directorRoom.Construct();
simpleRoom.Describe();
directorRoom = new DirectorRooms(new FamilyRoomBuilder());
var familyRoom = directorRoom.Construct();
familyRoom.Describe();
#endregion
#region Factory Sample
var psCretor = new PaymentServiceCreator();
var brazilianPaymentService = (IPaymentService)psCretor.Factory
(PaymentServiceCreator.ServicesAvailable.Brazilian);
brazilianPaymentService.EmailToCharge = "*****@*****.**";
brazilianPaymentService.MoneyToCharge = 178.90f;
brazilianPaymentService.OptionToCharge =
FactorySample.Enums.EnumChargingOptions.CreditCard;
brazilianPaymentService.ProcessCharging();
var italianPaymentService = (IPaymentService)psCretor.Factory
(PaymentServiceCreator.ServicesAvailable.Italian);
italianPaymentService.EmailToCharge = "*****@*****.**";
italianPaymentService.MoneyToCharge = 188.70f;
italianPaymentService.OptionToCharge =
FactorySample.Enums.EnumChargingOptions.DebitCard;
italianPaymentService.ProcessCharging();
#endregion
#region Singleton Sample
Console.WriteLine("Singleton Sample");
SingletonDemo.Current.Message = "This text will be printed by the singleton.";
SingletonDemo.Current.Print();
#endregion
#region Singleton Configuration Sample
Console.WriteLine("Singleton Configuration Sample");
for (int i = 0; i < 20; i++)
{
Console.WriteLine($"Random Number Parameter: {Configuration.Current.RandomNumber}. Last Time Loaded {Configuration.Current.LastTimeLoaded}");
Thread.Sleep(1000);
}
#endregion
#region Proxy Sample
Console.WriteLine("Proxy Sample");
var roomPicture = new ProxyRoomPicture();
Console.WriteLine($"Picture Id: {roomPicture.Id}");
Console.WriteLine($"Picture FileName: {roomPicture.FileName}");
Console.WriteLine($"Tags: {string.Join(";", roomPicture.Tags)}");
Console.WriteLine($"1st call: Picture Data");
Console.WriteLine($"Image: {roomPicture.PictureData}");
Console.WriteLine($"2nd call: Picture Data");
Console.WriteLine($"Image: {roomPicture.PictureData}");
#endregion
#region Command Sample
Console.WriteLine("");
Console.WriteLine("Command Sample");
var package = new Package("Shopping in New York");
var likeCommand = new LikeCmd(package);
var dislikeCommand = new DislikeCmd(package);
var loveCommand = new LoveCmd(package);
var commandInvoker = new CommandInvoker();
var keepAsking = true;
while (keepAsking)
{
Console.WriteLine($"Your oppinion about {package.Name}:");
Console.WriteLine("1 - Like");
Console.WriteLine("2 - Dislike");
Console.WriteLine("3 - Love");
Console.WriteLine("4 - Undo last command");
Console.WriteLine("Any other key - Exit");
var key = Console.ReadKey();
Console.WriteLine("");
switch (key.Key)
{
case ConsoleKey.NumPad1:
case ConsoleKey.D1:
commandInvoker.Command = likeCommand;
break;
case ConsoleKey.NumPad2:
case ConsoleKey.D2:
commandInvoker.Command = dislikeCommand;
break;
case ConsoleKey.NumPad3:
case ConsoleKey.D3:
commandInvoker.Command = loveCommand;
break;
case ConsoleKey.NumPad4:
case ConsoleKey.D4:
if (commandInvoker.Command != null)
{
commandInvoker.Undo();
commandInvoker.Command = null;
}
else
{
Console.WriteLine("There is no Command to Undo!");
}
break;
default:
keepAsking = false;
break;
}
if ((keepAsking) && (commandInvoker.Command != null))
{
commandInvoker.Invoke();
}
}
#endregion
#region Dependency Injection Sample
var userAddress = new UserAddress {
City = "São Paulo", Country = "Brazil", ZipCode = "01001-001"
};
var destinationAddress = new UserAddress {
City = "Rio de Janeiro", Country = "Brazil", ZipCode = "22460-050"
};
var distanceCalculator = new DistanceCalculator(userAddress, destinationAddress);
distanceCalculator.Calculate();
#endregion
Console.ReadKey();
}
public async Task <IActionResult> Get(string address)
{
var resultTask = Task <RouteSettings> .Factory.StartNew(
() =>
{
// get stores
var stores = this.storeFinder.GetStoresToServe().ToList();
var drones = this.droneService.GetAvailableDrones().ToList();
var clientAddress = this.locationFinder.GetAddressCoordinates(address);
if (!stores.AnySafe() || !drones.AnySafe() || clientAddress == null)
{
return(null);
}
var calc = new DistanceCalculator();
var storeClientDistance = new List <RouteDistance>();
foreach (var store in stores)
{
storeClientDistance.Add(new RouteDistance
{
LocationFrom = store.AddressLine,
LocationFromAddress = store,
LocationTo = clientAddress.AddressLine,
LocationToAddress = clientAddress,
Distance = calc.Calculate(store.Coordinates, clientAddress.Coordinates)
});
}
var nearestStore = storeClientDistance.OrderBy(x => x.Distance).FirstOrDefault();
var droneStoreDistance = new List <RouteDistance>();
foreach (var fleet in drones)
{
foreach (var store in stores)
{
if (store.AddressLine.Equals(nearestStore.LocationFrom, StringComparison.InvariantCultureIgnoreCase))
{
droneStoreDistance.Add(
new RouteDistance
{
LocationFrom = fleet.AddressLine,
LocationFromAddress = fleet,
LocationTo = store.AddressLine,
LocationToAddress = store,
Distance = calc.Calculate(fleet.Coordinates, store.Coordinates)
});
break;
}
}
}
var nearestFleet = droneStoreDistance
.Where(x => x.LocationTo.Equals(nearestStore.LocationFrom, StringComparison.CurrentCultureIgnoreCase))
.OrderBy(x => x.Distance)
.FirstOrDefault();
return(BuildRouteHelper.BuildRouteSettings(calc, nearestFleet, nearestStore));
});
return(this.Ok(await resultTask));
}
public async Task <IActionResult> GetForAll()
{
var resultTask = Task <List <RouteSettings> > .Factory.StartNew(() =>
{
// get stores
var stores = this.storeFinder.GetStoresToServe().ToList();
var fleets = this.droneService.GetDroneFleets().ToList();
var clientAddresses = clientLocations.Value;
var result = new List <RouteSettings>();
if (!stores.AnySafe() || !fleets.AnySafe() || !clientAddresses.AnySafe())
{
return(result);
}
var calc = new DistanceCalculator();
var fleetStoreDistance = new List <RouteDistance>();
foreach (var fleet in fleets)
{
foreach (var store in stores)
{
fleetStoreDistance.Add(new RouteDistance
{
LocationFrom = fleet.AddressLine,
LocationFromAddress = fleet,
LocationTo = store.AddressLine,
LocationToAddress = store,
Distance = calc.Calculate(fleet.Coordinates, store.Coordinates)
});
}
}
// get distance from client to store
var storeToClientDistances = new LinkedList <RouteDistance>();
foreach (var client in clientAddresses)
{
foreach (var store in stores)
{
storeToClientDistances.AddLast(
new RouteDistance
{
LocationFrom = store.AddressLine,
LocationFromAddress =
new Address {
AddressLine = store.AddressLine, Coordinates = store.Coordinates
},
LocationTo = client.AddressLine,
LocationToAddress =
new Address {
AddressLine = client.AddressLine, Coordinates = client.Coordinates
},
Distance = calc.Calculate(client.Coordinates, store.Coordinates)
});
}
var availableDrones = this.droneService.GetAvailableDrones();
var nearestStore = storeToClientDistances.OrderBy(x => x.Distance).FirstOrDefault();
var nearestFleet = fleetStoreDistance
.Where(x => x.LocationTo.Equals(nearestStore.LocationFrom, StringComparison.InvariantCultureIgnoreCase))
.OrderBy(x => x.Distance)
.FirstOrDefault();
var availableDroneNearby = availableDrones.FirstOrDefault(x => x.AddressLine.Equals(
nearestFleet.LocationFrom,
StringComparison.InvariantCultureIgnoreCase));
if (availableDroneNearby == null)
{
var availableDronesDistance = fleetStoreDistance
.Where(x => !x.LocationFrom.Equals(nearestFleet.LocationFrom, StringComparison.InvariantCultureIgnoreCase))
.ToList();
nearestFleet = availableDronesDistance
.OrderBy(x => x.Distance)
.FirstOrDefault();
}
result.Add(BuildRouteHelper.BuildRouteSettings(calc, nearestFleet, nearestStore));
storeToClientDistances.Clear();
}
return(result);
});
return(this.Ok(await resultTask));
}
/// <summary>
/// Обновление навигационных данных
/// </summary>
/// <param name="data"></param>
/// <param name="date"></param>
private void BuildHistoryRow(List <CarStateModel> data, DateTime date)
{
var r = new LoadedHistoryRows {
Date = date, Data = data
};
var slowTask = new Task(delegate
{
try
{
var dc = new DistanceCalculator();
for (var i = 0; i < data.Count() - 1; i++)
{
r.Mileage += dc.Calculate(data[i], data[i + 1]);
}
}
catch
{
}
if (!data.Any())
{
return;
}
try
{
r.MiddleSpeed = data.Sum(p => p.Spd) / 10 / data.Count();
var moving = data.Where(p => p.Spd > 10).ToList();
if (!moving.Any())
{
return;
}
var hStart = moving.Min(p => p.hh);
var minStart = moving.Where(p => p.hh == hStart).Min(p => p.mm);
var hStop = moving.Max(p => p.hh);
var mStop = moving.Where(p => p.hh == hStop).Max(p => p.mm);
r.Start = hStart + ":" + minStart;
r.Stop = hStop + ":" + mStop;
}
catch
{
}
});
slowTask.ContinueWith(delegate
{
if (_dispatcher != null)
{
_dispatcher.BeginInvoke(new Action(() =>
{
var item = HistoryRows.OrderBy(s => s.Date)
.LastOrDefault(o => o.StringDate.Equals(r.StringDate) || o.Date < r.Date);
if (item != null)
{
var indx = HistoryRows.IndexOf(item);
_foundselected = HistoryRows[indx].Equals(SelectedHistoryRow);
DistanceAll -= HistoryRows[indx].Mileage;
HistoryRows[indx] = r;
if (_foundselected)
{
SelectedHistoryRow = r;
}
_foundselected = false;
DistanceAll += r.Mileage;
}
else
{
HistoryRows.Add(r);
DistanceAll += r.Mileage;
}
}));
}
});
slowTask.Start();
}
public void Invalid_Distance_Should_Thorw_exception(string path)
{
var distanceCalculator = new DistanceCalculator(Map);
var actual = distanceCalculator.Calculate(path);
}