https://en.cppreference.com/w/cpp/numeric/math/copysign

. This flips the sign of lhs if rhs is negative, it doesn't set lhs's sign to rhs's sign.

This is known as the projection. The result is the component of lhs that was parallel to rhs.

 If you wanted to steal math notation, they denote the projection of u onto v as

 Alright then. I suppose in 1D projection and scalar projection are necessarily identical, "Project" works. This also lets the description piggyback off of the concept of projection, which is a kind of perspective.

 whoops, didn't read the full description.

yah, this is just the 1D (scalar) projection. Nothing special

Well, by a software engineering perspective, I think it's kinda a shitty operator... 

ConditionalSignAlignment(float num, boolean condition)

Speed = ConditionalSignAlignment(Speed, signAgreement (Speed, speed2);

 C# has a feature called extension methods. By putting 

 in front of the first parameter of a method, you can call it directly from an instance of that parameter's type. That means as long as the namespace is imported, you can call it from any 

If you think about it, this is kinda what a method is. It's just a function with an implicit parameter.

 how can you do a.Project(b)? Do you have a custom class named Speed?

Anyway I think a.Project(b) is clean, using a class for Speed

 There are a lot of noncommutative functions out there. Like the one I ended up naming the function after, projection. 

. I'd say breaking up a function like this should be the last thing you consider, after naming the parameters something indicative of its noncommutativeness, and documenting it, as it will have the most impact on how the code is actually written.

 well, I agree about the 0. Then from your request I got thay you wanted to make a method for the sign flip, but I do agree that is an over-engineering. But I don't think your method is a best practice: by having a method with 2 floats parameters in which the order matters, it's too hard to find a name that tells the client, that wants to use the method, what the 2 parameters represents and that the order matters.

In the solution I suggested you don't have  this confusion: signAgreement(floats) gets 2 floats, no matter the order, the second method gets two parameters of different type. To me the client should never need to open the method to understand what it does, neither read any comments for such a small method.

First function: So useful I've already written it. (Except it's DifferentSign for contextual reasons.)

Second function: Probably easier just to write the contents of the method at that point.

The two together: No sane programmer is going to write this over 

As a bonus, your method also has a bias towards flipping the sign at 0.

This relatively simple operation has been remarkably difficult for me to define.

float Foo(this float lhs, float rhs) => lhs * rhs.Sign();

It is intended to reframe lhs in the context of rhs's direction. For example, determining how much of the velocity of a videogame character is in the same direction as the player's input.

It serves a similar function to a scalar projection in one dimension.

Ṁ20 - I want a name that will be reasonably memorable, and short.

Ṁ30 - I want a simple one-sentence description that provides a perspective to think about it from, rather than just explaining what it does. (Similar to how one thinks of matrix multiplications as affine transformations, and not just a load of dot products.)

Related questions