1.0f / vec2(2.0f, 2.0f) == vec2(2.0f, 2.0f) about mathfu HOT 10 CLOSED

That's most definitely a bug, yes. Are you able to make a pull request?

from mathfu.

Had look at the issue, but could not find where the operator overload is declared. I was expecting something along the lines of:
inline Vector<float, 2>& operator/=(const float &s, const Vector<float, 2>& v)
Am I missing something?

from mathfu.

https://github.com/google/mathfu/blob/master/include/mathfu/vector.h#L417
https://github.com/google/mathfu/blob/master/include/mathfu/vector_2.h#L102
https://github.com/google/mathfu/blob/master/include/mathfu/vector_2.h#L118
https://github.com/google/mathfu/blob/master/include/mathfu/vector_2.h#L155

etc.

We have various overloads for each specialized vector e.g vec2, vec3, vec4
etc.

On Tue, Sep 15, 2015 at 10:06 AM, Daniel Monteiro [email protected]
wrote:

Had look at the issue, but could not find where the operator overload is
declared. I was expecting something along the lines of:
inline Vector<float, 2>& operator/=(const float &s, const Vector<float,
2>& v)
Am I missing something?

—
Reply to this email directly or view it on GitHub
#8 (comment).

from mathfu.

Precisely. By grepping thru the code, all I could find was overloads dealing with Vec2/Vec2 and Vec2/scalar, but not for scalar/Vec2 (which, in effect, would be scalar * Vec2^(-1) ).

Still, by far, the last few days of digging have been quite fascinating.

from mathfu.

That will teach me to not read your original message.

Is it possible that you're ending up in
https://github.com/google/mathfu/blob/master/include/mathfu/vector.h#L670
? It looks like that code is wrong since it should only accept a scalar on
the right-hand side of the expression. i.e scalar / vector = undefined
https://en.wikibooks.org/wiki/Fundamentals_of_Physics/Vectors, vector /
scalar = piecewise division of each element in the vector.

What code have you written that is problematic, any chance you could share
a snippet?

On Tue, Sep 15, 2015 at 10:31 AM, Daniel Monteiro [email protected]
wrote:

Precisely. By grepping thru the code, all I could find was overloads
dealing with Vec2/Vec2 and Vec2/scalar, but not for scalar/Vec2 (which, in
effect, would be scalar * Vec2^(-1) ).

Still, by far, the last few days of digging have been quite fascinating.

—
Reply to this email directly or view it on GitHub
#8 (comment).

from mathfu.

Not really mine. I'm just trying to learn from it.
I was unsure of what 1.0/vec2 would mean until I threw it at Wolfram Alpha ( {2.0, 3.0}^-1 got me {1.0/2.0, 1.0/3.0}). Me and my friends were baffled by his outcome.

By doing this on the generic vector wouldn't it be too expensive to go component-by-component? Maybe this couldn't be more efficiently (at the cost of some repetition) dealt at the more specific vectors? Or maybe it would result in unwanted duplicity of effort?

Or even, does it make sense to have it as a general proposition?

from mathfu.

I would really prefer to not have MathFu include operators that aren't well
defined.

We have specialized implementations of scalar divide for each vector type
which use SIMD when it's available. As I mentioned scalar / vector sounds
broken.

On Tue, Sep 15, 2015 at 11:12 AM, Daniel Monteiro [email protected]
wrote:

Not really mine. I'm just trying to learn from it.
I was unsure of what 1.0/vec2 would mean until I threw it at Wolfram Alpha
( {2.0, 3.0}^-1 got me {1.0/2.0, 1.0/3.0}). Me and my friends were baffled
by his outcome.

By doing this on the generic vector wouldn't it be too expensive to go
component-by-component? Maybe this couldn't be more efficiently (at the
cost of some repetition) dealt at the more specific vectors? Or maybe it
would result in unwanted duplicity of effort?

Or even, does it make sense to have it as a general proposition?

—
Reply to this email directly or view it on GitHub
#8 (comment).

from mathfu.

I agree. Makes a lot more sense

Maybe @batesj can provide us with more details on his use? Maybe we can suggest alternatives? IDK

from mathfu.

I would have been happy if my code didn't compile, so feel free to delete the scalar / vector operator.

What I expected was component-wise divide either through implicit construction or directly:
1.0 / vec2 == vec2(1.0) / vec2 == vec2(1.0, 1.0) / vec2

from mathfu.

6cb4a10

from mathfu.