**Point<T>** defines ***** for (**Point<T>**, **T**) but not the other way round. So myScalar*myVector will fail to compile.

Could we have bidirectional? So that one could transfer something like:

x = α u + β v

... directly to code?

π

**Point<T>** defines ***** for (**Point<T>**, **T**) but not the other way round. So myScalar*myVector will fail to compile.

Could we have bidirectional? So that one could transfer something like:

x = α u + β v

... directly to code?

π

I don't really mind using {vector}{OPERATOR}{scalar}.

Just.. I would expect someone to expect the other way round.

I've been posting minutiae (e.g. where I expect A but the framework gives B) on-the-fly in case some of the feedback might be of some use.

π

Yeah, this is a good request, and something I'd been meaning to do. Will add it when I get a moment!

This is actually a pain in the donkey.

A naive approach...

template <typename T, U> Point<T> operator* (U multiplier, Point<T>point) noexcept { ...

... fails as {Rect}*{Point} snaffles the overload.

Trying to get cunning with SFINAE http://coliru.stacked-crooked.com/a/1e226e96fc435f2a fails on Windows due to MSVC being a persistent pile of shit (https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/).

The least awkward method I can see is to temporarily promote the scalar to a double:

template <typename ValueType> class Point { public: : static friend Point operator* (double multiplier, Point<ValueType>point) noexcept { return Point((ValueType)(point.x * multiplier), (ValueType)(point.y * multiplier)); }

or:

template <typename T> Point<T> operator* (double multiplier, Point<T>point) noexcept { return Point<T>((T)(point.x * multiplier), (T)(point.y * multiplier)); }

I suppose I would prefer the former, as it keeps the overload within Point's declaration.

π

PS I would also consider macros to avoid duplicating otherwise identical code for each operator.