public ShippingCostService(
IRepository<ShippingDistanceCost> repo,
IDistanceCalculator distanceCalculator)
{
_repo = repo;
_distanceCalculator = distanceCalculator;
}
public UserMover(IUserRetriever userRetriever, IUserEnergyCalculator userEnergyCalculator, IUserSaver userSaver, IDistanceCalculator distanceCalculator)
{
_userRetriever = userRetriever;
_userEnergyCalcualtor = userEnergyCalculator;
_userSaver = userSaver;
_distanceCalculator = distanceCalculator;
}
public UserMoveDirector(IUserRetriever userRetriever, IUserEnergyProvider userEnergyCalculator, IUserSaver userSaver, IDistanceCalculator distanceCalculator, IUserCountsSaver userCountsSaver)
{
_userRetriever = userRetriever;
_userEnergyCalcualtor = userEnergyCalculator;
_userSaver = userSaver;
_distanceCalculator = distanceCalculator;
_userCountsSaver = userCountsSaver;
}
public CachedDistanceFunctionValue(AtomicReader reader, ShapeFieldCacheDistanceValueSource enclosingInstance)
{
cache = enclosingInstance.provider.GetCache(reader);
this.enclosingInstance = enclosingInstance;
from = enclosingInstance.from;
calculator = enclosingInstance.ctx.DistCalc;
nullValue = (enclosingInstance.ctx.IsGeo ? 180 * enclosingInstance.multiplier : double.MaxValue);
}
private readonly double nullValue;//computed
public DistanceToShapeValueSource(ValueSource shapeValueSource, IPoint queryPoint,
double multiplier, SpatialContext ctx)
{
this.shapeValueSource = shapeValueSource;
this.queryPoint = queryPoint;
this.multiplier = multiplier;
this.distCalc = ctx.DistCalc;
this.nullValue =
(ctx.IsGeo ? 180 * multiplier : double.MaxValue);
}
public TimeTrackerWorkspace(IDistanceCalculator distanceCalculator)
{
this.distanceCalculator = distanceCalculator;
// set the db location
//databaseLocation = Path.Combine (NSBundle.MainBundle.BundlePath, "Library/TrackLocationDB.db3");
this.databaseLocation = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), "LocationsDb.db3");
// instantiate the database
this.database = new TimeTrackerDatabase(this.databaseLocation);
}
public IRace Create(IDistanceCalculator distanceCalculator, IEnumerable<Waypoint> waypoints)
{
distanceCalculator.AssertNotNull();
waypoints = waypoints as List<Waypoint> ?? waypoints.ToList();
waypoints.AssertNotEmpty();
waypoints.AssertNotNull();
var Race = new RaceService(distanceCalculator, waypoints);
return Race;
}
public ClassificationService(
IImageBinarizer imageBinarizer,
IImageProcessor imageProcessor,
ILabelingService labelingService,
IDistanceCalculator<ClassificationUnit> distanceCalculator,
int classNumber)
{
this._imageBinarizer = imageBinarizer;
this._imageProcessor = imageProcessor;
this._labelingService = labelingService;
this._polygons = new List<Polygon>();
this._classificationUnits = new List<ClassificationUnit>();
this._distanceCalculator = distanceCalculator;
this._classNumber = classNumber;
this._random = new RNGCryptoServiceProvider();
this._kernels = new List<Kernel>(this._classNumber);
}
public UsersController()
{
_zombiePackRetriever = MvcApplication.DependancyInjection.Resolve<IZombiePackRetriever>();
_hotZoneRetriever = MvcApplication.DependancyInjection.Resolve<IHotZoneRetriever>();
_userRetriever = MvcApplication.DependancyInjection.Resolve<IUserRetriever>();
_userSaver = MvcApplication.DependancyInjection.Resolve<IUserSaver>();
_userHotZoneProgressRetriever = MvcApplication.DependancyInjection.Resolve<IUserZombiePackProgressRetriever>();
_userItemRetriever = MvcApplication.DependancyInjection.Resolve<IUserItemRetriever>();
_distanceCalculator = MvcApplication.DependancyInjection.Resolve<IDistanceCalculator>();
_userEnergyProvider = MvcApplication.DependancyInjection.Resolve<IUserEnergyProvider>();
_userMover = MvcApplication.DependancyInjection.Resolve<IUserMoveDirector>();
_shopDirector = MvcApplication.DependancyInjection.Resolve<IShopDirector>();
_userAttackPowerProvider = MvcApplication.DependancyInjection.Resolve<IUserAttackPowerProvider>();
_userSightRadiusProvider = MvcApplication.DependancyInjection.Resolve<IUserSightRadiusProvider>();
_itemUsageDirector = MvcApplication.DependancyInjection.Resolve<IItemUsageDirector>();
_achievementProvider = MvcApplication.DependancyInjection.Resolve<IAchievementProvider>();
_userLevelService = MvcApplication.DependancyInjection.Resolve<IUserLevelService>();
_userCountsRetriever = MvcApplication.DependancyInjection.Resolve<IUserCountsRetriever>();
}
public HelperService(IVolunteerCache volunteerCache, IDistanceCalculator distanceCalculator, IRepository repository)
{
_volunteerCache = volunteerCache;
_distanceCalculator = distanceCalculator;
_repository = repository;
}
/// <summary>
/// Recursively find leaf node to insert
/// at each level comparing against the next dimension.
/// </summary>
private KDTreeNode <T> findNearestNeighbour(KDTreeNode <T> currentNode,
T[] searchPoint, int depth,
IDistanceCalculator <T> distanceCalculator)
{
var currentDimension = depth % dimensions;
KDTreeNode <T> currentBest = null;
var compareResult = searchPoint[currentDimension]
.CompareTo(currentNode.Points[currentDimension]);
//move toward search point until leaf is reached
if (compareResult < 0)
{
if (currentNode.Left != null)
{
currentBest = findNearestNeighbour(currentNode.Left,
searchPoint, depth + 1, distanceCalculator);
}
else
{
currentBest = currentNode;
}
//currentBest is greater than point to current node distance
//or if right node sits on split plane
//then also move left
if (currentNode.Right != null &&
(distanceCalculator.Compare(currentNode.Points[currentDimension], searchPoint[currentDimension], searchPoint, currentBest.Points) < 0 ||
currentNode.Right.Points[currentDimension]
.CompareTo(currentNode.Points[currentDimension]) == 0))
{
var rightBest = findNearestNeighbour(currentNode.Right,
searchPoint, depth + 1,
distanceCalculator);
currentBest = getClosestToPoint(distanceCalculator, currentBest, rightBest, searchPoint);
}
//now recurse up from leaf updating current Best
currentBest = getClosestToPoint(distanceCalculator, currentBest, currentNode, searchPoint);
}
else if (compareResult >= 0)
{
if (currentNode.Right != null)
{
currentBest = findNearestNeighbour(currentNode.Right,
searchPoint, depth + 1, distanceCalculator);
}
else
{
currentBest = currentNode;
}
//currentBest is greater than point to current node distance
//or if search point lies on split plane
//then also move left
if (currentNode.Left != null &&
(distanceCalculator.Compare(currentNode.Points[currentDimension], searchPoint[currentDimension], searchPoint, currentBest.Points) < 0 || compareResult == 0))
{
var leftBest = findNearestNeighbour(currentNode.Left,
searchPoint, depth + 1,
distanceCalculator);
currentBest = getClosestToPoint(distanceCalculator, currentBest, leftBest, searchPoint);
}
//now recurse up from leaf updating current Best
currentBest = getClosestToPoint(distanceCalculator, currentBest, currentNode, searchPoint);
}
return(currentBest);
}
public RaceService(IDistanceCalculator distanceCalculator, IEnumerable<Waypoint> waypoints)
{
DistanceCalculator = distanceCalculator;
Waypoints = waypoints;
}
public MatrixGenerator(IDistanceCalculator calculator)
{
this.calculator = calculator;
}
public TravelController(IDistanceCalculator distanceCalculator)
{
this.distanceCalculator = distanceCalculator;
this.routeCalculator = new RouteCalculator(distanceCalculator);
}
public NearestNeighbourDistanceCalculator(IDistanceCalculator distanceCalculator)
{
_distanceCalculator = distanceCalculator;
}
public DistanceFunctionValue(DistanceValueSource outerInstance, AtomicReader reader)
{
this.outerInstance = outerInstance;
ptX = FieldCache.DEFAULT.GetDoubles(reader, outerInstance.strategy.FieldNameX, true);
ptY = FieldCache.DEFAULT.GetDoubles(reader, outerInstance.strategy.FieldNameY, true);
validX = FieldCache.DEFAULT.GetDocsWithField(reader, outerInstance.strategy.FieldNameX);
validY = FieldCache.DEFAULT.GetDocsWithField(reader, outerInstance.strategy.FieldNameY);
from = outerInstance.from;
calculator = outerInstance.strategy.SpatialContext.DistCalc;
nullValue = (outerInstance.strategy.SpatialContext.IsGeo ? 180 * outerInstance.multiplier : double.MaxValue);
}
public void Setup()
{
instanceUnderTest = new GeodesicCurveDistanceCalculator();
}
public void BuildDistanceCalculator()
{
_distanceCalculator = new DistanceCalculator(_distanceCoefficientsCalculator);
}
public CentroidDistanceGenerator(IDistanceCalculator calculator)
{
this.calculator = calculator;
}
public WalkPacketHandler(IDistanceCalculator distanceCalculator)
{
_distanceCalculator = distanceCalculator;
}
public MapMonster(List <NpcMonsterDto> npcMonsters, ILogger logger, IDistanceCalculator distanceCalculator)
{
_npcMonsters = npcMonsters;
_logger = logger;
_distanceCalculator = distanceCalculator;
}
public DbDistanceCalculatorDecorator(IDistanceCalculator distanceCalculator, IUnitOfWork unitOfWork)
{
_distanceCalculator = distanceCalculator;
_unitOfWork = unitOfWork;
}
public void DijkstraInstantiation_ValidCityData()
{
_loader = new RailNetworkDataLoader("AB5");
_distanceCalculator = DistanceCalculator<RailNetwork, City, Route>.Create(_loader);
Assert.AreEqual(2, _distanceCalculator.Graph.NodeCount);
Assert.AreEqual(1, _distanceCalculator.Graph.EdgeCount);
}
public void Setup()
{
_calculator = new DistanceCalculator();
}
public void TestCleanup()
{
_loader = null;
_distanceCalculator = null;
}
public MinDistanceFilter(IDistanceCalculator distanceCalculator)
{
_distanceCalculator = distanceCalculator;
}
/// <summary>
/// Initializes a new instance of the GraphScaffoldBuilder class.
/// </summary>
/// <param name="mapPairedReads">Mapping reads to mate pairs.</param>
/// <param name="readContigMap"> Mapping reads to contigs.</param>
/// <param name="pairedReadFilter">Filtering of mate pairs.</param>
/// <param name="distanceCalculator">Calculation of distance between
/// contigs using mate pairs.</param>
/// <param name="tracePath">Traversal of contig overlap graph.</param>
/// <param name="pathAssembler">Removal of containing paths and removal of overlapping paths.</param>
public GraphScaffoldBuilder(
IMatePairMapper mapPairedReads,
IReadContigMapper readContigMap,
IOrientationBasedMatePairFilter pairedReadFilter,
IDistanceCalculator distanceCalculator,
ITracePath tracePath,
IPathPurger pathAssembler)
{
if (null != mapPairedReads)
{
_mapPairedReads = mapPairedReads;
}
else
{
_mapPairedReads = new MatePairMapper();
}
if (null != readContigMap)
{
_readContigMap = readContigMap;
}
else
{
_readContigMap = new ReadContigMapper();
}
if (null != pairedReadFilter)
{
_pairedReadFilter = pairedReadFilter;
}
else
{
_pairedReadFilter = new OrientationBasedMatePairFilter();
}
if (null != distanceCalculator)
{
_distanceCalculator = distanceCalculator;
}
else
{
_distanceCalculator = new DistanceCalculator();
}
if (null != tracePath)
{
_tracePath = tracePath;
}
else
{
_tracePath = new TracePath();
}
if (null != pathAssembler)
{
_pathAssembler = pathAssembler;
}
else
{
_pathAssembler = new PathPurger();
}
//Hierarchical Scaffolding With Bambus
//by: Mihai Pop, Daniel S. Kosack, Steven L. Salzberg
//Genome Research, Vol. 14, No. 1. (January 2004), pp. 149-159.
_redundancy = 2;
//Memory and performance optimization.
_depth = 10;
}
public StoreRepository(string connectionString, IDistanceCalculator distanceCalculator)
{
_connectionString = connectionString;
_distanceCalculator = distanceCalculator;
}
public when_calculating_distance()
{
_distanceCalculator = new DistanceCalculator();
}
public JobFilteringService(IDistanceCalculator distanceCalculator)
{
_distanceCalculator = distanceCalculator;
}
private bool RedrawGraph()
{
try
{
panel1.Controls.Clear();
using (var graphics = panel1.CreateGraphics())
{
graphics.Clear(Color.White);
graphics.SmoothingMode = SmoothingMode.AntiAlias;
}
var loader = new RailNetworkDataLoader(textBox1.Text);
_distanceCalculator = DistanceCalculator<RailNetwork, City, Route>.Create(loader);
var nodes = _distanceCalculator.Graph.Nodes.Values.ToList();
DrawNodes(nodes);
DrawEdges(nodes);
return true;
}
catch (Exception ex)
{
MessageBox.Show("Invalid Graph\r\n" + ex);
return false;
}
}
public CallbackDistance(CalculatedOrder[] nodes, IDistanceCalculator distanceCalculator)
{
Nodes = nodes;
this.distanceCalculator = distanceCalculator;
}
public GetDistanceBetweenPostcodesHandler(IRepository repository, IDistanceCalculator distanceCalculator)
{
_repository = repository;
_distanceCalculator = distanceCalculator;
}
/// <summary>
/// Creates a new Intance of <see cref="TiendaService"/>
/// </summary>
/// <param name="tiendaDAO">Tienda DAO</param>
/// <param name="distanceCalculator">Distance Calculator</param>
public TiendaService(ITiendaDAO tiendaDAO, IDistanceCalculator distanceCalculator)
{
this._TiendaDAO = tiendaDAO;
this._DistanceCalculator = distanceCalculator;
}
public List <List <int> > Run(List <Instance> dataset, List <List <int> > currentRoute,
IEvaluator evaluator, IDistanceCalculator distanceCalculator, IPenaltyCalculator penaltyCalculator)
{
int k = 0;
while (k < Parameters.MAX_LOCAL_SEARCH_SWAP_ITERATION)
{
var oldRouteBeforeLocalSearchCopy = GRASPHelper.CopySolution(currentRoute);
double oldQuality = evaluator.EvaluateGlobalRoute(dataset, oldRouteBeforeLocalSearchCopy, distanceCalculator, penaltyCalculator);
bool WasIpmroved = false;
for (int g = 0; g < currentRoute.Count && !WasIpmroved; g++)
{
if (currentRoute[g].Count <= 2)
{
continue;
}
for (int z = 0; z < currentRoute.Count && !WasIpmroved; z++)
{
if (g == z)
{
continue;
}
//current route
for (int i = 1; i < currentRoute[g].Count && !WasIpmroved; i++)
{
int pointFromDiffRoute = currentRoute[g][i];
//next route
for (int j = 1; j < currentRoute[z].Count && !WasIpmroved; j++)
{
var tmp_copy = GRASPHelper.CopySolution(oldRouteBeforeLocalSearchCopy);
tmp_copy[z].Insert(j, pointFromDiffRoute);
if (!evaluator.CanExistWithCurrentTimeWindows(dataset, tmp_copy[z], distanceCalculator))
{
continue;
}
tmp_copy[g].RemoveAt(i);
double localQuality = evaluator.EvaluateGlobalRoute(dataset, tmp_copy, distanceCalculator, penaltyCalculator);
if (localQuality < oldQuality)
{
currentRoute = tmp_copy;
WasIpmroved = true;
}
}
}
}
}
if (!WasIpmroved)
{
break;
}
k++;
}
return(currentRoute);
}
public MapNpc(IItemProvider?itemProvider, IDao <ShopDto, int>?shops,
IDao <ShopItemDto, int>?shopItems,
List <NpcMonsterDto>?npcMonsters, ILogger logger, List <NpcTalkDto> npcTalks, IDistanceCalculator distanceCalculator)
{
_npcMonsters = npcMonsters;
_npcTalks = npcTalks;
_shops = shops;
_shopItems = shopItems;
_itemProvider = itemProvider;
_logger = logger;
Requests = new Subject <RequestData>();
_distanceCalculator = distanceCalculator;
}
public TemporaryEmissionsCalculator(IDistanceCalculator distance)
{
Distance = distance;
}
public KMeansNetwork(int numberOfNeurons,
INeuronInitializer neuronInit,
IDistanceCalculator distanceCalculator) : base(numberOfNeurons, neuronInit, distanceCalculator)
{
}
public TaxiCabIntersectionCalculator(IDistanceCalculator calculator)
{
_calculator = calculator;
}
public CustomerFinder(ILocationReader locationReader, IDistanceCalculator distanceCalculator)
{
this.locationReader = locationReader;
this.distanceCalculator = distanceCalculator;
}
public SimilarityCalculator(IDistanceCalculator distanceCalculator)
{
this.distanceCalculator = distanceCalculator;
}
public CellularNoise(IDistanceCalculator calculator, IConverter converter) : base(converter)
{
Calculator = calculator ?? throw new ArgumentNullException(nameof(calculator));
}
public void SetUp()
{
_timeSpanCalculator = new TimeSpanCalculator();
_distanceCalculator = new DistanceCalculator();
_velocityCalculator = new VelocityCalculator(_timeSpanCalculator, _distanceCalculator);
}
public AverageDailyDistanceCalculator(IDistanceCalculator calculator, DateRange period, VisitsByDayLINQQuery query)
{
this.calculator = calculator;
this.period = period;
this.query = query;
}
public void DijkstraInstantiation_ValidCityDataWithRepeatingRoutes()
{
_loader = new RailNetworkDataLoader("AB5,BC6,CD7,BC6,BC6");
_distanceCalculator = DistanceCalculator<RailNetwork, City, Route>.Create(_loader);
Assert.AreEqual(4, _distanceCalculator.Graph.NodeCount);
Assert.AreEqual(3, _distanceCalculator.Graph.EdgeCount);
}
public PreqPacketHandler(IMapInstanceProvider mapInstanceProvider, IMinilandProvider minilandProvider, IDistanceCalculator distanceCalculator)
{
_mapInstanceProvider = mapInstanceProvider;
_minilandProvider = minilandProvider;
_distanceCalculator = distanceCalculator;
}
public void TestInitialize()
{
_loader = new RailNetworkDataLoader(Input);
_distanceCalculator = DistanceCalculator<RailNetwork, City, Route>.Create(_loader);
}
public RouteCalculator(IDistanceCalculator distanceCalculator)
{
this.distanceCalculator = distanceCalculator;
}
public MonteCarloSquadMaker(ISetupSourceFactory setupSourceFactory, ISquadsSetupFactory squadSetupFactory, IDistanceCalculator distanceCalculator)
{
_setupSourceFactory = setupSourceFactory;
_squadSetupFactory = squadSetupFactory;
_distanceCalculator = distanceCalculator;
}
public OnlineEventListModelFactory(IDistanceCalculator distanceCalculator)
{
_distanceCalculator = distanceCalculator;
}
public ClassificationUnit WithDistanceDalculator(IDistanceCalculator<ClassificationUnit> distanceCalculator)
{
this._distanceCalculator = distanceCalculator;
return this;
}
/// <summary>
/// Dispose field instances.
/// </summary>
/// <param name="disposeManaged">If disposeManaged equals true, clean all resources.</param>
protected virtual void Dispose(bool disposeManaged)
{
if (disposeManaged)
{
this.distanceCalculator = null;
this.mapPairedReads = null;
this.pairedReadFilter = null;
this.pathAssembler = null;
this.readContigMap = null;
this.tracePath = null;
}
}
public ZombiePackRepository(string connectionString, IDistanceCalculator distanceCalculator)
{
_connectionString = connectionString;
_distanceCalculator = distanceCalculator;
}
public BaseRouteCreator(IDistanceCalculator distanceCalculator)
{
_distanceCalculator = distanceCalculator;
}
public GpxRouteCreator(IDistanceCalculator distanceCalculator) : base(distanceCalculator)
{
}
public ConnectionLengthCalculator(ICrossingPositionProvider <T> crossingPositionProvider,
IDistanceCalculator <T> distanceCalculator)
{
_crossingPositionProvider = crossingPositionProvider;
_distanceCalculator = distanceCalculator;
}
/// <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");
}
if (this.distanceCalculator == null)
{
this.distanceCalculator = new DistanceCalculator(contigMatePairs);
contigMatePairs = this.distanceCalculator.CalculateDistance();
}
else
{
contigMatePairs = this.distanceCalculator.CalculateDistance();
}
// this dictionary is updated in this step.
return contigMatePairs.Count;
}
/// <summary>
/// Initializes static class
/// </summary>
static Calculations()
{
_distanceCalculator = new GreatCircleDistanceCalculator();
}
/// <summary>
/// Initializes a new instance of the GraphScaffoldBuilder class.
/// </summary>
/// <param name="mapPairedReads">Mapping reads to mate pairs.</param>
/// <param name="readContigMap"> Mapping reads to contigs.</param>
/// <param name="pairedReadFilter">Filtering of mate pairs.</param>
/// <param name="distanceCalculator">Calculation of distance between
/// contigs using mate pairs.</param>
/// <param name="tracePath">Traversal of contig overlap graph.</param>
/// <param name="pathAssembler">Removal of containing paths and removal of overlapping paths.</param>
public GraphScaffoldBuilder(
IMatePairMapper mapPairedReads,
IReadContigMapper readContigMap,
IOrientationBasedMatePairFilter pairedReadFilter,
IDistanceCalculator distanceCalculator,
ITracePath tracePath,
IPathPurger pathAssembler)
{
this.mapPairedReads = mapPairedReads ?? new MatePairMapper();
this.readContigMap = readContigMap ?? new ReadContigMapper();
this.pairedReadFilter = pairedReadFilter ?? new OrientationBasedMatePairFilter();
this.tracePath = tracePath ?? new TracePath();
this.pathAssembler = pathAssembler ?? new PathPurger();
if (null != distanceCalculator)
{
this.distanceCalculator = distanceCalculator;
}
//Hierarchical Scaffolding With Bambus
//by: Mihai Pop, Daniel S. Kosack, Steven L. Salzberg
//Genome Research, Vol. 14, No. 1. (January 2004), pp. 149-159.
this.redundancyField = 2;
//Memory and performance optimization.
this.depthField = 10;
}
public OnlineSchedulingEventListModelFactory(IDistanceCalculator distanceCalculator)
{
_distanceCalculator = distanceCalculator;
_limitedAvailabilityThreshold = 3;
}
