Java：在忽略符号的同时执行数学运算

Question

I am trying to make a game involving the calcualtion of forces needed to perform some simple mathematical operations. I have a dx variable that represents both the speed and direction along the X-axis. Now I want to subtract friction but it would have to be an addition if the direction of dx is negative. Is there any way to subtract friction from dx using absolute values while returning a signed value? I was looking in to bitwise operators but I have no idea what the possibilities are...

What I could do (i think):

sign = ( dx >> 31 ) << 31;
dx = (dx << 1) >> 1;
dx = ( dx - friction ) & sign;

Not sure if this would work, just the idea... Any improvements?

Edit: this is what I did:

dxSign = Integer.signum(dx) * -1;
dySign = Integer.signum(dy) * -1;
dy = Math.abs(dy);
dx = Math.abs(dx);

fric = body.friction * mass;

dx = ( dx > fric ) ? dx - fric : 0;
dy = ( dy > fric ) ? dy - fric : 0;

dx = dx * absorption;
dy = dy * absorption;

dx *= dxSign;
dy *= dySign;

Answer 1

The safest option is to use a condition. You don't want fraction to change direction

dx = dx < -friction ? dx + friction : dx > friction ? dx - friction : 0

Answer 2

Your code is incorrect, for two reasons:

• dx = (dx << 1) >> 1; does not eliminate the sign. Moreover, it may incorrectly produce a "false positive" (ie a falsely negative number) when bit 31 is set to 1 . Even if you replace >> with >>> you would not get an absolute value, because int s are stored in two's complement, not as a sign + value representation
• sign will be either a 10000...00 or 00000..00 in binary representation, so ( dx - friction ) & sign will not merge the sign with the results of the other calculation.

You can change the addition for subtraction with the Integer.signum function, like this:

dx -= Integer.signum(dx) * friction;

Answer 3

Just do it the obvious way: don't try to be clever unless this has performance issues.

if(dx >0 ) {
    dx -= friction;
} else {
    dx += friction;
}

If that seems a bit verbose, hide it in a method:

dx = applyFriction(dx,friction);

int applyFriction(int pos, int friction) {
     if(pos > 0) {
           return pos - friction;
     } else {
           return pos + friction;
     }
}

This has issues when abs(pos) < friction , and if you look into your physics, you'll find it's more likely that friction is simulated by multiplying - which removes your concern about sign.

Answer 4

Use Math.abs when you want to ignore the sign. Be aware that optimization might result in your code becoming unreadable and difficult to maintain. So, for starters try to make your code as clean and possible and when you encounter performance issues, determine the source of your problem by benchmarking and optimize only the bottleneck of your code.

Answer 5

In physics, the sign of your direction doesn't really matter. I suggest using the fact that the kinetic friction is a force which is proportional to absolute velocity of the object in motion. That is, the object has some coefficient of friction μ F in the range [0, 1] . The change in velocity is just δ = μ F ∙ ∙δ where V is the initial velocity vector of your object, and δ is some span of time.

The new velocity V' is given by

 =  - δ
   =  - μF∙∙δt
   = (1 - μF∙δt)

In this way, you don't need to deal with the sign at all, and it extends easily into higher dimensional cases.

As an aside, make sure δ _t is small enough that it doesn't introduce an oscillation in your model.