Difference between revisions of "User talk:Voidious/Optimal Velocity"
(Added interesting test with Skillgannon's code.) |
RednaxelaBot (talk | contribs) m (Using <syntaxhighlight>.) |
||
| (2 intermediate revisions by 2 users not shown) | |||
| Line 1: | Line 1: | ||
I did a quick one-liner which gives almost exactly the same results as your getMaxVelocity(distance): | I did a quick one-liner which gives almost exactly the same results as your getMaxVelocity(distance): | ||
| − | < | + | <syntaxhighlight> |
private static final double maxVel(double distance){ | private static final double maxVel(double distance){ | ||
return Math.floor((Math.sqrt(1 + 4*2/Rules.DECELERATION*distance) - 1)); | return Math.floor((Math.sqrt(1 + 4*2/Rules.DECELERATION*distance) - 1)); | ||
} | } | ||
| − | </ | + | </syntaxhighlight> |
The difference is that mine gives integer results, rather than all the 0.5s 0.33333s 0.25s and 0.666667s. | The difference is that mine gives integer results, rather than all the 0.5s 0.33333s 0.25s and 0.666667s. | ||
| Line 95: | Line 95: | ||
Your solution and Voidious's one seem to preform about the same. Interesting. :) By the way, I did adjust your function to: | Your solution and Voidious's one seem to preform about the same. Interesting. :) By the way, I did adjust your function to: | ||
| − | < | + | <syntaxhighlight> |
private static final double maxVel(double distance){ | private static final double maxVel(double distance){ | ||
if(distance<0) | if(distance<0) | ||
| Line 103: | Line 103: | ||
return Math.floor((Math.sqrt(1 + 4*2/Rules.DECELERATION*distance) - 1)); | return Math.floor((Math.sqrt(1 + 4*2/Rules.DECELERATION*distance) - 1)); | ||
} | } | ||
| − | </ | + | </syntaxhighlight> |
Otherwise it gives nextVel=0.0 on distance==0.6. --[[User:Positive|Positive]] 10:50, 16 July 2009 (UTC) | Otherwise it gives nextVel=0.0 on distance==0.6. --[[User:Positive|Positive]] 10:50, 16 July 2009 (UTC) | ||
| + | |||
| + | To tell the truth, I actually like the results Voidious's version gives better, as it keeps a slightly higher velocity the whole way through to minimise any possible gap at the end. =) I've made a simplified version of the whole predictor based on your ideas, I'll post it just now. --[[User:Skilgannon|Skilgannon]] 11:19, 16 July 2009 (UTC) | ||
| + | |||
| + | Wow, that's pretty neat. While I know that, theoretically, you don't need to go max speed in every case, it's become a warning sign to me of a probable bug in solutions to this problem. For instance, for d=19.9, yours gives v=7, which will cause an extra tick (7, 6, 4, 2, d=0.9 remaining). Nevertheless, pretty cool. You darn students and your non-rusty math chops! =) --[[User:Voidious|Voidious]] 14:07, 16 July 2009 (UTC) | ||
Latest revision as of 09:43, 1 July 2010
I did a quick one-liner which gives almost exactly the same results as your getMaxVelocity(distance):
private static final double maxVel(double distance){
return Math.floor((Math.sqrt(1 + 4*2/Rules.DECELERATION*distance) - 1));
}The difference is that mine gives integer results, rather than all the 0.5s 0.33333s 0.25s and 0.666667s.
Distance Skilgannon Voidious 0 0.0 0.0 1 1.0 1.0 2 2.0 2.0 3 2.0 2.5 4 3.0 3.0 5 3.0 3.5 6 4.0 4.0 7 4.0 4.333333333333333 8 4.0 4.666666666666667 9 5.0 5.0 10 5.0 5.333333333333333 11 5.0 5.666666666666667 12 6.0 6.0 13 6.0 6.25 14 6.0 6.5 15 6.0 6.75 16 7.0 7.0 17 7.0 7.25 18 7.0 7.5 19 7.0 7.75 20 8.0 8.0
--Skilgannon 10:00, 16 July 2009 (UTC)
Hey Skilgannon, I did a test with your one-liner with the formula's on Positive/Optimal Velocity:
StartVelocity = 0.0; StartDistance = 6.0;
velocity = 0.0; distance=6.0 velocity = 1.0; distance=5.0 velocity = 2.0; distance=3.0 velocity = 2.0; distance=1.0 velocity = 1.0; distance=0.0
StartVelocity = 0.0; StartDistance = 10.0;
velocity = 0.0; distance=10.0 velocity = 1.0; distance=9.0 velocity = 2.0; distance=7.0 velocity = 3.0; distance=4.0 velocity = 3.0; distance=1.0 velocity = 1.0; distance=0.0
StartVelocity = -1.9; StartDistance = 10.0;
velocity = -1.9; distance=10.0 velocity = 0.10000000000000009; distance=9.9 velocity = 1.1; distance=8.8 velocity = 2.1; distance=6.700000000000001 velocity = 3.1; distance=3.600000000000001 velocity = 2.0; distance=1.600000000000001 velocity = 1.600000000000001; distance=0.0
StartVelocity = 8.0; StartDistance = -2.0;
velocity = 8.0; distance=-2.0 velocity = 6.0; distance=-8.0 velocity = 4.0; distance=-12.0 velocity = 2.0; distance=-14.0 velocity = -0.0; distance=-14.0 velocity = -1.0; distance=-13.0 velocity = -2.0; distance=-11.0 velocity = -3.0; distance=-8.0 velocity = -4.0; distance=-4.0 velocity = -3.0; distance=-1.0 velocity = -1.0; distance=0.0
StartVelocity = 5.0; StartDistance = 40.0;
velocity = 5.0; distance=40.0 velocity = 6.0; distance=34.0 velocity = 7.0; distance=27.0 velocity = 8.0; distance=19.0 velocity = 7.0; distance=12.0 velocity = 6.0; distance=6.0 velocity = 4.0; distance=2.0 velocity = 2.0; distance=0.0
Your solution and Voidious's one seem to preform about the same. Interesting. :) By the way, I did adjust your function to:
private static final double maxVel(double distance){
if(distance<0)
return -maxVel(-distance);
if(distance<=Rules.DECELERATION)
return distance;
return Math.floor((Math.sqrt(1 + 4*2/Rules.DECELERATION*distance) - 1));
}Otherwise it gives nextVel=0.0 on distance==0.6. --Positive 10:50, 16 July 2009 (UTC)
To tell the truth, I actually like the results Voidious's version gives better, as it keeps a slightly higher velocity the whole way through to minimise any possible gap at the end. =) I've made a simplified version of the whole predictor based on your ideas, I'll post it just now. --Skilgannon 11:19, 16 July 2009 (UTC)
Wow, that's pretty neat. While I know that, theoretically, you don't need to go max speed in every case, it's become a warning sign to me of a probable bug in solutions to this problem. For instance, for d=19.9, yours gives v=7, which will cause an extra tick (7, 6, 4, 2, d=0.9 remaining). Nevertheless, pretty cool. You darn students and your non-rusty math chops! =) --Voidious 14:07, 16 July 2009 (UTC)
