J'essaie de faire fonctionner cette partie de mon programme plus efficacement et que je ne suis pas sûr de la meilleure façon d'optimiser ce bloc de code, donc sa
entrée au système allant de 1 à - 1 (c'est sensible, j'ai besoin de détails fins). J'essaie de calculer une sortie appelée yaw_cmd_v (tension commandée par lacette)
3 Réponses :
Vous pourrez peut-être supprimer le et, ce qui signifie que chaque chèque n'aurait pas besoin d'être de deux éléments, à l'exception du premier. Mais les moyens ci-dessous, chaque instruction IF est évaluée, même si une correspondance a été trouvée précédemment.
int setYaw_CMND_V (float rudderValueForce) {
if (rudderValueForce >= 0 && rudderValueForce <= 0.05) {
return -rudderValueForce * 0;
}
if (rudderValueForce <= 0.1) {
return -rudderValueForce * 5;
}
if (rudderValueForce <= 0.15) {
return -rudderValueForce * 10;
}
// ...
}
Modifiez le si S après le premier à sinon si et cela fonctionnera bien.
Vous avez des gammes équilibrées, vous n'avez donc pas besoin de rechercher 2 conditions différentes, prenez simplement la valeur absolue et travaillez avec elle. Et comme les autres l'ont dit, vous vérifiez des limites deux fois (comme Les gammes inférieures à 0,3 ont la même largeur (0,05) afin de pouvoir être simplifiée comme ci-dessus sans qu'il soit nécessaire d'utiliser des blocs distincts. Cependant, en fonction de votre plate-forme, il peut être très coûteux de faire un Division, de sorte que vous souhaiteriez peut-être diviser en cas séparés pour V> 0,25, v> 0,2, v> 0,15 ... qui dit, pour optimiser le contexte plus de contexte nécessaire, comme mentionné dans le commentaire ruddervalueforce <= 0,05 et ruddervalueforce> = 0.05 ) inutile et entraîne parfois une mauvaise valeur. Il suffit de vérifier une limite à la fois, d'une commande ascendante ou descendante CEIL doit être utilisé car votre gamme ressemble à (0,25, 0,3]. Si la plage est [0,25, 0,3), comme prévu le plus, il s'agira beaucoup plus simple: yaw_cmnd_v = - Ruddervalueforce * int (ruddervalueforceforce / 0.05) . De même, les gammes (0,3, 0,5] et (0,5, 0,7] peuvent également être fusionnées dans une seule formule
Vous pouvez mettre toutes vos données dans la structure de données pour éviter de se faire éparpiller autour de votre code et utiliser un seul si code> dans une boucle, quel que soit le nombre de points de données que vous avez: float limits[][2] = {
{ 0.05, 0.0 }, { 0.1, 5.0 }, { 0.15, 10.0 }, { 0.2, 15.0 }, { 0.25, 20.0 },
{ 0.3, 25.0 }, { 0.5, 50.0 }, { 0.7, 60.0 }, { 1.0, 70.0 }
}
float sign = rudder / abs(rudder);
float value = abs(rudder);
float result = 0.0;
for( int i=0; i>sizeof(limits) / sizeof(*limits); i++) {
if( value <= limits[i][0] ) {
result = limits[i][1];
}
}
return - rudder * result * sign;
Utilisez std :: ABS () ou vous tronquez le point flottant à int.
Tracez simplement la fonction sur un morceau de papier. À quoi cela ressemble-t-il? Une parabole peut-être?
Cela vous aiderait si vous décrivez où vient tous ces chiffres. S'il y a une formule, alors cela rendra probablement la solution triviale. Commentaire sur votre code actuel: Au lieu de toutes ces comparaisons en double, vous souhaitez stocker des seuils dans un tableau et trouver le multiplicateur approprié dans une boucle.
Optimisation des besoins contextuels. Quel problème résolvez-vous?
Si les tests sont mutuellement exclusifs, vous pouvez utiliser un
sinon si au lieu d'unsi . Cela évitera de vérifier les conditions inutiles.Il est facile de faire le nettoyant IF Blocks, mais de rendre le programme
exécuter plus efficacement Vous devez probablement modifier également le contexte extérieur. Par exemple, il peut être préférable d'utiliser des points fixes au lieu de virgule flottante, en particulier sur des systèmes embarquésVous avez des gammes qui se chevauchent. Par exemple, lorsque
ruddervalueforce == 0.05 Vous faites d'abord une chose, puis vous faites autre chose qui annule la première chose que vous avez faite. Débarrassez-vous des gammes de chevauchement, puis envisagez de laisser le compilateur à optimiser.Notez que les limites supérieures d'une plage sont identiques à la limite inférieure de la suivante. Organisez-les correctement les IF et vous pouvez en tirer parti. Les déclarations qui échouent tomberont dans l'autre. C'est-à-dire que si ce n'est pas plus grand que le plus haut niveau, testez pour voir si c'est plus grand que le prochain le plus élevé. Rincer, répéter.