void BackwardRoutingStep(const unsigned target_id, QueryHeap &query_heap, SearchSpaceWithBuckets &search_space_with_buckets) const { const NodeID node = query_heap.DeleteMin(); const int target_distance = query_heap.GetKey(node); // store settled nodes in search space bucket search_space_with_buckets[node].emplace_back(target_id, target_distance); if (StallAtNode<false>(node, target_distance, query_heap)) { return; } RelaxOutgoingEdges<false>(node, target_distance, query_heap); }
void ForwardRoutingStep(const DataFacadeT &facade, const unsigned row_idx, const unsigned number_of_targets, QueryHeap &query_heap, const SearchSpaceWithBuckets &search_space_with_buckets, std::vector<EdgeWeight> &result_table) const { const NodeID node = query_heap.DeleteMin(); const int source_weight = query_heap.GetKey(node); // check if each encountered node has an entry const auto bucket_iterator = search_space_with_buckets.find(node); // iterate bucket if there exists one if (bucket_iterator != search_space_with_buckets.end()) { const std::vector<NodeBucket> &bucket_list = bucket_iterator->second; for (const NodeBucket ¤t_bucket : bucket_list) { // get target id from bucket entry const unsigned column_idx = current_bucket.target_id; const int target_weight = current_bucket.weight; auto ¤t_weight = result_table[row_idx * number_of_targets + column_idx]; // check if new weight is better const EdgeWeight new_weight = source_weight + target_weight; if (new_weight < 0) { const EdgeWeight loop_weight = super::GetLoopWeight(facade, node); const int new_weight_with_loop = new_weight + loop_weight; if (loop_weight != INVALID_EDGE_WEIGHT && new_weight_with_loop >= 0) { current_weight = std::min(current_weight, new_weight_with_loop); } } else if (new_weight < current_weight) { result_table[row_idx * number_of_targets + column_idx] = new_weight; } } } if (StallAtNode<true>(facade, node, source_weight, query_heap)) { return; } RelaxOutgoingEdges<true>(facade, node, source_weight, query_heap); }
void BackwardRoutingStep(const DataFacadeT &facade, const unsigned column_idx, QueryHeap &query_heap, SearchSpaceWithBuckets &search_space_with_buckets) const { const NodeID node = query_heap.DeleteMin(); const int target_weight = query_heap.GetKey(node); // store settled nodes in search space bucket search_space_with_buckets[node].emplace_back(column_idx, target_weight); if (StallAtNode<false>(facade, node, target_weight, query_heap)) { return; } RelaxOutgoingEdges<false>(facade, node, target_weight, query_heap); }
void ForwardRoutingStep(const unsigned source_id, const unsigned number_of_locations, QueryHeap &query_heap, const SearchSpaceWithBuckets &search_space_with_buckets, std::shared_ptr<std::vector<EdgeWeight>> result_table) const { const NodeID node = query_heap.DeleteMin(); const int source_distance = query_heap.GetKey(node); // check if each encountered node has an entry const auto bucket_iterator = search_space_with_buckets.find(node); // iterate bucket if there exists one if (bucket_iterator != search_space_with_buckets.end()) { const std::vector<NodeBucket> &bucket_list = bucket_iterator->second; for (const NodeBucket ¤t_bucket : bucket_list) { // get target id from bucket entry const unsigned target_id = current_bucket.target_id; const int target_distance = current_bucket.distance; const EdgeWeight current_distance = (*result_table)[source_id * number_of_locations + target_id]; // check if new distance is better const EdgeWeight new_distance = source_distance + target_distance; if (new_distance >= 0 && new_distance < current_distance) { (*result_table)[source_id * number_of_locations + target_id] = (source_distance + target_distance); } } } if (StallAtNode<true>(node, source_distance, query_heap)) { return; } RelaxOutgoingEdges<true>(node, source_distance, query_heap); }