Guten Abend 🙂

ich würde gerne ein Programm schreiben, welches mir das Spatprodukt dreier Vektoren berechnet. Dazu soll es einmal eine Funktion zur Berechnung des Kreuzproduktes, und danach die Funktion zur Berechnung des Skalarproduktes aufrufen. Der Code dazu sieht so aus: 
/*Aufgabe: Skalarprodukt, Vektorprodukt und Spatprodukt als Funktionen*/
#include<stdio.h>

/*Deklariere die Funktionen*/
double skalar(double a_1, double a_2, double a_3, double b_1, double b_2, double b_3);
double kreuz(double a_1, double a_2, double a_3, double b_1, double b_2, double b_3);
double spat(double a_1, double a_2, double a_3, double b_1, double b_2, double b_3);

/*Hauptprogramm*/
int main() {
	
	/*Variablendeklaration*/
	double erg_skalar;
	double erg_kreuz[3];
	double erg_spat;
	double a[3];
	double b[3];

	/*Einlesen der Komponenten*/
	for(int loop = 0; loop <= 2; loop++) { 

		printf("Komponente a_%i: ",loop);
		scanf("%lf", &a[loop]);
	}

	printf("\n");

	for(int loop = 0; loop <= 2; loop++) { 

		printf("Komponente b_%i: ",loop);
		scanf("%lf", &b[loop]);
	}
	
	printf("\n");
	
	/*Skalarprodukt speichern*/
	erg_skalar = skalar(a[0],a[1],a[2],b[0],b[1],b[2]);
	
	/*Kreuzprodukt speichern*/
	for(int i = 0; i <= 2; i++) {	

		erg_kreuz[i] = kreuz(a[0],a[1],a[2],b[0],b[1],b[2]);
	
	}
	
	/*Spatprodukt speichern*/
	erg_spat = spat(a[0],a[1],a[2],b[0],b[1],b[2]);

	/*Ergebnis Skalarprodukt ausgeben*/
	printf("a * b = %.2lf\n", erg_skalar);
	/*Ergebnis Kreuzprodukt ausgeben*/
	printf("a x b = (%.2lf,%.2lf,%.2lf)\n",erg_kreuz[0],erg_kreuz[1],erg_kreuz[2]);
	/*Ergebnis Spatprodukt ausgeben*/
	printf("(a x b) * c = %.2lf\n", erg_spat); 

return 0;
}

/*Definiere die Funktionen*/
double skalar(double a_1, double a_2, double a_3, double b_1, double b_2, double b_3)	{
	
	/*Variablendeklaration*/
	double a[3];
	double b[3];
	double erg;
	
	/*Umspeichern der Komponenten*/
	
	a[0] = a_1;
	a[1] = a_2;
	a[2] = a_3;
	b[0] = b_1;
	b[1] = b_2;
	b[2] = b_3;
	
	/*Berechnen des Skalarproduktes*/
	for(int loop = 0; loop <= 2; loop++) {
		
		erg = erg + (a[loop] * b[loop]); 	
	}
	
return erg;
}

double kreuz(double a_1, double a_2, double a_3, double b_1, double b_2, double b_3) {

	/*Variablendeklaration*/
	double a[3];
	double b[3];
	double erg;
	static int zaehler = 1;
	static int zaehler_2 = 1;
	
	/*Umspeichern der Vektoren*/
	
	a[0] = a_1;
	a[1] = a_2;
	a[2] = a_3;
	b[0] = b_1;
	b[1] = b_2;
	b[2] = b_3;
	
	/*Die Variable zaehler bzw. zaehler_2 zählt die Funktionsaufrufe. Dementsprechen werden die Komponenten des Kreuzproduktes berechnet*/
	switch(zaehler) {

		case 1:erg = a[1]*b[2] - a[2]*b[1]; zaehler++; return erg; 
		case 2:erg = a[2]*b[0] - a[0]*b[2]; zaehler++; return erg;
		case 3:erg = a[0]*b[1] - a[1]*b[0]; zaehler++; return erg;
		default: switch(zaehler_2) {
			
			case 1:erg = a[1]*b[2] - a[2]*b[1]; zaehler_2++; return erg; 
			case 2:erg = a[2]*b[0] - a[0]*b[2]; zaehler_2++; return erg;
			case 3:erg = a[0]*b[1] - a[1]*b[0]; zaehler_2++; return erg;
		}
	}

return 0;
}

double spat(double a_1, double a_2, double a_3, double b_1, double b_2, double b_3) {
	
	/*Variablendeklaration*/
	double c[3];
	double erg_kreuz[3];
	double erg_skalar;

	/*Einlesen der Komponenten*/
	for(int loop = 0; loop <= 2; loop++) { 

		printf("Komponente c_%i: ",loop);
		scanf("%lf", &c[loop]);
	}
	
	printf("\n");
	

	/*Kreuzprodukt speichern*/
	for(int i = 0; i <= 2, i++) {

		erg_kreuz[i] = kreuz(a_1,a_2,a_3,b_1,b_2,b_3);
		
	}
	
	/*Skalarprodukt speichern*/
	erg_skalar = skalar(erg_kreuz[0],erg_kreuz[1],erg_kreuz[2],c[0],c[1],c[2]);

	
return erg_skalar;
}
Skalarprodukt und Kreuzprodukt werden auch korrekt berechnet. Was mir allerdings nicht einleuchtet, ist, dass das Spatprodukt nur dann korrekt berechnet wird, wenn ich in der letzten for-Schleife immer noch einmal die Werte mit printf() ausgeben lasse. Kannn mir einer sagen, was ich hier falsch gemacht habe? Dafür schonmal vielen Dank

Iceberg
Moin,

na, da hast du dir ja was einfallen lassen für's Kreuzprodukt. 🙂 Aber okay, ist ja nicht das Thema.

Dein Problem hab ich jetzt so direkt nicht nachvollziehen können (da es nicht kompilierte, s.u.), aber in der zweiten for-Schleife von spat() hast du einen kleinen Typo drin: 
/*Kreuzprodukt speichern*/
for (int i = 0; i <= 2, i++)
{
	erg_kreuz[i] = kreuz(a_1, a_2, a_3, b_1, b_2, b_3);	
}
Nach dem i <= 2 muss ein Semikolon stehen und kein Komma. Mein gcc wirft mir das übrigens auch als Fehler aus, da ihm ein zweites Semikolon fehlt.

Behebt das dein Problem?

Davon abgesehen frage ich mich, wie du das kompiliert hast, denn in C ist es auch nicht erlaubt, die Laufvariable im Schleifenkopf zu deklarieren. 🙂 Also sollte es eigentlich zumindest so aussehen (an den anderen Stellen natürlich auch): 
/*Kreuzprodukt speichern*/
int i;
for (i = 0; i <= 2; i++)
{
	erg_kreuz[i] = kreuz(a_1, a_2, a_3, b_1, b_2, b_3);	
}
Besser wär's vielleicht auch, sich für eine Variable (loop oder i) zu entscheiden und die am Funktionsanfang bei den anderen Variablen zu deklarieren.

So ein paar einfache Tests mit anschaulichen Vektoren haben dann das richtige Ergebnis gebracht.
Also ich weiß ja nicht, wie das anderen geht, aber ich versteh bei dem
Kauderwelsch nur Bahnhof. Auch auf die Gefahr hin, damit Deine Hausaufgaben zu
machen, hab ich mir mal die Freiheit genommen, das Ganze in lesbaren C Code
umzubauen. Schließlich musst Du vielleicht irgendwann mal für mich oder mit mir
arbeiten...
/*Aufgabe: Skalarprodukt, Vektorprodukt und Spatprodukt als Funktionen*/
#include<stdio.h>

/*Deklariere die Funktionen*/
double skalar(int n, double* a, double* b);
double* kreuz(double* a, double* b, double* result);
double spat(double* a, double* b, double* c);

/*Hauptprogramm*/
int main()
	{
	/*Variablendeklaration*/
	double a[3];
	double b[3];
	double c[3];

	/*Einlesen der Komponenten*/
        int loop;
	for(loop = 0; loop <= 2; loop++)
	{ 
		printf("Komponente a_%i: ", loop);
		scanf("%lf", &a[loop]);
	}

	printf("\n");

	for(loop = 0; loop <= 2; loop++)
	{ 
		printf("Komponente b_%i: ", loop);
		scanf("%lf", &b[loop]);
	}
	
	printf("\n");
	
	for(loop = 0; loop <= 2; loop++)
	{ 
		printf("Komponente c_%i: ", loop);
		scanf("%lf", &c[loop]);
	}
	
	printf("\n");

	double erg_kreuz[3];
	kreuz(a, b, erg_kreuz);

	/*Ergebnis Skalarprodukt ausgeben*/
	printf("a * b = %.2lf\n", skalar(3, a, b));
	/*Ergebnis Kreuzprodukt ausgeben*/
	printf("a x b = (%.2lf,%.2lf,%.2lf)\n", erg_kreuz[0], erg_kreuz[1], erg_kreuz[2]);
	/*Ergebnis Spatprodukt ausgeben*/
	printf("(a x b) * c = %.2lf\n", spat(a, b, c));

	return 0;
}

/*Definiere die Funktionen*/
double skalar(int n, double* a, double* b)
{
	double erg = 0.;
	
	/*Berechnen des Skalarproduktes*/
        int loop;
	for(loop = 0; loop < n; loop++)
	{
		erg += a[loop] * b[loop];
	}
	
	return erg;
}

double* kreuz(double* a, double* b, double* result)
{
	result[0] = a[1]*b[2] - a[2]*b[1];
	result[1] = a[2]*b[0] - a[0]*b[2];
	result[2] = a[0]*b[1] - a[1]*b[0];

	return result;
}

double spat(double* a, double* b, double* c)
{
	double erg_kreuz[3];
	return skalar(3, kreuz(a, b, erg_kreuz), c);
}
Viel Spaß damit! Ach und noch was: Variablen, Klassen, Dokumentation, etc wird
eigentlich immer in Englisch geschrieben. Das zu korrigieren überlasse ich aber
mal lieber Dir 😉

  • [gelöscht]

  • Beitrag Nr. 4 
#!/usr/bin/python
# -*- coding: utf-8 -*-

a = [1,0,0]
b = [0,1,0]
c = [0,0,2]

spat=a[1]*b[2]*c[0]-a[2]*b[1]*c[0]+a[2]*b[0]*c[1]-a[0]*b[2]*c[1]+a[0]*b[1]*c[2]-a[1]*b[0]*c[2]

print("(a x b)*c = {0}".format(spat))
So sieht die Berechnung des Spatprodukts bei mir mit python aus. Auf eine direkte Abfrage der Vektoren und Überprüfung der Eingabe mittels Exceptions habe ich jetzt erstmal verzichtet. Dafür hat das Schreiben aber auch weniger als 60 Sekunden gedauert.

  • [gelöscht]

  • Beitrag Nr. 5
Hier auch nochmal mit Funktionen: 
#!/usr/bin/python
# -*- coding: utf-8 -*-

a = [1,0,0]
b = [0,1,0]
c = [0,0,2]

def vektorprodukt(x,y):
	vektor = [0,0,0]
	vektor[0] = x[1]*y[2]-x[2]*y[1]
	vektor[1] = x[2]*y[0]-x[0]*y[2]
	vektor[2] = x[0]*y[1]-x[1]*y[0]
	return vektor

def skalarprodukt(x,y):
	skalar = 0
	for i in range(len(x)):
		skalar += x[i]*y[i]
	return skalar

def spatprodukt(x,y,z):
	h = vektorprodukt(x,y)
	spat = skalarprodukt(h,z)
	return spat


spat1 = spatprodukt(a,b,c)

print("Methode 1: (a x b)*c = {0}".format(spat1))

spat2 = a[1]*b[2]*c[0]-a[2]*b[1]*c[0]+a[2]*b[0]*c[1]-a[0]*b[2]*c[1]+a[0]*b[1]*c[2]-a[1]*b[0]*c[2]

print("Methode 2: (a x b)*c = {0}".format(spat2))

  • [gelöscht]

  • Beitrag Nr. 6
Noch kürzer gehts hiermit: 
Spatprodukt = \sum_{ijk} \epsilon_{ijk} a_i b_k c_k

  • [gelöscht]

  • Beitrag Nr. 7
Freak84 schriebNoch kürzer gehts hiermit: 
Spatprodukt = \sum_{ijk} \epsilon_{ijk} a_i b_k c_k
Muss natürlich c_j lauten und nicht c_k
Danke für die Antworten 🙂

@Vain

Ja, das mit dem Semikolon hab ich auch grad gesehen, hatte gestern die for-Schleife testweise mal gegen eine while-Schleife getauscht und dann das Semikolon vergessen. Und die Laufzeitvariable ließ sich im Schleifenkopf deklarieren, wenn ich beim kompilieren -std=c99. Aber es ändert sich trotzdem nichts.

@the_isz

Nein, eine Hausaufgabe ist es nicht 🙂 Aber von Zeigern hab ich derzeit weniger (um nicht zu sagen fast garkeine) Ahnung. Trotzdem danke für die Mühe, ist interessant zu sehen, wie es besser gemacht wird.

@Mathematiker

Naja, meine Mathematik-Professorin hat uns nahegelegt, programmieren zu lernen. Weil ich in C schonmal reingeguckt hab und es das Erste war, was mir zwischen die Finger kam, wollte ich es mit C probieren. Aber Python sieht interessant aus, ich werde es mir auch mal angucken.

@Freak1984

Das Levi-Civita-Symbol kenne ich zwar, aber ich wüsste nicht, dass es in C einfach so aufzurufen ist. Oder meintest du auch Python?

Wenn ich mich nicht total verrechne, dann ist das Ergebnis immer um eins zu hoch.
Komponente a_0: 1
Komponente a_1: 1
Komponente a_2: 1

Komponente b_0: 1
Komponente b_1: 1
Komponente b_2: 1

Komponente c_0: 1
Komponente c_1: 1
Komponente c_2: 1

a * b = 3.00
a x b = (0.00,0.00,0.00)
(a x b) * c = 1.00
Wenn ich aber immer wieder nach der Zuweisung einmal den Wert der Variablen ausgeben lasse, dann erhalte ich anscheinend das richtige Ergebnis:
/*Kreuzprodukt speichern*/
	for(i = 0; i <= 2; i++) {

		erg_kreuz[i] = kreuz(a_1,a_2,a_3,b_1,b_2,b_3); printf("%.2lf\n", erg_kreuz[i]);
		
	}
Wenn ich mich nicht total verrechne, dann ist das Ergebnis immer um eins zu hoch.
Komponente a_0: 1
Komponente a_1: 1
Komponente a_2: 1

Komponente b_0: 1
Komponente b_1: 1
Komponente b_2: 1

Komponente c_0: 1
Komponente c_1: 1
Komponente c_2: 1

0.00
0.00
0.00
a * b = 3.00
a x b = (0.00,0.00,0.00)
(a x b) * c = 0.00
Das verstehe ich nicht, weil ich dachte, Variablenwerte ausgeben ändert diese Werte nicht.

  • [gelöscht]

  • Beitrag Nr. 9
Ich wüsste nicht, dass es den epsilon Tensor (Levi-Civita-Operator) schon fest gibt, aber man könnte ja eine entsprechende Funktion dazu schreiben und die immer wieder verwenden. Vielleicht gibt es ihn aber in der GnuScientificLibrary (gsl) für C oder in scipy, numpy, pylab, ..., für Python.
Wenn du viele numerische Berechnungen durchführen möchtest, dann würde ich auch zu Python raten, da es viele Pakete für solche Zwecke gibt und man es mit Matlab vergleichen kann. Auch wenn Python als Skriptsprache wohl langsamer als C ist, kommt man meiner Erfahrung nach mit Python doch schneller zum Ziel, da das reine Schreiben der Skripte weniger aufwendig ist als vergleichbarer Code in C. Ich bin aber auch kein Experte in C, kann also sein, dass der Entwicklungsaufwand doch nicht so groß ist.
Freak84 schriebIch bin aber auch kein Experte in C, kann also sein, dass der Entwicklungsaufwand doch nicht so groß ist.
Ne, das hast Du schon richtig geschrieben. Mit Python kommt man sicher schneller
ans Ziel, besonders wenn man sich mit dem Programmieren noch nicht so auskennt.

Ein Grund eine kompilierte Sprache wie C oder C++ zu verwenden ist halt die
Geschwindigkeit. Solange es auf die nicht ankommt, würde ich auch zu Python oder
einer vergleichbaren Sprache (perl, lua) raten.

Lustig wird's dann erst, wenn man irgendwann dann doch C/C++ braucht und erstmal
merkt, wieviel einem Python eigentlich abnimmt. Sowohl im positiven Sinne
(einfachere Handhabung vieler Dinge, z.B. Datei Input/Output), als auch im
negativen (eingeschränktere Möglichkeiten).
Iceberg schrieb Das verstehe ich nicht, weil ich dachte, Variablenwerte ausgeben ändert diese Werte nicht.
Tun sie auch nicht.

Mir ist heute morgen nicht aufgefallen, dass du "erg" in "skalar()" gar nicht initialisiert hast. Das ist in C absolut fatal, weil nicht-initialisierte Variablen "zufällige" Werte annehmen. Ganz zufällig sind diese Werte halt auch nicht, deswegen hat dein "printf" einen gewissen Effekt gehabt.

Wenn du nun mit einem unbestimmten Wert in "erg" startest und weiter unten in der for-Schleife aber "erg = erg + ..." stehen hast, dann, naja, ist klar, oder? 😉
@Vain

Habs geändert, jetzt läufts. Vielen Dank 🙂
12 Tage später
ich würd glaub haskell für son zeug benutzen. Ich lern grad Haskell in der Uni und bin da auch noch ein blutiger anfänger. Mein bisheriger Eindruck ist, dass ich haskell besonders bei mathematische Sachen, C/C++,Java,python,... vorziehen würde. Nicht nur weil man ne menge schreibarbeit spart.

Nein jetzt kommt kein assembler...es gibt außerdem zahlreiche fertige funktionen im netz sowie matheprogramme wie maxima,mathematica, die das spatptodukt berrechnen aber wenn man nur kopiert lernt mans nicht so gut.