Runden auf 0 bzw. 5

[Florian M. (flomll)]

Habe lange gesucht, jedoch nichts wirklich brauchbares gefunden.

Wie kann man einen Wert auf 0 bzw. 5 runden? Notwendig ist dabei, dass 
ich gezielt auf bzw. abrunden kann.

Beispiele:

Rechtsdrehen -> (aufrunden)
41 auf 45
42 auf 45
43 auf 45
44 auf 45
45 auf 45

46 auf 50
47 auf 50
48 auf 50
48 auf 50
49 auf 50
50 auf 50

Linksdrehen -> (abrunden)
41 auf 40
42 auf 40
43 auf 40
44 auf 40
45 auf 40

46 auf 45
47 auf 45
48 auf 45
48 auf 45
49 auf 45
50 auf 45

Das ganze ist für eine Steuerung mit eine berührungssensitiven Kreis.

[Noah (Gast)]

integerdivision durch 5 und dann wieder mit 5 multiplizieren?

für den aufruden-fall dann noch 5 hinzuaddieren.

[Florian M. (flomll)]

So schnell kanns gehen! :-)

Habe jetzt doch eine Lösung gefunden, die ich euch natürlich nicht 
vorenthalten will.


Rechtsdrehen:

U16 roundup05(U16 val){
  double temp = (double)(val/10.0);  // transform in to floating point value
  temp = temp * 2;
  return (U16)((ceil(temp)/2)*10);
}

U16 rounddown05(U16 val){
  double temp = (double)(val/10.0);  // transform in to floating point value
  temp = temp * 2;
  return (U16)((floor(temp)/2)*10);

}

[Turbo J (Gast)]

Dazu eignet sich der Divisionsrest, auch Modulo genannt.
Aufrunden:

i+=4;
i-= i%5;

Abrunden normal:

i-=i%5;

Dein etwas merkwürdig spezifiziertes "Abrunden":

i-=1;
i-=i%5;

[Florian M. (flomll)]

@ Noah: Wäre zwar eine sehr gute Lösung, jedoch bei runden Zahlen würde 
er um 5 weiter springen.

Beispiel: (falsch)
40 / 5 = 8

8 * 5 = 40

40 + 5 = 45

Beispiel: (richtig)

40 -> 40

[vip (Gast)]

Noah schrieb:
> integerdivision durch 5 und dann wieder mit 5 multiplizieren?
>
> für den aufruden-fall dann noch 5 hinzuaddieren.

Fast. 4 gehören davor dazuaddiert.

Florian Müller schrieb:
> Beispiel: (richtig)
>
> 40 -> 40

40+4=44
44/5=8
8*5=40

41+4=45
45/5=9
9*5=45

unsigned int myceil (unsigned int c){
    return (((c+4)/5)*5);
}

unsigned int myfloor (unsigned int c){
    return ((c/5)*5);
}

Florian Müller schrieb:
> U16 roundup05(U16 val){
>   double temp = (double)(val/10.0);  // transform in to floating point value
>   temp = temp * 2;
>   return (U16)((ceil(temp)/2)*10);
> }
>
> U16 rounddown05(U16 val){
>   double temp = (double)(val/10.0);  // transform in to floating point value
>   temp = temp * 2;
>   return (U16)((floor(temp)/2)*10);
>
> }

Float und math.h auf µC? Dann doch lieber meine Lösung oder die von 
Turbo. Nur die Compileroptimierung solltes du berücksichtigen, die 
könnte bei meiner Lösung auf die Idee kommen, die Division und die 
Multiplikation rauszukürzen.