vec2 * vec2 should be implemented!

General
1

Just wanted to state that vec2 * vec2 should be implemented the same way as vec2 + vec2.

print( vec2(2,2) + vec2(2,2) ) --prints [4,4]
print( vec2(2,2) * vec2(2,2) ) --FAILS!

--work around:
local v1 = vec2(2,2)
local v2 = vec2(2,2)
local v3 = vec2( v1.x*v2.x, v1.y*v2.y )
print(v3) --prints (4,4)

```
2

A bold statement!

Currently vec2 supports the use of the * for multiplication by a scalar. You can also do dot product and cross product multiplication of vectors.

https://bitbucket.org/TwoLivesLeft/core/wiki/vec2

I think you are after an element by element multiplication

3

somehow this is misleading. naturally I would think, *, is multiplying, and expect it to return an element by element multiplication result, IF two vec2 are compared. The current behaviour is ok when passing only a number as the multiplier.

4

I didn’t implement an element-wise multiplication because I felt it was a bit ambiguous. Many programming libraries overload vector * to mean cross product or sometimes even dot product.

I tried to be a bit conservative with the meaning of operators as they relate to vectors in Codea. I felt that unary negation, element-wise addition and subtraction, and scalar multiplication and division were appropriate as they were the common uses.

5

thank you for your point of view. but it would be helpful to have at least something like vec2:multiply(vec2). its anyway shorter than manually implemented solutions.
just my opinion. sorry for any inconvenience

6

(Untested)

local mt = getmetatable(vec2())
mt["multiply"] = function(self,v)
  return vec2(self.x*v.x,self.y*v.y)
end
7

@Andrew_Stacey Yes, but what is the getmetatable() for? Couldn’t you just:

(also untested)

vec2["multiply"] = function(self, v)
  return vec2(self.x * v.x, self.y * v.y)
end

Since vec2 is a global variable/class, you can simply add a method… or am I wrong?

8

Simple way to test!

You need the metatable because vec2 is a userdata so you can’t arbitrarily add functions to it.

9

Should element-wise multiplication be implemented via the * operator? What do you all think? Is this a good idea?

10

i would find that confusing…

11

Me too, but @se24vad suggestion of something like vec2: multiply(vec2) is a good one

12

thank you for the wisdom @Andrew_Stacey and thanks to all for the active discussion! vec:multiply would be enough @Simeon. Thanks for all the ideas and code and open ears for my issue)

13

Only if it doesn’t slow down the more usual use of *. I guess the dispatch to check type might steal some cycles? Better use Staceys addition if needed. Add bit operators instead :slight_smile:

14

But I would like a matrix * vec3 and matrix * vec4.

15

@tnlogy Given that matrix is 4x4, matrix * vec3 doesn’t make sense.

What would be nice would be easy conversion between the vector types, somewhat like in shaders. So I could do v = vec3(1,2,3) u = vec4(v,1).

16

It could convert to vec4 and back again behind the scenes, so that I can use matrix:rotate and such conveniently. :slight_smile:

17

But you’d want different conversions depending on whether you were doing points or normals. For points, you’d want to promote a vec3 with 1 in the last place, for normals then 0. So m * vec4(v,1) allows you to specify the promotion explicitly without over complicating matters.

18

Yes, that sounds good