Question

I have an optimisation algorithm which finds the best partition of a graph.

There are many measures for the quality of a partition (the variable being optimised), so I thought it would be a good idea to use function pointers to these quality functions, and pass that into my optimisation algorithm function.

This works fine, but the problem is different quality functions take some different arguments.

For example one quality function is find_linearised_stability and it requires a markov_time parameter:

float find_linearised_stability(cliques::Graph<T> &my_graph, cliques::Partition &my_partition,
                               std::vector<float> &markov_times, std::vector<float> &stabilities)

and is used in the optimisation function :

cliques::find_optimal_partition_louvain(my_new_graph, markov_times, &cliques::find_linearised_stability);

however another quality function find_modularityrequires no markov_time parameter. Of course I could just include it as an argument and not use it in the function but that seems like bad practice, and would get unwieldy once I start adding a lot of different quality functions.

What is a better design for this kind of situation?

Answer 1

Use function objects. One of those function objects can have a markov_time member that is passed in to the constructor:

struct find_linearised_stability {
    std::vector<float> & markov_times_;

    find_linearised_stability(std::vector<float> & markov_times)
        :markov_times_(markov_times)
    {}

    float operator () (cliques::Graph<T> &my_graph, cliques::Partition &my_partition,
                 std::vector<float> &stabilities)
    {
        // use markov_times_ in here, we didn't need to pass it since it's a member
    }
};

(you may need to make adjustments to constness/referenceness to suit your needs)

Then you can call your function like this:

cliques::find_optimal_partition_louvain(my_new_graph, cliques::find_linearised_stability(markov_times));

“what type for the function object do I use when declaring the … function?”

Make it a function template that takes the function object type as a template parameter, thusly:

template<typename PR>
whatever find_optimal_partition_louvain(my_new_graph, PR & pr)
{
    ...
    pr(my_new_graph, partition, stabilities);
    ...
}