Basic in C übersetzen

[Gast (Gast)]

Hallo an alle,

kann mir jemanden helfen das Basic Programm in c zu übersetzen?

[Sven P. (Gast)]

welches denn?

[Gast (Gast)]

sorry ,
ich habe es nicht eingefügt!!

[Rufus Τ. F. (rufus)]

Dateiformate

*.doc ist kein Quelltextformat.

[Karl H. (kbuchegg)]

Es gibt zwar Schlimmeres, aber diesen Spaghetticode muss
man erst mal aufräumen.

Allerdings: Sooo schlimm ist der Code dann auch wieder nicht.
Ein goto ist drinnen, der unmittelbar auf einen anderen if samt
goto führt. Über den müsste man etwas nachdenken, aber der Rest
übersetzt sich quasi von alleine. Alle Variablen mit einem %
hinten drann sind int, alles andere double. Und schon bist du
unterwegs.

Aber wozu nach C umsetzen? Fast Fourier Transformationen gibt es
doch auch in C im Web wie Sand am Meer. Man muss nur suchen.

PS: Musste das unbedingt sein, ein Basic-Programm in ein Word
Dokument einzubetten? Es gibt nur wenige Wahnsinnige wie mich,
die ein Word-Dokument aus dem Web einfach so aufmachen.

[Gast (Gast)]

Sorry,
ich glaube ich bin zu dummi dafür,
was heisst das(*.doc ist kein Quelltextformat.)
 Das Programm habe ich aus dem Buch vom Steven.W Smith (Digital Signal 
Processing) sollte zur berechnung vom FFT auf eienem Pic sehr gut 
geeignet ist.
Ich habe es versucht eigenes zu verstehen, aber klappt halt nichts!!

[Rufus Τ. F. (rufus)]

Das ist ein WORD-Dokument.

Noch ungeeigneter wäre eine PDF-Datei oder ein Bild vom Quelltext (als 
JPG oder was auch immer).

Das WORD-Dokument ist 26624 Bytes groß; der Nutzinhalt aber ist gerade 
mal 1418 Bytes groß.

[Gast (Gast)]

Habe schon fast alles im Netz durchgesucht .Leider war es noch 
komplezierter als ich dachte!!

[Gast (Gast)]

An rufus
Ok ! ich verstehe es jetzt

[Peter D. (peda)]

Gast wrote:

> was heisst das(*.doc ist kein Quelltextformat.)


Das heißt, wenn Du einem Compiler oder Basic ein *.doc fütterst, wird es 
Dich mit tonnenweise Fehlermeldungen überhäufen, aber nie compilieren.

Compiler mögen nur pure ASCII-Files ohne jede Formatierung.

Und die Endung entspricht dann dem Compiler, z.B.:

*.bas für Basic
*.c für C
*.asm für Assembler


Peter

[der Böse :) (Gast)]

> Das ist ein WORD-Dokument.

> Das WORD-Dokument ist 26624 Bytes groß; der Nutzinhalt aber ist gerade
> mal 1418 Bytes groß.

das ist der "Microsoft-Effekt" :)

ist wie beim 'Hello World', das besteht aus

2 Prozent Hello und 98 Prozent Microsoft :))

[Karl H. (kbuchegg)]

Gast wrote:
> Habe schon fast alles im Netz durchgesucht .Leider war es noch
> komplezierter als ich dachte!!

Nichts für ungut, aber:
Warum bloss habe ich das Gefühl, du versuchst dich da an einer
Problemstellung die 5 Schuhnummern zu groß für dich ist?

[Gast (Gast)]

Könnte er mir trotzdem jemanden das Programm mindestens zu verstehen?

Ich wäre natürlich sehr dankbar!!

[Karl H. (kbuchegg)]

Wenn ich mich nicht irgendwo gröber verhaut habe, dann müsste es
das eigentlich sein

#include <math.h>

void fft( int N, double* REX, double* IMX )
{
  // THE FAST FOURIER TRANSFORM
  //   Upon entry, N% contains the number of points in the DFT, REX[ ] and
  //   'IMX[ ] contain the real and imaginary parts of the input. Upon return,
  //   'REX[ ] and IMX[ ] contain the DFT output. All signals run from 0 to N%-1.

  double PI = 3.14159265;
  int    NM1 = N-1;
  int    ND2 = N/2;
  int    M   = int( log(N) / log(2.0) );
  int    J   = ND2;
  int    I, K, L, LE, LE2, JM1, IP;
  double SR, SI, TR, TI, UR, UI;

  for( I = 1; I <= N-2; ++i ) {
    if( I < J ) {
      TR = REX[J];
      TI = IMX[J];
      REX[J] = REX[I];
      IMX[J] = IMX[I];
      REX[I] = TR;
      IMX[I] = TI;
      K = ND2;
    }
    while( K <= J ) {
      J = J-K;
      K = K/2;
    }

    J = J+K;
  }

  for( L = 1; L <= M; ++L ) {
    LE = (int) ( 1 << L );
    LE2 = LE/2;
    UR = 1;
    UI = 0;
    SR =  cos( PI / LE2 );
    SI = -sin( PI / LE2 );

    for( J = 1; J <= LE2; ++J ) {
      JM1 = J-1;

      for( I = JM1; I <= NM1; I += LE ) {
        IP = I+LE2;
        TR = REX[IP]*UR - IMX[IP]*UI;
        TI = REX[IP]*UI + IMX[IP]*UR;
        REX[IP] = REX[I]-TR;
        IMX[IP] = IMX[I]-TI;
        REX[I] = REX[I]+TR;
        IMX[I] = IMX[I]+TI;
      }

      TR = UR;
      UR = TR*SR - UI*SI;
      UI = TR*SI + UI*SR;
    }
  }
}

Vom Basic übernommen wurde, dass der erste Nutzindex in den Arrays
jeweils 1 ist. D.h. da muss man bei einer Verwendung in C aufpassen,
dass die übergebenen Arrays immer um 1 größer definiert werden müssen.
Aber ein Umschreiben der Logik auf 0-basierte Arrays war mir jetzt
zuviel Aufwand. (Auch wenn der Original Kommentar was anderes
behauptet, denke ich, dass die Arrays hier 1-basiert verwendet
werden).

[Benedikt K. (benedikt)]

Vergiss das verstehen erstmal. Wichtig ist zu wissen, wie man es 
verwendet. Also welche Werte reingehen, und welche rauskommen, und was 
die bedeuten.

[Gast (Gast)]

Können sie es mir bitte villeicht noch besser erklären (Danke)

>Vom Basic übernommen wurde, dass der erste Nutzindex in den Arrays
jeweils 1 ist. D.h. da muss man bei einer Verwendung in C aufpassen,
dass die übergebenen Arrays immer um 1 größer definiert werden müssen.
Aber ein Umschreiben der Logik auf 0-basierte Arrays war mir jetzt
zuviel Aufwand.<

[Karl H. (kbuchegg)]

Gast wrote:
> Können sie es mir bitte villeicht noch besser erklären (Danke)
>

Eigentlich sollte ich nicht. :-)
Das ist C-Grundlagenwissen

In C ist der erste Array index eine 0.
D.h. ein Array A mit 5 Elementen hat die Elemente
 A[0], A[1], A[2], A[3], A[4]    (zähl nach: sind 5 Stück)

In den meisten Basics, beginnt die Zählerei aber bei 1
D.h. ein Array B mit 5 Elementen hat die Elemente
B[1], B[2], B[3], B[4], B[5]     (zähl wieder nach: sind wieder 5 Stück)

Wenn der C-Code also auf B[5] zugreifen will, dann sollte besser
sicher gestellt sein, dass das Array auch wirklich eine Element
mit dem Index 5 hat. Das hat es aber nur, wenn man es als Array
mit 6 Elementen definiert

  int B[6];

jetzt gibt es  B[0], B[1], B[2], B[3], B[4], B[5]

[Hannes L. (hannes)]

Also die BASIC-Dialekte, die ich kenne, beginnen ihre Arrays mit Index 
0.

...

[Karl H. (kbuchegg)]

Hannes Lux wrote:
> Also die BASIC-Dialekte, die ich kenne, beginnen ihre Arrays mit Index
> 0.

Hmm. Ich kenns wieder anders rum :-)
Aber egal. Im Originalcode sind mir zuviele FOR Schleifen,
die mit
   FOR irgendwas = 1 TO ....
codiert sind. Daraus schliesse ich, dass die Arrays bei 1 anfangen.

Sicher weiss ich es allerdings nicht, schon möglich dass ich
falsch liege. Der OP hat ja jetzt eine Basisimplementierung
mit der er arbeiten kann :-)

[Gast (Gast)]

kann man nicht der erste Array mit 0 initialisieren, dann fangen mit dem 
vektor 0?
  >for( I = 1; I <= N-2; ++i ) {
    if( I < J ) {
      TR = REX[J];
      TI = IMX[J];
      REX[J] = REX[I];
      IMX[J] = IMX[I];
      REX[I] = TR;
      IMX[I] = TI;
      K = ND2;
Im ursprung programm steht
THEN GOTO 1190 heisst es nicht man springt direkt um Befehl 1190 in 
diesem Fall hier: K = ND2;

[Karl H. (kbuchegg)]

Gast wrote:

> Im ursprung programm steht
> THEN GOTO 1190 heisst es nicht man springt direkt um Befehl 1190 in
> diesem Fall hier: K = ND2;

Yep. Mein Fehler

#include <math.h>

void fft( int N, double* REX, double* IMX )
{
  // THE FAST FOURIER TRANSFORM
  //   Upon entry, N% contains the number of points in the DFT, REX[ ] and
  //   'IMX[ ] contain the real and imaginary parts of the input. Upon return,
  //   'REX[ ] and IMX[ ] contain the DFT output. All signals run from 0 to N%-1.

  double PI = 3.14159265;
  int    NM1 = N-1;
  int    ND2 = N/2;
  int    M   = int( log(N)/LOG(2.0) );
  int    J   = ND2;
  int    I, K, L, LE, LE2, JM1, IP;
  double SR, SI, TR, TI, UR, UI;

  for( I = 1; I <= N-2; ++i ) {
    if( I < J ) {
      TR = REX[J];
      TI = IMX[J];
      REX[J] = REX[I];
      IMX[J] = IMX[I];
      REX[I] = TR;
      IMX[I] = TI;
    }
    K = ND2;

    while( K <= J ) {
      J = J-K;
      K = K/2;
    }

    J = J+K;
  }

  for( L = 1; L <= M; ++L ) {
    LE = (int) ( 1 << L );
    LE2 = LE/2;
    UR = 1;
    UI = 0;
    SR =  cos( PI / LE2 );
    SI = -sin( PI / LE2 );

    for( J = 1; J <= LE2; ++J ) {
      JM1 = J-1;

      for( I = JM1; I <= NM1; I += LE ) {
        IP = I+LE2;
        TR = REX[IP]*UR - IMX[IP]*UI;
        TI = REX[IP]*UI + IMX[IP]*UR;
        REX[IP] = REX[I]-TR;
        IMX[IP] = IMX[I]-TI;
        REX[I] = REX[I]+TR;
        IMX[I] = IMX[I]+TI;
      }

      TR = UR;
      UR = TR*SR - UI*SI;
      UI = TR*SI + UI*SR;
    }
  }
}

[Gast (Gast)]

Hallo,
ich versuche es gerade zu verstehen das Vorherige Übersetztes 
Programm.Kann ich aber leider nicht alles nachvollziehen.

haben hier die variablen SR,SI,TR,... irgendwelche besondere bedeutung?

[Basis Basic (Gast)]

Die meisten Basicdialekte kennen den Befehl

Option Base  = 0 oder Option Base  = 1

damit beginnen die Felder entweder mit 0 oder 1

[Ralf S. (spacedog)]

Basic - warum? warum nur?

[Gast (Gast)]

danke zuerst für den Antwort!!

Ich finde momentan Schwierigkeiten bei der Anpassung des programm in C!
Ich versuche zu verstehen welche Variablen erkennt der Compiler !

[Gast (Gast)]

>Basic - warum? warum nur?

Das Programm in Basic ist momentann für mich die Perfekte Lösung für die 
Berechnung vom FFT auf dem Pic!!

>Warum:Bit Reversal Algorithmus, Butterfly Berechnung
Ich bin halt kein Profi, aber ich versuche mein Bestens zu geben!!

[Basis Basic (Gast)]

.. Weil Basic eine leicht zuverstehende Syntax besitzt und anderen
Hochsprachen in nichts nachsteht ...

Hocheffiziente Compiler, Objekt - bassierende Prog.

du Darfst das Basic aus den '80ern nicht mit VB6 oder gar dem  für
.net vergleichen!!

Ich will hier aber nicht wieder eine sinnlose Diskussion lostreten!

[Bernd das Brot (Gast)]

>Basic - warum? warum nur?

Dummes Gescwätze

[Gast (Gast)]

sinnlose Diskusionen halte ich nichts davon!!

Ich will Bloß nur weiter gehlofen werden. Ich glaube ihr kennt dat schon 
wenn man nicht weiterkommt?

Also ich versuche gerade mein Programm in c anzupassen!!

[Norgan (Gast)]

> ich versuche es gerade zu verstehen das Vorherige Übersetztes
> Programm.Kann ich aber leider nicht alles nachvollziehen.
>
> haben hier die variablen SR,SI,TR,... irgendwelche besondere bedeutung?

Ja, haben sie. Ohne die mathematischen Grundlagen der FFT und den 
Algorithmus zu kennen wirst du die allerdings nicht verstehen. Und es 
würde mich sehr wunder, wenn sich hier jemand die Zeit nimmt, ein Essays 
über die FFT für Leute ohne Vorkenntnisse zu schreiben.

Zum Einstieg: 
http://de.wikipedia.org/wiki/Schnelle_Fourier-Transformation

[Karl H. (kbuchegg)]

Basis Basic wrote:

> du Darfst das Basic aus den '80ern nicht mit VB6 oder gar dem  für
> .net vergleichen!!

Ähm, du hast dir aber schon mal das vom OP gepostete Programm
angesehen, oder?

Das ist BASIC der 80-er Jahre.

[Karl H. (kbuchegg)]

Norgan wrote:
>> ich versuche es gerade zu verstehen das Vorherige Übersetztes
>> Programm.Kann ich aber leider nicht alles nachvollziehen.
>>
>> haben hier die variablen SR,SI,TR,... irgendwelche besondere bedeutung?
>
> Ja, haben sie.

Für den OP:

Kleiner Tip. Bei einer FFT gibt es den 'Realteil' einer Zahl
und den 'Imaginärteil' einer Zahl. Also R und I

Und jetzt gibt es einige Variablen, die heissen zb SR und SI
bzw. TR und TI

Ein Schelm wer böses dabei denkt, dass das R bzw. I in SR bzw. SI
irgendetwas bedeuten könnte.

Ansonsten schliesse ich mich Norgan an.
Ein Programm aus einem Buch zu klauen ist eine Sache. Es von
jemandem übersetzen zu lassen ist eine andere Sache. Aber:
Das alles hilft dir nichts, wenn du (wahlweise)
* keine Ahnung von Basic hast
* keine Ahnung von C hast
* keine Ahnung von Programmieren hast
* keine Ahnung von einer FFT hast.
Wenn du bei den Punkten aus dieser Liste mindestens 2 mal
Kopfnicken musst, dann hast du schon verloren.

[Hannes L. (hannes)]

Aua-ha, das war deutlich, so kenne ich Dich gar nicht... ;-)

Gruß in die Berge...

...

[Gast (Gast)]

Ich habe es nämlich nochmal angeschaut ,die variablen kann ich auch 
anderes umbenenen ,die haben eigentlich keine mathematische Bedeutung

[Matthias Kölling (Gast)]

Eine Variable kann man immer umbenennen. Ein Compiler kennt die 
mathematische Bedeutung einer Variablen nicht.

Gruß Matthias