Looking for old program or help recreating it

[STxAxTIC]

Hey R1 -

I just wanted to let you know of yet another discovery that I made that speeds everything up by ... lemme think... O(len(S)), where S is the input sequence. Anyway, I finally got around to testing whether my full-blown "phase analysis" - which was necessary for projects similar to this one - was necessary for this problem. Turns out everything improves yet again if I leave the phase stuff out of my solution. What's this mean for the code? The array inside the Analyze function called Fingerprint can be completely commented out. TheString is just "The String" now. No need to create close copies. I'm going to leave that code in anyway (related problems need it to stay, details on request). The real speed change happens because of:

Code: QB64: [Select]

1. Sub CreateHisto (arrfinger() As String, arralpha() As LetterBin, w As Integer)
2.     Dim As Integer j, k, n
3.     For n = 1 To UBound(arralpha)
4.         arralpha(n).Count = 0
5.     Next
6.     'For j = 1 To w
7.     j = 1
8.     For k = 1 To Len(arrfinger(j)) - (Len(arrfinger(j)) Mod w) Step w
9.         For n = 1 To UBound(arralpha)
10.             If (Mid$(arrfinger(j), k, w) = arralpha(n).Signature) Then
11.                 arralpha(n).Count = arralpha(n).Count + 1
12.             End If
13.         Next
14.     Next
15.     'Next
16.     Call QuickSort(arralpha(), 1, UBound(arralpha))
17. End Sub

See the entire FOR loop commented out? Good news. This all means j=1 for the whole sub, and the "fingerprint" array arrfinger() is really just a constant, just the working string. Doing this move improved every result by a little bit, and the whole thing runs faster. It's rare to find a win-win this late into the project!

I only found this because my write-up demanded that I talk about it. Since I don't want to delete a whole chapter, it's just "optional" now. I know you have the link, but for completeness:

http://barnes.x10host.com/pages/Binary-Analyzer.php

... And of course, the full code as of now:

Code: QB64: [Select]

1. Option _Explicit
2.  
3. Screen _NewImage(120, 40)
4.  
5. ' Version: 15
6.  
7. Type LetterBin
8.     Signature As String
9.     Count As Integer
10. End Type
11.  
12. Dim Shared Alphabet1(2) As LetterBin ' 0 1
13. Dim Shared Alphabet2(4) As LetterBin ' 00 01 10 11
14. Dim Shared Alphabet3(8) As LetterBin ' 000 001 010 011 100 101 110 111
15. Dim Shared Alphabet4(16) As LetterBin ' etc.
16. Dim Shared Alphabet5(32) As LetterBin
17. Dim Shared Alphabet6(64) As LetterBin
18. Dim Shared Alphabet7(128) As LetterBin
19. Dim Shared Alphabet8(256) As LetterBin
20. Dim Shared Alphabet9(512) As LetterBin
21. Dim Shared Alphabet10(1024) As LetterBin
22. Dim Shared Alphabet11(2048) As LetterBin
23. Dim Shared Alphabet12(4096) As LetterBin
24. Dim Shared Alphabet13(8192) As LetterBin
25.  
26. Alphabet1(1).Signature = "0"
27. Alphabet1(2).Signature = "1"
28. Call NewAlphabet(Alphabet1(), Alphabet2())
29. Call NewAlphabet(Alphabet2(), Alphabet3())
30. Call NewAlphabet(Alphabet3(), Alphabet4())
31. Call NewAlphabet(Alphabet4(), Alphabet5())
32. Call NewAlphabet(Alphabet5(), Alphabet6())
33. Call NewAlphabet(Alphabet6(), Alphabet7())
34. Call NewAlphabet(Alphabet7(), Alphabet8())
35. Call NewAlphabet(Alphabet8(), Alphabet9())
36. Call NewAlphabet(Alphabet9(), Alphabet10())
37. Call NewAlphabet(Alphabet10(), Alphabet11())
38. Call NewAlphabet(Alphabet11(), Alphabet12())
39. Call NewAlphabet(Alphabet12(), Alphabet13())
40.  
41. '''
42.  
43. ReDim Shared TestData(1000) As String
44. ReDim _Preserve TestData(LoadTestData(0))
45.  
46. Dim TheString As String
47.  
48. Dim As Integer j, k, n
49. Dim As Double f, g
50. Dim GuessPredicted As Integer
51. Dim GuessesCorrect As Double
52. Dim GuessesTotal As Double
53. Dim GuessStreak As Integer
54. Dim GuessStreakBest As Integer
55.  
56. Dim ProgressGraph(1 To _Width, 2) As Double
57.  
58.  
59.  
60.  
61. ''''''''''''
62. ''' Code for creating pathological strings:
63. 'Dim x$
64. 'Dim q
65. 'x$ = "1"
66. 'Print x$;
67. 'Do
68. '    Cls
69. '    Locate 1, 1
70. '    q = Analyze(x$, 0)
71. '    If (q = 1) Then
72. '        x$ = x$ + "0"
73. '    Else
74. '        x$ = x$ + "1"
75. '    End If
76. '    Print x$
77. '    _Display
78. '    _Delay .015
79. '    _Limit 120
80. 'Loop Until Len(x$) = 4000
81. 'Open "nnn.txt" For Output As #1
82. 'Print #1, x$
83. 'Close #1
84. '''''''''''
85.  
86. For n = 1 To UBound(TestData)
87.  
88.     TheString = TestData(n)
89.     GuessesCorrect = 0
90.     GuessesTotal = 0
91.     GuessStreak = 0
92.     GuessStreakBest = 0
93.  
94.     '''
95.     'TheString = ""
96.     'Randomize Timer
97.     'For k = 1 To 300
98.     '    If (Rnd > .5) Then TheString = TheString + "1" Else TheString = TheString + "0"
99.     'Next
100.  
101.     'TheString = "111000111000111000111000"
102.  
103.     '''
104.     'Cls: Locate 1, 1
105.     'Input "", TheString
106.     '''
107.  
108.     For j = 1 To Len(TheString)
109.  
110.         Cls
111.         Locate 1, 1
112.         For k = 1 To _Width
113.             Print "_";
114.         Next
115.         Print
116.         Print "Analyzing: (test # "; _Trim$(Str$(n)); ", length "; _Trim$(Str$(Len(TheString))); ")"
117.         Print
118.         Color 7
119.         Print Left$(TheString, j);
120.         Color 8
121.         Print "["; Right$(TheString, Len(TheString) - j); "]"
122.         Color 7
123.         Print
124.  
125.         ' Main prediction call
126.         GuessPredicted = Analyze(Left$(TheString, j), 0)
127.  
128.         ' Reconciliation
129.         Print "Prediction: "; _Trim$(Str$(GuessPredicted))
130.         If (j < Len(TheString)) Then
131.             Print "Actual:     "; _Trim$(Mid$(TheString, j + 1, 1))
132.             If (GuessPredicted = Val(Mid$(TheString, j + 1, 1))) Then
133.                 GuessesCorrect = GuessesCorrect + 1
134.                 GuessStreak = GuessStreak + 1
135.                 If (GuessStreak > GuessStreakBest) Then GuessStreakBest = GuessStreak
136.                 Print "I am RIGHT this round."
137.             Else
138.                 GuessStreak = 0
139.                 Print "I am WRONG this round."
140.             End If
141.             GuessesTotal = GuessesTotal + 1
142.         Else
143.             Print "Actual:     ?"
144.         End If
145.         Print
146.         Print "I'm on a "; _Trim$(Str$(GuessStreak)); "-round winning streak."
147.         Print "My best streak has been "; _Trim$(Str$(GuessStreakBest)); "."
148.         Print "My correctness rate is "; _Trim$(Str$(Int(100 * GuessesCorrect / GuessesTotal))); "% in "; _Trim$(Str$(GuessesTotal)); " guesses."
149.  
150.         ' Draw bottom graph
151.         If (CsrLin <= 23) Then
152.             For k = 1 To _Width
153.                 Locate _Height - 5, k: Print "_"
154.                 Locate _Height - 5 - 10, k: Print "_"
155.             Next
156.             Locate _Height - 5 + 1, 1: Print "0%"
157.             Locate _Height - 5 - 10 - 1, 1: Print "100%"
158.             f = (_Width - 1) / Int(Len(TheString))
159.             If (f > 1) Then f = 1 / f
160.             ProgressGraph(1 + Int(j * f), 1) = GuessesCorrect / GuessesTotal
161.             If (GuessStreak = 0) Then
162.                 ProgressGraph(1 + Int(j * f), 2) = 120
163.             Else
164.                 ProgressGraph(1 + Int(j * f), 2) = 251
165.             End If
166.             g = (_Width - 0) / Int(Len(TheString))
167.             If (g > 1) Then g = 1
168.             For k = 1 To Int(j * g)
169.                 Locate _Height - 5 - Int(10 * ProgressGraph(1 + Int(k * f), 1)), k: Print Chr$(ProgressGraph(1 + Int(k * f), 2))
170.             Next
171.         End If
172.  
173.         _Delay .015
174.         _Display
175.     Next
176.  
177.  
178.     _Delay 1
179.  
180. Next
181.  
182. End
183.  
184. Function Analyze (TheStringIn As String, pswitch As Integer)
185.     Dim TheReturn As Integer
186.     Dim As Integer n
187.     Dim As Double r, j, k, h
188.     Dim Fingerprint(16) As String
189.     Dim Partialguess(1 To 10, 2) As Double ' Change the upper bound to a higer number for more accuracy.
190.  
191.     ' Create shifted versions of string, i.e. ABCD -> BCDA, CDAB, DABC, ABCD, BCDA, etc.
192.     Fingerprint(1) = TheStringIn
193.     For n = 2 To UBound(Fingerprint)
194.         Fingerprint(n) = Right$(Fingerprint(n - 1), Len(Fingerprint(n - 1)) - 1) + Left$(Fingerprint(n - 1), 1)
195.     Next
196.  
197.     ' Initialize partial results.
198.     For n = LBound(Partialguess) To UBound(Partialguess)
199.         Partialguess(n, 1) = -999
200.     Next
201.  
202.     Call CreateHisto(Fingerprint(), Alphabet1(), 1)
203.     Call CreateHisto(Fingerprint(), Alphabet2(), 2)
204.     Call CreateHisto(Fingerprint(), Alphabet3(), 3)
205.     Call CreateHisto(Fingerprint(), Alphabet4(), 4)
206.     Call CreateHisto(Fingerprint(), Alphabet5(), 5)
207.     Call CreateHisto(Fingerprint(), Alphabet6(), 6)
208.     Call CreateHisto(Fingerprint(), Alphabet7(), 7)
209.     Call CreateHisto(Fingerprint(), Alphabet8(), 8)
210.     Call CreateHisto(Fingerprint(), Alphabet9(), 9)
211.     Call CreateHisto(Fingerprint(), Alphabet10(), 10)
212.     'Call CreateHisto(Fingerprint(), Alphabet11(), 11)
213.     'Call CreateHisto(Fingerprint(), Alphabet12(), 12)
214.     'Call CreateHisto(Fingerprint(), Alphabet13(), 13)
215.  
216.     If (pswitch = 1) Then
217.         For n = 1 To _Width
218.             Print "-";
219.         Next
220.         Print
221.     End If
222.  
223.     If (pswitch = 1) Then ' Set the last number >=1 to print stats for that histogram.
224.         If (Len(TheStringIn) >= 1) Then Call PrintHisto(Alphabet1(), 2)
225.         If (Len(TheStringIn) >= 2) Then Call PrintHisto(Alphabet2(), 4)
226.         If (Len(TheStringIn) >= 3) Then Call PrintHisto(Alphabet3(), 4)
227.         If (Len(TheStringIn) >= 4) Then Call PrintHisto(Alphabet4(), 0)
228.         If (Len(TheStringIn) >= 5) Then Call PrintHisto(Alphabet5(), 0)
229.         If (Len(TheStringIn) >= 6) Then Call PrintHisto(Alphabet6(), 0)
230.         If (Len(TheStringIn) >= 7) Then Call PrintHisto(Alphabet7(), 0)
231.         If (Len(TheStringIn) >= 8) Then Call PrintHisto(Alphabet8(), 0)
232.         If (Len(TheStringIn) >= 9) Then Call PrintHisto(Alphabet9(), 0)
233.         If (Len(TheStringIn) >= 10) Then Call PrintHisto(Alphabet10(), 0)
234.         'If (Len(TheStringIn) >= 11) Then Call PrintHisto(Alphabet11(), 0)
235.         'If (Len(TheStringIn) >= 12) Then Call PrintHisto(Alphabet12(), 0)
236.         'If (Len(TheStringIn) >= 13) Then Call PrintHisto(Alphabet13(), 0)
237.         Print
238.     End If
239.  
240.     If (Len(TheStringIn) >= 1) Then Call MakeGuess(TheStringIn, Alphabet1(), 1, Partialguess(), 0) ' Set the last number =1 to print guess for that histogram.
241.     If (Len(TheStringIn) >= 2) Then Call MakeGuess(TheStringIn, Alphabet2(), 2, Partialguess(), pswitch)
242.     If (Len(TheStringIn) >= 3) Then Call MakeGuess(TheStringIn, Alphabet3(), 3, Partialguess(), pswitch)
243.     If (Len(TheStringIn) >= 4) Then Call MakeGuess(TheStringIn, Alphabet4(), 4, Partialguess(), 0)
244.     If (Len(TheStringIn) >= 5) Then Call MakeGuess(TheStringIn, Alphabet5(), 5, Partialguess(), 0)
245.     If (Len(TheStringIn) >= 6) Then Call MakeGuess(TheStringIn, Alphabet6(), 6, Partialguess(), 0)
246.     If (Len(TheStringIn) >= 7) Then Call MakeGuess(TheStringIn, Alphabet7(), 7, Partialguess(), 0)
247.     If (Len(TheStringIn) >= 8) Then Call MakeGuess(TheStringIn, Alphabet8(), 8, Partialguess(), 0)
248.     If (Len(TheStringIn) >= 9) Then Call MakeGuess(TheStringIn, Alphabet9(), 9, Partialguess(), 0)
249.     If (Len(TheStringIn) >= 10) Then Call MakeGuess(TheStringIn, Alphabet10(), 10, Partialguess(), 0)
250.     'If (Len(TheStringIn) >= 11) Then Call MakeGuess(TheStringIn, Alphabet11(), 11, Partialguess(), 0)
251.     'If (Len(TheStringIn) >= 12) Then Call MakeGuess(TheStringIn, Alphabet12(), 12, Partialguess(), 0)
252.     'If (Len(TheStringIn) >= 13) Then Call MakeGuess(TheStringIn, Alphabet13(), 13, Partialguess(), 0)
253.     If (pswitch = 1) Then Print
254.  
255.     If (pswitch = 1) Then
256.         Print "Thinking:";
257.         For k = LBound(Partialguess) To UBound(Partialguess)
258.             If (Partialguess(k, 1) <> -999) Then
259.                 Print Partialguess(k, 1);
260.             Else
261.                 Print "_ ";
262.             End If
263.         Next
264.         Print
265.     End If
266.  
267.     j = 0
268.     r = 0
269.  
270.     For k = UBound(Partialguess) To LBound(Partialguess) Step -1
271.         If (Partialguess(k, 1) <> -999) Then
272.  
273.             ' This is the made-up part of the model:
274.             ' The variable r contributes to weighted average.
275.             ' The variable j is used for normalization.
276.             ' Scaling factor h influences weighted average calculaton.
277.             ' The factors multiplying h are totally arbitrary. Notes:
278.             '   setting o(h^2) means the later alphabets count for more.
279.             '   Partialguess(k, 1) euqals the calculated guess at frequency k.
280.             '   Partialguess(k, 2) euqals the peak count of the unscaled histogram.
281.             '   ...while Partialguess(k, 2) is here, it does not seem to help calculations.
282.  
283.             h = 1 + k - LBound(Partialguess)
284.  
285.             h = h ^ 2
286.  
287.             ' Standard weighted average:
288.             r = r + h * Partialguess(k, 1)
289.             j = j + h
290.  
291.         End If
292.     Next
293.     If (j <> 0) Then
294.         r = r / j
295.     End If
296.  
297.     If (pswitch = 1) Then Print "Predicting:  "; _Trim$(Str$(r))
298.  
299.     If (r > .5) Then
300.         r = 1
301.     Else
302.         r = 0
303.     End If
304.  
305.     If (pswitch = 1) Then
306.         Print "Rounding to: "; _Trim$(Str$(r))
307.     End If
308.  
309.     If (pswitch = 1) Then
310.         For n = 1 To _Width
311.             Print "-";
312.         Next
313.         Print: Print
314.     End If
315.  
316.     TheReturn = r
317.     Analyze = TheReturn
318. End Function
319.  
320. Sub MakeGuess (TheStringIn As String, arralpha() As LetterBin, wid As Integer, arrbeta() As Double, pswitch As Integer)
321.     Dim TheReturn As Double
322.     Dim As Integer j, k, n
323.     TheReturn = 0
324.     j = 1
325.     k = 0
326.     For n = 1 To UBound(arralpha)
327.         If (Left$(arralpha(n).Signature, wid - 1) = Right$(TheStringIn, wid - 1)) Then
328.             If (arralpha(n).Count >= j) Then
329.                 If (pswitch = 1) Then Print "Order-"; Right$("0" + _Trim$(Str$(wid)), 2); " guess: "; arralpha(n).Signature; " . "; _Trim$(Str$(arralpha(n).Count))
330.                 TheReturn = TheReturn + Val(Right$(arralpha(n).Signature, 1))
331.                 k = k + 1
332.                 j = arralpha(n).Count
333.             End If
334.         End If
335.     Next
336.     If (k <> 0) Then
337.         TheReturn = TheReturn / k
338.     Else
339.         TheReturn = .5
340.     End If
341.     arrbeta(wid, 1) = TheReturn
342.     arrbeta(wid, 2) = j
343. End Sub
344.  
345. Sub CreateHisto (arrfinger() As String, arralpha() As LetterBin, w As Integer)
346.     Dim As Integer j, k, n
347.     For n = 1 To UBound(arralpha)
348.         arralpha(n).Count = 0
349.     Next
350.     'For j = 1 To w
351.     j = 1
352.     For k = 1 To Len(arrfinger(j)) - (Len(arrfinger(j)) Mod w) Step w
353.         For n = 1 To UBound(arralpha)
354.             If (Mid$(arrfinger(j), k, w) = arralpha(n).Signature) Then
355.                 arralpha(n).Count = arralpha(n).Count + 1
356.             End If
357.         Next
358.     Next
359.     'Next
360.     Call QuickSort(arralpha(), 1, UBound(arralpha))
361. End Sub
362.  
363. Sub PrintHisto (arr() As LetterBin, w As Integer)
364.     Dim As Integer j, n
365.     If (w > 0) Then
366.         If (w > UBound(arr)) Then
367.             j = UBound(arr)
368.         Else
369.             j = w
370.         End If
371.         Print "Histogram: "; _Trim$(Str$(UBound(arr))); "-letter regroup, showing top "; _Trim$(Str$(w))
372.         For n = 1 To j
373.             Print arr(n).Signature; arr(n).Count
374.         Next
375.     End If
376. End Sub
377.  
378. Sub NewAlphabet (arrold() As LetterBin, arrnew() As LetterBin)
379.     Dim As Integer j, k, n
380.     n = 0
381.     For k = 1 To 2
382.         For j = 1 To UBound(arrold)
383.             n = n + 1
384.             arrnew(n).Signature = arrold(j).Signature
385.         Next
386.     Next
387.     For j = 1 To UBound(arrnew)
388.         If (j <= UBound(arrnew) / 2) Then
389.             arrnew(j).Signature = "0" + arrnew(j).Signature
390.         Else
391.             arrnew(j).Signature = "1" + arrnew(j).Signature
392.         End If
393.     Next
394. End Sub
395.  
396. Sub QuickSort (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
397.     Dim As Long piv
398.     If (LowLimit < HighLimit) Then
399.         piv = Partition(arr(), LowLimit, HighLimit)
400.         Call QuickSort(arr(), LowLimit, piv - 1)
401.         Call QuickSort(arr(), piv + 1, HighLimit)
402.     End If
403. End Sub
404.  
405. Function Partition (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
406.     Dim As Long i, j
407.     Dim As Double pivot, tmp
408.     pivot = arr(HighLimit).Count
409.     i = LowLimit - 1
410.     For j = LowLimit To HighLimit - 1
411.         tmp = arr(j).Count - pivot
412.         If (tmp >= 0) Then
413.             i = i + 1
414.             Swap arr(i), arr(j)
415.         End If
416.     Next
417.     Swap arr(i + 1), arr(HighLimit)
418.     Partition = i + 1
419. End Function
420.  
421. Function LoadTestData (alwayszero As Integer)
422.     Dim n As Integer
423.     n = alwayszero
424.     '''
425.     ' Systematic cases:
426.     '''
427.     n = n + 1: TestData(n) = "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
428.     n = n + 1: TestData(n) = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
429.     n = n + 1: TestData(n) = "0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101"
430.     n = n + 1: TestData(n) = "1010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010"
431.     n = n + 1: TestData(n) = "0010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010"
432.     n = n + 1: TestData(n) = "0100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100"
433.     n = n + 1: TestData(n) = "1001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001"
434.     n = n + 1: TestData(n) = "1101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101"
435.     n = n + 1: TestData(n) = "1011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011"
436.     n = n + 1: TestData(n) = "0110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110"
437.     '
438.     '''
439.     ' Community hand-typed cases:
440.     '''
441.     ' (from Cobalt) (Results in: 48%  -  Claims he made this data hand but behavior in Discord raises doubt.)
442.     n = n + 1: TestData(n) = "1010001101110110000000011100110100101010111110101001100101110100000111101011011000010101101100000110010010010101010110111111111001000100101011101000011110011000000100111100001100111000111100100000000111010011010011001111101000010011101111000011100011010110101101000111101111100101100100000101111011001101100000111011000001001111000110000001110101100101"
443.     ' (from Keybone) (Results in: 82%)
444.     n = n + 1: TestData(n) = "101010101010101010101001010101010101001010111001010101010101010101010100010101010101010100101001010101001100101010001010100101010100101010100101010101010101010011011110010101010100100101010110010011001010011001010100010100101010010101010101010010101010101010010101001010101010100110010101010100101010101010011001001010100101010010101010100101010010101001010100101001010010101010111010100110011001010101010100110101001010101010100101001010111010101010101010100101001010101010010101010101001010101001010101001010100101010100101010010101010101001010101001010101010101001010101001010100101010101010010101010010010101010101010101010010100101010101001010100101001010101001111101010101010100101010110011001010101010101010110101010101101010101010100101010010101010010101010101101110010101001010101010110010100101010101001011010101010100110101010100101010010101010100101010101001010101010101001010101010011010101010101110110100101010111010101011011001011001010101001010101010101010101010011001010101010100101010101010101010010100101"
445.     ' (from Keybone) (Results in: 54%)
446.     n = n + 1: TestData(n) = "0101110101100011010100101011001110001011001010001110101111010100111011100100101001010011110101101000101010001010101111001010111010101010100001010101000101101100101111101010010101110110111001000101000011010101010001001001001111101011101010100010110101110101100000101010101110111010100100100001110111100101011110101010001010001110010110111110110010101001001011101000101001011100011101000010101010101101010010110100101101000101111010101110111001010011101111010101000010101111100010101011110101011011110100001010110"
447.     ' (from Loudar) (Results in: 71%)
448.     n = n + 1: TestData(n) = "1011001010010100100100110010101010101001010101010101011010010101001010101001010010100110101011010101010101011010101101010101010101010010110101010101100101010101010110101101011010010101010010100110101101001010110101011010010101101010110100101111010101010011011011010010110101010010110100101101010100101011010010101001010101010001011101011010010101011100111010010001101011110010011010001011100110101010010011010101001001010010000101010110001"
449.     ' (from Luke) (Results in: 51%  -  I have long suspected Luke to be a computer. The numbers are now in.)
450.     n = n + 1: TestData(n) = "01100101001010001100001101101111011010010101010110110101001000001111001111110101000101111011010101111101010101101010101001010101011000010101010101001011010100110100110100110011010101010101110101010111111101011010100000001101111000010111000110111001000010100001101010110100000111101011111100001011001010110010110" ' Luke 50
451.     ' (from Sarafromct) (Results in: 64%)
452.     n = n + 1: TestData(n) = "10101010101011101000011101010111010101010101100111001010100111100001011011110101000001111010101101010000001111110011111110111101110111001110110010000100010101010101010100101011010110101010101010101001000000001111110000011110101010101010100010101110101010101101111111111111111111101010101010101000000" ' 63
453.     ' (from Spriggs) (Results in: 85%)
454.     n = n + 1: TestData(n) = "10111010101010101010101001010101010101001010101001010101010101010101010101010101010101010101010101010101001010100100100101010101010101001010100101010101010100101010100101010101010101010101001010010110010101010010101010101010101010101010100101001001001010101010101010101010101001010101001001101010010"
455.     ' (from Spriggs) (Results in: 67%)
456.     n = n + 1: TestData(n) = "11111011110100101011111111110100000011011110101100111100111111110111101110100111100110011111110101111111010111101111100111110111111111111011100111110111111110010000101011111001110101101010110111110"
457.     ' (from Hotpants) (Results in: 62%)
458.     n = n + 1: TestData(n) = "01010100011001010010101010101010101000110101010111101010100100011010101010100100101110010010010100001010101001010101010110010001001011000100100110101001001001010000000001010101101111101001010100010101001001010101000100101001100100010011010101010101010111010010101011101011011010110100100010010100100100010010001001" ' Tom
459.     '
460.     '''
461.     ' Known-Random cases:
462.     '''
463.     ' (using RND) (Results in: 45%)
464.     n = n + 1: TestData(n) = "11100101110011011010110100110011111011010110100100000110000100101001001010011100111101101110000001000000011011100101110000000111100100011101000000101000110100001000000001111010101011000010001110111110001001110101011000010101001111010100100000011100110110110000111010001010000011010000101111101011000"
465.     ' (from Spriggs) (Results in: 52%)
466.     n = n + 1: TestData(n) = "010101111010111100110000001001100100101100000101110001100101000010001001111101111111111100011110000011011110011000100011100100001101110011001001011001000011110010001000111100011100011110010110011110111010110100001000110000010000111000111011100110011010101111111100100010001111111100010100001011000011"
467.     ' (Wolfrm rule 30, central column) (Results in: 47%)
468.     n = n + 1: TestData(n) = "110111001100010110010011101011100111010101100001100101011010101111110000111100010101110000010010110001"
469.     ' (using RND) (Results in: 46%)
470.     n = n + 1: TestData(n) = "111001011100110110101101001100111110110101101001000001100001001010010010100111001111011011100000010000000110111001011100000001111001000111010000001010001101000010000000011110101010110000100011101111100010011101010110000101010011110101001000000111001101101100001110100010100000110100001011111010110000"
471.     ' (using RND) (Results in: 46%)
472.     n = n + 1: TestData(n) = "111001011100110110101101001100111110110101101001000001100001001010010010100111001111011011100000010000000110111001011100000001111001000111010000001010001101000010000000011110101010110000100011101111100010011101010110000101010011110101001000000111001101101100001110100010100000110100001011111010110000101110111110011100001000110010010001100111101000001101011000010101101011111010010001010010110110011000001001101000011100000011110001110011100010101010111101100100100001001000101101110110101100001111011101000100111110000001110000111011101000110110100111101101001100100110000111110111101001100010011110"
473.     ' (using RND) (Results in: 45%)
474.     n = n + 1: TestData(n) = "111001011100110110101101001100111110110101101001000001100001001010010010100111001111011011100000010000000110111001011100000001111001000111010000001010001101000010000000011110101010110000100011101111100010011101010110000101010011110101001000000111001101101100001110100010100000110100001011111010110000101110111110011100001000110010010001100111101000001101011000010101101011111010010001010010110110011000001001101000011100000011110001110011100010101010111101100100100001001000101101110110101100001111011101000100111110000001110000111011101000110110100111101101001100100110000111110111101001100010011110111001001100111000110011011000100101100010101010000010000111111010111111011100011100001000011000100100111001100001111010001010000001011100000101110000110010111110010101010110111110011100100001011101010000011011110110100010110111000100000110000001001010001011010000010001111110100100010011100011001000"
475.     ' (using RND) (Results in: 48%)
476.     n = n + 1: TestData(n) = "111001011100110110101101001100111110110101101001000001100001001010010010100111001111011011100000010000000110111001011100000001111001000111010000001010001101000010000000011110101010110000100011101111100010011101010110000101010011110101001000000111001101101100001110100010100000110100001011111010110000101110111110011100001000110010010001100111101000001101011000010101101011111010010001010010110110011000001001101000011100000011110001110011100010101010111101100100100001001000101101110110101100001111011101000100111110000001110000111011101000110110100111101101001100100110000111110111101001100010011110111001001100111000110011011000100101100010101010000010000111111010111111011100011100001000011000100100111001100001111010001010000001011100000101110000110010111110010101010110111110011100100001011101010000011011110110100010110111000100000110000001001010001011010000010001111110100100010011100011001000011101011010100110110000110010010011110111001001011111011000000100010011011100111110111011111101100011011101001111110100011010000111001001010111011101000001010010010100111010001001010101001000010011100111010101000110010110101111001110000010110110010101001000011000101000001100110100111101000110111101101010011011000101100101001010001100110101000101110000101100110010011010001010101010101101110101110110101100101001111100110110101011001000001100101001011000101100001001000001010111010100010100101011001111001011011100011001110010111011110010111101011101000100100010111010000001010011101010001110110110101011000101010100000001110110101011110101111100100101101000001011000101001110010010010000111001101010100101111101001110010001011000001001000111010001000011000111000000111001110111110011110110101100111011001100101101010101100010100100001010010110010000001100110010010100110011110110000001001000111001001010010000011111110011110010001100011100011010000111100111111010010001010011100100111100111101111110101000010011100011111100010000011111101101010010100000011011001110001100001011111100111000001110111011001111110011011100111000110110110011110000111000010011011000011001111111110010100000111110011111100100001100000000110001111101101011100011111011110001100100001100011100011111000000110011011100110101101001001111101101000000110101101001100011100011001110001000000111111100110101001110100010010010100000010100001010001011011001101010011111001101110110010101000111101100111000011000111001100011011011010100111111001100000100100110000100101001111111100110010111100000111101101001111001010011010011011100101001001001110101110001101010001111010101100101010111000111000011000001010010010101010100001110010001001001110110011100110011111001100111010011110100100110010000100011010001110000000100001100000010000111000111111000111100010001101011000101000010100011100011111000100010101000001001011001000101101111110111110110001101001001011100011110001101100010100101101011001001100111000000111111110110100010111111101000000001111000100001111111011000101001111110010000110101100010000011100110111101011011100110"
477.     '
478.     '''
479.     ' Pathological cases:
480.     '''
481.     n = n + 1: TestData(n) = "011111101111111110101111110011111110110111110111011110111001110111010110111101001111101010111110010111100110111011010110" ' seed 0
482.     n = n + 1: TestData(n) = "100000010000000001010000001100000001001000001000100001000110001000101001000010110000010101000001101000011001000100101001" ' seed 1
483.     n = n + 1: TestData(n) = "001111111110111111101011111100111110111011110110111110101011110111100110111111000111111110010111110011101110101101110010" ' seed 00
484.     n = n + 1: TestData(n) = "011111101111111110101111110011111110110111110111011110111001110111010110111101001111101010111110010111100110111011010110" ' seed 01
485.     n = n + 1: TestData(n) = "100000010000000001010000001100000001001000001000100001000110001000101001000010110000010101000001101000011001000100101001" ' seed 10
486.     n = n + 1: TestData(n) = "110000000001000000010100000011000001000100001001000001010100001000011001000000111000000001101000001100010001010010001101" ' seed 11
487.     n = n + 1: TestData(n) = "000111111111011111101101111101011111110011111110101011101110110110101110011101111011101010011110110011111011110011011110" ' seed 000
488.     n = n + 1: TestData(n) = "001111111110111111101011111100111110111011110110111110101011110111100110111111000111111110010111110011101110101101110010" ' seed 001
489.     n = n + 1: TestData(n) = "010111111111011111101101111101011110111011110101011111100111111110010111110111001110111110001111110100111110101101110100" ' seed 010
490.     n = n + 1: TestData(n) = "011111101111111110101111110011111110110111110111011110111001110111010110111101001111101010111110010111100110111011010110" ' seed 011
491.     n = n + 1: TestData(n) = "100000010000000001010000001100000001001000001000100001000110001000101001000010110000010101000001101000011001000100101001" ' seed 100
492.     n = n + 1: TestData(n) = "101000000000100000010010000010100001000100001010100000011000000001101000001000110001000001110000001011000001010010001011" ' seed 101
493.  
494.     LoadTestData = n
495. End Function
496.  
497.  

[STxAxTIC]

Hey R1

So the draft is finally complete, I can't believe it. I just updated the site with my hurried, probably typo-ridden discourse taking the reader through this project. I took care to explain every step, with pictures. Its subject to little updates for typos and stuff, but for the model described and the numbers shouldn't change.

As per usual, it's here: http://barnes.x10host.com/pages/Binary-Analyzer.php

The BAS file at the top is the latest version of the code (and always will be, consider that page the home for this code).

Now.... with all that out of the way.... I changed my "h" variable into an array, so I can turn certain weights on or off manually instead of using a sweeping function. This hasn't been explored whatsoever yet, but the code is ready to go on that front. The challenge now becomes stepping through "weight space", which, ironically can be reduced to a bunch of 1 and 0 switches, which it itself a binary sequence - and we could feed this into the ....!... nevermind... So I'll call this a milestone and let it rest a while.

Now I may inhale.

[random1]

STxAxTIC

I would like to see a fully stripped down version of the code, ie, string in / prediction
out, no print code or commented out stuff.  I use the full update as a stand-alone to
to check the edits I make in my embedded code,  If both outputs match then I figure
there's no mistakes.  If it's not too much to ask, it would be great to have a stripped
version along with full updates. 

Thanks for all the content and work on your end.  I can't weight, "pun intended," to work
with the new version.  Too many arms in the fire right now but soon as the holidays end
I will be able to dig in.

R1   

[STxAxTIC]

Morning r1,

So there is a short answer to your question, and that's my function Analyze(). It's a black box that receives a string and returns a number. I got rid of the commented-out lines, but it still takes a print switch argument can be ignored by setting to 0 forever.

Things got a little more complicated, too. I removed from Analyze() all of the human-influenced parts of the prediction model, and put this information in a shared array called AlphaWeight(). There is a good reason for this you may see coming. Anyway, a call to Analyze() looks like this:

Code: QB64: [Select]

1.  GuessPredicted = Analyze(TheString, AlphaWeight(), 0)

If you want the absolute black-box nugget of code that makes this go, that's the line. You can delete everything enclosing that line and use it in isolation. Admittedly I could/should streamline this function in terms of the way it *looks*, but that's a style issue I'll figure out later. It's me skirting around the arrays-in-types problem, if you want the excuse.

The reason AlphaWeight() is it's own entity now is I've discovered two different prediction models that work for two different jobs. For the long, wacky test strings we've been doing, the full-frequency analysis works best. For human inputs though, for some reason, 5-grams work the best: turn off all weights except 5. This is pure sorcery though, no good reason to have made this realization.

My next job is to come up with a way to "walk through weight space" where I can apply calculus to focus in on the best models for given tasks. Kinda exciting really. Sounds like AI (a term I hate).

As a program note, there are now three downloads at the top of the website. I froze the "article" version of the code in time so that there's something executable to go with the website. The main code is moving on though. (It's all kept straight with a version number.)

Code: QB64: [Select]

1. Option _Explicit
2.  
3. Screen _NewImage(120, 40)
4.  
5. ' Version: 18
6.  
7. Type LetterBin
8.     Signature As String
9.     Count As Integer
10. End Type
11.  
12. Dim Shared Alphabet1(2) As LetterBin ' 0 1
13. Dim Shared Alphabet2(4) As LetterBin ' 00 01 10 11
14. Dim Shared Alphabet3(8) As LetterBin ' 000 001 010 011 100 101 110 111
15. Dim Shared Alphabet4(16) As LetterBin ' etc.
16. Dim Shared Alphabet5(32) As LetterBin
17. Dim Shared Alphabet6(64) As LetterBin
18. Dim Shared Alphabet7(128) As LetterBin
19. Dim Shared Alphabet8(256) As LetterBin
20. Dim Shared Alphabet9(512) As LetterBin
21. Dim Shared Alphabet10(1024) As LetterBin
22. Dim Shared Alphabet11(2048) As LetterBin
23. Dim Shared Alphabet12(4096) As LetterBin
24. Dim Shared Alphabet13(8192) As LetterBin
25.  
26. Alphabet1(1).Signature = "0"
27. Alphabet1(2).Signature = "1"
28. Call NewAlphabet(Alphabet1(), Alphabet2())
29. Call NewAlphabet(Alphabet2(), Alphabet3())
30. Call NewAlphabet(Alphabet3(), Alphabet4())
31. Call NewAlphabet(Alphabet4(), Alphabet5())
32. Call NewAlphabet(Alphabet5(), Alphabet6())
33. Call NewAlphabet(Alphabet6(), Alphabet7())
34. Call NewAlphabet(Alphabet7(), Alphabet8())
35. Call NewAlphabet(Alphabet8(), Alphabet9())
36. Call NewAlphabet(Alphabet9(), Alphabet10())
37. Call NewAlphabet(Alphabet10(), Alphabet11())
38. Call NewAlphabet(Alphabet11(), Alphabet12())
39. Call NewAlphabet(Alphabet12(), Alphabet13())
40.  
41. ' Load test data.
42. ReDim Shared TestData(10000) As String
43. ReDim _Preserve TestData(LoadTestData(0))
44.  
45. ' This is the made-up part of the model.
46. Dim Shared AlphaWeight(13) As Double
47.  
48. ' Statistics and metrics:
49. Dim GuessPredicted As Integer
50. Dim GuessesCorrect As Double
51. Dim GuessesTotal As Double
52. Dim GuessStreak As Integer
53. Dim GuessStreakMax As Integer
54. Dim Grade(10000, 2) As Double
55.  
56. Call InitializeModel
57.  
58. '''
59. ' Bypass pre-cooked test data.
60. 'TestData(1) = "1111111111111111111111"
61. 'ReDim _Preserve TestData(1)
62. '''
63.  
64. Dim TheString As String
65. Dim As Integer k, m, n
66.  
67. For m = 1 To UBound(TestData)
68.  
69.     GuessPredicted = -1
70.     GuessesCorrect = 0
71.     GuessesTotal = 0
72.     GuessStreak = 0
73.     GuessStreakMax = 0
74.  
75.     For n = 1 To Len(TestData(m))
76.  
77.         '''
78.         ' Research Mode
79.         TheString = Left$(TestData(m), n)
80.         '''
81.  
82.         '''
83.         '' Gaming Mode
84.         'Cls
85.         'Locate 1, 1
86.         'Print "Press LEFT or RIGHT."
87.         'k = 0
88.         'Do: k = _KeyHit: Loop Until ((k = 19200) Or (k = 19712))
89.         'Select Case k
90.         '    Case 19200
91.         '        TheString = TheString + "0"
92.         '    Case 19712
93.         '        TheString = TheString + "1"
94.         'End Select
95.         '_KeyClear
96.         '''
97.  
98.         Cls
99.         Color 7
100.         Locate 1, 1
101.         For k = 1 To _Width
102.             Print "_";
103.         Next
104.         Print "Model:";
105.         For k = 1 To UBound(AlphaWeight)
106.             Print AlphaWeight(k);
107.         Next
108.         Print
109.         Print
110.         Print "Sequence (length "; _Trim$(Str$(Len(TheString))); "):"
111.         Print TheString;
112.         Color 8
113.         Print Right$(TestData(m), Len(TestData(m)) - n)
114.         Color 7
115.  
116.         ' Reconciliation
117.         If (GuessPredicted <> -1) Then
118.             Print
119.             Print
120.             Print "I predicted "; _Trim$(Str$(GuessPredicted)); " and you typed "; Right$(TheString, 1); "."
121.             If (GuessPredicted = Val(Right$(TheString, 1))) Then
122.                 Print "I am RIGHT this round."
123.                 GuessesCorrect = GuessesCorrect + 1
124.                 GuessStreak = GuessStreak + 1
125.                 If (GuessStreak > GuessStreakMax) Then GuessStreakMax = GuessStreak
126.                 Grade(n, 2) = 1
127.             Else
128.                 Print "I am WRONG this round."
129.                 GuessStreak = 0
130.                 Grade(n, 2) = 0
131.             End If
132.             GuessesTotal = GuessesTotal + 1
133.             Grade(n, 1) = GuessesCorrect / GuessesTotal
134.         End If
135.  
136.         If (GuessesTotal > 0) Then
137.             Print
138.             Print "I'm on a "; _Trim$(Str$(GuessStreak)); "-round winning streak."
139.             Print "My best streak has been "; _Trim$(Str$(GuessStreakMax)); "."
140.             If (GuessesTotal <> 0) Then
141.                 Print "My correctness rate is "; _Trim$(Str$(Int(100 * GuessesCorrect / GuessesTotal))); "% in "; _Trim$(Str$(GuessesTotal)); " guesses."
142.             End If
143.         End If
144.  
145.         GuessPredicted = Analyze(TheString, AlphaWeight(), 0)
146.  
147.         Print
148.         Print "I have made a prediction."
149.         Print "Press LEFT or RIGHT to test me."
150.  
151.         ' Draw bottom graph
152.         If (CsrLin <= 23) Then
153.             If (GuessesTotal <> 0) Then
154.                 Call PrintGraph(TheString, Grade())
155.             End If
156.         End If
157.  
158.         _Delay .02
159.         _Display
160.         _Limit 60
161.     Next
162.  
163.     _Delay 3
164. Next
165.  
166. End
167.  
168. Sub InitializeModel
169.     Dim As Integer k
170.     For k = 1 To UBound(AlphaWeight)
171.         AlphaWeight(k) = k ^ 2
172.     Next
173.     'AlphaWeight(1) = 0
174.     'AlphaWeight(2) = 0
175.     'AlphaWeight(3) = 0
176.     'AlphaWeight(4) = 0
177.     'AlphaWeight(5) = 1
178.     'AlphaWeight(6) = 0
179.     'AlphaWeight(7) = 0
180.     'AlphaWeight(8) = 0
181.     'AlphaWeight(9) = 0
182.     'AlphaWeight(10) = 0
183.     AlphaWeight(11) = 0
184.     AlphaWeight(12) = 0
185.     AlphaWeight(13) = 0
186. End Sub
187.  
188. Function Analyze (TheStringIn As String, arrweight() As Double, pswitch As Integer)
189.     Dim TheReturn As Integer
190.     Dim As Integer n
191.     Dim As Double r, j, k
192.     Dim StringPhase(16) As String
193.     Dim Partialguess(1 To 13, 2) As Double ' Change the upper bound to a higer number for more accuracy.
194.  
195.     ' Create shifted versions of string, i.e. ABCD -> BCDA, CDAB, DABC, ABCD, BCDA, etc.
196.     StringPhase(1) = TheStringIn
197.     'For n = 2 To UBound(StringPhase)
198.     'StringPhase(n) = Right$(StringPhase(n - 1), Len(StringPhase(n - 1)) - 1) + Left$(StringPhase(n - 1), 1)
199.     'Next
200.  
201.     ' Initialize partial results.
202.     For n = LBound(Partialguess) To UBound(Partialguess)
203.         Partialguess(n, 1) = -999
204.     Next
205.  
206.     If (arrweight(1) <> 0) Then Call CreateHisto(StringPhase(), Alphabet1(), 1)
207.     If (arrweight(2) <> 0) Then Call CreateHisto(StringPhase(), Alphabet2(), 2)
208.     If (arrweight(3) <> 0) Then Call CreateHisto(StringPhase(), Alphabet3(), 3)
209.     If (arrweight(4) <> 0) Then Call CreateHisto(StringPhase(), Alphabet4(), 4)
210.     If (arrweight(5) <> 0) Then Call CreateHisto(StringPhase(), Alphabet5(), 5)
211.     If (arrweight(6) <> 0) Then Call CreateHisto(StringPhase(), Alphabet6(), 6)
212.     If (arrweight(7) <> 0) Then Call CreateHisto(StringPhase(), Alphabet7(), 7)
213.     If (arrweight(8) <> 0) Then Call CreateHisto(StringPhase(), Alphabet8(), 8)
214.     If (arrweight(9) <> 0) Then Call CreateHisto(StringPhase(), Alphabet9(), 9)
215.     If (arrweight(10) <> 0) Then Call CreateHisto(StringPhase(), Alphabet10(), 10)
216.     If (arrweight(11) <> 0) Then Call CreateHisto(StringPhase(), Alphabet11(), 11)
217.     If (arrweight(12) <> 0) Then Call CreateHisto(StringPhase(), Alphabet12(), 12)
218.     If (arrweight(13) <> 0) Then Call CreateHisto(StringPhase(), Alphabet13(), 13)
219.  
220.     If (pswitch = 1) Then
221.         For n = 1 To _Width
222.             Print "-";
223.         Next
224.         Print
225.     End If
226.  
227.     If (pswitch = 1) Then ' Set the last argument >=1 to print stats for that histogram.
228.         If ((Len(TheStringIn) >= 1) And (arrweight(1) <> 0)) Then Call PrintHisto(Alphabet1(), 2)
229.         If ((Len(TheStringIn) >= 2) And (arrweight(2) <> 0)) Then Call PrintHisto(Alphabet2(), 4)
230.         If ((Len(TheStringIn) >= 3) And (arrweight(3) <> 0)) Then Call PrintHisto(Alphabet3(), 4)
231.         If ((Len(TheStringIn) >= 4) And (arrweight(4) <> 0)) Then Call PrintHisto(Alphabet4(), 0)
232.         If ((Len(TheStringIn) >= 5) And (arrweight(5) <> 0)) Then Call PrintHisto(Alphabet5(), 0)
233.         If ((Len(TheStringIn) >= 6) And (arrweight(6) <> 0)) Then Call PrintHisto(Alphabet6(), 0)
234.         If ((Len(TheStringIn) >= 7) And (arrweight(7) <> 0)) Then Call PrintHisto(Alphabet7(), 0)
235.         If ((Len(TheStringIn) >= 8) And (arrweight(8) <> 0)) Then Call PrintHisto(Alphabet8(), 0)
236.         If ((Len(TheStringIn) >= 9) And (arrweight(9) <> 0)) Then Call PrintHisto(Alphabet9(), 0)
237.         If ((Len(TheStringIn) >= 10) And (arrweight(10) <> 0)) Then Call PrintHisto(Alphabet10(), 0)
238.         If ((Len(TheStringIn) >= 11) And (arrweight(11) <> 0)) Then Call PrintHisto(Alphabet11(), 0)
239.         If ((Len(TheStringIn) >= 12) And (arrweight(12) <> 0)) Then Call PrintHisto(Alphabet12(), 0)
240.         If ((Len(TheStringIn) >= 13) And (arrweight(13) <> 0)) Then Call PrintHisto(Alphabet13(), 0)
241.         Print
242.     End If
243.  
244.     If ((Len(TheStringIn) >= 1) And (arrweight(1) <> 0)) Then Call MakeGuess(TheStringIn, Alphabet1(), 1, Partialguess(), 0) ' Set the last argument =1 to print guess for that histogram.
245.     If ((Len(TheStringIn) >= 2) And (arrweight(2) <> 0)) Then Call MakeGuess(TheStringIn, Alphabet2(), 2, Partialguess(), pswitch)
246.     If ((Len(TheStringIn) >= 3) And (arrweight(3) <> 0)) Then Call MakeGuess(TheStringIn, Alphabet3(), 3, Partialguess(), pswitch)
247.     If ((Len(TheStringIn) >= 4) And (arrweight(4) <> 0)) Then Call MakeGuess(TheStringIn, Alphabet4(), 4, Partialguess(), 0)
248.     If ((Len(TheStringIn) >= 5) And (arrweight(5) <> 0)) Then Call MakeGuess(TheStringIn, Alphabet5(), 5, Partialguess(), 0)
249.     If ((Len(TheStringIn) >= 6) And (arrweight(6) <> 0)) Then Call MakeGuess(TheStringIn, Alphabet6(), 6, Partialguess(), 0)
250.     If ((Len(TheStringIn) >= 7) And (arrweight(7) <> 0)) Then Call MakeGuess(TheStringIn, Alphabet7(), 7, Partialguess(), 0)
251.     If ((Len(TheStringIn) >= 8) And (arrweight(8) <> 0)) Then Call MakeGuess(TheStringIn, Alphabet8(), 8, Partialguess(), 0)
252.     If ((Len(TheStringIn) >= 9) And (arrweight(9) <> 0)) Then Call MakeGuess(TheStringIn, Alphabet9(), 9, Partialguess(), 0)
253.     If ((Len(TheStringIn) >= 10) And (arrweight(10) <> 0)) Then Call MakeGuess(TheStringIn, Alphabet10(), 10, Partialguess(), 0)
254.     If ((Len(TheStringIn) >= 11) And (arrweight(11) <> 0)) Then Call MakeGuess(TheStringIn, Alphabet11(), 11, Partialguess(), 0)
255.     If ((Len(TheStringIn) >= 12) And (arrweight(12) <> 0)) Then Call MakeGuess(TheStringIn, Alphabet12(), 12, Partialguess(), 0)
256.     If ((Len(TheStringIn) >= 13) And (arrweight(13) <> 0)) Then Call MakeGuess(TheStringIn, Alphabet13(), 13, Partialguess(), 0)
257.     If (pswitch = 1) Then Print
258.  
259.     If (pswitch = 1) Then
260.         Print "Thinking:";
261.         For k = LBound(Partialguess) To UBound(Partialguess)
262.             If (Partialguess(k, 1) <> -999) Then
263.                 Print Partialguess(k, 1);
264.             Else
265.                 Print "_ ";
266.             End If
267.         Next
268.         Print
269.     End If
270.  
271.     j = 0
272.     r = 0
273.  
274.     For k = UBound(Partialguess) To LBound(Partialguess) Step -1
275.         If (Partialguess(k, 1) <> -999) Then
276.             ' weighted average:
277.             r = r + arrweight(k) * Partialguess(k, 1)
278.             j = j + arrweight(k)
279.         End If
280.     Next
281.     If (j <> 0) Then
282.         r = r / j
283.     End If
284.  
285.     If (pswitch = 1) Then Print "Predicting:  "; _Trim$(Str$(r))
286.  
287.     If (r > .5) Then
288.         r = 1
289.     Else
290.         r = 0
291.     End If
292.  
293.     If (pswitch = 1) Then
294.         Print "Rounding to: "; _Trim$(Str$(r))
295.     End If
296.  
297.     If (pswitch = 1) Then
298.         For n = 1 To _Width
299.             Print "-";
300.         Next
301.         Print: Print
302.     End If
303.  
304.     TheReturn = r
305.     Analyze = TheReturn
306. End Function
307.  
308. Sub MakeGuess (TheStringIn As String, arralpha() As LetterBin, wid As Integer, arrbeta() As Double, pswitch As Integer)
309.     Dim TheReturn As Double
310.     Dim As Integer j, k, n
311.     TheReturn = 0
312.     j = 1
313.     k = 0
314.     For n = 1 To UBound(arralpha)
315.         If (Left$(arralpha(n).Signature, wid - 1) = Right$(TheStringIn, wid - 1)) Then
316.             If (arralpha(n).Count >= j) Then
317.                 If (pswitch = 1) Then Print "Order-"; Right$("0" + _Trim$(Str$(wid)), 2); " guess: "; arralpha(n).Signature; " . "; _Trim$(Str$(arralpha(n).Count))
318.                 TheReturn = TheReturn + Val(Right$(arralpha(n).Signature, 1))
319.                 k = k + 1
320.                 j = arralpha(n).Count
321.             End If
322.         End If
323.     Next
324.     If (k <> 0) Then
325.         TheReturn = TheReturn / k
326.     Else
327.         TheReturn = .5
328.     End If
329.     arrbeta(wid, 1) = TheReturn
330.     arrbeta(wid, 2) = j
331. End Sub
332.  
333. Sub CreateHisto (arrfinger() As String, arralpha() As LetterBin, w As Integer)
334.     Dim As Integer j, k, n
335.     For n = 1 To UBound(arralpha)
336.         arralpha(n).Count = 0
337.     Next
338.     'For j = 1 To w
339.     j = 1
340.     For k = 1 To Len(arrfinger(j)) - (Len(arrfinger(j)) Mod w) Step w
341.         For n = 1 To UBound(arralpha)
342.             If (Mid$(arrfinger(j), k, w) = arralpha(n).Signature) Then
343.                 arralpha(n).Count = arralpha(n).Count + 1
344.             End If
345.         Next
346.     Next
347.     'Next
348.     Call QuickSort(arralpha(), 1, UBound(arralpha))
349. End Sub
350.  
351. Sub PrintHisto (arr() As LetterBin, w As Integer)
352.     Dim As Integer j, n
353.     If (w > 0) Then
354.         If (w > UBound(arr)) Then
355.             j = UBound(arr)
356.         Else
357.             j = w
358.         End If
359.         Print "Histogram: "; _Trim$(Str$(UBound(arr))); "-letter regroup, showing top "; _Trim$(Str$(w))
360.         For n = 1 To j
361.             Print arr(n).Signature; arr(n).Count
362.         Next
363.     End If
364. End Sub
365.  
366. Sub PrintGraph (TheString As String, arrgrade() As Double)
367.     Dim As Integer j, k
368.     Dim As Double f, g, h
369.     For k = 1 To _Width
370.         Locate _Height - 5, k: Print "_"
371.         Locate _Height - 5 - 10, k: Print "_"
372.     Next
373.     Locate _Height - 5 + 1, 1: Print "0%"
374.     Locate _Height - 5 - 10 - 1, 1: Print "100%"
375.     f = _Width / Len(TheString)
376.     If (f > 1) Then f = 1
377.     For j = 1 To Len(TheString)
378.         h = j * f
379.         If (h < 1) Then h = h + 1
380.         g = arrgrade(j, 1)
381.         Locate _Height - 5 - Int(10 * g), Int(h)
382.         If (arrgrade(j, 2) = 1) Then
383.             Print Chr$(251)
384.         Else
385.             Print "x"
386.         End If
387.     Next
388. End Sub
389.  
390. Sub NewAlphabet (arrold() As LetterBin, arrnew() As LetterBin)
391.     Dim As Integer j, k, n
392.     n = 0
393.     For k = 1 To 2
394.         For j = 1 To UBound(arrold)
395.             n = n + 1
396.             arrnew(n).Signature = arrold(j).Signature
397.         Next
398.     Next
399.     For j = 1 To UBound(arrnew)
400.         If (j <= UBound(arrnew) / 2) Then
401.             arrnew(j).Signature = "0" + arrnew(j).Signature
402.         Else
403.             arrnew(j).Signature = "1" + arrnew(j).Signature
404.         End If
405.     Next
406. End Sub
407.  
408. Sub QuickSort (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
409.     Dim As Long piv
410.     If (LowLimit < HighLimit) Then
411.         piv = Partition(arr(), LowLimit, HighLimit)
412.         Call QuickSort(arr(), LowLimit, piv - 1)
413.         Call QuickSort(arr(), piv + 1, HighLimit)
414.     End If
415. End Sub
416.  
417. Function Partition (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
418.     Dim As Long i, j
419.     Dim As Double pivot, tmp
420.     pivot = arr(HighLimit).Count
421.     i = LowLimit - 1
422.     For j = LowLimit To HighLimit - 1
423.         tmp = arr(j).Count - pivot
424.         If (tmp >= 0) Then
425.             i = i + 1
426.             Swap arr(i), arr(j)
427.         End If
428.     Next
429.     Swap arr(i + 1), arr(HighLimit)
430.     Partition = i + 1
431. End Function
432.  
433. 'Function Pathological$ (TheSeed As String, TheLength As Integer)
434. '    Dim TheReturn As String
435. '    TheReturn = TheSeed
436. '    Dim p
437. '    Do
438. '        Cls
439. '        Locate 1, 1
440. '        Print TheReturn;
441. '        p = Analyze(TheReturn, 0)
442. '        If (p = 1) Then
443. '            TheReturn = TheReturn + "0"
444. '        Else
445. '            TheReturn = TheReturn + "1"
446. '        End If
447. '    Loop Until Len(TheReturn) = TheLength
448. '    Pathological$ = TheReturn
449. 'End Function
450.  
451. Function LoadTestData (alwayszero As Integer)
452.     Dim n As Integer
453.     n = alwayszero
454.  
455.     '''
456.     ' Percussive cases:
457.     '''
458.     n = n + 1: TestData(n) = "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
459.     n = n + 1: TestData(n) = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
460.     n = n + 1: TestData(n) = "0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101"
461.     n = n + 1: TestData(n) = "1010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010"
462.     n = n + 1: TestData(n) = "0001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011"
463.     n = n + 1: TestData(n) = "0100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111"
464.  
465.     '''
466.     ' Human samples:
467.     '''
468.     ' (from Keybone)
469.     n = n + 1: TestData(n) = "101010101010101010101001010101010101001010111001010101010101010101010100010101010101010100101001010101001100101010001010100101010100101010100101010101010101010011011110010101010100100101010110010011001010011001010100010100101010010101010101010010101010101010010101001010101010100110010101010100101010101010011001001010100101010010101010100101010010101001010100101001010010101010111010100110011001010101010100110101001010101010100101001010111010101010101010100101001010101010010101010101001010101001010101001010100101010100101010010101010101001010101001010101010101001010101001010100101010101010010101010010010101010101010101010010100101010101001010100101001010101001111101010101010100101010110011001010101010101010110101010101101010101010100101010010101010010101010101101110010101001010101010110010100101010101001011010101010100110101010100101010010101010100101010101001010101010101001010101010011010101010101110110100101010111010101011011001011001010101001010101010101010101010011001010101010100101010101010101010010100101"
470.     ' (from Keybone)
471.     n = n + 1: TestData(n) = "0101110101100011010100101011001110001011001010001110101111010100111011100100101001010011110101101000101010001010101111001010111010101010100001010101000101101100101111101010010101110110111001000101000011010101010001001001001111101011101010100010110101110101100000101010101110111010100100100001110111100101011110101010001010001110010110111110110010101001001011101000101001011100011101000010101010101101010010110100101101000101111010101110111001010011101111010101000010101111100010101011110101011011110100001010110"
472.     ' (from Loudar)
473.     n = n + 1: TestData(n) = "1011001010010100100100110010101010101001010101010101011010010101001010101001010010100110101011010101010101011010101101010101010101010010110101010101100101010101010110101101011010010101010010100110101101001010110101011010010101101010110100101111010101010011011011010010110101010010110100101101010100101011010010101001010101010001011101011010010101011100111010010001101011110010011010001011100110101010010011010101001001010010000101010110001"
474.     ' (from Luke)
475.     n = n + 1: TestData(n) = "01100101001010001100001101101111011010010101010110110101001000001111001111110101000101111011010101111101010101101010101001010101011000010101010101001011010100110100110100110011010101010101110101010111111101011010100000001101111000010111000110111001000010100001101010110100000111101011111100001011001010110010110"
476.     ' (from Sarafromct)
477.     n = n + 1: TestData(n) = "10101010101011101000011101010111010101010101100111001010100111100001011011110101000001111010101101010000001111110011111110111101110111001110110010000100010101010101010100101011010110101010101010101001000000001111110000011110101010101010100010101110101010101101111111111111111111101010101010101000000"
478.     ' (from Spriggs)
479.     n = n + 1: TestData(n) = "10111010101010101010101001010101010101001010101001010101010101010101010101010101010101010101010101010101001010100100100101010101010101001010100101010101010100101010100101010101010101010101001010010110010101010010101010101010101010101010100101001001001010101010101010101010101001010101001001101010010"
480.     ' (from Spriggs)
481.     n = n + 1: TestData(n) = "11111011110100101011111111110100000011011110101100111100111111110111101110100111100110011111110101111111010111101111100111110111111111111011100111110111111110010000101011111001110101101010110111110"
482.     ' (from Hotpants)
483.     n = n + 1: TestData(n) = "01010100011001010010101010101010101000110101010111101010100100011010101010100100101110010010010100001010101001010101010110010001001011000100100110101001001001010000000001010101101111101001010100010101001001010101000100101001100100010011010101010101010111010010101011101011011010110100100010010100100100010010001001"
484.  
485.     LoadTestData = n
486. End Function
487.  

[STxAxTIC]

Hey again R1,

I decided to just try oooooone more idea with this thing, and as fate would have it, that was like a dozen ideas ago. Before I get too crazy far ahead, I wanted to let you know that this program's prediction algo is now able to tune itself without any human intervention. That is to say, it does a kind of machine learning. Gulp. There goes another weekend probably... It seems to be doing very well so far - it's already found a better model than what the Inform game uses. (These updates are coming in hot.)

Just some review so we're on the same page. For a sequence S, the program looks at patterns in fixed width chunks 1,2,3,4...,7,8,9,10. That's why there are 10 alphabets, etc. etc. Alright, so this means the algorithm can come up with 10 different guesses g(n) for the result, one for each chunk size / library. The most general way to combine those looks like:

Prediction(s) = N * (w(1)*g(1) + w(2)*g(2) + w(3)*g(3) + ... + w(10)*g(10))

Where the function w(n) is the weight function we've been talking about. My old h-variable. So far so good?

Up til today, two such w(n)-models have been deployed:
(i) For our heavy testing, I let w(n) = n^2, so high-alphabet guesses matter more than lower ones.
(ii) All w(n)=0 except w(5)=1. Believe it or not, this is really good at predicting humans and there isn't any science behind it.

The website is solely about #1. InForm demo uses #2.

So what's new? Here we go.....

I wanted to think up a general-enough scheme for the weight function w(n) that covers most of "weight space", which is to say - I want a way to systematically guess at these weights. The model that's in play right now is as follows:

(i) Each w(n) is either a 0 or a 1. Either that guess counts, or it doesn't. No further weighting beyond that for now.
(ii) Lining up each w(n) in a row, this might, for instance look like 0100111010. (This means w(1)=0, w(2)=1, w(3)=0, etc.)
(iii) Observe that 0100111010 is itself a binary number. The lowest of these has all 0's: 0000000000. The highest has ten 1's: 1111111111
(iv) Thus, we can cycle through every single binary model by counting from 0000000000 to 1111111111 in binary.
(v) With that realized, test the program on a standardized piece of data and collect statistics on each model. The best model will stand out.

If you follow all that, you're caught up to what my code is doing right now. At the moment I've got it training on just a single sequence, and that's the one provided by Luke. Turns out the AI has already found a model better than the one I was using and the program's not even finished running yet. I know it's early, so results may vary.

Either way. here's what's going on:

Code: QB64: [Select]

1. Option _Explicit
2.  
3. Screen _NewImage(120, 40)
4.  
5. ' Version: 20
6.  
7. Type LetterBin
8.     Signature As String
9.     Count As Integer
10. End Type
11.  
12. Dim Shared Alphabet1(2) As LetterBin ' 0 1
13. Dim Shared Alphabet2(4) As LetterBin ' 00 01 10 11
14. Dim Shared Alphabet3(8) As LetterBin ' 000 001 010 011 100 101 110 111
15. Dim Shared Alphabet4(16) As LetterBin ' etc.
16. Dim Shared Alphabet5(32) As LetterBin
17. Dim Shared Alphabet6(64) As LetterBin
18. Dim Shared Alphabet7(128) As LetterBin
19. Dim Shared Alphabet8(256) As LetterBin
20. Dim Shared Alphabet9(512) As LetterBin
21. Dim Shared Alphabet10(1024) As LetterBin
22. Dim Shared Alphabet11(2048) As LetterBin
23. Dim Shared Alphabet12(4096) As LetterBin
24. Dim Shared Alphabet13(8192) As LetterBin
25.  
26. Alphabet1(1).Signature = "0"
27. Alphabet1(2).Signature = "1"
28. Call NewAlphabet(Alphabet1(), Alphabet2())
29. Call NewAlphabet(Alphabet2(), Alphabet3())
30. Call NewAlphabet(Alphabet3(), Alphabet4())
31. Call NewAlphabet(Alphabet4(), Alphabet5())
32. Call NewAlphabet(Alphabet5(), Alphabet6())
33. Call NewAlphabet(Alphabet6(), Alphabet7())
34. Call NewAlphabet(Alphabet7(), Alphabet8())
35. Call NewAlphabet(Alphabet8(), Alphabet9())
36. Call NewAlphabet(Alphabet9(), Alphabet10())
37. Call NewAlphabet(Alphabet10(), Alphabet11())
38. Call NewAlphabet(Alphabet11(), Alphabet12())
39. Call NewAlphabet(Alphabet12(), Alphabet13())
40.  
41. ' Load test data.
42. ReDim Shared TestData(10000) As String
43. ReDim _Preserve TestData(LoadTestData(0))
44.  
45. ' This is the made-up part of the model.
46. Dim Shared AlphaWeight(1 To 13) As Double
47.  
48. ' Statistics and metrics:
49. Dim GuessPredicted As Integer
50. Dim GuessCorrect As Double
51. Dim GuessTotal As Double
52. Dim GuessRatioMax As Double
53. Dim GuessStreak As Integer
54. Dim GuessStreakMax As Integer
55. Dim Grade(10000, 2) As Double
56.  
57. Dim TheString As String
58. Dim As Integer k, m, n
59.  
60. GuessRatioMax = 0
61.  
62. Dim BinaryModelCounter As Integer
63. Dim BinaryModelBest As Integer
64. BinaryModelCounter = 0
65.  
66. Do While (BinaryModelCounter < 1024)
67.     Call InitializeBinaryModel(BinaryModelCounter)
68.     BinaryModelCounter = BinaryModelCounter + 1
69.  
70.     '''
71.     ' Bypass pre-cooked test data.
72.     TestData(1) = "01100101001010001100001101101111011010010101010110110101001000001111001111110101000101111011010101111101010101101010101001010101011000010101010101001011010100110100110100110011010101010101110101010111111101011010100000001101111000010111000110111001000010100001101010110100000111101011111100001011001010110010110"
73.     ReDim _Preserve TestData(1)
74.     '''
75.  
76.     For m = 1 To UBound(TestData)
77.  
78.         GuessPredicted = -1
79.         GuessCorrect = 0
80.         GuessTotal = 0
81.         GuessStreak = 0
82.         GuessStreakMax = 0
83.  
84.         For n = 1 To Len(TestData(m)) '9999
85.  
86.             '''
87.             ' Research Mode
88.             TheString = Left$(TestData(m), n)
89.             '''
90.  
91.             '''
92.             '' Gaming Mode
93.             'Cls
94.             'Locate 1, 1
95.             'Print "Press LEFT or RIGHT."
96.             'k = 0
97.             'Do: k = _KeyHit: Loop Until ((k = 19200) Or (k = 19712))
98.             'Select Case k
99.             '    Case 19200
100.             '        TheString = TheString + "0"
101.             '    Case 19712
102.             '        TheString = TheString + "1"
103.             'End Select
104.             '_KeyClear
105.             '''
106.  
107.             Cls
108.             Color 7
109.             Locate 1, 1
110.             For k = 1 To _Width
111.                 Print "_";
112.             Next
113.             Print "Model:";
114.             For k = 1 To 10 'UBound(AlphaWeight)
115.                 Print AlphaWeight(k);
116.             Next
117.             Print
118.             Print
119.             Print "Sequence (length "; _Trim$(Str$(Len(TheString))); "):"
120.             Print TheString ';
121.             Color 8
122.             'Print Right$(TestData(m), Len(TestData(m)) - n)
123.             Color 7
124.  
125.             ' Reconciliation
126.             If (GuessPredicted <> -1) Then
127.                 Print
128.                 Print "I predicted "; _Trim$(Str$(GuessPredicted)); " and you typed "; Right$(TheString, 1); "."
129.                 If (GuessPredicted = Val(Right$(TheString, 1))) Then
130.                     Print "I am RIGHT this round."
131.                     GuessCorrect = GuessCorrect + 1
132.                     GuessStreak = GuessStreak + 1
133.                     If (GuessStreak > GuessStreakMax) Then GuessStreakMax = GuessStreak
134.                     Grade(n, 2) = 1
135.                 Else
136.                     Print "I am WRONG this round."
137.                     GuessStreak = 0
138.                     Grade(n, 2) = 0
139.                 End If
140.                 GuessTotal = GuessTotal + 1
141.                 Grade(n, 1) = GuessCorrect / GuessTotal
142.             End If
143.  
144.             If (GuessTotal > 0) Then
145.                 Print
146.                 Print "I'm on a "; _Trim$(Str$(GuessStreak)); "-round winning streak."
147.                 Print "My best streak has been "; _Trim$(Str$(GuessStreakMax)); "."
148.                 If (GuessTotal <> 0) Then
149.                     Print "My correctness rate is "; _Trim$(Str$(Int(100 * GuessCorrect / GuessTotal))); "% in "; _Trim$(Str$(GuessTotal)); " guesses."
150.                 End If
151.             End If
152.  
153.             GuessPredicted = Analyze(TheString, AlphaWeight(), 0)
154.  
155.             Print
156.             'Print "I have made a new prediction."
157.             'Print "Press LEFT or RIGHT to test me."
158.             Print "The best model was # "; _Trim$(Str$(BinaryModelBest)); ", rated "; _Trim$(Str$(Int(GuessRatioMax * 100))); "%"
159.  
160.             ' Draw bottom graph
161.             If (CsrLin <= 23) Then
162.                 If (GuessTotal <> 0) Then
163.                     Call PrintGraph(TheString, Grade())
164.                 End If
165.             End If
166.  
167.             _Display
168.             '_Delay .02
169.             _Limit 240
170.         Next
171.  
172.         If (GuessCorrect / GuessTotal > GuessRatioMax) Then
173.             BinaryModelBest = BinaryModelCounter
174.             GuessRatioMax = GuessCorrect / GuessTotal
175.         End If
176.  
177.         _Display
178.         _Delay 1
179.     Next
180. Loop
181.  
182. End
183.  
184. Sub InitializeBinaryModel (TheIndexIn As Integer)
185.     '0 to 1023
186.     Dim As Integer k
187.     Dim As String BinWeight
188.     BinWeight = BIN$(TheIndexIn)
189.     For k = 1 To 10
190.         AlphaWeight(k) = Val(Mid$(BinWeight, 10 - k + 1, 1))
191.     Next
192.     AlphaWeight(11) = 0
193.     AlphaWeight(12) = 0
194.     AlphaWeight(13) = 0
195. End Sub
196.  
197. Function BIN$ (n As Integer)
198.     Dim As Integer max, i, msb
199.     Dim As String b
200.     max% = 8 * Len(n%) ': MSB% = 1   'uncomment for 16 (32 or 64) bit returns
201.     For i = max% - 1 To 0 Step -1 'read as big-endian MSB to LSB
202.         If (n% And 2 ^ i) Then msb% = 1: b$ = b$ + "1" Else If msb% Then b$ = b$ + "0"
203.     Next
204.     b$ = "0000000000" + b$
205.     b$ = Right$(b$, 10)
206.     If b$ = "" Then BIN$ = "0" Else BIN$ = b$ 'check for empty string
207. End Function
208.  
209. Sub InitializeCustomModel
210.     Dim As Integer k
211.     For k = LBound(AlphaWeight) To UBound(AlphaWeight)
212.         AlphaWeight(k) = 0 * k ^ 2
213.     Next
214.     'AlphaWeight(1) = 0
215.     'AlphaWeight(2) = 0
216.     'AlphaWeight(3) = 0
217.     'AlphaWeight(4) = 0
218.     AlphaWeight(5) = 1
219.     'AlphaWeight(6) = 0
220.     'AlphaWeight(7) = 0
221.     'AlphaWeight(8) = 0
222.     'AlphaWeight(9) = 0
223.     'AlphaWeight(10) = 0
224.     AlphaWeight(11) = 0
225.     AlphaWeight(12) = 0
226.     AlphaWeight(13) = 0
227. End Sub
228.  
229. Function Analyze (TheStringIn As String, arrweight() As Double, pswitch As Integer)
230.     Dim TheReturn As Integer
231.     Dim As Integer n
232.     Dim As Double r, j, k
233.     Dim StringPhase(UBound(arrweight)) As String
234.     Dim Partialguess(LBound(arrweight) To UBound(arrweight), 2) As Double
235.  
236.     StringPhase(1) = TheStringIn
237.     'For n = 2 To UBound(StringPhase) ' Uncomment for phase analysis.
238.     'StringPhase(n) = Right$(StringPhase(n - 1), Len(StringPhase(n - 1)) - 1) + Left$(StringPhase(n - 1), 1)
239.     'Next
240.  
241.     ' Initialize partial results.
242.     For n = LBound(Partialguess) To UBound(Partialguess)
243.         Partialguess(n, 1) = -999
244.     Next
245.  
246.     If (pswitch = 1) Then
247.         Print
248.         For n = 1 To _Width
249.             Print "-";
250.         Next
251.         Print
252.     End If
253.  
254.     If (arrweight(1) <> 0) Then Call CreateHisto(StringPhase(), 1, Alphabet1())
255.     If (arrweight(2) <> 0) Then Call CreateHisto(StringPhase(), 2, Alphabet2())
256.     If (arrweight(3) <> 0) Then Call CreateHisto(StringPhase(), 3, Alphabet3())
257.     If (arrweight(4) <> 0) Then Call CreateHisto(StringPhase(), 4, Alphabet4())
258.     If (arrweight(5) <> 0) Then Call CreateHisto(StringPhase(), 5, Alphabet5())
259.     If (arrweight(6) <> 0) Then Call CreateHisto(StringPhase(), 6, Alphabet6())
260.     If (arrweight(7) <> 0) Then Call CreateHisto(StringPhase(), 7, Alphabet7())
261.     If (arrweight(8) <> 0) Then Call CreateHisto(StringPhase(), 8, Alphabet8())
262.     If (arrweight(9) <> 0) Then Call CreateHisto(StringPhase(), 9, Alphabet9())
263.     If (arrweight(10) <> 0) Then Call CreateHisto(StringPhase(), 10, Alphabet10())
264.     If (arrweight(11) <> 0) Then Call CreateHisto(StringPhase(), 11, Alphabet11())
265.     If (arrweight(12) <> 0) Then Call CreateHisto(StringPhase(), 12, Alphabet12())
266.     If (arrweight(13) <> 0) Then Call CreateHisto(StringPhase(), 13, Alphabet13())
267.  
268.     If (pswitch = 1) Then ' Set the last argument >=1 to print stats for that histogram.
269.         If ((Len(TheStringIn) >= 1) And (arrweight(1) <> 0)) Then Call PrintHisto(Alphabet1(), 0)
270.         If ((Len(TheStringIn) >= 2) And (arrweight(2) <> 0)) Then Call PrintHisto(Alphabet2(), 0)
271.         If ((Len(TheStringIn) >= 3) And (arrweight(3) <> 0)) Then Call PrintHisto(Alphabet3(), 0)
272.         If ((Len(TheStringIn) >= 4) And (arrweight(4) <> 0)) Then Call PrintHisto(Alphabet4(), 0)
273.         If ((Len(TheStringIn) >= 5) And (arrweight(5) <> 0)) Then Call PrintHisto(Alphabet5(), 4)
274.         If ((Len(TheStringIn) >= 6) And (arrweight(6) <> 0)) Then Call PrintHisto(Alphabet6(), 0)
275.         If ((Len(TheStringIn) >= 7) And (arrweight(7) <> 0)) Then Call PrintHisto(Alphabet7(), 0)
276.         If ((Len(TheStringIn) >= 8) And (arrweight(8) <> 0)) Then Call PrintHisto(Alphabet8(), 0)
277.         If ((Len(TheStringIn) >= 9) And (arrweight(9) <> 0)) Then Call PrintHisto(Alphabet9(), 0)
278.         If ((Len(TheStringIn) >= 10) And (arrweight(10) <> 0)) Then Call PrintHisto(Alphabet10(), 0)
279.         If ((Len(TheStringIn) >= 11) And (arrweight(11) <> 0)) Then Call PrintHisto(Alphabet11(), 0)
280.         If ((Len(TheStringIn) >= 12) And (arrweight(12) <> 0)) Then Call PrintHisto(Alphabet12(), 0)
281.         If ((Len(TheStringIn) >= 13) And (arrweight(13) <> 0)) Then Call PrintHisto(Alphabet13(), 0)
282.         Print
283.     End If
284.  
285.     If ((Len(TheStringIn) >= 1) And (arrweight(1) <> 0)) Then Call MakeGuess(TheStringIn, 1, Alphabet1(), Partialguess(), 0) ' Set the last argument =1 to print guess for that histogram.
286.     If ((Len(TheStringIn) >= 2) And (arrweight(2) <> 0)) Then Call MakeGuess(TheStringIn, 2, Alphabet2(), Partialguess(), 0)
287.     If ((Len(TheStringIn) >= 3) And (arrweight(3) <> 0)) Then Call MakeGuess(TheStringIn, 3, Alphabet3(), Partialguess(), 0)
288.     If ((Len(TheStringIn) >= 4) And (arrweight(4) <> 0)) Then Call MakeGuess(TheStringIn, 4, Alphabet4(), Partialguess(), 0)
289.     If ((Len(TheStringIn) >= 5) And (arrweight(5) <> 0)) Then Call MakeGuess(TheStringIn, 5, Alphabet5(), Partialguess(), pswitch)
290.     If ((Len(TheStringIn) >= 6) And (arrweight(6) <> 0)) Then Call MakeGuess(TheStringIn, 6, Alphabet6(), Partialguess(), 0)
291.     If ((Len(TheStringIn) >= 7) And (arrweight(7) <> 0)) Then Call MakeGuess(TheStringIn, 7, Alphabet7(), Partialguess(), 0)
292.     If ((Len(TheStringIn) >= 8) And (arrweight(8) <> 0)) Then Call MakeGuess(TheStringIn, 8, Alphabet8(), Partialguess(), 0)
293.     If ((Len(TheStringIn) >= 9) And (arrweight(9) <> 0)) Then Call MakeGuess(TheStringIn, 9, Alphabet9(), Partialguess(), 0)
294.     If ((Len(TheStringIn) >= 10) And (arrweight(10) <> 0)) Then Call MakeGuess(TheStringIn, 10, Alphabet10(), Partialguess(), 0)
295.     If ((Len(TheStringIn) >= 11) And (arrweight(11) <> 0)) Then Call MakeGuess(TheStringIn, 11, Alphabet11(), Partialguess(), 0)
296.     If ((Len(TheStringIn) >= 12) And (arrweight(12) <> 0)) Then Call MakeGuess(TheStringIn, 12, Alphabet12(), Partialguess(), 0)
297.     If ((Len(TheStringIn) >= 13) And (arrweight(13) <> 0)) Then Call MakeGuess(TheStringIn, 13, Alphabet13(), Partialguess(), 0)
298.     If (pswitch = 1) Then Print
299.  
300.     If (pswitch = 1) Then
301.         Print "Thinking:";
302.         For k = LBound(Partialguess) To UBound(Partialguess)
303.             If (Partialguess(k, 1) <> -999) Then
304.                 Print Partialguess(k, 1);
305.             Else
306.                 Print "_ ";
307.             End If
308.         Next
309.         Print
310.     End If
311.  
312.     j = 0
313.     r = 0
314.  
315.     ' Weighted average calculation
316.     For k = UBound(Partialguess) To LBound(Partialguess) Step -1
317.         If (Partialguess(k, 1) <> -999) Then
318.             r = r + arrweight(k) * Partialguess(k, 1)
319.             j = j + arrweight(k)
320.         End If
321.     Next
322.     If (j <> 0) Then
323.         r = r / j
324.     End If
325.  
326.     If (pswitch = 1) Then Print "Predicting:  "; _Trim$(Str$(r))
327.  
328.     If (r > .5) Then
329.         r = 1
330.     Else
331.         r = 0
332.     End If
333.  
334.     If (pswitch = 1) Then
335.         Print "Rounding to: "; _Trim$(Str$(r))
336.     End If
337.  
338.     If (pswitch = 1) Then
339.         For n = 1 To _Width
340.             Print "-";
341.         Next
342.         Print
343.     End If
344.  
345.     TheReturn = r
346.     Analyze = TheReturn
347. End Function
348.  
349. Sub MakeGuess (TheStringIn As String, wid As Integer, arralpha() As LetterBin, arrguess() As Double, pswitch As Integer)
350.     Dim TheReturn As Double
351.     Dim As Integer j, k, n
352.     TheReturn = 0
353.     j = 1
354.     k = 0
355.     For n = 1 To UBound(arralpha)
356.         If (Left$(arralpha(n).Signature, wid - 1) = Right$(TheStringIn, wid - 1)) Then
357.             If (arralpha(n).Count >= j) Then
358.                 If (pswitch = 1) Then Print "Order-"; Right$("0" + _Trim$(Str$(wid)), 2); " guess: "; arralpha(n).Signature; " . "; _Trim$(Str$(arralpha(n).Count))
359.                 TheReturn = TheReturn + Val(Right$(arralpha(n).Signature, 1))
360.                 k = k + 1
361.                 j = arralpha(n).Count
362.             End If
363.         End If
364.     Next
365.     If (k <> 0) Then
366.         TheReturn = TheReturn / k
367.     Else
368.         TheReturn = .5
369.     End If
370.     arrguess(wid, 1) = TheReturn
371.     arrguess(wid, 2) = j
372. End Sub
373.  
374. Sub CreateHisto (arrfinger() As String, wid As Integer, arralpha() As LetterBin)
375.     Dim As Integer j, k, n
376.     For n = 1 To UBound(arralpha)
377.         arralpha(n).Count = 0
378.     Next
379.     ' Uncomment this loop to enable phase analysis.
380.     'For j = 1 To wid
381.     j = 1
382.     For k = 1 To Len(arrfinger(j)) - (Len(arrfinger(j)) Mod wid) Step wid
383.         For n = 1 To UBound(arralpha)
384.             If (Mid$(arrfinger(j), k, wid) = arralpha(n).Signature) Then
385.                 arralpha(n).Count = arralpha(n).Count + 1
386.             End If
387.         Next
388.     Next
389.     'Next
390.     Call QuickSort(arralpha(), 1, UBound(arralpha))
391. End Sub
392.  
393. Sub PrintHisto (arr() As LetterBin, wid As Integer)
394.     Dim As Integer j, n
395.     If (wid > 0) Then
396.         If (wid > UBound(arr)) Then
397.             j = UBound(arr)
398.         Else
399.             j = wid
400.         End If
401.         Print "Histogram: "; _Trim$(Str$(UBound(arr))); "-letter regroup, showing top "; _Trim$(Str$(wid))
402.         For n = 1 To j
403.             Print arr(n).Signature; arr(n).Count
404.         Next
405.     End If
406. End Sub
407.  
408. Sub PrintGraph (TheString As String, arrgrade() As Double)
409.     Dim As Integer j, k
410.     Dim As Double f, g
411.     For k = 1 To _Width
412.         Locate _Height - 5, k: Print "_"
413.         Locate _Height - 5 - 10, k: Print "_"
414.     Next
415.     Locate _Height - 5 + 1, 1: Print "0%"
416.     Locate _Height - 5 - 10 - 1, 1: Print "100%"
417.     f = (_Width) / Len(TheString)
418.     If (f > 1) Then f = 1
419.     For j = 2 To Len(TheString)
420.         g = Int(j * f)
421.         If (g = 0) Then g = 1
422.         Locate _Height - 5 - Int(10 * arrgrade(j, 1)), g
423.         If (arrgrade(j, 2) = 1) Then
424.             Print Chr$(251)
425.         Else
426.             Print "x"
427.         End If
428.     Next
429. End Sub
430.  
431. Sub NewAlphabet (arrold() As LetterBin, arrnew() As LetterBin)
432.     Dim As Integer j, k, n
433.     n = 0
434.     For k = 1 To 2
435.         For j = 1 To UBound(arrold)
436.             n = n + 1
437.             arrnew(n).Signature = arrold(j).Signature
438.         Next
439.     Next
440.     For j = 1 To UBound(arrnew)
441.         If (j <= UBound(arrnew) / 2) Then
442.             arrnew(j).Signature = "0" + arrnew(j).Signature
443.         Else
444.             arrnew(j).Signature = "1" + arrnew(j).Signature
445.         End If
446.     Next
447. End Sub
448.  
449. Sub QuickSort (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
450.     Dim As Long piv
451.     If (LowLimit < HighLimit) Then
452.         piv = Partition(arr(), LowLimit, HighLimit)
453.         Call QuickSort(arr(), LowLimit, piv - 1)
454.         Call QuickSort(arr(), piv + 1, HighLimit)
455.     End If
456. End Sub
457.  
458. Function Partition (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
459.     Dim As Long i, j
460.     Dim As Double pivot, tmp
461.     pivot = arr(HighLimit).Count
462.     i = LowLimit - 1
463.     For j = LowLimit To HighLimit - 1
464.         tmp = arr(j).Count - pivot
465.         If (tmp >= 0) Then
466.             i = i + 1
467.             Swap arr(i), arr(j)
468.         End If
469.     Next
470.     Swap arr(i + 1), arr(HighLimit)
471.     Partition = i + 1
472. End Function
473.  
474. 'Function Pathological$ (TheSeed As String, TheLength As Integer)
475. '    Dim TheReturn As String
476. '    TheReturn = TheSeed
477. '    Dim p
478. '    Do
479. '        Cls
480. '        Locate 1, 1
481. '        Print TheReturn;
482. '        p = Analyze(TheReturn, 0)
483. '        If (p = 1) Then
484. '            TheReturn = TheReturn + "0"
485. '        Else
486. '            TheReturn = TheReturn + "1"
487. '        End If
488. '    Loop Until Len(TheReturn) = TheLength
489. '    Pathological$ = TheReturn
490. 'End Function
491.  
492. Function LoadTestData (alwayszero As Integer)
493.     Dim n As Integer
494.     n = alwayszero
495.  
496.     '''
497.     ' Percussive cases:
498.     '''
499.     n = n + 1: TestData(n) = "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
500.     n = n + 1: TestData(n) = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
501.     n = n + 1: TestData(n) = "0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101"
502.     n = n + 1: TestData(n) = "1010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010"
503.     n = n + 1: TestData(n) = "0001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011"
504.     n = n + 1: TestData(n) = "0100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111"
505.  
506.     '''
507.     ' Human samples:
508.     '''
509.     ' (from Keybone)
510.     n = n + 1: TestData(n) = "101010101010101010101001010101010101001010111001010101010101010101010100010101010101010100101001010101001100101010001010100101010100101010100101010101010101010011011110010101010100100101010110010011001010011001010100010100101010010101010101010010101010101010010101001010101010100110010101010100101010101010011001001010100101010010101010100101010010101001010100101001010010101010111010100110011001010101010100110101001010101010100101001010111010101010101010100101001010101010010101010101001010101001010101001010100101010100101010010101010101001010101001010101010101001010101001010100101010101010010101010010010101010101010101010010100101010101001010100101001010101001111101010101010100101010110011001010101010101010110101010101101010101010100101010010101010010101010101101110010101001010101010110010100101010101001011010101010100110101010100101010010101010100101010101001010101010101001010101010011010101010101110110100101010111010101011011001011001010101001010101010101010101010011001010101010100101010101010101010010100101"
511.     ' (from Keybone)
512.     n = n + 1: TestData(n) = "0101110101100011010100101011001110001011001010001110101111010100111011100100101001010011110101101000101010001010101111001010111010101010100001010101000101101100101111101010010101110110111001000101000011010101010001001001001111101011101010100010110101110101100000101010101110111010100100100001110111100101011110101010001010001110010110111110110010101001001011101000101001011100011101000010101010101101010010110100101101000101111010101110111001010011101111010101000010101111100010101011110101011011110100001010110"
513.     ' (from Loudar)
514.     n = n + 1: TestData(n) = "1011001010010100100100110010101010101001010101010101011010010101001010101001010010100110101011010101010101011010101101010101010101010010110101010101100101010101010110101101011010010101010010100110101101001010110101011010010101101010110100101111010101010011011011010010110101010010110100101101010100101011010010101001010101010001011101011010010101011100111010010001101011110010011010001011100110101010010011010101001001010010000101010110001"
515.     ' (from Luke)
516.     n = n + 1: TestData(n) = "01100101001010001100001101101111011010010101010110110101001000001111001111110101000101111011010101111101010101101010101001010101011000010101010101001011010100110100110100110011010101010101110101010111111101011010100000001101111000010111000110111001000010100001101010110100000111101011111100001011001010110010110"
517.     ' (from Sarafromct)
518.     n = n + 1: TestData(n) = "10101010101011101000011101010111010101010101100111001010100111100001011011110101000001111010101101010000001111110011111110111101110111001110110010000100010101010101010100101011010110101010101010101001000000001111110000011110101010101010100010101110101010101101111111111111111111101010101010101000000"
519.     ' (from Spriggs)
520.     n = n + 1: TestData(n) = "10111010101010101010101001010101010101001010101001010101010101010101010101010101010101010101010101010101001010100100100101010101010101001010100101010101010100101010100101010101010101010101001010010110010101010010101010101010101010101010100101001001001010101010101010101010101001010101001001101010010"
521.     ' (from Spriggs)
522.     n = n + 1: TestData(n) = "11111011110100101011111111110100000011011110101100111100111111110111101110100111100110011111110101111111010111101111100111110111111111111011100111110111111110010000101011111001110101101010110111110"
523.     ' (from Hotpants)
524.     n = n + 1: TestData(n) = "01010100011001010010101010101010101000110101010111101010100100011010101010100100101110010010010100001010101001010101010110010001001011000100100110101001001001010000000001010101101111101001010100010101001001010101000100101001100100010011010101010101010111010010101011101011011010110100100010010100100100010010001001"
525.  
526.     LoadTestData = n
527. End Function
528.  

[random1]

STxAxTIC

Very nice work.  One thing that really caught my attention was ranking the strings as to their
level of randomness.

I have two models I am currently working on.  The one I am interested in most is based on a
different type of data although the strings look very similar to those discussed so far. The idea
for this predictor is to first find the strings that show a high probability of being predictable and
process only those strings.  Second is to only take the (1) predictions.  If the prediction is 0 or ?
then toss it out.

This tool only processes 100 to 112 total strings and out of those I need the top 15 predicted 1's.
The more I study the linked information the more convinced I am that it may be possible.
       
Thanks again, again, this must be very time consuming on your end.  I will say that I am having
fun and learning at the same time.  Not many people would go to such extent, it is appreciated. 

R1   

[random1]

Here is a older predictor that I rewrote for this topic.  This works a little similar to the
one STxAxTIC has posted.  This tool has no brains so to say and should be easy to
understand.  I attached a picture that shows the results and a second file which contains
the data string file.  You will notice some of the strings are all *****.  These are events
that are no longer collected but left in place to maintain the data structure.  These are
skipped by the dummy predictor.  Anyone willing can try to improve the overall hit rate
is very welcome.  I am most interested in bringing up the number of correct (1's) made
by the predictor.  The data file needs to be in the same directory as the program or one
could edit the code and add a full path to the open statement. 

Anyway, maybe some brains can be added to make it better.  This is the second of two
predictors I am working on.  The other is the one STxAxTIC posted.  My code is most likely
outdated, but I am old and set in my ways.

Code: QB64: [Select]

1. Title1$ = "Predictor"
2. _Title Title1$
3. A& = _NewImage(400,200,32)
4. SCREEN A&
5. _SCREENMOVE _Middle
6.  
7. Dim PreDiction (1 to 112) as String
8. Dim StrLen as Double
9. Dim Match as Double
10. Dim Count as Double
11. Dim Hit0 as Double
12. Dim Hit1 as Double
13. Dim Dud as Double
14. PrintOn=1  '<- PrintSwitch
15. StrLen=0  '0 = Use entire string
16. Color _RGB32(255,255,0),_RGB32(0,0,0)
17.  
18. 'String feed from file
19. Count=0:Match=0:Dud=0
20. Open "tmp.txt" For Input as #1
21. Do While Not Eof(1)
22. Line Input #1, Dat1$
23. Dat1$=_trim$(Dat1$)
24. If StrLen > 0 Then Dat1$=Mid$(Dat1$,1,StrLen)  '<- Control Panel Setting to control length of String
25. Count=Count+1
26. Goto GotString
27. ReTurn1:
28. Loop
29. Close
30.  
31. 'Print & exit code
32. If PrintOn = 1 Then _printString (4,84), "Correct Predictions = " + _Trim$(Str$(Match))
33. If PrintOn = 1 Then _PrintString (4,100), "Predictor Hit Rate = " + Mid$(_Trim$(Str$(Match/(112-Dud))),1,4) + "% of " + _Trim$(Str$(112-Dud))
34. If PrintOn = 1 Then _PrintString (4,116), "Strings Not Processed = " + _Trim$(Str$(Dud))
35. If PrintOn = 1 Then _PrintString (4,132), "Finished....."
36. Color _RGB32(192,192,192),_RGB32(0,0,0)
37. _PrintString (4,180), "Press any key to exit"
38. Do While Right$(Inkey$,1)="":Loop
39. system
40.  
41. GotString:
42. If Instr(Dat1$,"*") > 0 Then Dud=Dud+1
43. If Instr(Dat1$,"*") > 0 Then Goto SkipString 'Skips invalid strings
44. If PrintOn = 1 Then _PrintString (4, 2), "Analyzing String " + _Trim$(Str$(Count)) + " of 112"
45. If PrintOn = 1 Then _PrintString (4,20), "Partial String = " + Mid$(Dat1$,1,30)
46.  
47. 'Dummy Prediction code Start's here
48.  
49. Cyc=4  '<-Control Panel Adjustable
50. H0=0:H1=0
51. NextCyc:
52.  
53. Pat0$="0"+Mid$(Dat1$,2,Cyc)
54. Pat1$="1"+Mid$(Dat1$,2,Cyc)
55.  
56. L1=1
57.   Do While L1 <= Len(Dat1$)-Len(Pat0$)
58.       If Mid$(Dat1$,L1,Len(Pat0$)) = Pat0$ Then H0=H0+1
59.       If Mid$(Dat1$,L1,Len(Pat1$)) = Pat1$ Then H1=H1+1
60.      L1=L1+1
61.   Loop
62. Cyc=Cyc+1
63. If Cyc <= 6 Then Goto NextCyc 'Control Panel adjustable
64.  
65. 'Dummy Prediction
66. If H1 >= H0 Then PreDiction(Count)="1" Else PreDiction(Count)="0"
67.  
68. 'Counts and print stuff
69. If PreDiction(Count) = Mid$(Dat1$,1,1) Then Match=Match+1
70. If PrintOn = 1 then _PrintString (4,36), "Prediction = " + PreDiction(Count) + " "
71. If Mid$(Dat1$,1,1) = PreDiction(Count) And Mid$(Dat1$,1,1) ="0" Then Hit0=Hit0+1
72. If Mid$(Dat1$,1,1) = PreDiction(Count) And Mid$(Dat1$,1,1) ="1" Then Hit1=Hit1+1
73. If PrintOn = 1 then _PrintString (4,52), "P-Match->(0) = " + _Trim$(Str$(Hit0))
74. If PrintOn = 1 then _PrintString (4,68), "P-Match->(1) = " + _Trim$(Str$(Hit1))
75. _Delay .3
76. SkipString:
77. Goto ReTurn1 'get next string
78.  

R1

[STxAxTIC]

Hey r1,

Funny story about tonight - 'cause time felt about right - I was about to try to collect a few recent thoughts on this whole thing and make a new reply, but got sidetracked, only to refresh the forum and see you had the same idea but didn't get sidetracked - you managed to make a coherent post, unlike myself. Later on I'll split my brain and see what's going on inside your predictor, but first I wanted to give an update on what my code is up to. The code itself is pretty stable, but the way I now use it needs to be looked at.

Just some points for review:
(i) Predictions (as an unrounded decimal) are P = N (w(1)*g(1) + w(2)g(2) + ... + w(10)g(10))
(ii) N is a normalization constant
(iii) g(n) is the guess for alphabet size n
(iv) w(n) is the weight of that guess, a 0 or a 1

That stuff must be a thousand percent clear to proceed with me properly. When I say I  "use a model", or "choose a model", all that means is to choose w(n) for each n=1,2,...,10. For a stupid example, setting all w(n)=0 just makes every prediction 0. For another example, setting all w(n)=1 gives equal weight to all n guesses that contribute to the final prediction. Turning on or off various w(n) like light switches gives a different model.

Alright, so lately I've been cycling through all possible w(n) and testing on many kinds of input sequences, and am finding - rather verifying - a few results that I always had a hunch about. This is motivated by noticing that, for some reason, inputs made by human beings are very strong in the w(5)-range, but altogether absent in higher ranges. It's as if the random number generator inside a human is great at sputtering out chunks of 5 or even 7, but not flurries of 8 or 12. Kinda amazing. Certain contrived inputs, like regular patterns, complex patterns, drum beats, etc... are all resonant in various w(n) that make sense when you look at them, these are usually nice and low w(n) as well.

So let me do an example. Working with *only* the first string in the file you attached, namely:

Code: [Select]

S = 11000110100100010010000101001001000000000100010000001000011000000001010000000010010000000110011110000001110101100000001100000000000010100000100100111100001000011111100000010000100100000000001110000001100010000000000100000110000000000100000000010000110000100001000000000000001000110000011111111111111001110000011000001100000001101001000110001110000000010000001111000000000100000001110001001000000010010001001000000001000000000000000000110000010000001000001000010001000001000010111000000001100011100100000000100011000000000001100010000010000100000000000000001000000001010001100000001101000000000100000000000001000000000001110010001110010011001000000101000000110000000000001000000000101000110000000000000000001100000000000000
(I)
Let me use the model with w(1)=1, w(2)=1, etc, ... all w(n)=1. The perfectly averaged model, every frequency gets the same weight. Running this, I get a result of: 74%. Not bad! This mode always does a pretty good job.

(II)
To repeat the past, I can also use the w(n)=n^2 model. Remember that ole thing? This one gives an answer of: 69%. Yuck. Glad we updated the model since the n^2 days.

(III)
Okay, so can we do better than stab around randomly for a model? Yes. By systematically searching, I found the best results in the 533rd model (there may be a better one after 533 but I stopped the program there). Converting 533 to binary, this means the model is: w(1)=1, w(2)=0, w(3)=1, w(4)=0, w(5)=1, w(6)=0, w(7)=0, w(8)=0, w(9)=0, w(10)=1. Okay, so choosing this model 1010100001 and checking the result, we find a success rate of 76%, the highest yet!

So clearly it's worth stepping around in "weight space" for the best model for a given sequence. Humans have their own signature like 000010000. Simple "music" has its own, typically something like 0110000000. Whatever you used to come up with that first string in TMP.txt, there's something significant about 1010100001 when it comes to cracking it. This is all coming to a grand conclusion that says: sequence can be boiled down to a frequency fingerprint. Kinda like Fourier analysis.

Let me know if I'm lecturing to an empty classroom or if you get what I'm fiddling with here, thanks!

[random1]

STxAxTIC

I can't speak for others but as for me, I am following every word.  The code I posted is very
simple and all it does is this.  As the code is set now, it starts with the 4 most current entries
in the string, lets say 1001 for example, flow = right to left so the first 4 digits in the string.

Next it builds two search strings, Pat0$ and Pat1$.  Pat0$ = "0" + the first 4 digits 1001 and
Pat1$ = "1" + the first 4.

so Pat0$ = 01001 and Pat1$ = 11001

The program worms it's way through the entire string and every time it finds a match it counts
it, ie, Hit0 and Hit1 hold these counts.  Once it finishes the search it then increases the digits
taken from the main string by 1.  So the first cycle uses the first 4 digits in the string, the second
uses 5 and so on.  Both search patterns, ie, Pat0$ and Pat1$ are padded with a 0 or 1 to impose
the next prediction before it happens.  The next value update will equal one of the two search
patterns. 

The program does not reset the counters during the cycle phase.  The number of cycles can be set
to span any range but search strings with lengths of 5 to 7 seem to work best.  In the version I
used in my main program I was able to set the string length, the number of cycles, weights etc
as commented within the code.  These can be ignored, just placed there to indicate values that
can be adjusted.  Sometimes shorter string lengths work better but in my main tool the strings
can have as many as 5K entries.

The predictions are made based on if the counts for Pat1$ are >= the counts for Pat0$.  Very
simple tool.

Once it completes analysis on the string it then loads the next string and repeats the process. 

What it does in a sense, is it only uses the alphabets that coincide with the most recent events
of the string being analyzed, ie the first 4 to 6 plus a leading 0 or 1 to simulate the next event.

It's basically a brute force method that tries to find what happened's most often within the history.
I use the >= because (0's) often make up the majority of the string volume so anytime the total
ones reach or surpass the zero counts the prediction goes to 1.   The results in the posted code
store the predicted values in a array which is not needed here but is used within my program to
transfer predictions to the next stage in my main program.

Please don't think that I have left off working with your attempts, I have read the information
you provide in the link dozens of times.  I understand what your doing and hope you continue
working on it.  The strings I posted are just a subset of the total and a different method is used
in building these strings.  They are based on rather a value stays the same or changes.  Not a
big difference but they do seem to be more predictable.

The hardest thing for me in understanding and making edits to your code so that in fits into my
main program is the print stuff.  Not a biggie but every time you make changes I have to change
my edits also.  What I have done to deal with this until the final version is complete is to add the
load from file option, compile it then shell the program from my main program.  Makes keeping
up much easier.

In the end I hope to edit your code so that it fits seamlessly into my main program where the
only thing printed to screen are the progress bars.

I mentioned somewhere in the post the idea of using more than one prediction tool for each
string in hopes that combining outputs might give a more accurate prediction.  Sometimes
it's easier to built more than one tool to ease complexity and expand the final project.  I can't
begin to tell you the number of times a attempt got so complex I could not follow my own
code.     
 
Anyway,  Many thanks

R1

[random1]

The below pic shows added counters for the number of incorrect predictions made overall.
If anyone is interested I will post the updated code. 

R1

https://i.postimg.cc/q7jZfNCQ/p1-ps.png

[STxAxTIC]

Yello r1,

I gave your program a closer look and your description really helped. Your method reminds me of a past thread - the stuff I was alluding to way back. Back a few pages ago when I was yelling for Steve and bplus to publicly remember working on a problem similar to this, it was because I remembered their solutions - and lo and behold - turns out yours is much like theirs. It'd say the algorithm you're using is viable for the question on hand, I've seen it work before for similar jobs.

What would be a fun exercise is to find the tuning in w(n)-space that makes my predictor say the same thing that yours does. And on that note, I can totally understand what you mean by saying my code has a whole mess of print statements and stuff. Let me peel that onion a little.

(I)
For anything to work at all, the "alphabets" arrays and the "weights" arrays must be defined. In cartoon code, this obviously looks like:

Code: QB64: [Select]

1. Dim Shared Alphabet1(2) As LetterBin ' 0 1
2. Dim Shared Alphabet2(4) As LetterBin ' 00 01 10 11
3. Dim Shared Alphabet3(8) As LetterBin ' 000 001 010 011 100 101 110 111
4. Dim Shared Alphabet4(16) As LetterBin ' etc.
5. ...
6. Alphabet1(1).Signature = "0"
7. Alphabet1(2).Signature = "1"
8. Call NewAlphabet(Alphabet1(), Alphabet2())
9. Call NewAlphabet(Alphabet2(), Alphabet3())
10. Call NewAlphabet(Alphabet3(), Alphabet4())
11. ...
12. Dim Shared AlphaWeight(1 To 13) As Double
13.  

where weights are specified a few ways. My favorite being

Code: QB64: [Select]

1. Call InitializeBinaryModel(BinaryModelIndex)

where BinaryModelIndex is an integer between 0 and 1023. This will convert to a 10-bit binary number that specifies w(n), as you already know.

(II)
Okay, with all that defined, it's ready for use. If you specify a sequence TheString = "00111011000011100100010100101" or whatever, all that's needed now is one function:

Analyze(TheString, AlphaWeight(), 0)

... but this is a function. So you want to print the output or store it in a varaible:

Code: QB64: [Select]

1. GuessPredicted = Analyze(TheString, AlphaWeight(), 0)

Point is, all you do is specify is TheString, and Analyze gives you a 0 or a 1. Done and done. In my code, everything surrounding Analyze can be deleted - there need not be a main loop or anything else.

(III)

All that said, my actual code puts Analyze in like, 3 loops. This is because, in order to avoid version hell, I use one codebase that does every task in a unified way. Since that's becoming stable, I may shatter this finally into different files to keep it all more digestible. I'll in fact maybe do this - consider the ball still in my court.

[STxAxTIC]

Hey R1,

Quick update on this... So I couldn't bring myself to fragment the code apart yet, I'm still a little busy making discoveries with it, so it's in research mode for the time being. One improvement I made is a way to load the data files you provide:

Code: QB64: [Select]

1. ' Load test data from file or from sub.
2. If (_CommandCount > 0) Then
3.     ReDim _Preserve TestData(LoadTestFile(0, Command$(1), -1))
4. Else
5.     ReDim _Preserve TestData(LoadTestData(0))
6. End If

The "-1" switch means the input string is stored backwards like your program prefers. I'll put the full code at the bottom. The way to use it right now: just compile the EXE and then drag+drop your file onto it. It will buzz through the whole thing swiftly, especially if you turn off the delays and limits. The model used is 0000101000 or something like that.

Some elaboration: There are two main loops in the program, (i) a routine that loops through each data sample while the model is fixed, or (ii) a routine that loops through each model while the sample is fixed. What is does *not* do so far is both at the same time. If all that is too crazy, fret not - Like I was saying, you can just delete around Analyze() until it's simple enough.

Speaking of simple enough, I want to look into turning your predictor into a function. That is, if I take your code, and insist on writing an analog to Analyze(), what does it look like? I'll spend a little while with it.

Code: QB64: [Select]

1. Option _Explicit
2.  
3. Screen _NewImage(120, 40)
4.  
5. ' Version: 22
6.  
7. Type LetterBin
8.     Signature As String
9.     Count As Integer
10. End Type
11.  
12. Dim Shared Alphabet1(2) As LetterBin ' 0 1
13. Dim Shared Alphabet2(4) As LetterBin ' 00 01 10 11
14. Dim Shared Alphabet3(8) As LetterBin ' 000 001 010 011 100 101 110 111
15. Dim Shared Alphabet4(16) As LetterBin ' etc.
16. Dim Shared Alphabet5(32) As LetterBin
17. Dim Shared Alphabet6(64) As LetterBin
18. Dim Shared Alphabet7(128) As LetterBin
19. Dim Shared Alphabet8(256) As LetterBin
20. Dim Shared Alphabet9(512) As LetterBin
21. Dim Shared Alphabet10(1024) As LetterBin
22. Dim Shared Alphabet11(2048) As LetterBin
23. Dim Shared Alphabet12(4096) As LetterBin
24. Dim Shared Alphabet13(8192) As LetterBin
25.  
26. Alphabet1(1).Signature = "0"
27. Alphabet1(2).Signature = "1"
28. Call NewAlphabet(Alphabet1(), Alphabet2())
29. Call NewAlphabet(Alphabet2(), Alphabet3())
30. Call NewAlphabet(Alphabet3(), Alphabet4())
31. Call NewAlphabet(Alphabet4(), Alphabet5())
32. Call NewAlphabet(Alphabet5(), Alphabet6())
33. Call NewAlphabet(Alphabet6(), Alphabet7())
34. Call NewAlphabet(Alphabet7(), Alphabet8())
35. Call NewAlphabet(Alphabet8(), Alphabet9())
36. Call NewAlphabet(Alphabet9(), Alphabet10())
37. Call NewAlphabet(Alphabet10(), Alphabet11())
38. Call NewAlphabet(Alphabet11(), Alphabet12())
39. Call NewAlphabet(Alphabet12(), Alphabet13())
40.  
41. ' Specification of weight model.
42. Dim Shared AlphaWeight(1 To 13) As Double
43.  
44. ' Array for test sequences.
45. ReDim Shared TestData(10000) As String
46.  
47. ' Statistics and metrics:
48. Dim GuessPredicted As Integer
49. Dim GuessCorrect As Double
50. Dim GuessTotal As Double
51. Dim GuessRatioBest As Double
52. Dim GuessStreak As Integer
53. Dim GuessStreakMax As Integer
54. Dim GuessStreakBest As Integer
55. Dim Grade(10000, 2) As Double
56. Dim BinaryModelIndex As Integer
57. Dim BinaryModelBest As Integer
58.  
59. ' Working varaibles:
60. Dim TheString As String
61. Dim As Integer k, m, n
62.  
63. ' Load test data from file or from sub.
64. If (_CommandCount > 0) Then
65.     ReDim _Preserve TestData(LoadTestFile(0, Command$(1), -1))
66. Else
67.     ReDim _Preserve TestData(LoadTestData(0))
68. End If
69.  
70. GuessRatioBest = 0
71. GuessStreakBest = 0
72.  
73. ' This outter loop is for cycling through models.
74. ' If models are manually set, this loop goes forever.
75. BinaryModelIndex = -1
76. Do While (BinaryModelIndex < 1024)
77.  
78.     '''
79.     ' Automatic increment of model index number.
80.     'BinaryModelIndex = BinaryModelIndex + 1
81.     'Call InitializeIndexedModel(BinaryModelIndex)
82.     '''
83.  
84.     '''
85.     ' Manual setting of model number using one of two similar functions:
86.     'Call InitializeIndexedModel(16)
87.     Call InitializeBinaryModel("0000101000")
88.     '''
89.  
90.     ' This enclosed loop is for looping through test strings.
91.     For m = 1 To UBound(TestData)
92.  
93.         GuessPredicted = -1
94.         GuessCorrect = 0
95.         GuessTotal = 0
96.         GuessStreak = 0
97.         GuessStreakMax = 0
98.  
99.         ' This core loop goes through a test string at a rate of one bit per iteration.
100.         ' For Gaming mode, this essentially becomes an infinite DO loop.
101.         For n = 1 To Len(TestData(m)) '9999
102.  
103.             '''
104.             ' Auto-feed Mode:
105.             TheString = Left$(TestData(m), n)
106.             '''
107.  
108.             '''
109.             ' Gaming Mode:
110.             'Call InitializeBinaryModel("0000101000")
111.             'Cls
112.             'Locate 1, 1
113.             'Print "Press LEFT or RIGHT."
114.             'k = 0
115.             'Do: k = _KeyHit: Loop Until ((k = 19200) Or (k = 19712))
116.             'Select Case k
117.             '    Case 19200
118.             '        TheString = TheString + "0"
119.             '    Case 19712
120.             '        TheString = TheString + "1"
121.             'End Select
122.             '_KeyClear
123.             '''
124.  
125.             Cls
126.             Color 7
127.             Locate 1, 1
128.             For k = 1 To _Width
129.                 Print "_";
130.             Next
131.             Print "Model ("; _Trim$(Str$(BinaryModelIndex)); "):";
132.             For k = 1 To 10 'UBound(AlphaWeight)
133.                 Print AlphaWeight(k);
134.             Next
135.             Print
136.             Print
137.             Print "Sequence (length "; _Trim$(Str$(Len(TheString))); "):"
138.             Print TheString;
139.             Color 8
140.             Print Right$(TestData(m), Len(TestData(m)) - n);
141.             Color 7
142.             Print
143.  
144.             ' Reconciliation
145.             If (GuessPredicted <> -1) Then
146.                 Print
147.                 Print "I predicted "; _Trim$(Str$(GuessPredicted)); " and you typed "; Right$(TheString, 1); "."
148.                 If (GuessPredicted = Val(Right$(TheString, 1))) Then
149.                     Print "I am RIGHT this round."
150.                     GuessCorrect = GuessCorrect + 1
151.                     GuessStreak = GuessStreak + 1
152.                     If (GuessStreak > GuessStreakMax) Then GuessStreakMax = GuessStreak
153.                     Grade(n, 2) = 1
154.                 Else
155.                     Print "I am WRONG this round."
156.                     GuessStreak = 0
157.                     Grade(n, 2) = 0
158.                 End If
159.                 GuessTotal = GuessTotal + 1
160.                 Grade(n, 1) = GuessCorrect / GuessTotal
161.             End If
162.  
163.             If (GuessTotal > 0) Then
164.                 Print
165.                 Print "I'm on a "; _Trim$(Str$(GuessStreak)); "-round winning streak."
166.                 Print "My best streak has been "; _Trim$(Str$(GuessStreakMax)); "."
167.                 If (GuessTotal <> 0) Then
168.                     Print "My correctness rate is "; _Trim$(Str$(Int(100 * GuessCorrect / GuessTotal))); "% in "; _Trim$(Str$(GuessTotal)); " guesses."
169.                 End If
170.             End If
171.  
172.             GuessPredicted = Analyze(TheString, AlphaWeight(), 0)
173.  
174.             Print
175.             'Print "I have made a new prediction."
176.             'Print "Press LEFT or RIGHT to test me."
177.             'Print "The best performance has been model #"; _Trim$(Str$(BinaryModelBest)); ", rated "; _Trim$(Str$(Int(GuessRatioBest * 100))); "%, best streak of "; _Trim$(Str$(GuessStreakBest)); "."
178.  
179.             ' Draw bottom graph if there's enough room.
180.             If (CsrLin <= 23) Then
181.                 If (GuessTotal <> 0) Then
182.                     Call PrintGraph(TheString, Grade())
183.                 End If
184.             End If
185.  
186.             _Display
187.             _Delay .02
188.             _Limit 240
189.         Next
190.  
191.         If (GuessCorrect / GuessTotal > GuessRatioBest) Then
192.             BinaryModelBest = BinaryModelIndex
193.             GuessRatioBest = GuessCorrect / GuessTotal
194.             GuessStreakBest = GuessStreakMax
195.         End If
196.  
197.         _Delay 3
198.     Next
199.  
200. Loop
201.  
202. End
203.  
204. Function Analyze (TheStringIn As String, arrweight() As Double, pswitch As Integer)
205.     Dim TheReturn As Integer
206.     Dim As Integer n
207.     Dim As Double r, j, k
208.     Dim StringPhase(UBound(arrweight)) As String
209.     Dim Partialguess(LBound(arrweight) To UBound(arrweight), 2) As Double
210.  
211.     StringPhase(1) = TheStringIn
212.     For n = 2 To UBound(StringPhase) ' Phase analysis.
213.         StringPhase(n) = Right$(StringPhase(n - 1), Len(StringPhase(n - 1)) - 1) + Left$(StringPhase(n - 1), 1)
214.     Next
215.  
216.     ' Initialize partial results.
217.     For n = LBound(Partialguess) To UBound(Partialguess)
218.         Partialguess(n, 1) = -999
219.     Next
220.  
221.     If (pswitch = 1) Then
222.         Print
223.         For n = 1 To _Width
224.             Print "-";
225.         Next
226.         Print
227.     End If
228.  
229.     If (arrweight(1) <> 0) Then Call CreateHisto(StringPhase(), 1, Alphabet1())
230.     If (arrweight(2) <> 0) Then Call CreateHisto(StringPhase(), 2, Alphabet2())
231.     If (arrweight(3) <> 0) Then Call CreateHisto(StringPhase(), 3, Alphabet3())
232.     If (arrweight(4) <> 0) Then Call CreateHisto(StringPhase(), 4, Alphabet4())
233.     If (arrweight(5) <> 0) Then Call CreateHisto(StringPhase(), 5, Alphabet5())
234.     If (arrweight(6) <> 0) Then Call CreateHisto(StringPhase(), 6, Alphabet6())
235.     If (arrweight(7) <> 0) Then Call CreateHisto(StringPhase(), 7, Alphabet7())
236.     If (arrweight(8) <> 0) Then Call CreateHisto(StringPhase(), 8, Alphabet8())
237.     If (arrweight(9) <> 0) Then Call CreateHisto(StringPhase(), 9, Alphabet9())
238.     If (arrweight(10) <> 0) Then Call CreateHisto(StringPhase(), 10, Alphabet10())
239.     If (arrweight(11) <> 0) Then Call CreateHisto(StringPhase(), 11, Alphabet11())
240.     If (arrweight(12) <> 0) Then Call CreateHisto(StringPhase(), 12, Alphabet12())
241.     If (arrweight(13) <> 0) Then Call CreateHisto(StringPhase(), 13, Alphabet13())
242.  
243.     If (pswitch = 1) Then ' Set the last argument >=1 to print stats for that histogram.
244.         If ((Len(TheStringIn) >= 1) And (arrweight(1) <> 0)) Then Call PrintHisto(Alphabet1(), 0)
245.         If ((Len(TheStringIn) >= 2) And (arrweight(2) <> 0)) Then Call PrintHisto(Alphabet2(), 0)
246.         If ((Len(TheStringIn) >= 3) And (arrweight(3) <> 0)) Then Call PrintHisto(Alphabet3(), 0)
247.         If ((Len(TheStringIn) >= 4) And (arrweight(4) <> 0)) Then Call PrintHisto(Alphabet4(), 0)
248.         If ((Len(TheStringIn) >= 5) And (arrweight(5) <> 0)) Then Call PrintHisto(Alphabet5(), 4)
249.         If ((Len(TheStringIn) >= 6) And (arrweight(6) <> 0)) Then Call PrintHisto(Alphabet6(), 0)
250.         If ((Len(TheStringIn) >= 7) And (arrweight(7) <> 0)) Then Call PrintHisto(Alphabet7(), 0)
251.         If ((Len(TheStringIn) >= 8) And (arrweight(8) <> 0)) Then Call PrintHisto(Alphabet8(), 0)
252.         If ((Len(TheStringIn) >= 9) And (arrweight(9) <> 0)) Then Call PrintHisto(Alphabet9(), 0)
253.         If ((Len(TheStringIn) >= 10) And (arrweight(10) <> 0)) Then Call PrintHisto(Alphabet10(), 0)
254.         If ((Len(TheStringIn) >= 11) And (arrweight(11) <> 0)) Then Call PrintHisto(Alphabet11(), 0)
255.         If ((Len(TheStringIn) >= 12) And (arrweight(12) <> 0)) Then Call PrintHisto(Alphabet12(), 0)
256.         If ((Len(TheStringIn) >= 13) And (arrweight(13) <> 0)) Then Call PrintHisto(Alphabet13(), 0)
257.         Print
258.     End If
259.  
260.     ' Set the last argument =1 to print guess for that histogram.
261.     If ((Len(TheStringIn) >= 1) And (arrweight(1) <> 0)) Then Call MakeGuess(TheStringIn, 1, Alphabet1(), Partialguess(), 0)
262.     If ((Len(TheStringIn) >= 2) And (arrweight(2) <> 0)) Then Call MakeGuess(TheStringIn, 2, Alphabet2(), Partialguess(), 0)
263.     If ((Len(TheStringIn) >= 3) And (arrweight(3) <> 0)) Then Call MakeGuess(TheStringIn, 3, Alphabet3(), Partialguess(), 0)
264.     If ((Len(TheStringIn) >= 4) And (arrweight(4) <> 0)) Then Call MakeGuess(TheStringIn, 4, Alphabet4(), Partialguess(), 0)
265.     If ((Len(TheStringIn) >= 5) And (arrweight(5) <> 0)) Then Call MakeGuess(TheStringIn, 5, Alphabet5(), Partialguess(), pswitch)
266.     If ((Len(TheStringIn) >= 6) And (arrweight(6) <> 0)) Then Call MakeGuess(TheStringIn, 6, Alphabet6(), Partialguess(), 0)
267.     If ((Len(TheStringIn) >= 7) And (arrweight(7) <> 0)) Then Call MakeGuess(TheStringIn, 7, Alphabet7(), Partialguess(), 0)
268.     If ((Len(TheStringIn) >= 8) And (arrweight(8) <> 0)) Then Call MakeGuess(TheStringIn, 8, Alphabet8(), Partialguess(), 0)
269.     If ((Len(TheStringIn) >= 9) And (arrweight(9) <> 0)) Then Call MakeGuess(TheStringIn, 9, Alphabet9(), Partialguess(), 0)
270.     If ((Len(TheStringIn) >= 10) And (arrweight(10) <> 0)) Then Call MakeGuess(TheStringIn, 10, Alphabet10(), Partialguess(), 0)
271.     If ((Len(TheStringIn) >= 11) And (arrweight(11) <> 0)) Then Call MakeGuess(TheStringIn, 11, Alphabet11(), Partialguess(), 0)
272.     If ((Len(TheStringIn) >= 12) And (arrweight(12) <> 0)) Then Call MakeGuess(TheStringIn, 12, Alphabet12(), Partialguess(), 0)
273.     If ((Len(TheStringIn) >= 13) And (arrweight(13) <> 0)) Then Call MakeGuess(TheStringIn, 13, Alphabet13(), Partialguess(), 0)
274.     If (pswitch = 1) Then Print
275.  
276.     If (pswitch = 1) Then
277.         Print "Thinking:   ";
278.         For k = LBound(Partialguess) To UBound(Partialguess)
279.             If (Partialguess(k, 1) <> -999) Then
280.                 Print Partialguess(k, 1);
281.             Else
282.                 Print "_ ";
283.             End If
284.         Next
285.         Print
286.     End If
287.  
288.     j = 0
289.     r = 0
290.  
291.     ' Weighted average calculation
292.     For k = UBound(Partialguess) To LBound(Partialguess) Step -1
293.         If (Partialguess(k, 1) <> -999) Then
294.             r = r + arrweight(k) * Partialguess(k, 1)
295.             j = j + arrweight(k)
296.         End If
297.     Next
298.     If (j <> 0) Then
299.         r = r / j
300.     End If
301.  
302.     If (pswitch = 1) Then Print "Predicting:  "; _Trim$(Str$(r))
303.  
304.     If (r > .5) Then
305.         r = 1
306.     Else
307.         r = 0
308.     End If
309.  
310.     If (pswitch = 1) Then
311.         Print "Rounding to: "; _Trim$(Str$(r))
312.     End If
313.  
314.     If (pswitch = 1) Then
315.         For n = 1 To _Width
316.             Print "-";
317.         Next
318.         Print
319.     End If
320.  
321.     TheReturn = r
322.     Analyze = TheReturn
323. End Function
324.  
325. Sub MakeGuess (TheStringIn As String, wid As Integer, arralpha() As LetterBin, arrguess() As Double, pswitch As Integer)
326.     Dim TheReturn As Double
327.     Dim As Integer j, k, n
328.     TheReturn = 0
329.     j = 1
330.     k = 0
331.     For n = 1 To UBound(arralpha)
332.         If (Left$(arralpha(n).Signature, wid - 1) = Right$(TheStringIn, wid - 1)) Then
333.             If (arralpha(n).Count >= j) Then
334.                 If (pswitch = 1) Then Print "Order-"; Right$("0" + _Trim$(Str$(wid)), 2); " guess: "; arralpha(n).Signature; " . "; _Trim$(Str$(arralpha(n).Count))
335.                 TheReturn = TheReturn + Val(Right$(arralpha(n).Signature, 1))
336.                 k = k + 1
337.                 j = arralpha(n).Count
338.             End If
339.         End If
340.     Next
341.     If (k <> 0) Then
342.         TheReturn = TheReturn / k
343.     Else
344.         TheReturn = .5
345.     End If
346.     arrguess(wid, 1) = TheReturn
347.     arrguess(wid, 2) = j
348. End Sub
349.  
350. Sub InitializeIndexedModel (TheIndexIn As Integer)
351.     '0 to 1023
352.     Call InitializeBinaryModel(BIN$(TheIndexIn))
353. End Sub
354.  
355. Sub InitializeBinaryModel (Weights As String)
356.     Dim As Integer k
357.     If (Weights = "-1") Then
358.         For k = LBound(AlphaWeight) To UBound(AlphaWeight)
359.             AlphaWeight(k) = k ^ 2
360.         Next
361.     Else
362.         For k = 1 To 10
363.             AlphaWeight(k) = Val(Mid$(Weights, k, 1))
364.         Next
365.         AlphaWeight(11) = 0
366.         AlphaWeight(12) = 0
367.         AlphaWeight(13) = 0
368.     End If
369. End Sub
370.  
371. Function BIN$ (n As Integer)
372.     ' Taken from the Wiki. Ugliest function ever.
373.     Dim As Integer max, i, msb
374.     Dim As String b
375.     max% = 8 * Len(n%) ': MSB% = 1   'uncomment for 16 (32 or 64) bit returns
376.     For i = max% - 1 To 0 Step -1 'read as big-endian MSB to LSB
377.         If (n% And 2 ^ i) Then msb% = 1: b$ = b$ + "1" Else If msb% Then b$ = b$ + "0"
378.     Next
379.     b$ = "0000000000" + b$
380.     b$ = Right$(b$, 10)
381.     If b$ = "" Then BIN$ = "0" Else BIN$ = b$ 'check for empty string
382. End Function
383.  
384. Sub CreateHisto (arrseqphase() As String, wid As Integer, arralpha() As LetterBin)
385.     Dim As Integer j, k, n
386.     For n = 1 To UBound(arralpha)
387.         arralpha(n).Count = 0
388.     Next
389.     ' Uncomment this loop to enable phase analysis.
390.     ' Hack j=1 to use base string only.
391.     For j = 1 To 1 'wid
392.         For k = 1 To Len(arrseqphase(j)) - (Len(arrseqphase(j)) Mod wid) Step wid
393.             For n = 1 To UBound(arralpha)
394.                 If (Mid$(arrseqphase(j), k, wid) = arralpha(n).Signature) Then
395.                     arralpha(n).Count = arralpha(n).Count + 1
396.                 End If
397.             Next
398.         Next
399.     Next
400.     Call QuickSort(arralpha(), 1, UBound(arralpha))
401. End Sub
402.  
403. Sub PrintHisto (arr() As LetterBin, wid As Integer)
404.     Dim As Integer j, n
405.     If (wid > 0) Then
406.         If (wid > UBound(arr)) Then
407.             j = UBound(arr)
408.         Else
409.             j = wid
410.         End If
411.         Print "Histogram: "; _Trim$(Str$(UBound(arr))); "-letter regroup, showing top "; _Trim$(Str$(wid))
412.         For n = 1 To j
413.             Print arr(n).Signature; arr(n).Count
414.         Next
415.     End If
416. End Sub
417.  
418. Sub PrintGraph (TheString As String, arrgrade() As Double)
419.     Dim As Integer j, k
420.     Dim As Double f, g
421.     For k = 1 To _Width
422.         Locate _Height - 5, k: Print "_"
423.         Locate _Height - 5 - 10, k: Print "_"
424.     Next
425.     Locate _Height - 5 + 1, 1: Print "0%"
426.     Locate _Height - 5 - 10 - 1, 1: Print "100%"
427.     f = (_Width) / Len(TheString)
428.     If (f > 1) Then f = 1
429.     For j = 2 To Len(TheString)
430.         g = Int(j * f)
431.         If (g = 0) Then g = 1
432.         Locate _Height - 5 - Int(10 * arrgrade(j, 1)), g
433.         If (arrgrade(j, 2) = 1) Then
434.             Print Chr$(251)
435.         Else
436.             Print "x"
437.         End If
438.     Next
439. End Sub
440.  
441. Sub NewAlphabet (arrold() As LetterBin, arrnew() As LetterBin)
442.     Dim As Integer j, k, n
443.     n = 0
444.     For k = 1 To 2
445.         For j = 1 To UBound(arrold)
446.             n = n + 1
447.             arrnew(n).Signature = arrold(j).Signature
448.         Next
449.     Next
450.     For j = 1 To UBound(arrnew)
451.         If (j <= UBound(arrnew) / 2) Then
452.             arrnew(j).Signature = "0" + arrnew(j).Signature
453.         Else
454.             arrnew(j).Signature = "1" + arrnew(j).Signature
455.         End If
456.     Next
457. End Sub
458.  
459. Sub QuickSort (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
460.     Dim As Long piv
461.     If (LowLimit < HighLimit) Then
462.         piv = Partition(arr(), LowLimit, HighLimit)
463.         Call QuickSort(arr(), LowLimit, piv - 1)
464.         Call QuickSort(arr(), piv + 1, HighLimit)
465.     End If
466. End Sub
467.  
468. Function Partition (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
469.     Dim As Long i, j
470.     Dim As Double pivot, tmp
471.     pivot = arr(HighLimit).Count
472.     i = LowLimit - 1
473.     For j = LowLimit To HighLimit - 1
474.         tmp = arr(j).Count - pivot
475.         If (tmp >= 0) Then
476.             i = i + 1
477.             Swap arr(i), arr(j)
478.         End If
479.     Next
480.     Swap arr(i + 1), arr(HighLimit)
481.     Partition = i + 1
482. End Function
483.  
484. Function Pathological$ (TheSeed As String, TheLength As Integer)
485.     Dim TheReturn As String
486.     TheReturn = TheSeed
487.     Dim p
488.     Do
489.         p = Analyze(TheReturn, AlphaWeight(), 0)
490.         If (p = 1) Then
491.             TheReturn = TheReturn + "0"
492.         Else
493.             TheReturn = TheReturn + "1"
494.         End If
495.     Loop Until Len(TheReturn) = TheLength
496.     Pathological$ = TheReturn
497. End Function
498.  
499. Function LoadTestFile (alwayszero As Integer, TheFile As String, ReversalToggle As Integer)
500.     Dim As Integer j, k
501.     Dim n As Integer
502.     Dim a As String
503.     n = alwayszero
504.     Open TheFile For Input As #1
505.     Do While Not EOF(1)
506.         n = n + 1
507.         Line Input #1, a
508.         TestData(n) = a
509.     Loop
510.     Close #1
511.     If (ReversalToggle = -1) Then
512.         For k = 1 To n
513.             a = TestData(k)
514.             TestData(k) = ""
515.             For j = Len(a) To 1 Step -1
516.                 TestData(k) = TestData(k) + Mid$(a, j, 1)
517.             Next
518.         Next
519.     End If
520.     LoadTestFile = n
521. End Function
522.  
523. Function LoadTestData (alwayszero As Integer)
524.     Dim n As Integer
525.     n = alwayszero
526.  
527.     '''
528.     ' Percussive cases:
529.     '''
530.     n = n + 1: TestData(n) = "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
531.     n = n + 1: TestData(n) = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
532.     n = n + 1: TestData(n) = "0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101"
533.     n = n + 1: TestData(n) = "1010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010"
534.     n = n + 1: TestData(n) = "0001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011"
535.     n = n + 1: TestData(n) = "0100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111"
536.  
537.     '''
538.     ' Human samples:
539.     '''
540.     ' (from Keybone)
541.     n = n + 1: TestData(n) = "101010101010101010101001010101010101001010111001010101010101010101010100010101010101010100101001010101001100101010001010100101010100101010100101010101010101010011011110010101010100100101010110010011001010011001010100010100101010010101010101010010101010101010010101001010101010100110010101010100101010101010011001001010100101010010101010100101010010101001010100101001010010101010111010100110011001010101010100110101001010101010100101001010111010101010101010100101001010101010010101010101001010101001010101001010100101010100101010010101010101001010101001010101010101001010101001010100101010101010010101010010010101010101010101010010100101010101001010100101001010101001111101010101010100101010110011001010101010101010110101010101101010101010100101010010101010010101010101101110010101001010101010110010100101010101001011010101010100110101010100101010010101010100101010101001010101010101001010101010011010101010101110110100101010111010101011011001011001010101001010101010101010101010011001010101010100101010101010101010010100101"
542.     ' (from Keybone)
543.     n = n + 1: TestData(n) = "0101110101100011010100101011001110001011001010001110101111010100111011100100101001010011110101101000101010001010101111001010111010101010100001010101000101101100101111101010010101110110111001000101000011010101010001001001001111101011101010100010110101110101100000101010101110111010100100100001110111100101011110101010001010001110010110111110110010101001001011101000101001011100011101000010101010101101010010110100101101000101111010101110111001010011101111010101000010101111100010101011110101011011110100001010110"
544.     ' (from Loudar)
545.     n = n + 1: TestData(n) = "1011001010010100100100110010101010101001010101010101011010010101001010101001010010100110101011010101010101011010101101010101010101010010110101010101100101010101010110101101011010010101010010100110101101001010110101011010010101101010110100101111010101010011011011010010110101010010110100101101010100101011010010101001010101010001011101011010010101011100111010010001101011110010011010001011100110101010010011010101001001010010000101010110001"
546.     ' (from Luke)
547.     n = n + 1: TestData(n) = "01100101001010001100001101101111011010010101010110110101001000001111001111110101000101111011010101111101010101101010101001010101011000010101010101001011010100110100110100110011010101010101110101010111111101011010100000001101111000010111000110111001000010100001101010110100000111101011111100001011001010110010110"
548.     ' (from Sarafromct)
549.     n = n + 1: TestData(n) = "10101010101011101000011101010111010101010101100111001010100111100001011011110101000001111010101101010000001111110011111110111101110111001110110010000100010101010101010100101011010110101010101010101001000000001111110000011110101010101010100010101110101010101101111111111111111111101010101010101000000"
550.     ' (from Spriggs)
551.     n = n + 1: TestData(n) = "10111010101010101010101001010101010101001010101001010101010101010101010101010101010101010101010101010101001010100100100101010101010101001010100101010101010100101010100101010101010101010101001010010110010101010010101010101010101010101010100101001001001010101010101010101010101001010101001001101010010"
552.     ' (from Spriggs)
553.     n = n + 1: TestData(n) = "11111011110100101011111111110100000011011110101100111100111111110111101110100111100110011111110101111111010111101111100111110111111111111011100111110111111110010000101011111001110101101010110111110"
554.     ' (from Hotpants)
555.     n = n + 1: TestData(n) = "01010100011001010010101010101010101000110101010111101010100100011010101010100100101110010010010100001010101001010101010110010001001011000100100110101001001001010000000001010101101111101001010100010101001001010101000100101001100100010011010101010101010111010010101011101011011010110100100010010100100100010010001001"
556.  
557.     '''
558.     ' Noted sequences:
559.     '''
560.     ' (Wolfram rule 30)
561.     n = n + 1: TestData(n) = "110111001100010110010011101011100111010101100001100101011010101111110000111100010101110000010010110001110001101101101000000010001111101110100111000111010111000001100100011001111001111110000001111111011001011011100000101100011011000110001110110110010101111111011010110110111101110010111011000100000000001101110010110010111100100110000111110000001011011001111001000010011111000001101001011001001011101011000001101001000101001011101011111011000100000011110101000111101001011010001101000111100001000011110001111010"
562.  
563.     LoadTestData = n
564. End Function
565.  
566. ''' Museum:
567. 'Call InitializeIndexedModel(BinaryModelIndex) ' Goes with counter
568. 'Call InitializeIndexedModel(0)                ' Always zero
569. 'Call InitializeIndexedModel(1023)             ' Homogeneous
570. 'Call InitializeIndexedModel(16)               ' This 5-gram case (16) works best for Gaming mode.
571. 'Call InitializeIndexedModel(82)               ' Learning algo discoverd this is a good one against humans.
572. 'Call InitializeIndexedModel(18)               ' Learning algo discoverd this is a good one against humans.
573. 'Call InitializeBinaryModel(-1)               ' Enables custom models.
574. '''
575.  
576. '''
577. ' Studies in pathology:
578. 'BinaryModelIndex = 2   ' cracked by 124       0000000010 0001111100
579. 'BinaryModelIndex = 3   ' cracked by 16        0000000011 0000010000
580. 'BinaryModelIndex = 4   ' cracked by 265       0000000100 0100001001
581. 'BinaryModelIndex = 5   ' cracked by 736       0000000101 1011100000
582. 'BinaryModelIndex = 6   ' cracked by 49        0000000110 0000110001
583. 'BinaryModelIndex = 7   ' cracked by 88        0000000111 0001011000
584. 'BinaryModelIndex = 8   ' cracked by xxx       0000001000 lambda=16
585. 'BinaryModelIndex = 9   ' cracked by xxx       0000001001 xxx
586. 'BinaryModelIndex = 10  ' cracked by 644       0000001010 1010000100
587. 'BinaryModelIndex = 11  ' cracked by 261       0000001011 0100000101
588. '''
589.  

[random1]

STxAxTIC

I think were going to need a smarter more inclusive method to reach the level of prediction
I need to call it a success.  The project thus far has already surpassed my expectations but
it seems the goal post has been moved.  Maybe chasing such expectations will turn into a
fool's errand but I can't stop thinking it's achievable.

I have a old predictor, even older then the dummy tool I posted earlier.  I will try to explain
it and maybe it will spark your interest.  It often averaged over 80% overall but I hit a wall so
to say and I was never able to improve it past a certain point.  Here is a rundown on how it
worked.

1st.  Count the overall number of 0's and 1's within the string being processed and calculate
        a hit ratio for both 0 and 1.
     
2nd.  Set a search string length, normally around 6 to 15 but could be much larger if needed.

3rd. Generate a random value between 1 and Len(dat1$), ie, of main string.

4th. A sample is then collected starting at rng value and extending to the length set in step 2

5th. Do a simple count for both 0's and 1's within the randomly collected sample.

6th.  A ratio is then calculated for the random sample.  This ratio is compared against the full
       string ratio and averaged to give a means to calculate the final guess in the 8th, 9th steps.

7th.  The program would be set to collect around 350 to 500 of these samples before making
        the guess / prediction. 

8th. The final step would be to count starting with the leftmost digit in the string to the value
       set in step 2 minus 1.  If the value in step 2 is set to 15 then count the first 14 as we will
       be adding either a 0 or a 1 in the final prediction.

9th.  The guess is made by first adding a digit 0 to the 14 and seeing how well it matches the
        overall ratio and the samples ratio.  Then do the same thing and replace the added 0 with
        a 1 and check again.       

The idea is to first get the ratios for the overall and the random samples, then apply those ratios
to the 14 most current list of digits in the main string.  Lets say the overall sample is something
like 35/65 and the random samples produce a ratio of 40/60 and the counts for the last 14 events
equals something like 33/67. This is then used to make the final guess /prediction.

The random samples give us a good understanding of how many times each digit should appear
within a certain length of sample size.  This is where I got stuck as a simple average is not enough
to make a good prediction.  Maybe creating a lower/upper threshold would add a fine tuning element
to the mix.

Anyway I was thinking you might be able to tinker with it by adding running averages, weights etc
to improve the overall accuracy.  I can post or attach the cartoon code if your interested. 

P.S.
This will be my last post until maybe Monday evening, family coming for Christmas.

Thanks again

R1 
   

[STxAxTIC]

Hey R1

Hope Christmas wasn't too exhausting! I just re-skimmed your nicely-detailed list of steps above, and I think I know what you were getting at. In fact, in some form or another, it sounds a lot like what I'm doing in some places. The way you make the final prediction by asking (qualitatively) "which familiar pattern was the sequence almost finished making?" is exactly what I do. The way we get to that question of course is different. (Insert all that "alphabet" mumbo jumbo I use.)

The reason I break radio silence today is to show a systematic way of improving correctness rates, plus show a few numbers. It's all about fitting the best model to the data, like ordinary curve fitting, but we're stepping through binary models. For every sample sequence tested, this new "stepping" method finds a better model than the one(s) we were assuming by hand. It's definitely a proof that the machine is always more precise than the person when it comes to looking for patterns, haha.

This new kind of analysis completes a good circuit in computation space. The final guess is informed by (i) patterns across all frequencies (alphabet sizes) from 1 to any limit, (ii) all possible ways of guessing the answer, assuming binary models. One next branch of research is nonbinary models, letting w(n) vary as some kind of function. This would be a brain-exploding amount of work to do *perfectly* right, but it can be messed with kinda easily. I drafted (in my usual non-spellchecked Notepad style) to demonstrate things. (Still incomplete but nontrivial.) http://barnes.x10host.com/pages/Binary-Analyzer/Binary-Analyzer-Two.php

Just to get back on a familiar track, are there any (new or old) test strings you have in mind that are particularly hard to crack?



Code as of now:

Code: QB64: [Select]

1. Option _Explicit
2.  
3. Do Until _ScreenExists: Loop
4. _Title "Binary Analyzer"
5.  
6. Screen _NewImage(120, 40)
7.  
8. ' Version: 22
9.  
10. Type LetterBin
11.     Signature As String
12.     Count As Integer
13. End Type
14.  
15. Dim Shared Alphabet1(2) As LetterBin ' 0 1
16. Dim Shared Alphabet2(4) As LetterBin ' 00 01 10 11
17. Dim Shared Alphabet3(8) As LetterBin ' 000 001 010 011 100 101 110 111
18. Dim Shared Alphabet4(16) As LetterBin ' etc.
19. Dim Shared Alphabet5(32) As LetterBin
20. Dim Shared Alphabet6(64) As LetterBin
21. Dim Shared Alphabet7(128) As LetterBin
22. Dim Shared Alphabet8(256) As LetterBin
23. Dim Shared Alphabet9(512) As LetterBin
24. Dim Shared Alphabet10(1024) As LetterBin
25. Dim Shared Alphabet11(2048) As LetterBin
26. Dim Shared Alphabet12(4096) As LetterBin
27. Dim Shared Alphabet13(8192) As LetterBin
28.  
29. Alphabet1(1).Signature = "0"
30. Alphabet1(2).Signature = "1"
31. Call NewAlphabet(Alphabet1(), Alphabet2())
32. Call NewAlphabet(Alphabet2(), Alphabet3())
33. Call NewAlphabet(Alphabet3(), Alphabet4())
34. Call NewAlphabet(Alphabet4(), Alphabet5())
35. Call NewAlphabet(Alphabet5(), Alphabet6())
36. Call NewAlphabet(Alphabet6(), Alphabet7())
37. Call NewAlphabet(Alphabet7(), Alphabet8())
38. Call NewAlphabet(Alphabet8(), Alphabet9())
39. Call NewAlphabet(Alphabet9(), Alphabet10())
40. Call NewAlphabet(Alphabet10(), Alphabet11())
41. Call NewAlphabet(Alphabet11(), Alphabet12())
42. Call NewAlphabet(Alphabet12(), Alphabet13())
43.  
44. ' Specification of weight model.
45. Dim Shared AlphaWeight(1 To 13) As Double
46.  
47. ' Array for test sequences.
48. ReDim Shared TestData(256 ^ 2) As String
49.  
50. ' Statistics and metrics:
51. Dim GuessPredicted As Integer
52. Dim GuessCorrect As Double
53. Dim GuessTotal As Double
54. Dim GuessRatioBest As Double
55. Dim GuessRatioWorst As Double
56. Dim GuessStreak As Integer
57. Dim GuessStreakMax As Integer
58. Dim GuessStreakBest As Integer
59. Dim Grade(256 ^ 2, 2) As Double
60. Dim BinaryModelIndex As Integer
61. Dim BinaryModelBest As Integer
62. Dim BinaryModelWorst As Integer
63.  
64. ' Working varaibles:
65. Dim TheString As String
66. Dim As Integer k, m, n
67.  
68. ' Load test data from file or from sub.
69. If (_CommandCount > 0) Then
70.     ReDim _Preserve TestData(LoadTestFile(0, Command$(1), -1))
71. Else
72.     ReDim _Preserve TestData(LoadTestData(0))
73. End If
74.  
75. GuessRatioBest = 0
76. GuessRatioWorst = 1
77. GuessStreakBest = 0
78. BinaryModelWorst = 1
79.  
80. '''
81. ' Play area:
82. 'Call InitializeModelLiteral("0010101000")
83. 'Call InitializeModelCustom("-1")
84. 'Call InitializeModelIndexed(84)
85. 'TestData(1) = Pathological$("1", 1000)
86. 'TestData(1) = QBPRNG$(Timer, 1000)
87. n = 1: TestData(n) = "1011001010010100100100110010101010101001010101010101011010010101001010101001010010100110101011010101010101011010101101010101010101010010110101010101100101010101010110101101011010010101010010100110101101001010110101011010010101101010110100101111010101010011011011010010110101010010110100101101010100101011010010101001010101010001011101011010010101011100111010010001101011110010011010001011100110101010010011010101001001010010000101010110001"
88. ReDim _Preserve TestData(1)
89. 'Open "output.txt" For Output As #1
90. 'Print #1, TestData(1)
91. 'Close #1
92. '''
93.  
94. ' This outer loop is for cycling through models.
95. ' If models are manually set, this loop goes forever.
96. BinaryModelIndex = -1
97. Do While (BinaryModelIndex < 1024)
98.  
99.     '''
100.     ' Automatic increment of model index number.
101.     BinaryModelIndex = BinaryModelIndex + 1
102.     Call InitializeModelIndexed(BinaryModelIndex)
103.     '''
104.  
105.     '''
106.     ' Manual setting of model number using either of two similar functions:
107.     'Call InitializeModelIndexed(16)
108.     'Call InitializeModelLiteral("0010100000")
109.     'Call InitializeModelCustom("-1")
110.     '''
111.  
112.     ' This enclosed loop is for looping through test strings.
113.     For m = 1 To UBound(TestData)
114.  
115.         GuessPredicted = -1
116.         GuessCorrect = 0
117.         GuessTotal = 0
118.         GuessStreak = 0
119.         GuessStreakMax = 0
120.  
121.         ' This core loop goes through a test string at a rate of one bit per iteration.
122.         ' For Gaming mode, this essentially becomes an infinite DO loop.
123.         For n = 1 To Len(TestData(m)) '9999
124.  
125.             '''
126.             ' Auto-feed Mode:
127.             TheString = Left$(TestData(m), n)
128.             '''
129.  
130.             '''
131.             ' Gaming Mode:
132.             'Call InitializeModelLiteral("0000101000")
133.             'Cls
134.             'Locate 1, 1
135.             'Print "Press LEFT or RIGHT."
136.             'k = 0
137.             'Do: k = _KeyHit: Loop Until ((k = 19200) Or (k = 19712))
138.             'Select Case k
139.             '    Case 19200
140.             '        TheString = TheString + "0"
141.             '    Case 19712
142.             '        TheString = TheString + "1"
143.             'End Select
144.             '_KeyClear
145.             '''
146.  
147.             Cls
148.             Color 7
149.             Locate 1, 1
150.             For k = 1 To _Width
151.                 Print "_";
152.             Next
153.             Print "Model ("; _Trim$(Str$(BinaryModelIndex)); "):";
154.             For k = 1 To 10 'UBound(AlphaWeight)
155.                 Print AlphaWeight(k);
156.             Next
157.             Print
158.             Print
159.             Print "Sequence (length "; _Trim$(Str$(Len(TheString))); "):"
160.             Print Right$(TheString, 400);
161.             Color 8
162.             Print Left$(Right$(TestData(m), Len(TestData(m)) - n), 400);
163.             Color 7
164.             Print
165.  
166.             ' Reconciliation
167.             If (GuessPredicted <> -1) Then
168.                 Print
169.                 Print "I predicted "; _Trim$(Str$(GuessPredicted)); " and you typed "; Right$(TheString, 1); "."
170.                 If (GuessPredicted = Val(Right$(TheString, 1))) Then
171.                     Print "I am RIGHT this round."
172.                     GuessCorrect = GuessCorrect + 1
173.                     GuessStreak = GuessStreak + 1
174.                     If (GuessStreak > GuessStreakMax) Then GuessStreakMax = GuessStreak
175.                     Grade(n, 2) = 1
176.                 Else
177.                     Print "I am WRONG this round."
178.                     GuessStreak = 0
179.                     Grade(n, 2) = 0
180.                 End If
181.                 GuessTotal = GuessTotal + 1
182.                 Grade(n, 1) = GuessCorrect / GuessTotal
183.             End If
184.  
185.             If (GuessTotal > 0) Then
186.                 Print
187.                 Print "I'm on a "; _Trim$(Str$(GuessStreak)); "-round winning streak."
188.                 Print "My best streak has been "; _Trim$(Str$(GuessStreakMax)); "."
189.                 If (GuessTotal <> 0) Then
190.                     Print "My correctness rate is "; _Trim$(Str$(Int(100 * GuessCorrect / GuessTotal))); "% in "; _Trim$(Str$(GuessTotal)); " trials."
191.                 End If
192.             End If
193.  
194.             GuessPredicted = Analyze(TheString, AlphaWeight(), 0)
195.  
196.             '''
197.             ' Reverse polarity if needed for any reason.
198.             'If (GuessPredicted = 0) Then
199.             '    GuessPredicted = 1
200.             'Else
201.             '    GuessPredicted = 0
202.             'End If
203.             '''
204.  
205.             Print
206.             'Print "I have made a new prediction."
207.             'Print "Press LEFT or RIGHT to test me."
208.             Print "The best performance has been model #"; _Trim$(Str$(BinaryModelBest)); ", rated "; _Trim$(Str$(Int(GuessRatioBest * 100))); "%, best streak of "; _Trim$(Str$(GuessStreakBest)); "."
209.             Print "The worst performance has been model #"; _Trim$(Str$(BinaryModelWorst)); ", rated "; _Trim$(Str$(Int(GuessRatioWorst * 100))); "%."
210.  
211.             ' Draw bottom graph if there's enough room.
212.             If (CsrLin <= 23) Then
213.                 If (GuessTotal <> 0) Then
214.                     Call PrintGraph(TheString, Grade())
215.                 End If
216.             End If
217.  
218.             _Display
219.             _Delay .02
220.             _Limit 240
221.         Next
222.  
223.         If (GuessTotal > 0) Then
224.             If (GuessCorrect / GuessTotal >= GuessRatioBest) Then
225.                 BinaryModelBest = BinaryModelIndex
226.                 GuessRatioBest = GuessCorrect / GuessTotal
227.                 GuessStreakBest = GuessStreakMax
228.                 'Open "output.txt" For Append As #1
229.                 'Print #1, BinaryModelBest, GuessRatioBest, GuessStreakBest
230.                 'Close #1
231.             End If
232.             If (GuessCorrect / GuessTotal <= GuessRatioWorst) Then
233.                 BinaryModelWorst = BinaryModelIndex
234.                 GuessRatioWorst = GuessCorrect / GuessTotal
235.             End If
236.  
237.         End If
238.  
239.         _Delay 3
240.     Next
241.  
242. Loop
243.  
244. End
245.  
246. Function Analyze (TheStringIn As String, arrweight() As Double, pswitch As Integer)
247.     Dim TheReturn As Integer
248.     Dim As Integer n
249.     Dim As Double r, j, k
250.     Dim StringPhase(UBound(arrweight)) As String
251.     Dim Partialguess(LBound(arrweight) To UBound(arrweight), 2) As Double
252.  
253.     StringPhase(1) = TheStringIn
254.     For n = 2 To UBound(StringPhase) ' Phase analysis.
255.         StringPhase(n) = Right$(StringPhase(n - 1), Len(StringPhase(n - 1)) - 1) + Left$(StringPhase(n - 1), 1)
256.     Next
257.  
258.     If (pswitch = 1) Then
259.         Print
260.         For n = 1 To _Width
261.             Print "-";
262.         Next
263.         Print
264.     End If
265.  
266.     If (arrweight(1) <> 0) Then Call CreateHisto(StringPhase(), 1, Alphabet1())
267.     If (arrweight(2) <> 0) Then Call CreateHisto(StringPhase(), 2, Alphabet2())
268.     If (arrweight(3) <> 0) Then Call CreateHisto(StringPhase(), 3, Alphabet3())
269.     If (arrweight(4) <> 0) Then Call CreateHisto(StringPhase(), 4, Alphabet4())
270.     If (arrweight(5) <> 0) Then Call CreateHisto(StringPhase(), 5, Alphabet5())
271.     If (arrweight(6) <> 0) Then Call CreateHisto(StringPhase(), 6, Alphabet6())
272.     If (arrweight(7) <> 0) Then Call CreateHisto(StringPhase(), 7, Alphabet7())
273.     If (arrweight(8) <> 0) Then Call CreateHisto(StringPhase(), 8, Alphabet8())
274.     If (arrweight(9) <> 0) Then Call CreateHisto(StringPhase(), 9, Alphabet9())
275.     If (arrweight(10) <> 0) Then Call CreateHisto(StringPhase(), 10, Alphabet10())
276.     If (arrweight(11) <> 0) Then Call CreateHisto(StringPhase(), 11, Alphabet11())
277.     If (arrweight(12) <> 0) Then Call CreateHisto(StringPhase(), 12, Alphabet12())
278.     If (arrweight(13) <> 0) Then Call CreateHisto(StringPhase(), 13, Alphabet13())
279.  
280.     If (pswitch = 1) Then ' Set the last argument >=1 to print stats for that histogram.
281.         If ((Len(TheStringIn) >= 1) And (arrweight(1) <> 0)) Then Call PrintHisto(Alphabet1(), 0)
282.         If ((Len(TheStringIn) >= 2) And (arrweight(2) <> 0)) Then Call PrintHisto(Alphabet2(), 0)
283.         If ((Len(TheStringIn) >= 3) And (arrweight(3) <> 0)) Then Call PrintHisto(Alphabet3(), 0)
284.         If ((Len(TheStringIn) >= 4) And (arrweight(4) <> 0)) Then Call PrintHisto(Alphabet4(), 0)
285.         If ((Len(TheStringIn) >= 5) And (arrweight(5) <> 0)) Then Call PrintHisto(Alphabet5(), 4)
286.         If ((Len(TheStringIn) >= 6) And (arrweight(6) <> 0)) Then Call PrintHisto(Alphabet6(), 0)
287.         If ((Len(TheStringIn) >= 7) And (arrweight(7) <> 0)) Then Call PrintHisto(Alphabet7(), 0)
288.         If ((Len(TheStringIn) >= 8) And (arrweight(8) <> 0)) Then Call PrintHisto(Alphabet8(), 0)
289.         If ((Len(TheStringIn) >= 9) And (arrweight(9) <> 0)) Then Call PrintHisto(Alphabet9(), 0)
290.         If ((Len(TheStringIn) >= 10) And (arrweight(10) <> 0)) Then Call PrintHisto(Alphabet10(), 0)
291.         If ((Len(TheStringIn) >= 11) And (arrweight(11) <> 0)) Then Call PrintHisto(Alphabet11(), 0)
292.         If ((Len(TheStringIn) >= 12) And (arrweight(12) <> 0)) Then Call PrintHisto(Alphabet12(), 0)
293.         If ((Len(TheStringIn) >= 13) And (arrweight(13) <> 0)) Then Call PrintHisto(Alphabet13(), 0)
294.         Print
295.     End If
296.  
297.     ' Set the last argument =1 to print guess for that histogram.
298.     If ((Len(TheStringIn) >= 1) And (arrweight(1) <> 0)) Then Call MakeGuess(TheStringIn, 1, Alphabet1(), Partialguess(), 0)
299.     If ((Len(TheStringIn) >= 2) And (arrweight(2) <> 0)) Then Call MakeGuess(TheStringIn, 2, Alphabet2(), Partialguess(), 0)
300.     If ((Len(TheStringIn) >= 3) And (arrweight(3) <> 0)) Then Call MakeGuess(TheStringIn, 3, Alphabet3(), Partialguess(), 0)
301.     If ((Len(TheStringIn) >= 4) And (arrweight(4) <> 0)) Then Call MakeGuess(TheStringIn, 4, Alphabet4(), Partialguess(), 0)
302.     If ((Len(TheStringIn) >= 5) And (arrweight(5) <> 0)) Then Call MakeGuess(TheStringIn, 5, Alphabet5(), Partialguess(), pswitch)
303.     If ((Len(TheStringIn) >= 6) And (arrweight(6) <> 0)) Then Call MakeGuess(TheStringIn, 6, Alphabet6(), Partialguess(), 0)
304.     If ((Len(TheStringIn) >= 7) And (arrweight(7) <> 0)) Then Call MakeGuess(TheStringIn, 7, Alphabet7(), Partialguess(), 0)
305.     If ((Len(TheStringIn) >= 8) And (arrweight(8) <> 0)) Then Call MakeGuess(TheStringIn, 8, Alphabet8(), Partialguess(), 0)
306.     If ((Len(TheStringIn) >= 9) And (arrweight(9) <> 0)) Then Call MakeGuess(TheStringIn, 9, Alphabet9(), Partialguess(), 0)
307.     If ((Len(TheStringIn) >= 10) And (arrweight(10) <> 0)) Then Call MakeGuess(TheStringIn, 10, Alphabet10(), Partialguess(), 0)
308.     If ((Len(TheStringIn) >= 11) And (arrweight(11) <> 0)) Then Call MakeGuess(TheStringIn, 11, Alphabet11(), Partialguess(), 0)
309.     If ((Len(TheStringIn) >= 12) And (arrweight(12) <> 0)) Then Call MakeGuess(TheStringIn, 12, Alphabet12(), Partialguess(), 0)
310.     If ((Len(TheStringIn) >= 13) And (arrweight(13) <> 0)) Then Call MakeGuess(TheStringIn, 13, Alphabet13(), Partialguess(), 0)
311.     If (pswitch = 1) Then Print
312.  
313.     If (pswitch = 1) Then
314.         Print "Thinking:   ";
315.         For k = LBound(Partialguess) To UBound(Partialguess)
316.             If ((Len(TheStringIn) >= k) And (arrweight(k) <> 0)) Then
317.                 Print Partialguess(k, 1);
318.             Else
319.                 Print "_ ";
320.             End If
321.         Next
322.         Print
323.     End If
324.  
325.     j = 0
326.     r = 0
327.  
328.     ' Weighted average calculation
329.     For k = LBound(Partialguess) To UBound(Partialguess)
330.         If ((Len(TheStringIn) >= k) And (arrweight(k) <> 0)) Then
331.             r = r + arrweight(k) * Partialguess(k, 1)
332.             j = j + arrweight(k)
333.         End If
334.     Next
335.     If (j <> 0) Then
336.         r = r / j
337.     End If
338.  
339.     If (pswitch = 1) Then Print "Predicting:  "; _Trim$(Str$(r))
340.  
341.     If (r > .5) Then
342.         r = 1
343.     Else
344.         r = 0
345.     End If
346.  
347.     If (pswitch = 1) Then
348.         Print "Rounding to: "; _Trim$(Str$(r))
349.     End If
350.  
351.     If (pswitch = 1) Then
352.         For n = 1 To _Width
353.             Print "-";
354.         Next
355.         Print
356.     End If
357.  
358.     TheReturn = r
359.     Analyze = TheReturn
360. End Function
361.  
362. Sub MakeGuess (TheStringIn As String, wid As Integer, arralpha() As LetterBin, arrguess() As Double, pswitch As Integer)
363.     Dim TheReturn As Double
364.     Dim As Integer j, k, n
365.     TheReturn = 0
366.     j = 1
367.     k = 0
368.     For n = 1 To UBound(arralpha)
369.         If (Left$(arralpha(n).Signature, wid - 1) = Right$(TheStringIn, wid - 1)) Then
370.             If (arralpha(n).Count >= j) Then
371.                 If (pswitch = 1) Then Print "Order-"; Right$("0" + _Trim$(Str$(wid)), 2); " guess: "; arralpha(n).Signature; " . "; _Trim$(Str$(arralpha(n).Count))
372.                 TheReturn = TheReturn + Val(Right$(arralpha(n).Signature, 1))
373.                 k = k + 1
374.                 j = arralpha(n).Count
375.             End If
376.         End If
377.     Next
378.     If (k <> 0) Then
379.         TheReturn = TheReturn / k
380.     Else
381.         TheReturn = .5
382.     End If
383.     arrguess(wid, 1) = TheReturn
384.     arrguess(wid, 2) = j
385. End Sub
386.  
387. Sub InitializeModelIndexed (TheIndexIn As Integer)
388.     '0 to 1023
389.     Call InitializeModelLiteral(BIN$(TheIndexIn))
390. End Sub
391.  
392. Sub InitializeModelLiteral (Weights As String)
393.     Dim As Integer k
394.     For k = 1 To 10
395.         AlphaWeight(k) = Val(Mid$(Weights, k, 1))
396.     Next
397.     AlphaWeight(11) = 0
398.     AlphaWeight(12) = 0
399.     AlphaWeight(13) = 0
400. End Sub
401.  
402. Sub InitializeModelCustom (Weights As String)
403.     Dim As Integer k
404.     If (Weights = "-1") Then
405.         For k = LBound(AlphaWeight) To UBound(AlphaWeight)
406.             AlphaWeight(k) = k ^ 2
407.         Next
408.     End If
409.     AlphaWeight(11) = 0
410.     AlphaWeight(12) = 0
411.     AlphaWeight(13) = 0
412. End Sub
413.  
414. Function BIN$ (n As Integer)
415.     ' Butchered from the Wiki. Ugliest function ever.
416.     Dim As Integer max, i, msb
417.     Dim As String b
418.     max% = 8 * Len(n%)
419.     For i = max% - 1 To 0 Step -1
420.         If (n% And 2 ^ i) Then msb% = 1: b$ = "1" + b$ Else If msb% Then b$ = "0" + b$
421.     Next
422.     b$ = b$ + "0000000000"
423.     b$ = Left$(b$, 10)
424.     BIN$ = b$
425. End Function
426.  
427. Sub CreateHisto (arrseqphase() As String, wid As Integer, arralpha() As LetterBin)
428.     Dim As Integer j, k, n
429.     For n = 1 To UBound(arralpha)
430.         arralpha(n).Count = 0
431.     Next
432.     ' Uncomment this loop to enable phase analysis.
433.     ' Hack j=1 to use base string only.
434.     For j = 1 To 1 'wid
435.         For k = 1 To Len(arrseqphase(j)) - (Len(arrseqphase(j)) Mod wid) Step wid
436.             For n = 1 To UBound(arralpha)
437.                 If (Mid$(arrseqphase(j), k, wid) = arralpha(n).Signature) Then
438.                     arralpha(n).Count = arralpha(n).Count + 1
439.                 End If
440.             Next
441.         Next
442.     Next
443.     Call QuickSort(arralpha(), 1, UBound(arralpha))
444. End Sub
445.  
446. Sub PrintHisto (arr() As LetterBin, wid As Integer)
447.     Dim As Integer j, n
448.     If (wid > 0) Then
449.         If (wid > UBound(arr)) Then
450.             j = UBound(arr)
451.         Else
452.             j = wid
453.         End If
454.         Print "Histogram: "; _Trim$(Str$(UBound(arr))); "-letter regroup, showing top "; _Trim$(Str$(wid))
455.         For n = 1 To j
456.             Print arr(n).Signature; arr(n).Count
457.         Next
458.     End If
459. End Sub
460.  
461. Sub PrintGraph (TheString As String, arrgrade() As Double)
462.     Dim As Integer j, k
463.     Dim As Double f, g
464.     For k = 1 To _Width
465.         Locate _Height - 5, k: Print "_"
466.         Locate _Height - 5 - 10, k: Print "_"
467.     Next
468.     Locate _Height - 5 + 1, 1: Print "0%"
469.     Locate _Height - 5 - 10 - 1, 1: Print "100%"
470.     f = (_Width) / Len(TheString)
471.     If (f > 1) Then f = 1
472.     For j = 2 To Len(TheString)
473.         g = Int(j * f)
474.         If (g = 0) Then g = 1
475.         Locate _Height - 5 - Int(10 * arrgrade(j, 1)), g
476.         If (arrgrade(j, 2) = 1) Then
477.             Print Chr$(251)
478.         Else
479.             Print "x"
480.         End If
481.     Next
482. End Sub
483.  
484. Sub NewAlphabet (arrold() As LetterBin, arrnew() As LetterBin)
485.     Dim As Integer j, k, n
486.     n = 0
487.     For k = 1 To 2
488.         For j = 1 To UBound(arrold)
489.             n = n + 1
490.             arrnew(n).Signature = arrold(j).Signature
491.         Next
492.     Next
493.     For j = 1 To UBound(arrnew)
494.         If (j <= UBound(arrnew) / 2) Then
495.             arrnew(j).Signature = "0" + arrnew(j).Signature
496.         Else
497.             arrnew(j).Signature = "1" + arrnew(j).Signature
498.         End If
499.     Next
500. End Sub
501.  
502. Sub QuickSort (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
503.     Dim As Long piv
504.     If (LowLimit < HighLimit) Then
505.         piv = Partition(arr(), LowLimit, HighLimit)
506.         Call QuickSort(arr(), LowLimit, piv - 1)
507.         Call QuickSort(arr(), piv + 1, HighLimit)
508.     End If
509. End Sub
510.  
511. Function Partition (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
512.     Dim As Long i, j
513.     Dim As Double pivot, tmp
514.     pivot = arr(HighLimit).Count
515.     i = LowLimit - 1
516.     For j = LowLimit To HighLimit - 1
517.         tmp = arr(j).Count - pivot
518.         If (tmp >= 0) Then
519.             i = i + 1
520.             Swap arr(i), arr(j)
521.         End If
522.     Next
523.     Swap arr(i + 1), arr(HighLimit)
524.     Partition = i + 1
525. End Function
526.  
527. Function Pathological$ (TheSeed As String, TheLength As Integer)
528.     Dim TheReturn As String
529.     TheReturn = TheSeed
530.     Dim p
531.     Do
532.         p = Analyze(TheReturn, AlphaWeight(), 0)
533.         If (p = 1) Then
534.             TheReturn = TheReturn + "0"
535.         Else
536.             TheReturn = TheReturn + "1"
537.         End If
538.     Loop Until Len(TheReturn) = TheLength
539.     Pathological$ = TheReturn
540. End Function
541.  
542. Function QBPRNG$ (TheSeed As Double, TheLength As Integer)
543.     Dim TheReturn As String
544.     Dim k As Integer
545.     Randomize TheSeed
546.     For k = 1 To TheLength
547.         If (Rnd > .5) Then
548.             TheReturn = TheReturn + "1"
549.         Else
550.             TheReturn = TheReturn + "0"
551.         End If
552.     Next
553.     QBPRNG$ = TheReturn
554. End Function
555.  
556. Function LoadTestFile (alwayszero As Integer, TheFile As String, ReversalToggle As Integer)
557.     Dim As Integer j, k
558.     Dim n As Integer
559.     Dim a As String
560.     n = alwayszero
561.     Open TheFile For Input As #1
562.     Do While Not EOF(1)
563.         n = n + 1
564.         Line Input #1, a
565.         TestData(n) = a
566.     Loop
567.     Close #1
568.     If (ReversalToggle = -1) Then
569.         For k = 1 To n
570.             a = TestData(k)
571.             TestData(k) = ""
572.             For j = Len(a) To 1 Step -1
573.                 TestData(k) = TestData(k) + Mid$(a, j, 1)
574.             Next
575.         Next
576.     End If
577.     LoadTestFile = n
578. End Function
579.  
580. Function LoadTestData (alwayszero As Integer)
581.     Dim n As Integer
582.     n = alwayszero
583.  
584.     '''
585.     ' Percussive cases:
586.     '''
587.     'n = n + 1: TestData(n) = "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
588.     'n = n + 1: TestData(n) = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
589.     'n = n + 1: TestData(n) = "0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101"
590.     'n = n + 1: TestData(n) = "1010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010"
591.     'n = n + 1: TestData(n) = "0001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011"
592.     'n = n + 1: TestData(n) = "0100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111"
593.  
594.     '''
595.     ' Human samples:
596.     '''
597.     ' (from Keybone)
598.     n = n + 1: TestData(n) = "101010101010101010101001010101010101001010111001010101010101010101010100010101010101010100101001010101001100101010001010100101010100101010100101010101010101010011011110010101010100100101010110010011001010011001010100010100101010010101010101010010101010101010010101001010101010100110010101010100101010101010011001001010100101010010101010100101010010101001010100101001010010101010111010100110011001010101010100110101001010101010100101001010111010101010101010100101001010101010010101010101001010101001010101001010100101010100101010010101010101001010101001010101010101001010101001010100101010101010010101010010010101010101010101010010100101010101001010100101001010101001111101010101010100101010110011001010101010101010110101010101101010101010100101010010101010010101010101101110010101001010101010110010100101010101001011010101010100110101010100101010010101010100101010101001010101010101001010101010011010101010101110110100101010111010101011011001011001010101001010101010101010101010011001010101010100101010101010101010010100101"
599.     ' (from Keybone)
600.     n = n + 1: TestData(n) = "0101110101100011010100101011001110001011001010001110101111010100111011100100101001010011110101101000101010001010101111001010111010101010100001010101000101101100101111101010010101110110111001000101000011010101010001001001001111101011101010100010110101110101100000101010101110111010100100100001110111100101011110101010001010001110010110111110110010101001001011101000101001011100011101000010101010101101010010110100101101000101111010101110111001010011101111010101000010101111100010101011110101011011110100001010110"
601.     ' (from Loudar)
602.     n = n + 1: TestData(n) = "1011001010010100100100110010101010101001010101010101011010010101001010101001010010100110101011010101010101011010101101010101010101010010110101010101100101010101010110101101011010010101010010100110101101001010110101011010010101101010110100101111010101010011011011010010110101010010110100101101010100101011010010101001010101010001011101011010010101011100111010010001101011110010011010001011100110101010010011010101001001010010000101010110001"
603.     ' (from Luke)
604.     n = n + 1: TestData(n) = "01100101001010001100001101101111011010010101010110110101001000001111001111110101000101111011010101111101010101101010101001010101011000010101010101001011010100110100110100110011010101010101110101010111111101011010100000001101111000010111000110111001000010100001101010110100000111101011111100001011001010110010110"
605.     ' (from Sarafromct)
606.     n = n + 1: TestData(n) = "10101010101011101000011101010111010101010101100111001010100111100001011011110101000001111010101101010000001111110011111110111101110111001110110010000100010101010101010100101011010110101010101010101001000000001111110000011110101010101010100010101110101010101101111111111111111111101010101010101000000"
607.     ' (from Spriggs)
608.     n = n + 1: TestData(n) = "10111010101010101010101001010101010101001010101001010101010101010101010101010101010101010101010101010101001010100100100101010101010101001010100101010101010100101010100101010101010101010101001010010110010101010010101010101010101010101010100101001001001010101010101010101010101001010101001001101010010"
609.     ' (from Spriggs)
610.     n = n + 1: TestData(n) = "11111011110100101011111111110100000011011110101100111100111111110111101110100111100110011111110101111111010111101111100111110111111111111011100111110111111110010000101011111001110101101010110111110"
611.     ' (from Hotpants)
612.     n = n + 1: TestData(n) = "01010100011001010010101010101010101000110101010111101010100100011010101010100100101110010010010100001010101001010101010110010001001011000100100110101001001001010000000001010101101111101001010100010101001001010101000100101001100100010011010101010101010111010010101011101011011010110100100010010100100100010010001001"
613.  
614.     '''
615.     ' Noted sequences:
616.     '''
617.     ' (Wolfram rule 30)
618.     n = n + 1: TestData(n) = "110111001100010110010011101011100111010101100001100101011010101111110000111100010101110000010010110001110001101101101000000010001111101110100111000111010111000001100100011001111001111110000001111111011001011011100000101100011011000110001110110110010101111111011010110110111101110010111011000100000000001101110010110010111100100110000111110000001011011001111001000010011111000001101001011001001011101011000001101001000101001011101011111011000100000011110101000111101001011010001101000111100001000011110001111010"
619.  
620.     LoadTestData = n
621. End Function
622.  
623. ''' Museum:
624. 'Call InitializeModelIndexed(BinaryModelIndex) ' Goes with counter
625. 'Call InitializeModelIndexed(0)                ' Always zero
626. 'Call InitializeModelIndexed(1023)             ' Homogeneous
627. 'Call InitializeModelIndexed(16)               ' This 5-gram case (16) works best for Gaming mode.
628. 'Call InitializeModelIndexed(82)               ' Learning algo discoverd this is a good one against humans.
629. 'Call InitializeModelIndexed(18)               ' Learning algo discoverd this is a good one against humans.
630. 'Call InitializeModelCustom(-1)                ' Enables custom model(s).
631. '''
632.  
633. '''
634. ' Studies in pathology:
635. 'BinaryModelIndex = 2   ' cracked by 124
636. 'BinaryModelIndex = 3   ' cracked by 16
637. 'BinaryModelIndex = 4   ' cracked by 265
638. 'BinaryModelIndex = 5   ' cracked by 736
639. 'BinaryModelIndex = 6   ' cracked by 49
640. 'BinaryModelIndex = 7   ' cracked by 88
641. 'BinaryModelIndex = 8   ' cracked by xxx
642. 'BinaryModelIndex = 9   ' cracked by xxx
643. 'BinaryModelIndex = 10  ' cracked by 644
644. 'BinaryModelIndex = 11  ' cracked by 261
645. '''
646.  

[random1]

STxAxTIC

What if we change the output so that (0)=miss and (1)=hit and then run that string back through
the predictor to see what happens.  Repeat this process as many times as needed to produce the
highest level of accuracy that can be obtained.  Kind of a noise cancellation feedback loop. 

I think the output string shows structure with a little noise thrown in here and there, if we can remove
the noise then then who knows what the results will show.  I have been working on a couple simple
tools but have not figured out how to combine the outputs so that the accuracy improves, so far my
attempts show a negative effect.

Anyway, you seem to have a lot cooking on the back burner so maybe when time permits you can
check it out.

I will bookmark the new link so I can stay abreast of any updates.

R1