Vektorrechnung

schau dir einfach mal http://de.wikipedia.org/wiki/Vektor_%28Mathematik%29 an da kommen alle Operationen vor.
und printVetor sollst nehm ich an einfach einen Vector ausgeben also (x,y,z) oder so in der Richtung

also, zu vektorrechnung gibts schon zig hunderte libs im internet wo man sich das anschauen kann in allen sprachen da man das für grafikprogrammierung braucht

Zitat

Wieso heisst es bei der Multiplikation
Vector mult( double value, const Vector *v2 );
und nicht
Vector mult( const Vector *v1, const Vector *v2 );

weil man 2 vektoren nicht miteinander multiplizieren kann, das ist nicht irgendwie festgelegt deswegen wird hie rmit einem skalar multipliziert, das ergebnis soll einfach sein

v2->x * value, v2->y * value, v2->z * value

dann

Zitat

Und was ist dann
Vector dot( const Vector *v1, const Vector *v2 );
?

das punktprodukt, wird verwendet für den winkel zwischen zwei vektoren, ich glaube du musst dich da verschrieben haben weil die fkt einen vektor zurück gibt aber das punktprodukt ist ein skalar

berechnung sieht so aus

float dot(D3DVECTOR& v1, D3DVECTOR& v2) 
{
 return ( v1.x * v2.x + v1.y * v2.y + v1.z * v2.z );    
}

Zitat

Aber das ist nicht das Hauptproblem.
Sondern wie macht man dann die Eingabe Ausgabe?

ausgabe... naja einfach cout << "x: " << vec.x << " y: " << vec.y etc
einfach irgendwie ausgeben.. wenn du ne eingabe machen musst der reihe nach die elemente eingeben

Zitat

Und was kommt in das Modul scalar.h und was in scalar.c ?

ka du hast da in der fragestellung nichts nem modul skalar erwähnt... skalar ist einfach ein einziger float / double wert... wüsst nicht wofür man da ein extra modul bräuchte, hört sich unsinnig an

Zitat

Vector set( double vec[3] );

naja einfach

Vector set( double vec[3] )
{
  Vector newVector;
  newVector.x = vec[0];
  newVector.y = vec[1];
  newVector.z = vec[2];


  return newVector;
}

Zitat von Vevusio

weil man 2 vektoren nicht miteinander multiplizieren kann, das ist nicht irgendwie festgelegt

Aber natürlich kann man - vorausgesetzt sie haben dieselbe Dimension. Beispiel: (a b) * (c d) = a*c + b*d

xxyy: Warum verwendest du in den Parametern Zeiger? Wenn du schon in C++ bist, drängen sich dafür Referenzen geradezu auf. Beispiel:

Vector add(const Vektor& v1,const Vektor& v2);

Wobei man das in OO-Sprachen eigentlich nicht so schreibt! Der Vektor, zu dem man addiert, sollte der durch die aktuelle Instanz festgelegte sein (also v2 weglassen und v1 zum aktuellen Vektor addieren). Das, was du machst, ist Java-Library-Stil, hat aber mit OO nix zu tun.

ja klar kann man x*x, y*y etc elementweise 2 vektoren multiplizieren aber soweit ich weiß ist das nirgends standardisiert dass v1*v2 gerechent wird indem v3.x = v1.x * v2.x usw oder?

ich würd auch referenzen nehmen weil man mit denen besser arbeiten kann aber wieso meinst du er sollte sie jetzt statt den pointern hier verwenden, im endeffekt ist es ja fast dasselbe

Zitat von sauzachn

(..)Wobei man das in OO-Sprachen eigentlich nicht so schreibt! Der Vektor, zu dem man addiert, sollte der durch die aktuelle Instanz festgelegte sein (also v2 weglassen und v1 zum aktuellen Vektor addieren). Das, was du machst, ist Java-Library-Stil, hat aber mit OO nix zu tun.

wieso er das so macht?.. weil es seine aufgabenstellung ist vielleicht es so zu machen? *g*

übrigens finde ich das immer noch objekt orientiert, die directx vektor klasse zb hat überladene +=, -=, etc operatoren, dazu funktionen wie Add(), Normalize() etc die direkt auf den vektor zugreifen aber auch statische funktionen in der form von denen da oben die nen neuen vektor liefern die in vielen situationen auch nützlich sind

Zitat von Vevusio

ja klar kann man x*x, y*y etc elementweise 2 vektoren multiplizieren aber soweit ich weiß ist das nirgends standardisiert dass v1*v2 gerechent wird indem v3.x = v1.x * v2.x usw oder?

Naja, für verschiedene Vektorräume ist es schon unterschiedlich. Aber im R^n macht man das Skalarprodukt so.
In anderen Prähilberträumen kann <v1,v2> wieder ganz anders aussehen. Es muss nur gewissen Axiomen gehorchen.

Zitat von Vevusio

ich würd auch referenzen nehmen weil man mit denen besser arbeiten kann aber wieso meinst du er sollte sie jetzt statt den pointern hier verwenden, im endeffekt ist es ja fast dasselbe

Nein, es gibt ein paar Unterschiede. Das wichtigste ist, dass du mit Referenzen nicht so viel Blödsinn machen kannst. Z.b. kannst du einen Zeiger ohne Weiteres umbiegen, eine Referenz aber nicht mehr, nachdem sie einmal worauf "zeigt". Das ist genau das, was man bei Funktionsparametern in 99.9% der Fälle will.

Eine genauere ausführliche Begründung steht glaub ich im Meyers, wenn ich mich richtig erinnere.

Zitat von Vevusio

aber auch statische funktionen in der form von denen da oben die nen neuen vektor liefern die in vielen situationen auch nützlich sind

Nützlich: ja natürlich. OO: Nein. Es sind nix Anderes als globale Funktionen. Du kannst sie gleich außerhalb der Klasse schreiben.

Zitat von sauzachn

Nein, es gibt ein paar Unterschiede. Das wichtigste ist, dass du mit Referenzen nicht so viel Blödsinn machen kannst. Z.b. kannst du einen Zeiger ohne Weiteres umbiegen, eine Referenz aber nicht mehr, nachdem sie einmal worauf "zeigt". Das ist genau das, was man bei Funktionsparametern in 99.9% der Fälle will.

jep aber zeiger selbst sind value types, wenn ich ihn also an die fkt übergebe bekommt sie ja blos ne kopie vom zeiger und selbst wenn sie den verändert bleibt er außerhalb der funktion gleich

außer ich übergebe nen zeiger oder referenz auf meinen zeiger dann kann die funktion ihn verhauen aber wenn ich nen zeiger auf nen zeiger übergebe dann will ich wahrscheinlich dass die funktion ihn auf neuen speicher zeigen lässt und ihn ändert

also ist es im endeffekt wieder dasselbe wie ne referenz wenn ich es in dem zusammenhang mit der funktion verwende?! ich hab mir das immer so vorgestellt

Zitat von xxyy

void printVector( const Vector * v );
{
printf("%lf %lf %lf",result.x, result.y, result.z);
}

Das stimmt nicht ganz:

void printVector( const Vector * v )
{
printf("%lf %lf %lf",v->x, v->y, v->z);
}

genau, und dot mult und set sehen richtig aus

Du hast Vector nie definiert! Sollte wohl so ähnlich wie das aussehen:

typedef struct {
  double x;
  double y;
  double z;
} Vector;

Zitat von xxyy

printVektor gibt das Ergebnis aus oder? Wenn ja, woher soll er wissen, dass "v" zu "result.x, result.y, result.z" gehört?

Tja, das solltest du ihm auch sagen. Wenn eine Funktion Parameter erwartest, musst du ihm solche auch übergeben.

Du hast meinen Strichpunkt-Fehler übrigens übernommen, den solltest noch ausbessern (zwischen parameterliste einer funktion und { kommt niemals ein ; -- ich hab wohl zu viel Pascal gemacht in letzter Zeit).

main()
{
Vector v1,v2;


printf("1. Vektor eingeben: ");
scanf("%lf %lf %lf",&v1->x,&v1->y,&v1->z);


printf("2. Vektor eingeben: ");
scanf("%lf %lf %lf",&v2->x,&v2->y,&v2->z);


printVector(v1);
printVector(v2);


}

Ich würd dir echt empfehlen, dir mal C anzusehen. Lohnt sich!

die pronix tutorials find ich gut hab sie auch mal gelesen, die scripten hier... die meisten typen an der uni sind einfach keine lehrer sondern machen das scheinbar als hobby oder ka, die können den stoff überhaupt nicht rüberbringen dementsprechend sind dann die scripten (ist mein eindruck bisher zumindest)

Vector v1, v2;
...
scanf("%lf %lf %lf", &v1.x, &v1.y, &v1.z);

so gehört es, mit -> greifst du auf elemente von variablen zu die pointer sind aber v1 und v2 sind in dem fall ganz normale variablen und keine pointer variablen also nimmt man den . operator

dann, all deine funktionen nehmen const Vector * als parameter zb

void printVector( const Vector * v )

und da wir gerade festgestellt haben deine v1 und v2 die du in der main definierst sind ganz normale variablen kannst du sie nicht einfach übergeben und sie werden automatisch von Vector zu Vector* (also ein zeiger auf eine vector variable)

ein zeiger zeigt auf eine speicheradresse von einer bestimmten form, Vector* zeigt auf speicher der form Vector und über den & operator holst du dir die speicheradresse von etwas

also wenn du funktionen wie printvektor aufrufst müssen die so aussehen
(in der main, oder wo auch immer die funktion aufgerufen wird)

printVector(&v1);

du könntest auch sowas machen wie

Vector *v1Pointer = &v1;
printVector(v1Pointer);

um mal klarzumachen wie der referenzierungsoperator (&) funktioniert, du bekommst einfach nen pointer (der ein zeiger auf eine speicheradresse von nem bestimmten typ ist) zurück, wenn du auf ein

int a;

das anwendest mit

&a

bekommst du einen pointer auf int also

int *

dann der letzte fehler, du hast kein result, ganz am ende

add(&v1, &v2);
printVector(&result);

das result ist nur innerhalb der funktion bekannt und die funktion liefert es wieder zurück allerdings nicht so dass es die variable irgendwie in der main definiert und auf ein mal kannst du sie verwenden, die funktion liefert einfach einen vektor zurück, so wie du es gemacht hast rufst du add auf, es liefert dir nen vektor der aber schwupps verloren ist weil du ihn nirgends abspeicherst und dann versuchst du printVector aufzurufen obwohl du garkeine variable namens result definiert hast, richtig würde es so aussehen

Vector v3;
v3 = add(&v1, &v2);
printVector(&v3);

du definierst erst in der main dass es einen Vector v3 gibt, dann wird v3 der rückgabewert der funktion zugewiesen, und dann v3 aussgeben

natürlich muss die variable nicht v3 heißen sondern du kannst sie nennen wie du willst

Eine ganz nette Einführung ist auch

http://boredzo.org/pointers/