Aufgabenstellung von Herren Grams

Funktionen und Dateien

6.1 Lagern Sie den Datentypen complex und die Funktion berag aus dem Hauptprogramm CompList.c aus und definieren Sie ein Modul complex.h und complex.c dafür. Gestallten Sie das Hauptprogramm entsprechend um, so dass es diese Module benutzt und funktionsgleich zum ursprünglichen Programm ist.

6.2 Ergänzen Sie das Modul complex.h und complex.c um eine Funktion sort für das topologische Sortieren. Zu diesem Zweck ist für die Elemente eine partielle Ordnung mittels des Kriteriums less (für <) definiert. Die Funktion less wird in der Header-Datei deklariert

    extern int less(struct complex*, struct complex*);

und im Hauptprogramm definiert. Es soll less(a,b) genau dann ungleich null sein, wenn a südwestlich von b liegt, also genau dann wenn a.x<b.x und a.y<b.y gilt. (Zeigen Sie, dassdadurch tatsächlich eine partielle Ordnung definiert wird.) Das Programm soll eine Folge von komplexen Zahlen entgegennehmen und dann topologisch sortiert wieder ausgeben. Die Hauptfunktion (main) des Programms CompList.c ist also um einen Verarbeitungsteil zu ergänzen, der nur aus dem Aufruf der Sortierfunktion sort besteht. Die Funktion für das Sortieren könnte beispielsweise so aussehen:

struct complex* sort(struct complex* p){
    if(p){
        struct complex *q=p->next; p->next=0;
        while (q) {
            struct complex *h=q; q=q->next;
            if (less(h, p)) {h->next=p; p=h;} else {
                struct complex *cur=p;
                while (cur->next&&!less(h, cur->next)) cur=cur->next;
                h->next=cur->next;
                cur->next=h;
            } /*EndIf*/
        }/*EndWhile
    } else /*NULL*/
    return p;
}

6.4 Schreiben Sie ein Programm für die Berechnung des Betrages des Scheinwiderstands eines Serienschwingkreises mit tabellarischer Ausgabe. Einzugenen sind die Parameterwerte der Bauelemente R, L und C sowie Unter- und Obergrenze des Frequenzbereichs und die Frequenz-Schrittweite. Benutzen Sie für die Berechnung die komplexe Darstellung der elementaren Impedanz und verwenden Sie möglichst weitgehend die Funktionen des Moduls complex. Ziel ist eine möglichst gut lesbarer Programmtext.

Lösungsansätze:

Aufgaben 6.1 bis 6.3

/*CompList.c*/

#include <stdio.h>
#include <stdlib.h>
#include "komplex.h"

/*Function in()*/
/*Speicher reservieren*/
KOMPLEX* in( KOMPLEX* p) 
{ 
    KOMPLEX* m;
    m=( KOMPLEX*) malloc(sizeof( KOMPLEX));
    printf("? Zahlen eingeben (Re,Im): ");
    scanf("%e,%e", &m->x,&m->y);
    m->next=p;
    return m;
}

/*Function out()*/
void out(KOMPLEX *h) 
{ 
    printf("\n! Die Zahlen: %.1e j%.1e",h->x,h->y);
    printf("! Betrag: %.1e ",betrag(h));
    printf("Phase: %.3e",phase(h));
}

/*Funktion less()*/
int less(KOMPLEX* z1,KOMPLEX* z2)
{
    return (z1->x)<(z2->x)&&(z1->y)<(z2->y);
}

/*Hauptprogramm main()*/
void main () 
{ 

    /*Initialisierung und Titel*/
    KOMPLEX *p=0,*h, y;
    unsigned char c='j',w;
    printf("Demo: Lineare Liste struct KOMPLEXer Zahlen\n");
    
    /*Eingabe*/
    while(c=='j') 
    {
        p=in(p);
        gets(&w);
        printf("? Weiter mit \"j\": ");
        scanf("%c", &c);
    }
    
    /*Verarbeitung: entfällt*/
    
    /*Ausgabe*/
    printf("\nAusgabe");
    p=sort(p);
    h=p;
    while (h) { out(h); h=h->next;}
    h=p;
    printf("\n");
    while ((h)&&(h->next)) 
    { 
        y=add(h,h->next);
        printf("Addition: %.1e j%.1e\n",y.x,y.y);
        y=sub(h,h->next);
        printf("Subtraktion: %.1e j%.1e\n",y.x,y.y);
        y=multi(h,h->next);
        printf("Multiplikation: %.1e j%.1e\n",y.x,y.y);
        y=div(h,h->next);
        printf("Division: %.1e j%.1e\n",y.x,y.y);
        h=h->next->next;
    }
    
    /*Fpeicherplatz Freigeben*/
    h=p;
    while (h) 
    {
        p=h;
        h=h->next;
        free (p);
    }
    printf("\n");
    // free (pointer);
}

/*Complex.h*/

#define KOMPLEX struct complex


/*Struktur festlegen*/
KOMPLEX {float x,y;KOMPLEX *next;};

extern float betrag(KOMPLEX*);
extern KOMPLEX* sort (KOMPLEX*);
extern KOMPLEX add (KOMPLEX* ,KOMPLEX*);
extern KOMPLEX sub (KOMPLEX* ,KOMPLEX*);
extern KOMPLEX multi (KOMPLEX* ,KOMPLEX*);
extern KOMPLEX div (KOMPLEX* ,KOMPLEX*);
extern float phase (KOMPLEX*);

/*komplex.c*/

#include <math.h>
#include "komplex.h"

/*Function betrag()*/
float betrag (KOMPLEX *z)
{
    return fabs(z->x)<fabs(z->y)? fabs(z->y)*sqrt(1+(z->x/z->y)*(z->x/z->y))
    : z->x==0? 0: fabs(z->x)*sqrt(1+(z->y/z->x)*(z->y/z->x));
}

/*Funktion less()
int less(KOMPLEX* z1,KOMPLEX* z2)
{
    return (z1->x)<(z2->x)&&(z1->y)<(z2->y);
}*/

/*Funktion sort()*/
KOMPLEX* sort(KOMPLEX* p)
{
    if(p)
    {
        KOMPLEX* q=p->next;
        p->next=0;
        while (q) 
        {
            KOMPLEX *h=q; 
            q=q->next;
            if (less(h, p)) 
            {
                h->next=p;
                p=h;
            }
            else 
            {
                KOMPLEX *cur=p;
                while (cur->next&&!less(h, cur->next)) cur=cur->next;
                h->next=cur->next;
                cur->next=h;
            }
        }
    }
    /*else;*/
    return p;
}

/*Addition*/
KOMPLEX add (KOMPLEX* z1,KOMPLEX* z2) 
{
    KOMPLEX c;
    c.x=z1->x+z2->x;
    c.y=z1->y+z2->y;
    return c;
}

/*Subtraktion*/
KOMPLEX sub (KOMPLEX* z1,KOMPLEX* z2) 
{
    KOMPLEX c;
    c.x=z1->x-z2->x;
    c.y=z1->y-z2->y;
    return c;
}

/*Multiplikation*/
KOMPLEX multi (KOMPLEX* z1,KOMPLEX* z2) 
{
    KOMPLEX c;
    c.x=z1->x*z2->x-z1->y*z2->y;
    c.y=z1->x*z2->y+z1->y*z2->x;
    return c;
}

/*Division*/
KOMPLEX div (KOMPLEX* z1,KOMPLEX* z2) 
{
    KOMPLEX c;
    c.x=(z1->x*z2->x+z1->y*z2->y)/pow(betrag(z2),2);
    c.y=(z1->y*z2->x-z1->x*z2->y)/pow(betrag(z2),2);
    return c;
}

/*phase ()*/
float phase (KOMPLEX* z) 
{
    return z->y!=0? atan(z->x/z->y):z->x>0? 90:270;
}

Aufgabe 6.4

/*Serienschwingkreis*/
#include <stdio.h>
#include "komplex.h"
#define PI 3.1415926536;

void main() 
{
    float fu,fo,step,r,l,c,w0,w;
    KOMPLEX z;
    printf("Serienschwingkreis vom Rainer M., Daniel G. & Guido M.\n\n");
    printf("Die physikalischen Werte fuer die folgende Werte muessen einzugeben werden:\n");
    printf("R = Widerstand [Ohm]\n");
    printf("C = Kapazitaet [F]\n");
    printf("L = Induktivitaet [H]\n");
    printf("fu = Startfrequenz [Hz]\n");
    printf("fo = Endfrequenz [Hz]\n");
    printf("s = Schrittweite [Hz]\n");
    printf("?R = ");scanf("%f",&r);
    printf("?C = ");scanf("%f",&c);
    printf("?L = ");scanf("%f",&l);
    printf("?fu = ");scanf("%f",&fu);
    printf("?fo = ");scanf("%f",&fo);
    printf("?s = ");scanf("%f",&step);
    w0=1/sqrt(l*c);
    z.x=r;
    while (fu<fo) 
    {
        w=fu*2*PI;
        z.y=w*l-1/(w*c);
        printf("%12.3f %12.3f \n",fu,betrag(&z));
        fu=step+fu;
    }
}