OpenMP: Verständnisfrage zu Vektoren, Matrizen (2D, 3D) und Arrays (2D, 3D)

[Schlitzauge]

Hi COM,

also Parallelisieren mittels OpenMP funktioniert mittlerweile wunderbar.

Wie das Addieren, Subtrahieren, Multiplizieren und Dividieren mit Vektoren bzw. Matrizen funktioniert ist mir auch bewusst (also mathematisch). Ich glaube auch, dass ich eine erfolgreiche Vektor- bzw. auch Matrix-Addition programmiert habe, soweit so gut.

Ich habe allerdings gerade ein Verständnisproblem zwischen Arrays, Vektoren und Matrizen.

Hier erstmal der Code einer stinknormalen 1D-Vektoraddition (Skalare Addition):

1DVecAdd64.cpp:

const uint64_t NumValues = 800000000ULL;

uint64_t a[NumValues] = {0ULL}, \

         b[NumValues] = {0ULL}, \

         c[NumValues] = {0ULL};


//serielle Variante:

for(uint64_t i=0ULL;i<NumValues;++i)

{

  c[i] = a[i] + b[i];

}


//parallele Variante:

#pragma omp parallel default(none) shared(std::cout, a, b, c)

{

  #pragma omp flush

  #pragma omp for schedule(static)

  for(uint64_t j=0ULL;j<NumValues;++j)

  {

    c[j] = a[j] + b[j];

  }

}

Funktioniert soweit auch wunderbar. Nun wollte ich aber mal in weitere Dimensionen vordringen, sprich 2D, 3D und 4D. Doch jetzt hab ich das Problem den Sinn und Zweck von mehrdimensionalen Arrays zu verstehen. Dazu mal ein Bsp.-Programm, wie ich eine 2D-Vektoraddition umgesetzt habe: 2DVecAdd64_1.cpp:

const uint64_t NVdim1 = 400000000ULL, NVdim2 = 400000000ULL;

//NVdim1: x (col)

//NVdim2: y (row)

uint64_t a[NVdim1][NVdim2] = {{0ULL}}, \

         b[NVdim1][NVdim2] = {{0ULL}}, \

         c[NVdim1][NVdim2] = {{0ULL}};


//serielle Variante:

for(uint64_t i=0ULL;i<NVdim1;++i)

{

  for(uint64_t j=0ULL;j<NVdim2;++j)

  {

    c[i][j] = a[i][j] + b[i][j];

  }

}


//parallele Variante:

#pragma omp parallel default(none) shared(std::cout, a, b, c)

{

  #pragma omp flush

  #pragma omp for schedule(static)

  for(uint64_t i=0ULL;i<NVdim1;++i)

  {

    for(uint64_t j=0ULL;j<NVdim2;++j)

    {

      c[i][j] = a[i][j] + b[i][j];

    }

  }

}

Was ist da der Unterschied zu vorher, also zur 1D-Variante? Für mich passiert hier genau das selbe: Skalare Additionen, nur liegen hier die Skalare (Array-Elemente) nicht mehr in einem 1D-Array, sondern in einem 2D-Array vor. Tatsache ist aber, dass über die Indizes jeweils immer nur eine normale Variable (Skalar) angesteuert wird, letztendlich also das gleiche passiert, wie im obigen Programm 1DVecAdd64. Was ich aber möchte ist eine klassische 2D-Vektoraddition (also eine Addition von zweikomponentigen Vektoren der Form v_n(x,y)). Ich möchte also folgendes damit berechnen können:

v1(x1,y1) + v2(x2,y2) = v3(x1+x2,y1+y2) = v3(x3,y3)

Bsp.:

v1(5,7) + v2(2,3) = v3(5+2,7+3) = v3(7,10)

Also die komponentenweise Addition. Ich sehe in meinem 2DVecAdd64_1-Prog aber nur die gleiche Berechnung wie im 1DVecAdd64-Prog, eine Addition von Skalaren. Weshalb mich das verwirrt?: Gerechnet wird stets nur mit Skalaren (1D-Vektoren), was den einzelnen Komponenten mehrkomponentiger (mehrdimensionaler) Vektoren entspricht. Ob ich mir jetzt ein eindimensionales Array hernehme:

1DArray[25];

oder ein zweidimensionales Array:

2DArray[5][5];

ist doch egal. Das sind in meinen Augen immer noch die gleichen Daten(mengen), lediglich etwas anders angeordnet und nun anders adressierbar. Gerechnet wird beim 2DVecAdd64_1-Prog letztenendes so:

A_ArrayElement+B_ArrayElement = C_ArrayElement;

Der Unterschied zwischen beiden Progs ist einfach nur die Art der Adressierung der Elemente (beim 1D-Prog gibt es jeweils nur einfache Indize, beim 2D-Prog halt zweifache Indize, schlussendlich wird aber jeweils immer nur ein Element (Skalar) angesprochen). Damit realisiere ich aber nicht das, was ich mir vorgestellt habe (glaube ich zumindest). Also habe ich es mal mittels eigenem Datentyp realisiert: 2DVecAdd64_2.cpp:

struct V2D //2D-Vektor

{

  public:

    uint64_t x, y;

    V2D(uint64_t X = 0ULL, uint64_t Y = 0ULL):x(X),y(Y){}

    ~V2D(){};

};


const uint64_t Num2DVecs = 400000000ULL; //Anzahl 2D-Vektoren

struct V2D a[Num2DVecs], \

           b[Num2DVecs], \

           c[Num2DVecs];


//serielle Variante:

for(uint64_t i=0ULL;i<Num2DVecs;++i)

{

  c[i].x = a[i].x + b[i].x;

  c[i].y = a[i].y + b[i].y;

}


//parallele Variante:

#pragma omp parallel default(none) shared(std::cout, a, b, c)

{

  #pragma omp flush

  #pragma omp for schedule(static)

  for(uint64_t j=0ULL;j<Num2DVecs;++j)

  {

    c[j].x = a[j].x + b[j].x;

    c[j].y = a[j].y + b[j].y;

  }

}

Damit kann ich genau das realisieren / so rechnen, wie eben beschrieben. Jetzt könnte ich das für 3D und 4D so weiter machen, doch irgendwie werde ich nicht daraus schlau. Meine Frage ist nun, was richtig ist, um mit 2D-Vektoren (Vektor mit zwei Komponenten x und y) zu rechnen? (und warum). Ich meine, die Lösung mit eigenem Datentyp funktioniert und ist richtig. Doch wie müsste die Lösung aussehen, wenn ich das ausschließlich mit klassischen Arrays umsetzen möchte? Um es nochmal deutlich zu machen: ich möchte keine 1D-Vektor/Skalar-Addition:

a+b=c

, sondern eine 2D-Vektor-Addition (wo also jeweils einzeln die [x,y] Komponenten zweier solcher 2D-Vektoren zu Ergebniskomponenten eines 2D-Ergebnisvektors errechnet werden):

v1(x1,y1) + v2(x2,y2) = v3(x1+x2,y1+y2) = v3(x3,y3)

Ich habe folgendes versucht: 2DVecAdd64_3.cpp

const uint64_t NVdim1 = 400000000ULL, NVdim2 = 400000000ULL;

//NVdim1 = x (col)

//NVdim2 = y (row)

uint64_t a[NVdim1][NVdim2] = {{0ULL}}, \

         b[NVdim1][NVdim2] = {{0ULL}}, \

         c[NVdim1][NVdim2] = {{0ULL}};


//serielle Variante:

for(uint64_t i=0ULL;i<NVdim1;++i)

{

  for(uint64_t j=0ULL;j<NVdim2;++j)

  {

    c[i][j] = a[i][j] + b[i][j];

  }

}


omp_set_nested(2);

//parallele Variante:

#pragma omp parallel default(none) shared(std::cout, a, b, c)

{

  #pragma omp flush

  #pragma omp for collapse(2) schedule(static)

  for(uint64_t i=0ULL;i<NVdim1;++i)

  {

    for(uint64_t j=0ULL;j<NVdim2;++j)

    {

      c[i][j] = a[i][j] + b[i][j];

    }

  }

}

Der gleiche Fall wieder. Was bringt mir das, wenn doch nur wieder Skalare miteinander addiert werden??? Meine Vermutung ist ja, dass ich etwas Grundlegendes verwechsle. Mittels Array kann man einen 2D-Vektor (zwei Komponenten) wie folgt darstellen:

array[2];

wobei das array[] der Vektor ist und das Element mit Index 0 (array[0]) die x-Komponente und das Element mit Index 1 die y-Komponente. An sich liegen diese Komponenten aber erst einmal gleichwertig hintereinander. Wäre dann ein zweidimensionales Array:

array2D[2][2]

quasi zwei solcher Vektoren?

Liegt es dann an mir / am Programmierer, jeweils die richtigen Datenelemente als x- und y-Komponenten zu interpretieren (etwa bei der Ausgabe oder beim Algorithmieren)?

Das würde dann auch einiges erklären, wobei mir der Weg mittels struct dann doch optisch ansprechender und verständlicher erscheint.

Ich danke vielmals im Voraus.

Grüße

Schlitzauge

[flashpixx]

Wo ist der Zusammen zu OpenMP? Für mich ist Deine semantisches / mathematisches Problem.

Liegt es dann an mir / am Programmierer, jeweils die richtigen Datenelemente als x- und y-Komponenten zu interpretieren (etwa bei der Ausgabe oder beim Algorithmieren)?

Das würde dann auch einiges erklären, wobei mir der Weg mittels struct dann doch optisch ansprechender und verständlicher erscheint.

Dir nützt ein Struct nicht viel, wenn Du nicht weißt welche Dimension Dein Vektor hat, z.B. wenn der Benutzer die Dimensionalität festlegt. Das Struct muss zur Compilezeit bekannt sein, in diesem Fall wäre aber die Dimensionalität nicht bekannt und damit kannst Du kein Struct anlegen.

Mir scheint aber, dass Du Vektoren als "Punktbeschreibung" ansiehst, das ist aber so nicht richtig und mathematisch nicht vollständig. Du solltest damit beginnen, was Vektoren überhaupt sind (Vektorraum), wie sich dazu Matrizen (Matrix (Mathematik)) verhalten, gerade welche Bedeutung dazu Körper (Algebra) haben. Davon kommt man dann zu Vektorraum bzw Topologischer Raum und Norm (Mathematik) und Metrischer Raum (diese ganzen Strukturen finden sich auch in der Literatur zur Linearen Algebra).

Aufgrund der theoretischen Strukturen wäre dann im nächsten Schritt zu überlegen, wie man diese in einem Algorithmus / Datenstruktur umsetzt. Die technische Umsetzung hat nicht zwingend mit der mathematische Definition zu tun. Wenn ich z.B. einen 2D Vektor habe, dann kann dieser z.B. Kartesisches Koordinatensystem oder auch Polarkoordinaten enthalten, d.h. die inhaltliche Interpretation ist wiederum unabhängig von der technischen Umsetzung oder der mathematischen Definitionen. In den meisten Fällen wird man aber keine 2D oder 3D Vektoren als Datenstruktur entwerfen, sondern das ganze direkt als n-dimensionalen Datentyp entwerfen, da sich damit automatisch eine größere Flexibilität ergibt. Mit Matrizen kann man analog verfahren, wobei dann zu einem Hyperwürfel kommt, der häufig im Bereich Datawarehouse verwendet wird bzw. sobald man mehrdimensionale Ebenen / Strukturen realisieren muss

[Klotzkopp]

Um es nochmal deutlich zu machen: ich möchte keine 1D-Vektor/Skalar-Addition:

a+b=c

, sondern eine 2D-Vektor-Addition (wo also jeweils einzeln die [x,y] Komponenten zweier solcher 2D-Vektoren zu Ergebniskomponenten eines 2D-Ergebnisvektors errechnet werden):

v1(x1,y1) + v2(x2,y2) = v3(x1+x2,y1+y2) = v3(x3,y3)

Du siehst da einen Unterschied, wo keiner ist.

Letztendlich rechnest du auch im zweiten Fall x3=x1+x2 und y3=y1+y2. Jede Rechenoperation auf Vektoren wird auf Operationen auf die skalaren Komponenten zurückgeführt, und das zeigt sich zwangsläufig in der Implementierung.

Bearbeitet 16. Dezember 2011 von Klotzkopp

[Schlitzauge]

Wo ist der Zusammen zu OpenMP?

Dazu komme ich erst noch.

Dir nützt ein Struct nicht viel, wenn Du nicht weißt welche Dimension Dein Vektor hat, z.B. wenn der Benutzer die Dimensionalität festlegt. Das Struct muss zur Compilezeit bekannt sein, in diesem Fall wäre aber die Dimensionalität nicht bekannt und damit kannst Du kein Struct anlegen.

Ja, dass gilt aber nur, wenn das Arrays dynamisch angelegt ist / wird. In meinem Fall hab ich es erstmal statisch angelegt. Ich möchte erstmal mit zweikomponentigen mathematischen Vektoren rechnen (x1+x2,y1+y2), es ist also eine festgelegte Vorgabe. Dazu bietet sich meine Lösung mit meinem struct-Datentyp auch entsprechend an. Nun würde ich aber mal gerne wissen, wie ich das rein mittels Arrays realisieren kann?

Dazu habe ich mal einen Versuch unternommen:

2DVecAdd64_3.cpp

const uint64_t NVdim1 = 400000000ULL, NVdim2 = 400000000ULL;

//NVdim1 = x (col)

//NVdim2 = y (row)

uint64_t a[NVdim1][NVdim2] = {{0ULL}}, \

         b[NVdim1][NVdim2] = {{0ULL}}, \

         c[NVdim1][NVdim2] = {{0ULL}};


//serielle Variante:

for(uint64_t i=0ULL;i<NVdim1;++i)

{

  for(uint64_t j=0ULL;j<NVdim2;++j)

  {

    c[i][j] = a[i][j] + b[i][j];

  }

}


omp_set_nested(2);

//parallele Variante:

#pragma omp parallel default(none) shared(std::cout, a, b, c)

{

  #pragma omp flush

  #pragma omp for collapse(2) schedule(static)

  for(uint64_t i=0ULL;i<NVdim1;++i)

  {

    for(uint64_t j=0ULL;j<NVdim2;++j)

    {

      c[i][j] = a[i][j] + b[i][j];

    }

  }

}

Nur bin ich mir jetzt unsicher, ob ich auch genau das Gleiche wie beschrieben (x1+x2,y1+y2) realisiere. Wenn ja, warum, wenn nein, warum nicht und wie müsste es denn ausschauen?

Konkret gefragt, würde ich gerne wissen, wie denn meine struct-Lösung mit Arrays zu realisieren ist?

Mir schweben da so einige Gedanken durch den Kopf:

a.) 1D-Zeiger-Array von zweikomponentigen Arrays, also:

Zweikomponentiges Array (2D-Vektor): array[2];

und davon halt ein Array für n 2D-Vektoren (bei mir stellvertretend durch a, b und c) anlegen.

b.) Mittels mehrdimensionalem Array:

2DArray[x][y];

halt so, wie ich es bereits umgesetzt habe. Ich sehe da nur nicht, weshalb dort jeweils die Komponenten (x1+x2,y1+y2) miteinander addiert werden? Für mich sehe ich da nur eine skalare Addition, also das gleiche wie bei meinem ersten 1DVecAdd64.cpp-Prog von ganz oben.

Ich verwechsle da anscheinend etwas zwischen der Dimension eines Arrays und der Dimension eines mathematischen Raumes. Da ich dazu noch nicht allzu viel Erfahrung habe, wäre ich für jeden Erklärungsversuch sehr dankbar. Mathematisch kann ich das alles, es hapert vom Verständnis her aber irgendwie bei der programmiertechnischen Umsetzung (also was mehrdimensionale Arrays angeht). Belesen hab ich mich bereits ausführlich genug: Tutorials, Bücher, etc., doch irgendwie werde ich nicht schlauer daraus. Deshalb frage ich nun hier nach. Gut möglich dass ich mit meinen Vermutungen bereits richtig liege, vlt. auch nicht. Ich bräuchte da mal jemanden, der mir nen Tritt verpasst.

Grüße

Schlitzauge :)

[flashpixx]

Ich verwechsle da anscheinend etwas zwischen der Dimension eines Arrays und der Dimension eines mathematischen Raumes.

Nein, wenn man es mit Array macht (bzw. ich würde es mit Zeigern machen, so dass es dynamisch ist), dann hat das Array so viele Elemente wie Dein Raum Dimensionen hat.

Verständnis her aber irgendwie bei der programmiertechnischen Umsetzung (also was mehrdimensionale Arrays angeht).

Für Vektoren brauchst Du keine mehrdimensionalen Arrays. Du brauchst diese erst wenn Du eben mit "(Hyper)Flächen" arbeitest.

Überlege Dir einfach was ein Vektor genau ist, also einmal theoretisch und dann was er praktisch beschreibt. Ebenso was der Operator für eine Bedeutung hat. Mir scheint, dass es bei Dir an der Vorstellung hapert, was ein Vektor ist, Du versuchst mit Deinen Arrays krampfhaft irgendetwas zu realisieren.

Zusätzlich hängst Du Dich an einer XYZ-Darstellung eines Structs fest. Die Problematik hat hier überhaupt nichts mit Code zu tun, also lass diesen weg.

[Schlitzauge]

Nein, wenn man es mit Array macht (bzw. ich würde es mit Zeigern machen, so dass es dynamisch ist), dann hat das Array so viele Elemente wie Dein Raum Dimensionen hat.

Ah ok. Verstehe ich das richtig, dass ein Array von 1000 Elementen (array[1000]) einem 1000-dimensionalen mathematischen Raum gleichkommt? Bzw. ein dreikomponentiges Array (array[3]) einem 3D-Raum?

Du versuchst mit Deinen Arrays krampfhaft irgendetwas zu realisieren.

Zusätzlich hängst Du Dich an einer XYZ-Darstellung eines Structs fest. Die Problematik hat hier überhaupt nichts mit Code zu tun, also lass diesen weg.

Naja, ich möchte nicht irgendwas krampfhaft umsetzen, sondern lediglich Folgendes:

a(x1,y1) + b(x2,y2) = c(x1+x2,y1+y2) = c(x3,y3)

Wie ich bereits mehrfach erwähnt habe, also die Vektoraddition mehrkomponentiger Vektoren (in den Beispielen also mit 2D-Vektoren / zweikomponentiger Vektoren).

Wie ich das mittels struct umsetze, ist klar, funktioniert auch bestens.

Ich wollte das aber gerne mal mittels einfacher Arrays und einmal mittels mehrdimensionaler Arrays umsetzen, ich weiß nur nicht wie. Könnte da mal jemand nen Beispiel-Code geben oder über meine zwei, drei Beispiele drüber gucken, vlt. hab ich ja bereits schon eine Lösung mittels Arrays umgesetzt.

Mir ist schon klar, dass wir hier im C++-Forum sind und nicht im Mathe-Forum. Zum Code-spezifischen Teil, insb. zum OpenMP-spezifischen, komme ich erst noch. Vorher hätte ich das Bisherige aber erstmal gerne abgeklärt. Da das unmittelbar mit meinem eigentlichen Anliegen zu tun hat, wollte ich deshalb nicht gleich zwei getrennte Threads aufmachen.

[flashpixx]

Verstehe ich das richtig, dass ein Array von 1000 Elementen (array[1000]) einem 1000-dimensionalen mathematischen Raum gleichkommt? Bzw. ein dreikomponentiges Array (array[3]) einem 3D-Raum?

Nein, diese Aussage ist falsch. Beantworte doch einmal die Frage "was ist ein Vektor" (keine mathematische Definition, sondern eine praktische). Als nächstes dann "was ist ein Raum" und wie kann man diesen beschreiben.

Du wirfst hier Äpfel mit Birnen durcheinander, du presst auch hier wieder die Strukturen der Mathematik in ein Array, d.h. in eine praktische / technische Umsetzung. Du schreibst "Array == Raum" und das ist falsch.

Naja, ich möchte nicht irgendwas krampfhaft umsetzen, sondern lediglich Folgendes [...]

Gerade dieses einfache Beispiel zeigt doch schon, dass Du die Grundlagen nicht verstanden hast. Die Lösung für Dein Problem ist wirklich einfach, selbst für n-dimensionale Vektoren.

Ich wollte das aber gerne mal mittels einfacher Arrays und einmal mittels mehrdimensionaler Arrays umsetzen, ich weiß nur nicht wie. Könnte da mal jemand nen Beispiel-Code geben oder über meine zwei, drei Beispiele drüber gucken, vlt. hab ich ja bereits schon eine Lösung mittels Arrays umgesetzt.

Ich habe Deine Beispiele gelesen und Dir nützt es hier gar nichts, wenn Dir jemand ein weiteres Beispiel gibt. Du brauchst eine Vorstellung von dem, was Du umsetzen willst und die erlangst Du nicht durch das Lesen von Beispielen, sondern wenn Du darüber nachdenkst.

Wenn Du solche Strukturen aus der lineare Algebra nur verwenden willst, dann würde ich Dir zu Boost Basic Linear Algebra - Boost 1.48.0 bzw. MultiDimensional Array Libary - Boost 1.48.0 raten. Dann musst Du Dich nicht mit der Implementierung und der Mathematik rum schlagen. Letztendlich wirst Du aber, wenn Du die Konzepte, die diesen Strukturen zu Grunde liegen, nicht verstanden hast, immer wieder Probleme bei der praktischen Realisierung haben.

Deine Beispiele zeigen eben, dass Deine Vorstellung nicht richtig ist.

Es ist wirklich gar nicht schwer bzw. kompliziert (außer man will das ganze sehr formal machen, aber ich denke, dass Du das nicht brauchst). Mein Tip: Nicht so kompliziert denken, sondern einfach...

[Schlitzauge]

Nein, diese Aussage ist falsch. Beantworte doch einmal die Frage "was ist ein Vektor" (keine mathematische Definition, sondern eine praktische). Als nächstes dann "was ist ein Raum" und wie kann man diesen beschreiben.

Das war keine Aussage, sondern eine Frage bzw. Hinterfragung und sorry, dass war aber wortwörtliche Deine Aussage:

Nein, wenn man es mit Array macht (bzw. ich würde es mit Zeigern machen, so dass es dynamisch ist), dann hat das Array so viele Elemente wie Dein Raum Dimensionen hat.

Falls ich das falsch verstanden haben sollte, bitte ich um Aufklärung.

Ein Vektor ist allgemein gesagt, eine Menge / Liste von Zahlen (Skalaren), sowie eine Verschiebung im Vektorraum.

Ein Vektor kann selbst wiederum ein Träger von Vektoren sein, etwa ein 2D-Vektor. Ein 2D-Vektor besitzt immer ein Zahlenpaar (x, y), wobei jede Komponente ein einfacher 1D-Vektor (Skalar) ist. Bei 3D-Vektoren spricht man hingegen von einem Tripple bzw. von drei Komponenten (x,y,z), usw.

Raum: Mit geographischen Bezug, im Sinne des euklidischer Raum und des kartesischen Koordinatensystems, beschreibt ein Vektor eine Verschiebung einer n-dimensionalen topologischen Struktur und seine Komponenten die kartesischen Koordinaten.

Gerade dieses einfache Beispiel zeigt doch schon, dass Du die Grundlagen nicht verstanden hast. Die Lösung für Dein Problem ist wirklich einfach, selbst für n-dimensionale Vektoren.

...

Ich habe Deine Beispiele gelesen und Dir nützt es hier gar nichts, wenn Dir jemand ein weiteres Beispiel gibt. Du brauchst eine Vorstellung von dem, was Du umsetzen willst und die erlangst Du nicht durch das Lesen von Beispielen, sondern wenn Du darüber nachdenkst.

...

Es ist wirklich gar nicht schwer bzw. kompliziert (außer man will das ganze sehr formal machen, aber ich denke, dass Du das nicht brauchst). Mein Tip: Nicht so kompliziert denken, sondern einfach.

Hm, schnief.:confused:

Es hilft mir nicht weiter, wenn man mich auf Erkenntnisse aufmerksam macht, die ich für mich schon selber entdeckt habe. Mathematisch ist diese Materie für mich kein Problem, aber irgendwas Grundlegendes tue ich anscheinend beim programmiertechnischen Umsetzen verwechseln, weshalb für mich Missverständnisse => Unklarheiten aufkommen.

Ich würde es eventuell (100% Sicherheit gibt es nie) besser verstehen, wenn man mir konkret sagen würde, was nun richtig ist und was falsch und wenn falsch, warum. Wenn die Umsetzung mittels eindimensionaler Arrays und auch mittels mehrdimensionaler Arrays SO einfach sein soll, warum dann nicht einfach mal einen Beispielcode posten. Ungeachtet dessen, ob ich es verstehe oder nicht, hätte ich wenigstens etwas, was richtig ist und was ich analysieren könnte und ggfl. bei Unklarheit nochmals hinterfragen kann. Tutorials, Nachschlagewerke und Bücher habe ich nun sehr viele durchforstet. Wenn ich die Antwort auf meine Frage(n) dort gefunden hätte, würde ich dann noch hier nachfragen???

Es ist aber keineswegs so, dass ich hier nach Fertiglösungen suche, so nach der Devise: "brauche was, macht mal!", sondern dass ich mich nun sehr lange mit der Materie auseinandersetze und viel ausprobiere (unter Aneignung theoretischen Wissens). Manchmal kann dann trotzdem irgendwas noch unklar erscheinen. Ist ein Forum nicht dazu da, jemanden / andere um Hilfe zu bitten? Ich verlange ja nicht, mir sämtlichen Stoff vorzugaukeln, sondern bitte lediglich darum, mir bei dem einen konkreten Fall zu helfen. Ich wäre bzw. bin sehr dankbar für jede Hilfestellung, Lösungen, Lösungsansätze und Hinweise.

Grüße

Schlitzauge :confused:

[flashpixx]

Ein Vektor ist allgemein gesagt, eine Menge / Liste von Zahlen (Skalaren) [...]

Ja

[...]sowie eine Verschiebung im Vektorraum.

Ein Vektor kann selbst wiederum ein Träger von Vektoren sein, etwa ein 2D-Vektor. Ein 2D-Vektor besitzt immer ein Zahlenpaar (x, y), wobei jede Komponente ein einfacher 1D-Vektor (Skalar) ist. Bei 3D-Vektoren spricht man hingegen von einem Tripple bzw. von drei Komponenten (x,y,z), usw.

Raum: Mit geographischen Bezug, im Sinne des euklidischer Raum und des kartesischen Koordinatensystems, beschreibt ein Vektor eine Verschiebung einer n-dimensionalen topologischen Struktur und seine Komponenten die kartesischen Koordinaten.

Nein, das ist falsch. Eine Verschiebung kann mit einem Vektor beschrieben werden, aber ein Vektor ist keine Verschiebung (eine Äquivalenzrelation existiert hier nicht). Wenn Du sagst, dass ein Vektor selbst wieder Träger von Vektoren sein soll, dann verweise ich einmal auf Träger (Mathematik)

Wenn Du es schon etwas formalisieren willst, dann wäre die Frage worüber definierst Du überhaupt Deinen Vektor, d.h. was erlaubt Dir überhaupt eine Operation wie +, * etc durchzuführen und woher kommen überhaupt Deine Skalare / Elemente in dem Vektor !?

Mathematisch ist diese Materie für mich kein Problem, aber irgendwas Grundlegendes tue ich anscheinend beim programmiertechnischen Umsetzen verwechseln, weshalb für mich Missverständnisse => Unklarheiten aufkommen.

Das sehe ich anders, denn im Absatz vorher wirfst Du einen Begriff "Träger" ein, wobei bisher keine Rede von irgendwelchen Abschlusseigenschaften und Abbildungen war. Die Aussage dass 2D Vektoren Tupel bzw. 3D Vektoren Tripel sind, ist okay, bringt uns aber hier nicht wirklich viel weiter, weil was ist dann ein n-dimensionaler Vektor!?

Wenn die Umsetzung mittels eindimensionaler Arrays und auch mittels mehrdimensionaler Arrays SO einfach sein soll, warum dann nicht einfach mal einen Beispielcode posten.

Warum willst Du Code haben, wenn Du Lücken in Bezug auf die grundlegende Definition hast !? Wenn Du unbedingt Code willst, dann schau Dir die Vektorklasse der Boost an

Ungeachtet dessen, ob ich es verstehe oder nicht, hätte ich wenigstens etwas, was richtig ist und was ich analysieren könnte und ggfl. bei Unklarheit nochmals hinterfragen kann. [...]

Ich traue Dir ohne weiteres zu, dass Du den Code selbst schreiben kannst, wenn Du die Zusammenhänge verstanden hast. Das "Code schreiben" ist hier nicht das Problem, bei Dir sind Unklarheiten im Verständnis von Vektoren, Räumen und Operatoren.

Mach es doch an einem ganz einfachen Beispiel Dir klar: Stell Dir eine Ebene in 2D vor. Was ist dann ein 2D Vektor in Bezug auf diese Ebene? Und was ist dann die Ebene in Bezug auf den Vektor !? (Tipp: Mengenlehre)

Bearbeitet 16. Dezember 2011 von flashpixx