Taschenrechner

    • VB.NET

    Es gibt 12 Antworten in diesem Thema. Der letzte Beitrag () ist von picoflop.

      Taschenrechner

      oder wasauchimmer man "scripten" will ;)

      ACHTUNG !!! Benötigt VS PRO (geht zumindest nicht mit Express!)

      VB.NET-Quellcode

      1. '
      2. ' Orignal in C#:
      3. ' http://www.gamedev.net/community/forums/topic.asp?topic_id=264462
      4. ' Abgewandelt in VB
      5. '
      6. Imports Microsoft.VisualBasic
      7. Imports System.CodeDom
      8. Imports System.CodeDom.Compiler
      10. Public Class NetScripter
      12. Public Sub Test()
      13. Dim d As Double = DoCalc("1 + 4 * (2^0.5)")
      14. Debug.Print(d)
      15. End Sub
      17. Public Function DoCalc(ByVal mathexp As String) As Double
      19. Dim scr As New System.Text.StringBuilder
      20. scr.AppendLine("Public Class DummyClass")
      21. scr.AppendLine("Public Shared Function DoCalc() As Double")
      22. scr.AppendLine("Return " & mathexp)
      23. scr.AppendLine("End Function")
      24. scr.AppendLine("End Class")
      26. Dim res As CompilerResults = ExecuteScript(scr.ToString)
      27. Return res.CompiledAssembly.GetType("DummyClass").GetMethod("DoCalc").Invoke(Nothing, Nothing)
      29. End Function
      31. Public Shared Function ExecuteScript(ByVal scripttext As String) As CompilerResults
      33. Dim codeProvider As CodeDomProvider = CodeDomProvider.CreateProvider("VisualBasic")
      34. Dim codeCompiler As ICodeCompiler = codeProvider.CreateCompiler
      36. Dim params As New CompilerParameters
      37. With params
      38. .GenerateExecutable = False
      39. .GenerateInMemory = True
      40. .IncludeDebugInformation = False
      41. .TreatWarningsAsErrors = False
      42. .ReferencedAssemblies.Add("system.dll")
      43. .ReferencedAssemblies.Add("System.Windows.Forms.dll")
      44. End With
      45. Dim results As CompilerResults = codeCompiler.CompileAssemblyFromSource(params, scripttext)
      46. If results.Errors.Count = 0 Then
      48. Else
      49. ' irgendeine Fehlerbehandlung
      50. Throw New Exception("mupf!")
      51. End If
      52. Return results
      54. End Function
      56. End Class


      Wie man sieht kann man eigentlich so ziemlich jeden Schweinkram damit machen. Einfach mal rumspielen ;)

      NACHTRAG:
      Bitte aufpassen, wenn man direkt Benutzereingaben übernimmt! Schließlich gehts hier letztlich um eval() und der User könnte ja zB auch Programmcode zum Löschen von Dateien etc eingeben ...

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

      @K:
      Frage: Was passiert bei dir, wenn der Code einen Fehler enthält?
      Frage: Wie lange brauchst du mit deinem System um das zu machen, was bei mir in "Test" steht (also denselben Term berechnen)? (Bei mir auf meinem NB: 0.22 sek)

      Ausgehend von DIESEM Thread:
      [Release] Quadsoft.ExpressionParser - Ein Parser für mathematische Ausdrücke

      Hab ich das ganze mal umgeschrieben, um zu zeigen, wie man mit CodeDom extrem performante Sachen machen kann. Dabei hab ich es noch nicht mal sonderlich optimiert!

      Die Klasse, die zum erzeugen des dynamischen Assemblies verwendet wird:
      Spoiler anzeigen

      VB.NET-Quellcode

      1. '
      2. ' Orignal in C#:
      3. ' http://www.gamedev.net/community/forums/topic.asp?topic_id=264462
      4. ' Abgewandelt in VB
      5. '
      6. Imports Microsoft.VisualBasic
      7. Imports System.CodeDom
      8. Imports System.CodeDom.Compiler
      10. Public Class NetScripter
      12. Public Function Test(ByVal s As String) As Byte()
      13. Return DoCalc(s, s, s)
      14. End Function
      16. Public Function DoCalc(ByVal rexp As String, ByVal gexp As String, ByVal bexp As String) As Byte()
      18. Dim scr As New System.Text.StringBuilder
      19. scr.AppendLine("Imports System.Math")
      20. scr.AppendLine("Public Class DummyClass")
      21. scr.AppendLine("Public Shared Function DoCalc() As byte()")
      22. scr.AppendLine("Dim result(256*256*3-1) As byte")
      23. scr.AppendLine("For y as integer = 0 to 255")
      24. scr.AppendLine("For x as integer = 0 to 255")
      25. scr.AppendLine("result(y*256*3 + x*3)= CInt(" & rexp & ") and &hff")
      26. scr.AppendLine("result(y*256*3 + x*3 + 1)= CInt(" & gexp & ") and &hff")
      27. scr.AppendLine("result(y*256*3 + x*3 + 2)= CInt(" & bexp & ") and &hff")
      28. scr.AppendLine("Next x")
      29. scr.AppendLine("Next y")
      30. scr.AppendLine("Return result")
      31. scr.AppendLine("End Function")
      32. scr.AppendLine("End Class")
      34. Dim res As CompilerResults = ExecuteScript(scr.ToString)
      35. Return res.CompiledAssembly.GetType("DummyClass").GetMethod("DoCalc").Invoke(Nothing, Nothing)
      37. End Function
      39. Public Shared Function ExecuteScript(ByVal scripttext As String) As CompilerResults
      41. Dim codeProvider As CodeDomProvider = CodeDomProvider.CreateProvider("VisualBasic")
      42. Dim codeCompiler As ICodeCompiler = codeProvider.CreateCompiler
      44. Dim params As New CompilerParameters
      45. With params
      46. .GenerateExecutable = False
      47. .GenerateInMemory = True
      48. .IncludeDebugInformation = False
      49. .TreatWarningsAsErrors = False
      50. .ReferencedAssemblies.Add("system.dll")
      51. .ReferencedAssemblies.Add("System.Windows.Forms.dll")
      52. End With
      53. Dim results As CompilerResults = codeCompiler.CompileAssemblyFromSource(params, scripttext)
      54. If results.Errors.Count = 0 Then
      56. Else
      57. ' irgendeine Fehlerbehandlung
      58. For Each s As String In results.Output
      59. Debug.Print(s)
      60. Next
      61. Throw New Exception("mupf!")
      62. End If
      63. Return results
      65. End Function
      67. End Class


      Aufruf zb so:
      Spoiler anzeigen

      VB.NET-Quellcode

      1. Imports NCalc
      3. Public Class Form1
      5. Private bm As Bitmap
      7. Public Sub CreateBitmap()
      9. If bm Is Nothing Then
      10. bm = New Bitmap(256, 256, System.Drawing.Imaging.PixelFormat.Format24bppRgb)
      11. Dim bmdata As System.Drawing.Imaging.BitmapData = bm.LockBits(New Drawing.Rectangle(0, 0, bm.Width, bm.Height), Imaging.ImageLockMode.ReadWrite, Imaging.PixelFormat.Format24bppRgb)
      12. Dim ptr As IntPtr = bmdata.Scan0
      13. Dim bytes As Integer = Math.Abs(bmdata.Stride) * bm.Height
      14. Dim s As String = "Sin( y / 8 + Cos( x / 5 ) / 2 ) * 127 + 127"
      15. Dim x As New NetScripter()
      16. Dim rgbvalues() As Byte = x.Test(s)
      17. System.Runtime.InteropServices.Marshal.Copy(rgbvalues, 0, ptr, rgbvalues.Length)
      18. bm.UnlockBits(bmdata)
      19. PictureBox1.Width = bm.Width
      20. PictureBox1.Height = bm.Height
      21. PictureBox1.Image = bm
      22. PictureBox1.Refresh()
      23. End If
      25. End Sub
      27. Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
      28. Dim stp As New Stopwatch
      29. stp.Start()
      30. CreateBitmap()
      31. stp.Stop()
      32. MessageBox.Show(stp.ElapsedMilliseconds.ToString)
      33. End Sub
      35. End Class

      Das ganze läuft also INKLUSIVE kompilieren UND "zeichnen" (Django zeichnet nicht, Django jongliert mit Bytes ;) ) bei MIR (Turion X2 mit 1.8 GHz) in rund 300 MILLIsekunden.

      CodeDom macht Spass ;)

      dürfte eigt. auch kein Problem sein, das Lock/Unlock innerhalb von CodeDom zu machen, damit man nur ein Bitmap übergeben muss ;)

      Bzw. Man könnte doch auch GDI+ verwenden um auf das Bild zu zeichnen, gut ist möglicherweiße langsamer(aber man bekommt ja wiederum Performancevorteile durch den verwendeten Bresenham-Algorithmus)...über DrawCurve, könnte man dann auch mit weniger Werten(weniger Rechnen->mehr Performance) eine relativ schöne Kurve zeichnen, außerdem hat man die Möglichkeit Antialiasing zu verwenden ;)

      Bzw. mist fällt mir gerade auf: es wird ja gar keine einfache Gleichung übergeben, dann geht das so gut auch wieder nicht(ein paar X-Werte könnte man denke ich trotzallem überspringen^^)
      Ich wollte auch mal ne total überflüssige Signatur:
      ---Leer---

      jvbsl schrieb:

      dürfte eigt. auch kein Problem sein, das Lock/Unlock innerhalb von CodeDom zu machen, damit man nur ein Bitmap übergeben muss

      Klar.
      Aber da ich mit AppendLine den Schrott übergebe, habe ich lieber mehr in der "richtigen" IDE geschrieben ;)

      Ich denke, was am meisten bringen dürfte:

      - Äußere Schleife (Y) mit Tasks.Parallel.For machen oder einfach in PLINQ kapseln (braucht also FW4). Dann macht er jede innere Schleife auf nem eigenen Kern und da Dual-Core ja schon fast Minimum ist, dürfte man da sicherlich nochmal so 30-70% rausholen. Konnt ich jetzt so nicht testen, weil mein Notebook nur 2008 drauf hat und der große momentan abgeklemmt ist. Theoretisch könnte man auch selber ein Multithreading drumherum schreiben ... aber wer will das schon ;)

      - Lookup Table für Cos und Sin anlegen. Könnte man den Expression String einfach mit Replace umbiegen (also Cos wird zu MyCos usw). Das ganze dann halt nur einmal berechnen und in der gewünschten genauigkeit.

      Ist halt nur die frage, ob das bei so kleinen Bitmaps überhaupt der Brüller ist. Das Kompilieren und das umzu frißt ja immer einen bestimmten Sockelbetrag an Rechenzeit

      Hmm. Ich find das immer mühselig und ineffizient, so zum rumspielen immer gleich ein neues Projekt anlegen zu müssen, und dann läufts meist nichtmal auf Anhieb - kannst du nicht vlt. deine Source komplet zippen und anhängen? - weil du hast es doch schon, und ich müsstes erst noch aufbauen.

      ErfinderDesRades schrieb:

      Hmm. Ich find das immer mühselig und ineffizient, so zum rumspielen immer gleich ein neues Projekt anlegen zu müssen, und dann läufts meist nichtmal auf Anhieb

      Und ich hasse es, jedesmal komplette Projekte runterladen zu müssen, wenn mich nur ein bestimmter Teilbereich interessiert ... ;)

      Nachtrach:
      Ich hab mal den kompilierten Code testweise so umgebaut, dass er nach dem Dim des Arrays dieses sofort return'ed. Es werden also KEINERLEI Berechnungen durchgeführt. Das Ergebnis ist ... nun ja ;)
      Mit Berechnungen: 310ms (Durchschnitt)
      Ohne Berechnungen: 250ms (Durchschnitt)

      dh man kann sich das optimieren vermutlich sparen, weil bei "kleinen" Bitmaps der Overhead durch kompilieren, invoken etc schon deutlich größer als die reine Rechenzeit ist.

      Schade eigentlich ;)
      Dateien

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

    Facebook
    Telefonspende