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