Multiplication à virgule fixe dans une plage connue

Question

J'essaie de multiplier A*B par un point fixe de 16 bits, tout en conservant la plus grande précision possible. A est 16 bits dans la plage d'entiers non signés, B est divisé par 1000 et toujours entre 0.001 et 9.999. Cela fait un moment que je traite de problèmes comme ça, donc:

• Je sais que je peux faire A*B/1000 après le déplacement des variables 32 bits, bande retour à 16 bits
• Je voudrais rendre plus rapide que celle
• Je voudrais faire toutes les opérations sans passer à 32 bits (depuis que j'ai multiplication 16 bits uniquement)

est-il un moyen facile de le faire?

Éditer: A sera entre 0 et 4000, de sorte que tous les résultats possibles sont également dans la plage de 16 bits.

Modifier: B vient de l'utilisateur, définir chiffre par chiffre dans le masque X.XXX, c'est pourquoi l'opération est /1000.

Answer 1

Non, vous devez aller à 32 bits. En général, le produit de deux nombres de 16 bits vous donnera toujours un résultat de 32 bits.

Vous devez vérifier le jeu d'instructions CPU de la CPU sur laquelle vous travaillez car la plupart des instructions de multiplication sur les machines 16 bits ont une option pour renvoyer le résultat sous la forme d'un entier 32 bits directement.

Cela vous aidera beaucoup parce que:

short testfunction (short a, short b) 
{ 
    int A32 = a; 
    int B32 = b; 

    return A32*B32/1000 
} 

forcerait le compilateur à faire un 32bit * 32bit se multiplient. Sur votre machine, cela peut être très lent ou même effectué en plusieurs étapes en utilisant uniquement des multiplicateurs 16 bits.

Un peu d'assemblage en ligne ou même mieux un intrinsèque du compilateur pourrait accélérer beaucoup les choses.

Voici un exemple pour le Texas Instruments C64x + DSP qui a des valeurs intrinsèques:

short test (short a, short b) 
{ 
    int product = _mpy (a,b); // calculates product, returns 32 bit integer 
    return product/1000; 
} 

Une autre pensée: Vous divisant par 1000. Était-ce votre choix constant? Il serait beaucoup plus rapide d'utiliser une puissance de deux comme base pour vos nombres à virgule fixe. 1024 est proche. Pourquoi pas vous:

return (a*b)/1024 

à la place? Le compilateur pourrait optimiser ceci en utilisant un décalage à droite de 10 bits. Cela devrait être beaucoup plus rapide que de faire des tours de multiplication réciproques.