4. Programm zur Berechnung binärer Folgen und deren Energiewerte

Programm zur Berechnung binärer Folgen und deren Energiewerte

  • D

    Hallo zusammen!

    Ich soll ein Programm schreiben welches binäre Folgen aus +1 und -1 berechnet und danach deren Energiewert bestimmt. Nachdem ich das Wochenende damit verbracht habe hinter die Formeln zu steigen habe ich mich heute ans Programmieren begeben. Anfangen wollte ich mit einer festen vorgegebenen Folge anstatt mich erst mit Zufallszahlen rumzuquälen da meine Programmierkenntnisse nicht unbedingt die besten sind. Ich habe die Aufgabenstellung mal hochgeladen da ich hier keine Möglichkeit gefunden habe sie im Beitrag anzuhängen. [url] http://imageshack.us/f/851/aufgabenstellung.jpg/ [/url]

    Jetzt ist mir beim ersten Schritt der ganzen Berechnung wohl schon ein Fehler unterlaufen den ich nicht wirklich sehe. Vielleicht könnt ihr ja erkennen wo mein logischer Fehler liegt 😞

    #include <stdio.h>

int main(void)
{
    int folge[]= {1,-1,-1,1,-1,1,-1,1,1,1,1,-1,-1,1,-1,-1,1,1,1,-1,1,-1,-1,-1,1,1,-1,1};
    int x=0, y=1, c=0, n=28;

    for(x=0; x<n; x++)
    {
        for(y=1; y<n; y++)
        {
            c=folge[x]*folge[y];
            printf("Ergebnis: %d \n", c);
        }
    }
}

    Ich hoffe das ihr mir ein bischen weiterhelfen könnt bzw mir n bischen auf die Sprünge helft. Bin über jeden Ratschlag dankbar!

    Gruß
    Dennis

    0
  • C

    Hi,

    ich bin noch Schüler und habe das Zeichen da noch nie gesehen, versuche aber trotzdem mal dir zu helfen. Was ist dein k?

    Edit:
    Und hier gibt's auch C/C++ Tags (unter den Smilies) dann sieht dein Code hübscher aus:

    int i;
    0
  • D

    Vielen Dank für den Tipp 🙂
    k erhöht sich bei der Berechnung der Folge immer um 1, ist aber immer um 1 kleiner als die Anzahl der Folgenlänge n.

    Im Prinzip multipliziere ich im 1. Schritt den 1. Wert des Feldes mit dem 2. Wert des Feldes, den 2. mit dem 3. usw da k=1 ist. Im 2. Schritt ist k=2 und ich multipliziere den 1. Wert mit dem 3., den 2. mit dem 4. usw. Das ganze geht solange bis k um 1 kleiner ist als n.

    Momentan ist das Programm soweit das es den ersten durchlauf macht und den 1. wert mit dem 2. berechnet und so weiter. Allerdings stimmt bei dem Ergebnis irgendwas nicht, handschriftlich bekomme ich da ganz andere Werte raus 😕

    0
  • ?

    @cooky451
    Meinst du ∑?
    Das ist das große Sigma (In den Symbolen unter den Smilies: vorletzte Reihe, 2. Zeichen von rechts) und bedeutet Summe. Man soll also alle Werte von k=1 bos k=n-1 aufsummieren.

    Und genau das fehlt schon mal. Da ist kein + in der Berechnung.

    0
  • D

    Bis zum aufsummieren bin ich noch nich gekommen, zerbreche mir aber schon den kopf dadrüber wie ich das anstellen kann. Dazu müssten die einzelnen Werte von c doch gespeichert werden oder gibt es eine möglichkeit das er den neuen Wert bei jedem Schleifendurchlauf dazu addiert?

    0
  • C

    Ja, habe mir das ∑ schon zusammengereimt, trotzdem danke 😉

    @TE
    Was sollten denn die ersten 5 Ausgaben sein?

    0
  • D

    Die ersten 5 Werte sollten lauten: -1,1,-1,-1,-1

    Zudem bekomme ich auch wesentlich mehr Werte raus als die erwarteten 27 😞

    0
  • C

    Dennis83 schrieb:

    Zudem bekomme ich auch wesentlich mehr Werte raus als die erwarteten 27 😞

    Klar, du hast ja auch zwei Schleifen. printf wird n*(n-1) mal ausgeführt.
    Ich verstehe die Funktionsvorschrift irgendwie so:
    (Scheine mich aber zu irren, da völlig andere Werte raus kommen.)

    int korrel(int k, int n, int *s)
{
  int rval = 0;
  for (int j = 0; j < n - k; ++j)
    rval += s[j] * s[j + k];
  return rval;
}

int main()
{
  int s[]= {1,-1,-1,1,-1,1,-1,1,1,1,1,-1,-1,1,-1,-1,1,1,1,-1,1,-1,-1,-1,1,1,-1,1};
  int e = 0, n = sizeof(s) / sizeof(*s);

  for (int k = 1; k < n; ++k)
  {
    int c = korrel(k, n, s);
    e += c*c;
    printf("C: %d\n", c);
  }

  printf("E: %d\n", e);

  getchar();
}
    0
  • D

    So sieht das schon ganz anders aus 🙂 Ich hatte bis jetzt nur die einzelnen Werte von s[j]*s[j+k] ausgerechnet, bis zum bilden von Ck bin ich garnicht erst gekommen. Ich werde jetzt nochmal stück für stück deinen Quelltext durchgehen. Ich danke dir schonmal vielmals für deine Hilfe!! War echt super 🙂

    0
  • C

    Da mir das irgendwie Spass gemacht hat hier noch ein kleiner Nachschlag:

    int perm_next(int *s, size_t n)
{
  for (int i = n - 1; i >= 0; --i)
  {
    if (s[i] == -1)
    {
      s[i] = 1;
      return 1;
    }
    s[i] = -1;
  }
  return 0;
}

// "Inlined ;)"
//int get_ener(int *s, int n)
//{
//  int C, E = 0;
//  for (int k = 1; k < n; ++k)
//  {
//    C = 0;
//    for (int j = 0; j < n - k; ++j)
//      C += s[j] * s[j + k];
//    E += C * C;
//  }
//  return E;
//}

size_t get_min_ener(size_t n)
{
  int s[0x100];
  if (n >= sizeof(s) / sizeof(*s))
    return 0;
  size_t j, k, min = -1;
  for (j = 0; j < n; ++j)
    s[j] = -1;
  do {
    size_t C, E = 0;
    for (k = 1; k < n; ++k)
    {
      C = 0;
      for (j = 0; j < n - k; ++j)
        C += s[j] * s[j + k];
      E += C * C;
    } // get_ener()
    if (E < min)
      min = E;
  } while (perm_next(s, n));
  return min;
}

void print_ener(size_t min, size_t max)
{
  while (min <= max)
  {
    time_t t = clock();
    printf("n: %d; min: %d; t: %d;\n", min, 
      get_min_ener(min), clock() - t);
    ++min;
  }
}

int main()
{
  print_ener(4, 28);
  getchar();
}

    Scheinen zumindest die von der Aufgabenstellung geforderten Werte zu kommen. Welche Note bekomme ich? 😃
    (Dauert übrigens ewig das Permutieren.. hat jemand vielleicht eine schnellere Lösung?)

    Edit:
    Zeitmessung eingefügt.

    0
Anmelden zum Antworten