Verlauf Komplexer Zahlen berechnen

  • VB.NET
  • .NET (FX) 4.5–4.8

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
    16. midPX = p1.X + ((p2.X - p1.X) / 2)
    17. midPY = p1.Y + ((p2.Y - p1.Y) / 2)
    18. Dim nf As Tuple(Of Double, Double) = zoomFaktor(zoomFaktor.Count - 1)
    19. Dim xp As Double = (zoomVerlaufL.Item(zoomVerlaufL.Count - 1).Item1)
    20. Dim difxp As Double = (midPX * (nf.Item1 / BildBreite))
    21. Dim yp As Double = (zoomVerlaufL.Item(zoomVerlaufL.Count - 1).Item2)
    22. Dim difyp As Double = (midPY * (nf.Item2 / BildHöhe))
    23. zoomFaktor.Add(New Tuple(Of Double, Double)(nf.Item1 / AuswahlAktuell.Width / 2 / 2, nf.Item2 / AuswahlAktuell.Width / 2 / 2))
    24. zoomVerlaufL.Add(New Tuple(Of Double, Double)(difxp, difyp))
    25. Dim xlt, ylt As Double
    27. ylt = zoomVerlaufL(0).Item2
    28. xLT = zoomVerlaufL(0).Item1
    29. For i As Integer = 1 To zoomVerlaufL.Count - 1
    30. xLT += zoomVerlaufL(i).Item1
    31. yLT += zoomVerlaufL(i).Item2
    32. Next
    33. Label12.Text = xlt & ":" & ylt#
    34. zoomFaktorLX = xlt
    35. zoomFaktorLY = ylt
    36. End If
    38. If p1.X < 0 Or p2.X < 0 Or p1.X > BildBreite Or p2.X > BildBreite Then Return False
    39. If p1.Y < 0 Or p2.Y < 0 Or p2.Y > BildHöhe Or p1.Y > BildHöhe Then Return False
    41. xmin = NumberRange(p1.X, p1.Y).Item1
    42. ymin = NumberRange(p1.X, p1.Y).Item2
    43. xmax = NumberRange(p2.X, p2.Y).Item1
    44. ymax = NumberRange(p2.X, p2.Y).Item2
    45. Return True
    46. 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^^

    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“ ()

    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!

    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“ ()

    @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!

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

    Spoiler anzeigen


    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“ ()

    @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!

    @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. ?

    @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!

    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!

    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.

Facebook
Telefonspende