basePath_SSEC.cpp File Reference

#include "cpp_common/basePath_SSEC.hpp"
#include <cmath>
#include <limits>
#include <deque>
#include <iostream>
#include <algorithm>
#include <utility>
#include "c_types/general_path_element_t.h"
#include "cpp_common/pgr_assert.h"

Include dependency graph for basePath_SSEC.cpp:

Go to the source code of this file.

Functions
size_t	collapse_paths (General_path_element_t **ret_path, const std::deque< Path > &paths)
size_t	count_tuples (const std::deque< Path > &paths)
void	equi_cost (std::deque< Path > &paths)
std::ostream &	operator<< (std::ostream &log, const Path &path)

Function Documentation

collapse_paths()

size_t collapse_paths	(	General_path_element_t **	ret_path,
		const std::deque< Path > &	paths
	)

Definition at line 310 of file basePath_SSEC.cpp.

                                       {
    size_t sequence = 0;
    for (const Path &path : paths) {
        if (path.path.size() > 0)
            path.generate_postgres_data(ret_path, sequence);
    }
    return sequence;
}

Referenced by do_pgr_astarManyToMany(), do_pgr_bdAstar(), do_pgr_bdDijkstra(), do_pgr_bellman_ford(), do_pgr_bellman_ford_neg(), do_pgr_binaryBreadthFirstSearch(), do_pgr_combinations_dijkstra(), do_pgr_dagShortestPath(), do_pgr_driving_many_to_dist(), do_pgr_edwardMoore(), do_pgr_many_to_many_dijkstra(), do_pgr_many_withPointsDD(), do_pgr_withPoints(), and do_trsp().

count_tuples()

size_t count_tuples

(

const std::deque< Path > &

paths

)

Definition at line 387 of file basePath_SSEC.cpp.

                                            {
    size_t count(0);
    for (const Path &e : paths) {
        count += e.path.size();
    }
    return count;
}

Referenced by do_pgr_astarManyToMany(), do_pgr_bdAstar(), do_pgr_bdDijkstra(), do_pgr_bellman_ford(), do_pgr_bellman_ford_neg(), do_pgr_binaryBreadthFirstSearch(), do_pgr_combinations_dijkstra(), do_pgr_dagShortestPath(), do_pgr_dijkstraVia(), do_pgr_driving_many_to_dist(), do_pgr_edwardMoore(), do_pgr_ksp(), do_pgr_many_to_many_dijkstra(), do_pgr_many_withPointsDD(), do_pgr_turnRestrictedPath(), do_pgr_withPoints(), do_pgr_withPointsKsp(), and do_trsp().

equi_cost()

void equi_cost

(

std::deque< Path > &

paths

)

Definition at line 336 of file basePath_SSEC.cpp.

                                   {
    /* sort paths by size: largest first */
    std::sort(paths.begin(), paths.end(),
            [](const Path &e1, const Path &e2)->bool {
            return e2.size() < e1.size();
            });
 
    /* sort each path by node: smaller id first */
    for (auto &p : paths) {
        if (p.size() < 2) continue;
        std::sort(p.begin(), p.end(),
                [](const Path_t &e1, const Path_t &e2)->bool {
                return e1.node < e2.node;
                });
    }
 
    for (auto &p1 : paths) {
        for (const auto &p2 : paths) {
            if (p1.start_id() == p2.start_id()) continue;
            for (const auto &stop : p2.path) {
                /* find the node of p2 in p1 */
                auto pos = lower_bound(p1.begin(), p1.end(), stop,
                        [](const Path_t &l, const Path_t &r)->bool {
                        return l.node < r.node;
                        });
 
                if (pos != p1.end()
                        && (stop.node == pos->node)
                        && (stop.agg_cost < pos->agg_cost)) {
                    /* both share the same node &
                     * the second path has the smallest
                     *  So erasing from the first path */
                    p1.erase(pos);
                }
            }
        }
    }
    /* sort paths by start_id */
    std::sort(paths.begin(), paths.end(),
            [](const Path &e1, const Path &e2)->bool {
            return e1.start_id() < e2.start_id();
            });
 
    /* sort each path by agg_cost, node */
    for (auto &path : paths) {
        path.sort_by_node_agg_cost();
    }
}

operator<<()

std::ostream& operator<<	(	std::ostream &	log,
		const Path &	path
	)

Definition at line 118 of file basePath_SSEC.cpp.

                                                          {
    log << "Path: " << path.start_id() << " -> " << path.end_id() << "\n"
        << "seq\tnode\tedge\tcost\tagg_cost\n";
    int64_t i = 0;
    for (const auto &e : path) {
        log << i << "\t"
            << e.node << "\t"
            << e.edge << "\t"
            << e.cost << "\t"
            << e.agg_cost << "\n";
        ++i;
    }
    return log;
}

References Path::end_id(), and Path::start_id().