next_permutation with custom comparer function c++ - c++

Question

I'm using a custom comparer function for my next_permutation function, but I don't understand why I'm getting the error:
Expression: invalid operator<
I want my function to work with at least these restrictions in the function body, but keep getting errors:
bool mycomp(int i, int j)
{
return (((i < 0) && (j > 0)) || ((i > 0) && (j < 0)));
};
but when I do it like this, it works fine:
bool mycomp(int i, int j)
{
return (((i < 0) && (j > 0)));
};
I want to also add another restriction, but don't know how.
here is the relevant code with the next_permutation function:
int counter, size, *guests;
for (int i = 2; i <= 9; i++)
{
size = i * 2;
counter = 1;
guests = new int[size];
for (int j = 0; j < size; j += 2)
{
guests[j] = counter;
guests[j + 1] = 0 - counter;
++counter;
}
sort(guests, guests + size);
counter = 0;
while (next_permutation(guests, guests + size, mycomp))
{
++counter;
}
}
I also understand that there is a strict weak ordering requirement. I understood the gist of it after reading about it, but not sure exactly how it applies to this situation. Thank you in advance.

Answer 1

Your compiler is trying to tell you (through a runtime assertion) that your comparator is invalid. It is invalid as it does not respect the strict weak ordering contract for at least two reasons :
1) It is not antisymmetric ( ie f(x, y) implies !f(y, x)) :
std::cout << mycomp(2, -3) << '\n';
std::cout << mycomp(-3, 2) << '\n';
Output:
true
true
2) It is not transitive (ie f(x, y) and f(y, z) imply f(x, z) ):
std::cout << mycomp(2, -3) << '\n';
std::cout << mycomp(-3, 2) << '\n';
std::cout << mycomp(2, 2) << '\n';
Output:
true
true
false
false
Demo
Your probably need to rethink your problem, and how you really want to order your elements while doing the permutations.

Answer 2

Permutation is about ordering. The default ordering is 1<2<3<4<5<6 etc -- the order you are used to.
The custom comparator lets you set an ordering that is different than the default one.
This is useful in a number of situations.
For a toy example, you could set all even numbers to be greater than all odd ones -- 1<3<5<7<...<0<2<4<6<8<....
Example implementation that leverages std::tuple:
std::tuple<bool,unsigned> myhelper( unsigned x ) {
return std::make_tuple( !(x%2), x );
}
bool myorder( unsigned lhs, unsigned rhs ) {
return helper(lhx)<helper(rhs);
}
For types that don't have an operator < that is a strict weak ordering, it lets you provide one. A complex number can be ordered lexicographically, or magnitude-wise: the magnitude-ordering is not a strict weak ordering, and having < be a lexicographic order would be surprising.