4. komplexe Übertragungsfunktion

komplexe Übertragungsfunktion

  • ?

    scontch schrieb:

    Also mit 2D array kann ich mir das grad nicht Vorstellen bzw. kapier ich des ned.

    Jeder Eintrag in dem 2D-Array entspricht einem "Pixel" auf dem Ausgabegerät. Du brauchst also sowas in der Art: char a[70][20]

    Der Vorteil ist folgender: Wenn Du die Kurve zeichnest und ein Sternchen an die Position x,y zu zeichnen hast, kannst Du einfach auf das Array zugreifen: a[x][y] = '*'. Das ist in der Console nicht ohne weiters möglich.

    Anschließend mit zwei Schleifen drüber laufen und alles auf einen Schlag printen.

    0
  • ?

    In kDivision bei der Berechnung von Ergd.Re muss es ein + statt - sein

    0
  • S

    Vielen Dank fürs drüber schauen. Den Fehler hätt ich heute nicht mehr gefunden 😉

    Nach dem Frühstück mach ich mir mal nochmal Gedanken zu dem array...

    0
  • S

    dringendes Problem, bitte um schnelle antworten wenn möglich.

    #include <stdio.h>

int main (void) {

	int Bild [1] [1];
	int i,j;

	Bild [0][0] = '*';
	Bild [1][0] = '*';

	for (i=0;i<=1;i++){
		for (j=0;j<=1;j++){
	if (Bild [i][j] == '*'){
	printf("*");
}
else{
printf("1");
}}}
	getchar();
	return 0;
}

    ich erwarte bei der ausgabe 2 * erhalte aber 3, wieso?
    wenn ich die sternchen in [0] [0] und [1] [1] befülle erhalte ich korrekterweise 2. Wo is der Fehler??

    0
  • B

    Wieviele Elemente hat das Array Bild?

    0
  • S

    Also das Orginal zur Aufgabe soll 70 breit und 20 hoch sein;

    mein beispiel hab ich gelöst.
    ich hab null plan was ich mit der aufgabe machen soll, dass das ein richtiges bild wird.

    das is was ich hab. das bild stimmt null und ich weiss ned warum. wenn ich alles logisch durchgehe sollte es meiner meinung nach passen 😢

    #include <stdio.h>
#include <math.h>

//Deklarieren der Variablen für die Kreisfrequenz
double Pi = 3.141592654;
double f;
double omega;

//Deklarieren der Variablen nach Vorgabe
const double C1 = 4e-12, C2 = 10e-12, L = 0.1e-3, R = 470;

//komplexe Zahl mit Real- und Imaginärteil deklarieren
struct kompZ {
double Re;
double Im;
};

//Funktionsprototypen
struct kompZ kAddition (struct kompZ kompZ1, struct kompZ kompZ2);
struct kompZ kMultiplikation (double Zahl1, struct kompZ kompZ2);
struct kompZ kDivision (struct kompZ kompZ1, struct kompZ kompZ2);
double Phase (struct kompZ kompZ1);
double Betrag (struct kompZ kompZ1);
struct kompZ kLeitwert (double omega);
struct kompZ H (struct kompZ y);
double log10(double x);
double min_max (double AmpdB);

int main()
{

double temp;
double max = 20 * log10(Betrag(H(kLeitwert(2 * Pi * 4.5e6))));
double min = max;

double AmpdBtemp [70];
int t = 0;

for(f = 4.5e6; f <= 4.5e6 + 70 * 20e3; f = f + 20e3) {

omega = 2 * Pi * f;

struct kompZ y;
y = kLeitwert(omega);

struct kompZ h;
h = H(y);

double Amp = Betrag(h);
double Pha = Phase(h);

//printf("Omega: %lf\tAmpltiude: %lf\tPhase:%lf\n",omega,Amp,Pha);

double AmpdB = 20* log10(Amp);
//printf("AmpdB: %lf\n\n", AmpdB);

temp = AmpdB;

if (max < temp) {
max = temp;
}

if (min > temp) {
min = temp;
}

AmpdBtemp [t] = AmpdB;
t++;

}
/*
int penis;
for (penis=0; penis<70; penis++)
printf ("%f\n", AmpdBtemp[penis]);
*///Array AmpdBtemp wird richtig befüllt

double step = (min - max) / 20;

char Bild [70] [20];
double point0 = min;
double point1;
int i, j=0;

Bild [0] [0] = '*';
t = 0;
for (i = 1; i < 70; i++) {
point1 = AmpdBtemp [t];
t++;

if (point1 > point0) {

if (point1 - point0 > step ) {
Bild [i] [j+1] = '*';
point0 = point1;
j++;
}

else {
Bild [i] [j] = '*';
point0 = point1;
}
}

else {

if (point0 - point1 > step) {
Bild [i] [j-1] = '*';
point0 = point1;
j--;
}

else {
Bild [i] [j] = '*';
point0 = point1;
}
}
}

int x;
int y;

for (y = 0; y < 19; y++) {

for (x = 0; x < 70 ; x++){ 
if (Bild [x][y] == '*') 
printf("*");
else
{printf (" ");}
}
printf("\n");

}

system("PAUSE");	
return 0;
}

//Funktion für die komplexe Addidion nach math. Regeln
struct kompZ kAddition (struct kompZ kompZ1, struct kompZ kompZ2) {
struct kompZ Erga;
Erga.Re = kompZ1.Re + kompZ2.Re;
Erga.Im = kompZ1.Im + kompZ2.Im;
return Erga;
}

//Funktion für die komplexe Multiplikation mit einem Faktor nach math. Regeln
struct kompZ kMultiplikation (double Zahl1, struct kompZ kompZ2) {
struct kompZ Ergm;
Ergm.Re = Zahl1 * kompZ2.Re;
Ergm.Im = Zahl1 * kompZ2.Im;
return Ergm;
}

//Funktion für die komplexe Division nach math. Regeln
struct kompZ kDivision (struct kompZ kompZ1, struct kompZ kompZ2) {
struct kompZ Ergd;
Ergd.Re = (kompZ1.Re * kompZ2.Re - kompZ1.Im * kompZ2.Im) / (kompZ2.Re * kompZ2.Re + kompZ2.Im * kompZ2.Im);
Ergd.Im = (kompZ1.Im * kompZ2.Re - kompZ1.Re * kompZ2.Im) / (kompZ2.Re * kompZ2.Re + kompZ2.Im * kompZ2.Im);
return Ergd;
}

//Funktion für die Berechnung des Winkels von komplexen Zahlen nach math. Regeln
double Phase (struct kompZ kompZ1) {
double Pha;
Pha = atan2(kompZ1.Im, kompZ1.Re);
return Pha;
}

//Funktion für die Berechnung des Betrags einer komplexen Zahl nach math. Regeln
double Betrag (struct kompZ kompZ1) {
double Amp;
Amp = sqrt ( kompZ1.Im * kompZ1.Im + kompZ1.Re * kompZ1.Re);
return Amp;
}

//1. Berechnung des komplexen Leitwerts
struct kompZ kLeitwert (double omega) {
struct kompZ y;
y.Re = 0;
y.Im = omega * (C2 / (1 - omega * omega * L * C2) - C1);
return y;
}

//2. Berechnung der Übertragungsfunktion 
struct kompZ H (struct kompZ y) {

//R * kLeitwert
struct kompZ u2;
u2 = kMultiplikation(R,y);

//1 + R * kLeitwert
struct kompZ u1;
struct kompZ eins;
eins.Re = 1;
eins.Im = 0;
u1 = kAddition ( eins , kMultiplikation ( R , y));

struct kompZ h = kDivision (u2, u1);

return h;
}
    0
  • L

    Bitte rück deinen Code doch vernünftig ein, das ist ja extrem schwierig zu lesen so...
    Aber ich verstehe die Logik auch nicht. Wieso machst du nicht einfach:

    double AmpdBtemp[70];
char Bild [70] [20];
int maxdB,mindB;

/* Berechne AmpdBtemp und die maximal und minimalwerte maxdB und mindB
   [...]*/

/* Initialisiere Bild mit ' '
   [...]*/

for (int i=0; i<70; i++)
{
  int dBValue=(int)((AmpdBtemp[i]-mindB)/(maxdB-mindB)*20); /*Rechne das nochmal nach, damit das auch stimmt*/
  Bild[i][dBValue]='*';
}

/* Hier Bild ausgeben
   [...]*/
    0
  • S

    Meine Logik dahinter war das "dynamische Befüllen des Arrays", da die dritte Aufgabe ist, den Benutzer C1, C2, L und R auswählen zu lassen und dann die Grafik anzupassen. Kann ich des dann auch so machen?

    /* Initialisiere Bild mit ' '
    [...]*/

    Hmm, heißt das, ich soll einfach das ganze Array mit Leerzeichen befüllen, oder wie war des gemeind?

    Sorry für den unübersichtlichen Code. War müde und der Kopf war voll. Der nächste ist Vorbildlich 🙂

    0
  • L

    Hier ein Stückchen Code, das das Ausgeben übernimmt. So einfach wie möglich geschrieben (das ginge sowohl effizienter als auch schöner...). Ich hoffe so wird die Idee klar:

    #include <stdio.h>
#include <math.h>

int main(void)
{
  char image[10][11];
  int values[]={1,2,3,4,3,2,1,1,0,5};
  int i=0,j=0;

  // Mit ' ' füllen
  for (i=0; i<10; i++)
  {
    for (j=0; j<10; j++)
    {
      image[i][j]=' ';
    }
    image[i][10]=0;
  }

  // Zeichnen
  for (i=0; i<10; i++)
  {
    image[values[i]][i]='*';
  }

  // Ausgeben
  for (i=9; i>=0; i--)
  { 
    printf("%s\n",image[i]);
  }

  return 0;
}
    0
  • S

    Hi, ja hab zwar lange gebraucht, aber ich denke so einigermaßen hab ichs überrissen.

    Vielen vielen Dank 🙂

    Dennoch hab ich noch 2, 3 Probleme 😃

    Also folgendes hab ich bisher:

    int main()
{
 	//Implementieren der Variablen zur Berechnung von Minimum und Maximum
	double temp;
 	double max = 20 * log10(Betrag(H(kLeitwert(2 * Pi * 4.5e6))));
	double min = max;

	//Array zur Speicherung der Ergebnisse in dB 
    int AmpdBtemp [70];
 	int t = 0;

    //Berechnung der 70 Stützwerte
	for(f = 4.5e6; f <= 4.5e6 + 70 * 20e3; f = f + 20e3) {

		  omega = 2 * Pi * f;

		  struct kompZ y;
		  y = kLeitwert(omega);

 		  struct kompZ h;
		  h = H(y);

		  double Amp = Betrag(h);
		  double Pha = Phase(h);
		  double AmpdB = 20* log10(Amp);

		  temp = max;

		  	  if (max < temp) {
			  	 max = temp;
			  }

			  if (min > temp) {
			  	 min = temp;
			  }

		AmpdBtemp [t] = AmpdB * (-1);
		t++;
	}

 	char Bild[70][71]; 
  	int i=0,j=0; 

    // Komplettes Bild mit Leerzeichen füllen 
  	for (i=0; i<70; i++) {
  		for (j=0; j<70; j++) { 
      		Bild[i][j]=' '; 
  		} 
    	Bild[i][70]=0; 
	} 

 	// Im Array 'zeichnen' 
  	for (i=0; i<70; i++) {
  	  int dBValue=((AmpdBtemp[i]-min)/(max-min)*20);
	  Bild[AmpdBtemp[i]][dBValue]='*'; 
    } 

   	// Ausgeben 
  	for (i=0; i<=69; i++) {
  		printf("%s\n",Bild[i]); 
    } 

  	system("PAUSE");	
  	return 0;
}

    Zum einen muss bei mir bei

    int Bild [70][71]

    egal mit welchen Werten, der zweite immer eins höher sein als der erste. sonst funktionierts nicht. Aber dann hab ich ja so viele Zeilen, aber ich will ja nur 20. Geb ich da aber eine 20 rein, gibts keine Ausgabe mehr.

    Zum anderen funktioniert

    int dBValue=((AmpdBtemp[i]-min)/(max-min)*20);
	  Bild[AmpdBtemp[i]][dBValue]='*';

    nicht 😞 ohne die Berechnung und mit

    Bild[AmpdBtemp]][i]

    klappts.
    Will ich auf 20 "dehnen" stürzt mir das Programm ab.

    Und was mich noch intressehalber interessiert: wieso bekomm ich Smileys oder andere Symbole aus der ASCII Tabelle wenn ich die letzte Zeile nicht 0 setze?

    0
  • ?

    scontch schrieb:

    Zum einen muss bei mir bei

    int Bild [70][71]

    egal mit welchen Werten, der zweite immer eins höher sein als der erste. sonst funktionierts nicht. Aber dann hab ich ja so viele Zeilen, aber ich will ja nur 20. Geb ich da aber eine 20 rein, gibts keine Ausgabe mehr.

    Komm schon Mann. Mach mal die Augen auf:

    for (i=0; i<70; i++) {
    for (j=0; j<70; j++) {

    0
  • S

    ja schon klar, aber wenn des angepasst is gehts auch nicht. dann gibt er kauderwelsch aus. aber egal. ich kanns ja bei der ausgabe auf 20 zeilen kürzen.

    Allerdings funktioniert das "ziehen" auf 20 zeilen nicht..

    0
Anmelden zum Antworten