operator / for point2 is hard coded to operate on type double (Trac 11739) about gil HOT 7 CLOSED

What is the possible range (set of valid types) of T ? I think I have written similar code in the past, where my assumption was that the divisor must be a wide floating point value for the operation to make sense, which would explain the second double argument. And then it would make sense to use simple type promotion to compute the return type, which may just be double, too, in this case.
(I'm just thinking aloud, trying to mentally reproduce why the code was written the way it is.)

from gil.

@mloskot Is there not a better point class in boost? Wouldn't that be better than using gil::point2?

from gil.

It's such a trivial class...
I'm not sure it would be worthwhile dragging in another dependency just for that. Besides, there are rather specific requirements for it (See http://boostorg.github.io/gil/html/design_guide.html#point) that I'm not sure any pre-existing class would meet without additional adapter code.
(And speaking of requirements: the /= signature using double actually comes from the concept itself.)

from gil.

I agree with @stefanseefeld that pulling Boost.Geometry or whatever as a dependency would not buy as anything really, but potential maintenance hassle.

I will look at implementing the idea of promoting the return type to best float-point type matching the operands.

from gil.

@stefanseefeld & @chhenning
How about replacing the current double-hardwired point<T>::operator/ with template function auto-promoting the base T of its point<T> result using std::common_type which I had no idea about until today :-)

template <typename T, typename D>
auto operator/(point<T> const& p, D d)
{
    static_assert(std::is_arithmetic<D>::value, "denominator is not arithmetic type");
    using numeric_type = typename std::common_type<T, D>::type;
    return point<numeric_type>(p.x / t, p.y / t);
}

Test:

point<int> p1;
static_assert(std::is_same<decltype((p1 / short{}).x), int>::value, "!int");
static_assert(std::is_same<decltype((p1 / int{}).x), int>::value, "!int");
static_assert(std::is_same<decltype((p1 / float{}).x), float>::value, "!float");
static_assert(std::is_same<decltype((p1 / double{}).x), double>::value, "!double");

point<float> p2;
static_assert(std::is_same<decltype((p2 / int{}).x), float>::value, "!float");
static_assert(std::is_same<decltype((p2 / float{}).x), float>::value, "!float");
static_assert(std::is_same<decltype((p2 / double{}).x), double>::value, "!double");

from gil.

Yeah, perfect !

from gil.

Fixed by #157

from gil.