µC 8bits => arrondir valeur (avis aux experts)

Version imprimable

26/11/2008, 09h41
Emcy

µC 8bits => arrondir valeur (avis aux experts)

bonjour,

Je programme sur un µControlleur 8 bits (PIC18 de chez microchip) : mes ressources sont donc très limitées.

Je dois arrondir au millier des valeurs qui sont entre 1 000 et 100 000 (donc stocké dans une variable de 4 octets) => ex : 1 024 => 1 000; 5 950 => 6 000.
=> une fois la valeur arrondi, je dois la diviser par 1 000 pour avoir mon résultat final => ex : 50 000 => 50.

Quel est le meilleur algo pour faire mon arrondi ?

Remarque : la valeur à arrondir est le résultat d'une multiplication d'un nombre K (compris entre 2 et 195) par 512. K ne prend pas n'importe quelle valeur : la valeur à arrondir est proche à ±2.5% (max) de la valeur arrondi (le résultat).
26/11/2008, 10h07
3DArchi

Ma question va peut être paraître stupide, mais pourquoi arrondir avant de diviser? Ta division entière va de facto arrondir ta valeur?
26/11/2008, 10h23
Emcy

parce que si tu fais (49 900 / 1000), tu auras comme résultat 49 au lieu de 50 (je ne travaille pas avec des virgules flottantes à cause de mon µC).

Par contre au lieu de faire K * 512 / 1000, il est peut être plus judicieux de faire K / CONST avec CONST = 1000/512 = 1.953125 ...
26/11/2008, 10h30
ram-0000

(49000 + (1000/2)) / 1000 te donneras 49
(49499 + (1000/2)) / 1000 te donneras 49
(49500 + (1000/2)) / 1000 te donneras 50
(49900 + (1000/2)) / 1000 te donneras 50
(50499 + (1000/2)) / 1000 te donneras 50
(50500 + (1000/2)) / 1000 te donneras 51

Citation:

Envoyé par Emcy

bonjour,

Je programme sur un µControlleur 8 bits (PIC18 de chez microchip) : mes ressources sont donc très limitées.

Je dois arrondir au millier des valeurs qui sont entre 1 000 et 100 000 (donc stocké dans une variable de 4 octets) => ex : 1 024 => 1 000; 5 950 => 6 000.
=> une fois la valeur arrondi, je dois la diviser par 1 000 pour avoir mon résultat final => ex : 50 000 => 50.

Quel est le meilleur algo pour faire mon arrondi ?

Remarque : la valeur à arrondir est le résultat d'une multiplication d'un nombre K (compris entre 2 et 195) par 512. K ne prend pas n'importe quelle valeur : la valeur à arrondir est proche à ±2.5% (max) de la valeur arrondi (le résultat).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
#include <stdio.h>
#define N(a)(sizeof(a)/sizeof*(a))
int main (void)
{
   unsigned long a[] = {
      1000,
      4999,
      5000,
      5001,
      49999,
      50000,
      50001,
      99999,
      100000,
   };
 
   {
      size_t i;
      for (i = 0; i < N (a); i++)
      {
         printf ("%8lu", a[i]);
      }
      printf ("\n");
   }
 
   {
      size_t i;
      for (i = 0; i < N (a); i++)
      {
         printf ("%8lu", a[i]/1000);
      }
      printf ("\n");
   }
 
   {
      size_t i;
      for (i = 0; i < N (a); i++)
      {
         printf ("%8lu", (a[i]+1)/1000);
      }
      printf ("\n");
   }
 
   return 0;
}

Code:

1
2
3
4
5
6
7
 
    1000    4999    5000    5001   49999   50000   50001   99999  100000
       1       4       5       5      49      50      50      99     100
       1       5       5       5      50      50      50     100     100
 
Process returned 0 (0x0)   execution time : 0.042 s
Press any key to continue.

26/11/2008, 11h32
Emcy

Emmanuel , il me semble que ton système ne fonctionne pas sur les nombres...

la solution de ram-0000 est pour le moment la meilleure...
... cependant je me demande si ça ne serait pas plus simple de directement faire K / 1.953125 ça eviterait peut-être d'utiliser une variable de 4 octets et donc gagner en perf...
26/11/2008, 11h46
3DArchi

Citation:

Envoyé par Emcy

cependant je me demande si ça ne serait pas plus simple de directement faire K / 1.953125 ça eviterait peut-être d'utiliser une variable de 4 octets et donc gagner en perf...

Là tu n'est plus en opération entière. En général, les perfs sont moins bonnes.
26/11/2008, 13h57
Emcy

ok merci