itoa durch Shiftoperatoren - möglich?

[Sven (Gast)]

Hi Leute!

Ist es möglich eine Art von itoa mittels Shiftoperationen zu machen?

Ich merke schon deutlich einen Speicherplatzunterschied wenn ich z.B. 
anstatt durch 32 teilen einen Rechtsshift um 5 mache. Das macht bei mir 
hier gerade einen Unterschied von 268 Byte aus (mein Controller hat 2k).

Ich habe hier meine eigene Funktion

void integer_to_single_numbers( int16_t source_number, uint8_t *dest_buffer )
{ 
  if( source_number < 0 )
  {
    shift_reg_control.display__sign = SIGN_NEGATIVE;
    source_number *= -1;
  }
  else
  {
    shift_reg_control.display__sign = NO_SIGN;
  }
  
  dest_buffer[0] = (source_number / 1000);
  source_number %= 1000;
  dest_buffer[1] = (source_number / 100);
  source_number %= 100;
  dest_buffer[2] = (source_number / 10);
  dest_buffer[3] = (source_number % 10);
}

die mir Zahlen in ihre Einzelteile zerlegt. Gibt es denn irgendeine 
Möglichkeit auch zu einer Zehnerpotenz ähnliches anzuwenden?

[Sven (Gast)]

Nachtrag: Nimmt eine Multiplikation mit -1 auch verhältnismäßig mehr 
Speicher weg als eine Addition? Geht das auch anders?

[Harglbar (Gast)]

Optimierung ausgeschaltet? Der Compiler benutzt automatisch Shifts, wenn 
Zweierpotenzen im Spiel sind.

Wenn du Platz sparen willst, lass es lieber für solch triviale Sachen 
Structs zu benutzen.

Und nein, Shifts im Binärsystem bringen dir nichts im Dezimalsystem.

[(prx) A. K. (prx)]

Sven schrieb:

> Ist es möglich eine Art von itoa mittels Shiftoperationen zu machen?

Nur wenn die Basis eine Zweierpotenz ist.

[Heinz L. (ducttape)]

Divisionen sind teuer. Aber das wirst Du auch schon festgestellt haben. 
In Assembler ließe sich sowas noch mehr optimieren, aber hast du mal 
etwas im Stil von dem da probiert:

void itoa (unsigned int input, char* digits)
//digits muss ein Array sein das hinreichend groß ist.
{
unsigned char ucplace=0;
unsigned int uidiv;

while (ucplace<MAXDIGITS)
{
  switch (ucplace)
  {
    case 0:
    {
      uidiv=10000;
      break;
    }
    case 1:
    {
      uidiv=1000;
      break;
    }
    ...//Die restlichen Zuweisungen, bis runter zu case 4: uidiv=1;
  }
  
  while (input >= uidiv)
  {
    input -= uidiv;
    digits[ucplace]++;
  }
}
return;
}

Hab ich jetzt nur mal runtergeschrieben und nicht ausprobiert, aber die 
Idee ist, so lang die höchste 10er Potenz abzuziehen (und die Anzahl zu 
zählen) bis der Rest kleiner ist, dann die nächstniedrigere 10er Potenz 
zählen usw.

Sollt klappen, schneller sein und weniger Platz fressen. In ASM könnte 
man hier noch einiges mehr optimieren... ich guck mal ob ich Zeit finde, 
brauchen kann man sowas bekanntlich immer mal.

[Peter D. (peda)]

Zahlenausgabe schnell und codesparend, da ist die Subtraktionsmethode 
optimal:

void outint( int val )
{
  uint code TEST[] = { 10, 100, 1000, 10000 };
  uchar d, i;
  bit zero;
  uint uval = val;

  if( val < 0 ){
    uval = -val;
    putchar( '-' );
  }

  zero = 1;
  i = 4;
  do{
    i--;
    for( d = '0'; uval >= TEST[i]; uval -= TEST[i] ){
      d++;
      zero = 0;
    }
    if( zero == 0 )
      putchar( d );
  }while( i );

  putchar( (uchar)uval + '0' );
}

Peter

[Oliver (Gast)]

Harglbar schrieb:
> Optimierung ausgeschaltet? Der Compiler benutzt automatisch Shifts, wenn
> Zweierpotenzen im Spiel sind.

Hm. Von welcher Firma ist denn das Produkt "Der Compiler"?
Das sollten man schon wissen, bevor man solche Aussagen trifft.

Eine Optimierung, soweit vorhanden, sollte man aber schon einschalten.

Oliver

[bitshift (Gast)]

Sven schrieb:
> Nachtrag: Nimmt eine Multiplikation mit -1 auch verhältnismäßig mehr
> Speicher weg als eine Addition? Geht das auch anders?

ZAHL = ~(ZAHL)+1

bzw

ZAHL = ~(ZAHL-1)

[(prx) A. K. (prx)]

Sven schrieb:
>     source_number *= -1;

Sven schrieb:
> Nachtrag: Nimmt eine Multiplikation mit -1 auch verhältnismäßig mehr
> Speicher weg als eine Addition? Geht das auch anders?

bitshift schrieb:
> ZAHL = ~(ZAHL-1)

Soll ich jetzt lachen oder weinen?

[Sven (Gast)]

Hi und danke!

Ich habe es jetzt mit der Subtraktion implementiert und wieder 132Byte 
gespart. Super!

void integer_to_numbers( int16_t source_number, uint8_t *dest_buffer )
{
  uint16_t test_val[4] = { 1000, 100, 10, 1 };
  uint16_t temp_val;
  uint8_t count, number;
  
  temp_val = source_number;
  shift_reg_control.display__sign = NO_SIGN;
  
  if( source_number < 0 )
  {
    shift_reg_control.display__sign = SIGN_NEGATIVE;
    temp_val = -source_number;
  }
  
  count = 0;
  
  do
  {    
    for( number = 0; temp_val >= test_val[count]; temp_val -= test_val[count] )
    {
      number++;
    }
    
    dest_buffer[count] = number;  
    count++;
    
  } while( count < 4 );
}

[Sven (Gast)]

Ach ja: Ich benutze den IAR Compiler. Optimierungen habe ich persönlich 
jetzt nicht eingestellt. Zumindest habe nichts verändert.

[Sven (Gast)]

Wie geht denn das mit den Optimierungen? Ich find nichts im Netz.

[Sven (Gast)]

Harglbar schrieb:
> Wenn du Platz sparen willst, lass es lieber für solch triviale Sachen
> Structs zu benutzen.

Verbrauchen structs mehr Platz als einzelne Variablen?

[MaWin (Gast)]

> wieder 132Byte gespart.

void integer_to_numbers(int16_t source_number, uint8_t *dest_buffer)
{
    char *buf[6];

    if(source_number<0) 
    { 
        *dest_buffer++='-'; 
        source_number=-source_number; 
    }
    buf[i=5]='\0'; // terminiert nachher den dest_buffer
    do // immer mindestens eine 0
    {
       buf[--i]=source_number%10;
       source_number/=10;
    }
    while(source_number); // kann auch 5 Stellen, führende 0 unterdrückt
    while(i<=5)
    {
        *dest_buffer++=buf[i++];
    }
}

braucht sicher weniger Speicher.

[Sven (Gast)]

MaWin schrieb:
> braucht sicher weniger Speicher.

So hatte ich es doch vorher ungefähr - da ist doch wieder die Division 
drin.

[Stefan (Gast)]

Welchen Controller nutzt du?

[W.S. (Gast)]

Sven schrieb:
> (mein Controller hat 2k)

So, 2k WAS? Dein Controller hat nur 2 K Byte Befehlsspeicher oder 2 K 
Befehle? Ist also vermutlich ein kleiner 8 Bitter.

Und da willst du solche Hilfsroutinen wie das Ausgabekonvertieren von 
Integers in C schreiben, ohne dich intensiv um die in den mitgelieferten 
Bibliotheken vorhandenen Funktionen zu kümmern. Ah ja.

Such einfach mal nach der Funktion ldiv. Die müßte es bei IAR auch für 
die kleineren uC geben - und wenn du sie gefunden hast, dann schreib 
deine Ziffernroutine neu.

Ich geb dir hier mal einen Ausschnitt aus ner Konvertierung (die 
Formatierungen hab ich weggelassen):

long LtoStr (long aValue, int digits, char* Buffer, int BufLen)
  ...
  i = BufLen - 1;
  Buffer[i--] = 0;    /* Endemarker setzen */
  if (aValue<0)
       { L = -aValue;
         v = 1;
       }
  else { L = aValue;
         v = 0;
       }

  if (!L)  Buffer[i--] = '0';
  while (i)
  { if (!L) goto _lready;
    T = ldiv(L,10);
    L = T.quot;
    Buffer[i--] = '0'+T.rem;
  }

                     /* i = 0 heisst: der Buffer ist voll! */
  i = 0; j = BufLen - 2;
  Buffer[i++] = '>';
  while (i<j) Buffer[i++] = '9';
  return aValue;

_lready:
  ...


Aber bei einem uC mit nur 2 K Programmspeicher würde ich zumindest 
solche Routinen in Assembler schreiben und nicht ldiv, sondern die von 
Peter Dannegger skizzierte Subtraktionsmethode benutzen. Die braucht 
lediglich Subtraktionen und ein paar Zehnerpotenzen als Konstanten.

W.S.