I think how search has been handled, with the default & algorithm-specific versions, is worth considering.

**From:** Jeremy Murphy <jeremy.william.murphy@gmail.com>

**Sent:** Sunday, April 23, 2023 11:28 PM

**To:** sg19@lists.isocpp.org

**Cc:** Jens Maurer <jens.maurer@gmx.net>; Phil Ratzloff <Phil.Ratzloff@sas.com>; Oliver Rosten <oliver.rosten@googlemail.com>

**Subject:** Re: [SG19] D1709: Graph Proposal

You don't often get email from
jeremy.william.murphy@gmail.com.
Learn why this is important |

*EXTERNAL*

Hi everyone,

apologies for dropping in unannounced, I'm not sure what the protocol for participation is.

I just had a couple of comments to add on the algorithm naming topic.

The value of having std::sort and std::stable_sort is ease of use -- a user doesn't have to deliberate when they want to get on with the task of sorting arbitrary data. But for the users with specific requirements such as sorting many small
arrays, or not caring about the worst-case scenario, they have to pay the cost of generality.

From memory, some standard implementations have "insertion_sort" in there, but it's not in ::std, so it's not available to the user.

C++17 introduced an overload of std::search that takes a searcher object such as std::boyer_moore or std::boyer_moore_horspool, and also provided the std::default_searcher class that just does the basic algorithm. (Of course they retained
the original interface to std::search too.)

From these examples, I'm suggesting why not have both? I mean, have std::dijkstra and std::bellman_ford, etc, but also have the std::shortest_path(_variant) names that default to the most generally pleasing (whatever that means) algorithm.
That would satisfy the users that want to choose their algorithm explicitly and the users that want the language to choose the best algorithm for the problem. You might even design it like std::search, so that the algorithm is passed as a solver to the single
interface, i.e. a user might call std::shortest_path(std::dijkstra{}, ...) to explicitly use Dijkstra's algorithm to solve that problem; if the user doesn't explicitly choose a solver then the default is used.

Cheers.

Jeremy

On Sat, 15 Apr 2023 at 02:28, Phil Ratzloff via SG19 <sg19@lists.isocpp.org> wrote:

(Adding Andrew – he’s had problems getting added to the SG19 reflector)

From:SG19 <sg19-bounces@lists.isocpp.org>On Behalf OfOliver Rosten via SG19

Sent:Friday, April 14, 2023 8:50 AM

To:Jens Maurer <jens.maurer@gmx.net>

Cc:Oliver Rosten <oliver.rosten@googlemail.com>; sg19@lists.isocpp.org

Subject:Re: [SG19] D1709: Graph Proposal

EXTERNALI think there are some other considerations to bear in mind, which were briefly touched on last night.

To what extent can the problem of dispatch be dealt with implicitly? What I'm getting at here is that in

someinstances an appropriate concept could do the trick. For example, consider the simple cases where the weights are(i) int

(ii) unsigned int

There is enough info to always correctly and optimally dispatch case (ii). The first case is harder. In general, we can't assume that Dijskstra will work and so by default we should dispatch to e.g. Bellman-Ford. However, clients may wish to explicitly override this if they

knowthat none of the weights are actually negative.

Perhaps this implies a set of functions

shortest_path (constrained to accept graph-like types satisfying enough requirements for implicit dispatch)

shortest_path_semi_positive_weights (ideally with a nicer name)

shortest_path_negative_weights (ditto)

Oliver

PS Out of curiosity, what is your objection to overload sets? I tend to find them easier to work with in generic code since it's easy to create maps from types to types. However, I typically find maps from types to function invocations more fiddly and a bit clumsier.

On Fri, 14 Apr 2023 at 08:34, Jens Maurer <jens.maurer@gmx.net> wrote:

On 13/04/2023 22.54, Oliver Rosten via SG19 wrote:

> Hi folks,

>

> Further to today's meeting I wanted to add a further thought about standardizing explicitly named algorithms, such as Dijksrta's.

>

> To recap:

>

> 1. I expressed worry with this direction as I think we should be standardizing what algorithms do, rather than how they do it. I drew an analogy with sort and stable_sort: this is what is standardized, not quick_sort, merge_sort etc. Therefore, my preference is the shortest_path 'driver' approach.

>

> 2. A counter-argument was given that users may wish to specify a particular algorithm since e.g. Dijkstra's is inappropriate if there are negative weights.

>

> That's pretty much where we left it at the meeting.

>

> However, I think what point 2 is really highlighting is that the shortest_path 'driver' algorithm should be sufficiently flexible to disambiguate things like this (and this is true regardless of whether there are explicitly named alternatives). For example, I could imagine an overload set with a tag parameter indicating whether there are negative weights.

Agreed with the general idea, but please let's not have overload sets

with tag parameters if we're not dealing with a constructor and we're

not dealing with an open-ended set of possibilities.

It's "sort" and "stable_sort", thus it should be "shortest_path_positive_weights"

and "shortest_path" (details of names tbd), i.e. functions are differentiated by name.

Jens--

SG19 mailing list

SG19@lists.isocpp.org

https://lists.isocpp.org/mailman/listinfo.cgi/sg19