Operator Overloading for Arrays or how to make Vector Calculations?

[toihr]

I am very interested as a scientist to use the V Language because of the simplicity and ease of writing while still generating highly optimizable code that can run on everything through the use of C as an IR.

There is just one thing that I havent quite been able to figure out. The Documentation mentions that Operator overloading exists mainly for the Science Domains that should be supported. So I was trying to use operator overloading to create a simple way to do Vector Addition (Element Wise array addition). I know I could just make a loop instead but thats just in general less readable.

So far i tried to do it as follows:

(a1 []int) + (a2 []int) []int{
   result := []int{len: a1.len, init: 0}
   for i in 0 .. a1.len{
      result[i] = a1[i] + a2[i]
   }
   return result
}

But this does not seem to work is there a way to do this if anyone knows something good here it would be greatly appreciated.

[Delta456]

You would have to make an alias for the int slice.

type Slice = []int

(a1 Slice) + (a2 Slice) Slice {
   result := Slice([]int{len: a1.len, init: 0})
   for i in 0 .. a1.len{
      result[i] = a1[i] + a2[i]
   }
   return result
}

[JalonSolov]

for i, _ in a1 {

You don't need to specify starting from 0 and going to length. It is for index, value in array, and _ means the value is ignored for this loop, since you need the index to access the 2nd array.

V also supports iterating the value (without the index) with a simple

for val in a1 {

but that won't give the index to use for the 2nd array.

[toihr]

aye i see how that works now. Its a bit more inconvenient than I would have liked, on the level of using Numpy in python. I had hoped i could overload it directly so I dont have to wrap the arrays i want to use in a slice([1,2,3]) which just makes it a little bit more inconvenient to write.

[LukyGuyLucky]

neither of the above code snippets works.There is something missing.

[tstibor]

You can overload a struct containing a generic [], e.g.

struct Vec[T] {
    mut: e []T
}

fn (a Vec[T]) + (b Vec[T]) Vec[T] {
    mut c := a
    for i in 0 .. a.e.len {
        c.e[i] = a.e[i] + b.e[i]
    }
    return c
}

fn main() {

    x := Vec { [1.0, 2, 3] }
    y := Vec { [4.0, 5, 6] }
    z := x + y
    
    println(z)
}

Vec[f64]{
    e: [5.0, 7.0, 9.0]
}

[JalonSolov]

Alternatively, as I mentioned earlier, you could replace

    for i in 0 .. a.e.len {

with

    for i, _ in a.e {

Fewer characters to type for the same result.

[tstibor]

Just tried to understand why there is also no overload for Vec2[T] and scalar multiplication, but only overload for element-wise multiplication:

// * returns the resulting vector of the multiplication of `v` and `u`.
@[inline]
pub fn (v Vec2[T]) * (u Vec2[T]) Vec2[T] {
	return Vec2[T]{v.x * u.x, v.y * u.y}
}

adding the following in vlib/math/vec/vec2.v

// * returns the resulting vector of the multiplication of the `scalar` value.
pub fn (v Vec2[T]) * (scalar U) Vec2[T] {
	return Vec2[T]{v.x * U(scalar), v.y * U(scalar)}
}

results unfortunately in

vlib/math/vec/vec2.v:149:20: error: cannot duplicate operator overload `*`
  147 | 
  148 | // * returns the resulting vector of the multiplication of the `scalar` value.
  149 | pub fn (v Vec2[T]) * (scalar U) Vec2[T] {
      |                    ^
  150 |     return Vec2[T]{v.x * U(scalar), v.y * U(scalar)}
  151 | }

Would be great to have the feature of Vec2, Vec3, and Vec4 * scalar overload.

[JalonSolov]

The problem is... what does Vec * 5 mean? Does it mean multiply each element of Vec by 5, or does it mean make 5 copies of Vec?

What about Vec1 + Vec2? Does it mean add corresponding elements together? What if there is an uneven number of elements between the 2? Does the operation wrap? What if you wanted to concatenate with + instead of adding?

So the first thing that would have to be done is decide on one specific interpretation. Then implement to that interpretation.

Then document it heavily, so that when someone gets a different answer than they expected, you can point them to the docs and say "it works like that, not like you want".

Part of the documentation needs to be WHY this particular interpretation was chosen as the one to be implemented.

[jorgeluismireles]

Just tried to understand why there is also no overload for Vec2[T] and scalar multiplication

It exists not as overload but as a method:

// multiply_scalar multiplies the vector with `scalar`.
pub fn (mut v Vec2[T]) multiply_scalar[U](scalar U) {
	v.x *= T(scalar)
	v.y *= T(scalar)
}

https://github.com/vlang/v/blob/master/vlib/math/vec/vec2.v#L159C1-L164C1

[tstibor]

I know I have seen the method multiply_scalar and actually wondered why one cannot overload the scalar multiplication. That was the point of the last post. That was the reason why I quickly hacked:

pub fn (v Vec2[T]) * (scalar U) Vec2[T] {
return Vec2[T]{v.x * U(scalar), v.y * U(scalar)}
}

to see whether one can extend the vec2.v with a simple scalar overload.

I understand that:

>>> import math.vec
>>> mut a := vec.Vec2{1.0, 2.0}
>>> a.multiply_scalar(1.57)
>>> a
vec.Vec2[f64]{
    x: 1.57
    y: 3.14
}

Given that import math.vec have math and vec in the name, and using Vec2 in R² it would be useful to have a scalar multiplication overload as '*'. Something like:

>>> 1.57 * a

error: expression evaluated but not used
   12 | a.multiply_scalar(1.57)
   13 | println(a)
   14 | 1.57 * a
      | ~~~~~~~~

and I also don't think that this would lead to confusion that 5 * vec.Vec2 would give 5 copies.
The problem seems to be that one cannot have more than one overload. There exists already the element-wise multiplication overload:

v/vlib/math/vec/vec2.v

Line 137 in 951d304

// * returns the resulting vector of the multiplication of `v` and `u`.

[JalonSolov]

Correct. V does not allow shadowing, so you can only have one of each name, no matter what it may be. So you can't have a function with the same name as a const, and neither can you have 2 functions with the same name.

[jorgeluismireles]

Besides shadowing, V requires both types of operator overloading be the same. Lets you say you want to sustract an integer from a nibble. We get these errors:

struct Nibble { n u8 }
struct Integer { n u8 }

fn (n Nibble) + (m Nibble) Nibble {
	return Nibble {	n: n.n + m.n }
}

// expected `Nibble` not `Integer` - both operands must be the same type for operator overloading
fn (n Nibble) - (i Integer) Nibble {
	return Nibble { n: n.n - i.n }
}

fn main() {
	println('${Nibble{1} + Nibble{3}}') // 4 ok
	//println('${Nibble{3} - Integer{1}}') // mismatched types `Nibble` and `Integer`
}