greycode-programmierung mit VBA-Excel

Dieses Thema greycode-programmierung mit VBA-Excel im Forum "Microsoft Office Suite" wurde erstellt von a_123, 4. Mai 2005.

Thema: greycode-programmierung mit VBA-Excel hi ich versuche den greycode mithilfe von VBA-Excel zu programmieren. Bis jetzt habe ich nur den binärcode...

  1. hi
    ich versuche den greycode mithilfe von VBA-Excel zu programmieren. Bis jetzt habe ich nur den binärcode programmiert bekommen. Wer den unterschied nicht kennt erstmal hier
    Dez | Bin | Gray
    ---------------
    0 | 00000 | 00000
    1 | 00001 | 00001
    2 | 00010 | 00011
    3 | 00011 | 00010
    4 | 00100 | 00110
    5 | 00101 | 00111
    6 | 00110 | 00101
    7 | 00111 | 00100
    8 | 01000 | 01100
    9 | 01001 | 01101
    10 | 01010 | 01111
    11 | 01011 | 01110
    12 | 01100 | 01010
    13 | 01101 | 01011
    14 | 01110 | 01001
    15 | 01111 | 01000
    16 | 10000 | 11000
    17 | 10001 | 11001
    18 | 10010 | 11011
    19 | 11011 | 11010
    20 | 10100 | 11110
    21 | 10101 | 11111
    22 | 10110 | 11101
    23 | 10111 | 11100
    24 | 11000 | 10100
    25 | 11001 | 10101
    26 | 11010 | 10111
    27 | 11011 | 10110
    28 | 11100 | 10010
    29 | 11101 | 10011
    30 | 11110 | 10001
    31 | 11111 | 10000

    eine kleine übersicht. Wie kann man den greycode programmieren?? Da habe ich nähmlich leider nicht die geringste ahnung wie ich dort überhaupt anfangen könnte.
     
  2. Hallo a_123,

    ich hab mal das Ganze in einen Excel-Makro gegossen.

    Gruß Matjes  :)

    Code:
    Sub GraycodeErstellen()
      
     ->hier kann die Breite der Gray-Codes eingestellt werden
      Const c_BreiteGraycode As Long = 5
      
      Const c_SpalteZahl = 1
      Const c_SpalteGraycode = 2
      
      Dim wb As Workbook, ws As Worksheet
      Dim l_zeile As Long, x As Long, n As Long, pos1 As Long, pos0 As Long
     ->Integerfeld für die Aufnahme der einzelnen diggits
     ->diggit 0 ist das Zeichen rechts
      Dim f(0 To c_BreiteGraycode - 1) As Integer, diggit As Long
      
     ->neue Mappe anlegen für Ergebnis
      Set wb = Workbooks.Add
      Set ws = wb.Worksheets(1)
        
     ->Foramtierung des benötigten Bereiches als Text
      ws.Range(ws.Cells(1, 1), _
               ws.Cells(2 + (2 ^ c_BreiteGraycode), c_SpalteGraycode)).NumberFormat = @
      
     ->Zeile für Ausgabe setzen
      l_zeile = 3
      
     ->für alle Kombinationen
      For x = 0 To (2 ^ c_BreiteGraycode) - 1
       ->Bildungsgesetz für jedes Digget
       ->Diggits werden von rechts nach links betrachtet
       ->0 ist das erste diggit rechts
        For diggit = LBound(f()) To UBound(f())
          If ((x + (2 ^ diggit)) Mod (2 ^ (2 + diggit))) < (2 ^ (diggit + 1)) Then
            f(diggit) = 0
          Else
            f(diggit) = 1
          End If
        Next
       ->Zeile ausgeben (Dezimal / Graycode)
        ws.Cells(l_zeile, c_SpalteZahl).Value = x
        ws.Cells(l_zeile, c_SpalteGraycode).Value = GraycodeAlsString(f())
        l_zeile = l_zeile + 1
      Next
      
      
     ->Überschrift schreiben, Spalten ausrichten
      ws.Cells(2, c_SpalteZahl).Value = Dezimal
      ws.Cells(2, c_SpalteZahl).Font.Bold = True
      ws.Columns(c_SpalteZahl).AutoFit
      ws.Columns(c_SpalteZahl).HorizontalAlignment = xlCenter
      ws.Cells(2, c_SpalteGraycode).Value = Gray-Code
      ws.Cells(2, c_SpalteGraycode).Font.Bold = True
      ws.Columns(c_SpalteGraycode).AutoFit
      ws.Columns(c_SpalteGraycode).HorizontalAlignment = xlCenter
      
      ws.Cells(1, 1).Value = Gray-Code Breite= & c_BreiteGraycode
      ws.Cells(1, 1).Font.Bold = True
      
      Set ws = Nothing: Set wb = Nothing
    
    End Sub
    Function GraycodeAlsString(f() As Integer) As String
      Dim x As Long
      GraycodeAlsString = 
      For x = UBound(f()) To LBound(f()) Step -1
        GraycodeAlsString = GraycodeAlsString & f(x)
      Next
    End Function
     
  3. erstmal respekt!!!!!!! Du bist echt super

    ich habe allerdings nicht verstanden, wie der den greycode ermittelt, da ich es erstmal so amchen wollte, dass man eine Zahl eingint und er daraufhin den greycode herausgibt. könntest du vielleicht mal die rechnung zum greycode beschreiben?
     
  4. Hallo a_123,

    also rechnen ist nicht viel. Das Geheimnis liegt in der Betrachtung des Bildungsgesetzes. Wenn Du dir die untereinandergeschriebenen Gray-Codes spaltenweise betrachtest, kannst du eine sich wiederholende Folge feststellen.

    ganz rechte Spalte:
    fängt mit einer 0 an
    dann folgen im Wechsel 2 Einsen, 2 Nullen

    zweite Spalte von rechts:
    fängt mit zwei 0 an
    dann folgen im Wechsel 4 Einsen, 4 Nullen

    dritte Spalte von rechts:
    fängt mit vier 0 an
    dann folgen im Wechsel 8 Einsen, 8 Nullen

    Dies Verhalten ist abgebildet in:
    Code:
        If ((l_Dezimal + (2 ^ diggit)) Mod (2 ^ (2 + diggit))) < (2 ^ (diggit + 1)) Then
          f(diggit) = 0
        Else
          f(diggit) = 1
        End If
    Also muß man nur genügend diggits zur Verfügung stellen.

    Die Umrechnung hab ich dir nochmal in ein Makro geschrieben.

    Gruß Matjes :)

    Code:
    Sub EingabeDezimalAusgabeGraycode()
      
     ->hier kann die Breite der Gray-Codes eingestellt werden
      Dim x As Long, s_Dezimal As String, l_Dezimal As Long
      Dim l_2erPotenz As Long, s As String, d_tmp As Long
      Dim f() As Integer, diggit As Long
      
      s_Dezimal = 
    ZahlenEingabe:
      s_Dezimal = InputBox( _
        Bitte geben Sie eine Zahl ein., _
        Umrechnung Dezimalzahl in Gray-Code, _
        )
     ->Eingabe pruefen
      If Trim(s_Dezimal) =  Then Exit Sub
      For x = 1 To Len(s_Dezimal)
        s = Mid(s_Dezimal, x, 1)
        Select Case s
          Case 0 To 9
          Case Else
            MsgBox (x &  Zeichen unzulässig.)
            GoTo ZahlenEingabe
        End Select
      Next
      l_Dezimal = s_Dezimal
      
     ->Graycode-Breite bestimmen
      l_tmp = l_Dezimal
      l_2erPotenz = 0
      Do
        l_2erPotenz = l_2erPotenz + 1
        l_tmp = l_tmp \ 2
        If l_tmp = 0 Then Exit Do
      Loop
      
     ->Integerfeld für die Aufnahme der einzelnen diggits des Gray-Code
     ->diggit 0 ist das Zeichen rechts
      ReDim f(0 To l_2erPotenz - 1)
      
     ->Bildungsgesetz für jedes Digget
     ->Diggits werden von rechts nach links betrachtet
     ->0 ist das erste diggit rechts
      For diggit = LBound(f()) To UBound(f())
        If ((l_Dezimal + (2 ^ diggit)) Mod (2 ^ (2 + diggit))) < (2 ^ (diggit + 1)) Then
          f(diggit) = 0
        Else
          f(diggit) = 1
        End If
      Next
      
     ->Ergebnis ausgeben (Dezimal / Graycode)
      MsgBox ( _
        Umwandlung Dezimal <-> Gray-Code & vbLf & vbLf & _
        Dezimal  :  & l_Dezimal & vbLf & _
        Gray-Code:  & GraycodeAlsString(f()))
    End Sub
    '**********************************************
    Sub GraycodeTablleErstellen()
      
     ->hier kann die Breite der Gray-Codes eingestellt werden
      Const c_BreiteGraycode As Long = 5
      
      Const c_SpalteZahl = 1
      Const c_SpalteGraycode = 2
      
      Dim wb As Workbook, ws As Worksheet
      Dim l_zeile As Long, x As Long, n As Long, pos1 As Long, pos0 As Long
     ->Integerfeld für die Aufnahme der einzelnen diggits
     ->diggit 0 ist das Zeichen rechts
      Dim f(0 To c_BreiteGraycode - 1) As Integer, diggit As Long
      
     ->neue Mappe anlegen für Ergebnis
      Set wb = Workbooks.Add
      Set ws = wb.Worksheets(1)
        
     ->Foramtierung des benötigten Bereiches als Text
      ws.Range(ws.Cells(1, 1), _
               ws.Cells(2 + (2 ^ c_BreiteGraycode), c_SpalteGraycode)).NumberFormat = @
      
     ->Zeile für Ausgabe setzen
      l_zeile = 3
      
     ->für alle Kombinationen - Anfangskombination
      For x = 0 To (2 ^ c_BreiteGraycode) - 1
       ->Bildungsgesetz für jedes Digget
       ->Diggits werden von rechts nach links betrachtet
       ->0 ist das erste diggit rechts
        For diggit = LBound(f()) To UBound(f())
          If ((x + (2 ^ diggit)) Mod (2 ^ (2 + diggit))) < (2 ^ (diggit + 1)) Then
            f(diggit) = 0
          Else
            f(diggit) = 1
          End If
        Next
       ->Zeile ausgeben (Dezimal / Graycode)
        ws.Cells(l_zeile, c_SpalteZahl).Value = x
        ws.Cells(l_zeile, c_SpalteGraycode).Value = GraycodeAlsString(f())
        l_zeile = l_zeile + 1
      Next
      
      
     ->Überschrift schreiben, Spalten ausrichten
      ws.Cells(2, c_SpalteZahl).Value = Dezimal
      ws.Cells(2, c_SpalteZahl).Font.Bold = True
      ws.Columns(c_SpalteZahl).AutoFit
      ws.Columns(c_SpalteZahl).HorizontalAlignment = xlCenter
      ws.Cells(2, c_SpalteGraycode).Value = Gray-Code
      ws.Cells(2, c_SpalteGraycode).Font.Bold = True
      ws.Columns(c_SpalteGraycode).AutoFit
      ws.Columns(c_SpalteGraycode).HorizontalAlignment = xlCenter
      
      ws.Cells(1, 1).Value = Gray-Code Breite= & c_BreiteGraycode
      ws.Cells(1, 1).Font.Bold = True
      
      Set ws = Nothing: Set wb = Nothing
    
    End Sub
    '****************************************************
    Function GraycodeAlsString(f() As Integer) As String
      Dim x As Long
      GraycodeAlsString = 
      For x = UBound(f()) To LBound(f()) Step -1
        GraycodeAlsString = GraycodeAlsString & f(x)
      Next
    End Function
     
  5. mal ne frage, was bedeutet
    ?? und wieso nimmt Excel if ohne end if?
     
  6. Hallo a_123,

    Trim(String) ist ein VBA-Befehl, der ggf. Leerzeichen am Ende und am Anfang eines Strings beseitigt.
    Code:
      s_Dezimal =        1234567       
      s_Dezimal = Trim(s_Dezimal)
    Dann lautet der resultieren String s_Dezimal 1234567

    Wenn Du in Excel im VB-Editor in einem Modul diesen Befehl stehen hast, erhälst Du Hilfe dazu, indem Du dieses Wort selektierst , also TRIM, und dann F1 drückst. Dann geht die Hilfe zum selektierten Befehl auf.


    zu IF:
    Du hast vollkommen recht. Die normale Schreibweise ist
    Code:
      If Bedingung Then
        Anweisung1
        Anweisung2
      End If
    In VBA gibt es aber auch die einzeilige If-Anweisung. Da fehlt das End If.
    Code:
    If Bedingung Then Anweisung1: Anweisung2
    Damit muß man aber etwas Erfahrung sammeln. Nicht alle Konstrukte lassen sich in eine Zeile packen.

    Gruß Matjes :)
     
  7. Code:
    If ((l_Dezimal + (2 ^ diggit)) Mod (2 ^ (2 + diggit))) < (2 ^ (diggit + 1)) Then
    könntest du mir vielleicht das nochmal genauer erklären?

    Wenn ((l_Dezimal + (2 ^ diggit)) ..... Dann...

    Wozu dient diese Mod?
     
  8. Hallo a_123,

    ich hab noch einen Makro geschrieben, der die Zwischenergbnisse der Formel mit ausgibt. Dann kann man das besser verfolgen.

    Code:
    Sub EingabeDezimalAusgabeGraycode()
      
     ->hier kann die Breite der Gray-Codes eingestellt werden
      Dim x As Long, s_Dezimal As String, l_Dezimal As Long
      Dim l_2erPotenz As Long, s As String, d_tmp As Long
      Dim f() As Integer, diggit As Long
      
      s_Dezimal = 
    ZahlenEingabe:
      s_Dezimal = InputBox( _
        Bitte geben Sie eine Zahl ein., _
        Umrechnung Dezimalzahl in Gray-Code, _
        )
     ->Eingabe pruefen
      If Trim(s_Dezimal) =  Then Exit Sub
      For x = 1 To Len(s_Dezimal)
        s = Mid(s_Dezimal, x, 1)
        Select Case s
          Case 0 To 9
          Case Else
            MsgBox (x &  Zeichen unzulässig.)
            GoTo ZahlenEingabe
        End Select
      Next
      l_Dezimal = s_Dezimal
      
     ->Graycode-Breite bestimmen
      l_tmp = l_Dezimal
      l_2erPotenz = 0
      Do
        l_2erPotenz = l_2erPotenz + 1
        l_tmp = l_tmp \ 2
        If l_tmp = 0 Then Exit Do
      Loop
      
     ->Integerfeld für die Aufnahme der einzelnen diggits des Gray-Code
     ->diggit 0 ist das Zeichen rechts
      ReDim f(0 To l_2erPotenz - 1)
      
     ->Bildungsgesetz für jedes Digget
     ->Diggits werden von rechts nach links betrachtet
     ->0 ist das erste diggit rechts
      For diggit = LBound(f()) To UBound(f())
        If ((l_Dezimal + (2 ^ diggit)) Mod (2 ^ (2 + diggit))) < (2 ^ (diggit + 1)) Then
          f(diggit) = 0
        Else
          f(diggit) = 1
        End If
      Next
      
     ->Ergebnis ausgeben (Dezimal / Graycode)
      MsgBox ( _
        Umwandlung Dezimal <-> Gray-Code & vbLf & vbLf & _
        Dezimal  :  & l_Dezimal & vbLf & _
        Gray-Code:  & GraycodeAlsString(f()))
    End Sub
    '**********************************************
    Sub GraycodeTablleErstellen()
      
     ->hier kann die Breite der Gray-Codes eingestellt werden
      Const c_BreiteGraycode As Long = 5
      
      Const c_SpalteZahl = 1
      Const c_SpalteGraycode = 2
      
      Dim wb As Workbook, ws As Worksheet
      Dim l_zeile As Long, x As Long, n As Long, pos1 As Long, pos0 As Long
     ->Integerfeld für die Aufnahme der einzelnen diggits
     ->diggit 0 ist das Zeichen rechts
      Dim f(0 To c_BreiteGraycode - 1) As Integer, diggit As Long
      
     ->neue Mappe anlegen für Ergebnis
      Set wb = Workbooks.Add
      Set ws = wb.Worksheets(1)
        
     ->Foramtierung des benötigten Bereiches als Text
      ws.Range(ws.Cells(1, 1), _
               ws.Cells(2 + (2 ^ c_BreiteGraycode), c_SpalteGraycode)).NumberFormat = @
      
     ->Zeile für Ausgabe setzen
      l_zeile = 3
     ->für alle Kombinationen - Anfangskombination
      For x = 0 To (2 ^ c_BreiteGraycode) - 1
       ->Bildungsgesetz für jedes Digget
       ->Diggits werden von rechts nach links betrachtet
       ->0 ist das erste diggit rechts
        For diggit = LBound(f()) To UBound(f())
          If ((x + (2 ^ diggit)) Mod (2 ^ (2 + diggit))) < (2 ^ (diggit + 1)) Then
            f(diggit) = 0
          Else
            f(diggit) = 1
          End If
        Next
       ->Zeile ausgeben (Dezimal / Graycode)
        ws.Cells(l_zeile, c_SpalteZahl).Value = x
        ws.Cells(l_zeile, c_SpalteGraycode).Value = GraycodeAlsString(f())
        l_zeile = l_zeile + 1
      Next
      
      
     ->Überschrift schreiben, Spalten ausrichten
      ws.Cells(2, c_SpalteZahl).Value = Dezimal
      ws.Cells(2, c_SpalteZahl).Font.Bold = True
      ws.Columns(c_SpalteZahl).AutoFit
      ws.Columns(c_SpalteZahl).HorizontalAlignment = xlCenter
      ws.Cells(2, c_SpalteGraycode).Value = Gray-Code
      ws.Cells(2, c_SpalteGraycode).Font.Bold = True
      ws.Columns(c_SpalteGraycode).AutoFit
      ws.Columns(c_SpalteGraycode).HorizontalAlignment = xlCenter
      
      ws.Cells(1, 1).Value = Gray-Code Breite= & c_BreiteGraycode
      ws.Cells(1, 1).Font.Bold = True
      
      Set ws = Nothing: Set wb = Nothing
    
    End Sub
    '****************************************************
    Function GraycodeAlsString(f() As Integer) As String
      Dim x As Long
      GraycodeAlsString = 
      For x = UBound(f()) To LBound(f()) Step -1
        GraycodeAlsString = GraycodeAlsString & f(x)
      Next
    End Function
    '**********************************************
    Sub GraycodeTablleErstellenMitBerechnungZwischenergebnissen()
      
     ->hier kann die Breite der Gray-Codes eingestellt werden
      Const c_BreiteGraycode As Long = 5
      
      Const c_SpalteZahl = 1
      Const c_SpalteGraycode = 2
     ->xxx mod yyy < zzz
      Const c_Spalte_x = 3
      Const c_Spalte_digit = 4
      Const c_Spalte_digitWert = 5
      Const c_Spalte_xxx = 6
      Const c_Spalte_yyy = 7
      Const c_Spalte_xxxmodyyy = 8
      Const c_Spalte_zzz = 9
      
      
      Dim wb As Workbook, ws As Worksheet
      Dim l_zeile As Long, x As Long, n As Long, pos1 As Long, pos0 As Long
     ->Integerfeld für die Aufnahme der einzelnen diggits
     ->diggit 0 ist das Zeichen rechts
      Dim f(0 To c_BreiteGraycode - 1) As Integer, diggit As Long
      
     ->neue Mappe anlegen für Ergebnis
      Set wb = Workbooks.Add
      Set ws = wb.Worksheets(1)
        
     ->Foramtierung des benötigten Bereiches als Text
      ws.Range(ws.Cells(1, 1), _
               ws.Cells(2 + (2 ^ c_BreiteGraycode) * c_BreiteGraycode, _
                             c_Spalte_zzz)).NumberFormat = @
      
     ->Zeile für Ausgabe setzen
      l_zeile = 3
     ->für alle Kombinationen - Anfangskombination
      For x = 0 To (2 ^ c_BreiteGraycode) - 1
       ->Bildungsgesetz für jedes Digget
       ->Diggits werden von rechts nach links betrachtet
       ->0 ist das erste diggit rechts
        For diggit = LBound(f()) To UBound(f())
          If ((x + (2 ^ diggit)) Mod (2 ^ (2 + diggit))) < (2 ^ (diggit + 1)) Then
            f(diggit) = 0
          Else
            f(diggit) = 1
          End If
         ->Ausgabe der einzelnen Bestandteile der Berechnungsformel
          ws.Cells(l_zeile + diggit, c_Spalte_x).Value = x
          ws.Cells(l_zeile + diggit, c_Spalte_digit).Value = diggit
          ws.Cells(l_zeile + diggit, c_Spalte_digitWert).Value = f(diggit)
          ws.Cells(l_zeile + diggit, c_Spalte_xxx).Value = x + (2 ^ diggit)
          ws.Cells(l_zeile + diggit, c_Spalte_yyy).Value = 2 ^ (2 + diggit)
          ws.Cells(l_zeile + diggit, c_Spalte_xxxmodyyy).Value = _
                                    (x + (2 ^ diggit)) Mod (2 ^ (2 + diggit))
          ws.Cells(l_zeile + diggit, c_Spalte_zzz).Value = (2 ^ (diggit + 1))
        Next
       ->Zeile ausgeben (Dezimal / Graycode)
        ws.Cells(l_zeile, c_SpalteZahl).Value = x
        ws.Cells(l_zeile, c_SpalteGraycode).Value = GraycodeAlsString(f())
        l_zeile = l_zeile + c_BreiteGraycode
      Next
      
      
     ->Überschrift schreiben, Spalten ausrichten
      ws.Cells(2, c_SpalteZahl).Value = Dezimal
      ws.Cells(2, c_SpalteZahl).Font.Bold = True
      ws.Columns(c_SpalteZahl).AutoFit
      ws.Columns(c_SpalteZahl).HorizontalAlignment = xlCenter
      ws.Cells(2, c_SpalteGraycode).Value = Gray-Code
      ws.Cells(2, c_SpalteGraycode).Font.Bold = True
      ws.Columns(c_SpalteGraycode).AutoFit
      ws.Columns(c_SpalteGraycode).HorizontalAlignment = xlCenter
      ws.Cells(2, c_Spalte_x).Value = x
      ws.Cells(2, c_Spalte_x).Font.Bold = True
      ws.Columns(c_Spalte_x).AutoFit
      ws.Columns(c_Spalte_x).HorizontalAlignment = xlCenter
      ws.Cells(2, c_Spalte_digit).Value = diggit
      ws.Cells(2, c_Spalte_digit).Font.Bold = True
      ws.Columns(c_Spalte_digit).AutoFit
      ws.Columns(c_Spalte_digit).HorizontalAlignment = xlCenter
      ws.Cells(2, c_Spalte_digitWert).Value = diggit & vbLf & Wert
      ws.Cells(2, c_Spalte_digitWert).Font.Bold = True
      ws.Columns(c_Spalte_digitWert).AutoFit
      ws.Columns(c_Spalte_digitWert).HorizontalAlignment = xlCenter
      ws.Cells(2, c_Spalte_xxx).Value = x+(2^diggit)
      ws.Cells(2, c_Spalte_xxx).Font.Bold = True
      ws.Columns(c_Spalte_xxx).ColumnWidth = 12
      ws.Columns(c_Spalte_xxx).HorizontalAlignment = xlRight
      ws.Cells(2, c_Spalte_yyy).Value = 2^(2+diggit)
      ws.Cells(2, c_Spalte_yyy).Font.Bold = True
      ws.Columns(c_Spalte_yyy).ColumnWidth = 12
      ws.Columns(c_Spalte_yyy).HorizontalAlignment = xlRight
      ws.Cells(2, c_Spalte_xxxmodyyy).Value = (x+(2^diggit))Mod (2^(2+diggit)))
      ws.Cells(2, c_Spalte_xxxmodyyy).WrapText = True
      ws.Cells(2, c_Spalte_xxxmodyyy).Font.Bold = True
      ws.Columns(c_Spalte_xxxmodyyy).ColumnWidth = 30
      ws.Columns(c_Spalte_xxxmodyyy).HorizontalAlignment = xlRight
      ws.Cells(2, c_Spalte_zzz).Value = 2^(diggit+1)
      ws.Cells(2, c_Spalte_zzz).Font.Bold = True
      ws.Columns(c_Spalte_zzz).ColumnWidth = 12
      ws.Columns(c_Spalte_zzz).HorizontalAlignment = xlRight
    
      
      
      
      ws.Cells(1, c_Spalte_x).Value = ((x+(2^diggit)) Mod (2^(2+diggit))) < (2^(diggit+1))
      ws.Cells(1, c_Spalte_x).Font.Bold = True
      ws.Cells(1, c_Spalte_x).HorizontalAlignment = xlLeft
      ws.Cells(1, 1).Value = Gray-Code Breite= & c_BreiteGraycode
      ws.Cells(1, 1).Font.Bold = True
      
      Set ws = Nothing: Set wb = Nothing
    
    End Sub
     
  9. und jetzt auch noch die Erklärung zur Formel-Bildung  ;)

    l_Decimal hab ich hier x genannt, da das der Übersicht dient.

    Gruß Matjes :)

    Code:
    ((x + (2 ^ diggit)) Mod (2 ^ (2 + diggit))) < (2 ^ (diggit + 1))
    
    1. Schritt
    Also für das diggit 0 würde die Formel lauten:
    (x + 1) Mod 4 < 2
    
    Erklärung:
    1a)
    Mod gibt Rest zurück, der bei der Ganzzahl-Division (x+1)/4 bleibt.
    Also für x=0 ist x Mod 4 =0
    Also für x=1 ist x Mod 4 =1
    Also für x=2 ist x Mod 4 =2
    Also für x=3 ist x Mod 4 =3
    Also für x=4 ist x Mod 4 =0
    Also für x=5 ist x Mod 4 =1
    ...
    So erhält man für dieses diggit eine Formel, deren Ergebnis sich in der Schrittweite 4 wiederholt.
    
    1b)
    Jetzt muß aus diesem Ergebnis die Folge 0,0,1,1 abgeleitet werden. Das wird durch die Kleiner-Abfrage mit der halben Schrittweite bewerkstelligt.
    Also für x=0 ist x Mod 4 =0 < 2 wahr   -> Wert Diggit = 0
    Also für x=1 ist x Mod 4 =1 < 2 wahr   -> Wert Diggit = 0
    Also für x=2 ist x Mod 4 =2 < 2 falsch -> Wert Diggit = 1
    Also für x=3 ist x Mod 4 =3 < 2 falsch -> Wert Diggit = 1
    Also für x=4 ist x Mod 4 =0 < 2 wahr   -> Wert Diggit = 0
    Also für x=1 ist x Mod 4 =1 < 2 wahr   -> Wert Diggit = 0
    
    1c)
    Damit die Folge jetzt auch noch mit dem richtigen Wert anfängt, muß der Ausgangswert noch um 1 verschoben werden.
    Also für x=0 ist (x +1) Mod 4 =1 < 2 wahr   -> Wert Diggit = 0
    Also für x=1 ist (x +1) Mod 4 =2 < 2 falsch -> Wert Diggit = 1
    Also für x=2 ist (x +1) Mod 4 =3 < 2 falsch -> Wert Diggit = 1
    Also für x=3 ist (x +1) Mod 4 =0 < 2 wahr   -> Wert Diggit = 0
    Also für x=4 ist (x +1) Mod 4 =1 < 2 wahr   -> Wert Diggit = 0
    Also für x=1 ist (x +1) Mod 4 =2 < 2 wahr   -> Wert Diggit = 1
    
    Jetz haben wir das Bildungsgesetz für diggit 0. 
    
    2. Schritt
    Formel für Diggit 1 lautet:
    (x + 2) Mod 8 < 4
    Mod 8, weil alle 8 Schritte sich das Muster wiederholt (siehe 1a)
    < 4, ist die halbe Schrittweite (siehe 1b)
    Versatz ist 2 (siehe 1c)
    
    3. Schritt
    Formel für Diggit 2 lautet:
    (x + 4) Mod 16 < 8
    Erklärung (siehe 1a-c):
    Schrittweite 16, halbe Schrittweite 8, Versatz 4
    
    So kann man dann beliebig fortfahren, bis einem die Regelmäßigkeit auffällt.
    
    
    4. Schritt
    Jetzt, da das Bildungsmuster erkannt ist, muß man das ganze noch in eine Formel zwingen, die für alle diggits gilt. Dazu schreibt man sich die bisherigen Bildungsformeln der einzelnen diggits untereinander.
    
    diggit 0: (x +  1) Mod  4 <  2
    diggit 1: (x +  2) Mod  8 <  4
    diggit 2: (x +  4) Mod 16 <  8
    diggit 3: (x +  8) Mod 32 < 16
    diggit 4: (x + 16) Mod 64 < 32
    
    Man die Zahlen auch als 2er-Potenz schreiben:
    diggit 0: (x + 2^0) Mod 2^2 < 2^1
    diggit 1: (x + 2^1) Mod 2^3 < 2^2
    diggit 2: (x + 2^2) Mod 2^4 < 2^3
    diggit 3: (x + 2^3) Mod 2^5 < 2^4
    diggit 4: (x + 2^4) Mod 2^6 < 2^5
    
    Hier kann man erkennen, dass die Potenzen propotional zur diggit-Nummer steigt. 
    diggit 0: (x + 2^diggit) Mod 2^(diggit+2) < 2^(diggit+1)
    diggit 1: (x + 2^diggit) Mod 2^(diggit+2) < 2^(diggit+1)
    diggit 2: (x + 2^diggit) Mod 2^(diggit+2) < 2^(diggit+1)
    diggit 3: (x + 2^diggit) Mod 2^(diggit+2) < 2^(diggit+1)
    diggit 4: (x + 2^diggit) Mod 2^(diggit+2) < 2^(diggit+1)
    
    Da, wie man sieht, die Formeln für die einzelnen diggits gleich sind, ist die allgemeine Formel gefunden.
    (x + 2^diggit) Mod 2^(diggit+2) < 2^(diggit+1)
     
Die Seite wird geladen...

greycode-programmierung mit VBA-Excel - Ähnliche Themen

Forum Datum
VBA-Excel Variable in for-schleife hochzählen Microsoft Office Suite 27. Okt. 2008