Verlauf Komplexer Zahlen berechnen

  • VB.NET
  • .NET 4.5

Es gibt 43 Antworten in diesem Thema. Der letzte Beitrag () ist von Farliam.

    Farliam schrieb:

    nur hilft es ja nicht, wenn die Umrechnung am Ende nicht stimmt.
    Wenn ich Deinen Code in Post #19 sehe, steht da nix anderes.
    Das Ablegen und Abrufen geht dann halt mit einem Einzeiler.
    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 habe die Lösung nun irgendwie hinbekommen. Wenn ich das Bild mittig hinlege kann ich dann auch reinzoomen.
    Nur gefällt mir dass nicht, am Anfang muss das Bild erstmal Horizontal/Vertikal ausgerichtet werden.

    Der Punkt den ich suche kann ich herausfinden wenn ich:

    x = 13
    x1=x/(13/1440=xStep1)*x1
    x2=x1/xstep1/1440=xStep2)*x2
    x3=x2/xstep2/1440=)*x3

    Dann ist der neue Punkt die Summe von x-x3.

    Mir ging es gar nicht um das abrufen, sondern wie ich das richtig berechnen kann :/

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

    @Farliam Vielleicht rechnest Du mit dem Mittelpunkt des Rechtecks und den halben Seitenlängen nach außen, das lässt sich vielleicht leichter denken.
    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!
    So oder so ähnlich, muss es mal richtig testen.

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Private Function SetZoomBereich() As Boolean
    2. Dim p1 As Point = TranslateMousePointToPoint(PictureBox1.Size, New Drawing.Size(BildBreite, BildHöhe), AuswahlAktuell.Location)
    3. Dim p2 As Point = TranslateMousePointToPoint(PictureBox1.Size, New Drawing.Size(BildBreite, BildHöhe),
    4. New Point(AuswahlAktuell.X + AuswahlAktuell.Width, AuswahlAktuell.Y + AuswahlAktuell.Height))
    5. Dim midPX As Double
    6. Dim midPY As Double
    7. If zoomVerlaufL.Count = 0 Then
    8. 'Erster Zoomverlauf
    9. midPX = p1.X + ((p2.X - p1.X) / 2)
    10. midPY = p1.Y + ((p2.Y - p1.Y) / 2)
    11. zoomVerlaufL.Add(New Tuple(Of Double, Double)(midPX, midPY))
    12. Label12.Text = zoomVerlaufL.Item(zoomVerlaufL.Count - 1).ToString & vbCrLf & vbCrLf
    13. zoomFaktor.Add(New Tuple(Of Double, Double)(AuswahlAktuell.Width / 2 / 2, AuswahlAktuell.Height / 2 / 2))
    14. Else
    15. midPX = p1.X + ((p2.X - p1.X) / 2)
    16. midPY = p1.Y + ((p2.Y - p1.Y) / 2)
    17. Dim nf As Tuple(Of Double, Double) = zoomFaktor(zoomFaktor.Count - 1)
    18. Dim xp As Double = (zoomVerlaufL.Item(zoomVerlaufL.Count - 1).Item1)
    19. Dim difxp As Double = (midPX * (nf.Item1 / BildBreite))
    20. Dim yp As Double = (zoomVerlaufL.Item(zoomVerlaufL.Count - 1).Item2)
    21. Dim difyp As Double = (midPY * (nf.Item2 / BildHöhe))
    22. zoomFaktor.Add(New Tuple(Of Double, Double)(nf.Item1 / AuswahlAktuell.Width / 2 / 2, nf.Item2 / AuswahlAktuell.Width / 2 / 2))
    23. zoomVerlaufL.Add(New Tuple(Of Double, Double)(difxp, difyp))
    24. Dim xlt, ylt As Double
    25. ylt = zoomVerlaufL(0).Item2
    26. xLT = zoomVerlaufL(0).Item1
    27. For i As Integer = 1 To zoomVerlaufL.Count - 1
    28. xLT += zoomVerlaufL(i).Item1
    29. yLT += zoomVerlaufL(i).Item2
    30. Next
    31. Label12.Text = xlt & ":" & ylt#
    32. zoomFaktorLX = xlt
    33. zoomFaktorLY = ylt
    34. End If
    35. If p1.X < 0 Or p2.X < 0 Or p1.X > BildBreite Or p2.X > BildBreite Then Return False
    36. If p1.Y < 0 Or p2.Y < 0 Or p2.Y > BildHöhe Or p1.Y > BildHöhe Then Return False
    37. xmin = NumberRange(p1.X, p1.Y).Item1
    38. ymin = NumberRange(p1.X, p1.Y).Item2
    39. xmax = NumberRange(p2.X, p2.Y).Item1
    40. ymax = NumberRange(p2.X, p2.Y).Item2
    41. Return True
    42. End Function


    Nachtrag :

    Ich lasse mein Programm gerade mal laufen, und es scheint sich richtig zu zentrieren. Nur verliere ich bei dieser Methode am Ende die Nachkommastellen. Und bei solch tiefen Bereichen, weiß ich nicht wie sich das am Ende auswirkt.

    Aber wann und wo ich diese Bereiche entfernen könnte weiß ich nicht. Es ist ja auch wichtig, dass der Bereich in dem gezoomt wird, auch immer die gleiche Auflösung behält.

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

    Farliam schrieb:

    Nur verliere ich bei dieser Methode am Ende die Nachkommastellen.
    In welcher Dimension?
    xy-Ort
    oder
    z-Farbtiefe?
    Wie äußert sich das?
    Mit einer Klasse RectangleD kannst Du das Zoomen da drinne machen lassen, da überblickst Du das Jonglieren mit den Koordinaten einfacher und sicherer.
    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!
    @RodFromGermany

    Nun die Nachkommastellen des Mittelpunktes auf der letzten Ebne.
    Ich versuche das ganze mal anders rum.

    Statt von der ersten Ebne zu versuchen an die letzte Ranzukommen, versuche ich mal von der letzten Ebne auf die erste umzurechnen. Wenn ich dann am Ende mich den ersten xmin,ymin... Werte nähere, habe ich Nachkommastellen die ich verwenden kann.

    Danke dir

    Farliam schrieb:

    Nun die Nachkommastellen des Mittelpunktes auf der letzten Ebne.
    Wie passiert denn das?
    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!
    Wie soll ich denn die Nachkommastellen im Zoomvorgang verwenden? Die Nachkommastellen geben ja nur den Weg durch die Ebnen an.
    Wenn ich aber Pixel für Pixel nach unten zoome, kann ich mit den Nachkommastellen nichts anfangen. Nur mit der Absoluten Mitte. Auch wenn die am Ende ungenau ist^^

    Neu

    Ich habe mir die ganze Nacht den Kopf zerbrochen wie ich das Problem lösen könnte. Und meine Idee, das ganze von Unten nach oben zu berechnen war richtig.
    Und eigentlich ist das nicht mal kompliziert. Das gleiche was ich mache wenn ich von oben nach unten zoome, kann ich indirekt auch von unten nach oben.

    Oben habe ich den Wert von xmin,xmax die auf/in den jeweiligen Pixel liegen. Der Wert des Pixel entspricht dem Absoluten Wert xmin bis xmax / Länge der Bitmap * PixelPos

    Wenn ich nun von unten nach oben rechnen will rechne ich auch Pixel für Pixel.
    Nur nehme ich unten für xStepMin : Absolut(EbneA->minx,EbneZ->minx) / Bildbreite
    Das ergibt dann für xmin einen Pixelbetrag
    Das gleiche mache ich dann für xmax
    Nun habe ich die Werte für 1 Pixel. Dann kann ich diese Werte von der Ebne Z abziehen/addieren. Demnach EbneZ.xmin -/+ xstep min

    Das wiederhole ich solange bis ich mich der Erste Ebne genähert habe. Dazu verwende ich dann einen Betrag der Angibt wie genau.

    Wichtig ist dabei, ich erhalte am Ende nicht einen Betrag wie viele Pixel ich dann abziehen kann, um die Ebne Z wieder zu erreichen. Ich erhalte einen xmin,xmax... Wert die ich von meiner Complexen Zahl abziehe.
    Ich ziehe sie also ab, das Bild vergrößert. Damit auch die Nachkommastellen ihr Fett weg bekommen, überprüfe ich wann der xStepper beim zoomvorgang < den errechneten Abzug ist. Wenn dies der Fall ist, wird der errechnete Abzug minus den aktuellen xStepper genommen.

    Das ganze dann so lange wie man lustig ist. Für testzwecken hab ich mal eine Variabel namens Pixelmove deklariert. Um zu sehen ob das ganze in die Richtige Richtung geht. Dieser Pixelmove muss mann dann aber auch beim Zoomvorgang * errechneten Wert nehmen.


    LG

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „Farliam“ ()

    Neu

    Farliam schrieb:

    Und meine Idee, das ganze von Unten nach oben zu berechnen war richtig.
    OOD und OOP wäre eine richtige Herangehensweise, und wenn Du das nicht gemacht hast (was ich mal annehme) wäre ein Redesign der richtige Ansatz für Dich.
    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!

    Neu

    Vollzitat des direkten Vorposts an dieser Stelle entfernt ~VaporiZed

    Das ist von mir nur ein reines Hobby. Aber soweit hast du recht. Meist fange ich einfach aus Spaß an. Irgendwann bin ich dann so weit, das ich durch den ganzen CodeSalat nicht mehr durchblicke. Dann fange ich ein komplett neues Projekt an, und übernehme nach und nach die guten Funktionen von dem alten.

    Zu meinem Code da oben. Den werde ich gleich noch etwas ergänzen^^ ich übergebe nämlich die Falschen Daten nach außen. Im jetzigen Zustand schauts schon sehr ordentlich aus; also der Zoomvorgang :D
    Meine jetzige Lösung entspricht nicht gerade dem, was man unter guter Performance versteht.

    Ich glaube Lineare Interpolation könnte da auch weiterhelfen.

    lg

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

    Neu

    @Farliam Was ist mit den Rundungseffekten / -fehlern?
    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!

    Neu

    Vollzitat des direkten Vorposts an dieser Stelle entfernt ~VaporiZed

    Meinst du beim Rückwärtsrechnen von der letzten zur Ersten Ebne?

    Ich hab den Code rausgenommen, und umgeschrieben. Aber ja, er zoomt zwar ziemlich genau. Doch wenn ich Mir die einzelnen Frames genau anschaue, und die Daten mit dem manuellen Zoomvorgang vergleiche, lassen sich kleine Abweichungen erkennen. Ich denke das dies durch die ungenaue Darstellung von Double in diesem Tiefen Bereich zusammenhängt. Zusätzlich ist mir etwas aufgefallen, die Bilder verzerren sich. Der Punkt wo das Bild hinwandert aber richtig. Eventuell liegt es daran, weil ich bei der Rückwärtsrechnung der Rest der neuen ersten ebne(xmin,xmax,ymin,ymax) - Orginale Werte der ersten(xmin,ymin,ymax,xmax) rechne, und als ersten Abzug der Komplexen zahlen verwendet habe.

    Erkennt man gut auf dem Video, der ZoomPunkt ist richtig, nur das Bild verzerrt:

    Spoiler anzeigen

    Die Funktion die mir die einzelnen Abzüge pro Zoom liefert ist folgende:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Private Function GetQuadrant(ByVal t1 As Tuple(Of Double, Double, Double, Double),
    2. ByVal t2 As Tuple(Of Double, Double, Double, Double)) As List(Of Tuple(Of Double, Double, Double, Double))
    3. Dim prec As Double = 0.00000000005 'Genauigkeit
    4. 'Zuerst rechnen wir den xmin,xmax Step aus
    5. Dim curXmin As Double = t2.Item1
    6. Dim curXmax As Double = t2.Item2
    7. Dim curXminDiff As Double = GetAbsolute(t1.Item1, t2.Item1) / BildBreite
    8. Dim curXmaxDiff As Double = GetAbsolute(t1.Item2, t2.Item2) / BildBreite
    9. Dim curXminStep As Double
    10. Dim curXmaxStep As Double
    11. Dim countx As Integer
    12. Dim county As Integer
    13. Dim xminStep As New List(Of Double)
    14. Dim xmaxStep As New List(Of Double)
    15. SetText("Erstelle X Verlauf")
    16. Do While True
    17. curXminStep += (curXminDiff)
    18. curXmaxStep += (curXmaxDiff)
    19. xminStep.Add(curXminDiff)
    20. xmaxStep.Add(curXmaxDiff)
    21. If curXmin < t1.Item1 Then curXmin += curXminDiff
    22. If curXmin > t1.Item1 Then curXmin -= curXminDiff
    23. If curXmax < t1.Item2 Then curXmax += curXmaxDiff
    24. If curXmax > t1.Item2 Then curXmax -= curXmaxDiff
    25. curXmaxDiff = GetAbsolute(t1.Item2, curXmax) / BildBreite
    26. curXminDiff = GetAbsolute(t1.Item1, curXmin) / BildBreite
    27. If GetAbsolute(curXmin, t2.Item1) > GetAbsolute(t1.Item1, t2.Item1) - prec Or
    28. GetAbsolute(curXmax, t2.Item2) > GetAbsolute(t1.Item2, t2.Item2) - prec Then
    29. 'Letzte Differenz zwischen Ursprung und Ziel als erster Step addieren
    30. xminStep.Add(GetAbsolute(t1.Item1, curXmin))
    31. xmaxStep.Add(GetAbsolute(t1.Item2, curXmax))
    32. Exit Do
    33. End If
    34. countx += 1
    35. Loop
    36. Dim curYmin As Double = t2.Item3
    37. Dim curYmax As Double = t2.Item4
    38. Dim curYminDiff As Double = GetAbsolute(t1.Item3, t2.Item3) / BildHöhe
    39. Dim curYmaxDiff As Double = GetAbsolute(t1.Item4, t2.Item4) / BildHöhe
    40. Dim curYminStep As Double = 0
    41. Dim curYmaxStep As Double = 0
    42. Dim yminStep As New List(Of Double)
    43. Dim ymaxStep As New List(Of Double)
    44. SetText("Erstelle Y Verlauf")
    45. Do While True
    46. curYminStep += (curYminDiff)
    47. curYmaxStep += (curYmaxDiff)
    48. yminStep.Add(curYminDiff)
    49. ymaxStep.Add(curYmaxDiff)
    50. If curYmin < t1.Item3 Then curYmin += curYminDiff
    51. If curYmin > t1.Item3 Then curYmin -= curYminDiff
    52. If curYmax < t1.Item4 Then curYmax += curYmaxDiff
    53. If curYmax > t1.Item4 Then curYmax -= curYmaxDiff
    54. curYminDiff = GetAbsolute(t1.Item3, curYmin) / BildHöhe
    55. curYmaxDiff = GetAbsolute(t1.Item4, curYmax) / BildHöhe
    56. If GetAbsolute(curYmin, t2.Item3) > GetAbsolute(t1.Item3, t2.Item3) - prec Or
    57. GetAbsolute(curYmax, t2.Item4) > GetAbsolute(t1.Item4, t2.Item4) - prec Then
    58. 'Letzte Differenz zwischen Ursprung und Ziel als erster Step addieren
    59. yminStep.Add(GetAbsolute(t1.Item3, curYmin)) '<- Glaube daher kommt die Verzerrung. Die Ungenauigkeit von Double. Der Abzug(x1,x2,y1,y2) in der letzten Ebne auf z.B. 1440 Pixel umgerechnet, ergibt eine sehr ungenaue Zahl
    60. ymaxStep.Add(GetAbsolute(t1.Item4, curYmax))'<-Diese < 50k Berechnungen addieren sich. Deswegen gibt es am Ende eine Differenz zwischen ermittelter erste Ebne, und Orginaler
    61. Exit Do
    62. End If
    63. county += 1
    64. Loop
    65. Dim steps As Integer
    66. If countx > county Then
    67. steps = countx
    68. ElseIf countx < county Then
    69. steps = county
    70. Else
    71. steps = county
    72. End If
    73. Dim stepFaktor As New List(Of Tuple(Of Double, Double, Double, Double))
    74. Dim n As Tuple(Of Double, Double, Double, Double)
    75. Dim nxr, nxl, nyu, nyd As Double
    76. For i As Integer = 0 To steps
    77. If xminStep.Count - 1 >= i Then
    78. nxl = xminStep(i)
    79. Else
    80. nxl = 0
    81. End If
    82. If xmaxStep.Count - 1 >= i Then
    83. nxr = xmaxStep(i)
    84. Else
    85. nxr = 0
    86. End If
    87. If ymaxStep.Count - 1 >= i Then
    88. nyd = ymaxStep(i)
    89. Else
    90. nyd = 0
    91. End If
    92. If yminStep.Count - 1 >= i Then
    93. nyu = yminStep(i)
    94. Else
    95. nyu = 0
    96. End If
    97. n = New Tuple(Of Double, Double, Double, Double)(nxl, nxr, nyu, nyd)
    98. stepFaktor.Add(n)
    99. Next
    100. Return stepFaktor
    101. End Function


    Das dies alles andere als Perfomant ist, bis zu 60k Tuple mit 4 Double Werten zu speichern ist mir klar. Ich könnte es lokal zwischen speichern. Oder immer 500 Schritte berechnen, und dann wieder die Funktion aufrufen.
    Mir ging es aber erstmal darum zu schauen, ob es im Kern funktioniert.


    Wenn ich nur den "relativen Mittelpunkt" - der letzten Ebne umrechne auf die erste Ebne. War glaube ich in einigen Antworten vorher von mir. Und das Bild auf diesen Mittig zentriere sieht es besser aus.



    Nur ist diese Methode natürlich viel zu ungenau.

    Nur soll mich das ganze erstmal nicht weiter stören. Viel wichtiger ist mein Programm von Grund auf neu zu gestalten.

    Aber ich würde gerne auf dein Stichpunkt OOP zurück kommen.

    Mir ist gestern eine Idee eingefallen, und diese lässt sich im jetzigen Zustand nicht ohne weiteres umsetzen.

    Während des manuellen Zoomens fällt mir jetzt plötzlich auf "oh, jetzt wirds ungenau", Double reicht nicht mehr. Ich gehe auf die letzte genaue Ebne, und stelle von Double auf Decimal um, irgendwann fällt mir dann auf, dass auch Decimal am Ende ist, dann würde ich gerne auf BigDecimal umstellen.

    Nun habe ich verschiedene Iterationen, die man auswählen kann um verschiedene Fraktale zu berechnen. Und die Bilder werden in seperaten Threads berechnet.

    Wie könnte ich das am besten Strukturieren? Für jedes Fraktal eine eigene Klasse? Für die Datentype eine Kindklasse(OF T) mit implementieren eines Interfaces? Da jedes Fraktal, eines gemeinsam hat. Sie haben den Bereich xmin,ymin,xmax,ymax und die Bildgröße. Und am Ende eine Klasse die alle andere Klassen verarbeitet und mit der GUI interargiert? Nur müsste ich dann ja am Ende vom Thread zur Klasse Fraktal->VerarbeitendeKlasse->GUI ein Event feuern das z.B. das Bild bis zur Form weiter gibt.

    Ich hatte gestern schonmal versucht, eine Klasse(OF T) für Double,Decimal,BigDecimal zu schreiben. Aber da ich mich mit Generischen Klassen und Interfaces noch nie beschäftigt habe, und für VB.Net keine Bücher besitze, habe ich dementsprechend keine Idee wo ich Anfangen könnte zu suchen. Nach Tutorials für Klassen(Of Type) habe ich zwar gesucht. Doch nicht wirklich gute Beispiele und Erklärungen gefunden.

    LG

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „VaporiZed“ ()

    Neu

    @Farliam Wie wäre es, wenn Du alles in der höchsten Präzision rechnest, am Anfang, wo Du sie noch nicht brauchst, sollte die Rechenzeit eigentlich hinnehmbar sein.
    Dann gibt es auch keine ggf. sichtbaren Übergänge bei anderen Rechen-Genauigkeiten.
    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!

    Neu

    @RodFromGermany

    Ja das muss ich mal ausprobieren.

    Ich habe eine kurze Frage an dich. Und zwar habe ich mir nun eine Klasse erstellt, die mir die Komplexen zahlen speichert. Die Klasse NumberRange(Of T).
    Sie kommt zur Zeit mit den Typen Double und Decimal zurecht. Da sie wenig Code enthält, frage ich einfach den Typ von T ab, und Caste beim erstellen zu Double oder Decimal.

    Jetzt bin ich gerade dabei die Klasse für das erste Fraktal zu erstellen. Diese erbt von der Klasse NumberRange. Nun wollte ich den Algo abtippen, aber ich kann ja nicht schreiben c1 + c2
    Weil c1 ja vom Typ T ist. Nun würde ich gerne den + Operator überladen, der dann überprüft ob es eben Decimal oder Double ist.

    VB.NET-Quellcode

    1. Private Function GetKonvS1(ByVal oVal As Object, ByVal nVal As Object, ByVal xP As Object, ByVal yP As Object) As Object
    2. If GetType(T) Is GetType(Double) Then
    3. Dim p1 As Double
    4. p1 = DirectCast(nVal, Double) * DirectCast(xP, Double)
    5. p1 = p1 / DirectCast(oVal, Double) * DirectCast(yP, Double)
    6. Return p1
    7. ElseIf GetType(T) Is GetType(Decimal) Then
    8. Dim p1 As Decimal
    9. p1 = DirectCast(nVal, Decimal) * DirectCast(xP, Decimal)
    10. p1 = p1 / DirectCast(oVal, Decimal) * DirectCast(yP, Decimal)
    11. Return p1
    12. End If
    13. Return Nothing
    14. End Function


    So habe ich den Zwischenschritt gemacht. Aber das ganze ist fast genauso viel Arbeit wie 2 Klassen manuell für Decimal und Double zu tippen.

    Oder wie stelle ich das am besten an? Ich kann meine Variabeln entweder als T oder als Object deklarieren. ?

    Neu

    @Farliam Du musst da nicht As Object reinschreiben,dafür ist doch das T da.
    Ich rate Dur dringend, mal eine schöpferische Pause einzulegen und Dich mit generischen Klassen zu speichern.
    Wenn Du das Konzept verinnerlicht hast, ist das alles ganz einfach.
    Operatoren überladen musst Du nur dann, wenn Du eine eigene Klasse Complex hast.
    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!

    Neu

    Farliam schrieb:

    ein paar gute Beispiele
    in C#, die für Dich zu übersetzen habe ich keine Lust.
    Frag Frau Google nach vb.net generischen Klassen beispiele:
    docs.microsoft.com/de-de/dotne…/data-types/generic-types
    docs.microsoft.com/de-de/dotne…ow-to-use-a-generic-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!

    Neu

    Würde die auch nehmen^^ Die Beispiele habe ich auch schon gesehen. Mir wird nur der nutzen noch nicht so ganz klar.
    Klar ich kann meine Nummern so super entweder als Decimal oder Double speichern, ohne die komplette Klasse 2 mal zu schreiben.

    Doch wo liegt der Sinn, wenn ich dann meine Berechnung durchführen will und 100ter male die Werte Casten muss.