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);
        }
示例#7
0
        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>();
        }
示例#10
0
 public HelperService(IVolunteerCache volunteerCache, IDistanceCalculator distanceCalculator, IRepository repository)
 {
     _volunteerCache     = volunteerCache;
     _distanceCalculator = distanceCalculator;
     _repository         = repository;
 }
示例#11
0
        /// <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);
        }
示例#12
0
 public RaceService(IDistanceCalculator distanceCalculator, IEnumerable<Waypoint> waypoints)
 {
     DistanceCalculator = distanceCalculator;
     Waypoints = waypoints;
 }
 public MatrixGenerator(IDistanceCalculator calculator)
 {
     this.calculator = calculator;
 }
示例#14
0
 public TravelController(IDistanceCalculator distanceCalculator)
 {
     this.distanceCalculator = distanceCalculator;
     this.routeCalculator    = new RouteCalculator(distanceCalculator);
 }
 public NearestNeighbourDistanceCalculator(IDistanceCalculator distanceCalculator)
 {
     _distanceCalculator = distanceCalculator;
 }
示例#16
0
            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);
            }
示例#17
0
 public void Setup()
 {
     instanceUnderTest = new GeodesicCurveDistanceCalculator();
 }
示例#18
0
 public void BuildDistanceCalculator()
 {
     _distanceCalculator = new DistanceCalculator(_distanceCoefficientsCalculator);
 }
 public CentroidDistanceGenerator(IDistanceCalculator calculator)
 {
     this.calculator = calculator;
 }
示例#20
0
 public WalkPacketHandler(IDistanceCalculator distanceCalculator)
 {
     _distanceCalculator = distanceCalculator;
 }
示例#21
0
 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;
 }
示例#23
0
        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();
 }
示例#25
0
 public void TestCleanup()
 {
     _loader = null;
     _distanceCalculator = null;
 }
示例#26
0
 public MinDistanceFilter(IDistanceCalculator distanceCalculator)
 {
     _distanceCalculator = distanceCalculator;
 }
示例#27
0
        /// <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;
 }
示例#31
0
        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;
            }
        }
示例#32
0
 public CallbackDistance(CalculatedOrder[] nodes, IDistanceCalculator distanceCalculator)
 {
     Nodes = nodes;
     this.distanceCalculator = distanceCalculator;
 }
 public GetDistanceBetweenPostcodesHandler(IRepository repository, IDistanceCalculator distanceCalculator)
 {
     _repository         = repository;
     _distanceCalculator = distanceCalculator;
 }
示例#34
0
 /// <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;
 }
示例#35
0
        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);
        }
示例#36
0
 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;
 }
示例#38
0
 public KMeansNetwork(int numberOfNeurons,
                      INeuronInitializer neuronInit,
                      IDistanceCalculator distanceCalculator) : base(numberOfNeurons, neuronInit, distanceCalculator)
 {
 }
 public TaxiCabIntersectionCalculator(IDistanceCalculator calculator)
 {
     _calculator = calculator;
 }
示例#40
0
 public CustomerFinder(ILocationReader locationReader, IDistanceCalculator distanceCalculator)
 {
     this.locationReader     = locationReader;
     this.distanceCalculator = distanceCalculator;
 }
示例#41
0
 public SimilarityCalculator(IDistanceCalculator distanceCalculator)
 {
     this.distanceCalculator = distanceCalculator;
 }
示例#42
0
 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;
 }
示例#45
0
        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);
        }
示例#46
0
 public PreqPacketHandler(IMapInstanceProvider mapInstanceProvider, IMinilandProvider minilandProvider, IDistanceCalculator distanceCalculator)
 {
     _mapInstanceProvider = mapInstanceProvider;
     _minilandProvider    = minilandProvider;
     _distanceCalculator  = distanceCalculator;
 }
示例#47
0
        public void TestInitialize()
        {
            _loader = new RailNetworkDataLoader(Input);

            _distanceCalculator = DistanceCalculator<RailNetwork, City, Route>.Create(_loader);
        }
示例#48
0
 public RouteCalculator(IDistanceCalculator distanceCalculator)
 {
     this.distanceCalculator = distanceCalculator;
 }
示例#49
0
 public MonteCarloSquadMaker(ISetupSourceFactory setupSourceFactory, ISquadsSetupFactory squadSetupFactory, IDistanceCalculator distanceCalculator)
 {
     _setupSourceFactory = setupSourceFactory;
     _squadSetupFactory  = squadSetupFactory;
     _distanceCalculator = distanceCalculator;
 }
 public OnlineEventListModelFactory(IDistanceCalculator distanceCalculator)
 {
     _distanceCalculator = distanceCalculator;
 }
示例#51
0
 public ClassificationUnit WithDistanceDalculator(IDistanceCalculator<ClassificationUnit> distanceCalculator)
 {
     this._distanceCalculator = distanceCalculator;
     return this;
 }
示例#52
0
 /// <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;
 }
示例#57
0
        /// <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;
        }
示例#58
0
 /// <summary>
 /// Initializes static class
 /// </summary>
 static Calculations()
 {
     _distanceCalculator = new GreatCircleDistanceCalculator();
 }
示例#59
0
        /// <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;
        }
示例#60
0
 public OnlineSchedulingEventListModelFactory(IDistanceCalculator distanceCalculator)
 {
     _distanceCalculator           = distanceCalculator;
     _limitedAvailabilityThreshold = 3;
 }