It's all well and good to have a library with fast sin/cos/tan functions, but always remember to cheat if you can.

For instance, in a game, it's common to have a gun/spell or whatever that shoots enemies in a cone shape. Like a shotgun or burning hands. One way to code this is to calculate the angle between where you're pointing and the enemies, (using arccos) and if that angle is small enough, apply the damage or whatever.

A better way to do it to take the vector where the shotgun is pointing, and the vector to a candidate enemy is, and take the dot product of those two. Pre-compute the cosine of the angle of effect, and compare the dot product to that -- if the dot product is higher, it's a hit, if it's lower, it's a miss. (you can get away with very rough normalization in a game, for instance using the rqsrt instruction in sse2) You've taken a potentially slow arccos operation and turned it into a fast handful of basic float operations.

Or for instance, you're moving something in a circle over time. You might have something like

    float angle = 0
    for (...)
      angle += 0.01
      <something with sin(angle) cos(angle)>

Instead, you might do:

    const float sin_dx = sin(0.01)
    const float cos_dx = cos(0.01)
    float sin_angle = 0
    float cos_angle = 1
    for (...)
      const float new_sin_angle = sin_angle * cos_dx + cos_angle * sin_dx
      cos_angle = cos_angle * cos_dx - sin_angle * sin_dx
      sin_angle = new_sin_angle

And you've replaced a sin/cos pair with 6 elementary float operations.

And there's the ever popular comparing squares of distances instead of comparing distances, saving yourself a square root.

In general, inner loops should never have a transcendental or exact square root in them. If you think you need it, there's almost always a way to hoist from an inner loop out into an outer loop.