C, Dezimal -> Ternärzahl

[Jeromyo H. (jeromyo)]

Abend,

ich bräuchte für ein Projekt ein kleines Stück Code, dass mir eine 
Dezimalzahl von 0-200 in einen Ternärcode umwandelt, und zwar in C, 
genauer in dem Dialekt der Arduino IDE, aber da geht ja das meiste, was 
auch in C geht, hoff ich. Ich habe mir jetzt schon stundenlang den Kopf 
zerbrochen, aber ich weiß nicht, wie, kann mir jemand weiterhelfen?
Und eine LUT mit 200 Einträgen wollte ich jetzt auch nicht von Hand 
tippen :/

[Dr. Sommer (Gast)]

Jeromyo Hochgesang schrieb:
> Dialekt der Arduino IDE
Das ist einfach C++, welches auch alles kann was C kann.

Stelle die Zahl eben zur Basis '3' dar (anstelle zur Basis '2', wie sie 
Computer speichern, oder '10' wie man Zahlen üblicherweise 
menschenlesbar darstellt). Das geht üblicherweise über sukzessives 
Teilen mit Rest durch 3. Schaue mal nach BCD-Encodern, die machen fast 
das selbe, aber zur Basis 10.

[B. S. (bestucki)]

Schau mal hier:
http://de.wikipedia.org/wiki/Stellenwertsystem#Konvertierungen

[Jeromyo H. (jeromyo)]

Sehr nett, danke, ist ein guter Anfang :)

[Johann L. (gjlayde)]

In itoa/utoa kann man doch die Bases (radix) angeben. Damit ist die 
Umwandling ins 3er-System eine C-Zeile.

[Jeromyo H. (jeromyo)]

Kannst du mal kurz ein Pseudocode-Beispiel mit itoa geben? Weil ich habs 
damit trotz Recherche nicht hinbekommen

[Markus F. (Gast)]

Darf man fragen wozu das benötigt wird?

[B. S. (bestucki)]

Jeromyo Hochgesang schrieb:
> Kannst du mal kurz ein Pseudocode-Beispiel mit itoa geben? Weil ich habs
> damit trotz Recherche nicht hinbekommen

http://www.cplusplus.com/reference/cstdlib/itoa/

[Jeromyo H. (jeromyo)]

Ich bastel an einem Verschlüsselungsalgorithmus auf dem AVR, durch den 
Zahlenbasiswechseln und reduzieren von Bitanzahlen wird der ursrüngliche 
Text bei falschem Schlüssel nicht mehr rekonstruierbar, so weit der 
Gedanke, klappt auch ganz gut :)

[Jeromyo H. (jeromyo)]

Danke an be stucki!

[Mr. X (Gast)]

Jeromyo Hochgesang schrieb:
> Kannst du mal kurz ein Pseudocode-Beispiel mit itoa geben? Weil ich habs
> damit trotz Recherche nicht hinbekommen

Brauchst du es auch noch vorcompiliert?

Du kannst auch so lange 81, 27, 9 und 3 von deiner Zahl abziehen, bis 
jeweils etwas negatives raus kommt.

[Jeromyo H. (jeromyo)]

Nein, Mr. X, es läuft alles schon so wie geplant :) Tzdm danke, ich habe 
es mit dem sukzessiven Teilen hinbekommen.

[Mr. X (Gast)]

Jeromyo Hochgesang schrieb:
> sukzessiven Teilen

Und wie lange dauert das im Vergleich zur Subtraktion?

[B. S. (bestucki)]

Mr. X schrieb:
> Und wie lange dauert das im Vergleich zur Subtraktion?

Hab ich vor einem halben Jahr mal versucht. Um eine Zahl nur durch 
Subtraktion in einen String umzuwandeln, benötigte mein Controller ca. 
1.5 mal länger als mit Modulo und Division. Der benötigte 
Programmspeicher war etwa gleich. Getestet mit einem PIC18 und dem XC8 
Compiler von Microchip. Sourcecode hab ich nicht mehr.

[Johann L. (gjlayde)]

Falls Geschwindigkeit zählt, kann man / und % verwenden und den Code auf 
Geschwindigkeit optimieren. Der Compiler verwendet dann eine 
Multiplikation.

Beispiel:

unsigned d, m;

void f (unsigned x)
{
    d = x / 3;
    m = x % 3;
}

Ergebnis mit avr-gcc 4.7:

f:
  movw r30,r24   ;  2  *movhi/1  [length = 1]
  movw r18,r24   ;  6  *movhi/1  [length = 1]
  ldi r26,lo8(-85)   ;  7  *movhi/5  [length = 2]
  ldi r27,lo8(-86)
  rcall __umulhisi3   ;  8  *umulhi3_highpart_call  [length = 1]
  lsr r25   ;  31  *lshrhi3_const/2  [length = 2]
  ror r24
  sts d+1,r25   ;  11  *movhi/4  [length = 4]
  sts d,r24
  movw r20,r24   ;  27  *movhi/1  [length = 1]
  lsl r20   ;  32  *ashlhi3_const/2  [length = 2]
  rol r21
  add r20,r24   ;  20  *addhi3/1  [length = 2]
  adc r21,r25
  sub r30,r20   ;  21  subhi3/1  [length = 2]
  sbc r31,r21
  sts m+1,r31   ;  22  *movhi/4  [length = 4]
  sts m,r30
  ret   ;  30  return  [length = 1]

Und hier noch die 8-Bit Version, nochma kürzer:

f:
  ldi r25,lo8(-85)   ;  6  movqi_insn/2  [length = 1]
  mul r24,r25   ;  7  umulqi3_highpart  [length = 3]
  mov r25,r1
  clr __zero_reg__
  lsr r25   ;  8  *lshrqi3/3  [length = 1]
  sts d,r25   ;  9  movqi_insn/3  [length = 2]
  mov r18,r25   ;  23  movqi_insn/1  [length = 1]
  lsl r18   ;  14  *ashlqi3/3  [length = 1]
  add r18,r25   ;  16  addqi3/1  [length = 1]
  sub r24,r18   ;  17  subqi3/1  [length = 1]
  sts m,r24   ;  18  movqi_insn/3  [length = 2]
  ret   ;  26  return  [length = 1]

Was ich nicht verstehe ist, was das mit Verschlüsselung zu tun haben 
soll.

Scheint eher ne Obfuscation zu werden als ne handfeste, seriöse 
Verschlüsselung...

[Jeromyo (Gast)]

(Sry, gerade als Gast, da fremder Rechner :/)

So hab ich das ganze jetzt gelöst, nicht sehr effizient und für euch 
wahrsch."Spaghetticode", aber was solls, i made it!

int dec2TC(int decInt){
 
 int decIntModulo[5];
 int decIntA[5];
 
 for(int x2 = 0; x2 <= 5; x2++){
  decIntModulo[x2] = 0;
  decIntA[x2] = 0; 
 }
 
 decIntA[0] = decInt/3;
 decIntModulo[0] = decInt % 3;
 decIntA[1] = decIntA[0]/3;
 decIntModulo[1] = decIntA[0] % 3;
 decIntA[2] = decIntA[1]/3;
 decIntModulo[2] = decIntA[1] % 3;
 decIntA[3] = decIntA[2]/3;
 decIntModulo[3] = decIntA[2] % 3;
 decIntA[4] = decIntA[3]/3;
 decIntModulo[4] = decIntA[3] % 3;
 decIntA[5] = decIntA[4]/3;
 decIntModulo[5] = decIntA[4] % 3; 
 
 String sInt = "";
 int ternVal = 0b00000;
 
 for(int x3 = 4; x3 >= 0; x3--){ 
 sInt = sInt + decIntModulo[x3];
 }
 
 char charArInt[sInt.length() + 1];
 sInt.toCharArray(charArInt, sizeof(charArInt));
 ternVal = atoi(charArInt);
 
 return ternVal;
 
}

[Jeromyo H. (jeromyo)]

Mir fällt gerade auf, das innere, die tatsächliche Division+Modulo, 
könnte man in eine Schleife packen, aber so ists übersichtlicher :)

[Christopher B. (chrimbo)]

Jeromyo Hochgesang schrieb:
> aber so ists übersichtlicher :)
ernsthaft?