Class design, kinda math specific.

We had a thread about this once, and one thing that someone suggested (which I started doing) was using normalized to represent the non-mutating normalize function.

That is:

v.normalize(); // mutating function, modifies v
v.normalized(); // non-mutating function, does not modify v (returns a new vector)

Another suggestion someone brought up was to use free functions instead of member functions. So then I do something like:

// Personally, I hate overloading operators for cross and dot
// (if my keyboard doesn't have the mathematically right symbol, I write it out)
u = cross(a, b);
v = dot(a, b);
w = normalized(a);

In then end, I combine these two. Free functions are always non-mutating (and in ambiguous cases, the past-tense form of the word is used). Member functions that mutate do not use the past-tense. Member functions that obviously don't mutate are allowed (like magnitude()). Member functions that don't modify the object, but is not obvious, are not allowed (like a normalized() member function). Something like:

a = normalized(b); // b is not modified
b.normalize(); // b is modified (note: I don't define b.normalized() (i.e. a non-mutating member version of normalize))
c = cross(a, b); // a and b are not modified
c = dot(a, b); // a and b are not modified
c = -a; // a is not modified

On top of this, I make the b.normalize() function return void, so it's clear it's meant to be called for its side effects and can't be accidentally used in the same place that the free normalized() function can.

Edit: and for those curious, I'm intentionally not using code tags because they're too frustrating to work with.

We had a thread about this once, and one thing that someone suggested (which I started doing) was using normalized to represent the non-mutating normalize function.

Heh, I just linked to the same thread in another thread less than an hour ago.

We had a thread about this once, and one thing that someone suggested (which I started doing) was using normalized to represent the non-mutating normalize function.

Heh, I just linked to the same thread in another thread less than an hour ago.

Ha that was a good thread, but I was actually thinking of this thread (and Sneftel's response). I can't remember which thread someone mentioned the free-functions in, though...

I'm actually pretty unsure of the speed/clearness/etc of some of the decisions on my math library (in Java) but after going around 3 or so designs, my latest iteration does this:

public static Vector3f normalize( Vector3f vec, Vector3f dest )
{
 
//normalize vec, store in dest.
 
return dest;
}

Instead of writing 2 or 3 similar methods, I wrote only one that can be wired to have different results. If you don't want your vec to be changed, send a different one via the "dest" parameter. If you don't mind your vec changed, call the method with vec on both parameters.

You can call it with an anonymous object if you want since it returns the result. (ie, norm = normalize( vec, new Vector3f() ) ).

I don't think its the most performant implementation. It probably can't be used freely with some operations (matrix multiplication of the top of my head) but it does what I wanted to in a single method instead of using more.

What do you mean about if I'm sure? I don't remember C++ syntax (probably missing a :: or something like that) The complete method is this one:

public static DataArrayFloat normalize3f ( DataArrayFloat vec, DataArrayFloat dest )
{
float[] vecArray = vec.getArray(),
destArray = dest.getArray();
 
float norm = 1.0f / (float)(Math.sqrt(vecArray[0] * vecArray[0] + vecArray[1] * vecArray[1] + vecArray[2] * vecArray[2]));
 
destArray[0] = vecArray[0] * norm;
destArray[1] = vecArray[1] * norm;
destArray[2] = vecArray[2] * norm;
 
return dest;
}

Anyway, why specifically do you need operator overloading for a normalize function? I reckon addition and substraction operators come in handy (see up there, no power ^ operator either heh) but I don't see its use for normalization.