greycode-programmierung mit VBA-Excel

  • #1
A

a_123

Guest
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
 
  • #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)
 
Thema:

greycode-programmierung mit VBA-Excel

ANGEBOTE & SPONSOREN

Neueste Themen

Statistik des Forums

Themen
113.840
Beiträge
707.963
Mitglieder
51.494
Neuestes Mitglied
Flensburg45
Oben