[OpenSource] MathUtils 2.4.3 - erweiterte Mathematikbibliothek

    • Release
    • Open Source

    Es gibt 104 Antworten in diesem Thema. Der letzte Beitrag () ist von Artentus.

      [OpenSource] MathUtils 2.4.3 - erweiterte Mathematikbibliothek

      Beschreibung:
      Gleich vorneweg: diese Bibliothek habe ich geschrieben, um meine Fähigkeiten in C# und meinen allgemeinen Codestil zu verbessern. Sie hat zwar auch einen praktischen Nutzen, jedoch gehe ich nicht davon aus, dass das in großen Projekten produktiv eingesetzt werden wird (weder von mir, noch von jemand anderem). Deswegen habe ich es OpenSource gemacht, da der Code wohl der interessante Teil an der Sache ist.
      Die Bibliothek enthält Klassen, die für die Lösung kompliziertere mathematischer Probleme geschrieben sind. Unter anderem sind das Matrizen und Vektoren (wohl der Hauptteil der Lib).
      Es liegt auch eine kleine Testanwendung bei, die demonstriert, was damit alles möglich ist: es wird ein 3D-Würfel, der sich um seine drei Achsen dreht und dabei seine Größe ändert, mit GDI+ gezeichnet.

      Update 2.0: Ab jetzt wird auch zweidimensionale Geometrie unterstützt.
      Update 2.1: Ab jetzt werden auch Geradengleichungen unterstützt.
      Update 2.2: Ab jetzt können lineare Gleichungssysteme gelöst werden
      Update 2.3: Ab jetzt auch mit Formelparser

      Wenn jemand noch Vorschläge hat, was noch dringend in so einer Bibliothek rein müsste, kann er sie gerne äußern, ich werde dann schauen, ob ich es hinbekomme.

      Ich werde übrigens kein Tutorial hier rein schreiben, wie man das ganze Zeug benutzt, da ich das selbst wahrscheinlich nicht besonders gut erklären könnte, und außerdem weil das definitiv zu lange für einen Post im Forum wäre. Einen kurzen Überblick könnt ihr euch aber hier und hier verschaffen.

      Klassendiagramm:



      Changelog:

      Version 2.4
      • Vektoren sind nun leichter in der Handhabung
      • neue Matrix3x3-Klasse für 2D-Transformationen hinzugefügt
      • neue Rational-Klasse

      Version 2.4.1
      • Testprojekt hinzugefügt
      • kleine Bugfixes und Verbesserungen


      Verwendete Programmiersprache und IDE:
      Visual C# (IDE: Visual Studio 2012)

      Systemanforderungen:
      .NET Framework 4

      Download:
      vb-paradise.de/index.php/Attac…8ffd2b0db8b00f6e94f6749ec (83,5 kB)
      vb-paradise.de/index.php/Attac…8ffd2b0db8b00f6e94f6749ec (594,3 kB)

      Source:
      GitHub

      Lizenz/Weitergabe:
      OpenSource
      Dateien

      • MathUtils.zip

        (83,64 kB, 336 mal heruntergeladen, zuletzt: )

      • MathUtils_Solution.zip

        (704,75 kB, 384 mal heruntergeladen, zuletzt: )

      Dieser Beitrag wurde bereits 19 mal editiert, zuletzt von „Artentus“ ()

      Da mir der Beispielcode für meine Verhältnisse wirklich zu ranzig war, habe ich die Testanwendung nochmal komplett neu geschrieben. Ich hab auch gleich noch Vollbildmodus und FPS-Counter eingebaut. Den Code habe ich ebenfalls mit dem neuen ausgetauscht. Jetzt wird glaube ich auch leichter ersichtlich, wie man die Lib benutzt.

      @Artentus
      Also das Klassendiagramm gibt ja schonmal einen schönen Überblick über viele Funktionen :thumbsup: Tolle Arbeit

      Wenn du nichts dagegen hast werde ich mal in einem Parser diese Klassen verwenden damit der besser mit Matrizen und Vektoren arbeiten kann. Vor allem die Unterstützung für Operatoren wird die Arbeit wahrscheinlich erleichtern :thumbup: (Danach kann ich auch nochmal ein Feedback mit Kritik abgeben :D )

      Hast du vor noch weiter hierdran zu arbeiten oder ist das jetzt die finale Version?

      Implizite Typenkonvertierungen von Vector2 zu Size und Point wären vielleicht auch ganz hilfreich. Generell finde ich implizite Konvertierungen besser als Methoden wie ToPoint, ToSize etc.
      So Methoden würde ich nur bei nicht so offensichtlichen Dingen einbauen, wie von Size -> Point oder andersherum.


      MfG :)

      @Telcrome
      Danke für dein Lob.
      Wenn ich noch Sachen finde, die dazu passen, dann werde ich das sicherlich auch noch mit einbauen. Möglicherweise erweitere ich das ganze auch noch um Geometrie (also Polygonkollision usw. , hab da schon nen Source in VB rumfliegen).

      @Trudi
      Laut den Framework Designgiudlines sollte man einen impliziten Konvertierungsoperator nur einsetzen, wenn der Zieltyp alle Funktionalität des Ausgangstyps besitzt. Das heißt als, von Point nach Vector2 wäre in Ordnung, anders rum aber nicht. Ich werde mal schauen, was ich da tun kann, es fehlen sowieso noch ein paar Sachen, wie mir aufgefallen ist.

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Artentus“ ()

      @Artentus: Überleg mal, im Sinne von DateTime und TimeSpan zwischen
      Ortsvektoren
      und
      Richtungsvektoren
      zu unterscheiden. Das ist sowas wie Option Explicit für Vektoren bzw. deren überladene Vektoren.
      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
      das System ist eigentlich losgelöst von System.Drawing. Insofern wäre es für eine Schicht sinnvoll, Point, etc. manuell nochmal zu definieren und dann halt [Vector] + [Vector] = [Vector] und [Point] + [Vector] = [Point]. Modelliere btw. die Matrix-Klasse doch einfach als Interface IMatrix (und dann Implementierung z.B. per Extension).
      Ansonsten siehts übrigens ganz nice aus.

      Gruß
      ~blaze~

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „~blaze~“ ()

      @RodFromGermany
      Wie sollte ich das deiner Meinung nach denn am besten umsetzen?
      Ich hab das weggelassen, weil ich diese Unterscheidung nicht ordentlich realisieren konnte. Es ist ja eigentlich nur eine Unterscheidung nach Einsatzzweck, die Mathematik bleibt die gleiche.

      @~blaze~
      Das ist ne gute Idee, wird nur viel Schreibarbeit.
      Aber wenn ich die Matrix als Interface deklariere, dann hab ich doch keine Möglichkeit den Inhalt zu speichern, oder? Das würde doch dann bedeuten, ich müsste dann gleich noch ne Standardimplementation mitliefern: IMatrix<--Matrix Sorry, wenn ich da jetzt komplett daneben liege, ich hab immer noch nicht so richtig raus, wie man mit Interfaces arbeitet.

      @all
      Ich hab gerade übrigens nochmal die komplette Sache mit der Projektion von 3D -> 2D neu gemacht (war schlecht implementiert), gibt also demnächst nen Update.

      Jep, aber du könntest Structures verwenden statt Matrizen.

      VB.NET-Quellcode

      1. Public Interface IMatrix
      2. ReadOnly Property Rows As Integer
      3. ReadOnly Property Columns As Integer
      4. Default Property Value(ByVal row As Integer, ByVal column As Integer) As Object
      5. End Interface
      7. Public Interface IMatrix(Of T)
      8. Inherits IMatrix
      9. Default Shadows Property Value(ByVal row As Integer, ByVal column As Integer) As T
      10. End Interface

      So z.B. könnte das aussehen. Dann halt konkrete Typen implementieren für IMatrix(Of Single) und 4x4-Matrix. Ist halt etwas overengineered, aber dann kannst du über Extensions eben die konkreten Funktionen wie Invert, etc. implementieren. Vector wäre dann nat. analog. Structures sind bei sowas halt praktischer als Klassen. Die Implementierung einer Matrix-Klasse mit dynamischer Anzahl von Rows und Columns wär' nat. trotzdem sinnvoll.

      Gruß
      ~blaze~

      Ok, danke für die Hilfe. Ich werde das dann mal in Angriff nehmen.

      Edit:
      @~blaze~
      Ok, ich hab das gerad mal versucht und hatte aber Probleme damit, dass das Interface generisch ist. Viele der Operationen sind halt nur mit Zahlentypen machbar, deswegen kann ich keine Generischen Extensions dafür schreiben. Gibts da was, das ich tun kann?

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Artentus“ ()

      Artentus schrieb:

      Wie sollte ich das deiner Meinung nach denn am besten umsetzen?
      Grob-Plan:

      VB.NET-Quellcode

      1. Public MustInherit Class Vector
      2. Dim x As Double
      3. Dim y As Double
      4. Dim z As Double
      5. End Class
      7. Public Class OrtsVector
      8. Inherits Vector
      9. ' erlaubte Operationen überladen
      10. ' Addition, Multiplikation, Division nicht nicht überladen
      11. 'RichtungsVector = OrtsVector - OrtsVector
      12. End Class
      14. Public Class RichtungsVector
      15. Inherits Vector
      16. ' erlaubte Operationen überladen
      17. 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!

      Ich hatte es so gedacht:

      VB.NET-Quellcode

      1. Public Interface IMatrix
      2. ReadOnly Property Rows As Integer
      3. ReadOnly Property Columns As Integer
      4. Default Property Element(ByVal row As Integer, ByVal column As Integer) As Object
      5. ReadOnly Property ElementType As Type
      6. End Interface
      8. Public Interface IMatrix(Of T)
      9. Inherits IMatrix
      10. Default Shadows Property Value(ByVal row As Integer, ByVal column As Integer) As T
      11. End Interface
      13. Public Module MatrixExtensions
      14. Public Function IsIdentity(ByVal value As IMatrix(Of Single)) As Boolean
      15. Dim rows As Integer = value.Rows, columns As Integer = value.Columns
      16. If rows <> columns Then Return False
      18. For i As Integer = 0 To rows - 1
      19. For j As Integer = 0 To columns - 1
      20. If value(i, j) <> If(i = j, 1, 0) Then Return False
      21. Next
      22. Next
      23. Return True
      24. End Function
      25. End Module
      27. Public Structure Matrix2x2
      28. Implements IMatrix(Of Single)
      30. Public M11, M12, M21, M22 As Single 'oder eben als Array oder in c# mit einem fixed-array float[4] in der struct (allerdings wohl eher private)
      32. Public ReadOnly Property Columns As Integer Implements IMatrix.Columns
      33. Get
      34. Return 2
      35. End Get
      36. End Property
      38. Private Overloads Property ElementObj(ByVal row As Integer, ByVal column As Integer) As Object Implements IMatrix.Element
      39. Get
      40. Return Element(row, column)
      41. End Get
      42. Set(ByVal value As Object)
      43. Element(row, column) = DirectCast(value, Single)
      44. End Set
      45. End Property
      47. Private ReadOnly Property ElementType As System.Type Implements IMatrix.ElementType
      48. Get
      49. Return GetType(Single)
      50. End Get
      51. End Property
      53. Public ReadOnly Property Rows As Integer Implements IMatrix.Rows
      54. Get
      55. Return 2
      56. End Get
      57. End Property
      59. Default Public Overloads Property Element(ByVal row As Integer, ByVal column As Integer) As Single Implements IMatrix(Of Single).Value
      60. Get
      61. If row < 0 OrElse row >= 2 Then Throw New ArgumentOutOfRangeException("row")
      62. If column < 0 OrElse column >= 2 Then Throw New ArgumentOutOfRangeException("column")
      63. If row = 0 Then
      64. If column = 0 Then
      65. Return M11
      66. Else
      67. Return M12
      68. End If
      69. Else
      70. If column = 0 Then
      71. Return M21
      72. Else
      73. Return M22
      74. End If
      75. End If
      76. End Get
      77. Set(ByVal value As Single)
      78. If row = 0 Then
      79. If column = 0 Then
      80. M11 = value
      81. Else
      82. M12 = value
      83. End If
      84. Else
      85. If column = 0 Then
      86. M21 = value
      87. Else
      88. M22 = value
      89. End If
      90. End If
      91. End Set
      92. End Property
      93. End Structure


      Gruß
      ~blaze~

      So würde es gehen und so werde ich es jetzt auch machen. Aber dann frage ich mich, wofür das generische Interface überhaupt da sein soll, wenn man die Extensions eh nur für einen bestimmten Typ schreibt. IEnumerable zeichnet ja z.B. aus, dass es für jeden Typ die gleichen Funktionen bietet, nicht nur für die Grunddatentypen.

      Im Prinzip genügt eine Matrix-Klasse sicher, aber wenn man Matrix2x2 oder über homogene Koordinaten eine 3x3-Matrix, etc. z.B. für Rendering verwendet, sind halt doch relativ grobe Unterschiede zwischen Klassen und Strukturen zu erkennen. Insbesondere müssen die dann nicht geklont werden, wenn man auf den konkreten Typ ausweicht. Allerdings kann man über das Interface eben auch nicht-statische Typen zur Verfügung stellen.

      Aso, ganz vergessen: du kannst auch für die restlichen Typen einfach IConvertible verwenden und in den ursprünglichen Elementtyp zurückkonvertieren.

      VB.NET-Quellcode

      1. Public Module MatrixExtensions
      2. Public Function IsIdentity(ByVal value As IMatrix(Of Single)) As Boolean
      3. '...
      4. End Function
      6. Public Function IsIdentity(ByVal value As IMatrix) As Boolean
      7. If GetType(IConvertible).IsAssignableFrom(value.ElementType) Then Throw New ArgumentException("Matrix elements do not provide an implementation of IConvertible.")
      8. Dim rows As Integer = value.Rows, columns As Integer = value.Columns
      9. Dim c As System.Globalization.CultureInfo = System.Globalization.CultureInfo.CurrentCulture
      10. If rows <> columns Then Return False
      12. For i As Integer = 0 To rows - 1
      13. For j As Integer = 0 To columns - 1
      14. If DirectCast(value(i, j), IConvertible).ToDouble(c) <> If(i = j, 1, 0) Then Return False
      15. Next
      16. Next
      17. Return True
      18. End Function
      19. End Module


      Gruß
      ~blaze~

      Hatte bei beiden btw. das Extension-Attribut vergessen. Bei meinem Code ist's so, dass IMatrix(Of T) von IMatrix erbt, welches eben den ElementType zurückgibt. Für bekannte Matrixtypen (IMatrix(Of Single), IMatrix(Of Double)) kann die Implementierung halt konkretisiert werden. Ansonsten wird überprüft, ob der ElementType IConvertable implementiert. Wenn das der Fall ist, können Elemente IConvertible zugewiesen werden - daher die Abfrage auf IsAssignable (die ganzen primitiven Datentypen implementieren IConvertible), wird eben eine Double-Konvertierung vorgenommen (der 0-Vergleich ist übrigens hier nicht ganz sinnvoll, da kein Epsilon verwendet wird, sondern 0 und 1).

      Gruß
      ~blaze~

      Das war mir schon klar, aber ich bekomme wegen diesen Interfaces manche Sachen nicht mehr hin, da mir ja jetzt die Basisklasse Matrix fehlt, und ich somit keine Matrizen von beliebiger Größe mehr erstellen kann. Mir nützen die ganzen Extensions nicht, wenn ich nur Interfaces habe, aber keine Klasse, die die Eigenschaften auch tatsächlich implementiert. Und wenn ich eine solche hinzufüge und sie von IMatrix erben lasse, dann kann ich mir das Interface auch gleich wieder sparen, da man dann wieder von der klasse ableiten kann.
      Ich hab gerade echt schon Kopfschmerzen, weil ich mir Gedanken darüber gemacht habe, wie ich dieses Problem lösen könnte, bin aber zu keinem anderen Ergebnis gekommen, als alles mit Klassen zu lösen (also so, wie ich es jetzt habe). Meine Kenntnisse sind vielleicht einfach noch nicht groß genug, um was komplexeres zu verstehen.

      Das wäre dann eine IMatrix(Of Double), die die Rows und Columns im Konstruktor übergeben bekommt und nur die Properties nach außen reicht. Diese Matrix ist dann aber eine Klasse und keine Structure. Das gleiche Phänomen tritt übrigens bei einigen Leuten auf, die mit mir schon mal ein Projekt durchgeführt haben... :P

      Gruß
      ~blaze~

      So wollte ich es zunächst auch machen, aber dann bekomme ich das Problem, dass ich nach bestimmten Operation, die in Extensions ausgeführt werden, danach nicht mehr die Art Matrix rausbekomme, die ich eingebe, sondern immer eine Instanz dieser Klasse. Außerdem kann ich dann keine Operatoren mehr verwenden, weil die Structures nicht von der Matrix-klasse erben und ich somit für jede Structure eine eigene Überladung schreiben müsste.
      Vielleicht lässt sich das auch ganz einfach lösen, und ich unterliege nur nem inneren Zwang, alles immer in einer möglichst niedrigen Ebene der Vererbunghirarchie implementieren zu wollen, obwohl die Sachen eigentlich in abgeleitete Klassen gehören.

      Ich lös' das Problem dann meist so, dass zwei Klassen noch mal Methoden anbieten, die das nicht auf abstrakter Ebene lösen, sondern auf diskreter, also z.B. für Matrix2x2 eine Überladung mit Function Multiply(Matrix2x2, Matrix2x) As Matrix2x2 und bei der Extension/statischen Methode in einer zusätzlichen Klasse eben eine Überladung auf IMatrix, IMatrix o.ä.

      Gruß
      ~blaze~