Question d'optimisation C#

C’est une question quasi triviale. Ou pas. Supposons le code suivant, qui est amené a être appellé très très souvent, x, y et z étant de type float:

int X = (int)Math.Floor(x) & 255;
int Y = (int)Math.Floor(y) & 255;
int Z = (int)Math.Floor(z) & 255;

x -= (float)Math.Floor(x);
y -= (float)Math.Floor(y);
z -= (float)Math.Floor(z);

Est ce que le code suivant est équivalent et optimisé (j’ai lu ca et la qu’on pouvait procéder de la manière suivante, j’aimerai un avis des gourous de la zone)?

int X = (int)x & 255;
int Y = (int)y  & 255;
int Z = (int)z & 255;

x -=  (float)(int)x;
y -= (float)(int)y;
z -=  (float)(int)z;

Et pour les curieux, ce code provient de: http://mrl.nyu.edu/~perlin/noise/ (une implémentation Java du Perlin Noise, que j’ai déjà adapté en C#, mais que j’aimerai encore plus optimiser).

J’aurais tendance a dire que le floor est pas necessaire vu que tu fais le cast en int obligatoirement, et que le cast doit juste clamper a la partie entiere (donc floor).

Mon petit doigt me dit que le Math.Floor ne sert à rien. (et la seconde solution est donc logiquement plus rapide).

En mieux:

int xi = (int) x;
int yi = (int) y;
int zi = (int) z;

int X = xi &255;
int Y = yi &255;
int Z = zi &255;

x -= xi;
y -= yi;
z -= zi;

Pinaillage pas rapport au reste de la methode de calcul (fad et lrep seront largement plus couteuse).

Je suis approximativement sur que ce code sert à faire un genre de modulo pour effectuer une répétition sur le bruit initial de la table de permutation du perlin noise. J’avais aussi pensé à ta solution, Trevidos, qui me semble encore faire moins d’opérations. Je testerai ce soir. (Tout le reste du code est des opérations arithmétique de base sur des flottants inlinés, je pense pas que je puisse y gagner encore quelque chose… sauf à développer / factoriser à la mano…).