Vektoren

    • VB.NET

    Es gibt 20 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

      Vektoren

      Hallo Forum, ich dachte ich schreibe mal drei Strukturen zu Vektoren (Vector2D, Vector3D, Vector4D).
      Ich habe folgende Funktionen eingebaut:

      Operatoren:
      - * (Vector & Double)
      - * (Double & Vector)
      - / (Vector & Double)
      - + (Vector & Vector)
      - - (Vector & Vector)

      Eigenschaften (alle Datentyp Double):

      Vector2D:
      - X
      - Y
      - Length

      Vector3D:
      - X
      - Y
      - Z
      - Length

      Vector4D:

      - X
      - Y
      - Z
      - W
      - Length

      Subs:

      - New (Konstruktor)

      Functions:

      - Normalize
      - ScalarProduct
      - IsOrthogonal
      - ToString
      - CrossProduct (bei Vector3D)

      Es sind also nur die wichtigsten Funktionen, damit man aber sieht wie man Vektoren in Visual Basic umsetzen kann, reicht es hoffentlich.

      Spoiler anzeigen

      VB.NET-Quellcode

      1. Option Strict On
      2. Imports System.Math
      4. Public Structure Vector2D
      6. Public Sub New(ByVal xx As Double, ByVal yy As Double)
      7. X = xx
      8. Y = yy
      9. End Sub
      11. Public Property X() As Double
      12. Public Property Y() As Double
      14. Public ReadOnly Property Length() As Double
      15. Get
      16. Return Sqrt(Pow(X, 2) + Pow(Y, 2))
      17. End Get
      18. End Property
      20. Public Shared Operator +(ByVal v1 As Vector2D, ByVal v2 As Vector2D) As Vector2D
      21. Return New Vector2D(v1.X + v2.X, v1.Y + v2.Y)
      22. End Operator
      24. Public Shared Operator -(ByVal v1 As Vector2D, ByVal v2 As Vector2D) As Vector2D
      25. Return New Vector2D(v1.X - v2.X, v1.Y - v2.Y)
      26. End Operator
      28. Public Shared Operator *(ByVal v1 As Vector2D, ByVal d As Double) As Vector2D
      29. Return New Vector2D(v1.X * d, v1.Y * d)
      30. End Operator
      32. Public Shared Operator *(ByVal d As Double, ByVal v1 As Vector2D) As Vector2D
      33. Return New Vector2D(v1.X * d, v1.Y * d)
      34. End Operator
      36. Public Shared Operator /(ByVal v1 As Vector2D, ByVal d As Double) As Vector2D
      37. Return New Vector2D(v1.X / d, v1.Y / d)
      38. End Operator
      40. Public Overrides Function ToString() As String
      41. Return String.Format("({0},{1})", x, y)
      42. End Function
      44. Public Shared Function Normalize(ByVal v1 As Vector2D) As Vector2D
      45. Return v1 / v1.Length
      46. End Function
      48. Public Shared Function ScalarProduct(ByVal v1 As Vector2D, ByVal v2 As Vector2D) As Double
      49. Return v1.X * v2.X + v1.Y * v2.Y
      50. End Function
      52. Public Shared Function IsOrthogonal(ByVal v1 As Vector2D, ByVal v2 As Vector2D) As Boolean
      53. If Double.Equals(ScalarProduct(v1, v2), 0) Then Return True
      54. Return False
      55. End Function
      56. End Structure
      58. Public Structure Vector3D
      60. Public Sub New(ByVal xx As Double, ByVal yy As Double, ByVal zz As Double)
      61. X = xx
      62. Y = yy
      63. Z = zz
      64. End Sub
      66. Public Property X() As Double
      67. Public Property Y() As Double
      68. Public Property Z() As Double
      70. Public ReadOnly Property Length() As Double
      71. Get
      72. Return Sqrt(Pow(X, 2) + Pow(Y, 2) + Pow(Z, 2))
      73. End Get
      74. End Property
      76. Public Shared Operator +(ByVal v1 As Vector3D, ByVal v2 As Vector3D) As Vector3D
      77. Return New Vector3D(v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z)
      78. End Operator
      80. Public Shared Operator -(ByVal v1 As Vector3D, ByVal v2 As Vector3D) As Vector3D
      81. Return New Vector3D(v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z)
      82. End Operator
      84. Public Shared Operator *(ByVal v1 As Vector3D, ByVal d As Double) As Vector3D
      85. Return New Vector3D(v1.X * d, v1.Y * d, v1.Z * d)
      86. End Operator
      88. Public Shared Operator *(ByVal d As Double, ByVal v1 As Vector3D) As Vector3D
      89. Return New Vector3D(v1.X * d, v1.Y * d, v1.Z * d)
      90. End Operator
      92. Public Shared Operator /(ByVal v1 As Vector3D, ByVal d As Double) As Vector3D
      93. Return New Vector3D(v1.X / d, v1.Y / d, v1.Z / d)
      94. End Operator
      96. Public Overrides Function ToString() As String
      97. Return String.Format("({0},{1},{2})", X, Y, Z)
      98. End Function
      100. Public Shared Function Normalize(ByVal v1 As Vector3D) As Vector3D
      101. Return v1 / v1.Length
      102. End Function
      104. Public Shared Function ScalarProduct(ByVal v1 As Vector3D, ByVal v2 As Vector3D) As Double
      105. Return v1.X * v2.X + v1.Y * v2.Y + v1.Z * v2.Z
      106. End Function
      108. Public Shared Function IsOrthogonal(ByVal v1 As Vector3D, ByVal v2 As Vector3D) As Boolean
      109. If Double.Equals(ScalarProduct(v1, v2), 0) Then Return True
      110. Return False
      111. End Function
      113. Public Shared Function CrossProdukct(ByVal v1 As Vector3D, ByVal v2 As Vector3D) As Vector3D
      114. Return New Vector3D(v1.Y * v2.Z - v1.Z * v2.Y, v1.Z * v2.X - v1.X * v2.Z, v1.X * v2.Y - v1.Y * v2.X)
      115. End Function
      116. End Structure
      118. Public Structure Vector4D
      120. Public Sub New(ByVal xx As Double, ByVal yy As Double, ByVal zz As Double, ByVal ww As Double)
      121. X = xx
      122. Y = yy
      123. Z = zz
      124. W = ww
      125. End Sub
      127. Public Property X() As Double
      128. Public Property Y() As Double
      129. Public Property Z() As Double
      130. Public Property W() As Double
      132. Public ReadOnly Property Length() As Double
      133. Get
      134. Return Sqrt(Pow(X, 2) + Pow(Y, 2) + Pow(Z, 2) + Pow(W, 2))
      135. End Get
      136. End Property
      138. Public Shared Operator +(ByVal v1 As Vector4D, ByVal v2 As Vector4D) As Vector4D
      139. Return New Vector4D(v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z, v1.W + v2.W)
      140. End Operator
      142. Public Shared Operator -(ByVal v1 As Vector4D, ByVal v2 As Vector4D) As Vector4D
      143. Return New Vector4D(v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z, v1.W - v2.W)
      144. End Operator
      146. Public Shared Operator *(ByVal v1 As Vector4D, ByVal d As Double) As Vector4D
      147. Return New Vector4D(v1.X * d, v1.Y * d, v1.Z * d, v1.W * d)
      148. End Operator
      150. Public Shared Operator *(ByVal d As Double, ByVal v1 As Vector4D) As Vector4D
      151. Return New Vector4D(v1.X * d, v1.Y * d, v1.Z * d, v1.W * d)
      152. End Operator
      154. Public Shared Operator /(ByVal v1 As Vector4D, ByVal d As Double) As Vector4D
      155. Return New Vector4D(v1.X / d, v1.Y / d, v1.Z / d, v1.W / d)
      156. End Operator
      158. Public Overrides Function ToString() As String
      159. Return String.Format("({0},{1},{2},{3})", X, Y, Z, W)
      160. End Function
      162. Public Shared Function Normalize(ByVal v1 As Vector4D) As Vector4D
      163. Return v1 / v1.Length
      164. End Function
      166. Public Shared Function ScalarProduct(ByVal v1 As Vector4D, ByVal v2 As Vector4D) As Double
      167. Return v1.X * v2.X + v1.Y * v2.Y + v1.Z * v2.Z + v1.W * v2.W
      168. End Function
      170. Public Shared Function IsOrthogonal(ByVal v1 As Vector4D, ByVal v2 As Vector4D) As Boolean
      171. If Double.Equals(ScalarProduct(v1, v2), 0) Then Return True
      172. Return False
      173. End Function
      174. End Structure


      Dieser Beitrag wurde bereits 6 mal editiert, zuletzt von „TheVBTutorialsVB“ () aus folgendem Grund: Update

      Sieht doch richtig gut aus :thumbsup:. Das einzigste, was mir noch einfallen würde, wäre, dass du die Properties von X, Y, ... in der Kurzschreibweise (nur die erste Zeile der Property) verfasst, dann kannst du auch auf die Private xx, yy, ... verzichten :). Ansonsten ist es doch so gut wie perfekt.

      Welchen mathematischen Hintergrund haben diese Funktionen:

      TheVBTutorialsVB schrieb:

      VB.NET-Quellcode

      1. Public Shared Operator *(ByVal v1 As Vector2D, ByVal v2 As Vector2D) As Vector2D
      2. Return New Vector2D(v1.X * v2.X, v1.Y * v2.Y)
      3. End Operator
      5. Public Shared Operator /(ByVal v1 As Vector2D, ByVal v2 As Vector2D) As Vector2D
      6. Return New Vector2D(v1.X / v2.X, v1.Y / v2.Y)
      7. End Operator
      analog V3, V4 ?
      Bei der Funktion IsOrthogonal würde ich nicht auf = 0 testen, sondern auf Math.Abs(Skalarprodukt(...) < Epsilon)
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

      Das scheint mir ein Problem von so Lösungen ohne konkretes Problem: Da kann man sich jetzt tagelang weitere Features für ausdenken, etwa beim 2D-Vector Kompatiblität zu System.Drawing.PointF, und System.Drawing.Drawing2D.Matrix, damit man ordentliche Matrix-Transformationen mit dem Zeugs treiben kann.
      Oder man möchte die Konversion in Polar-Koordinaten haben, was manchmal ja auch sehr nützlich ist.

      Also lass dir hier kein Lebenswerk aufschwätzen, was am Ende doch keiner benutzt.

      Ach ja, ganz vergessen: Sowas hat Artentus schon in seinem Projekt MathUtils integriert, kannst ja da mal vorbeischauen: [OpenSource] MathUtils 2.4 - erweiterte Mathematikbibliothek

      Ich habe auch mal sowas gemacht. Siehe hier bzw. hier.

      Deine Vector2D-Klasse könnte noch einen Konstruktor oder einen Cast-Operator gebrauchen, um einen Vector2D aus einem Punkt zu erstellen. Außerdem könnte man noch eine Betrags-Funktion (Abs, Länge) hinzufügen und readonly, statische Eigenschaften/Felder wie "Zero" (Vector3D(0)), "Up" (Vector3D(1,0,0)), "Down" (usw.), "Left" für bestimtme Vektoren bereitstellen.

      Kannst dich ja auch noch von den XNA-Vektoren inspirieren lassen:
      msdn.microsoft.com/en-us/libra…work.vector2_members.aspx
      msdn.microsoft.com/en-us/libra…work.vector3_members.aspx
      Von meinem iPhone gesendet

      Danke an alle für die Kritik. Ich werde mich nochmal ransetzen, hatte in den letzten Tagen kaum Zeit.

      RodFromGermany schrieb:

      Bei der Funktion IsOrthogonal würde ich nicht auf = 0 testen, sondern auf Math.Abs(Skalarprodukt(...) < Epsilon)


      Dazu habe ich eine Frage. Es muss doch 0 sein, damit sie senkrecht sind. Wieso soll ichs dann anders überprüfen? Dauert der Methodenaufruf nicht länger als der direkte Vergleich? Ich glaub dir zwar dass das besser ist, aber ich verstehe nicht warum...kannste das bitte erklären? ^^

      @TheVBTutorialsVB
      Ein Double ist nicht genau. Wenn die Werte zu viele Stellen haben, dann kann ein korrektes Ergebnis auf != 0 nicht mehr gewährleistet werden. Wenn der Gleitkommafehler nur 0,0000000000001 beträgt, dann ist es schon != 0. Deswegen prüft man nicht auf == 0, sondern ob es fast 0 ist. Epsilon gibt dabei die Toleranz an.

      TheVBTutorialsVB schrieb:

      Es muss doch 0 sein, damit sie senkrecht sind.
      Das ist mathematisch gesehen vollkommen korrekt. In der Informatik kommt es allerdings vor, dass bei einer Kommazahl nicht die gleiche Zahl rauskommt, wie ursprünglich abgespeichert wurde. Das hängt damit zusammen, wie Floats im Speicher abgelegt werden.
      Dieser Effekt äußert sich z. B. so:
      ideone.com/ub9ovu
      Siehe dort:
      msdn.microsoft.com/en-us/library/system.double.epsilon.aspx

      TheVBTutorialsVB schrieb:

      Dauert der Methodenaufruf nicht länger als der direkte Vergleich?
      Das ist korrekt, allerdings ist so mehr sichergestellt, dass das "richtige" Ergebnis rauskommt. Wenn man auf performanz aus ist, würde man das wahrscheinlich auch anders lösen.
      Von meinem iPhone gesendet

      TheVBTutorialsVB schrieb:

      VB.NET-Quellcode

      1. Public Structure Vector2D

      VB.NET-Quellcode

      1. Public Overrides Function ToString() As String
      2. Return "(" & X.ToString & "," & Y.ToString & ")"
      3. End Function
      4. Public Shared Function Normalize(ByVal v1 As Vector2D) As Vector2D
      5. Return 1 / v1.Length * v1
      6. End Function
      Mach da und aus den anderen dies draus:

      VB.NET-Quellcode

      1. Public Overrides Function ToString() As String
      2. Return String.Format("({0},{1})", x, y)
      3. End Function
      5. Public Shared Function Normalize(ByVal v1 As Vector2D) As Vector2D
      6. Return v1 / v1.Length
      7. End Function
      Und mach da ggf. eine serialisierbare Klasse draus.
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

      ErfinderDesRades schrieb:

      oder?
      Nein, ich meine eine

      VB.NET-Quellcode

      1. <Serializable()> Public Class Vector2D
      2. ' Stuff
      3. End Class
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

      Hi
      Structure ist in diesem Fall besser geeignet, zumal auch die Effizienz besser ist, gerade, weil sehr viele Referenzen benötigt würden. So würden nur durch Boxing weitere Instanzen erzeugt. Vector# ist außerdem an sich eine atomare Größe und benötigt semantisch keine Verweise auf eine ihrer Instanzen.

      Gruß
      ~blaze~

    Facebook
    Telefonspende