QB64.org Forum

Active Forums => QB64 Discussion => Topic started by: random1 on December 07, 2021, 11:37:55 am

Title: Looking for old program or help recreating it
Post by: random1 on December 07, 2021, 11:37:55 am

Many years ago, mid 90's  I came across a sort of sequential prediction tool.
I don't remember the name but it was suppose to show how bad people were
at random.
The program presented the user with two buttons labeled (0) and (1).  The user
would select one of the two and then the program would try to predict the users
selection.  The more a person played the better it got at predicting.  The users
input was held until after the prediction was made then it would be added to the
the predictors data string.
I did not understand the code back then but held on to it for many years thinking
it could come in handy.  I changed computers many times since then and the
source code got lost in the process.  It was written using qb45 is about all I can
remember.
I have a tool that processes around 800 binary strings and I thought this tool
might come in handy to test the randomness of the data.  The strings are just
a series of zeros and ones, either the event true=1 or false=0.

Anyway, looking for anyone knowledgeable in this sort of thing to post a few
ideas including source code.  The program could also include a 3rd state for
whenever no clear prediction could be made.  I use a wildcard (*)   

Small data sample
0001000001011100000011000100011000010010000000000000000011000000000000000001110010000000000001111000000001001110000000000000100000000011110000000000000000000000000000010100000000000000000100000000000000110001111000010001000000000000000000011010000000000000000010001101100000100001000000110011000011010010000000000000000000100001000011000110001010000000100000000000000000000000000000000000010000000000100000000000000010100000100000000000000000000000000000000000100001000000000000000010110100000000000010010000000000000000000100000000001100000011000000000000000000000000000000110010000110000100000   

Thanks R1
 

Title: Re: Looking for old program or help recreating it
Post by: bplus on December 07, 2021, 11:43:35 am

I think I saw a program like that for Rock, Paper, Scissors at a Basic forum. Might try that for searches.

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 07, 2021, 03:08:49 pm

All rock, paper, scissors that I have ever seen just use a random number generator
to select one of the options.

What I am looking for is more a learning algorithm for forecasting / prediction.
The app I mentioned learnt from the users inputs and used user data to predict the
users next choice.

My idea was to swap the user input with data strings and automate the process.  What I
am using now and how it works.

First it takes a number of random samples from within the string, both the number of samples
and the length of each sample are set within a configuration menu. Around 350 works best for
the number of samples along with a sample size of 8 to 25 digits, user defined.

Next it calculates ratios for ones vs zeros for each sample. This allows me to calculate a sort
of running average.  The overall totals for the main data string are calculated before the data
is fed into the predictor and the probabilities are used to help calculate a weight which is then
used in the final prediction.
   
The final prediction is made by looking at a sample taken from the last so many entries -1
so if the sample length is 25 then it collects the last 24 and then adds one to the zero count
and calculates the ratio then the same thing is done again adding a one to the ones count.

Whichever comes closest to the running average +/- the weight is the predicted value.  It's
sort of a best fit model.

If I remember correctly the program I mentioned at the head of the topic reached over a 80%
hit rate in less than 100 plays when looking at the last 10 or so attempts.

The program mentioned uses random choices at first until it had enough data to feed the prediction algorithm.

The more games played the better it got at predicting users next choice.  At the time I was not
able to figure out how the algorithm worked as it's code was way above my skill level.

I am starting a new predictor project and welcome any input from others.  Some of the 800 plus
data strings I use are too random to be of any use while others are not.  My goal is to find around
25 out of the 800 that can be predicted with a high degree of consistency. 

R1

Title: Re: Looking for old program or help recreating it
Post by: bplus on December 07, 2021, 03:51:38 pm

Yeah the RPS thing was an AI or NeuroNet that picked up patterns and was to show how badly humans played Rock, Paper, Scissors because humans are bad at randomness.

I like this challenge, I will try an approach I used here:
https://www.qb64.org/forum/index.php?topic=2122.0

Title: Re: Looking for old program or help recreating it
Post by: bplus on December 07, 2021, 04:45:29 pm

At first I thought this was crap, then I saw a > sign turned the wrong way!

I get better than average for AI:

Code: QB64: [Select]

1. _Title "Predicting Human Randomness" 'b+ 2021-12-07
2. Randomize Timer
3. Do
4.     If Len(s$) < 8 Then
5.         If Rnd < .5 Then AI$ = "H" Else AI$ = "T"
6.     Else
7.         sum = 0: count = 0
8.         match$ = Mid$(s$, Len(s$) - 7, 7)
9.         place = InStr(s$, match$)
10.         While place <> 0 And place < Len(s$) - 7
11.             count = count + 1
12.             char$ = Mid$(s$, place + 8, 1)
13.             If char$ = "H" Then sum = sum + 1
14.             place = InStr(place + 1, s$, match$)
15.         Wend
16.         If count Then
17.             Sound 500, 1  ' >>>>>>>>>>>>>>>>>>>>>>>>>>> this signals it found at least one match
18.             ' >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> check how it does after the sound
19.             If sum / count > .5 Then AI$ = "H" Else AI$ = "T"
20.         Else
21.             If Rnd > .5 Then AI$ = "H" Else AI$ = "T"
22.         End If
23.     End If
24.     Input "Enter H or T "; p$
25.     p$ = UCase$(p$)
26.     If p$ = "H" Or p$ = "T" Then s$ = s$ + p$ Else Exit Do
27.     Print "AI predicted "; AI$
28.     If AI$ = p$ Then ai = ai + 1
29.     Print "AI is correct "; 100 * ai / Len(s$); "% times."
30. Loop
31. Print s$
32. Print "AI is correct "; 100 * ai / Len(s$); "% times."
33. Print "Goodbye!"
34. Beep 'sorry I get crazy doing h enter, t enter
35. Sleep
36. Beep
37. Sleep
38.  
39.  

Sure if you see what AI is doing you can break it but how about not looking... ;-))

Title: Re: Looking for old program or help recreating it
Post by: bplus on December 07, 2021, 05:20:22 pm

Ran code 1,000,000 times several times.  AI is 50% +- <1% against a Rnd selection for H or T.

Title: Re: Looking for old program or help recreating it
Post by: George McGinn on December 07, 2021, 05:51:50 pm

Human behavior has more patterns that just a random generator.

I vaguely remember that program from way back. If I recall, it used statistical probabilities based on past patterns, such as if the human hits Key A always or most of the time when pressing Key B twice in a row, etc, it used a crude AI to be more predictive.

I had a program that I wrote for Roulette back in the 1990's (I only found my first release of it on 3 1/2 floppies when I wrote it as shareware back in 1990) that determined basic patterns for RED/BLACK and groups of numbers, and against a real wheel I had back then, it was more than 50-50 (like 60% correct). But iPhone didn't exist back then, so I could not drag a large PC into a casino. Instead, I had my program analyze the wheel and betting layout, and came up with a set up numbers and bets to play that makes it very hard for the ball to find an open spot. (DM me if you want these, I have them somewhere)

I never won big money with it, but it made trips to AC and Vegas more enjoyable. Baccarat, that's a different story.

I should re-invent it now that iPhones do exist!  Hmmmm...

I bet we can come up with a better predictive AI today. Just a matter of how much time one's willing to spend on coding --- could make for an interesting QB64 game.

Title: Re: Looking for old program or help recreating it
Post by: cfalcon030 on December 07, 2021, 06:56:08 pm

If you don't mind me asking, what is your end goal? If it's to determine the randomness of your sample data you will need a different algorithm like a Runs test and not a predictive algorithm.
https://en.m.wikipedia.org/wiki/Wald%E2%80%93Wolfowitz_runs_test

Title: Re: Looking for old program or help recreating it
Post by: bplus on December 07, 2021, 07:12:12 pm

My goal was to try and catch humans (myself) being predictable when I try to be random.

I think if you get an AI that does better than 60% you've got something that catches patterns in human play.

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 07, 2021, 07:41:09 pm

This discussion is 90% similar to a thing we studied once, but I took it overboard. I think this handworked example shows a way to answer this question without bogging you guys down with weird notation:

 [ This attachment cannot be displayed inline in 'Print Page' view ]  

tldr: there is a 1/4096 chance that this string was hammered out randomly on a keyboard:  0 1 0 0 1 1 0 0 1 1 1 0 0 1 0 0 1 1 0 0 1 1 1 0

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 08, 2021, 12:19:30 am

My goal
Whatever code we can come up with, I have the methods to test it's effectiveness.

What I am looking for is a method to predict the next digit using the data string history
to make the prediction.  Everything else has already been coded, ie the before and after
code

Whatever I end up using will be part of a universal forecast / prediction tool.

When I coded the main program I done it in such a way that I can swap out the
predictor code without making any other changes.  The input string is named
Dat1$ and the predictors output variable is PV1$.  Anyone with the time to take
a stab at it can use these two variables for input and output.  Name any other
variables whatever you want.  If your code requires fine tuning of any of the
other variables then supply a list and I will add them to the configuration menu
where they can be adjusted.

The main program is already coded to do all the pre & post processing.  It's fully
functional and uses a prng to simulate the predicted value.  I always do this first
to test the code and secondly to get a base line to measure the predictors output. 
Any good predictor should be able to beat the prng's output.

Like I said, I start with over 800 data strings which are fed to the predictor one at a
time in hopes of finding maybe 25 that are mostly predictable.     

The configuration menu allows adjusting up to 10 constants that may be used by the
predictor for fine tuning.  These include but are not limited to, the number of data points,
# of samples to use, length of each sample, weights, trigger threshold etc...   

For development data just generate random strings 0's and 1's around 3000 to 5000
digits in length.  I will test any posted code against real data and report the results.

Thanks in advance

R1
 
   

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 08, 2021, 12:57:27 am

This is a cool question. Maybe there's a Markov chain-like hack that can be done to help with this, but I'm still maybe... call it 66% sure that the method I described above can handle this.

The Argument: If the user is doing some kind of pattern apart from randomness when they type, then the pattern may be detectable in any number of "frequencies", which means to say, detectable by looking at "clusters of N digits". For this problem, realistic values of N may be from 2 to say, 10.

The Method: we can define different "alphabets" based on clusters of 1's and 0's in groups of N. For N=2, we have a 4-letter alphabet 00, 01, 10, 11. For N=3, there are quite a few more "letters", i.e. 000, 001, 010, 011, etc etc , 110, 111. I call these clusters "letters" because you should think of each cluster as *one* symbol. Without driving the connection too hard, we can say A=00, B=01, C=10, D=11. Or further, choosing a different set of letters for N=3, a=000, b=001, c=010, etc etc.

With me so far? A big string of 1's and 0's as you have given can be translated into a string made of letters ABCD, which will have half the length as the original. Or, express the original string of 1's and 0's using the N=3 letters to get a shorter translation. Each translation carries the same information, of course. The point is, you can easily see which "letters" are repeated, which are ignored, so on and so forth. It's definitely a way to go. I may try it!

I don't want us to talk past each other though cause if I solve this thing I need an audience of N>0.

------------------------------

BUT, that's a lot of work. I think the cheapest, least airtight but nontrivial way to do this uses one variable and one rule: "once the user feels they have repeated themselves X times", remember X.

Title: Re: Looking for old program or help recreating it
Post by: Dimster on December 08, 2021, 11:08:14 am

Just looking at your sample set, you could just total the number of times a "0" was selected v's a "1". In your sample set the "0" out numbers the "1" by a large margin. So predicting a "0" at the beginning your program would be correct more times than it's wrong. If "0" is the predominant then that becomes the goto prediction and the program then just needs to watch for the pattern of the "1". ie, if a "1" then how often is the very next select another "1". So you just need the program to decide on when to predict a "1". We all have predictable behaviors. I would think, if you had a moving average for the selection of "1" your program could determine if the user is increasing or deceasing the selection of "1". Not that this kind of pattern prediction would be correct all the time but it could be correct more times than it would be wrong. This approach is not that sophisticated, such a program would not be a true Artificial Intelligent predictor of human behavior because there are only the two inputs (like a flip of a coin). Neither does it "learn" so I'd guess it would plateau in it's effectiveness of correct predictions and be very slow to adapt to the user's change in strategy of selection/repeat selections. But given enough data in the moving average it could adapt as well.

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 08, 2021, 07:17:17 pm

Dimster

All the strings have different ratios of 0's and 1's.  Some work out to 90/10 and your correct that
playing the value with the highest ratio in these cases would produce the most hits.  I am looking
for something that can take into account several factors such as runs of 0's or 1's, frequency, etc.
and then make it's prediction based on these factors. 

STxAxTIC
My manual analysis uses Markov chains and allows searching for strings within the chain.  See the
attached picture

These work well enough, it's the time that it takes, that's the problem.  After 10 or so analysis my mind
is worn out so to say processing the data.  I have a automated version of the Markov string analysis but
it needs some help or a sort of a decision tree to make the final prediction. 

No one piece of information is good enough to base a prediction on, I tried coding a decision tree with no
success as it too needs some sort of learning algorithm that combines the data into experts before
making it's choices.   

In the attached image, looking at the top string of data, you can see the first 4 values highlighted in
blue.  The tool searches the entire string looking for an exact match.  Whenever if finds a match it
records the value preceding the selected pattern.  The second string shows the results of the search

Only a small portion of the main data string is visible in the tools window.  The second string and the graph at the bottom show the results of the search string.  You can also see a simple set of statistics for the returned results. 

Shows (0)= the number of times 0 appears within the results
Out = it's last appearance
Avg= average
L/R = longest run
Probability
STC = short trend shows
Exp = the number of times the value is expected to show in a shortened data set.  It's calculated
using the overall probability * the short trend.  I think stc is set to 20.  You can see by this value
how well the results track with the overall.  If this value is different, ie, higher or lower than it's
expected value than it;s a good indicator to include in the prediction process.
   
The values are displayed for both 0's and 1's.  The color graph is there because it's easier on the eyes
than looking at the 0&1's string.

One approach would be to increase the number of statistical observations and then code some
sort of a decision tree to make the final choice.  The values shown are not sufficient so more
are needed.   In the automated tool I am building all these plus others are planned as part of
the final prediction.
The tool in the picture allows for adding and subtracting digits in the search string, if a person
only knew when to stop, LOL.
 

https://i.postimg.cc/NjvwW9KL/markov-analysis.png (https://i.postimg.cc/NjvwW9KL/markov-analysis.png) 
   

Thanks Again
R1

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 08, 2021, 07:52:29 pm

Something else I find interesting.  The results string shows 95 results.  Any 4 digit binary string
has 16 possible arrangements of 0's and 1's.   The expected average for any one pattern of four
digits is 95/16=6, rounded.  In the picture we can see that the pattern 0110 appears 8 times
which equals  .084 vs the expected .063.  Is this usable, maybe, maybe not.

https://i.postimg.cc/4dgDSryM/ma-2.png (https://i.postimg.cc/4dgDSryM/ma-2.png)

R1

Edit
I missed a, 0110 in the search results, it appears 9 times for .094 hit rate

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 08, 2021, 08:12:40 pm

Hey @random1

I'll look a little more deeply into your attempts right after I post this, but I want you let you know I'm cracking this problem pretty easily based on a previous work of mine. I want to bring you on board with this. So please consider this random string:

"010010010100100101010100101010101010101010101101101010101001111101010101010101010101001010101010"

Qualitatively, what I tried to do was just mash 1 and 0 in a sloppy left-right fashion. Sure, there are clusters of 0's and 1's, no problem. But the overall dominating pattern, particularly at the end, is alternating 0's and 1's. So, can we make a program to detect that? Absolutely yes. The model is fully general and will detect any pattern at any frequency up to n=5 characters at a time, but one can easily make this bigger. See if you can make sense of the code below. I didn't explain it much here, but the stuff I was saying above is implemented in this code. You can see that there will be numbers accumulating next to common patterns in the test string. Super fast, super systematic, will answer your question... Lemme know what you think before this code gets too far ahead. I'll quit til I hear back.

Code: QB64: [Select]

1. Screen _NewImage(800, 800, 32)
2.  
3. Type Letter
4.     Signature As String
5.     Count As Integer
6. End Type
7.  
8. Dim Shared Alphabet1(2) As Letter
9. Alphabet1(1).Signature = "0"
10. Alphabet1(2).Signature = "1"
11.  
12. Dim Shared Alphabet2(4) As Letter
13. Alphabet2(1).Signature = "00"
14. Alphabet2(2).Signature = "01"
15. Alphabet2(3).Signature = "10"
16. Alphabet2(4).Signature = "11"
17.  
18. Dim Shared Alphabet3(8) As Letter
19. Alphabet3(1).Signature = "000"
20. Alphabet3(2).Signature = "001"
21. Alphabet3(3).Signature = "010"
22. Alphabet3(4).Signature = "011"
23. Alphabet3(5).Signature = "100"
24. Alphabet3(6).Signature = "101"
25. Alphabet3(7).Signature = "110"
26. Alphabet3(8).Signature = "111"
27.  
28. Dim Shared Alphabet4(16) As Letter
29. Alphabet4(1).Signature = "0000"
30. Alphabet4(2).Signature = "0001"
31. Alphabet4(3).Signature = "0010"
32. Alphabet4(4).Signature = "0011"
33. Alphabet4(5).Signature = "0100"
34. Alphabet4(6).Signature = "0101"
35. Alphabet4(7).Signature = "0110"
36. Alphabet4(8).Signature = "0111"
37. Alphabet4(9).Signature = "1000"
38. Alphabet4(10).Signature = "1001"
39. Alphabet4(11).Signature = "1010"
40. Alphabet4(12).Signature = "1011"
41. Alphabet4(13).Signature = "1100"
42. Alphabet4(14).Signature = "1101"
43. Alphabet4(15).Signature = "1110"
44. Alphabet4(16).Signature = "1111"
45.  
46. Dim Shared Alphabet5(32) As Letter
47. Alphabet5(1).Signature = "00000"
48. Alphabet5(2).Signature = "00001"
49. Alphabet5(3).Signature = "00010"
50. Alphabet5(4).Signature = "00011"
51. Alphabet5(5).Signature = "00100"
52. Alphabet5(6).Signature = "00101"
53. Alphabet5(7).Signature = "00110"
54. Alphabet5(8).Signature = "00111"
55. Alphabet5(9).Signature = "01000"
56. Alphabet5(10).Signature = "01001"
57. Alphabet5(11).Signature = "01010"
58. Alphabet5(12).Signature = "01011"
59. Alphabet5(13).Signature = "01100"
60. Alphabet5(14).Signature = "01101"
61. Alphabet5(15).Signature = "01110"
62. Alphabet5(16).Signature = "01111"
63. Alphabet5(17).Signature = "10000"
64. Alphabet5(18).Signature = "10001"
65. Alphabet5(19).Signature = "10010"
66. Alphabet5(20).Signature = "10011"
67. Alphabet5(21).Signature = "10100"
68. Alphabet5(22).Signature = "10101"
69. Alphabet5(23).Signature = "10110"
70. Alphabet5(24).Signature = "10111"
71. Alphabet5(25).Signature = "11000"
72. Alphabet5(26).Signature = "11001"
73. Alphabet5(27).Signature = "11010"
74. Alphabet5(28).Signature = "11011"
75. Alphabet5(29).Signature = "11100"
76. Alphabet5(30).Signature = "11101"
77. Alphabet5(31).Signature = "11110"
78. Alphabet5(32).Signature = "11111"
79.  
80.  
81. Call ResetCount
82.  
83. Dim FingerPrint(6) As String
84.  
85. FingerPrint(1) = "010010010100100101010100101010101010101010101101101010101001111101010101010101010101001010101010"
86.  
87. For n = 2 To UBound(FingerPrint)
88.     FingerPrint(n) = Right$(FingerPrint(n - 1), Len(FingerPrint(n - 1)) - 1) + Left$(FingerPrint(n - 1), 1)
89. Next
90.  
91. For m = 1 To 2
92.     For n = 1 To Len(FingerPrint(m)) Step 2
93.         a$ = Mid$(FingerPrint(m), n, 2)
94.         For k = 1 To UBound(Alphabet2)
95.             If a$ = Alphabet2(k).Signature Then
96.                 Alphabet2(k).Count = Alphabet2(k).Count + 1
97.             End If
98.         Next
99.     Next
100.  
101.     For k = 1 To UBound(Alphabet2)
102.         Locate k, 1 + 12 * (m - 1)
103.         Print Alphabet2(k).Signature; Alphabet2(k).Count
104.     Next
105.  
106.     Sleep
107. Next
108.  
109. Cls
110.  
111. For m = 1 To 3
112.     For n = 1 To Len(FingerPrint(m)) Step 3
113.         a$ = Mid$(FingerPrint(m), n, 3)
114.         For k = 1 To UBound(Alphabet3)
115.             If a$ = Alphabet3(k).Signature Then
116.                 Alphabet3(k).Count = Alphabet3(k).Count + 1
117.             End If
118.         Next
119.     Next
120.  
121.     For k = 1 To UBound(Alphabet3)
122.         Locate k, 1 + 12 * (m - 1)
123.         Print Alphabet3(k).Signature; Alphabet3(k).Count
124.     Next
125.  
126.     Sleep
127. Next
128.  
129. Cls
130.  
131. For m = 1 To 4
132.     For n = 1 To Len(FingerPrint(m)) Step 4
133.         a$ = Mid$(FingerPrint(m), n, 4)
134.         For k = 1 To UBound(Alphabet4)
135.             If a$ = Alphabet4(k).Signature Then
136.                 Alphabet4(k).Count = Alphabet4(k).Count + 1
137.             End If
138.         Next
139.     Next
140.  
141.     For k = 1 To UBound(Alphabet4)
142.         Locate k, 1 + 12 * (m - 1)
143.         Print Alphabet4(k).Signature; Alphabet4(k).Count
144.     Next
145.  
146.     Sleep
147. Next
148.  
149. Cls
150.  
151. For m = 1 To 5
152.     For n = 1 To Len(FingerPrint(m)) Step 5
153.         a$ = Mid$(FingerPrint(m), n, 5)
154.         For k = 1 To UBound(Alphabet5)
155.             If a$ = Alphabet5(k).Signature Then
156.                 Alphabet5(k).Count = Alphabet5(k).Count + 1
157.             End If
158.         Next
159.     Next
160.  
161.     For k = 1 To UBound(Alphabet5)
162.         Locate k, 1 + 12 * (m - 1)
163.         Print Alphabet5(k).Signature; Alphabet5(k).Count
164.     Next
165.  
166.     Sleep
167. Next
168.  
169. End
170.  
171. Sub ResetCount
172.     For n = 1 To UBound(Alphabet1)
173.         Alphabet1(n).Count = 0
174.     Next
175.     For n = 1 To UBound(Alphabet2)
176.         Alphabet2(n).Count = 0
177.     Next
178.     For n = 1 To UBound(Alphabet3)
179.         Alphabet3(n).Count = 0
180.     Next
181.     For n = 1 To UBound(Alphabet4)
182.         Alphabet4(n).Count = 0
183.     Next
184. End Sub

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 08, 2021, 08:24:42 pm

Alright, I couldn't resist running your sample data string into my program. I can see you picked a weird sequence, but I highlighted the most indicative numbers (as of now)... see if any of that seems useful, seeing how you studied that string extensively, I bet:

Code: [Select]

0001000001011100000011000100011000010010000000000000000011000000000000000001110010000000000001111000000001001110000000000000100000000011110000000000000000000000000000010100000000000000000100000000000000110001111000010001000000000000000000011010000000000000000010001101100000100001000000110011000011010010000000000000000000100001000011000110001010000000100000000000000000000000000000000000010000000000100000000000000010100000100000000000000000000000000000000000100001000000000000000010110100000000000010010000000000000000000100000000001100000011000000000000000000000000000000110010000110000100000   
  [ This attachment cannot be displayed inline in 'Print Page' view ]  

Oh, and if I was to finish coding the program, I would have it predict a 0 for the next digit.

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 08, 2021, 09:58:35 pm

I feel I need to elaborate a little more.  Look at the second image and pay attention
to the 0110 patterns within the results string that are highlighted in green.  Counting
the one I missed there are 9.  The data flows from right to left with the latest entries
on the left.  If we look at the results string from right to left we notice that the following
digit after each 0110 pattern is a (1).  This is what I would classify as an Expert. 

I would have no reservations predicting digit 1 as the next value in the string.  Each
string has to be analyzed to try and find it's own expert.  And each expert should be
assigned a confidence level between 0 and .99.  It's also that more than one expert
can be found through our analysis.  The search pattern should always be taken from
the left most part of the string because that's what we are looking for to make the
next prediction.   The experts if any will change day to day most of the time so it's
important to be able to find them on the fly so to say. 

The possibilities are almost limitless as to what we might use to construct a prediction
model so try to think outside the box.  Anyway, I hope the information I have presented
here helps to kick start other ideas.

R1     
           

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 08, 2021, 10:04:15 pm

I'll keep looking at what you're attempting but do you not agree that the program above assigns "0110" a somewhat high "score"? (It would be on the previous screen, not in the screenshot itself, which has the 5 digit analysis.) There are few more common strings, such as "0000", so that truth is up there too.

Let me ask, what is the end result of this? You want an Eliza-like program that tries to guess what my next number is, and then honestly reports the guess after I finally make my choice? Cause that's where I thought you were going.

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 08, 2021, 10:09:47 pm

 STxAxTIC

I will have to look up the string I posted to see what the next value was as it's been
updated a couple times since I posted it.  I should have kept a note of which string I
used.  My program copies each string I look at to the clipboard automatically and I
just selected one at random.  If/when you finish your code so that it makes a 0 or 1
prediction I will run it against all 800 + strings and report back to it's overall hit rate.
Many thanks for posting.

R1

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 08, 2021, 10:28:43 pm

The main goal is to produce a universal prediction tool.  The 0110 is nothing more than
the values of the last 4 entries.  The string changes day to day and when using the first
4 digits then we have 16 possibilities but each day the sequence is determined by the
events I track.  Each string is updated daily by adding a 0 or 1 to the string.  if the event
accrued then a 1 is added if not then a 0.  The reason I mentioned the old program  was
my interest in the algorithm it used.  I was wondering how it would stack up as a predictor
against my data.  Instead of me imputing one digit at a time I would feed it a string of
3k to 5k in length and see how successful it was.   It seems to me if the method it used
could predict my next choice then given enough data it might be useful to my current
project.  I am not building a game, I wanted to repurpose the code into something useful. 
 
Sorry if I was not clear in this.

R1

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 08, 2021, 10:50:03 pm

P.S.  I track over 800 events each day so I have over 800 strings that I try to predict.
Standard prediction tools don't work, I've tried all sorts of methods and figure I needed
to start thinking outside the box if it's going to be successful.

Anyway, that's where I am at.   My last attempt failed and it was sometimes hitting
over 80% correct.  The problem was that the tool was not consistent enough to meet
my needs. This has been a ongoing project that I have been working on for years.

R1   

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 08, 2021, 11:32:10 pm

I may have to do a video or something on this because the details are getting a bit hard to convey. Anyway, I updated the code to be much more powerful, and I'm attaching a screenshot that outlines one possible good analysis. If we want to continue this, we need to pick a dataset that we'll both use and come up with definite questions about the data that we could use our methods to answer. (Statistical stuff can't really be trusted.) Anyway, here's where it stands on my end. I may do something less lazy than a weighted average at the end, but for now it's getting there:

Code: QB64: [Select]

1. Type Letter
2.     Signature As String
3.     Count As Integer
4. End Type
5.  
6. Dim Shared Alphabet1(2) As Letter
7. Alphabet1(1).Signature = "0"
8. Alphabet1(2).Signature = "1"
9.  
10. Dim Shared Alphabet2(4) As Letter
11. Dim Shared Alphabet3(8) As Letter
12. Dim Shared Alphabet4(16) As Letter
13. Dim Shared Alphabet5(32) As Letter
14. Dim Shared Alphabet6(64) As Letter
15. Dim Shared Alphabet7(128) As Letter
16. Dim Shared Alphabet8(256) As Letter
17.  
18. Call NewAlphabet(Alphabet1(), Alphabet2())
19. Call NewAlphabet(Alphabet2(), Alphabet3())
20. Call NewAlphabet(Alphabet3(), Alphabet4())
21. Call NewAlphabet(Alphabet4(), Alphabet5())
22. Call NewAlphabet(Alphabet5(), Alphabet6())
23. Call NewAlphabet(Alphabet6(), Alphabet7())
24. Call NewAlphabet(Alphabet7(), Alphabet8())
25.  
26. Dim Shared FingerPrint(16) As String
27.  
28. 'FingerPrint(1) = "010010010100100101010100101010101010101010101101101010101001111101010101010101010101001010101010"
29. FingerPrint(1) = "0001000001011100000011000100011000010010000000000000000011000000000000000001110010000000000001111000000001001110000000000000100000000011110000000000000000000000000000010100000000000000000100000000000000110001111000010001000000000000000000011010000000000000000010001101100000100001000000110011000011010010000000000000000000100001000011000110001010000000100000000000000000000000000000000000010000000000100000000000000010100000100000000000000000000000000000000000100001000000000000000010110100000000000010010000000000000000000100000000001100000011000000000000000000000000000000110010000110000100000"
30.  
31. For n = 2 To UBound(FingerPrint)
32.     FingerPrint(n) = Right$(FingerPrint(n - 1), Len(FingerPrint(n - 1)) - 1) + Left$(FingerPrint(n - 1), 1)
33. Next
34.  
35. Call UpdateHisto(Alphabet2(), 2)
36. Call PrintHisto(Alphabet2())
37.  
38. Call UpdateHisto(Alphabet3(), 3)
39. Call PrintHisto(Alphabet3())
40.  
41. Call UpdateHisto(Alphabet4(), 4)
42. Call PrintHisto(Alphabet4())
43.  
44. Call UpdateHisto(Alphabet5(), 5)
45. Call PrintHisto(Alphabet5())
46.  
47. Call UpdateHisto(Alphabet6(), 6)
48. Call PrintHisto(Alphabet6())
49.  
50. Call UpdateHisto(Alphabet7(), 7)
51. Call PrintHisto(Alphabet7())
52.  
53. Call UpdateHisto(Alphabet8(), 8)
54. Call PrintHisto(Alphabet8())
55.  
56. End
57.  
58. Sub UpdateHisto (arr() As Letter, w As Integer)
59.     For m = 1 To w
60.         For n = 1 To Len(FingerPrint(m)) Step w
61.             a$ = Mid$(FingerPrint(m), n, w)
62.             For k = 1 To UBound(arr)
63.                 If a$ = arr(k).Signature Then
64.                     arr(k).Count = arr(k).Count + 1
65.                 End If
66.             Next
67.         Next
68.     Next
69. End Sub
70.  
71. Sub PrintHisto (arr() As Letter)
72.     Call BubbleSort(arr())
73.     For k = UBound(arr) To 1 Step -1
74.         Print arr(k).Signature; arr(k).Count
75.     Next
76.     Sleep
77.     Cls
78. End Sub
79.  
80. Sub NewAlphabet (arrold() As Letter, arrnew() As Letter)
81.     n = 0
82.     For j = 1 To 2
83.         For k = 1 To UBound(arrold)
84.             n = n + 1
85.             arrnew(n).Signature = arrold(k).Signature
86.         Next
87.     Next
88.     For k = 1 To UBound(arrnew)
89.         If k <= UBound(arrnew) / 2 Then
90.             arrnew(k).Signature = "0" + arrnew(k).Signature
91.         Else
92.             arrnew(k).Signature = "1" + arrnew(k).Signature
93.         End If
94.     Next
95. End Sub
96.  
97. Sub BubbleSort (arr() As Letter)
98.     Dim As Integer i, j
99.     Dim As Double u, v
100.     For j = UBound(arr) To 1 Step -1
101.         For i = 2 To UBound(arr)
102.             u = arr(i - 1).Count
103.             v = arr(i).Count
104.             If (u < v) Then
105.                 Swap arr(i - 1), arr(i)
106.             End If
107.         Next
108.     Next
109. End Sub

  [ This attachment cannot be displayed inline in 'Print Page' view ]  

Title: Re: Looking for old program or help recreating it
Post by: SMcNeill on December 09, 2021, 12:42:58 am

What you're trying to do, it sounds like, is basically what this guy over at Numberphile talks about.  Take a look at the video.  I think you might like it and it might give you some insight into what your program needs to have to be a human sequence tester.

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 09, 2021, 01:47:53 am

Yeah, this guy's ^ in the same ballpark, mostly. This whole topic does make me sigh just a little, like am I the only one who remembers doing work like this with you guys (Steve, bplus) like 2 years ago? We were able to detect ordered strings hidden in a bunch of randomness. That old problem, the video above, the present problem - all the same ballpark. In fact, the topic of the video is quite a bit simpler than the thing we're doing. (Just run the guy's string of H and T through my code and see the uneven distributions.) Anyway, thanks for bringing that up Steve. I'm gonna keep playing this this 'cause I'm not sure if I'm being thorough enough in my explanations.

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 09, 2021, 07:39:45 am

Okay so @random1...

For the sake of setting the bar somewhere, consider this data set:

Code: [Select]

string = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": nextdigit = "0"
'
string = "01010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101": nextdigit = "0"
string = "10101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010": nextdigit = "1"
'
string = "00100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100": nextdigit = "1"
string = "01001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001": nextdigit = "0"
string = "10010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010": nextdigit = "0"
'
string = "00010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001": nextdigit = "0"
string = "00100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010": nextdigit = "0"
string = "01000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100": nextdigit = "0"
string = "10001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000": nextdigit = "1"
'
string = "00001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000": nextdigit = "0"
string = "00010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000": nextdigit = "1"
string = "00100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001": nextdigit = "0"
string = "01000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010": nextdigit = "0"
string = "10000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100": nextdigit = "0"
'
string = "00000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100": nextdigit = "0"
string = "00001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000": nextdigit = "0"
string = "00010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000": nextdigit = "0"
string = "00100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000": nextdigit = "1"
string = "01000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001": nextdigit = "0"
string = "10000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010": nextdigit = "0"
'
string = "00000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100": nextdigit = "0"
string = "00100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000": nextdigit = "1"
'
string = "00000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001": nextdigit = "0"
string = "10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000": nextdigit = "1"
'
string = "00110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011": nextdigit = "0"
string = "01100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110": nextdigit = "0"
string = "11001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100": nextdigit = "1"
string = "10011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001": nextdigit = "1"
'
string = "00011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100": nextdigit = "0"
string = "00111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000": nextdigit = "1"
string = "01110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001": nextdigit = "1"
string = "11100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011": nextdigit = "1"
string = "11000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111": nextdigit = "0"
string = "10001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110": nextdigit = "0"
'
string = "01001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100": nextdigit = "0"
string = "10011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000": nextdigit = "1"
string = "00110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001": nextdigit = "1"
string = "01100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011": nextdigit = "1"
string = "11000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111": nextdigit = "0"
string = "10001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110": nextdigit = "1"
string = "00011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101": nextdigit = "0"
'
string = "01001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001": nextdigit = "0"
string = "10010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010": nextdigit = "1"
string = "00101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101": nextdigit = "0"
string = "01010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010": nextdigit = "1"
string = "10101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101": nextdigit = "0"
string = "01010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010": nextdigit = "1"
string = "10101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101": nextdigit = "0"
string = "01010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010": nextdigit = "0"
string = "10101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100": nextdigit = "0"
string = "01010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000": nextdigit = "1"
string = "10100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001": nextdigit = "1"
What we've got is a nice bunch of patterns of zero and ones. In each case, even for the ugly later cases, there is always a pattern going on, and I specified the correct next digit in a separate string. This is the kind of data set I would need to test a method I would come up with. Come up with a guess, square it off against the known result. So before reading on, my fast question to you is: How well will your methods predict the so-called "next digit" in each of these? Will that take long? Give it a shot for me.

-----

The code below gets every single one of those examples correct, with the exception of *one* case, and that's because I had to nerf my code down to make sure it wasn't somehow giving an "always right" bug. I needed to see *one* mistake take place, so I contrived a case that I knew could trick it (it takes place right before the end). Alas, it doesn't need to be this way, there is no flaw in the method that I can see - it'll just have to run slightly slower to be 100% perfect. But anyway, here is the bar. Call it 99% "perfect" for the data being used:

Code: QB64: [Select]

1. Type Letter
2.     Signature As String
3.     Count As Integer
4. End Type
5.  
6. Dim Shared FingerPrint(16) As String
7.  
8. Dim Shared Alphabet1(2) As Letter
9. Alphabet1(1).Signature = "0"
10. Alphabet1(2).Signature = "1"
11.  
12. Dim Shared Alphabet2(4) As Letter
13. Dim Shared Alphabet3(8) As Letter
14. Dim Shared Alphabet4(16) As Letter
15. Dim Shared Alphabet5(32) As Letter
16. Dim Shared Alphabet6(64) As Letter
17. Dim Shared Alphabet7(128) As Letter
18. Dim Shared Alphabet8(256) As Letter
19. Dim Shared Alphabet9(512) As Letter
20. Dim Shared Alphabet10(1024) As Letter
21. Dim Shared Alphabet11(2048) As Letter
22. Dim Shared Alphabet12(4096) As Letter
23. 'Dim Shared Alphabet13(8192) As Letter
24.  
25. Call NewAlphabet(Alphabet1(), Alphabet2())
26. Call NewAlphabet(Alphabet2(), Alphabet3())
27. Call NewAlphabet(Alphabet3(), Alphabet4())
28. Call NewAlphabet(Alphabet4(), Alphabet5())
29. Call NewAlphabet(Alphabet5(), Alphabet6())
30. Call NewAlphabet(Alphabet6(), Alphabet7())
31. Call NewAlphabet(Alphabet7(), Alphabet8())
32. Call NewAlphabet(Alphabet8(), Alphabet9())
33. Call NewAlphabet(Alphabet9(), Alphabet10())
34. Call NewAlphabet(Alphabet10(), Alphabet11())
35. Call NewAlphabet(Alphabet11(), Alphabet12())
36. 'Call NewAlphabet(Alphabet12(), Alphabet13())
37.  
38. Dim n As Integer
39. n = 0
40. ReDim Shared TheInput(1000, 2) As String
41.  
42. n = n + 1: TheInput(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TheInput(n, 2) = "0"
43. '
44. n = n + 1: TheInput(n, 1) = "01010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101": TheInput(n, 2) = "0"
45. n = n + 1: TheInput(n, 1) = "10101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010": TheInput(n, 2) = "1"
46. '
47. n = n + 1: TheInput(n, 1) = "00100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100": TheInput(n, 2) = "1"
48. n = n + 1: TheInput(n, 1) = "01001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001": TheInput(n, 2) = "0"
49. n = n + 1: TheInput(n, 1) = "10010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010": TheInput(n, 2) = "0"
50. '
51. n = n + 1: TheInput(n, 1) = "00010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001": TheInput(n, 2) = "0"
52. n = n + 1: TheInput(n, 1) = "00100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010": TheInput(n, 2) = "0"
53. n = n + 1: TheInput(n, 1) = "01000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100": TheInput(n, 2) = "0"
54. n = n + 1: TheInput(n, 1) = "10001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000": TheInput(n, 2) = "1"
55. '
56. n = n + 1: TheInput(n, 1) = "00001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000": TheInput(n, 2) = "0"
57. n = n + 1: TheInput(n, 1) = "00010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000": TheInput(n, 2) = "1"
58. n = n + 1: TheInput(n, 1) = "00100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001": TheInput(n, 2) = "0"
59. n = n + 1: TheInput(n, 1) = "01000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010": TheInput(n, 2) = "0"
60. n = n + 1: TheInput(n, 1) = "10000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100": TheInput(n, 2) = "0"
61. '
62. n = n + 1: TheInput(n, 1) = "00000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100": TheInput(n, 2) = "0"
63. n = n + 1: TheInput(n, 1) = "00001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000": TheInput(n, 2) = "0"
64. n = n + 1: TheInput(n, 1) = "00010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000": TheInput(n, 2) = "0"
65. n = n + 1: TheInput(n, 1) = "00100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000": TheInput(n, 2) = "1"
66. n = n + 1: TheInput(n, 1) = "01000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001": TheInput(n, 2) = "0"
67. n = n + 1: TheInput(n, 1) = "10000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010": TheInput(n, 2) = "0"
68. '
69. n = n + 1: TheInput(n, 1) = "00000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100": TheInput(n, 2) = "0"
70. n = n + 1: TheInput(n, 1) = "00100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000": TheInput(n, 2) = "1"
71. '
72. n = n + 1: TheInput(n, 1) = "00000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001": TheInput(n, 2) = "0"
73. n = n + 1: TheInput(n, 1) = "10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000": TheInput(n, 2) = "1"
74. '
75. n = n + 1: TheInput(n, 1) = "00110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011": TheInput(n, 2) = "0"
76. n = n + 1: TheInput(n, 1) = "01100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110": TheInput(n, 2) = "0"
77. n = n + 1: TheInput(n, 1) = "11001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100": TheInput(n, 2) = "1"
78. n = n + 1: TheInput(n, 1) = "10011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001": TheInput(n, 2) = "1"
79. '
80. n = n + 1: TheInput(n, 1) = "00011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100": TheInput(n, 2) = "0"
81. n = n + 1: TheInput(n, 1) = "00111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000": TheInput(n, 2) = "1"
82. n = n + 1: TheInput(n, 1) = "01110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001": TheInput(n, 2) = "1"
83. n = n + 1: TheInput(n, 1) = "11100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011": TheInput(n, 2) = "1"
84. n = n + 1: TheInput(n, 1) = "11000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111": TheInput(n, 2) = "0"
85. n = n + 1: TheInput(n, 1) = "10001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110": TheInput(n, 2) = "0"
86. '
87. n = n + 1: TheInput(n, 1) = "01001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100": TheInput(n, 2) = "0"
88. n = n + 1: TheInput(n, 1) = "10011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000": TheInput(n, 2) = "1"
89. n = n + 1: TheInput(n, 1) = "00110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001": TheInput(n, 2) = "1"
90. n = n + 1: TheInput(n, 1) = "01100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011": TheInput(n, 2) = "1"
91. n = n + 1: TheInput(n, 1) = "11000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111": TheInput(n, 2) = "0"
92. n = n + 1: TheInput(n, 1) = "10001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110": TheInput(n, 2) = "1"
93. n = n + 1: TheInput(n, 1) = "00011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101": TheInput(n, 2) = "0"
94. '
95. n = n + 1: TheInput(n, 1) = "01001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001": TheInput(n, 2) = "0" '0
96. n = n + 1: TheInput(n, 1) = "10010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010": TheInput(n, 2) = "1" '1
97. n = n + 1: TheInput(n, 1) = "00101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101": TheInput(n, 2) = "0" '0
98. n = n + 1: TheInput(n, 1) = "01010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010": TheInput(n, 2) = "1" '1
99. n = n + 1: TheInput(n, 1) = "10101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101": TheInput(n, 2) = "0" '0
100. n = n + 1: TheInput(n, 1) = "01010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010": TheInput(n, 2) = "1" '1
101. n = n + 1: TheInput(n, 1) = "10101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101": TheInput(n, 2) = "0" '0
102. n = n + 1: TheInput(n, 1) = "01010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010": TheInput(n, 2) = "0" '0
103. n = n + 1: TheInput(n, 1) = "10101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100": TheInput(n, 2) = "0" '0
104. n = n + 1: TheInput(n, 1) = "01010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000": TheInput(n, 2) = "1" '1
105. n = n + 1: TheInput(n, 1) = "10100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001": TheInput(n, 2) = "1" '1
106. '
107. n = n + 1: TheInput(n, 1) = "0001000001011100000011000100011000010010000000000000000011000000000000000001110010000000000001111000000001001110000000000000100000000011110000000000000000000000000000010100000000000000000100000000000000110001111000010001000000000000000000011010000000000000000010001101100000100001000000110011000011010010000000000000000000100001000011000110001010000000100000000000000000000000000000000000010000000000100000000000000010100000100000000000000000000000000000000000100001000000000000000010110100000000000010010000000000000000000100000000001100000011000000000000000000000000000000110010000110000100000": TheInput(n, 2) = "?"
108. '
109.  
110. For m = 1 To n
111.  
112.     FingerPrint(1) = TheInput(m, 1)
113.  
114.     For k = 2 To UBound(FingerPrint)
115.         FingerPrint(k) = Right$(FingerPrint(k - 1), Len(FingerPrint(k - 1)) - 1) + Left$(FingerPrint(k - 1), 1)
116.     Next
117.  
118.     Call CreateHisto(Alphabet2(), 2)
119.     'Call PrintHisto(Alphabet2())
120.     p2 = MakeGuess(Alphabet2(), 2)
121.  
122.     Call CreateHisto(Alphabet3(), 3)
123.     'Call PrintHisto(Alphabet3())
124.     p3 = MakeGuess(Alphabet3(), 3)
125.  
126.     Call CreateHisto(Alphabet4(), 4)
127.     'Call PrintHisto(Alphabet4())
128.     p4 = MakeGuess(Alphabet4(), 4)
129.  
130.     Call CreateHisto(Alphabet5(), 5)
131.     'Call PrintHisto(Alphabet5())
132.     p5 = MakeGuess(Alphabet5(), 5)
133.  
134.     Call CreateHisto(Alphabet6(), 6)
135.     'Call PrintHisto(Alphabet6())
136.     p6 = MakeGuess(Alphabet6(), 6)
137.  
138.     Call CreateHisto(Alphabet7(), 7)
139.     'Call PrintHisto(Alphabet7())
140.     p7 = MakeGuess(Alphabet7(), 7)
141.  
142.     Call CreateHisto(Alphabet8(), 8)
143.     'Call PrintHisto(Alphabet8())
144.     p8 = MakeGuess(Alphabet8(), 8)
145.  
146.     Call CreateHisto(Alphabet9(), 9)
147.     'Call PrintHisto(Alphabet9())
148.     p9 = MakeGuess(Alphabet9(), 9)
149.  
150.     Call CreateHisto(Alphabet10(), 10)
151.     'Call PrintHisto(Alphabet10())
152.     p10 = MakeGuess(Alphabet10(), 10)
153.  
154.     Call CreateHisto(Alphabet11(), 11)
155.     'Call PrintHisto(Alphabet11())
156.     p11 = MakeGuess(Alphabet11(), 11)
157.  
158.     Call CreateHisto(Alphabet12(), 12)
159.     'Call PrintHisto(Alphabet12())
160.     p12 = MakeGuess(Alphabet12(), 12)
161.  
162.     'Call CreateHisto(Alphabet13(), 13)
163.     'Call PrintHisto(Alphabet13())
164.     'p13 = MakeGuess(Alphabet13(), 13)
165.  
166.     Cls
167.     Print "String:"
168.     Print FingerPrint(1)
169.     Print
170.     Print "Predicted:"; p12
171.     Print "Actual:    "; TheInput(m, 2)
172.     'Print
173.     'Print p2; p3; p4; p5; p6; p7; p8; p9; p10; p11; p12; p13
174.     Sleep
175.  
176. Next
177.  
178. End
179.  
180. Function MakeGuess (arr() As Letter, w As Integer)
181.     Dim TheReturn As Integer
182.     x$ = Right$(FingerPrint(1), w - 1)
183.     For k = 1 To UBound(arr)
184.         If Left$(arr(k).Signature, w - 1) = x$ Then
185.             'Print "..."; arr(k).Signature
186.             TheReturn = Val(Right$(arr(k).Signature, 1))
187.             Exit For
188.         End If
189.     Next
190.     MakeGuess = TheReturn
191. End Function
192.  
193. Sub CreateHisto (arr() As Letter, w As Integer)
194.     For m = 1 To w
195.         For n = 1 To Len(FingerPrint(m)) Step w
196.             a$ = Mid$(FingerPrint(m), n, w)
197.             For k = 1 To UBound(arr)
198.                 If a$ = arr(k).Signature Then
199.                     arr(k).Count = arr(k).Count + 1
200.                 End If
201.             Next
202.         Next
203.     Next
204.     Call BubbleSort(arr())
205. End Sub
206.  
207. Sub PrintHisto (arr() As Letter)
208.     For k = 1 To 3
209.         Print arr(k).Signature; arr(k).Count
210.     Next
211. End Sub
212.  
213. Sub NewAlphabet (arrold() As Letter, arrnew() As Letter)
214.     n = 0
215.     For j = 1 To 2
216.         For k = 1 To UBound(arrold)
217.             n = n + 1
218.             arrnew(n).Signature = arrold(k).Signature
219.         Next
220.     Next
221.     For k = 1 To UBound(arrnew)
222.         If k <= UBound(arrnew) / 2 Then
223.             arrnew(k).Signature = "0" + arrnew(k).Signature
224.         Else
225.             arrnew(k).Signature = "1" + arrnew(k).Signature
226.         End If
227.     Next
228. End Sub
229.  
230. Sub BubbleSort (arr() As Letter)
231.     Dim As Integer i, j
232.     Dim As Double u, v
233.     For j = UBound(arr) To 1 Step -1
234.         For i = 2 To UBound(arr)
235.             u = arr(i - 1).Count
236.             v = arr(i).Count
237.             If (u < v) Then
238.                 Swap arr(i - 1), arr(i)
239.             End If
240.         Next
241.     Next
242. End Sub

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 09, 2021, 09:49:57 am

SMcNeill

The video you posted is on target and a big goal is avoiding the gamblers fallacy like a plague.

Thanks for posting 
 



 

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 09, 2021, 10:52:31 am

STxAxTIC

The strings you show do not have any random elements except for the mentioned.
My approach at this would be a basic counter loop with a quick decimal to binary
converter.  Use an array to store the counts.  Running averages is something I use
but by itself it's not enough to make a solid prediction when the data can be some-
what random.   The video SMcNeill posted shows where I am at and also explains
where the 3rd state comes in, a wild card that skips whenever no clear prediction
can be made. 
Please don't think I am downplaying your input, I am not.  Lets say that we start
with the right most digit in the string and from that value we try to predict the
digit to the left of it.  We then check the prediction against the second leftmost
digit.  Next we add the second digit to the first so that we now have 2 digits to
use in making the next prediction and so on and on. 
If the data does not contain any random data, then as soon as the length of the
pattern is determined it's a no brain'er from that point.  The direction I am headed
is to create a self adapting algorithm to minimize the error, not exactly a neural
network but close.  It seems simple enough until one starts coding.  My thoughts
are to combine several such algorithms into a single predictor using all the outputs
to make the prediction.  The running average is already part of the project.   The
speed of the code is not that important as long as were not talking hours, my current
code takes around 45 seconds to process 800+ strings which includes 2 graphics.

Picture
Green graph shows single string process and pink shows overrall

https://i.postimg.cc/9fqHZchS/splash.png (https://i.postimg.cc/9fqHZchS/splash.png)

R1   
 
 

Title: Re: Looking for old program or help recreating it
Post by: Dimster on December 09, 2021, 11:05:51 am

Just trying to determine if you are trying to predict an event or predict the behavior of a person?

Quote

The main goal is to produce a universal prediction tool.  The 0110 is nothing more than
the values of the last 4 entries.  The string changes day to day and when using the first
4 digits then we have 16 possibilities but each day the sequence is determined by the
events I track.  Each string is updated daily by adding a 0 or 1 to the string.  if the event
accrued then a 1 is added if not then a 0.

Events of nature are truly random but a persons behavior may be predictable.

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 09, 2021, 12:42:00 pm

Yeah, I kinda figured this would happen.

random1, my method works on random strings also - of course - we need to TEST things with regularized input before we give the algorithm true unknowns.

IF you can't run your stuff on my test data, or won't, the way it really sounds, then Im considering this issue closed and you guys have some reading to do!

Please, let's see how your attempt handles the data I provided. No speculation about it, let's see a test.

Title: Re: Looking for old program or help recreating it
Post by: bplus on December 09, 2021, 12:50:13 pm

Yeah Steve's link was what I was trying to get at, now that I've seen it, I see how poorly I coded my attempt.

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 09, 2021, 01:03:26 pm

The idea is to predict the next event using a algorithm similar to the one in the program
I mentioned at the start of the topic.

In the posted video, notice the bets; penny, dollar and 100 dollars.  The bets seems to be
based on a confidence level, this alone sums up what I am trying to do.  We could think
of the 1's and 0,s as heads and tails if it makes it easier to understand.  Predicting a (0)
is as important as predicting a (1), just need accurate predictions.

My goal is to find 20 to 25 of the 800+ strings that have a very high confidence level and
skip the rest, keep the $100.00 bets so to say and pass on the others. 

One does not need to process the entire string, in the video the $100 bet is made on the
20th of 20 predictions.  The strings length and the amount of data used will be different
depending on the method used.   

I have a couple new ideas and will start coding them in the next day or two.   

Hope this helps

R1 


   

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 09, 2021, 01:18:10 pm

Okay last reply, I promise - I can't believe what I'm seeing here!

Quote

The strings you show do not have any random elements

Irrelevant point anyway, but if your method works, it will work on that data set.

Quote

The idea is to predict the next event using a algorithm similar to the one in the program
I mentioned at the start of the topic.

I claim to have solved the bold part of the statement you made. Why insist on the italic part then?

Quote

One does not need to process the entire string

I disagree with this, a fully-informed answer should use all of the data available. Use the whole string, not just recent characters.

Quote

The main goal is to produce a universal prediction tool.

I'm not sure how I feel about this, but the thing I'm using is very close to, or maybe simple *is* - universal. I've publicly tested this method on numbers, strings, etc etc. I honestly can't believe Steve and/or bplus haven't openly remembered this study, or maybe the implications of it were stronger to me than they were to the average reader.

You'll prolly skip right over this encounter in the long run, just remember you have a solution laying around when you care to look into what I'm doing.

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 09, 2021, 01:37:29 pm

"" Yeah, I kinda figured this would happen.

random1, my method works on random strings also - of course - we need to TEST things with regularized input before we give the algorithm true unknowns.

IF you can't run your stuff on my test data, or won't, the way it really sounds, then Im considering this issue closed and you guys have some reading to do!

Please, let's see how your attempt handles the data I provided. No speculation about it, let's see a test."


See the picture below.  I will fully test your code against all 800+strings but can't do it right now
as I am in the middle of a rewrite.  Like I said I don't ignore anything people post but that does not
mean I can jump on it right now.  I detect a bit of ass-hole in your last post.  You don't have to post
anything and it's not my responsibility to work on your time.  People like you are the main reason
I do very little posting.  On second thought, I may not even give your code another look. 
       


https://i.postimg.cc/yYMz0Bc2/stat.png (https://i.postimg.cc/yYMz0Bc2/stat.png)

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 09, 2021, 01:49:11 pm

Alright man, we can be past the issue of my code. I know it works, the world can see it works. But let's forget about that - pretend I never worked on this problem. Let me start afresh, do a big re-set, and only see things your way, and I mean it.

This will mean:

Quote

I will fully test your code against all 800+strings but can't do it right now

...can go away.

So let's re-begin: I don't need you to test my algorithm, I need you to test my data set. Just run those strings through what you've got and show me how it does. Ya?

Title: Re: Looking for old program or help recreating it
Post by: SpriggsySpriggs on December 09, 2021, 01:50:15 pm

@random1 Welcome to the forum! I don't think I've seen you on here before (but I've been less active recently). Glad to see you are wanting to deal in mathematical programs! @STxAxTIC is our resident mathematician and provides great examples so I hope you can use them to your benefit. Good luck with your program and I wish you the best!

Title: Re: Looking for old program or help recreating it
Post by: SMcNeill on December 09, 2021, 01:58:58 pm

I think the biggest problem with this type of program is simply getting a valid data set to test against. 

Asking QB64 to give you a list of 20 heads or tail results is worthless.  You're not trying to test if the computer is random; you're trying to make a prediction based on human psychology with random numbers.  It's like telling folks to, "Give me a random number between 1 and 10."

Go ahead.   Do it.    Before you read any more of this post, pause and think of a random number between one and ten.

.
.
.
.
.

Got it?

.
.
.
.
.


It's 7.

.
.
.
.
.

Or, at least for 47% of you, it's seven, according to various studies done when people were asked to generate a value from 1 to 10.  If it's not 7, chances are, it's 3.

WHY??

Because both are midways off-center, making them seem "random" to our brain, and both are prime numbers, making them stand out as less divisible and "special" to us.  They just "seem" random, when, in fact, they're anything but that!

Ask yourself, "Why don't people choose 1 or 10, when given a choice to choose any value between those numbers?"

Various theories exist on answering that question, but the one I tend to like is simply, "Told to guess between one and ten, our brains simply remove those numbers from the pool to begin with."  That leaves two through nine to be the real range of values that most people might choose from.  (Minus a very few extremes who fall onto the end of our bell curve of human psychology.)

From two to nine, most people don't want to be on the extremes, as that "just doesn't feel random", so they shoot for somewhere near the center of that range...   But, you don't want to go for the EXACT center; it's "not really random" to the human brain either -- after all, it's the exact center!  So that leaves us with 3, 4, 6, 7, 8 as a value that most people will choose from...

Of those, there's only two prime numbers, which seem "odd" to us by their unique nature, and as such, we realize that they're not "normal numbers."  An "abnormal number" HAS to be more random than a plain old "normal number".   Right??

At least, it is as far as the human mind is concerned for the vast portion of humanity!!

BUT, the problem comes that once you tell this to someone, and then you tell them to "Guess a number from one to ten", they'll react upon the information I just gave you.  Three and Seven are no longer viable numbers, as that person now things of them as "AHA!  He's going to trap me into being normal and thinking of one of those values!"  Chances are, they're now going to go to an extreme and think of "something random, outside the pattern"!

They'll choose one or ten, as I emphasized that people don't choose those values normally!!

And that's why it's so hard to get a valid set of random numbers from people...  The moment you mention it, they instantly start to think, "What's this guy doing?  How can I *BEAT* him at his process?  How do I prove I'm not an *average* bear??"

Suddenly you're not testing human behavior for guessing random numbers -- instead you're now trying to see if you can predict human behavior for people trying to beat your algorithm for prediction!

Which makes this type of project one that is incredibly hard to do, just because it's hard to actually get a valid data set to run it against.

Title: Re: Looking for old program or help recreating it
Post by: SMcNeill on December 09, 2021, 02:03:30 pm

Quote from: random1 on December 09, 2021, 01:37:29 pm

I detect a bit of ass-hole in your last post. 

Don't worry.  I often detect a LOT of asshole when STxATxIC posts.  Feel free to tune him out completely if you want.   I certainly don't do much more than glance quickly over his crap anymore and pay very little attention to whatever he's spouting off over at the moment. 

But, I have to admit, it's nice to see I'm not the only one who feels this way, as far as he's concerned.  LOL!  ;)

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 09, 2021, 02:05:54 pm

Quote

Which makes this type of project one that is incredibly hard to do, just because it's hard to actually get a valid data set to run it against.

I agree, hence why I chose these strings for testing:

Code: [Select]

string = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": nextdigit = "0"
'
string = "01010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101": nextdigit = "0"
string = "10101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010": nextdigit = "1"
'
string = "00100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100": nextdigit = "1"
string = "01001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001": nextdigit = "0"
string = "10010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010": nextdigit = "0"
'
string = "00010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001": nextdigit = "0"
string = "00100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010": nextdigit = "0"
string = "01000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100": nextdigit = "0"
string = "10001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000": nextdigit = "1"
'
string = "00001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000": nextdigit = "0"
string = "00010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000": nextdigit = "1"
string = "00100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001": nextdigit = "0"
string = "01000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010": nextdigit = "0"
string = "10000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100": nextdigit = "0"
'
string = "00000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100": nextdigit = "0"
string = "00001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000": nextdigit = "0"
string = "00010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000": nextdigit = "0"
string = "00100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000": nextdigit = "1"
string = "01000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001": nextdigit = "0"
string = "10000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010": nextdigit = "0"
'
string = "00000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100": nextdigit = "0"
string = "00100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000": nextdigit = "1"
'
string = "00000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001": nextdigit = "0"
string = "10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000": nextdigit = "1"
'
string = "00110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011": nextdigit = "0"
string = "01100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110": nextdigit = "0"
string = "11001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100": nextdigit = "1"
string = "10011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001": nextdigit = "1"
'
string = "00011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100": nextdigit = "0"
string = "00111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000": nextdigit = "1"
string = "01110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001": nextdigit = "1"
string = "11100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011": nextdigit = "1"
string = "11000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111": nextdigit = "0"
string = "10001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110": nextdigit = "0"
'
string = "01001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100": nextdigit = "0"
string = "10011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000": nextdigit = "1"
string = "00110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001": nextdigit = "1"
string = "01100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011": nextdigit = "1"
string = "11000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111": nextdigit = "0"
string = "10001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110": nextdigit = "1"
string = "00011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101": nextdigit = "0"
'
string = "01001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001": nextdigit = "0"
string = "10010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010": nextdigit = "1"
string = "00101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101": nextdigit = "0"
string = "01010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010": nextdigit = "1"
string = "10101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101": nextdigit = "0"
string = "01010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010": nextdigit = "1"
string = "10101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101": nextdigit = "0"
string = "01010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010": nextdigit = "0"
string = "10101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100": nextdigit = "0"
string = "01010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000": nextdigit = "1"
string = "10100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001": nextdigit = "1"
And everything else Steve just went on about only concretizes why it's critical that the algorithm being used is completely robotic, completely unbiased, completely systematic, completely uninformed by a human. (That's the reason reason my code, which I swore I wouldn't mention anymore, is so small.)

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 09, 2021, 02:09:20 pm

Yup, as usual Steve wants to go all ad-hominem when he feels a certain way. Why, man? I wasn't even coming after you. Go wait for me in a calculus thread where I can pants you in the proper arena.

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 09, 2021, 04:01:14 pm

STxAxTIC

Here is a challenge that will prove rather your program works or not.
I only have a hour or so each day to work on this project. 

Attached is a plain text file that contains 44 strings updated a few
minutes ago.  It should be easy for you to add the code to input
the strings directly into your program and then record and post the
predicted value for each string. 

Each line contains 500 values which should be enough.  Post your
predicted values for 1 through 44, if for some reason your predictor
cannot make a prediction for a string then just add a "*" for that value. 

This way it will make testing the predictions easier.  Each prediction
should be a 0,1 or *.  Some of the strings contain all or mostly zeros. 

Anyone else that wants to run a test can have at it.  But I need your
results before the end of the day which is when I run the next update

P.S.
I never said anything one way or the other as to rather or not your
program had any merit, here's your way to prove it.

R1

Title: Re: Looking for old program or help recreating it
Post by: cfalcon030 on December 09, 2021, 05:27:42 pm

Does this match what you are looking for

https://archive.org/details/gameeven.qb64

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 09, 2021, 07:52:52 pm

Hello r1

I'm willing to play the game using the file you've provided, and I'll do you a little better: I refined my prediction calculation a little bit, so when it's not sure what to do, the answer will be a decimal between 0 and 1. If you see something like 0.25, it means I'm leaning more towards 0. A true coin-on-its-side result would be 0.5, call this your "asterisk" case.. A 0.75 means it's leaning toward 1. Because I've started to tweak and bugfix my estimator equation thingy, I'm quietly adding version numbers to this code for the time being, in case we have to refer back to something very specific.

Before I spill any beans here, another remark: I really really really think we should be starting this analysis using data that has semi-regularity to it, but not trivial regularity, for the sole - and very important - reason that we need an actual truth table to compare our predictions with. With no actual standard, it's a pissing contest in high winds. So because I'm doing this for you without an argument, I beg, I plead with you, PLEASE return the favor to me and run your algorithm on the sample data I cooked up.

Anyway, here are the predictions. Labeling the strings starting with 1 and ending with 40-something:

Code: [Select]

01: 0
02: 0
03: 0
04: .125
05: 0
06: .125
07: .875
08: 0
09: 0
10: 0
11: 0
12: .875
13: 0
14: .5
15: .125
16: 0
17: 0
18: 0
19: 0
20: 1
21: 0
22: .25
23: .125
24: .75
25: 0
26: 0
27: .125
28: .125
29: 0
30: 0
31: 1
32: .75
33: 0
34: 0
35: 0
36: .125
37: 0
38: .75
39: .125
40: 0
41: 0
42: .75
43: .125
44: 0

Full code right here, still making it pretty:

Code: QB64: [Select]

1. Option _Explicit
2.  
3. ' Version: 4
4.  
5. Type Letter
6.     Signature As String
7.     Count As Integer
8. End Type
9.  
10. Dim Shared TheInput(1000, 2) As String
11.  
12. Dim Shared FingerPrint(16) As String
13.  
14. Dim Shared Alphabet1(2) As Letter
15. Alphabet1(1).Signature = "0"
16. Alphabet1(2).Signature = "1"
17. Alphabet1(1).Count = 0
18. Alphabet1(2).Count = 0
19.  
20. Dim Shared Alphabet2(4) As Letter
21. Dim Shared Alphabet3(8) As Letter
22. Dim Shared Alphabet4(16) As Letter
23. Dim Shared Alphabet5(32) As Letter
24. Dim Shared Alphabet6(64) As Letter
25. Dim Shared Alphabet7(128) As Letter
26. Dim Shared Alphabet8(256) As Letter
27. Dim Shared Alphabet9(512) As Letter
28. Dim Shared Alphabet10(1024) As Letter
29. Dim Shared Alphabet11(2048) As Letter
30. Dim Shared Alphabet12(4096) As Letter
31. Dim Shared Alphabet13(8192) As Letter
32.  
33. Call NewAlphabet(Alphabet1(), Alphabet2())
34. Call NewAlphabet(Alphabet2(), Alphabet3())
35. Call NewAlphabet(Alphabet3(), Alphabet4())
36. Call NewAlphabet(Alphabet4(), Alphabet5())
37. Call NewAlphabet(Alphabet5(), Alphabet6())
38. Call NewAlphabet(Alphabet6(), Alphabet7())
39. Call NewAlphabet(Alphabet7(), Alphabet8())
40. Call NewAlphabet(Alphabet8(), Alphabet9())
41. Call NewAlphabet(Alphabet9(), Alphabet10())
42. Call NewAlphabet(Alphabet10(), Alphabet11())
43. Call NewAlphabet(Alphabet11(), Alphabet12())
44. Call NewAlphabet(Alphabet12(), Alphabet13())
45.  
46. Call LoadInput
47.  
48. Dim m As Integer
49. Dim k As Integer
50.  
51. m = 1
52. Do
53.  
54.     Cls
55.     Call Analyze(m)
56.     Print
57.  
58.     _Display
59.     _KeyClear
60.     Do: k = _KeyHit: Loop Until k
61.  
62.     Select Case k
63.         Case 19712
64.             m = m + 1
65.         Case 19200
66.             m = m - 1
67.         Case Else
68.             Cls: _Display
69.     End Select
70.     _KeyClear
71.  
72.     _Limit 30
73. Loop
74.  
75. End
76.  
77. Sub LoadInput
78.     Dim n As Integer
79.     '''
80.     n = 0
81.     '''
82.     n = n + 1: TheInput(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TheInput(n, 2) = "0"
83.     n = n + 1: TheInput(n, 1) = "01010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101": TheInput(n, 2) = "0"
84.     n = n + 1: TheInput(n, 1) = "10101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010": TheInput(n, 2) = "1"
85.     n = n + 1: TheInput(n, 1) = "00100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100": TheInput(n, 2) = "1"
86.     n = n + 1: TheInput(n, 1) = "01001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001": TheInput(n, 2) = "0"
87.     n = n + 1: TheInput(n, 1) = "10010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010": TheInput(n, 2) = "0"
88.     n = n + 1: TheInput(n, 1) = "00010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001": TheInput(n, 2) = "0"
89.     n = n + 1: TheInput(n, 1) = "00100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010": TheInput(n, 2) = "0"
90.     n = n + 1: TheInput(n, 1) = "01000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100": TheInput(n, 2) = "0"
91.     n = n + 1: TheInput(n, 1) = "10001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000": TheInput(n, 2) = "1"
92.     n = n + 1: TheInput(n, 1) = "00001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000": TheInput(n, 2) = "0"
93.     n = n + 1: TheInput(n, 1) = "00010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000": TheInput(n, 2) = "1"
94.     n = n + 1: TheInput(n, 1) = "00100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001": TheInput(n, 2) = "0"
95.     n = n + 1: TheInput(n, 1) = "01000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010": TheInput(n, 2) = "0"
96.     n = n + 1: TheInput(n, 1) = "10000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100": TheInput(n, 2) = "0"
97.     n = n + 1: TheInput(n, 1) = "00000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100": TheInput(n, 2) = "0"
98.     n = n + 1: TheInput(n, 1) = "00001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000": TheInput(n, 2) = "0"
99.     n = n + 1: TheInput(n, 1) = "00010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000": TheInput(n, 2) = "0"
100.     n = n + 1: TheInput(n, 1) = "00100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000": TheInput(n, 2) = "1"
101.     n = n + 1: TheInput(n, 1) = "01000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001": TheInput(n, 2) = "0"
102.     n = n + 1: TheInput(n, 1) = "10000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010": TheInput(n, 2) = "0"
103.     n = n + 1: TheInput(n, 1) = "00000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100": TheInput(n, 2) = "0"
104.     n = n + 1: TheInput(n, 1) = "00100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000": TheInput(n, 2) = "1"
105.     n = n + 1: TheInput(n, 1) = "00000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001": TheInput(n, 2) = "0"
106.     n = n + 1: TheInput(n, 1) = "10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000": TheInput(n, 2) = "1"
107.     n = n + 1: TheInput(n, 1) = "00110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011": TheInput(n, 2) = "0"
108.     n = n + 1: TheInput(n, 1) = "01100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110": TheInput(n, 2) = "0"
109.     n = n + 1: TheInput(n, 1) = "11001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100": TheInput(n, 2) = "1"
110.     n = n + 1: TheInput(n, 1) = "10011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001": TheInput(n, 2) = "1"
111.     n = n + 1: TheInput(n, 1) = "00011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100": TheInput(n, 2) = "0"
112.     n = n + 1: TheInput(n, 1) = "00111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000": TheInput(n, 2) = "1"
113.     n = n + 1: TheInput(n, 1) = "01110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001": TheInput(n, 2) = "1"
114.     n = n + 1: TheInput(n, 1) = "11100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011": TheInput(n, 2) = "1"
115.     n = n + 1: TheInput(n, 1) = "11000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111": TheInput(n, 2) = "0"
116.     n = n + 1: TheInput(n, 1) = "10001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110": TheInput(n, 2) = "0"
117.     n = n + 1: TheInput(n, 1) = "01001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100": TheInput(n, 2) = "0"
118.     n = n + 1: TheInput(n, 1) = "10011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000": TheInput(n, 2) = "1"
119.     n = n + 1: TheInput(n, 1) = "00110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001": TheInput(n, 2) = "1"
120.     n = n + 1: TheInput(n, 1) = "01100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011": TheInput(n, 2) = "1"
121.     n = n + 1: TheInput(n, 1) = "11000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111": TheInput(n, 2) = "0"
122.     n = n + 1: TheInput(n, 1) = "10001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110": TheInput(n, 2) = "1"
123.     n = n + 1: TheInput(n, 1) = "00011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101": TheInput(n, 2) = "0"
124.     n = n + 1: TheInput(n, 1) = "01001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001": TheInput(n, 2) = "0"
125.     n = n + 1: TheInput(n, 1) = "10010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010": TheInput(n, 2) = "1"
126.     n = n + 1: TheInput(n, 1) = "00101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101": TheInput(n, 2) = "0"
127.     n = n + 1: TheInput(n, 1) = "01010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010": TheInput(n, 2) = "1"
128.     n = n + 1: TheInput(n, 1) = "10101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101": TheInput(n, 2) = "0"
129.     n = n + 1: TheInput(n, 1) = "01010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010": TheInput(n, 2) = "1"
130.     n = n + 1: TheInput(n, 1) = "10101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101": TheInput(n, 2) = "0"
131.     n = n + 1: TheInput(n, 1) = "01010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010": TheInput(n, 2) = "0"
132.     n = n + 1: TheInput(n, 1) = "10101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100": TheInput(n, 2) = "0"
133.     n = n + 1: TheInput(n, 1) = "01010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000": TheInput(n, 2) = "1"
134.     n = n + 1: TheInput(n, 1) = "10100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001": TheInput(n, 2) = "1"
135.     n = n + 1: TheInput(n, 1) = "10100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001": TheInput(n, 2) = "?"
136.     n = n + 1: TheInput(n, 1) = "0001000001011100000011000100011000010010000000000000000011000000000000000001110010000000000001111000000001001110000000000000100000000011110000000000000000000000000000010100000000000000000100000000000000110001111000010001000000000000000000011010000000000000000010001101100000100001000000110011000011010010000000000000000000100001000011000110001010000000100000000000000000000000000000000000010000000000100000000000000010100000100000000000000000000000000000000000100001000000000000000010110100000000000010010000000000000000000100000000001100000011000000000000000000000000000000110010000110000100000": TheInput(n, 2) = "?"
137.     '''
138.     'n = 0
139.     '''
140.     n = n + 1: TheInput(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TheInput(n, 2) = "?"
141.     n = n + 1: TheInput(n, 1) = "00000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TheInput(n, 2) = "?"
142.     n = n + 1: TheInput(n, 1) = "00000100000101110000001100010001100001001000000000000000001100000000000000000111001000000000000111100000000100111000000000000010000000001111000000000000000000000000000001010000000000000000010000000000000011000111100001000100000000000000000001101000000000000000001000110110000010000100000011001100001101001000000000000000000010000100001100011000101000000010000000000000000000000000000000000001000000000010000000000000001010000010000000000000000000000000000000000010000100000000000000001011010000000000": TheInput(n, 2) = "?"
143.     n = n + 1: TheInput(n, 1) = "00011101100000000001011100001011101000100111101100011000000011001010101000101000111111011000111000100000000000000110110000000001001001110110100001011011101100000011001010001111111110101100001101100001100011000111101100110000000101101101110000001110110111000011000110000000001101111000110000000011111100110001111000011101111101010011111111101111010011011001111101100010001100101101001011000010100111111101111010111111010110001100011000000100010001100111111001101101111000000010110111110000001011010011": TheInput(n, 2) = "?"
144.     n = n + 1: TheInput(n, 1) = "00000000100000000000110000000000000000010000000000000000010000000000000000001000000000000000000000000000000001000000010000000000000000000000000000000000000000000000000000011000000000000000001000000001000000000000000000000000000000000000000001001011001000000000000110000000000000000000000000000000000100010000000000000000000000000000000000001100000000000000000000000000000000100000000000000000001000000000000000000000000000000000000000000000100000000000000000100000000000000000000000000000000000000000": TheInput(n, 2) = "?"
145.     n = n + 1: TheInput(n, 1) = "01111011010110000100001000011001101101000011000011000000000100110010001010000100010000001110111000001000000000101110101100000000100011100101101110000010110101111001011010100000111011100110100001100100111010111110000010000110010000000100111100110000000101010100111001000000101000100101111001001001000010000100110011011010011011101000110011000000101000000100010000101101000101000110000100010101010111100000000001100000110010000001000011100001001000100000011100000101000001010101000100011010000100010011": TheInput(n, 2) = "?"
146.     n = n + 1: TheInput(n, 1) = "11000110011000111000001101000010001000001110001001110010000110000111010001010001100010101100001111100000111100101100000011000111101101110010101101010000101010000001111100000111110101010000000011011100100110101100111101000000100100101000011010000000010110101010011001110011111000010001100110001111111001100010011100010101001100000101010101100000000001001010000011011100010011001000001001110111100110010010000010000111111101100011010101010101000111010110101000000010001001001011011011100101111110110010": TheInput(n, 2) = "?"
147.     n = n + 1: TheInput(n, 1) = "10101101010001010110010110011111011111111101110100010011101110000000100011010000100111111001110110100011011110011101110001110011110000111011011110111011101100000010100111100010000010100111110010100100010001010101111000111010011101010111001110110000101101110001110010011101010110101110001111000101011001001101001011111101110010110101001100110010111101010111010010000010110100010001101110110101101110000101101010001001101101011000111110100000011101110010101111011110111110100110101001111101110001010110": TheInput(n, 2) = "?"
148.     n = n + 1: TheInput(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TheInput(n, 2) = "?"
149.     n = n + 1: TheInput(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000001000000000000000000000000000100000000000000000000000000000000000000000000000100000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000": TheInput(n, 2) = "?"
150.     n = n + 1: TheInput(n, 1) = "00000110110101110000001100100101000001001111101111100000011000000000001001000100011000000000100011100000100000001001000001000010000000010111001101000001100000010101100011010011111000100111010000000000001010001011101110010100000000000010001011101000010000100000101100110100000011111000000001110000010101010000111111110000000110000100111110011000100000010001010100000000000110000000011000100000000111110011110010000100001010000010011100000000010001101010000000000110010000000110000000110011000000000000": TheInput(n, 2) = "?"
151.     n = n + 1: TheInput(n, 1) = "11011001010011000110101011011010000110001001010001001111100111001011110110111010001111010110010100100101011010110010010100111010111001101011100100001010011111111010011100101101000011011011000111011011010110111100110011100010100001101010110101110101110111010111010010011001110100011010011010101111101110100100100111101101001011100001001100100111010101100100101000111111111001001111100111010110111100001000000111101000111000001101011001001110001000010100110011111001001010101001110111010101111001100001": TheInput(n, 2) = "?"
152.     n = n + 1: TheInput(n, 1) = "00000000000000000000010000000001100000000000000000000001010000000000110010000000000000000000000000000000000000000000000000001100000000000111000101000000000000000000000000000100010001000000000000000000000000000000001100010010000000000000000001100000000000000000000000000001000000000000000000000000000000000010000011000000000000010000000000000001000000001000000000000000000000000000000000000100100000000000100000000000000000000000000000000000100000000000000000000000000000000000000000100000000000000000": TheInput(n, 2) = "?"
153.     n = n + 1: TheInput(n, 1) = "11101000011011010000101000100000010001001000000110011110001011010001001101101010001100111000000101001000011000001010010100010011100110101000101000000000010100111001010100010010101010100011000011000001011010000000010000000001011110110111000010000001011011100000000111001110100000110000000011000101100000001001000100110011000100100000100001001000000011010010100000000100100000101001100000110001001001110101010001000000011000000010101000110010000100001011000001101000101010011011001110010110000010000000": TheInput(n, 2) = "?"
154.     n = n + 1: TheInput(n, 1) = "00000010100110101001001000100000010100100100101101010010000001001100000000001011001110011011000010000111111001100010110011000010100110110000000000011010011010010100100011011011001100110001101001110000101001001100100010001101001000001011111100011011100000011001001010111000000000111101111001111001111111101000000000101100011001001011011010010000100001100010011110010000001011000001010111010010011111001001001110111100110010000110100111101000000101110100101010001111001111101100010101001001010101000101": TheInput(n, 2) = "?"
155.     n = n + 1: TheInput(n, 1) = "00111100000000000111001001100000111010010010010011100010001100001100000011011000100010000101110010110100110110011100010001111110011011000110010000001001101111111000011000010001101110011101111010100110100110000111011101001111110011011111100110111000001101101110001001001000011110100110000111110111010000001100100100100111110110100001001011100110111000100011110100100100110010011110011011100011101111010010000110000011101100000111001011000110000010001101111011111011001100000010000101000000000000101110": TheInput(n, 2) = "?"
156.     n = n + 1: TheInput(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TheInput(n, 2) = "?"
157.     n = n + 1: TheInput(n, 1) = "00000000000000000000000000000000000000000100000000000000000000000010000000000000001000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000": TheInput(n, 2) = "?"
158.     n = n + 1: TheInput(n, 1) = "00000000010111101100110000001011000001001011001100000001001100001001000001001100010000111111000011100001000000001111010010000100001000000010001101001011101011011010000101010011110110110001100001000010000010100011000000110001000000011101110001000000000000110000100000101100000001011010000101000000100100011000111111110010110101010100011110100110110000010001101000000000101001000010100110000100010100111000010010100100001000110000000100010100010000000010000100011100010010110100010000010010001001000010": TheInput(n, 2) = "?"
159.     n = n + 1: TheInput(n, 1) = "11111111011001010010001100000100110110101110100011010010111011110100101000100000000101100000000100110010111110111000110101101010111111011101101010011111100100110100010011011001100000001110111110000101000000001100110101011110011111101100001110011101111100111100011100010010110111100001010000010001101001001111000000000101001000100100000110011000101011100100000100111011010110100000010001011010101011010010100111011000100011001000001010001011101010000100001011001011100001001011101110100110110010111100": TheInput(n, 2) = "?"
160.     n = n + 1: TheInput(n, 1) = "00000000000000000000000000010000000000000000000000000000000100000000100000000000000000000011100000000000000000000000000001000000000000000000000000000011001000000000000100000000000000000000000000010010000000000000000000000000000000000000000000000000000000000000000000000000000010001000000000000000000000000000000000000010000000000000000000000010000000000000000000000000000000000000000000000001001000000000011100000000000000001000000000000000000100000000100010000110100000000000000000000000000000000000": TheInput(n, 2) = "?"
161.     n = n + 1: TheInput(n, 1) = "01011000100010001000011010000010010010000100100101000100011001000010000010110110010110001100010001000010110110000011010100000100100010010011111101111100110010101100000001000000100111010000010000100000000111100110000101110001100100000001000001001100100100010000001001000110000000000100011100110110000101100011100010110100000011001001011000010001001000101010010010000001000000100101100101001110110010010000100010100010000000100111001100000000001000111111010100001000001010000010101010110101101000001100": TheInput(n, 2) = "?"
162.     n = n + 1: TheInput(n, 1) = "00000101000010010110000110001101111110010001110010000010101001111111010000011011100000110000010101101110101111110101001100000100000000100110001000000000000001110011101011011110000001000110101001000000000000010100010010110110000010001100100010011001010011111011001110110000110100010010000010010110011000010110110010101000111000000100000001101100100110010100110111001110110101010001101100000000110010100010000001000101011100000000000111101110101011001011001100100000001101110000001001101010000000111011": TheInput(n, 2) = "?"
163.     n = n + 1: TheInput(n, 1) = "10100010000111100111110001101101100001100111001010011110011001101110100111000111001010100111100010110010101010100100100000101010111100100000010111001000101110010010111000001100011011001011010100101101101110001001111100110000001011100000010110011010001000001101101111001000011101001000110010110111100011111011001100011110100110100111001110000101010001010001101001101001011001111010011001101010000001111010110011100001010100011100110100011011110011100101000001110010010111100111110011001110011111001010": TheInput(n, 2) = "?"
164.     n = n + 1: TheInput(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TheInput(n, 2) = "?"
165.     n = n + 1: TheInput(n, 1) = "00000000000000000000000000000000000000000100000000000001100000000000000000000000000000000000000000010000000000000000000000000000000001000000000000000000000000000000000001000000000000100000000000000000000000000000000000000000000000001100000000000000000000000000000000000000000000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TheInput(n, 2) = "?"
166.     n = n + 1: TheInput(n, 1) = "00100000011101101100000000000000000000001010001010001010010000000011101000010100001000000110000110100000000010001000111100100100001010110000011000001010110100110011000010001000110101001001100001011000001000000000000010110000100000110000001001000000100000110100100100100001010011000000010101010010100101000000001011100010000000001100000110100010100010000001110000000100000001110010100100001110000001100110000100001000001000000000010000001000001000000001001100000000010011110100000000001010100001111111": TheInput(n, 2) = "?"
167.     n = n + 1: TheInput(n, 1) = "01010110100011101001111011101011111111101001100000010100001001111110010111100011101100011111110001101101111000110011010011010011110000101111110110010001000001010100100100110011010010010110101011100000111111111101111110110011111101010011110000111101000010010011010000011100001000011011000011001101100011011101000101010101111011000100001111010100111001011100011100011011011000000010011010010100110010011001111011010010110011111000101110010111111100100100111110111010101001101011010100000001011010010000": TheInput(n, 2) = "?"
168.     n = n + 1: TheInput(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000100000001000000000000000000000000000000000000000001000000000000000000000000000000000000000010000000000000010010100000000000001000000000001000100000000000000000000001000000000000000000000000000000010000000010000000000000000000000001000000010000000000000000000000000000000000000000010000000110000000000000000000000001000000000010000100000000000000000100000001000000010000000000000000000000010000000000000000001000000000000000": TheInput(n, 2) = "?"
169.     n = n + 1: TheInput(n, 1) = "00000001100010111010101010001001000011001100000000000000010011000111001101001010110010010010010100101010000001001000111000000010110000010001001110100000000101101001110100010100000101000100000101000000010000110000010011010000100101001111000000011110001000001101101100000001000101000000011001011001110111100010010001000011110011110010010001000001110100100010101001110000010100000010010100000000101001000100101000011000000001001010111010110100000011001100101010000000100100100111111001110101000100000001": TheInput(n, 2) = "?"
170.     n = n + 1: TheInput(n, 1) = "11010010010101000010000011010000101110111010011001101000101111011101001110000001011110100101101111000100000010110001010101000110100001100000111000111100011110110011101101101111101010100100011101000000010010101110000011011100010010101110101010000001110001001111110011011101000010110000101111000000101100011100101100001001100001111110000101110000010010000001001010000000011011000001000101000100000111101100110011000111010000001000010000000000100101010001100001011000001010001000111111110110101000011111": TheInput(n, 2) = "?"
171.     n = n + 1: TheInput(n, 1) = "11011111000111100000010011111111101111001100100010111010010000011000110100111010011000111101000111010000110110101010011010101011100110011101000001011011111110011100110100001001010000001000010010100101111011000101001000000011110011110001100100100011011001010000101101111110101011011100000111000111000011110101111011101000101010000111011110000111111101011101110110001000011000111011011011111100110000001011011010110101101111011001011000111100101100111010011100110111101100110110100110000010011111110101": TheInput(n, 2) = "?"
172.     n = n + 1: TheInput(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TheInput(n, 2) = "?"
173.     n = n + 1: TheInput(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TheInput(n, 2) = "?"
174.     n = n + 1: TheInput(n, 1) = "00100000000000000011000000000000000000000110000010011111100000000000000001000000001000000000000000010110000110000001100010000000000011110000000001100000000000110011000011000000010000001110000000011000001000010000110100000010000000111101000000000000000000100000000001100000100011000000000100000000000101000000000011010000001100010100000110110010100001010000110000001000000001100000110000001100000000011010000000000000101001100000000000000000100000011010100000000010010000100100010000000000000001111000": TheInput(n, 2) = "?"
175.     n = n + 1: TheInput(n, 1) = "00010100011101010101100000101000001100111001101101000000011001111001100110110111010111111011110001100000000001100000011001111000111001000110011010001110100110011001110111100000101000110001100110100111000111001000001001110101101110000000110000000000011001010101000110011101011001100011001001011001101100011110000101101001100011001010011000001100110000101000001111110110000000001100001100010010101111100101001101010000000110011011111100011111010000000101000000100101100111010110001101111010101010000110": TheInput(n, 2) = "?"
176.     n = n + 1: TheInput(n, 1) = "00000010000000000001100000000000000001000000000000000000000000000000000000000000000001001000000000000000000100000000000000000000010000000000000000100100000101000001000000100001100000000000000000000000000010110000000000000000100001000000000000001000000001100010000000010000010000000000000110000000001000000000001000010000000000010000000000000000000000000000000000000100001000000000000100001000000000000000000100000000000100000000000000000000000001001000000000000000000001000010000000000010000011000000": TheInput(n, 2) = "?"
177.     n = n + 1: TheInput(n, 1) = "11010000111110000000000011000001011000010011010100100000000000110011011101010010100100000000000000010001101001000001001010011000100101101000111011000001000010010000010000010100001000100110100001100100001001001001100011110010011000110111000011000000011000000000100110001000101101100000001000000000000100000000000001001110001110100000010100001011101010110100001001001000000010010100001010100111011111000100001010000011010001000011001101110001101110000011010101101001010100110100010001011100110100110111": TheInput(n, 2) = "?"
178.     n = n + 1: TheInput(n, 1) = "00000000110110001000000011001000100000001110011010100010101101111100101100101000001010000000101101010100101011010000010001001110001001100001110101011010111010000100001011001010010100011001011000010000100001000000000100001111001000101011111110100001110010011000100001101000101001101011110001011111000110111010010101000001001011101101110000001011110000011001100011111001010100010101110011000100110000101101010010110000000000010011001001101101000010000010001110000011111100111101100100110000001000110000": TheInput(n, 2) = "?"
179.     n = n + 1: TheInput(n, 1) = "00101101111001100011001000011101001000000001100000101001000010110101000011001101110010110011000010101100111010101111100101100111000010110111010100000000001010000111111011001000111011100100011111101010010101011111111010010110010001101010100101010110111010111000101111001101001101101111010101010010110001000110110110101000010100001000010011101010011110001000001111001100110001011010100011101011100000100000111001000111001010101111010010010100110111001000100011010110100011111011101001101010111101101010": TheInput(n, 2) = "?"
180.     n = n + 1: TheInput(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TheInput(n, 2) = "?"
181.     n = n + 1: TheInput(n, 1) = "10000000100000000000000001001001000000100011010001010100000100000000010101100110101000000000000100000101010000000101000000000101100000000000010000001000001011000110100110100010010100010111000100000100001010000000101010001000111001000000010000100100000000000000100000001001000000110001010001001010010000000010101001000111011000100100100000010010000100100000000000001000010010000110010110000110100000000000101001010100000110010001110000111000000110000000000000000000000100101100001010000100000101100010": TheInput(n, 2) = "?"
182.     n = n + 1: TheInput(n, 1) = "00001101011011101101111110010000011011010000101110101011001001111000101010010001010111100001110011011010100011011010101010111010001010100110101100000110110100101001011001010000001010100000111010111011100100110111010101010100000010000010101110001011010011001111011110110000110010001010001000110100101111101100000110111000000000000010001111101001011011010111110110000100101000111000101001110001010011110100010100100011110000001100001011000100100000011110111111100011000011000011100101111010111010010101": TheInput(n, 2) = "?"
183.     n = n + 1: TheInput(n, 1) = "01110011000100111110101110110110101110011100101000000011111010011111101010001000000000111110011010111010001110111000111111010010011101111101100111110001000000011000001000001101101001001000010001011000010001111100010001100111000100111111100011010001101101110110000001010110001111000100101110010001101101010001010110110000100111011001010100101101110000001111001111110111100101101001001001111001011111111011000010101001001001101010001111000011011001111111001011111101111001010010110000100001010000011000": TheInput(n, 2) = "?"
184.     '''
185. End Sub
186.  
187.  
188.  
189. Sub Analyze (TheIndex As Integer)
190.     Dim actual As String
191.     Dim k As Integer
192.     Dim As Double p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13
193.  
194.     FingerPrint(1) = TheInput(TheIndex, 1)
195.     actual = TheInput(TheIndex, 2)
196.  
197.     For k = 2 To UBound(FingerPrint)
198.         FingerPrint(k) = Right$(FingerPrint(k - 1), Len(FingerPrint(k - 1)) - 1) + Left$(FingerPrint(k - 1), 1)
199.     Next
200.  
201.     Call CreateHisto(Alphabet2(), 2)
202.     Call CreateHisto(Alphabet3(), 3)
203.     Call CreateHisto(Alphabet4(), 4)
204.     Call CreateHisto(Alphabet5(), 5)
205.     Call CreateHisto(Alphabet6(), 6)
206.     Call CreateHisto(Alphabet7(), 7)
207.     Call CreateHisto(Alphabet8(), 8)
208.     Call CreateHisto(Alphabet9(), 9)
209.     Call CreateHisto(Alphabet10(), 10)
210.     Call CreateHisto(Alphabet11(), 11)
211.     Call CreateHisto(Alphabet12(), 12)
212.     Call CreateHisto(Alphabet13(), 13)
213.  
214.     Call PrintHisto(Alphabet2(), 0)
215.     Call PrintHisto(Alphabet3(), 0)
216.     Call PrintHisto(Alphabet4(), 0)
217.     Call PrintHisto(Alphabet5(), 0)
218.     Call PrintHisto(Alphabet6(), 0)
219.     Call PrintHisto(Alphabet7(), 0)
220.     Call PrintHisto(Alphabet8(), 0)
221.     Call PrintHisto(Alphabet9(), 0)
222.     Call PrintHisto(Alphabet10(), 0)
223.     Call PrintHisto(Alphabet11(), 0)
224.     Call PrintHisto(Alphabet12(), 0)
225.     Call PrintHisto(Alphabet13(), 0)
226.  
227.     p2 = MakeGuess(Alphabet2(), 2)
228.     p3 = MakeGuess(Alphabet3(), 3)
229.     p4 = MakeGuess(Alphabet4(), 4)
230.     p5 = MakeGuess(Alphabet5(), 5)
231.     p6 = MakeGuess(Alphabet6(), 6)
232.     p7 = MakeGuess(Alphabet7(), 7)
233.     p8 = MakeGuess(Alphabet8(), 8)
234.     p9 = MakeGuess(Alphabet9(), 9)
235.     p10 = MakeGuess(Alphabet10(), 10)
236.     p11 = MakeGuess(Alphabet11(), 11)
237.     p12 = MakeGuess(Alphabet12(), 12)
238.     p13 = MakeGuess(Alphabet13(), 13)
239.  
240.     Print
241.     Print "String ID:"; TheIndex
242.     Print FingerPrint(1)
243.     Print
244.     Print "Thinking:  "; p2; p3; p4; p5; p6; p7; p8; p9; p10; p11; p12; p13
245.     Print
246.     Print "Prediction:"; (1 / 4) * (p10 + p11 + p12 + p13)
247.     Print "Actual:     "; actual
248. End Sub
249.  
250. Function MakeGuess (arr() As Letter, w As Integer)
251.     Dim TheReturn As Double
252.     Dim As Integer k
253.     For k = 1 To UBound(arr)
254.         If (Left$(arr(k).Signature, w - 1) = Right$(FingerPrint(1), w - 1)) Then
255.             Print "..."; arr(k).Signature; arr(k).Count
256.             TheReturn = Val(Right$(arr(k).Signature, 1))
257.             If (arr(k).Count = 0) Then TheReturn = .5
258.             Exit For
259.         End If
260.     Next
261.     MakeGuess = TheReturn
262. End Function
263.  
264. Sub CreateHisto (arr() As Letter, w As Integer)
265.     Dim As Integer m, n, k
266.     For n = 1 To UBound(arr)
267.         arr(n).Count = 0
268.     Next
269.     For m = 1 To w
270.         For n = 1 To Len(FingerPrint(m)) - w Step w 'added the -w
271.             For k = 1 To UBound(arr)
272.                 If (Mid$(FingerPrint(m), n, w) = arr(k).Signature) Then
273.                     arr(k).Count = arr(k).Count + 1
274.                 End If
275.             Next
276.         Next
277.     Next
278.     Call BubbleSort(arr())
279. End Sub
280.  
281. Sub NewAlphabet (arrold() As Letter, arrnew() As Letter)
282.     Dim As Integer n, j, k
283.     n = 0
284.     For j = 1 To 2
285.         For k = 1 To UBound(arrold)
286.             n = n + 1
287.             arrnew(n).Signature = arrold(k).Signature
288.         Next
289.     Next
290.     For k = 1 To UBound(arrnew)
291.         If (k <= UBound(arrnew) / 2) Then
292.             arrnew(k).Signature = "0" + arrnew(k).Signature
293.         Else
294.             arrnew(k).Signature = "1" + arrnew(k).Signature
295.         End If
296.     Next
297. End Sub
298.  
299. Sub PrintHisto (arr() As Letter, w As Integer)
300.     Dim As Integer n
301.     If (w > 0) Then
302.         For n = 1 To w
303.             Print arr(n).Signature; arr(n).Count
304.         Next
305.     End If
306. End Sub
307.  
308. Sub BubbleSort (arr() As Letter)
309.     Dim As Integer i, j
310.     Dim As Integer u, v
311.     For j = UBound(arr) To 1 Step -1
312.         For i = 2 To UBound(arr)
313.             u = arr(i - 1).Count
314.             v = arr(i).Count
315.             If (u < v) Then
316.                 Swap arr(i - 1), arr(i)
317.             End If
318.         Next
319.     Next
320. End Sub

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 09, 2021, 08:39:55 pm

While this reply is still fresh I want to break down a case that my algo did the absolute worst on, and even this is corrected for in the next stroke of precision, so to speak. The screenshot below has everything. Look how ugly and "random" (everyone contain yourselves, i'm using the word colloquially) that string is! My code will eventually decide the answer is 0, but after a long time thinking it was 1. Too much time in this case, leading to a 50/50 result. Oh, I know the "actual" answer to be 0 because there IS a pattern in this string, just a really long one. This is the only uncertain case among the 50-something cases I cooked up originally.

  [ This attachment cannot be displayed inline in 'Print Page' view ]  

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 10, 2021, 12:08:05 am

Results

Hit 34 of 44 for a hit rate of 77%, all values rounded < .5 = 0, >=.5 = 1

Values to the right are the actual values that showed.   

(+) equals a match, (x) = miss
 
01: 0         0 +
02: 0         0 +
03: 0         0 +
04: .125    0 +
05: 0         0 +
06: .125    0 +
07: .875    0 x
08: 0         1 x
09: 0        0 +
10: 0        0 +
11: 0        0 +
12: .875   0 x
13: 0        0 +
14: .5       0 x
15: .125   0 +
16: 0       0 +
17: 0       0 +
18: 0       0 +
19: 0       0 +
20: 1       1 +
21: 0       0 +
22: .25    0 +
23: .125   0 +
24: .75     1 +
25: 0        0 +
26: 0        0 +
27: .125   0 +
28: .125   1 x
29: 0        0 +
30: 0        0 +
31: 1        0 x
32: .75     0 x
33: 0        0 +
34: 0        0 +
35: 0        0 +
36: .125   1 x
37: 0        0 +
38: .75     1 +
39: .125   0 +
40: 0       0 +
41: 0       0 +
42: .75    0 x
43: .125   1 x
44: 0       0 +

R1

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 10, 2021, 12:21:13 am

Once I have my predictor back up and running I will test it against the strings you provided.
As I stated, I removed the predictor code and for testing other parts of the program I have
inserted a PRNG  with a range of 0 to 2.  0&1+2 for wildcard.  This allows me to make sure all
other code functions properly.  I still think it's going to take more than one method and maybe
several to get the job done although the results were impressive for being straight out of the box
playing against actual data.  The strings I provided range from easy to very difficult.  I selected
them to get a better idea how well your predictor works overall.   

R1

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 10, 2021, 12:55:31 am

On what basis are you assigning me these marks? Are you saying your sequences are deterministic? Or are you saying you just concealed the final digit from your data and then just brought it back in to grade my program? If you did the second thing, that's an extreme fallacy and you can just toss those results no matter how good they look. I kid... kinda... still deciding if that was a dirty move or not but I'll take a 77 anyway. :-)

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 10, 2021, 03:33:11 pm

STxAxTIC
Please read this entire post.

I don't think your reading my post very carefully and just took the prediction idea and ran
with it.  Yes, your first attempt done very well IMHO, however I need to run hundreds of
test using other real data.

Nothing underhanded going on here, I run my programs updater each day which updates
the strings. If the event happened then a 1 is added to the string, if the event did not
happen then a 0 is added.  A type of web-crawler gathers the information, simple as that.

What benefit could I possibly gain by trying to trick you somehow, I want this to work?  I
don't expect to achieve perfect predictions.   My goal is to find which strings out of the 800+
that I use are the most predictable overall. 

The predictor is a small part of a much larger program, over 25K lines as it now stands. The
predictor / forecaster contains several stages which includes formatting the data that's fed to
the actual predictor and another stage that takes the predictors output and turns it into real
world data.  I tried to code it in a manner that allows me to paste prediction code directly into
the program without making any other changes.  This allows for fast turn around time and
also allows me to evaluate the many predictor codes I have came up with over the years.  My
code even allows stacking predictors as a means to compare them against each other or allow
several predictors outputs to be combined for the final prediction.   

The program gathers the information, does all the data processing / formatting and builds the
data strings formatted and ready for the predictor.  The input string variable is named Dat1$. 
Once the predictor is finished processing it prints the predicted value to a string named PV1$,
ie, predicted value.
     
If you want to make it easier for me to test your code then keep these in mind.  The program feeds
the predictor one string at a time, processes the prediction, then adds that value to an array before
moving to the next string where it repeats the process.  Once all the strings have been processed the
program then enters the final stage where the predictions are converted to real world data.

All I need is a program that will try to predict the next value for the string being processed, everything
else is complete.  Input = Dat1$, Output to PV1$.   String data flow is right to left.

I removed my predictor code and replaced it with a simple PRNG that generates a value from
0 to 2.  This was done as a means to test the pre and post processing stages of my code and
provide me a simple easy way to add code posted by others .  A output range of 0 to 2 is used
to produce a 0,1 or 2.  2=the wildcard option, or 50/50, the coin landing on it's side so to say.   

The average PRNG run is around 32% correct, "wildcards removed" from the calculation so the
77% is nothing to scoff at.  I consider it scored very well.  This however is based on a single
event, who knows if may of just been a bad day.

My main program will in the final stages kick out certain predictions based on it's overall past 
performance.  The program only needs 20 to 25 trusted predictions out of the 800+ that it
processes to give me what I need.

Anyway, hope this gives you a better understanding of what I am doing.  Again, 77% is a high
enough score to put this in the keeper box, but it also needs more real world testing to get a
better understanding of how it fairs overall.  It may prove better than a 77% hit rate as it was
only given 44 strings to process.  I spend much more time testing than coding.
 
R1

Edit

The PRNG baseline it taken from the real world, ie, final result where the 77% is gotten from
the string hit rate.  The PRNG taken at the string process averages form 46 to 52%.  On the
other hand the 77% translates to 60% real world, still much higher that the PRNG's 27 to 32%

Just wanted to clear that up.
R1

 

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 12, 2021, 02:55:34 am

Hey R1,

I read ya carefully m8, you've got a big project on your hands. As soon as your predictor part is working how you like it, we can resume the nitty-gritty. As for my code, I made some effort to make it better in case you are still wanting to use it for testing. Noticeable changes are better layering, more systematic and varied test cases, and overall bugfixes. I also am experimenting with how the guess is calculated. These experiments are subject to tweaking or outright removal.

The code below has over a hundred total test cases, but we start at case 79, skipping my data and going right to yours. I think it still scores a 77 in this form, for what that's worth. I honestly think the answer key has errors, but we can skip worrying about that. :-)

Code: QB64: [Select]

1. Option _Explicit
2.  
3. ' Version: 6
4.  
5. Type LetterBin
6.     Signature As String
7.     Count As Integer
8. End Type
9.  
10. Dim Shared TestData(1000, 2) As String
11. Call LoadTestData
12.  
13. Dim Shared Alphabet1(2) As LetterBin ' 0 1
14. Dim Shared Alphabet2(4) As LetterBin ' 00 01 10 11
15. Dim Shared Alphabet3(8) As LetterBin ' 000 001 010 011 100 101 110 111
16. Dim Shared Alphabet4(16) As LetterBin ' etc
17. Dim Shared Alphabet5(32) As LetterBin
18. Dim Shared Alphabet6(64) As LetterBin
19. Dim Shared Alphabet7(128) As LetterBin
20. Dim Shared Alphabet8(256) As LetterBin
21. Dim Shared Alphabet9(512) As LetterBin
22. Dim Shared Alphabet10(1024) As LetterBin
23. Dim Shared Alphabet11(2048) As LetterBin
24. Dim Shared Alphabet12(4096) As LetterBin
25. Dim Shared Alphabet13(8192) As LetterBin
26.  
27. Alphabet1(1).Signature = "0"
28. Alphabet1(2).Signature = "1"
29. Call NewAlphabet(Alphabet1(), Alphabet2())
30. Call NewAlphabet(Alphabet2(), Alphabet3())
31. Call NewAlphabet(Alphabet3(), Alphabet4())
32. Call NewAlphabet(Alphabet4(), Alphabet5())
33. Call NewAlphabet(Alphabet5(), Alphabet6())
34. Call NewAlphabet(Alphabet6(), Alphabet7())
35. Call NewAlphabet(Alphabet7(), Alphabet8())
36. Call NewAlphabet(Alphabet8(), Alphabet9())
37. Call NewAlphabet(Alphabet9(), Alphabet10())
38. Call NewAlphabet(Alphabet10(), Alphabet11())
39. Call NewAlphabet(Alphabet11(), Alphabet12())
40. Call NewAlphabet(Alphabet12(), Alphabet13())
41.  
42. Dim m As Integer
43. Dim k As Integer
44. Dim thestring As String
45. Dim actual As String
46.  
47. m = 79
48. thestring = ""
49. Do
50.  
51.     ' If analyzing pre-cooked data, load test string into Fingerprint(1).
52.     If (m > 0) Then
53.         thestring = TestData(m, 1)
54.         actual = TestData(m, 2)
55.     Else
56.         actual = "?"
57.     End If
58.  
59.     Cls
60.     For k = 1 To _Width
61.         Print "-";
62.     Next
63.     Print
64.     Print "Case:"; m
65.     Print
66.     Call Analyze(thestring, actual)
67.     Print
68.  
69.     _KeyClear: Do: k = _KeyHit: _Limit 30: Loop Until k: _KeyClear
70.  
71.     If (m > 0) Then
72.         m = UserInput1(k, m)
73.     Else
74.         thestring = UserInput2$(k, thestring)
75.     End If
76.  
77.     _KeyClear
78.     _Limit 30
79. Loop
80.  
81. End
82.  
83. Sub Analyze (TheStringIn As String, ActualIn As String)
84.     Dim As Integer j, k
85.     Dim As Double r
86.     Dim Fingerprint(16) As String
87.     Dim p(2 To 13) As Double
88.  
89.     ' Create shifted versions of string, i.e. ABCD -> BCDA, CDAB, DABC, ABCD, BCDA, etc.
90.     Fingerprint(1) = TheStringIn
91.     For k = 2 To UBound(Fingerprint)
92.         Fingerprint(k) = Right$(Fingerprint(k - 1), Len(Fingerprint(k - 1)) - 1) + Left$(Fingerprint(k - 1), 1)
93.     Next
94.  
95.     ' Initialize partial results.
96.     For k = LBound(p) To UBound(p)
97.         p(k) = -999
98.     Next
99.  
100.     Call CreateHisto(Fingerprint(), Alphabet2(), 2)
101.     Call CreateHisto(Fingerprint(), Alphabet3(), 3)
102.     Call CreateHisto(Fingerprint(), Alphabet4(), 4)
103.     Call CreateHisto(Fingerprint(), Alphabet5(), 5)
104.     Call CreateHisto(Fingerprint(), Alphabet6(), 6)
105.     Call CreateHisto(Fingerprint(), Alphabet7(), 7)
106.     Call CreateHisto(Fingerprint(), Alphabet8(), 8)
107.     Call CreateHisto(Fingerprint(), Alphabet9(), 9)
108.     Call CreateHisto(Fingerprint(), Alphabet10(), 10)
109.     Call CreateHisto(Fingerprint(), Alphabet11(), 11)
110.     Call CreateHisto(Fingerprint(), Alphabet12(), 12)
111.     Call CreateHisto(Fingerprint(), Alphabet13(), 13)
112.  
113.     If (Len(TheStringIn) >= 2) Then Call PrintHisto(Alphabet2(), 0) ' Turn the last number high to print stats for that histogram.
114.     If (Len(TheStringIn) >= 3) Then Call PrintHisto(Alphabet3(), 0)
115.     If (Len(TheStringIn) >= 4) Then Call PrintHisto(Alphabet4(), 0)
116.     If (Len(TheStringIn) >= 5) Then Call PrintHisto(Alphabet5(), 0)
117.     If (Len(TheStringIn) >= 6) Then Call PrintHisto(Alphabet6(), 0)
118.     If (Len(TheStringIn) >= 7) Then Call PrintHisto(Alphabet7(), 0)
119.     If (Len(TheStringIn) >= 8) Then Call PrintHisto(Alphabet8(), 0)
120.     If (Len(TheStringIn) >= 9) Then Call PrintHisto(Alphabet9(), 0)
121.     If (Len(TheStringIn) >= 10) Then Call PrintHisto(Alphabet10(), 0)
122.     If (Len(TheStringIn) >= 11) Then Call PrintHisto(Alphabet11(), 0)
123.     If (Len(TheStringIn) >= 12) Then Call PrintHisto(Alphabet12(), 0)
124.     If (Len(TheStringIn) >= 13) Then Call PrintHisto(Alphabet13(), 0)
125.     Print
126.  
127.     If (Len(TheStringIn) >= 2) Then p(2) = MakeGuess(TheStringIn, Alphabet2(), 2, 1) ' Set the last number =1 to print guess for that histogram.
128.     If (Len(TheStringIn) >= 3) Then p(3) = MakeGuess(TheStringIn, Alphabet3(), 3, 1)
129.     If (Len(TheStringIn) >= 4) Then p(4) = MakeGuess(TheStringIn, Alphabet4(), 4, 1)
130.     If (Len(TheStringIn) >= 5) Then p(5) = MakeGuess(TheStringIn, Alphabet5(), 5, 1)
131.     If (Len(TheStringIn) >= 6) Then p(6) = MakeGuess(TheStringIn, Alphabet6(), 6, 1)
132.     If (Len(TheStringIn) >= 7) Then p(7) = MakeGuess(TheStringIn, Alphabet7(), 7, 1)
133.     If (Len(TheStringIn) >= 8) Then p(8) = MakeGuess(TheStringIn, Alphabet8(), 8, 1)
134.     If (Len(TheStringIn) >= 9) Then p(9) = MakeGuess(TheStringIn, Alphabet9(), 9, 1)
135.     If (Len(TheStringIn) >= 10) Then p(10) = MakeGuess(TheStringIn, Alphabet10(), 10, 1)
136.     If (Len(TheStringIn) >= 11) Then p(11) = MakeGuess(TheStringIn, Alphabet11(), 11, 1)
137.     If (Len(TheStringIn) >= 12) Then p(12) = MakeGuess(TheStringIn, Alphabet12(), 12, 1)
138.     If (Len(TheStringIn) >= 13) Then p(13) = MakeGuess(TheStringIn, Alphabet13(), 13, 1)
139.     Print
140.  
141.     Print "Analyzing:"
142.     Print TheStringIn
143.     Print
144.     Print "Thinking:";
145.     For k = LBound(p) To UBound(p)
146.         If (p(k) <> -999) Then Print p(k); Else Print "_ ";
147.     Next
148.     Print: Print
149.  
150.     j = 0
151.     r = 0
152.     Dim h
153.     ' the only human disgression allowed is in the next 10 or so lines
154.     For k = UBound(p) To LBound(p) Step -1
155.         h = 1 + k - LBound(p)
156.         h = h * h ' proposed model: later guesses count for more. this line can be commented out or made more elaborate
157.         If (p(k) <> -999) Then
158.             ' weighted average calculated here
159.             r = r + h * p(k)
160.             j = j + h
161.         End If
162.     Next
163.     If (j <> 0) Then r = r / j
164.     Print "Predicting:  "; _Trim$(Str$(r))
165.     If (r > .5) Then
166.         r = 1
167.     Else
168.         r = 0
169.     End If
170.     Print
171.     Print "Rounding to: "; _Trim$(Str$(r))
172.  
173.     If (ActualIn <> "?") Then
174.         Print
175.         Print "Actual:      "; ActualIn
176.         If (_Trim$(Str$(r)) <> ActualIn) Then
177.             'Beep
178.             Print
179.             Print "*** MISMATCH ***"
180.         End If
181.     End If
182.  
183. End Sub
184.  
185. Function MakeGuess (OrigString As String, arralpha() As LetterBin, wid As Integer, p As Integer)
186.     Dim TheReturn As Double
187.     Dim As Integer j, k, n
188.     TheReturn = 0
189.     j = 1
190.     k = 0
191.     For n = 1 To UBound(arralpha)
192.         If (Left$(arralpha(n).Signature, wid - 1) = Right$(OrigString, wid - 1)) Then
193.             If (arralpha(n).Count >= j) Then
194.                 If (p = 1) Then Print "Order "; _Trim$(Str$(wid)); " guess: "; arralpha(n).Signature; " . "; _Trim$(Str$(arralpha(n).Count))
195.                 TheReturn = TheReturn + Val(Right$(arralpha(n).Signature, 1))
196.                 k = k + 1
197.                 j = arralpha(n).Count
198.             End If
199.         End If
200.     Next
201.     If (k <> 0) Then
202.         TheReturn = TheReturn / k
203.     Else
204.         TheReturn = .5
205.     End If
206.     MakeGuess = TheReturn
207. End Function
208.  
209. Sub CreateHisto (arrfinger() As String, arralpha() As LetterBin, w As Integer)
210.     Dim As Integer j, k, n
211.     For n = 1 To UBound(arralpha)
212.         arralpha(n).Count = 0
213.     Next
214.     For j = 1 To w
215.         For k = 1 To Len(arrfinger(j)) - 0 Step w 'make the 0 a -w? might not matter at all
216.             For n = 1 To UBound(arralpha)
217.                 If (Mid$(arrfinger(j), k, w) = arralpha(n).Signature) Then
218.                     arralpha(n).Count = arralpha(n).Count + 1
219.                 End If
220.             Next
221.         Next
222.     Next
223.     Call QuickSort(arralpha(), 1, UBound(arralpha))
224. End Sub
225.  
226. Sub PrintHisto (arr() As LetterBin, w As Integer)
227.     Dim As Integer j, n
228.     If (w > 0) Then
229.         If (w > UBound(arr)) Then
230.             j = UBound(arr)
231.         Else
232.             j = w
233.         End If
234.         Print "Un-scaled histogram: "; _Trim$(Str$(UBound(arr))); "-letter regroup, showing top "; _Trim$(Str$(w))
235.         For n = 1 To j
236.             Print arr(n).Signature; arr(n).Count
237.         Next
238.     End If
239. End Sub
240.  
241. Function UserInput1 (TheKeyIn As Integer, PresentIndexIn As Integer)
242.     Dim TheReturn As Integer
243.     Dim As Integer j, k
244.     k = TheKeyIn
245.     j = -1
246.     Select Case k ' Arrows
247.         Case 19712
248.             j = PresentIndexIn + 1
249.         Case 19200
250.             j = PresentIndexIn - 1
251.     End Select
252.     TheReturn = j
253.     UserInput1 = TheReturn
254. End Function
255.  
256. Function UserInput2$ (TheKeyIn As Integer, TheStringIn As String)
257.     Dim TheReturn As String
258.     Dim As Integer k
259.     Dim As String t
260.     k = TheKeyIn
261.     t = TheStringIn
262.     Select Case k ' 0, 1, Backspace
263.         Case 48
264.             t = t + "0"
265.         Case 49
266.             t = t + "1"
267.         Case 8
268.             t = Left$(t, Len(t) - 1)
269.     End Select
270.     TheReturn = t
271.     UserInput2$ = TheReturn
272. End Function
273.  
274. Sub NewAlphabet (arrold() As LetterBin, arrnew() As LetterBin)
275.     Dim As Integer j, k, n
276.     n = 0
277.     For k = 1 To 2
278.         For j = 1 To UBound(arrold)
279.             n = n + 1
280.             arrnew(n).Signature = arrold(j).Signature
281.         Next
282.     Next
283.     For j = 1 To UBound(arrnew)
284.         If (j <= UBound(arrnew) / 2) Then
285.             arrnew(j).Signature = "0" + arrnew(j).Signature
286.         Else
287.             arrnew(j).Signature = "1" + arrnew(j).Signature
288.         End If
289.     Next
290. End Sub
291.  
292. 'Sub BubbleSort (arr() As LetterBin)
293. '    Dim As Integer i, j
294. '    Dim As Integer u, v
295. '    For j = UBound(arr) To 1 Step -1
296. '        For i = 2 To UBound(arr)
297. '            u = arr(i - 1).Count
298. '            v = arr(i).Count
299. '            If (u < v) Then
300. '                Swap arr(i - 1), arr(i)
301. '            End If
302. '        Next
303. '    Next
304. 'End Sub
305.  
306. Sub QuickSort (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
307.     Dim As Long piv
308.     If (LowLimit < HighLimit) Then
309.         piv = Partition(arr(), LowLimit, HighLimit)
310.         Call QuickSort(arr(), LowLimit, piv - 1)
311.         Call QuickSort(arr(), piv + 1, HighLimit)
312.     End If
313. End Sub
314.  
315. Function Partition (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
316.     Dim As Long i, j
317.     Dim As Double pivot, tmp
318.     pivot = arr(HighLimit).Count
319.     i = LowLimit - 1
320.     For j = LowLimit To HighLimit - 1
321.         tmp = arr(j).Count - pivot
322.         If (tmp >= 0) Then
323.             i = i + 1
324.             Swap arr(i), arr(j)
325.         End If
326.     Next
327.     Swap arr(i + 1), arr(HighLimit)
328.     Partition = i + 1
329. End Function
330.  
331. Sub LoadTestData
332.     Dim n As Integer
333.     '''
334.     n = 0
335.     '''
336.     ' Test: counting linearly
337.     n = n + 1: TestData(n, 1) = "000001010011100101110111": TestData(n, 2) = "0" '0 to 7
338.     n = n + 1: TestData(n, 1) = "0000000100100011010001010110011110001001101010111100110111101111": TestData(n, 2) = "0" '0 to 15
339.     n = n + 1: TestData(n, 1) = "0000000001000100001100100001010011000111010000100101010010110110001101011100111110000100011001010011101001010110110101111100011001110101101111100111011111011111": TestData(n, 2) = "0" '0 to 31
340.     '''
341.     'n = 0
342.     '''
343.     ' Test: single-one patterns at stepping frequencies, all phases
344.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0"
345.     n = n + 1: TestData(n, 1) = "01010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101": TestData(n, 2) = "0"
346.     n = n + 1: TestData(n, 1) = "10101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010": TestData(n, 2) = "1"
347.     n = n + 1: TestData(n, 1) = "00100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100": TestData(n, 2) = "1"
348.     n = n + 1: TestData(n, 1) = "01001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001": TestData(n, 2) = "0"
349.     n = n + 1: TestData(n, 1) = "10010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010": TestData(n, 2) = "0"
350.     n = n + 1: TestData(n, 1) = "00010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001": TestData(n, 2) = "0"
351.     n = n + 1: TestData(n, 1) = "00100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010": TestData(n, 2) = "0"
352.     n = n + 1: TestData(n, 1) = "01000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100": TestData(n, 2) = "0"
353.     n = n + 1: TestData(n, 1) = "10001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000": TestData(n, 2) = "1"
354.     n = n + 1: TestData(n, 1) = "00001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000": TestData(n, 2) = "0"
355.     n = n + 1: TestData(n, 1) = "00010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000": TestData(n, 2) = "1"
356.     n = n + 1: TestData(n, 1) = "00100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001": TestData(n, 2) = "0"
357.     n = n + 1: TestData(n, 1) = "01000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010": TestData(n, 2) = "0"
358.     n = n + 1: TestData(n, 1) = "10000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100": TestData(n, 2) = "0"
359.     n = n + 1: TestData(n, 1) = "00000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100": TestData(n, 2) = "0"
360.     n = n + 1: TestData(n, 1) = "00001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000": TestData(n, 2) = "0"
361.     n = n + 1: TestData(n, 1) = "00010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000": TestData(n, 2) = "0"
362.     n = n + 1: TestData(n, 1) = "00100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000": TestData(n, 2) = "1"
363.     n = n + 1: TestData(n, 1) = "01000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001": TestData(n, 2) = "0"
364.     n = n + 1: TestData(n, 1) = "10000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010": TestData(n, 2) = "0"
365.     '''
366.     'n = 0
367.     '''
368.     ' Test: single-one patterns, select phases
369.     n = n + 1: TestData(n, 1) = "00000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100": TestData(n, 2) = "0"
370.     n = n + 1: TestData(n, 1) = "00100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000": TestData(n, 2) = "1"
371.     n = n + 1: TestData(n, 1) = "00000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001": TestData(n, 2) = "0"
372.     n = n + 1: TestData(n, 1) = "10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000": TestData(n, 2) = "1"
373.     '''
374.     'n = 0
375.     '''
376.     ' Test: double-one patterns
377.     n = n + 1: TestData(n, 1) = "00110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011": TestData(n, 2) = "0"
378.     n = n + 1: TestData(n, 1) = "01100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110": TestData(n, 2) = "0"
379.     n = n + 1: TestData(n, 1) = "11001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100": TestData(n, 2) = "1"
380.     n = n + 1: TestData(n, 1) = "10011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001": TestData(n, 2) = "1"
381.     n = n + 1: TestData(n, 1) = "00011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100": TestData(n, 2) = "0"
382.     n = n + 1: TestData(n, 1) = "00111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000": TestData(n, 2) = "1"
383.     n = n + 1: TestData(n, 1) = "01110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001": TestData(n, 2) = "1"
384.     n = n + 1: TestData(n, 1) = "11100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011": TestData(n, 2) = "1"
385.     n = n + 1: TestData(n, 1) = "11000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111": TestData(n, 2) = "0"
386.     n = n + 1: TestData(n, 1) = "10001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110": TestData(n, 2) = "0"
387.     '''
388.     'n = 0
389.     '''
390.     ' Test: repeated staggered pattern: 010011000111, all phases
391.     n = n + 1: TestData(n, 1) = "010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111": TestData(n, 2) = "0"
392.     n = n + 1: TestData(n, 1) = "100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110": TestData(n, 2) = "1"
393.     n = n + 1: TestData(n, 1) = "001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101": TestData(n, 2) = "0"
394.     n = n + 1: TestData(n, 1) = "011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010": TestData(n, 2) = "0"
395.     n = n + 1: TestData(n, 1) = "110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100": TestData(n, 2) = "1"
396.     n = n + 1: TestData(n, 1) = "100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001": TestData(n, 2) = "1"
397.     n = n + 1: TestData(n, 1) = "000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011": TestData(n, 2) = "0"
398.     n = n + 1: TestData(n, 1) = "001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110": TestData(n, 2) = "0"
399.     n = n + 1: TestData(n, 1) = "011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100": TestData(n, 2) = "0"
400.     n = n + 1: TestData(n, 1) = "111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000": TestData(n, 2) = "1"
401.     n = n + 1: TestData(n, 1) = "110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001": TestData(n, 2) = "1"
402.     n = n + 1: TestData(n, 1) = "101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011": TestData(n, 2) = "1"
403.     '''
404.     'n = 0
405.     '''
406.     ' Test: repeated staggered pattern: 0100101010101001010101000111, all phases
407.     n = n + 1: TestData(n, 1) = "01001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111": TestData(n, 2) = "0"
408.     n = n + 1: TestData(n, 1) = "10010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110": TestData(n, 2) = "1"
409.     n = n + 1: TestData(n, 1) = "00101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101": TestData(n, 2) = "0"
410.     n = n + 1: TestData(n, 1) = "01010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010": TestData(n, 2) = "0"
411.     n = n + 1: TestData(n, 1) = "10101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100": TestData(n, 2) = "1"
412.     n = n + 1: TestData(n, 1) = "01010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001": TestData(n, 2) = "0"
413.     n = n + 1: TestData(n, 1) = "10101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010": TestData(n, 2) = "1"
414.     n = n + 1: TestData(n, 1) = "01010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101": TestData(n, 2) = "0"
415.     n = n + 1: TestData(n, 1) = "10101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010": TestData(n, 2) = "1"
416.     n = n + 1: TestData(n, 1) = "01010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101": TestData(n, 2) = "0"
417.     n = n + 1: TestData(n, 1) = "10100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010": TestData(n, 2) = "1"
418.     n = n + 1: TestData(n, 1) = "01001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101": TestData(n, 2) = "0"
419.     n = n + 1: TestData(n, 1) = "10010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010": TestData(n, 2) = "1"
420.     n = n + 1: TestData(n, 1) = "00101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101": TestData(n, 2) = "0"
421.     n = n + 1: TestData(n, 1) = "01010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010": TestData(n, 2) = "0"
422.     n = n + 1: TestData(n, 1) = "10101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100": TestData(n, 2) = "1"
423.     n = n + 1: TestData(n, 1) = "01010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001": TestData(n, 2) = "0"
424.     n = n + 1: TestData(n, 1) = "10101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010": TestData(n, 2) = "1"
425.     n = n + 1: TestData(n, 1) = "01010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101": TestData(n, 2) = "0"
426.     n = n + 1: TestData(n, 1) = "10100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010": TestData(n, 2) = "1"
427.     n = n + 1: TestData(n, 1) = "01000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101": TestData(n, 2) = "0"
428.     n = n + 1: TestData(n, 1) = "10001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010": TestData(n, 2) = "1"
429.     n = n + 1: TestData(n, 1) = "00011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101": TestData(n, 2) = "0"
430.     n = n + 1: TestData(n, 1) = "00111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010": TestData(n, 2) = "0"
431.     n = n + 1: TestData(n, 1) = "01110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100": TestData(n, 2) = "0"
432.     n = n + 1: TestData(n, 1) = "11101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000": TestData(n, 2) = "1"
433.     n = n + 1: TestData(n, 1) = "11010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001": TestData(n, 2) = "1"
434.     n = n + 1: TestData(n, 1) = "10100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011": TestData(n, 2) = "1"
435.     '''
436.     'n = 0
437.     '''
438.     ' Test: r1's custom quiz
439.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '1
440.     n = n + 1: TestData(n, 1) = "00000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
441.     n = n + 1: TestData(n, 1) = "00000100000101110000001100010001100001001000000000000000001100000000000000000111001000000000000111100000000100111000000000000010000000001111000000000000000000000000000001010000000000000000010000000000000011000111100001000100000000000000000001101000000000000000001000110110000010000100000011001100001101001000000000000000000010000100001100011000101000000010000000000000000000000000000000000001000000000010000000000000001010000010000000000000000000000000000000000010000100000000000000001011010000000000": TestData(n, 2) = "0" '
442.     n = n + 1: TestData(n, 1) = "00011101100000000001011100001011101000100111101100011000000011001010101000101000111111011000111000100000000000000110110000000001001001110110100001011011101100000011001010001111111110101100001101100001100011000111101100110000000101101101110000001110110111000011000110000000001101111000110000000011111100110001111000011101111101010011111111101111010011011001111101100010001100101101001011000010100111111101111010111111010110001100011000000100010001100111111001101101111000000010110111110000001011010011": TestData(n, 2) = "0" '
443.     n = n + 1: TestData(n, 1) = "00000000100000000000110000000000000000010000000000000000010000000000000000001000000000000000000000000000000001000000010000000000000000000000000000000000000000000000000000011000000000000000001000000001000000000000000000000000000000000000000001001011001000000000000110000000000000000000000000000000000100010000000000000000000000000000000000001100000000000000000000000000000000100000000000000000001000000000000000000000000000000000000000000000100000000000000000100000000000000000000000000000000000000000": TestData(n, 2) = "0" '
444.     n = n + 1: TestData(n, 1) = "01111011010110000100001000011001101101000011000011000000000100110010001010000100010000001110111000001000000000101110101100000000100011100101101110000010110101111001011010100000111011100110100001100100111010111110000010000110010000000100111100110000000101010100111001000000101000100101111001001001000010000100110011011010011011101000110011000000101000000100010000101101000101000110000100010101010111100000000001100000110010000001000011100001001000100000011100000101000001010101000100011010000100010011": TestData(n, 2) = "0" '
445.     n = n + 1: TestData(n, 1) = "11000110011000111000001101000010001000001110001001110010000110000111010001010001100010101100001111100000111100101100000011000111101101110010101101010000101010000001111100000111110101010000000011011100100110101100111101000000100100101000011010000000010110101010011001110011111000010001100110001111111001100010011100010101001100000101010101100000000001001010000011011100010011001000001001110111100110010010000010000111111101100011010101010101000111010110101000000010001001001011011011100101111110110010": TestData(n, 2) = "0" '
446.     n = n + 1: TestData(n, 1) = "10101101010001010110010110011111011111111101110100010011101110000000100011010000100111111001110110100011011110011101110001110011110000111011011110111011101100000010100111100010000010100111110010100100010001010101111000111010011101010111001110110000101101110001110010011101010110101110001111000101011001001101001011111101110010110101001100110010111101010111010010000010110100010001101110110101101110000101101010001001101101011000111110100000011101110010101111011110111110100110101001111101110001010110": TestData(n, 2) = "1" '
447.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
448.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000001000000000000000000000000000100000000000000000000000000000000000000000000000100000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000": TestData(n, 2) = "0" '10
449.     n = n + 1: TestData(n, 1) = "00000110110101110000001100100101000001001111101111100000011000000000001001000100011000000000100011100000100000001001000001000010000000010111001101000001100000010101100011010011111000100111010000000000001010001011101110010100000000000010001011101000010000100000101100110100000011111000000001110000010101010000111111110000000110000100111110011000100000010001010100000000000110000000011000100000000111110011110010000100001010000010011100000000010001101010000000000110010000000110000000110011000000000000": TestData(n, 2) = "0" '
450.     n = n + 1: TestData(n, 1) = "11011001010011000110101011011010000110001001010001001111100111001011110110111010001111010110010100100101011010110010010100111010111001101011100100001010011111111010011100101101000011011011000111011011010110111100110011100010100001101010110101110101110111010111010010011001110100011010011010101111101110100100100111101101001011100001001100100111010101100100101000111111111001001111100111010110111100001000000111101000111000001101011001001110001000010100110011111001001010101001110111010101111001100001": TestData(n, 2) = "0" '
451.     n = n + 1: TestData(n, 1) = "00000000000000000000010000000001100000000000000000000001010000000000110010000000000000000000000000000000000000000000000000001100000000000111000101000000000000000000000000000100010001000000000000000000000000000000001100010010000000000000000001100000000000000000000000000001000000000000000000000000000000000010000011000000000000010000000000000001000000001000000000000000000000000000000000000100100000000000100000000000000000000000000000000000100000000000000000000000000000000000000000100000000000000000": TestData(n, 2) = "0" '
452.     n = n + 1: TestData(n, 1) = "11101000011011010000101000100000010001001000000110011110001011010001001101101010001100111000000101001000011000001010010100010011100110101000101000000000010100111001010100010010101010100011000011000001011010000000010000000001011110110111000010000001011011100000000111001110100000110000000011000101100000001001000100110011000100100000100001001000000011010010100000000100100000101001100000110001001001110101010001000000011000000010101000110010000100001011000001101000101010011011001110010110000010000000": TestData(n, 2) = "0" '
453.     n = n + 1: TestData(n, 1) = "00000010100110101001001000100000010100100100101101010010000001001100000000001011001110011011000010000111111001100010110011000010100110110000000000011010011010010100100011011011001100110001101001110000101001001100100010001101001000001011111100011011100000011001001010111000000000111101111001111001111111101000000000101100011001001011011010010000100001100010011110010000001011000001010111010010011111001001001110111100110010000110100111101000000101110100101010001111001111101100010101001001010101000101": TestData(n, 2) = "0" '
454.     n = n + 1: TestData(n, 1) = "00111100000000000111001001100000111010010010010011100010001100001100000011011000100010000101110010110100110110011100010001111110011011000110010000001001101111111000011000010001101110011101111010100110100110000111011101001111110011011111100110111000001101101110001001001000011110100110000111110111010000001100100100100111110110100001001011100110111000100011110100100100110010011110011011100011101111010010000110000011101100000111001011000110000010001101111011111011001100000010000101000000000000101110": TestData(n, 2) = "0" '
455.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
456.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000100000000000000000000000010000000000000001000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000": TestData(n, 2) = "0" '
457.     n = n + 1: TestData(n, 1) = "00000000010111101100110000001011000001001011001100000001001100001001000001001100010000111111000011100001000000001111010010000100001000000010001101001011101011011010000101010011110110110001100001000010000010100011000000110001000000011101110001000000000000110000100000101100000001011010000101000000100100011000111111110010110101010100011110100110110000010001101000000000101001000010100110000100010100111000010010100100001000110000000100010100010000000010000100011100010010110100010000010010001001000010": TestData(n, 2) = "0" '
458.     n = n + 1: TestData(n, 1) = "11111111011001010010001100000100110110101110100011010010111011110100101000100000000101100000000100110010111110111000110101101010111111011101101010011111100100110100010011011001100000001110111110000101000000001100110101011110011111101100001110011101111100111100011100010010110111100001010000010001101001001111000000000101001000100100000110011000101011100100000100111011010110100000010001011010101011010010100111011000100011001000001010001011101010000100001011001011100001001011101110100110110010111100": TestData(n, 2) = "1" '20
459.     n = n + 1: TestData(n, 1) = "00000000000000000000000000010000000000000000000000000000000100000000100000000000000000000011100000000000000000000000000001000000000000000000000000000011001000000000000100000000000000000000000000010010000000000000000000000000000000000000000000000000000000000000000000000000000010001000000000000000000000000000000000000010000000000000000000000010000000000000000000000000000000000000000000000001001000000000011100000000000000001000000000000000000100000000100010000110100000000000000000000000000000000000": TestData(n, 2) = "0" '
460.     n = n + 1: TestData(n, 1) = "01011000100010001000011010000010010010000100100101000100011001000010000010110110010110001100010001000010110110000011010100000100100010010011111101111100110010101100000001000000100111010000010000100000000111100110000101110001100100000001000001001100100100010000001001000110000000000100011100110110000101100011100010110100000011001001011000010001001000101010010010000001000000100101100101001110110010010000100010100010000000100111001100000000001000111111010100001000001010000010101010110101101000001100": TestData(n, 2) = "0" '
461.     n = n + 1: TestData(n, 1) = "00000101000010010110000110001101111110010001110010000010101001111111010000011011100000110000010101101110101111110101001100000100000000100110001000000000000001110011101011011110000001000110101001000000000000010100010010110110000010001100100010011001010011111011001110110000110100010010000010010110011000010110110010101000111000000100000001101100100110010100110111001110110101010001101100000000110010100010000001000101011100000000000111101110101011001011001100100000001101110000001001101010000000111011": TestData(n, 2) = "0" '
462.     n = n + 1: TestData(n, 1) = "10100010000111100111110001101101100001100111001010011110011001101110100111000111001010100111100010110010101010100100100000101010111100100000010111001000101110010010111000001100011011001011010100101101101110001001111100110000001011100000010110011010001000001101101111001000011101001000110010110111100011111011001100011110100110100111001110000101010001010001101001101001011001111010011001101010000001111010110011100001010100011100110100011011110011100101000001110010010111100111110011001110011111001010": TestData(n, 2) = "1" '
463.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
464.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000100000000000001100000000000000000000000000000000000000000010000000000000000000000000000000001000000000000000000000000000000000001000000000000100000000000000000000000000000000000000000000000001100000000000000000000000000000000000000000000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
465.     n = n + 1: TestData(n, 1) = "00100000011101101100000000000000000000001010001010001010010000000011101000010100001000000110000110100000000010001000111100100100001010110000011000001010110100110011000010001000110101001001100001011000001000000000000010110000100000110000001001000000100000110100100100100001010011000000010101010010100101000000001011100010000000001100000110100010100010000001110000000100000001110010100100001110000001100110000100001000001000000000010000001000001000000001001100000000010011110100000000001010100001111111": TestData(n, 2) = "0" '
466.     n = n + 1: TestData(n, 1) = "01010110100011101001111011101011111111101001100000010100001001111110010111100011101100011111110001101101111000110011010011010011110000101111110110010001000001010100100100110011010010010110101011100000111111111101111110110011111101010011110000111101000010010011010000011100001000011011000011001101100011011101000101010101111011000100001111010100111001011100011100011011011000000010011010010100110010011001111011010010110011111000101110010111111100100100111110111010101001101011010100000001011010010000": TestData(n, 2) = "1" '
467.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000100000001000000000000000000000000000000000000000001000000000000000000000000000000000000000010000000000000010010100000000000001000000000001000100000000000000000000001000000000000000000000000000000010000000010000000000000000000000001000000010000000000000000000000000000000000000000010000000110000000000000000000000001000000000010000100000000000000000100000001000000010000000000000000000000010000000000000000001000000000000000": TestData(n, 2) = "0" '
468.     n = n + 1: TestData(n, 1) = "00000001100010111010101010001001000011001100000000000000010011000111001101001010110010010010010100101010000001001000111000000010110000010001001110100000000101101001110100010100000101000100000101000000010000110000010011010000100101001111000000011110001000001101101100000001000101000000011001011001110111100010010001000011110011110010010001000001110100100010101001110000010100000010010100000000101001000100101000011000000001001010111010110100000011001100101010000000100100100111111001110101000100000001": TestData(n, 2) = "0" '30
469.     n = n + 1: TestData(n, 1) = "11010010010101000010000011010000101110111010011001101000101111011101001110000001011110100101101111000100000010110001010101000110100001100000111000111100011110110011101101101111101010100100011101000000010010101110000011011100010010101110101010000001110001001111110011011101000010110000101111000000101100011100101100001001100001111110000101110000010010000001001010000000011011000001000101000100000111101100110011000111010000001000010000000000100101010001100001011000001010001000111111110110101000011111": TestData(n, 2) = "0" '
470.     n = n + 1: TestData(n, 1) = "11011111000111100000010011111111101111001100100010111010010000011000110100111010011000111101000111010000110110101010011010101011100110011101000001011011111110011100110100001001010000001000010010100101111011000101001000000011110011110001100100100011011001010000101101111110101011011100000111000111000011110101111011101000101010000111011110000111111101011101110110001000011000111011011011111100110000001011011010110101101111011001011000111100101100111010011100110111101100110110100110000010011111110101": TestData(n, 2) = "0" '
471.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
472.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
473.     n = n + 1: TestData(n, 1) = "00100000000000000011000000000000000000000110000010011111100000000000000001000000001000000000000000010110000110000001100010000000000011110000000001100000000000110011000011000000010000001110000000011000001000010000110100000010000000111101000000000000000000100000000001100000100011000000000100000000000101000000000011010000001100010100000110110010100001010000110000001000000001100000110000001100000000011010000000000000101001100000000000000000100000011010100000000010010000100100010000000000000001111000": TestData(n, 2) = "0" '
474.     n = n + 1: TestData(n, 1) = "00010100011101010101100000101000001100111001101101000000011001111001100110110111010111111011110001100000000001100000011001111000111001000110011010001110100110011001110111100000101000110001100110100111000111001000001001110101101110000000110000000000011001010101000110011101011001100011001001011001101100011110000101101001100011001010011000001100110000101000001111110110000000001100001100010010101111100101001101010000000110011011111100011111010000000101000000100101100111010110001101111010101010000110": TestData(n, 2) = "1" '
475.     n = n + 1: TestData(n, 1) = "00000010000000000001100000000000000001000000000000000000000000000000000000000000000001001000000000000000000100000000000000000000010000000000000000100100000101000001000000100001100000000000000000000000000010110000000000000000100001000000000000001000000001100010000000010000010000000000000110000000001000000000001000010000000000010000000000000000000000000000000000000100001000000000000100001000000000000000000100000000000100000000000000000000000001001000000000000000000001000010000000000010000011000000": TestData(n, 2) = "0" '
476.     n = n + 1: TestData(n, 1) = "11010000111110000000000011000001011000010011010100100000000000110011011101010010100100000000000000010001101001000001001010011000100101101000111011000001000010010000010000010100001000100110100001100100001001001001100011110010011000110111000011000000011000000000100110001000101101100000001000000000000100000000000001001110001110100000010100001011101010110100001001001000000010010100001010100111011111000100001010000011010001000011001101110001101110000011010101101001010100110100010001011100110100110111": TestData(n, 2) = "1" '
477.     n = n + 1: TestData(n, 1) = "00000000110110001000000011001000100000001110011010100010101101111100101100101000001010000000101101010100101011010000010001001110001001100001110101011010111010000100001011001010010100011001011000010000100001000000000100001111001000101011111110100001110010011000100001101000101001101011110001011111000110111010010101000001001011101101110000001011110000011001100011111001010100010101110011000100110000101101010010110000000000010011001001101101000010000010001110000011111100111101100100110000001000110000": TestData(n, 2) = "0" '
478.     n = n + 1: TestData(n, 1) = "00101101111001100011001000011101001000000001100000101001000010110101000011001101110010110011000010101100111010101111100101100111000010110111010100000000001010000111111011001000111011100100011111101010010101011111111010010110010001101010100101010110111010111000101111001101001101101111010101010010110001000110110110101000010100001000010011101010011110001000001111001100110001011010100011101011100000100000111001000111001010101111010010010100110111001000100011010110100011111011101001101010111101101010": TestData(n, 2) = "0" '40
479.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
480.     n = n + 1: TestData(n, 1) = "10000000100000000000000001001001000000100011010001010100000100000000010101100110101000000000000100000101010000000101000000000101100000000000010000001000001011000110100110100010010100010111000100000100001010000000101010001000111001000000010000100100000000000000100000001001000000110001010001001010010000000010101001000111011000100100100000010010000100100000000000001000010010000110010110000110100000000000101001010100000110010001110000111000000110000000000000000000000100101100001010000100000101100010": TestData(n, 2) = "0" '
481.     n = n + 1: TestData(n, 1) = "00001101011011101101111110010000011011010000101110101011001001111000101010010001010111100001110011011010100011011010101010111010001010100110101100000110110100101001011001010000001010100000111010111011100100110111010101010100000010000010101110001011010011001111011110110000110010001010001000110100101111101100000110111000000000000010001111101001011011010111110110000100101000111000101001110001010011110100010100100011110000001100001011000100100000011110111111100011000011000011100101111010111010010101": TestData(n, 2) = "1" '
482.     n = n + 1: TestData(n, 1) = "01110011000100111110101110110110101110011100101000000011111010011111101010001000000000111110011010111010001110111000111111010010011101111101100111110001000000011000001000001101101001001000010001011000010001111100010001100111000100111111100011010001101101110110000001010110001111000100101110010001101101010001010110110000100111011001010100101101110000001111001111110111100101101001001001111001011111111011000010101001001001101010001111000011011001111111001011111101111001010010110000100001010000011000": TestData(n, 2) = "0" '
483. End Sub

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 12, 2021, 09:42:46 pm

Sounds good, I am making a few changes to your code so that it's more compatible with my
programs existing code.  Once it's in the loop so to say I can automate the testing process 
and use all 800+ strings.  Should be interesting. 

R1             
 

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 12, 2021, 10:44:39 pm

Hey r1 - without wearing the subject out, I'll forewarn that I am still streamlining the code. Today I realized I had a few variables of the wrong type, which was actually making the guesses too crude. Very hard to notice this, but it was true. Anyway, i'll try to find a sensible place to post the latest code so you always get the best. Good luck in the meantime!

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 13, 2021, 02:49:32 pm

Glad to see I'm not the only one. For me it's mixing variable types, one works for this
but need another for that.  I started storing the product as a string$ then use val($)
in my final calculations.  Maybe not the most efficient method but it helps keep things
straight.  I have a old function I picked up years ago called StrNum$.  Don't remember
the original author.

Code: QB64: [Select]

1. FUNCTION StrNum$ (n#)
2. value$ = UCASE$(LTRIM$(STR$(n#)))
3. XPOS1% = INSTR(value$, "D") + INSTR(value$, "E") 'only D or E can be present
4. IF XPOS1% THEN
5. expo% = VAL(MID$(value$, XPOS1% + 1))
6. IF VAL(value$) < 0 THEN
7. sign$ = "-": value$ = MID$(value$, 2, XPOS1% - 2)
8. ELSE value$ = MID$(value$, 1, XPOS1% - 1)
9. END IF
10. dot% = INSTR(value$, "."): L% = LEN(value$)
11. IF expo% > 0 THEN ADD$ = STRING$(expo% - (L% - dot%), "0")
12. IF expo% < 0 THEN min$ = STRING$(ABS(expo%) - (dot% - 1), "0"): DP$ = "."
13. FOR n = 1 TO L%
14. IF MID$(value$, n, 1) <> "." THEN num$ = num$ + MID$(value$, n, 1)
15. NEXT
16. ELSE STRNUM$ = value$: EXIT FUNCTION
17. END IF
18. STRNUM$ = sign$ + DP$ + min$ + num$ + ADD$
19. END FUNCTION  

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 13, 2021, 03:38:47 pm

P.S.
While your streamlining your code, if you could change it so that it processes a single string, makes
it's prediction then passes that value on, it would be much easier to add to my code.  There is quite
a bit of processing going on before and after each prediction is made.   My program is designed to
cook the data so to say, hand that data to the predictor then take the predicted value and move on. 

I am in the process of editing your code so that it works well with my code.  If there is going to be
several versions / updates then I think you can see the advantages.  I have at least 10 old predictors
that I can add or remove from the main program by simply using copy and paste.  I keep my old
prediction tools thinking some day I might be able to improve them.

R1       


   

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 13, 2021, 05:26:33 pm

I attached another string file.  These strings, show the same data in a different format.

If the string value repeated, ie, the same value (0) or (1) carried over from the previous
event then the value is (1), if not then (0).  This list contains 112 strings 500 values in
length.  The strings flow is right to left.  The strings with  "****"  indicate events that
have been culled from the list but kept in place for later use.

At the bottom of the file is a small set of stats that that show the number of times each
value repeated within each string and the repeat probability.   

This data could be a bit easier to predict, my code is already capable of generating the
data and make all the needed conversions.

R1

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 13, 2021, 08:54:02 pm

Hey r1,

So a few updates...

(Part I) I made my prediction function into more of a black box so it can be used in isolation. Of course, it still needs to the "alphabet" arrays

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.  

defined and filled in order to work. In practice that full chunk of code would go in the BI section, and then all one needs to do is use one line:

Code: QB64: [Select]

1. prediction = Analyze(thestring, actual, 1)

Pretty simple, the answer "prediction" is a 1 or a 0, the "Analyze" function takes three arguments:
(a) the string to analyze, i.e. "1001101001010101"
(b) the known next digit, if it exists. otherwise, this argument must be a "?"
(c) an optional flag for printing, just set this to zero

...so that should help....

Part (II) is more intersting...

So I looked at the file you provided, and then read what you said about it, and then had to write another program to wrestle your data into a form that my program already uses. Reading a string left-to-right is a little more natural to me, so I reversed all your strings. I also (as kindof a checksum) made sure I could re-derive all of the decimal values you included at the bottom. I unambiguously know exactly where those come from. Inspired by this, I edited my analysis function to calculate those same numbers (for any input string, not just the new ones).

The new results are only mildly interesting, and hardly surprising. Punchline is, using that decimal is a rather crummy way to estimate what number comes next. Case in point would be something like:

0101010101010101010101
versus
1010101010101010101010

Those two strings differ by just a phase but would produce identical decimals. All the reason why an n-gram based approach is much more revealing. But anyway, I ramble. This program is pre-set to analyze your newest data:

Code: QB64: [Select]

1. Option _Explicit
2.  
3. Screen _NewImage(120, 60)
4.  
5. ' Version: 7
6.  
7. Type LetterBin
8.     Signature As String
9.     Count As Integer
10. End Type
11.  
12. Dim Shared TestData(1000, 2) As String
13. Call LoadTestData
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. Dim m As Integer
45. Dim k As Integer
46. Dim thestring As String
47. Dim actual As String
48. Dim prediction As Integer
49.  
50. m = 1
51. thestring = ""
52. Do
53.  
54.     ' If analyzing pre-cooked data, load a test string.
55.     If (m > 0) Then
56.         thestring = TestData(m, 1)
57.         actual = TestData(m, 2)
58.     Else
59.         actual = "?"
60.     End If
61.  
62.     Cls
63.     For k = 1 To _Width
64.         Print "-";
65.     Next
66.     Print
67.     Print "Case:"; m
68.     Print
69.     prediction = Analyze(thestring, actual, 1)
70.     'Print "("; prediction; ")"
71.  
72.     _KeyClear: Do: k = _KeyHit: _Limit 30: Loop Until k: _KeyClear
73.  
74.     If (m > 0) Then
75.         m = UserInput1(k, m)
76.     Else
77.         thestring = UserInput2$(k, thestring)
78.     End If
79.  
80.     '_Delay 1
81.     'm = m + 1
82.  
83.     _KeyClear
84.     _Limit 30
85. Loop
86.  
87. End
88.  
89. Function Analyze (TheStringIn As String, ActualIn As String, pswitch As Integer)
90.     Dim TheReturn As Integer
91.     Dim As Integer n
92.     Dim As Double r, j, k, h
93.     Dim Fingerprint(16) As String
94.     Dim p(2 To 13, 2) As Double
95.  
96.     ' Create shifted versions of string, i.e. ABCD -> BCDA, CDAB, DABC, ABCD, BCDA, etc.
97.     Fingerprint(1) = TheStringIn
98.     For n = 2 To UBound(Fingerprint)
99.         Fingerprint(n) = Right$(Fingerprint(n - 1), Len(Fingerprint(n - 1)) - 1) + Left$(Fingerprint(n - 1), 1)
100.     Next
101.  
102.     ' Initialize partial results.
103.     For n = LBound(p) To UBound(p)
104.         p(n, 1) = -999
105.     Next
106.  
107.     Call CreateHisto(Fingerprint(), Alphabet2(), 2, 0) ' Set the last number =1 to print steps.
108.     Call CreateHisto(Fingerprint(), Alphabet3(), 3, 0)
109.     Call CreateHisto(Fingerprint(), Alphabet4(), 4, 0)
110.     Call CreateHisto(Fingerprint(), Alphabet5(), 5, 0)
111.     Call CreateHisto(Fingerprint(), Alphabet6(), 6, 0)
112.     Call CreateHisto(Fingerprint(), Alphabet7(), 7, 0)
113.     Call CreateHisto(Fingerprint(), Alphabet8(), 8, 0)
114.     Call CreateHisto(Fingerprint(), Alphabet9(), 9, 0)
115.     Call CreateHisto(Fingerprint(), Alphabet10(), 10, 0)
116.     Call CreateHisto(Fingerprint(), Alphabet11(), 11, 0)
117.     Call CreateHisto(Fingerprint(), Alphabet12(), 12, 0)
118.     Call CreateHisto(Fingerprint(), Alphabet13(), 13, 0)
119.  
120.     If (pswitch = 1) Then
121.         If (Len(TheStringIn) >= 2) Then Call PrintHisto(Alphabet2(), 3) ' Set the last number >=1 to print stats for that histogram.
122.         If (Len(TheStringIn) >= 3) Then Call PrintHisto(Alphabet3(), 3)
123.         If (Len(TheStringIn) >= 4) Then Call PrintHisto(Alphabet4(), 3)
124.         If (Len(TheStringIn) >= 5) Then Call PrintHisto(Alphabet5(), 3)
125.         If (Len(TheStringIn) >= 6) Then Call PrintHisto(Alphabet6(), 0)
126.         If (Len(TheStringIn) >= 7) Then Call PrintHisto(Alphabet7(), 0)
127.         If (Len(TheStringIn) >= 8) Then Call PrintHisto(Alphabet8(), 0)
128.         If (Len(TheStringIn) >= 9) Then Call PrintHisto(Alphabet9(), 0)
129.         If (Len(TheStringIn) >= 10) Then Call PrintHisto(Alphabet10(), 0)
130.         If (Len(TheStringIn) >= 11) Then Call PrintHisto(Alphabet11(), 0)
131.         If (Len(TheStringIn) >= 12) Then Call PrintHisto(Alphabet12(), 0)
132.         If (Len(TheStringIn) >= 13) Then Call PrintHisto(Alphabet13(), 0)
133.         Print
134.     End If
135.  
136.     If (Len(TheStringIn) >= 2) Then Call MakeGuess(TheStringIn, Alphabet2(), 2, p(), pswitch) ' Set the last number =1 to print guess for that histogram.
137.     If (Len(TheStringIn) >= 3) Then Call MakeGuess(TheStringIn, Alphabet3(), 3, p(), pswitch)
138.     If (Len(TheStringIn) >= 4) Then Call MakeGuess(TheStringIn, Alphabet4(), 4, p(), pswitch)
139.     If (Len(TheStringIn) >= 5) Then Call MakeGuess(TheStringIn, Alphabet5(), 5, p(), pswitch)
140.     If (Len(TheStringIn) >= 6) Then Call MakeGuess(TheStringIn, Alphabet6(), 6, p(), pswitch)
141.     If (Len(TheStringIn) >= 7) Then Call MakeGuess(TheStringIn, Alphabet7(), 7, p(), pswitch)
142.     If (Len(TheStringIn) >= 8) Then Call MakeGuess(TheStringIn, Alphabet8(), 8, p(), pswitch)
143.     If (Len(TheStringIn) >= 9) Then Call MakeGuess(TheStringIn, Alphabet9(), 9, p(), pswitch)
144.     If (Len(TheStringIn) >= 10) Then Call MakeGuess(TheStringIn, Alphabet10(), 10, p(), pswitch)
145.     If (Len(TheStringIn) >= 11) Then Call MakeGuess(TheStringIn, Alphabet11(), 11, p(), pswitch)
146.     If (Len(TheStringIn) >= 12) Then Call MakeGuess(TheStringIn, Alphabet12(), 12, p(), pswitch)
147.     If (Len(TheStringIn) >= 13) Then Call MakeGuess(TheStringIn, Alphabet13(), 13, p(), pswitch)
148.     If (pswitch = 1) Then Print
149.  
150.     If (pswitch = 1) Then
151.         Print "Analyzing:"
152.         Print TheStringIn
153.         Print
154.         Print "Thinking:";
155.         For k = LBound(p) To UBound(p)
156.             If (p(k, 1) <> -999) Then
157.                 Print p(k, 1);
158.             Else
159.                 Print "_ ";
160.             End If
161.         Next
162.         Print: Print
163.     End If
164.  
165.     j = 0
166.     r = 0
167.  
168.     For k = UBound(p) To LBound(p) Step -1
169.         If (p(k, 1) <> -999) Then
170.  
171.             ' This is the made-up part of the model:
172.             ' The variable r contributes to weighted average.
173.             ' The variable j is used for normalization.
174.             ' Scaling factor h influences weighted average calculaton.
175.             ' The factors multiplying h are totally arbitrary. Notes:
176.             '   setting o(h^2) means the later alphabets count for more.
177.             '   p(k, 1) euqals the calculated guess at frequency k.
178.             '   p(k, 2) euqals the peak count of the unscaled histogram.
179.             '   ...while p(k, 2) is here, it does not seem to help calculations.
180.  
181.             h = 1 + k - LBound(p)
182.  
183.             h = h ^ 2
184.  
185.             ' Standard weighted average:
186.             r = r + h * p(k, 1)
187.             j = j + h
188.  
189.         End If
190.     Next
191.     If (j <> 0) Then
192.         r = r / j
193.     End If
194.  
195.     If (pswitch = 1) Then Print "Predicting:  "; _Trim$(Str$(r))
196.  
197.     If (r > .5) Then
198.         r = 1
199.     Else
200.         r = 0
201.     End If
202.  
203.     If (pswitch = 1) Then
204.         Print "Rounding to: "; _Trim$(Str$(r))
205.         If (ActualIn <> "?") Then
206.             Print
207.             Print "Actual:      "; ActualIn
208.             If (_Trim$(Str$(r)) <> ActualIn) Then
209.                 Beep
210.                 Print
211.                 Print "*** MISMATCH ***"
212.             End If
213.         Else
214.             n = Len(TheStringIn)
215.             h = 0
216.             For k = 1 To n
217.                 If Val(Mid$(TheStringIn, k, 1)) = 1 Then h = h + 1
218.             Next
219.             h = h / n
220.             Print
221.             Print "Naive (dec): "; _Trim$(Str$(h))
222.             If (h > .5) Then
223.                 h = 1
224.             Else
225.                 h = 0
226.             End If
227.             Print "Naive (int): "; _Trim$(Str$(h))
228.             If (r <> h) Then
229.                 Beep
230.                 Print
231.                 Print "*** MISMATCH ***"
232.             End If
233.         End If
234.     End If
235.  
236.     TheReturn = r
237.     Analyze = TheReturn
238. End Function
239.  
240. Sub MakeGuess (OrigString As String, arralpha() As LetterBin, wid As Integer, arrbeta() As Double, pswitch As Integer)
241.     Dim TheReturn As Double
242.     Dim As Integer j, k, n
243.     TheReturn = 0
244.     j = 1 '0
245.     k = 0
246.     For n = 1 To UBound(arralpha)
247.         If (Left$(arralpha(n).Signature, wid - 1) = Right$(OrigString, wid - 1)) Then
248.             If (arralpha(n).Count >= j) Then
249.                 If (pswitch = 1) Then Print "Order-"; Right$("0" + _Trim$(Str$(wid)), 2); " guess: "; arralpha(n).Signature; " . "; _Trim$(Str$(arralpha(n).Count))
250.                 TheReturn = TheReturn + Val(Right$(arralpha(n).Signature, 1))
251.                 k = k + 1
252.                 j = arralpha(n).Count
253.             End If
254.         End If
255.     Next
256.     If (k <> 0) Then
257.         TheReturn = TheReturn / k
258.         arrbeta(wid, 1) = TheReturn
259.         arrbeta(wid, 2) = j
260.     Else
261.         TheReturn = .5
262.         arrbeta(wid, 1) = TheReturn
263.         arrbeta(wid, 2) = j
264.     End If
265. End Sub
266.  
267. Sub CreateHisto (arrfinger() As String, arralpha() As LetterBin, w As Integer, pswitch As Integer)
268.     Dim As Integer j, k, n
269.     For n = 1 To UBound(arralpha)
270.         arralpha(n).Count = 0
271.     Next
272.     For j = 1 To w '1 'w
273.         For k = 1 To Len(arrfinger(j)) - (Len(arrfinger(j)) Mod w) Step w '- 0 Step 1 'w 'make the 0 a -w? might not matter at all
274.             If (pswitch = 1) Then Print j; " "; arrfinger(j)
275.             For n = 1 To UBound(arralpha)
276.                 If (pswitch = 1) Then
277.                     Print "@@@"; n; " "; Mid$(arrfinger(j), k, w); " "; arralpha(n).Signature;
278.                 End If
279.                 If (Mid$(arrfinger(j), k, w) = arralpha(n).Signature) Then
280.                     arralpha(n).Count = arralpha(n).Count + 1
281.                     If (pswitch = 1) Then Print "***";
282.                 End If
283.                 If pswitch = 1 Then Print
284.             Next
285.         Next
286.     Next
287.     Call QuickSort(arralpha(), 1, UBound(arralpha))
288. End Sub
289.  
290. Sub PrintHisto (arr() As LetterBin, w As Integer)
291.     Dim As Integer j, n
292.     If (w > 0) Then
293.         If (w > UBound(arr)) Then
294.             j = UBound(arr)
295.         Else
296.             j = w
297.         End If
298.         Print "Histogram: "; _Trim$(Str$(UBound(arr))); "-letter regroup, showing top "; _Trim$(Str$(w))
299.         For n = 1 To j
300.             Print arr(n).Signature; arr(n).Count
301.         Next
302.     End If
303. End Sub
304.  
305. Function UserInput1 (TheKeyIn As Integer, PresentIndexIn As Integer)
306.     Dim TheReturn As Integer
307.     Dim As Integer j, k
308.     k = TheKeyIn
309.     j = -1
310.     Select Case k ' Arrows
311.         Case 19712
312.             j = PresentIndexIn + 1
313.         Case 19200
314.             j = PresentIndexIn - 1
315.     End Select
316.     TheReturn = j
317.     UserInput1 = TheReturn
318. End Function
319.  
320. Function UserInput2$ (TheKeyIn As Integer, TheStringIn As String)
321.     Dim TheReturn As String
322.     Dim As Integer k
323.     Dim As String t
324.     k = TheKeyIn
325.     t = TheStringIn
326.     Select Case k ' 0, 1, Backspace
327.         Case 48
328.             t = t + "0"
329.         Case 49
330.             t = t + "1"
331.         Case 8
332.             t = Left$(t, Len(t) - 1)
333.     End Select
334.     TheReturn = t
335.     UserInput2$ = TheReturn
336. End Function
337.  
338. Sub NewAlphabet (arrold() As LetterBin, arrnew() As LetterBin)
339.     Dim As Integer j, k, n
340.     n = 0
341.     For k = 1 To 2
342.         For j = 1 To UBound(arrold)
343.             n = n + 1
344.             arrnew(n).Signature = arrold(j).Signature
345.         Next
346.     Next
347.     For j = 1 To UBound(arrnew)
348.         If (j <= UBound(arrnew) / 2) Then
349.             arrnew(j).Signature = "0" + arrnew(j).Signature
350.         Else
351.             arrnew(j).Signature = "1" + arrnew(j).Signature
352.         End If
353.     Next
354. End Sub
355.  
356. Sub QuickSort (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
357.     Dim As Long piv
358.     If (LowLimit < HighLimit) Then
359.         piv = Partition(arr(), LowLimit, HighLimit)
360.         Call QuickSort(arr(), LowLimit, piv - 1)
361.         Call QuickSort(arr(), piv + 1, HighLimit)
362.     End If
363. End Sub
364.  
365. Function Partition (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
366.     Dim As Long i, j
367.     Dim As Double pivot, tmp
368.     pivot = arr(HighLimit).Count
369.     i = LowLimit - 1
370.     For j = LowLimit To HighLimit - 1
371.         tmp = arr(j).Count - pivot
372.         If (tmp >= 0) Then
373.             i = i + 1
374.             Swap arr(i), arr(j)
375.         End If
376.     Next
377.     Swap arr(i + 1), arr(HighLimit)
378.     Partition = i + 1
379. End Function
380.  
381. Sub LoadTestData
382.     Dim n As Integer
383.     '''
384.     n = 0
385.     '''
386.     ' Test: counting linearly
387.     n = n + 1: TestData(n, 1) = "000001010011100101110111": TestData(n, 2) = "0" '0 to 7
388.     n = n + 1: TestData(n, 1) = "0000000100100011010001010110011110001001101010111100110111101111": TestData(n, 2) = "0" '0 to 15
389.     n = n + 1: TestData(n, 1) = "0000000001000100001100100001010011000111010000100101010010110110001101011100111110000100011001010011101001010110110101111100011001110101101111100111011111011111": TestData(n, 2) = "0" '0 to 31
390.     '''
391.     'n = 0
392.     '''
393.     ' Test: single-one patterns at stepping frequencies, all phases
394.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0"
395.     n = n + 1: TestData(n, 1) = "01010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101": TestData(n, 2) = "0"
396.     n = n + 1: TestData(n, 1) = "10101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010": TestData(n, 2) = "1"
397.     n = n + 1: TestData(n, 1) = "00100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100": TestData(n, 2) = "1"
398.     n = n + 1: TestData(n, 1) = "01001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001": TestData(n, 2) = "0"
399.     n = n + 1: TestData(n, 1) = "10010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010": TestData(n, 2) = "0"
400.     n = n + 1: TestData(n, 1) = "00010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001": TestData(n, 2) = "0"
401.     n = n + 1: TestData(n, 1) = "00100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010": TestData(n, 2) = "0"
402.     n = n + 1: TestData(n, 1) = "01000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100": TestData(n, 2) = "0"
403.     n = n + 1: TestData(n, 1) = "10001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000": TestData(n, 2) = "1"
404.     n = n + 1: TestData(n, 1) = "00001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000": TestData(n, 2) = "0"
405.     n = n + 1: TestData(n, 1) = "00010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000": TestData(n, 2) = "1"
406.     n = n + 1: TestData(n, 1) = "00100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001": TestData(n, 2) = "0"
407.     n = n + 1: TestData(n, 1) = "01000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010": TestData(n, 2) = "0"
408.     n = n + 1: TestData(n, 1) = "10000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100": TestData(n, 2) = "0"
409.     n = n + 1: TestData(n, 1) = "00000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100": TestData(n, 2) = "0"
410.     n = n + 1: TestData(n, 1) = "00001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000": TestData(n, 2) = "0"
411.     n = n + 1: TestData(n, 1) = "00010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000": TestData(n, 2) = "0"
412.     n = n + 1: TestData(n, 1) = "00100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000": TestData(n, 2) = "1"
413.     n = n + 1: TestData(n, 1) = "01000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001": TestData(n, 2) = "0"
414.     n = n + 1: TestData(n, 1) = "10000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010": TestData(n, 2) = "0"
415.     '''
416.     'n = 0
417.     '''
418.     ' Test: single-one patterns, select phases
419.     n = n + 1: TestData(n, 1) = "00000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100": TestData(n, 2) = "0"
420.     n = n + 1: TestData(n, 1) = "00100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000": TestData(n, 2) = "1"
421.     n = n + 1: TestData(n, 1) = "00000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001": TestData(n, 2) = "0"
422.     n = n + 1: TestData(n, 1) = "10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000": TestData(n, 2) = "1"
423.     '''
424.     'n = 0
425.     '''
426.     ' Test: double-one patterns
427.     n = n + 1: TestData(n, 1) = "00110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011": TestData(n, 2) = "0"
428.     n = n + 1: TestData(n, 1) = "01100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110": TestData(n, 2) = "0"
429.     n = n + 1: TestData(n, 1) = "11001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100": TestData(n, 2) = "1"
430.     n = n + 1: TestData(n, 1) = "10011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001": TestData(n, 2) = "1"
431.     n = n + 1: TestData(n, 1) = "00011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100": TestData(n, 2) = "0"
432.     n = n + 1: TestData(n, 1) = "00111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000": TestData(n, 2) = "1"
433.     n = n + 1: TestData(n, 1) = "01110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001": TestData(n, 2) = "1"
434.     n = n + 1: TestData(n, 1) = "11100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011": TestData(n, 2) = "1"
435.     n = n + 1: TestData(n, 1) = "11000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111": TestData(n, 2) = "0"
436.     n = n + 1: TestData(n, 1) = "10001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110": TestData(n, 2) = "0"
437.     '''
438.     'n = 0
439.     '''
440.     ' Test: repeated staggered pattern: 010011000111, all phases
441.     n = n + 1: TestData(n, 1) = "010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111": TestData(n, 2) = "0"
442.     n = n + 1: TestData(n, 1) = "100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110": TestData(n, 2) = "1"
443.     n = n + 1: TestData(n, 1) = "001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101": TestData(n, 2) = "0"
444.     n = n + 1: TestData(n, 1) = "011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010": TestData(n, 2) = "0"
445.     n = n + 1: TestData(n, 1) = "110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100": TestData(n, 2) = "1"
446.     n = n + 1: TestData(n, 1) = "100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001": TestData(n, 2) = "1"
447.     n = n + 1: TestData(n, 1) = "000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011": TestData(n, 2) = "0"
448.     n = n + 1: TestData(n, 1) = "001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110": TestData(n, 2) = "0"
449.     n = n + 1: TestData(n, 1) = "011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100": TestData(n, 2) = "0"
450.     n = n + 1: TestData(n, 1) = "111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000": TestData(n, 2) = "1"
451.     n = n + 1: TestData(n, 1) = "110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001": TestData(n, 2) = "1"
452.     n = n + 1: TestData(n, 1) = "101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011": TestData(n, 2) = "1"
453.     '''
454.     'n = 0
455.     '''
456.     ' Test: repeated staggered pattern: 0100101010101001010101000111, all phases
457.     n = n + 1: TestData(n, 1) = "01001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111": TestData(n, 2) = "0"
458.     n = n + 1: TestData(n, 1) = "10010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110": TestData(n, 2) = "1"
459.     n = n + 1: TestData(n, 1) = "00101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101": TestData(n, 2) = "0"
460.     n = n + 1: TestData(n, 1) = "01010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010": TestData(n, 2) = "0"
461.     n = n + 1: TestData(n, 1) = "10101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100": TestData(n, 2) = "1"
462.     n = n + 1: TestData(n, 1) = "01010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001": TestData(n, 2) = "0"
463.     n = n + 1: TestData(n, 1) = "10101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010": TestData(n, 2) = "1"
464.     n = n + 1: TestData(n, 1) = "01010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101": TestData(n, 2) = "0"
465.     n = n + 1: TestData(n, 1) = "10101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010": TestData(n, 2) = "1"
466.     n = n + 1: TestData(n, 1) = "01010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101": TestData(n, 2) = "0"
467.     n = n + 1: TestData(n, 1) = "10100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010": TestData(n, 2) = "1"
468.     n = n + 1: TestData(n, 1) = "01001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101": TestData(n, 2) = "0"
469.     n = n + 1: TestData(n, 1) = "10010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010": TestData(n, 2) = "1"
470.     n = n + 1: TestData(n, 1) = "00101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101": TestData(n, 2) = "0"
471.     n = n + 1: TestData(n, 1) = "01010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010": TestData(n, 2) = "0"
472.     n = n + 1: TestData(n, 1) = "10101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100": TestData(n, 2) = "1"
473.     n = n + 1: TestData(n, 1) = "01010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001": TestData(n, 2) = "0"
474.     n = n + 1: TestData(n, 1) = "10101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010": TestData(n, 2) = "1"
475.     n = n + 1: TestData(n, 1) = "01010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101": TestData(n, 2) = "0"
476.     n = n + 1: TestData(n, 1) = "10100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010": TestData(n, 2) = "1"
477.     n = n + 1: TestData(n, 1) = "01000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101": TestData(n, 2) = "0"
478.     n = n + 1: TestData(n, 1) = "10001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010": TestData(n, 2) = "1"
479.     n = n + 1: TestData(n, 1) = "00011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101": TestData(n, 2) = "0"
480.     n = n + 1: TestData(n, 1) = "00111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010": TestData(n, 2) = "0"
481.     n = n + 1: TestData(n, 1) = "01110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100": TestData(n, 2) = "0"
482.     n = n + 1: TestData(n, 1) = "11101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000": TestData(n, 2) = "1"
483.     n = n + 1: TestData(n, 1) = "11010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001": TestData(n, 2) = "1"
484.     n = n + 1: TestData(n, 1) = "10100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011": TestData(n, 2) = "1"
485.     '''
486.     'n = 0
487.     '''
488.     ' Test: r1's custom quiz 1
489.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '1
490.     n = n + 1: TestData(n, 1) = "00000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
491.     n = n + 1: TestData(n, 1) = "00000100000101110000001100010001100001001000000000000000001100000000000000000111001000000000000111100000000100111000000000000010000000001111000000000000000000000000000001010000000000000000010000000000000011000111100001000100000000000000000001101000000000000000001000110110000010000100000011001100001101001000000000000000000010000100001100011000101000000010000000000000000000000000000000000001000000000010000000000000001010000010000000000000000000000000000000000010000100000000000000001011010000000000": TestData(n, 2) = "0" '
492.     n = n + 1: TestData(n, 1) = "00011101100000000001011100001011101000100111101100011000000011001010101000101000111111011000111000100000000000000110110000000001001001110110100001011011101100000011001010001111111110101100001101100001100011000111101100110000000101101101110000001110110111000011000110000000001101111000110000000011111100110001111000011101111101010011111111101111010011011001111101100010001100101101001011000010100111111101111010111111010110001100011000000100010001100111111001101101111000000010110111110000001011010011": TestData(n, 2) = "0" '
493.     n = n + 1: TestData(n, 1) = "00000000100000000000110000000000000000010000000000000000010000000000000000001000000000000000000000000000000001000000010000000000000000000000000000000000000000000000000000011000000000000000001000000001000000000000000000000000000000000000000001001011001000000000000110000000000000000000000000000000000100010000000000000000000000000000000000001100000000000000000000000000000000100000000000000000001000000000000000000000000000000000000000000000100000000000000000100000000000000000000000000000000000000000": TestData(n, 2) = "0" '
494.     n = n + 1: TestData(n, 1) = "01111011010110000100001000011001101101000011000011000000000100110010001010000100010000001110111000001000000000101110101100000000100011100101101110000010110101111001011010100000111011100110100001100100111010111110000010000110010000000100111100110000000101010100111001000000101000100101111001001001000010000100110011011010011011101000110011000000101000000100010000101101000101000110000100010101010111100000000001100000110010000001000011100001001000100000011100000101000001010101000100011010000100010011": TestData(n, 2) = "0" '
495.     n = n + 1: TestData(n, 1) = "11000110011000111000001101000010001000001110001001110010000110000111010001010001100010101100001111100000111100101100000011000111101101110010101101010000101010000001111100000111110101010000000011011100100110101100111101000000100100101000011010000000010110101010011001110011111000010001100110001111111001100010011100010101001100000101010101100000000001001010000011011100010011001000001001110111100110010010000010000111111101100011010101010101000111010110101000000010001001001011011011100101111110110010": TestData(n, 2) = "0" '
496.     n = n + 1: TestData(n, 1) = "10101101010001010110010110011111011111111101110100010011101110000000100011010000100111111001110110100011011110011101110001110011110000111011011110111011101100000010100111100010000010100111110010100100010001010101111000111010011101010111001110110000101101110001110010011101010110101110001111000101011001001101001011111101110010110101001100110010111101010111010010000010110100010001101110110101101110000101101010001001101101011000111110100000011101110010101111011110111110100110101001111101110001010110": TestData(n, 2) = "1" '
497.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
498.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000001000000000000000000000000000100000000000000000000000000000000000000000000000100000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000": TestData(n, 2) = "0" '10
499.     n = n + 1: TestData(n, 1) = "00000110110101110000001100100101000001001111101111100000011000000000001001000100011000000000100011100000100000001001000001000010000000010111001101000001100000010101100011010011111000100111010000000000001010001011101110010100000000000010001011101000010000100000101100110100000011111000000001110000010101010000111111110000000110000100111110011000100000010001010100000000000110000000011000100000000111110011110010000100001010000010011100000000010001101010000000000110010000000110000000110011000000000000": TestData(n, 2) = "0" '
500.     n = n + 1: TestData(n, 1) = "11011001010011000110101011011010000110001001010001001111100111001011110110111010001111010110010100100101011010110010010100111010111001101011100100001010011111111010011100101101000011011011000111011011010110111100110011100010100001101010110101110101110111010111010010011001110100011010011010101111101110100100100111101101001011100001001100100111010101100100101000111111111001001111100111010110111100001000000111101000111000001101011001001110001000010100110011111001001010101001110111010101111001100001": TestData(n, 2) = "0" '
501.     n = n + 1: TestData(n, 1) = "00000000000000000000010000000001100000000000000000000001010000000000110010000000000000000000000000000000000000000000000000001100000000000111000101000000000000000000000000000100010001000000000000000000000000000000001100010010000000000000000001100000000000000000000000000001000000000000000000000000000000000010000011000000000000010000000000000001000000001000000000000000000000000000000000000100100000000000100000000000000000000000000000000000100000000000000000000000000000000000000000100000000000000000": TestData(n, 2) = "0" '
502.     n = n + 1: TestData(n, 1) = "11101000011011010000101000100000010001001000000110011110001011010001001101101010001100111000000101001000011000001010010100010011100110101000101000000000010100111001010100010010101010100011000011000001011010000000010000000001011110110111000010000001011011100000000111001110100000110000000011000101100000001001000100110011000100100000100001001000000011010010100000000100100000101001100000110001001001110101010001000000011000000010101000110010000100001011000001101000101010011011001110010110000010000000": TestData(n, 2) = "0" '
503.     n = n + 1: TestData(n, 1) = "00000010100110101001001000100000010100100100101101010010000001001100000000001011001110011011000010000111111001100010110011000010100110110000000000011010011010010100100011011011001100110001101001110000101001001100100010001101001000001011111100011011100000011001001010111000000000111101111001111001111111101000000000101100011001001011011010010000100001100010011110010000001011000001010111010010011111001001001110111100110010000110100111101000000101110100101010001111001111101100010101001001010101000101": TestData(n, 2) = "0" '
504.     n = n + 1: TestData(n, 1) = "00111100000000000111001001100000111010010010010011100010001100001100000011011000100010000101110010110100110110011100010001111110011011000110010000001001101111111000011000010001101110011101111010100110100110000111011101001111110011011111100110111000001101101110001001001000011110100110000111110111010000001100100100100111110110100001001011100110111000100011110100100100110010011110011011100011101111010010000110000011101100000111001011000110000010001101111011111011001100000010000101000000000000101110": TestData(n, 2) = "0" '
505.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
506.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000100000000000000000000000010000000000000001000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000": TestData(n, 2) = "0" '
507.     n = n + 1: TestData(n, 1) = "00000000010111101100110000001011000001001011001100000001001100001001000001001100010000111111000011100001000000001111010010000100001000000010001101001011101011011010000101010011110110110001100001000010000010100011000000110001000000011101110001000000000000110000100000101100000001011010000101000000100100011000111111110010110101010100011110100110110000010001101000000000101001000010100110000100010100111000010010100100001000110000000100010100010000000010000100011100010010110100010000010010001001000010": TestData(n, 2) = "0" '
508.     n = n + 1: TestData(n, 1) = "11111111011001010010001100000100110110101110100011010010111011110100101000100000000101100000000100110010111110111000110101101010111111011101101010011111100100110100010011011001100000001110111110000101000000001100110101011110011111101100001110011101111100111100011100010010110111100001010000010001101001001111000000000101001000100100000110011000101011100100000100111011010110100000010001011010101011010010100111011000100011001000001010001011101010000100001011001011100001001011101110100110110010111100": TestData(n, 2) = "1" '20
509.     n = n + 1: TestData(n, 1) = "00000000000000000000000000010000000000000000000000000000000100000000100000000000000000000011100000000000000000000000000001000000000000000000000000000011001000000000000100000000000000000000000000010010000000000000000000000000000000000000000000000000000000000000000000000000000010001000000000000000000000000000000000000010000000000000000000000010000000000000000000000000000000000000000000000001001000000000011100000000000000001000000000000000000100000000100010000110100000000000000000000000000000000000": TestData(n, 2) = "0" '
510.     n = n + 1: TestData(n, 1) = "01011000100010001000011010000010010010000100100101000100011001000010000010110110010110001100010001000010110110000011010100000100100010010011111101111100110010101100000001000000100111010000010000100000000111100110000101110001100100000001000001001100100100010000001001000110000000000100011100110110000101100011100010110100000011001001011000010001001000101010010010000001000000100101100101001110110010010000100010100010000000100111001100000000001000111111010100001000001010000010101010110101101000001100": TestData(n, 2) = "0" '
511.     n = n + 1: TestData(n, 1) = "00000101000010010110000110001101111110010001110010000010101001111111010000011011100000110000010101101110101111110101001100000100000000100110001000000000000001110011101011011110000001000110101001000000000000010100010010110110000010001100100010011001010011111011001110110000110100010010000010010110011000010110110010101000111000000100000001101100100110010100110111001110110101010001101100000000110010100010000001000101011100000000000111101110101011001011001100100000001101110000001001101010000000111011": TestData(n, 2) = "0" '
512.     n = n + 1: TestData(n, 1) = "10100010000111100111110001101101100001100111001010011110011001101110100111000111001010100111100010110010101010100100100000101010111100100000010111001000101110010010111000001100011011001011010100101101101110001001111100110000001011100000010110011010001000001101101111001000011101001000110010110111100011111011001100011110100110100111001110000101010001010001101001101001011001111010011001101010000001111010110011100001010100011100110100011011110011100101000001110010010111100111110011001110011111001010": TestData(n, 2) = "1" '
513.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
514.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000100000000000001100000000000000000000000000000000000000000010000000000000000000000000000000001000000000000000000000000000000000001000000000000100000000000000000000000000000000000000000000000001100000000000000000000000000000000000000000000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
515.     n = n + 1: TestData(n, 1) = "00100000011101101100000000000000000000001010001010001010010000000011101000010100001000000110000110100000000010001000111100100100001010110000011000001010110100110011000010001000110101001001100001011000001000000000000010110000100000110000001001000000100000110100100100100001010011000000010101010010100101000000001011100010000000001100000110100010100010000001110000000100000001110010100100001110000001100110000100001000001000000000010000001000001000000001001100000000010011110100000000001010100001111111": TestData(n, 2) = "0" '
516.     n = n + 1: TestData(n, 1) = "01010110100011101001111011101011111111101001100000010100001001111110010111100011101100011111110001101101111000110011010011010011110000101111110110010001000001010100100100110011010010010110101011100000111111111101111110110011111101010011110000111101000010010011010000011100001000011011000011001101100011011101000101010101111011000100001111010100111001011100011100011011011000000010011010010100110010011001111011010010110011111000101110010111111100100100111110111010101001101011010100000001011010010000": TestData(n, 2) = "1" '
517.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000100000001000000000000000000000000000000000000000001000000000000000000000000000000000000000010000000000000010010100000000000001000000000001000100000000000000000000001000000000000000000000000000000010000000010000000000000000000000001000000010000000000000000000000000000000000000000010000000110000000000000000000000001000000000010000100000000000000000100000001000000010000000000000000000000010000000000000000001000000000000000": TestData(n, 2) = "0" '
518.     n = n + 1: TestData(n, 1) = "00000001100010111010101010001001000011001100000000000000010011000111001101001010110010010010010100101010000001001000111000000010110000010001001110100000000101101001110100010100000101000100000101000000010000110000010011010000100101001111000000011110001000001101101100000001000101000000011001011001110111100010010001000011110011110010010001000001110100100010101001110000010100000010010100000000101001000100101000011000000001001010111010110100000011001100101010000000100100100111111001110101000100000001": TestData(n, 2) = "0" '30
519.     n = n + 1: TestData(n, 1) = "11010010010101000010000011010000101110111010011001101000101111011101001110000001011110100101101111000100000010110001010101000110100001100000111000111100011110110011101101101111101010100100011101000000010010101110000011011100010010101110101010000001110001001111110011011101000010110000101111000000101100011100101100001001100001111110000101110000010010000001001010000000011011000001000101000100000111101100110011000111010000001000010000000000100101010001100001011000001010001000111111110110101000011111": TestData(n, 2) = "0" '
520.     n = n + 1: TestData(n, 1) = "11011111000111100000010011111111101111001100100010111010010000011000110100111010011000111101000111010000110110101010011010101011100110011101000001011011111110011100110100001001010000001000010010100101111011000101001000000011110011110001100100100011011001010000101101111110101011011100000111000111000011110101111011101000101010000111011110000111111101011101110110001000011000111011011011111100110000001011011010110101101111011001011000111100101100111010011100110111101100110110100110000010011111110101": TestData(n, 2) = "0" '
521.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
522.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
523.     n = n + 1: TestData(n, 1) = "00100000000000000011000000000000000000000110000010011111100000000000000001000000001000000000000000010110000110000001100010000000000011110000000001100000000000110011000011000000010000001110000000011000001000010000110100000010000000111101000000000000000000100000000001100000100011000000000100000000000101000000000011010000001100010100000110110010100001010000110000001000000001100000110000001100000000011010000000000000101001100000000000000000100000011010100000000010010000100100010000000000000001111000": TestData(n, 2) = "0" '
524.     n = n + 1: TestData(n, 1) = "00010100011101010101100000101000001100111001101101000000011001111001100110110111010111111011110001100000000001100000011001111000111001000110011010001110100110011001110111100000101000110001100110100111000111001000001001110101101110000000110000000000011001010101000110011101011001100011001001011001101100011110000101101001100011001010011000001100110000101000001111110110000000001100001100010010101111100101001101010000000110011011111100011111010000000101000000100101100111010110001101111010101010000110": TestData(n, 2) = "1" '
525.     n = n + 1: TestData(n, 1) = "00000010000000000001100000000000000001000000000000000000000000000000000000000000000001001000000000000000000100000000000000000000010000000000000000100100000101000001000000100001100000000000000000000000000010110000000000000000100001000000000000001000000001100010000000010000010000000000000110000000001000000000001000010000000000010000000000000000000000000000000000000100001000000000000100001000000000000000000100000000000100000000000000000000000001001000000000000000000001000010000000000010000011000000": TestData(n, 2) = "0" '
526.     n = n + 1: TestData(n, 1) = "11010000111110000000000011000001011000010011010100100000000000110011011101010010100100000000000000010001101001000001001010011000100101101000111011000001000010010000010000010100001000100110100001100100001001001001100011110010011000110111000011000000011000000000100110001000101101100000001000000000000100000000000001001110001110100000010100001011101010110100001001001000000010010100001010100111011111000100001010000011010001000011001101110001101110000011010101101001010100110100010001011100110100110111": TestData(n, 2) = "1" '
527.     n = n + 1: TestData(n, 1) = "00000000110110001000000011001000100000001110011010100010101101111100101100101000001010000000101101010100101011010000010001001110001001100001110101011010111010000100001011001010010100011001011000010000100001000000000100001111001000101011111110100001110010011000100001101000101001101011110001011111000110111010010101000001001011101101110000001011110000011001100011111001010100010101110011000100110000101101010010110000000000010011001001101101000010000010001110000011111100111101100100110000001000110000": TestData(n, 2) = "0" '
528.     n = n + 1: TestData(n, 1) = "00101101111001100011001000011101001000000001100000101001000010110101000011001101110010110011000010101100111010101111100101100111000010110111010100000000001010000111111011001000111011100100011111101010010101011111111010010110010001101010100101010110111010111000101111001101001101101111010101010010110001000110110110101000010100001000010011101010011110001000001111001100110001011010100011101011100000100000111001000111001010101111010010010100110111001000100011010110100011111011101001101010111101101010": TestData(n, 2) = "0" '40
529.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
530.     n = n + 1: TestData(n, 1) = "10000000100000000000000001001001000000100011010001010100000100000000010101100110101000000000000100000101010000000101000000000101100000000000010000001000001011000110100110100010010100010111000100000100001010000000101010001000111001000000010000100100000000000000100000001001000000110001010001001010010000000010101001000111011000100100100000010010000100100000000000001000010010000110010110000110100000000000101001010100000110010001110000111000000110000000000000000000000100101100001010000100000101100010": TestData(n, 2) = "0" '
531.     n = n + 1: TestData(n, 1) = "00001101011011101101111110010000011011010000101110101011001001111000101010010001010111100001110011011010100011011010101010111010001010100110101100000110110100101001011001010000001010100000111010111011100100110111010101010100000010000010101110001011010011001111011110110000110010001010001000110100101111101100000110111000000000000010001111101001011011010111110110000100101000111000101001110001010011110100010100100011110000001100001011000100100000011110111111100011000011000011100101111010111010010101": TestData(n, 2) = "1" '
532.     n = n + 1: TestData(n, 1) = "01110011000100111110101110110110101110011100101000000011111010011111101010001000000000111110011010111010001110111000111111010010011101111101100111110001000000011000001000001101101001001000010001011000010001111100010001100111000100111111100011010001101101110110000001010110001111000100101110010001101101010001010110110000100111011001010100101101110000001111001111110111100101101001001001111001011111111011000010101001001001101010001111000011011001111111001011111101111001010010110000100001010000011000": TestData(n, 2) = "0" '
533.     '''
534.     n = 0
535.     '''
536.     ' Test: r1's custom quiz 2
537.     n = n + 1: TestData(n, 1) = "10000001001000000000000011000000000011010100000100010100010111001001000011100000000000101000000000000000000100000011000011010001000000010000000001001000001000000000000100000100000101001000010000000000100011001101010000000010000100010000001001000000010000010000010000010001100000010010000000000110110110000100110010000000000100000001001111110010011001000011000001101010001111111010101000010111111110000000000101000000000010001010101011000001101001000010000000010110001001000010010100010101000000011101": TestData(n, 2) = "?"
538.     n = n + 1: TestData(n, 1) = "10001000000000000000000100101000000000001100000000010000100000000000000011100000000010000100000000000101000100000000000011000000000000110000000000000100100000000000000100000011000000000000000000000000000000001001100000000100100100000000000000000100010000000000000000000000000000000000000000000001001000000000000000111000000000000000000000000010001011010010000000000000000100010101001000001000010010000100000001000001000100010000000001000000110000000000000011000000000000000000000100000000000000001000": TestData(n, 2) = "?"
539.     n = n + 1: TestData(n, 1) = "00001000000000000100000000000000010001000000000000000000000001100011000000000010000000001000101000000101000000000100000110000000001000000000010100000000000000100001010100000000000000000000110000010010000100000101000000000100100000000100010000110000010101000000010000000001000000000100001000000111000100000000000000000100000001000001000000000000000000000000000000000000100010000100000000100000001000000100000000000000100000001010000000000000000101000000000010000100000001100000000000000001000000000001": TestData(n, 2) = "?"
540.     n = n + 1: TestData(n, 1) = "00001000000000000000000000000000100000000000010010000000000000000000100000001000000001000000000000000000000001100000001100011001010000000000000000000000000100000001000000001001100010000000100000000100000001000000001001000001010000000000000000001000000000011000000000000000001100000000000001000000111000000010000000000000000000000101000000010000000000100000000000001000110100000000001000101000010000000000000000000000000000000000000000101000000000101010000010010000001000001000000000000000000100010000": TestData(n, 2) = "?"
541.     n = n + 1: TestData(n, 1) = "00001001111110110001110000000100000110000100000001000000100000010000111000001000001101000001001000000000000000101000110000001011100000100000110000001000000000100001100000010010011100000011100001000110001001000011001011000100010110000110000100111110111011001100000000000000000010000000011100000010000000000000000000111001010001000100000000001010001010000000000000000010101000001000011110100010000100010000001100100001000100000000111000011000000000000000000000010101011010001111000101000000100100110000": TestData(n, 2) = "?"
542.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "?"
543.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "?"
544.     n = n + 1: TestData(n, 1) = "00000001111000110110101000011001001111110101101100011010111100111010100101001010001001100100000100001011000100000100000110000110110000000100101001110001101001110010001000100010110000000110010010101010001000000110100000001001011100001000000100001011111010011011000000000110111100100000010000100001110000010000000000110001111110001100010111000100100001000011000010101110000001000000001101101001111000000010011000000110001000011100111011011000100100000000110000010010110011010110000110011010000010010110": TestData(n, 2) = "?"
545.     n = n + 1: TestData(n, 1) = "10001110100010001000100001110001001101100010100100111001000000001001100000001000111000001000001100001110010000000001001111000011110101100111001001111011101010110100001001001100100100001101000111010001111110101010101101000101011011111001010110000001010000000000111100100111011001010110000010001110010000001000111110011101111100111000000001100101000000000101111111100011001100111100101011101010011110000010011110001011110011101100010101110000100000011001000011001001010101110110101100111000000010000100": TestData(n, 2) = "?"
546.     n = n + 1: TestData(n, 1) = "00111001100110011100000000000000001000100100010100100010001101000111011100100010001111100000000110000001000001111001000100000101010011101000001000110100011111110001000110001101110000000010101100000111000001100110011111110000000000000100100000000110101001010110000000011100000010110100110000000110000000001010000101000001000000100000100010000000000100000011000000000010010100010001101100110010101010000010111100000111111100000001001010001001001000000000111000010011010011000000001101000000000010000011": TestData(n, 2) = "?"
547.     n = n + 1: TestData(n, 1) = "10000101100000010101000111000110011000100100000101000011001110000010000100000111001001100000011100000101001000000000111100000100011000000010001100111000001001110100100000010000110011110011000000000010100100010111000000000000000010010000010001010010101100110010000000100101000001101001010010000000000010000001110010000011000000010010001010000010011000011111101100000010100000001110011110100000101001011111011001100110001000100000001110001000010000000001110001010010010011100000000100100100110011000010": TestData(n, 2) = "?"
548.     n = n + 1: TestData(n, 1) = "01011100011100011000100100011010011000010011000011101100110010000000011000001100111001010010001001001101010101100100100011111110110111111111001011111011011001110011011000010001100100101100000111101001000100111110010110110101001000011011110101010010010001111011101111111100110000111110011001001111110111010000010110001001000101001100001101010010000000000110011110100001100000010000011001110110110010011000100000000110001001000001100000011001001100100100100011010001111100011001111101100000111100000000": TestData(n, 2) = "?"
549.     n = n + 1: TestData(n, 1) = "00110000100010000000100000000101000100000000000000000010000000100000110000101000110000100010000000001000100100000101000010110101001101100010001000100100010000000000000000000000100100011001001010001010000010010000000100001001000010000001010110010000100011010000100011010110110100100100001000000010110100000001010010000001111110000000100100100000001101000110111100011101001110010010001010110000000011110001101000000001110000100010100000010001000010001000100000010000000000000000000010011001011000010100": TestData(n, 2) = "?"
550.     n = n + 1: TestData(n, 1) = "10110010010010010000110011100101010001001001100011000001000010011000101001100000110110000000100011111000011000000111111000001000011011010111000000010001000101001110010001101101011001010001000110000010000110010100010000011001010000100000101100011100000110001001100111100110000110100010100000011000111100111010010100011000000000011000010111100000100001010100011110100000000000101101110010000000100110100001110000001110001000100000000000010010001100000000111100000001000000000000000000000000001001000000": TestData(n, 2) = "?"
551.     n = n + 1: TestData(n, 1) = "11010000100101101011010111010110101110101000001101001011100000111001010001100000101100110000010111000100100101110100001101111001011011001100110101111100010010111100010010111111010001111110010011110000110011110011010011010101100001101010011110101001110001100011001110111110011111111101100001100000011000000101101100111100011010001011010101001010000101010011000010011011010110110111011110000001110010100010000000101111101011101111000101010001011111100100101000011001011001101111101100010111010100111001": TestData(n, 2) = "?"
552.     n = n + 1: TestData(n, 1) = "00000000001110011101011110000001110100101110110111000101111000011010101110010001100110001000111101100010101110100010010110101110110110110001001001010010000011101111010010110010000110001000100001111110100001100000101011011000001100001011110001110100111010101110001011110000001111110101010101100101000001101010101001010010100001001000101000011000111101100111101001001010110010000100111010011010111010000100001011010101111111100100111101011001100111110010011110011100011110001110001001011000011010001101": TestData(n, 2) = "?"
553.     n = n + 1: TestData(n, 1) = "10001001110000001000010001011011000100011010010101101011010100011001000011010101101100011011000111010111100010110011001001101011100111101101001000100100101111011100001100100100010000001100000010000010011101001010001011100011100001001000010000100010001001111000000010001101000001001110000110011110011100011011001110101000101001111111001010111000111011100110110011111011010111000011100001111110110101010111010110100000110110010110010100011000111110111101110011001111111000011111111001111001001101011111": TestData(n, 2) = "?"
554.     n = n + 1: TestData(n, 1) = "10010011010111111001010001110000011011100100100110011110011111010011011111111101111001100001100110100100100110011111111100011011100010011011110010010100010100000000010010001111001001110010111100001001010111110010110111111100110001010011010100001111101011100110010111110111110000111100110101001010111001101011001001000101100001000110111100010111001001001001101011000110001011100011100010110000111101111101100100100011101100011011110011110000111100001100001100100011000111110000100000110101100011001011": TestData(n, 2) = "?"
555.     n = n + 1: TestData(n, 1) = "01111000000111010111111100110100011010111011110101000111000101111000111111100011010010001111001010111100111101101010000101110101000010101100001111010101011110011001011011100001110101101011111001010111001101110001110011111111100011000110100011111101000010100101010001001100101000100001000100000010101100011111001110101101111001111001110100011001101011001100111001100000010111000111000011001000011001000010011101011101110101010010110010111110111111010101100001111110011110011000010011000010010000110000": TestData(n, 2) = "?"
556.     n = n + 1: TestData(n, 1) = "11100101001100110010000000001111111011001011100100111101110111101000111000110110001100101000101110100101001000011011000111010110011101100010000100111010111010011010010010101110111011110010110110011001110101100111100010100010101000100001000100001000100101010101001111010111110101100101100111010110100100111000010101001101011100010110000000100110111100101111100001010011001100000100010101111111110110010111011011011001010111011100001001110010100100110110110101001101000001011001110111010110100000111010": TestData(n, 2) = "?"
557.     n = n + 1: TestData(n, 1) = "00101011100010110100010101100110110111001111000100100110011111000001101011100001110110100001110011111101001000100100010111000111110110001101101000101100011111101001010010001000111111110111011001100011011011010110000101101100100100011011101001011010101001100011111101110101111111010001010001001100110100100000011100111101110010011000011001001000001110001001010010101010000110101001011010100100111011010011011110101110110100010001000100100011000011110111111011000011101101100111101111100011000011010111": TestData(n, 2) = "?"
558.     n = n + 1: TestData(n, 1) = "00000100100101110000110100100011111110100110000101010001100010000000111111000111010011111111111110011000010011010111011010101101011011011010011000100100101100010110111011000111001110011110001111100000101101100001100011111010010100110100111010100101011100100001100111111010001100000001100010001000111110101000010000100100110010101111110011111111001111111101001000111100100100111100001111101000111110011111001111111001110100101001000011100010001010100110101011011001000001111010101100100110001011110111": TestData(n, 2) = "?"
559.     n = n + 1: TestData(n, 1) = "00000111111000010000101100011100110000100010111111110111011110010011000011110000001110000110001101101011010111010001100011000101100011111100010000010101010111111111010100000110111010001001100110111100011111000100101111111100010100110110100000101110010101000000000010000111111101011111111101110110111110111111111001101110100100110111101110111001100000100011011111010000101110011010111100000110100010110010001101001010100010000000101111110000111000001000010001000100010110011011111011101110100001101010": TestData(n, 2) = "?"
560.     n = n + 1: TestData(n, 1) = "10101101001001011100001000001110010001110011001011000111110010110110100011111111111001010000101010011110011110110010010001011010011111101000011001111100000011001011011001001110110000101001011000100111100011000111110011100000010011000000101001010011000111100000111000101110110111100001110000101011010001101010101101101110011011111100111001010100011000111011101111011111011101010000100100000100110101111100000101000000001001001110000111100100111011011100101101010110100101110101010111001010110010100011": TestData(n, 2) = "?"
561.     n = n + 1: TestData(n, 1) = "00111100000001100110111100111110110100001000001111100110011111100111110001100001100100110110000000011111110010111000111000101000000010000101011001010000011010110001111000010010010010000111010100110011000001000011110110110010010010011111111111111001100100010111101010000001100110010000110011000101000100001000001111010010101100001000101010101101001100000000001001101001011110001100100000000001110011111000100110101010000001111111111010001001011000100010000000100001000100011000100000110100101011000010": TestData(n, 2) = "?"
562.     n = n + 1: TestData(n, 1) = "00001100001100010100000100001111110011001111010000111001001111100010101101011000101100010010101010000011010111100100101100001110011001100000001011000111010000111000001100010000000100100111000100100000010101110100010000101010101110111011101001111000010110111110010000110110001010001111100101100011101010011010100110000101010110010100111101100100011000001011111110111001001101100000000001010011000010100000011001001011110000000000010100000000000100111110001000100101000100000000001000001001110000000000": TestData(n, 2) = "?"
563.     n = n + 1: TestData(n, 1) = "00010011100000101100010001010000111100001100101110110011000111111001111001111000010001011110111010100110101111100100111110000000001111010001100011100001101110100011010000010001111111000001111111010111001111001111111001000010000101101101000100100000011111011000011100100011001100110010000001000111111110100011111010101011000101111110000011001010101100100001001111001001000011111111010011110000110010100101111100110100111111011000110010010111000000010010001010010000110101100111110100100010011100110010": TestData(n, 2) = "?"
564.     n = n + 1: TestData(n, 1) = "10011100100001100111000000111010000100000000010000011011000010100001110000110000110100001000001000011001011110010000001001000111000100100001000000111001100000100011000000000000000011000000101011010100101000000010010100010000011000011100000111000010100110101010010111010000010000110000010000000110010001000001100100000001001000110100011010101001000010100100000001001000100010100010111010010100010111100011000001101100000011001110100010010001001100110001000010001010001000010111000010010000111001011000": TestData(n, 2) = "?"
565.     n = n + 1: TestData(n, 1) = "01001001001000000100101111110000000010011000000110011101110111111001100011100001000000101000000000000110001111001011010010110011101110010000001001001000000000000000000101000000010001111000011000010000000011001100110000000011100100100011001111000100100010011100010010010111110100010010000111001110011110010000110010100000000001001011001111110010001001011110000000011011001111111100100000110111111110000000111001000000000010111010101011000011111001110010000010011010001001110001011100010110000001111101": TestData(n, 2) = "?"
566.     n = n + 1: TestData(n, 1) = "10011000000000000100000010101001000000001100100000011001100011010001000011101000110010000100001000000000100100000000000011000000000000110000010100010100000000100000010110000011010000000000110000000000000000001001100000000100010000100000000100000100010000000000100010011110100100000000000000000001001001000100000000001000000000000000000000000000001011010010000000011000101000010101001000101000010110000100100101000001100000000000001011000000000010000000000011000111000000000010100100000100000001001000": TestData(n, 2) = "?"
567.     n = n + 1: TestData(n, 1) = "00001000100000100000000000001100000001000011100111101000000001100011111000001010110000000100101000000000100001000100101110000000001000110000010100001000100000100001110100000000000100000000000001010010011101010101001000000100100000110000110000110000010001000000010000000001000000000100000010001111000111000000000000100100001001000101100000000010000001000000000001000000100010000100000000100000001100000111000000010001110010011010000000000000001101000010000010000100000011110000100000000001000000000001": TestData(n, 2) = "?"
568.     n = n + 1: TestData(n, 1) = "00001000001011110101000000001000101000100000010110110000000001100000111000001000101001000000000000001100100001100000101100011001000001110000010001001000100100000011110011001000000100000000010001000110000001000101001001001001010000110100000100101110010000011000000000010000001100100000010000000000111000001010000000000100001000000110000100010100001001100000000000001000000100000000001000101000010000000100000001110010000100000000000000011000000001101010000010000000001010001000010010000000100100010000": TestData(n, 2) = "?"
569.     n = n + 1: TestData(n, 1) = "00001010101000010001100100000100000110111110000001111100000001110000001000000010111101010011000000000010100001110000110010011111100000000000111000011100100000100001100001000010011000000111100001010010011001010011001110001000010000000111010100011001111111111100010000100010000100000000111001000011000000100110000000111000111110000100001000100110100010001001100100001000111000001000011110000111100100011100001000000001000100000110011000011000000001000010000000110011111010111110000101010001110100110000": TestData(n, 2) = "?"
570.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "?"
571.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "?"
572.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000100100000000010100000000001000000000000010001010000100000000000100000010000000000100000000001101000001010000100000000000010000000000000000000000000000000000000011000000000000100000000000000000000000000000001000000000000000010000100000000000000000000000010000001000000100000000000000000000001000000000001000000000000000000000000100000000000000000000001010000000000000000100010001001000000100100000001100000000000000000000000001000000100000000000000000000100": TestData(n, 2) = "?"
573.     n = n + 1: TestData(n, 1) = "10000101000000000001000000000010000000001000000000000110100000000010000111100000000000000000000000000000000100000000000000001000110100100000001000001000000000001000001000000000000000000110000010000000000000000000000000100000000000000011000000000000001000000000000000000000000001000000000011000000000100001000000000000000000001000000010000000000001001010000000000000000000000000100100000000000000000000100000000100010001000000000010001000001000000000000100000000000011110011000000000000000100000001000": TestData(n, 2) = "?"
574.     n = n + 1: TestData(n, 1) = "00000000000000001000000100000000100000000000000000000000000000000000000000110001000110000000101000001000000010010000000000010000000010000000000000000000000000000001000010000000100000100000000000000000000100100000100001000000100000000010000000000000000001000100010010000010000100000000000000000010000000010000000001000000100001000000000000000000000000000000000100100000100010010000000100000000100000000100000000100000000000000100000000010000100001000000000100000000000000000000000000000110000000000000": TestData(n, 2) = "?"
575.     n = n + 1: TestData(n, 1) = "00000000000000000000000000100000000000000000000000000000110000001000000001000000000000000000000010000000010000000001001000000001100000000000000000000000000100000001000000001000001000000000000000000000000001000000100000000000000000000000000001011000000000000010000000000100000000001001000000001000010110000000100000000000000000000000000000000000000000000000010000000100000010000000001000000100100000000000000000000000000000000000000001000000101000001000100000000010000000001000101000000100000001001000": TestData(n, 2) = "?"
576.     n = n + 1: TestData(n, 1) = "00000000100000010000000000000000000000000000001011000000010000000001000000000001000100000000010010000000000010000000000001000000010000000010010000100000001010000100010000000001000000000000100000000000000001000000000010010000010000000010101000001000000000000000000000011000000000000000000000000000100000000000000000000000000000001000000101000000000000000000000000000000000000000000000000000000010000000010001000000000000000000000000000000010001010100000000001011000010001001010001010000000000000000000": TestData(n, 2) = "?"
577.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "?"
578.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "?"
579.     n = n + 1: TestData(n, 1) = "11110101001000011101011111110011000011111100111111111110011111111111101011101000001110011111001111000011000100000111111111110011110010000001101011111010111001000000010111001111110101111000111001010000110011001111110000100111100100110011111111110011011010011100100111111111110100011110000111001111111111110110110010010000111101011111111111110010011111111111000101111110101111111111111000110111111110000111111111101011000101111001101011000011111111110010000011110110001101110010011100010111100110001101": TestData(n, 2) = "?"
580.     n = n + 1: TestData(n, 1) = "01000110000100000101000001010000011010010000000000011000010110000001001010010110000000001000010000011010000100000011010010001001000010000010011001001110000000001010010001010000010110001011111111000100000010000000011000010000100100000100000000001000010001000010001010010000100100100001000000000000010100110101001000000111000001001000001000011001001001000010011000000010110110010000100001010110111011000000100000000000100100001100011000000101101001000010110100010010001101010000010011110000000000001100": TestData(n, 2) = "?"
581.     n = n + 1: TestData(n, 1) = "00101001011000000000110000110100010000100000000011000110110000100000100000100011000101000100001000011000001110000101000100011010110000001110010100000110000011000000000010010011000000000000010000010110000010001000100110110101000000000000000010000000100000100001001001010000010100111000110100000001010000000000011101010001010000000001110000000000001010001001011100000001000100000100100001010001000010111100000000000101100001001000000100000000000000100000000000111000001000001000000001100000110100001001": TestData(n, 2) = "?"
582.     n = n + 1: TestData(n, 1) = "00101101000010000110000001100000110000000100000000010010000000000100100001001001000000000000000001001000000100000010011000000000000000000001000101100000101100001010001100001000001000110100101001110001011000000000000000101000100111100100000000010001001110001001010010000000000000100011010000011100000001000000001010110100000101000000001000000000011000010011011100000010100100100000000000000000001001001110000001010000100000010000000000000100100110011100100010100010000110001001000101100001001010100010": TestData(n, 2) = "?"
583.     n = n + 1: TestData(n, 1) = "00000100010110011000000000100100010000000100000001010000111000010100000010001100000010100000110100100100010000011001001001000000001101000000001010101001100001000100010100101001000001001000010000000000100000100100000001010000010101010000000110000101000000000010000001011100000111000100010100000110000011010000100000000001010010100100000010100000011000000010100100011000100000000000000000001000000000001110101101010010000000011000100000000101000010110110110000010001100010000001001100000010011000001000": TestData(n, 2) = "?"
584.     n = n + 1: TestData(n, 1) = "01000000000000000100001001010000011110101010100001001000000000000100010100000010000100000100000011001000000001101010100001011100000100011100011000000110000100000010010000001000100100000001101001011010000000101000010000000000011010000001101000000010001000000000010110001100000010110001011000000001010100010000000010010100100100100010010000010011000001000000110000101100110010110000000011000000101010000000000011001010000001010110010001000000111010100110000010001001000100100000000001110001100000000000": TestData(n, 2) = "?"
585.     n = n + 1: TestData(n, 1) = "10000000000100001110001001011001100101100000000100000010000011010001000110010010101011000001000000101001000100000000000000110000000000100000000001001010001010100001000001000100100110100011010000001001000010000000010000000000110101000000000010000000100000000100000100000000010100000000000000000000100011000110111000100000110000001010000100000100010001101101111010000001100000000000000000010001001101000101100000000010100000001001000000000000000000001001000110000000010001000000000111001000001001000100": TestData(n, 2) = "?"
586.     n = n + 1: TestData(n, 1) = "00010001111000000010010000000001000000101000000100011000010001011001100010110011100000000011001000000100000010010100000001000110010010000000010010011101001001101000000010000001000010011001100101000001000110001010000010010010010100101001010000001000001101000101101100000100100010101010000001000000000000010001000000000000100010010100000000100100001001000001100000011111011100100001000000100000000010000000001001000010001000000010000010101010011110000000000001000001000011000000001000000000000001000001": TestData(n, 2) = "?"
587.     n = n + 1: TestData(n, 1) = "00000111001100000000100100010000000100000111100100010000100001010110000000000000000000000000000110000100110100010010001000001000000010000001010001101110110100000001000001000001100100101010000001100001110000000000101100000000000000010000001000000000111000000010000010101010001000110000000000000010100110000000000000010010000101010000000000000010010000010101110000100100000000100010100000001101000001010010000000000000001001000101010001100001000001010000000001001000000010110010000010000000010100100010": TestData(n, 2) = "?"
588.     n = n + 1: TestData(n, 1) = "00000000001100001001010000001000000101011100100101001011110010001001000001011010000010000000100100001010010001111001000100000000000010000000010000000010000000000001010000100000010010100100000001000101010100100000110011100000000010010010001100000000101010100000100000001001110000000100010000100101010101100100011000100100001001000000101110010000010000000000001000000000101010001001010011100000000100010000000000100000101000000100000000011001000100001000000000010000001110001000000000100010011010010110": TestData(n, 2) = "?"
589.     n = n + 1: TestData(n, 1) = "00010001000000000101011010001010000001000001010100000000001011000010000000000000000001010000100001000101010101100100010011100100100000000000100000001000000000000100010100000000000110000010010000000110000100001100110101110000110001000100110000010000010000011000000010100000100001010100010110001000100000000001000000000000001000110000001001000111010000010100011000000010010000000101000000000011001001101100001000000010000000000000000000000011101000000110000000110010010000110000001000000000100010000001": TestData(n, 2) = "?"
590.     n = n + 1: TestData(n, 1) = "00000000000110100000100011000000100000100100000000000000011011100000010101100001101010110000000000000000000000111101001001100110001000110001001101000101010000110010010001000000010001000000001000011000000000000000000010000000000001000100000001010010000001000001000101111110000100010010000010011010000000000000100100001001010100001000010100001001000100101000001000000001000000010101000100000010000001110000000000000000001011000011001000010000001110001001000101011110011010000101000000000000000110000000": TestData(n, 2) = "?"
591.     n = n + 1: TestData(n, 1) = "00010000100010110000000010111001000111010001000000001000100010000100001010010000000001101010000010000001000000000011000010000000010100100100010000110100000100001001100011010010000000011110100010111010110001110000100000100100000100000000010000000000000000110001001010000000000000100100010001110001110000010101010000001010000011101101011010000000001000110000000110110001001100101010000100000001010110001011001100010010000010100011100100001001100000011110000000110001110001100100000100101000101000010000": TestData(n, 2) = "?"
592.     n = n + 1: TestData(n, 1) = "00110000000000000000000000000010100000000001000000000000000001000000001000111000000100000000100000010001000000000010000010011110010100011110000010000000000000000000000000010010010000000001000000000000000000000000000000010011010000000000110000000001010001010110000000100000000000010010000000000111100000000000010000000000100000001010000000000001000010001110001001010100000000000000000100000000000000001000000010011000000000000000001000011010000000011100000001100000000100110000000100100101011100100100": TestData(n, 2) = "?"
593.     n = n + 1: TestData(n, 1) = "01000000000000000100000101010000000010010000000110011000010100000001000010001000000000101000000000000010000100000011000010000000000010000000000001001010000000000000000000000000000000001000010000000000000011000000010000000000000100010000000000000000010000000000010010010100100100000000000000000000010100010100000000000000000000001100001000000000001001000010000000000010000110010000000000010000111010000000100000010000000110000010001000000000101000000010000000010010001101010000010000000001000000001100": TestData(n, 2) = "?"
594.     n = n + 1: TestData(n, 1) = "00000001000000000000000000000010000000000000100000000100000000000010000000000100000100000001000000100000001110000000000000000010000000000000000100000100000000010000000010000101000000000010010000000000000000000000101000000000000000001000000010000000000000000000000000000000000000000001000000000000010000000000000000010001000000000010100000010000001010000000000000100000000100000000000101000000000000000100000000000000000000000000000000000000000000000000000000010000001000000000000000000000000000000101": TestData(n, 2) = "?"
595.     n = n + 1: TestData(n, 1) = "11100110000000000000100000010010000010000000000000100100000010010000000000000000000000000000000110000000001011000000000000000001000000100000001100000000000000001001000000000100000000000000000000111000000000001000000000000000000000100100010000000000000000000000100100000110000000000000000000000000000000000000000111000001001000000000000000010000001000010000100000000000000000000000000000000000010000101010001000010100000000000000000000000001100100000000000000000000010000000100000100000000000000000000": TestData(n, 2) = "?"
596.     n = n + 1: TestData(n, 1) = "00000000000000000000011000000000001000000000000000000000011100000100110000000000000000100000000000001000010000000000100000000000000000010000000000100000000000001000000000000001001100000100000010100000010001000000001001000000000000000010000000000000000000000001000000000000011000000010000000000001000000000000000000000000000000000000000000111000000100000001100011000000000000001000000000010000101000000000000101000000000100000100000000001000000000010000010000100000000000000100000000000000000000000010": TestData(n, 2) = "?"
597.     n = n + 1: TestData(n, 1) = "00000000000010000000000000100000000000000000000000100000000011000000000000000010000000000000000000000001000000010000000000000000001000000000000001100000000000000000010000001001000000000000100000100000000110000000000000010000000000000001000010000000001100000010000000100000000000000010100100000001000000000010001000000010000000000000001000000000000000000000000000000000100000010000000000000000001000100000000000000000001000001000000001000000000000100001000100000000000000000000100000000000000000010000": TestData(n, 2) = "?"
598.     n = n + 1: TestData(n, 1) = "00010000000000000000000000000000000100000000001000000000000000000000000000010000000000000000000010010000000100001001010010001001000000000000000010000001000000000000000100000000001000000001000000001000000000000000000000010000011010000000000000110001000000001000000000001000000000000100010000000010000000000100000000000100000100000010000100000000000000000000000000000000000100000000000000000000100110000010001010000111000000000000000000000000001000000010001000000000001001000000000000000000000010001000": TestData(n, 2) = "?"
599.     n = n + 1: TestData(n, 1) = "00000000000100000000000000000000010000100001000001000000000001010000000001000000000000100000000000000000000000000000000000000110000000100000010000000001000000000100000000000000000000000100000001001000000000000000100000000000000000010000000000000000111000000000010000010000001000000000000000001010000000000000000000101001100000000000000100001000000000000000000000000000000000000101010001000100000000000000000100000000010000000000000010000000000000000000000000000100000000000000000000000100000100000000": TestData(n, 2) = "?"
600.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "?"
601.     n = n + 1: TestData(n, 1) = "00000000001000000000000000000010010101001001000000100000000011110001000011001100000100010001000000111001010000010100001001100000000100001000001100000010110000000100100011000000000000000010000101101000100000011000101001110000001000111000100011100010001000001010000000000010000001100000000000011000000000010111000000000100001000000000000000000001000001000001000100010000011100001000001100000001000110101000001010000000000000000000000011000000000000001000000011001000001010000001010101100010010000000100": TestData(n, 2) = "?"
602.     n = n + 1: TestData(n, 1) = "10000001100110110010010000000000001000000000100011100010000010100101010001100000100010001001001111110010000010000101001100000110000100100000111100000111100101010000101000010000000010000111010000000011000000101100001010000100100000001010101001100001010110001000010100001100100000000110100101000110000101101110010101000011010010100110010000100010110111000010011000000000100111000010110110011110000010010001010011101101101110010011000011110010010011000001100000100000100000000010011011000110010000000000": TestData(n, 2) = "?"
603.     n = n + 1: TestData(n, 1) = "01001100101100110101101011000000100000111001001011100101010010101101000111100010010110100100001100011111111100111111100001010100100000111110000001000101010110000110010000010100100110010001000001110110010111100101001011111011011000000100000000110001110000010010001010011000010001110001001010111111001100101011010101111100110010001001010100011001000000010010000111100011100100111001100000000000100001111111100000000111111000100010001101101100011100011110011010111101001010010100001011000010100100100011": TestData(n, 2) = "?"
604.     n = n + 1: TestData(n, 1) = "00100100110010011100000010000100010011110000101011111000110110100000110111000100000100000011110100000011001000010010011110010000110011111010111001101111001001000011000011000000101101000011100000010101001011100000110010010010011000011100000010001000110011000011001111101100011101011010100001101100110000100001010110000001011111011100110000010100000001000010000000000010010000000000011000101011001001101000000010000000100000010001000001100110000101001111000000000011000000100100010010001111100010000100": TestData(n, 2) = "?"
605.     n = n + 1: TestData(n, 1) = "00000100010010000111111000011000001000001000000010000110111000100100001000000000101010100010101001111011111100010001000000110000000011001100100001000000001000000000000000100000011010100101111000011001001011100011010110010000000000011111101000100000110101011011001100110111101000011010000100001010000000101110110110010100100111100100000000000100010001001000011000000000000010000000100000000000110000001000100000000011000110010000000001100010010000000001000101001111000011010111001001000100000110110110": TestData(n, 2) = "?"
606.     n = n + 1: TestData(n, 1) = "00010011011010111001011100100100101100010110100111001001100011000011110101001110111001000010011000011001000000001000010100110101010000000111101000100110011111100000000010110000010001110001100101000011100001010011000010000111101110000111000100010110101001110001100010000000010001111000110001110001000001100000110111111110000101110100000101000011110011000101001101101100001000100100000000000001000000000100000101000001001000110110110001010010000001010100001101000010100000000001010001111000011010100101": TestData(n, 2) = "?"
607.     n = n + 1: TestData(n, 1) = "00000000000000001001100001001000010101000000010001000000000001010000000000001000000000000000000010100001100000100010010000100000000011000001001111000000000101011100000101110001100000001100000100000100000101001000100010000100101110000000010000101101110101000111000010110011000000111010000110100101110001000000001001101000010000010001000010010000100110000011010000100001001000100011000010000000000000100000010000101100100000010000001100000100000000000000000000001000000110100010100110000010001000010000": TestData(n, 2) = "?"
608.     n = n + 1: TestData(n, 1) = "00100000010001011000001000001010000100100001100111000000010001010001000001001011001011101000001010000001001010001010011100100001011000010100010011010100000000001000010011100000000100000100000110000101011001011100010111000000100011001010011100110111011010100100000000100000000000000001000100010000011001000000001001101000000110001000010011111000101000000000000010000100000000100000000000000000000000001100010000001111100110000101001000110000010000000101000001001000110000001000001100011000010011000000": TestData(n, 2) = "?"
609.     n = n + 1: TestData(n, 1) = "00100000000000001000111000000010010001100011000011000100111000001100000111000100010000000001010011001000001000000011111000011100100000000000000100001100010010010100000010000011111101010010100101100000001110010010000100000000000001010000000000000001010010010001000000100000011111000011010001001100000000100011101000000001001010000000001101111101011000100000110011000000001001000000010000000000011010000001001001000100000000110110010000110011000000000010010110100000100001001010100000000001000100001000": TestData(n, 2) = "?"
610.     n = n + 1: TestData(n, 1) = "00001100001100010100000100001111110011001111010000111001001111100010101101011000101100010010101010000011010111100100101100001110011001100000001011000111010000111000001100010000000100100111000100100000010101110100010000101010101110111011101001111000010110111110010000110110001010001111100101100011101010011010100110000101010110010100111101100100011000001011111110111001001101100000000001010011000010100000011001001011110000000000010100000000000100111110001000100101000100000000001000001001110000000000": TestData(n, 2) = "?"
611.     n = n + 1: TestData(n, 1) = "00001010001000010000010100010010000011000010000110000010101110101011000011000000100101100000010000001100101010000100010000001101001000010001100110000110010000000000101000000000000001101000100000110110000010100110000111100110000000100000000010110000100000011000010000010001000100010001000001100001101000010010001000000110000010100000000010010110100010010011000100100110000111110001000010111000010101100010000001000010010001001001010000010000000010110110011000101001011000011011000100011100100000010010": TestData(n, 2) = "?"
612.     n = n + 1: TestData(n, 1) = "00100000001000011000000000100010000000001010010000000100000100001000010100001100001000110000100010011101001000010000010000000100001010100100001000000100110000100111010000110000110010000010010000101001011101100010000100000100000000000100000000001011000000000000001100000100000000001010000011000100000110011000010001100000000000001000001000011000001000110011000000000100001010000000011010100000010001000100000100000010100000110100000011001010110000000000000011000000000000000000010100011010001100001101": TestData(n, 2) = "?"
613.     n = n + 1: TestData(n, 1) = "00110011100000011100111100110011001100001100110110110011010111111001111100110000001001010100001001010111110101100100111110000111111111100111101011100011001111010100100000010001111111001101111111100111001111001111111001110010000101101111001100111000011110011001111100100111010100110010110111010111111110001111111100101011000101111110011011011111001110000001001111001111000011111000001011110000111110011111111101110100111111011001011111110010000010010010000010010000110011110101110101000011111100111110": TestData(n, 2) = "?"
614.     n = n + 1: TestData(n, 1) = "00100101100100010000001001001010000001110100000101000000001011001000110101000111000110111001000000100001000100100110000000010001001010000010001000000000001000010001000100010100110110110000010100001010010100010100011100000010101110000101000101000000011000110101011100001000000000100011100111010010010000100111000010010000010000101010000001000000100000010000001010100000001000000000001010000000010001010000001101001111001110110010000001000000110100000010001000000000000010001000100100001110000100110010": TestData(n, 2) = "?"
615.     n = n + 1: TestData(n, 1) = "01100010000100001101011110010000001010011110010010000110000100000001001011000011110000110001111000000000110100000001100000010100001000000001000001010010000000001000011100001010011010010011010001000000110011011001000001000011100001100000000100001110000011111110101000110100001000101000000111000100110110100000010000000011100000110100100010000000101001001100000000001010001010000001100100110000000100000111000001100010000000000000110010001000011001000101000000000000000000000000100000000001100000101000": TestData(n, 2) = "?"
616.     n = n + 1: TestData(n, 1) = "00100000100001101010000001000100010000001011111101011101011111100010100000000000000010110100100001000000000000001010001000000100111001011010000000101000001001000000110011000101010010001110010000000000010001000100001010100000010010011011001000111010100000000000011000000101010010001100100011111110000110000000011100001100010101000001010101000010001010000000000000100000001011111110000000100000100000010100001010010011010111000011000010101101010010111000000000000001000001001011001010000100000010001010": TestData(n, 2) = "?"
617.     n = n + 1: TestData(n, 1) = "11100000010000010110100000000110001000000001100000111000010000101001011110000100010000110100000101000011110000000000100100101010111011010000001110000010000110000001100010010000111010001100010001001000010110001000000110111001010001111110000010000100100100000000101110010000001100010110010011101001001001000000100000000000100010001001100110100011000001011100000100000010101000010001001010011000010011100010010100000010000001111000001001110000110011010001100000110001011000000000000101001011000101000000": TestData(n, 2) = "?"
618.     n = n + 1: TestData(n, 1) = "00110000001110000010001000000100100000010101100000011000110000100100000001110011000001110101000001000000000110000000000001010000111001010000010000000000000000100110100110100000010011011100111000110000011000110000100010100010110000011010010100000000100000110100001000000000000001100100000111101000010000100000000001000000000000100001001100010010110000000011100000010000011100010000000000000101000000001000000001000010000001000000000000100000010010010000000001000011000000010100100000000000010000100000": TestData(n, 2) = "?"
619.     n = n + 1: TestData(n, 1) = "10011001110100010000011010000011000010011011011001010111100001100010110101001010000001100011000000110000000000000000101101000011101110110000111111111110010000110100001110011001011000110101001100000010111110001010001000011011011001010000000100000110001010010000011110100010100011000101110110100100110000011000100001010100110011001110010000001001110010001100000010100110101111010110000101000111111010000100111000001110000000000000000000110001101000000011110001011110000100000000000100110010000100111000": TestData(n, 2) = "?"
620.     n = n + 1: TestData(n, 1) = "01111000100000000100000001000001101000000000000101000000001011010001101010111000010011110010000000000000111011000010110011000000001000100110010000000110111000000000000000000100011010000000011001010100010010001100001000000001000011100001000000000100000000000000111000010000001001000000101011010010000000011000000000000000111000000000100011001100010001001100000000100111001000000001000001010001000000011010001000000011100110000110000100000010010001000001000000000010000000111100010000010101011000000111": TestData(n, 2) = "?"
621.     n = n + 1: TestData(n, 1) = "11010000010110110011000011100001011111011000011110011101100000110000100000010000010001010000111110010110101001000000101110000110001000010001110100000010000001000011101101010000110010001100000100000011101100100001000000001100111001010100000100110001011100010000010111001110000100010010000010001111100000100100100001000110110001100110001101111011000001011001000000011100100101010011001100101011010001100010011010001001000001101101111011011111000011110010011000000000010010110010000000110001000100110111": TestData(n, 2) = "?"
622.     n = n + 1: TestData(n, 1) = "00000100000010111110001000101100000010001010000000101101111001011001001011100000010101110001111001010110010000111100000010000111100100111101001000001110000110110001000000100011001101000011111101100101100011000100010101001000111111000011100000101010011000100011010000000000001100000001100111000000010111000000000100101000000110001000110000000000001000100001111000000010011001111000000010100000000001010110001101001000101000001100000100000010000011110010110111000011101011111100000110100011001100010000": TestData(n, 2) = "?"
623.     n = n + 1: TestData(n, 1) = "10101110010100010000010000010000011111110110000001100001001110100001000011000000100100100000011001101101011010010100101000010000100111001010010001001100011000100010110010001111000000101000100001111011000001100000111111100110010011000000100011011000000110000000011100010011000100111111100001000001010001111100000100100100001101100100100000010010100111100101001000110011010111110010000111101000101001010001000101000010011001000111101011100010001000110010010111000011000010010100000000000010001000110010": TestData(n, 2) = "?"
624.     n = n + 1: TestData(n, 1) = "00000111101011000100000110000011010111110011111001001111011000010000010010010101000001000001100100100000000010000000111110010110001100110000110011000110010001000100110011111000000001111100111111001000001001001110011010010000011001100001010000000011111111110100011111100100001011111111010000001100010100011010100000110010011100111010000011001110000000001101001010000001110011000010011100001000110010100011111100100001111110011100011111100100000110100100100001001001101100000000000110011000001000000010": TestData(n, 2) = "?"
625.     n = n + 1: TestData(n, 1) = "11111110010011111111100001100100100001111111110110101011110000111101011111111111110011100111111001100111111111111111110010101010111111110011111111110011110010000001111111100111111110111000111111100001100010011001111111111011100010101101000100111111111010110011110011110011100111100001000101111100111001010111001010111111100001111011000100000111111001000111100100111111111000000001000000110110111001111000001010011001111111011011111000000100111110101100000011111111001111100001101100011010001111111100": TestData(n, 2) = "?"
626.     n = n + 1: TestData(n, 1) = "00111010110000001111101100000000010100000110001000000001010110100100011011110111100001001110000000000000000100001000010101011010001011101000111011010010000000000001101101101001101001100001110000100100100111000110000101101010100000010010001000001100110000001011010000000000100000011010101100001001001101100100010010100001100001001100101000000000000000110010101010000000111001010111100100110001000011001100111111011001101110000010000111101000001100000000000000100010111110100010101000001011100001111001": TestData(n, 2) = "?"
627.     n = n + 1: TestData(n, 1) = "00000001000011100110011001101000000000001110000001011000100011000001000101111001101110011101101111101110111100100010010110110011001000100000100000000101110010000010100111011110000111101001011001111100000110000110011001010001000000011100001111111101111100101101111011000000000100000000001111011000000001001011100100010001000001001100010000010011001110011000110011101001010110100110001110010000101111111011101101101100000010000100001100001100100011101011110110000110000010100110100010000110100110100100": TestData(n, 2) = "?"
628.     n = n + 1: TestData(n, 1) = "10111000101111101010011001001100001111110011000111011010000001110001010110100110011010110000011100110011100010100101010010001100010010000111001010111011000110110100000000110010100011001010001100111111111010001111001101000111010111111100100010000011110010011010100100100110001000010010011101010000000000100011001000011111001110010011101100011111110010000111100001001001001000100001000101111001001000111000110011001010101010010101100000010101000011100011001000001000100110000000000000111000001110010001": TestData(n, 2) = "?"
629.     n = n + 1: TestData(n, 1) = "11111001000101111111100011111101110101111110110001111101010100010000111111111111111110011111001110101111001101011111100010111111110100011100111110101110011001110011111111100101011000000101011100110110111100000101110000100100111110011110000111111111011011111100001100100110011001001101000001000101111001111101011101010110111100011100010011001000010000111110010001011110011111111111111001010111111101011111001110000000101001111010100111111101011000100101000011111001011001010011001101000110000100111111": TestData(n, 2) = "?"
630.     n = n + 1: TestData(n, 1) = "11001000011100110101111111001111010111100011011111101101101011011101101010011111111010111001110011110011111001000011111111111110001011111100111000011111111111111011000110011100110011001111010000010010011011011111101010011100111111111001111111001100111111101001101111010111110101100111111110011111110101101110010010001101000000011111110000001111111111111100000101000000111100011011001111111110011101110010101011111111000110111010001100100111111111111111111100001110011000011100001100011010001100000111": TestData(n, 2) = "?"
631.     n = n + 1: TestData(n, 1) = "01110000001111111111110011101001011000011111111111001111111100111111111111010110100011111110101110101001110000111000011111111001000000111100111100111100111101010011100111111110011111111100100111010001111111001100111001111111110011111111111101011111111000011111110100010101111110110111000010011110000100111010110010011111111100100111111111111111101101111100101010011110110110011110000110000001101101111101101111110011111111001111111101101101000100111101011101011111111001001111111111100110011111110010": TestData(n, 2) = "?"
632.     n = n + 1: TestData(n, 1) = "00100110010011111110100011001111110011100111111111111111111111111100010111101000111111010111111010111010010111111001000011100111111111001111001111111111111100111111111111110101001010111101010010011100101011111000001010110111001100110000111111110011001101010011101010011111111100100110011111110101001111111100100001110011100111111111111111110011111111001110000010111001111001101100010000111111001101001011111111111010110001011111110011111111111001000011100001100110000111111100110010011100101011001111": TestData(n, 2) = "?"
633.     n = n + 1: TestData(n, 1) = "01111001111110000010111001111101011111111000000101011111111100100111100001111111001101011110011110000111100111111110100101110000100001000010111101110101110000010001001110101111100100111111010010001100111111111111100111111111111111111110011111111110010011111100100001000011001001110011111111111111111111100001111111001000010011111111100111111100100001000011111111111111000000111111111001010110011111100110011001110011100111110011100111110011111010111100111111100000011111111110011110011001001101011100": TestData(n, 2) = "?"
634.     n = n + 1: TestData(n, 1) = "11111111111101101111111100111001111110010011111000011010111111111110011110011111110010011111111111111100111111111111100111110011111111111001111111110110111111111111000101000011111111111001000011110100010010011111001111110010111010000111110010011111111001001110011111111101010011100000011100111111010100001110011111111111111111110110111100101110111111111010111100111111111111111100001110000110011111111111100100111111111111010111100111111001100111111111100001111111111111101010110111111001111111100001": TestData(n, 2) = "?"
635.     n = n + 1: TestData(n, 1) = "10111001000011101011111011000110000100101000111000011110110001111100111101101000000001110010100001000111001001111010101011010110011110100110010101101001100001001000000100110000001011011111010000101010001011001011111101001011010110011010100100110101010101011000000111010110101000100111000000010000100111000111000001000101111101011100000011100111000001001011000000000011001011110010110000110001111111010101110110111110101010000001011011101111011100010101001110000111101001010001011001100100110011101111": TestData(n, 2) = "?"
636.     n = n + 1: TestData(n, 1) = "00011000111110101110110100111010001110101001010110011110000101101100100000101000111000111100001111101110110011110111010010011111011100101001010110000110011110011001111000000100110101010010111100001111101010011101110110000111111100000101111100101011110000010001000111111010111100101010111110010011111100111100111100100000011111100100111101111011010111000110011101110000110011001010110101110001000100000100001001010101010111110001011110000011011111100110011001111110011111011000100110011001100000110100": TestData(n, 2) = "?"
637.     n = n + 1: TestData(n, 1) = "11111000010101110101001110011110000111001101100000010000110100111100111110101000011100001000001011101001100110100101001100110101101100001111001000101101100010010011110100010000101011010110011011011001100001100111111001011001100101010111000111000010111111101011101011010100001101011010000001010101101011001100111010110011101010010010000100001101010101011101111000010010100110111101101110011101001001011111101000111101011000010001110000110010001100101010101111010111100101100001000000111101101011000010": TestData(n, 2) = "?"
638.     n = n + 1: TestData(n, 1) = "10000000000101100111000000010100011011010001111000101010111110011101101100011101001101111001000100100100000101111001110010011110010100011010100111111111101000100011000101010011111000011001111000011000000100010001000011100110111000001010111101001101001000100010001011100111111001111010011010010010111011111011001110111000001000110000101011010010010000010001100011100101010101101011111000111011101010101111111010001011000111110011111100010001010011011000100110011010101010110011100011010011111000111011": TestData(n, 2) = "?"
639.     n = n + 1: TestData(n, 1) = "11010000010011101000010111000000011000011010011110010011001110001001010110110011100111000000101011100110101001110011110000000001110100001010111111111111001011011110000001100111111010100111110101001100010110000010101100110001000010011010100001001100110011101101111100100110110110111010100100010011000110111001101001110111101010010000011011001001110011111111010000011111011100111010111110110101011011110010011010000100101000010001001011100111100110101010101011001011011001100110101001111001010000100010": TestData(n, 2) = "?"
640.     n = n + 1: TestData(n, 1) = "11010110011010111111001111010011110111100111001110010011101000111010010011001100011110011010000101010110111101011101101011010001111011001111010000011010110000100100011111000001110100110000100110010000111111010010100111000100101110110100110000001010111100010000101000100010100111000111000010000010010110101111001000010010011100111010000111010111011011011000010101100111100110010101001101101101100101100111100110110001101001001001011111001110100010101101110000010101111101010011111000111100000111010110": TestData(n, 2) = "?"
641.     n = n + 1: TestData(n, 1) = "00000100110111011101011011011101001011000100011001010111110100001100000011011001110010110011101111001111111000100111010101100111001111001101100001001110111110010110110101001001001010001100001100001010101011001100000100011000001010101001100100100100001111010110011101101110100101111100101001101001001010110010001011111111110010111001100000011101111101001101100101100101110101101100111000111010001110000111100100000100011000010110111110011000000101000111111001110011011111000110111101010111100001001101": TestData(n, 2) = "?"
642.     n = n + 1: TestData(n, 1) = "01111111101101010001101000100100111100001101111000111100011111000111111101101001100100110001101111001100110100010110111100010010111111100001100011010010101111111111001111010010000000100001101101111010011101000110111110101110011111111101001000000000000011100001110101110100010011000111001011111100011110001110001001011001001101010100000101101100100001110110111111111111000100000100111011000111100111111000101110010110101010011010011011110100001011100001110011110111110010010000010100010110101011111010": TestData(n, 2) = "?"
643.     n = n + 1: TestData(n, 1) = "01010010100000101100110000111011100101010111001101011001101011110001001011001111100011011101011110001100000001111100111010010010101101111101100100000110100010010101111110011111110011001101001001100011101000100010110001011000001111011001100101110001110111101110000011011010101111000001111000011010101101110101001011011111110101100100101100110011000010011101101001110111000011010111001100101100001101001001100101011100111010000010110100000101111111010001110000110101110101000110011001011011011101000110": TestData(n, 2) = "?"
644.     n = n + 1: TestData(n, 1) = "11001000101011011111101000010000110111111111000011010000010101000000100110111110010000000111110110111111100110101010111110011010001110010110100101000010111111000000111100111000011100100111001100111111110100010110000010010011000111001110001110110100111110101111011010100010000101001001101111111101010101111010111111001001001111111100101011011011101001100000100010111110101010100001110000110011001110101100101000101000111100100101110110011111001101011001100011100101001001100010101010011001010001111101": TestData(n, 2) = "?"
645.     n = n + 1: TestData(n, 1) = "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111": TestData(n, 2) = "?"
646.     n = n + 1: TestData(n, 1) = "00100000000010000000000100000011000110110001001110101010010011010001100000101001000000000000010001110100001001101000001000000000010001101001011000010000000000010000000010011010011001001000000100000100000000001000000001000101001000001110001001000100000000000100000111000011010000000000010001000000110010000000011000000000100100001000001000010001001001110000000010000000100000000000000010000100000010000000101110011000001000100000011010100001010000001000010100000000001000001100000100010010000101100000": TestData(n, 2) = "?"
647.     n = n + 1: TestData(n, 1) = "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111": TestData(n, 2) = "?"
648.     n = n + 1: TestData(n, 1) = "00001101110100101100011001010001001010010110000110000000100001000100100110000000010010100011000100110000110000100010000011001000000000100000001000100100100001100110100000101000101000010001110001111001000101000000100100001000000001110110100010001001000100100000011011000001000000000101000010000100010000110101001010010010001000110010110000000110010000110000001000101010001001101111001000010000101100011000000110001011110000001111001000000000000011110011100000000101010000000101110001000100000000100000": TestData(n, 2) = "?"
649. End Sub

p.s.

I dont think I understood

Quote

If the string value repeated, ie, the same value (0) or (1) carried over from the previous
event then the value is (1), if not then (0).

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 13, 2021, 11:28:01 pm

The new strings are built using the originals and based on rather the string value repeats
or changes.

Truth table
0 to 0 =(0) 
1 to 1 =(1)
0 to 1 =(0)
1 to 0 =(0)

It's just a reformatting of the string which can have a smoothing effect on the data which
seems to be somewhat easier to predict.  You don't need to do anything different, as were
still looking at predicting a zero or a one.  My software has a ascending / descending order
for all string option.  Some options require the data be fed in a certain order.

My math skills are lacking when it comes to higher level stuff so most of my tools are based
on statistics and pattern matching, maybe that's why most of them fail.  What I am working
on now is based on the logic used in the video that was posted.  The guy was able to come to
a high confidence level by the end of 20 games, the $100.00 bet.  The difference is that my
data may be too close to random to ever achieve this.  I am continuing to work on solutions
on my own but also using what you post at the same time.  If my post seem to fall outside
what your working on, then they can be safely ignored.

Anyway, thanks for your efforts and I will continue to follow your post as long as it takes
or your willing to address it.   There may not be the solution I'm looking for.  It's not just
a matter of finding the best, if the best falls short of my needs which is a possibility.


R1


   

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 14, 2021, 09:45:59 am

Hey R1, another day, another update, another summary, really.

So you're doing well by checking out and studying the video Steve linked. It implies a few lessons about n-grams, combinatorics, and other light-duty discrete math stuff. It's not a bad way to start thinking about this problem. Let me do you one better though. Luke clued me in to this website:

Quote

https://www.expunctis.com/2019/03/07/Not-so-random.html

...which does the "short game" version of what we're doing. You try to give the program a random sequence, and it will predict your next action pretty well. Zoom to this morning. I actually read the bottom of the website. Turns out the guy just uses 5-grams, and I thought "dude, this is just a special case of what I'm doing". So I commented a few lines and was able to copy the behavior from the website just about exactly:

  [ This attachment cannot be displayed inline in 'Print Page' view ]  

It's not terribly hard to "act randomly" for a while, but you're eventually caught. I've since modified my code a little since the screenshot, but below I kept the code in "game mode" with a few more experimental switches turned on. Try this out:

Code: QB64: [Select]

1. Option _Explicit
2.  
3. Screen _NewImage(120, 60)
4.  
5. ' Version: 8
6.  
7. Type LetterBin
8.     Signature As String
9.     Count As Integer
10. End Type
11.  
12. Dim Shared TestData(1000, 2) As String
13. Call LoadTestData
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. Dim m As Integer
45. Dim k As Integer
46. Dim thestring As String
47. Dim actual As String
48. Dim prediction As Integer
49.  
50. Dim Shared predictedGuess As Double
51. Dim Shared correctGuesses As Double
52. Dim Shared totalGuesses As Double
53.  
54. predictedGuess = Rnd
55. correctGuesses = 0
56. totalGuesses = 0
57.  
58. m = -1
59. thestring = ""
60. Do
61.  
62.     ' If analyzing pre-cooked data, load a test string.
63.     If (m > 0) Then
64.         thestring = TestData(m, 1)
65.         actual = TestData(m, 2)
66.     Else
67.         actual = "?"
68.     End If
69.  
70.     Cls
71.     For k = 1 To _Width
72.         Print "-";
73.     Next
74.  
75.     If (m > 0) Then
76.         Print
77.         Print "Case:"; m
78.         Print
79.     Else
80.         Print
81.         Print "Press 0 or 1 as randomly as you can. I've already guessed your next input."
82.         Print
83.         Print ">"; thestring
84.         Print
85.         Print "My previous guess was: "; _Trim$(Str$(predictedGuess))
86.         Print "I have been correct at a rate of "; _Trim$(Str$(Int(100 * correctGuesses / totalGuesses))); "%"
87.     End If
88.  
89.     prediction = Analyze(thestring, actual, 0)
90.     predictedGuess = prediction
91.  
92.     _KeyClear: Do: k = _KeyHit: _Limit 30: Loop Until k: _KeyClear
93.  
94.     If (m > 0) Then
95.         'm = UserInput1(k, m)
96.         _Delay 1
97.         m = m + 1
98.     Else
99.         thestring = UserInput2$(k, thestring)
100.     End If
101.  
102.     _KeyClear
103.     _Limit 30
104. Loop
105.  
106. End
107.  
108. Function Analyze (TheStringIn As String, ActualIn As String, pswitch As Integer)
109.     Dim TheReturn As Integer
110.     Dim As Integer n
111.     Dim As Double r, j, k, h
112.     Dim Fingerprint(16) As String
113.     Dim p(2 To 10, 2) As Double
114.  
115.     ' Create shifted versions of string, i.e. ABCD -> BCDA, CDAB, DABC, ABCD, BCDA, etc.
116.     Fingerprint(1) = TheStringIn
117.     For n = 2 To UBound(Fingerprint)
118.         Fingerprint(n) = Right$(Fingerprint(n - 1), Len(Fingerprint(n - 1)) - 1) + Left$(Fingerprint(n - 1), 1)
119.     Next
120.  
121.     ' Initialize partial results.
122.     For n = LBound(p) To UBound(p)
123.         p(n, 1) = -999
124.     Next
125.  
126.     Call CreateHisto(Fingerprint(), Alphabet2(), 2, 0) ' Set the last number =1 to print steps.
127.     Call CreateHisto(Fingerprint(), Alphabet3(), 3, 0)
128.     Call CreateHisto(Fingerprint(), Alphabet4(), 4, 0)
129.     Call CreateHisto(Fingerprint(), Alphabet5(), 5, 0)
130.     Call CreateHisto(Fingerprint(), Alphabet6(), 6, 0)
131.     Call CreateHisto(Fingerprint(), Alphabet7(), 7, 0)
132.     Call CreateHisto(Fingerprint(), Alphabet8(), 8, 0)
133.     Call CreateHisto(Fingerprint(), Alphabet9(), 9, 0)
134.     Call CreateHisto(Fingerprint(), Alphabet10(), 10, 0)
135.     'Call CreateHisto(Fingerprint(), Alphabet11(), 11, 0)
136.     'Call CreateHisto(Fingerprint(), Alphabet12(), 12, 0)
137.     'Call CreateHisto(Fingerprint(), Alphabet13(), 13, 0)
138.  
139.     If (pswitch = 1) Then
140.         If (Len(TheStringIn) >= 2) Then Call PrintHisto(Alphabet2(), 3) ' Set the last number >=1 to print stats for that histogram.
141.         If (Len(TheStringIn) >= 3) Then Call PrintHisto(Alphabet3(), 3)
142.         If (Len(TheStringIn) >= 4) Then Call PrintHisto(Alphabet4(), 3)
143.         If (Len(TheStringIn) >= 5) Then Call PrintHisto(Alphabet5(), 3)
144.         If (Len(TheStringIn) >= 6) Then Call PrintHisto(Alphabet6(), 0)
145.         If (Len(TheStringIn) >= 7) Then Call PrintHisto(Alphabet7(), 0)
146.         If (Len(TheStringIn) >= 8) Then Call PrintHisto(Alphabet8(), 0)
147.         If (Len(TheStringIn) >= 9) Then Call PrintHisto(Alphabet9(), 0)
148.         If (Len(TheStringIn) >= 10) Then Call PrintHisto(Alphabet10(), 0)
149.         'If (Len(TheStringIn) >= 11) Then Call PrintHisto(Alphabet11(), 0)
150.         'If (Len(TheStringIn) >= 12) Then Call PrintHisto(Alphabet12(), 0)
151.         'If (Len(TheStringIn) >= 13) Then Call PrintHisto(Alphabet13(), 0)
152.         Print
153.     End If
154.  
155.     If (Len(TheStringIn) >= 2) Then Call MakeGuess(TheStringIn, Alphabet2(), 2, p(), pswitch) ' Set the last number =1 to print guess for that histogram.
156.     If (Len(TheStringIn) >= 3) Then Call MakeGuess(TheStringIn, Alphabet3(), 3, p(), pswitch)
157.     If (Len(TheStringIn) >= 4) Then Call MakeGuess(TheStringIn, Alphabet4(), 4, p(), pswitch)
158.     If (Len(TheStringIn) >= 5) Then Call MakeGuess(TheStringIn, Alphabet5(), 5, p(), pswitch)
159.     If (Len(TheStringIn) >= 6) Then Call MakeGuess(TheStringIn, Alphabet6(), 6, p(), pswitch)
160.     If (Len(TheStringIn) >= 7) Then Call MakeGuess(TheStringIn, Alphabet7(), 7, p(), pswitch)
161.     If (Len(TheStringIn) >= 8) Then Call MakeGuess(TheStringIn, Alphabet8(), 8, p(), pswitch)
162.     If (Len(TheStringIn) >= 9) Then Call MakeGuess(TheStringIn, Alphabet9(), 9, p(), pswitch)
163.     If (Len(TheStringIn) >= 10) Then Call MakeGuess(TheStringIn, Alphabet10(), 10, p(), pswitch)
164.     'If (Len(TheStringIn) >= 11) Then Call MakeGuess(TheStringIn, Alphabet11(), 11, p(), pswitch)
165.     'If (Len(TheStringIn) >= 12) Then Call MakeGuess(TheStringIn, Alphabet12(), 12, p(), pswitch)
166.     'If (Len(TheStringIn) >= 13) Then Call MakeGuess(TheStringIn, Alphabet13(), 13, p(), pswitch)
167.     If (pswitch = 1) Then Print
168.  
169.     If (pswitch = 1) Then
170.         Print "Analyzing:"
171.         Print TheStringIn
172.  
173.         Print
174.         Print "Thinking:";
175.         For k = LBound(p) To UBound(p)
176.             If (p(k, 1) <> -999) Then
177.                 Print p(k, 1);
178.             Else
179.                 Print "_ ";
180.             End If
181.         Next
182.         Print: Print
183.     End If
184.  
185.     j = 0
186.     r = 0
187.  
188.     For k = UBound(p) To LBound(p) Step -1
189.         If (p(k, 1) <> -999) Then
190.  
191.             ' This is the made-up part of the model:
192.             ' The variable r contributes to weighted average.
193.             ' The variable j is used for normalization.
194.             ' Scaling factor h influences weighted average calculaton.
195.             ' The factors multiplying h are totally arbitrary. Notes:
196.             '   setting o(h^2) means the later alphabets count for more.
197.             '   p(k, 1) euqals the calculated guess at frequency k.
198.             '   p(k, 2) euqals the peak count of the unscaled histogram.
199.             '   ...while p(k, 2) is here, it does not seem to help calculations.
200.  
201.             h = 1 + k - LBound(p)
202.  
203.             h = h ^ 2
204.  
205.             ' Standard weighted average:
206.             r = r + h * p(k, 1)
207.             j = j + h
208.  
209.         End If
210.     Next
211.     If (j <> 0) Then
212.         r = r / j
213.     End If
214.  
215.     If (pswitch = 1) Then Print "Predicting:  "; _Trim$(Str$(r))
216.  
217.     If (r > .5) Then
218.         r = 1
219.     Else
220.         r = 0
221.     End If
222.  
223.     If (pswitch = 1) Then
224.         Print "Rounding to: "; _Trim$(Str$(r))
225.  
226.         ' Just for show, do the most naive thing possible by counting 1's.
227.         n = Len(TheStringIn)
228.         h = 0
229.         For k = 1 To n
230.             If Val(Mid$(TheStringIn, k, 1)) = 1 Then h = h + 1
231.         Next
232.         h = h / n
233.         Print
234.         Print "Naive (dec): "; _Trim$(Str$(h))
235.         If (h > .5) Then
236.             h = 1
237.         Else
238.             h = 0
239.         End If
240.         Print "Naive (int): "; _Trim$(Str$(h))
241.  
242.         ' Compare result to actual/known data if it was specified.
243.         If (ActualIn <> "?") Then
244.             Print
245.             Print "Actual:      "; ActualIn
246.             If (_Trim$(Str$(r)) <> ActualIn) Then
247.                 Beep
248.                 Print
249.                 Print "*** MISMATCH ***"
250.             End If
251.         End If
252.  
253.     End If
254.  
255.     TheReturn = r
256.     Analyze = TheReturn
257. End Function
258.  
259. Sub MakeGuess (OrigString As String, arralpha() As LetterBin, wid As Integer, arrbeta() As Double, pswitch As Integer)
260.     Dim TheReturn As Double
261.     Dim As Integer j, k, n
262.     TheReturn = 0
263.     j = 1 '0
264.     k = 0
265.     For n = 1 To UBound(arralpha)
266.         If (Left$(arralpha(n).Signature, wid - 1) = Right$(OrigString, wid - 1)) Then
267.             If (arralpha(n).Count >= j) Then
268.                 If (pswitch = 1) Then Print "Order-"; Right$("0" + _Trim$(Str$(wid)), 2); " guess: "; arralpha(n).Signature; " . "; _Trim$(Str$(arralpha(n).Count))
269.                 TheReturn = TheReturn + Val(Right$(arralpha(n).Signature, 1))
270.                 k = k + 1
271.                 j = arralpha(n).Count
272.             End If
273.         End If
274.     Next
275.     If (k <> 0) Then
276.         TheReturn = TheReturn / k
277.         arrbeta(wid, 1) = TheReturn
278.         arrbeta(wid, 2) = j
279.     Else
280.         TheReturn = .5
281.         arrbeta(wid, 1) = TheReturn
282.         arrbeta(wid, 2) = j
283.     End If
284. End Sub
285.  
286. Sub CreateHisto (arrfinger() As String, arralpha() As LetterBin, w As Integer, pswitch As Integer)
287.     Dim As Integer j, k, n
288.     For n = 1 To UBound(arralpha)
289.         arralpha(n).Count = 0
290.     Next
291.     For j = 1 To w '1 'w
292.         For k = 1 To Len(arrfinger(j)) - (Len(arrfinger(j)) Mod w) Step w '- 0 Step 1 'w 'make the 0 a -w? might not matter at all
293.             If (pswitch = 1) Then Print j; " "; arrfinger(j)
294.             For n = 1 To UBound(arralpha)
295.                 If (pswitch = 1) Then Print "@@@"; n; " "; Mid$(arrfinger(j), k, w); " "; arralpha(n).Signature;
296.                 If (Mid$(arrfinger(j), k, w) = arralpha(n).Signature) Then
297.                     arralpha(n).Count = arralpha(n).Count + 1
298.                     If (pswitch = 1) Then Print "***";
299.                 End If
300.                 If (pswitch = 1) Then Print
301.             Next
302.         Next
303.     Next
304.     Call QuickSort(arralpha(), 1, UBound(arralpha))
305. End Sub
306.  
307. Sub PrintHisto (arr() As LetterBin, w As Integer)
308.     Dim As Integer j, n
309.     If (w > 0) Then
310.         If (w > UBound(arr)) Then
311.             j = UBound(arr)
312.         Else
313.             j = w
314.         End If
315.         Print "Histogram: "; _Trim$(Str$(UBound(arr))); "-letter regroup, showing top "; _Trim$(Str$(w))
316.         For n = 1 To j
317.             Print arr(n).Signature; arr(n).Count
318.         Next
319.     End If
320. End Sub
321.  
322. Function UserInput1 (TheKeyIn As Integer, PresentIndexIn As Integer)
323.     Dim TheReturn As Integer
324.     Dim As Integer j, k
325.     k = TheKeyIn
326.     j = -1
327.     Select Case k ' Arrows
328.         Case 19712
329.             j = PresentIndexIn + 1
330.         Case 19200
331.             j = PresentIndexIn - 1
332.     End Select
333.     TheReturn = j
334.     UserInput1 = TheReturn
335. End Function
336.  
337. Function UserInput2$ (TheKeyIn As Integer, TheStringIn As String)
338.     Dim TheReturn As String
339.     Dim As Integer k
340.     Dim As String t
341.     k = TheKeyIn
342.     t = TheStringIn
343.     Select Case k ' 0, 1
344.         Case 48
345.             t = t + "0"
346.             If predictedGuess = 0 Then correctGuesses = correctGuesses + 1
347.             totalGuesses = totalGuesses + 1
348.         Case 49
349.             t = t + "1"
350.             If predictedGuess = 1 Then correctGuesses = correctGuesses + 1
351.             totalGuesses = totalGuesses + 1
352.     End Select
353.     TheReturn = t
354.     UserInput2$ = TheReturn
355. End Function
356.  
357. Sub NewAlphabet (arrold() As LetterBin, arrnew() As LetterBin)
358.     Dim As Integer j, k, n
359.     n = 0
360.     For k = 1 To 2
361.         For j = 1 To UBound(arrold)
362.             n = n + 1
363.             arrnew(n).Signature = arrold(j).Signature
364.         Next
365.     Next
366.     For j = 1 To UBound(arrnew)
367.         If (j <= UBound(arrnew) / 2) Then
368.             arrnew(j).Signature = "0" + arrnew(j).Signature
369.         Else
370.             arrnew(j).Signature = "1" + arrnew(j).Signature
371.         End If
372.     Next
373. End Sub
374.  
375. Sub QuickSort (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
376.     Dim As Long piv
377.     If (LowLimit < HighLimit) Then
378.         piv = Partition(arr(), LowLimit, HighLimit)
379.         Call QuickSort(arr(), LowLimit, piv - 1)
380.         Call QuickSort(arr(), piv + 1, HighLimit)
381.     End If
382. End Sub
383.  
384. Function Partition (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
385.     Dim As Long i, j
386.     Dim As Double pivot, tmp
387.     pivot = arr(HighLimit).Count
388.     i = LowLimit - 1
389.     For j = LowLimit To HighLimit - 1
390.         tmp = arr(j).Count - pivot
391.         If (tmp >= 0) Then
392.             i = i + 1
393.             Swap arr(i), arr(j)
394.         End If
395.     Next
396.     Swap arr(i + 1), arr(HighLimit)
397.     Partition = i + 1
398. End Function
399.  
400. Sub LoadTestData
401.     Dim n As Integer
402.     '''
403.     n = 0
404.     '''
405.     ' Test: counting linearly
406.     n = n + 1: TestData(n, 1) = "000001010011100101110111": TestData(n, 2) = "0" '0 to 7
407.     n = n + 1: TestData(n, 1) = "0000000100100011010001010110011110001001101010111100110111101111": TestData(n, 2) = "0" '0 to 15
408.     n = n + 1: TestData(n, 1) = "0000000001000100001100100001010011000111010000100101010010110110001101011100111110000100011001010011101001010110110101111100011001110101101111100111011111011111": TestData(n, 2) = "0" '0 to 31
409.     '''
410.     'n = 0
411.     '''
412.     ' Test: single-one patterns at stepping frequencies, all phases
413.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0"
414.     n = n + 1: TestData(n, 1) = "01010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101": TestData(n, 2) = "0"
415.     n = n + 1: TestData(n, 1) = "10101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010": TestData(n, 2) = "1"
416.     n = n + 1: TestData(n, 1) = "00100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100": TestData(n, 2) = "1"
417.     n = n + 1: TestData(n, 1) = "01001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001": TestData(n, 2) = "0"
418.     n = n + 1: TestData(n, 1) = "10010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010": TestData(n, 2) = "0"
419.     n = n + 1: TestData(n, 1) = "00010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001": TestData(n, 2) = "0"
420.     n = n + 1: TestData(n, 1) = "00100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010": TestData(n, 2) = "0"
421.     n = n + 1: TestData(n, 1) = "01000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100": TestData(n, 2) = "0"
422.     n = n + 1: TestData(n, 1) = "10001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000": TestData(n, 2) = "1"
423.     n = n + 1: TestData(n, 1) = "00001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000": TestData(n, 2) = "0"
424.     n = n + 1: TestData(n, 1) = "00010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000": TestData(n, 2) = "1"
425.     n = n + 1: TestData(n, 1) = "00100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001": TestData(n, 2) = "0"
426.     n = n + 1: TestData(n, 1) = "01000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010": TestData(n, 2) = "0"
427.     n = n + 1: TestData(n, 1) = "10000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100001000010000100": TestData(n, 2) = "0"
428.     n = n + 1: TestData(n, 1) = "00000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100": TestData(n, 2) = "0"
429.     n = n + 1: TestData(n, 1) = "00001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000": TestData(n, 2) = "0"
430.     n = n + 1: TestData(n, 1) = "00010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000": TestData(n, 2) = "0"
431.     n = n + 1: TestData(n, 1) = "00100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000100000": TestData(n, 2) = "1"
432.     n = n + 1: TestData(n, 1) = "01000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001000001": TestData(n, 2) = "0"
433.     n = n + 1: TestData(n, 1) = "10000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010000010": TestData(n, 2) = "0"
434.     ' Test: inverted version of the above
435.     n = n + 1: TestData(n, 1) = "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111": TestData(n, 2) = "1"
436.     n = n + 1: TestData(n, 1) = "10101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010": TestData(n, 2) = "1"
437.     n = n + 1: TestData(n, 1) = "01010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101": TestData(n, 2) = "0"
438.     n = n + 1: TestData(n, 1) = "11011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011": TestData(n, 2) = "0"
439.     n = n + 1: TestData(n, 1) = "10110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110": TestData(n, 2) = "1"
440.     n = n + 1: TestData(n, 1) = "01101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101": TestData(n, 2) = "1"
441.     n = n + 1: TestData(n, 1) = "11101110111011101110111011101110111011101110111011101110111011101110111011101110111011101110111011101110111011101110111011101110": TestData(n, 2) = "1"
442.     n = n + 1: TestData(n, 1) = "11011101110111011101110111011101110111011101110111011101110111011101110111011101110111011101110111011101110111011101110111011101": TestData(n, 2) = "1"
443.     n = n + 1: TestData(n, 1) = "10111011101110111011101110111011101110111011101110111011101110111011101110111011101110111011101110111011101110111011101110111011": TestData(n, 2) = "1"
444.     n = n + 1: TestData(n, 1) = "01110111011101110111011101110111011101110111011101110111011101110111011101110111011101110111011101110111011101110111011101110111": TestData(n, 2) = "0"
445.     n = n + 1: TestData(n, 1) = "11110111101111011110111101111011110111101111011110111101111011110111101111011110111101111011110111101111011110111101111011110111": TestData(n, 2) = "1"
446.     n = n + 1: TestData(n, 1) = "11101111011110111101111011110111101111011110111101111011110111101111011110111101111011110111101111011110111101111011110111101111": TestData(n, 2) = "0"
447.     n = n + 1: TestData(n, 1) = "11011110111101111011110111101111011110111101111011110111101111011110111101111011110111101111011110111101111011110111101111011110": TestData(n, 2) = "1"
448.     n = n + 1: TestData(n, 1) = "10111101111011110111101111011110111101111011110111101111011110111101111011110111101111011110111101111011110111101111011110111101": TestData(n, 2) = "1"
449.     n = n + 1: TestData(n, 1) = "01111011110111101111011110111101111011110111101111011110111101111011110111101111011110111101111011110111101111011110111101111011": TestData(n, 2) = "1"
450.     n = n + 1: TestData(n, 1) = "11111011111011111011111011111011111011111011111011111011111011111011111011111011111011111011111011111011111011111011111011111011": TestData(n, 2) = "1"
451.     n = n + 1: TestData(n, 1) = "11110111110111110111110111110111110111110111110111110111110111110111110111110111110111110111110111110111110111110111110111110111": TestData(n, 2) = "1"
452.     n = n + 1: TestData(n, 1) = "11101111101111101111101111101111101111101111101111101111101111101111101111101111101111101111101111101111101111101111101111101111": TestData(n, 2) = "1"
453.     n = n + 1: TestData(n, 1) = "11011111011111011111011111011111011111011111011111011111011111011111011111011111011111011111011111011111011111011111011111011111": TestData(n, 2) = "0"
454.     n = n + 1: TestData(n, 1) = "10111110111110111110111110111110111110111110111110111110111110111110111110111110111110111110111110111110111110111110111110111110": TestData(n, 2) = "1"
455.     n = n + 1: TestData(n, 1) = "01111101111101111101111101111101111101111101111101111101111101111101111101111101111101111101111101111101111101111101111101111101": TestData(n, 2) = "1"
456.     '''
457.     'n = 0
458.     '''
459.     ' Test: single-one patterns, select phases
460.     n = n + 1: TestData(n, 1) = "00000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100": TestData(n, 2) = "0"
461.     n = n + 1: TestData(n, 1) = "00100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000": TestData(n, 2) = "1"
462.     n = n + 1: TestData(n, 1) = "00000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001": TestData(n, 2) = "0"
463.     n = n + 1: TestData(n, 1) = "10000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000010000000": TestData(n, 2) = "1"
464.     ' Test: inverted version of the above
465.     n = n + 1: TestData(n, 1) = "11111101111110111111011111101111110111111011111101111110111111011111101111110111111011111101111110111111011111101111110111111011": TestData(n, 2) = "1"
466.     n = n + 1: TestData(n, 1) = "11011111101111110111111011111101111110111111011111101111110111111011111101111110111111011111101111110111111011111101111110111111": TestData(n, 2) = "0"
467.     n = n + 1: TestData(n, 1) = "11111110111111101111111011111110111111101111111011111110111111101111111011111110111111101111111011111110111111101111111011111110": TestData(n, 2) = "1"
468.     n = n + 1: TestData(n, 1) = "01111111011111110111111101111111011111110111111101111111011111110111111101111111011111110111111101111111011111110111111101111111": TestData(n, 2) = "0"
469.     '''
470.     'n = 0
471.     '''
472.     ' Test: double-one patterns
473.     n = n + 1: TestData(n, 1) = "00110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011": TestData(n, 2) = "0"
474.     n = n + 1: TestData(n, 1) = "01100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110": TestData(n, 2) = "0"
475.     n = n + 1: TestData(n, 1) = "11001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100": TestData(n, 2) = "1"
476.     n = n + 1: TestData(n, 1) = "10011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001": TestData(n, 2) = "1"
477.     n = n + 1: TestData(n, 1) = "00011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100": TestData(n, 2) = "0"
478.     n = n + 1: TestData(n, 1) = "00111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000": TestData(n, 2) = "1"
479.     n = n + 1: TestData(n, 1) = "01110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001": TestData(n, 2) = "1"
480.     n = n + 1: TestData(n, 1) = "11100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011": TestData(n, 2) = "1"
481.     n = n + 1: TestData(n, 1) = "11000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111": TestData(n, 2) = "0"
482.     n = n + 1: TestData(n, 1) = "10001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110": TestData(n, 2) = "0"
483.     ' Test: inverted version of the above
484.     n = n + 1: TestData(n, 1) = "11001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100": TestData(n, 2) = "1"
485.     n = n + 1: TestData(n, 1) = "10011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001": TestData(n, 2) = "1"
486.     n = n + 1: TestData(n, 1) = "00110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011": TestData(n, 2) = "0"
487.     n = n + 1: TestData(n, 1) = "01100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110": TestData(n, 2) = "0"
488.     n = n + 1: TestData(n, 1) = "11100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011": TestData(n, 2) = "1"
489.     n = n + 1: TestData(n, 1) = "11000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111": TestData(n, 2) = "0"
490.     n = n + 1: TestData(n, 1) = "10001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110": TestData(n, 2) = "0"
491.     n = n + 1: TestData(n, 1) = "00011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100011100": TestData(n, 2) = "0"
492.     n = n + 1: TestData(n, 1) = "00111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000111000": TestData(n, 2) = "1"
493.     n = n + 1: TestData(n, 1) = "01110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001110001": TestData(n, 2) = "1"
494.     '''
495.     'n = 0
496.     '''
497.     ' Test: repeated staggered pattern: 010011000111, all phases
498.     n = n + 1: TestData(n, 1) = "010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111": TestData(n, 2) = "0"
499.     n = n + 1: TestData(n, 1) = "100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110": TestData(n, 2) = "1"
500.     n = n + 1: TestData(n, 1) = "001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101": TestData(n, 2) = "0"
501.     n = n + 1: TestData(n, 1) = "011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010": TestData(n, 2) = "0"
502.     n = n + 1: TestData(n, 1) = "110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100": TestData(n, 2) = "1"
503.     n = n + 1: TestData(n, 1) = "100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001": TestData(n, 2) = "1"
504.     n = n + 1: TestData(n, 1) = "000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011": TestData(n, 2) = "0"
505.     n = n + 1: TestData(n, 1) = "001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110": TestData(n, 2) = "0"
506.     n = n + 1: TestData(n, 1) = "011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100": TestData(n, 2) = "0"
507.     n = n + 1: TestData(n, 1) = "111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000111010011000": TestData(n, 2) = "1"
508.     n = n + 1: TestData(n, 1) = "110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001110100110001": TestData(n, 2) = "1"
509.     n = n + 1: TestData(n, 1) = "101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011101001100011": TestData(n, 2) = "1"
510.     ' Test: inverted version of the above
511.     n = n + 1: TestData(n, 1) = "101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000": TestData(n, 2) = "1"
512.     n = n + 1: TestData(n, 1) = "011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001": TestData(n, 2) = "0"
513.     n = n + 1: TestData(n, 1) = "110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010": TestData(n, 2) = "1"
514.     n = n + 1: TestData(n, 1) = "100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101": TestData(n, 2) = "1"
515.     n = n + 1: TestData(n, 1) = "001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011": TestData(n, 2) = "0"
516.     n = n + 1: TestData(n, 1) = "011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110": TestData(n, 2) = "0"
517.     n = n + 1: TestData(n, 1) = "111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100": TestData(n, 2) = "1"
518.     n = n + 1: TestData(n, 1) = "110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001": TestData(n, 2) = "1"
519.     n = n + 1: TestData(n, 1) = "100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011": TestData(n, 2) = "1"
520.     n = n + 1: TestData(n, 1) = "000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111000101100111": TestData(n, 2) = "0"
521.     n = n + 1: TestData(n, 1) = "001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110001011001110": TestData(n, 2) = "0"
522.     n = n + 1: TestData(n, 1) = "010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100010110011100": TestData(n, 2) = "0"
523.     '''
524.     'n = 0
525.     '''
526.     ' Test: repeated staggered pattern: 0100101010101001010101000111, all phases
527.     n = n + 1: TestData(n, 1) = "01001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111": TestData(n, 2) = "0"
528.     n = n + 1: TestData(n, 1) = "10010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110": TestData(n, 2) = "1"
529.     n = n + 1: TestData(n, 1) = "00101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101": TestData(n, 2) = "0"
530.     n = n + 1: TestData(n, 1) = "01010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010": TestData(n, 2) = "0"
531.     n = n + 1: TestData(n, 1) = "10101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100": TestData(n, 2) = "1"
532.     n = n + 1: TestData(n, 1) = "01010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001": TestData(n, 2) = "0"
533.     n = n + 1: TestData(n, 1) = "10101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010": TestData(n, 2) = "1"
534.     n = n + 1: TestData(n, 1) = "01010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101": TestData(n, 2) = "0"
535.     n = n + 1: TestData(n, 1) = "10101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010": TestData(n, 2) = "1"
536.     n = n + 1: TestData(n, 1) = "01010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101": TestData(n, 2) = "0"
537.     n = n + 1: TestData(n, 1) = "10100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010": TestData(n, 2) = "1"
538.     n = n + 1: TestData(n, 1) = "01001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101": TestData(n, 2) = "0"
539.     n = n + 1: TestData(n, 1) = "10010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010": TestData(n, 2) = "1"
540.     n = n + 1: TestData(n, 1) = "00101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101": TestData(n, 2) = "0"
541.     n = n + 1: TestData(n, 1) = "01010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010": TestData(n, 2) = "0"
542.     n = n + 1: TestData(n, 1) = "10101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100": TestData(n, 2) = "1"
543.     n = n + 1: TestData(n, 1) = "01010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001": TestData(n, 2) = "0"
544.     n = n + 1: TestData(n, 1) = "10101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010": TestData(n, 2) = "1"
545.     n = n + 1: TestData(n, 1) = "01010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101": TestData(n, 2) = "0"
546.     n = n + 1: TestData(n, 1) = "10100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010": TestData(n, 2) = "1"
547.     n = n + 1: TestData(n, 1) = "01000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101": TestData(n, 2) = "0"
548.     n = n + 1: TestData(n, 1) = "10001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010": TestData(n, 2) = "1"
549.     n = n + 1: TestData(n, 1) = "00011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101": TestData(n, 2) = "0"
550.     n = n + 1: TestData(n, 1) = "00111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010": TestData(n, 2) = "0"
551.     n = n + 1: TestData(n, 1) = "01110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100": TestData(n, 2) = "0"
552.     n = n + 1: TestData(n, 1) = "11101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000": TestData(n, 2) = "1"
553.     n = n + 1: TestData(n, 1) = "11010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011101001010101010010101010001": TestData(n, 2) = "1"
554.     n = n + 1: TestData(n, 1) = "10100101010101001010101000111010010101010100101010100011101001010101010010101010001110100101010101001010101000111010010101010100101010100011": TestData(n, 2) = "1"
555.     ' Test: inverted version of the above
556.     n = n + 1: TestData(n, 1) = "10110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000": TestData(n, 2) = "1"
557.     n = n + 1: TestData(n, 1) = "01101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001": TestData(n, 2) = "0"
558.     n = n + 1: TestData(n, 1) = "11010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010": TestData(n, 2) = "1"
559.     n = n + 1: TestData(n, 1) = "10101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101": TestData(n, 2) = "1"
560.     n = n + 1: TestData(n, 1) = "01010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011": TestData(n, 2) = "0"
561.     n = n + 1: TestData(n, 1) = "10101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110": TestData(n, 2) = "1"
562.     n = n + 1: TestData(n, 1) = "01010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101": TestData(n, 2) = "0"
563.     n = n + 1: TestData(n, 1) = "10101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010": TestData(n, 2) = "1"
564.     n = n + 1: TestData(n, 1) = "01010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101": TestData(n, 2) = "0"
565.     n = n + 1: TestData(n, 1) = "10101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010": TestData(n, 2) = "1"
566.     n = n + 1: TestData(n, 1) = "01011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101": TestData(n, 2) = "0"
567.     n = n + 1: TestData(n, 1) = "10110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010": TestData(n, 2) = "1"
568.     n = n + 1: TestData(n, 1) = "01101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101": TestData(n, 2) = "0"
569.     n = n + 1: TestData(n, 1) = "11010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010": TestData(n, 2) = "1"
570.     n = n + 1: TestData(n, 1) = "10101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101": TestData(n, 2) = "1"
571.     n = n + 1: TestData(n, 1) = "01010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011": TestData(n, 2) = "0"
572.     n = n + 1: TestData(n, 1) = "10101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110": TestData(n, 2) = "1"
573.     n = n + 1: TestData(n, 1) = "01010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101": TestData(n, 2) = "0"
574.     n = n + 1: TestData(n, 1) = "10101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010": TestData(n, 2) = "1"
575.     n = n + 1: TestData(n, 1) = "01011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101": TestData(n, 2) = "0"
576.     n = n + 1: TestData(n, 1) = "10111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010": TestData(n, 2) = "1"
577.     n = n + 1: TestData(n, 1) = "01110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101": TestData(n, 2) = "0"
578.     n = n + 1: TestData(n, 1) = "11100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010": TestData(n, 2) = "1"
579.     n = n + 1: TestData(n, 1) = "11000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101": TestData(n, 2) = "1"
580.     n = n + 1: TestData(n, 1) = "10001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011": TestData(n, 2) = "1"
581.     n = n + 1: TestData(n, 1) = "00010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111": TestData(n, 2) = "0"
582.     n = n + 1: TestData(n, 1) = "00101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101010101110": TestData(n, 2) = "0"
583.     n = n + 1: TestData(n, 1) = "01011010101010110101010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100": TestData(n, 2) = "0"
584.     '''
585.     'n = 0
586.     '''
587.     ' Test: r1's custom quiz 1
588.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '1
589.     n = n + 1: TestData(n, 1) = "00000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
590.     n = n + 1: TestData(n, 1) = "00000100000101110000001100010001100001001000000000000000001100000000000000000111001000000000000111100000000100111000000000000010000000001111000000000000000000000000000001010000000000000000010000000000000011000111100001000100000000000000000001101000000000000000001000110110000010000100000011001100001101001000000000000000000010000100001100011000101000000010000000000000000000000000000000000001000000000010000000000000001010000010000000000000000000000000000000000010000100000000000000001011010000000000": TestData(n, 2) = "0" '
591.     n = n + 1: TestData(n, 1) = "00011101100000000001011100001011101000100111101100011000000011001010101000101000111111011000111000100000000000000110110000000001001001110110100001011011101100000011001010001111111110101100001101100001100011000111101100110000000101101101110000001110110111000011000110000000001101111000110000000011111100110001111000011101111101010011111111101111010011011001111101100010001100101101001011000010100111111101111010111111010110001100011000000100010001100111111001101101111000000010110111110000001011010011": TestData(n, 2) = "0" '
592.     n = n + 1: TestData(n, 1) = "00000000100000000000110000000000000000010000000000000000010000000000000000001000000000000000000000000000000001000000010000000000000000000000000000000000000000000000000000011000000000000000001000000001000000000000000000000000000000000000000001001011001000000000000110000000000000000000000000000000000100010000000000000000000000000000000000001100000000000000000000000000000000100000000000000000001000000000000000000000000000000000000000000000100000000000000000100000000000000000000000000000000000000000": TestData(n, 2) = "0" '
593.     n = n + 1: TestData(n, 1) = "01111011010110000100001000011001101101000011000011000000000100110010001010000100010000001110111000001000000000101110101100000000100011100101101110000010110101111001011010100000111011100110100001100100111010111110000010000110010000000100111100110000000101010100111001000000101000100101111001001001000010000100110011011010011011101000110011000000101000000100010000101101000101000110000100010101010111100000000001100000110010000001000011100001001000100000011100000101000001010101000100011010000100010011": TestData(n, 2) = "0" '
594.     n = n + 1: TestData(n, 1) = "11000110011000111000001101000010001000001110001001110010000110000111010001010001100010101100001111100000111100101100000011000111101101110010101101010000101010000001111100000111110101010000000011011100100110101100111101000000100100101000011010000000010110101010011001110011111000010001100110001111111001100010011100010101001100000101010101100000000001001010000011011100010011001000001001110111100110010010000010000111111101100011010101010101000111010110101000000010001001001011011011100101111110110010": TestData(n, 2) = "0" '
595.     n = n + 1: TestData(n, 1) = "10101101010001010110010110011111011111111101110100010011101110000000100011010000100111111001110110100011011110011101110001110011110000111011011110111011101100000010100111100010000010100111110010100100010001010101111000111010011101010111001110110000101101110001110010011101010110101110001111000101011001001101001011111101110010110101001100110010111101010111010010000010110100010001101110110101101110000101101010001001101101011000111110100000011101110010101111011110111110100110101001111101110001010110": TestData(n, 2) = "1" '
596.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
597.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000001000000000000000000000000000100000000000000000000000000000000000000000000000100000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000": TestData(n, 2) = "0" '10
598.     n = n + 1: TestData(n, 1) = "00000110110101110000001100100101000001001111101111100000011000000000001001000100011000000000100011100000100000001001000001000010000000010111001101000001100000010101100011010011111000100111010000000000001010001011101110010100000000000010001011101000010000100000101100110100000011111000000001110000010101010000111111110000000110000100111110011000100000010001010100000000000110000000011000100000000111110011110010000100001010000010011100000000010001101010000000000110010000000110000000110011000000000000": TestData(n, 2) = "0" '
599.     n = n + 1: TestData(n, 1) = "11011001010011000110101011011010000110001001010001001111100111001011110110111010001111010110010100100101011010110010010100111010111001101011100100001010011111111010011100101101000011011011000111011011010110111100110011100010100001101010110101110101110111010111010010011001110100011010011010101111101110100100100111101101001011100001001100100111010101100100101000111111111001001111100111010110111100001000000111101000111000001101011001001110001000010100110011111001001010101001110111010101111001100001": TestData(n, 2) = "0" '
600.     n = n + 1: TestData(n, 1) = "00000000000000000000010000000001100000000000000000000001010000000000110010000000000000000000000000000000000000000000000000001100000000000111000101000000000000000000000000000100010001000000000000000000000000000000001100010010000000000000000001100000000000000000000000000001000000000000000000000000000000000010000011000000000000010000000000000001000000001000000000000000000000000000000000000100100000000000100000000000000000000000000000000000100000000000000000000000000000000000000000100000000000000000": TestData(n, 2) = "0" '
601.     n = n + 1: TestData(n, 1) = "11101000011011010000101000100000010001001000000110011110001011010001001101101010001100111000000101001000011000001010010100010011100110101000101000000000010100111001010100010010101010100011000011000001011010000000010000000001011110110111000010000001011011100000000111001110100000110000000011000101100000001001000100110011000100100000100001001000000011010010100000000100100000101001100000110001001001110101010001000000011000000010101000110010000100001011000001101000101010011011001110010110000010000000": TestData(n, 2) = "0" '
602.     n = n + 1: TestData(n, 1) = "00000010100110101001001000100000010100100100101101010010000001001100000000001011001110011011000010000111111001100010110011000010100110110000000000011010011010010100100011011011001100110001101001110000101001001100100010001101001000001011111100011011100000011001001010111000000000111101111001111001111111101000000000101100011001001011011010010000100001100010011110010000001011000001010111010010011111001001001110111100110010000110100111101000000101110100101010001111001111101100010101001001010101000101": TestData(n, 2) = "0" '
603.     n = n + 1: TestData(n, 1) = "00111100000000000111001001100000111010010010010011100010001100001100000011011000100010000101110010110100110110011100010001111110011011000110010000001001101111111000011000010001101110011101111010100110100110000111011101001111110011011111100110111000001101101110001001001000011110100110000111110111010000001100100100100111110110100001001011100110111000100011110100100100110010011110011011100011101111010010000110000011101100000111001011000110000010001101111011111011001100000010000101000000000000101110": TestData(n, 2) = "0" '
604.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
605.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000100000000000000000000000010000000000000001000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000": TestData(n, 2) = "0" '
606.     n = n + 1: TestData(n, 1) = "00000000010111101100110000001011000001001011001100000001001100001001000001001100010000111111000011100001000000001111010010000100001000000010001101001011101011011010000101010011110110110001100001000010000010100011000000110001000000011101110001000000000000110000100000101100000001011010000101000000100100011000111111110010110101010100011110100110110000010001101000000000101001000010100110000100010100111000010010100100001000110000000100010100010000000010000100011100010010110100010000010010001001000010": TestData(n, 2) = "0" '
607.     n = n + 1: TestData(n, 1) = "11111111011001010010001100000100110110101110100011010010111011110100101000100000000101100000000100110010111110111000110101101010111111011101101010011111100100110100010011011001100000001110111110000101000000001100110101011110011111101100001110011101111100111100011100010010110111100001010000010001101001001111000000000101001000100100000110011000101011100100000100111011010110100000010001011010101011010010100111011000100011001000001010001011101010000100001011001011100001001011101110100110110010111100": TestData(n, 2) = "1" '20
608.     n = n + 1: TestData(n, 1) = "00000000000000000000000000010000000000000000000000000000000100000000100000000000000000000011100000000000000000000000000001000000000000000000000000000011001000000000000100000000000000000000000000010010000000000000000000000000000000000000000000000000000000000000000000000000000010001000000000000000000000000000000000000010000000000000000000000010000000000000000000000000000000000000000000000001001000000000011100000000000000001000000000000000000100000000100010000110100000000000000000000000000000000000": TestData(n, 2) = "0" '
609.     n = n + 1: TestData(n, 1) = "01011000100010001000011010000010010010000100100101000100011001000010000010110110010110001100010001000010110110000011010100000100100010010011111101111100110010101100000001000000100111010000010000100000000111100110000101110001100100000001000001001100100100010000001001000110000000000100011100110110000101100011100010110100000011001001011000010001001000101010010010000001000000100101100101001110110010010000100010100010000000100111001100000000001000111111010100001000001010000010101010110101101000001100": TestData(n, 2) = "0" '
610.     n = n + 1: TestData(n, 1) = "00000101000010010110000110001101111110010001110010000010101001111111010000011011100000110000010101101110101111110101001100000100000000100110001000000000000001110011101011011110000001000110101001000000000000010100010010110110000010001100100010011001010011111011001110110000110100010010000010010110011000010110110010101000111000000100000001101100100110010100110111001110110101010001101100000000110010100010000001000101011100000000000111101110101011001011001100100000001101110000001001101010000000111011": TestData(n, 2) = "0" '
611.     n = n + 1: TestData(n, 1) = "10100010000111100111110001101101100001100111001010011110011001101110100111000111001010100111100010110010101010100100100000101010111100100000010111001000101110010010111000001100011011001011010100101101101110001001111100110000001011100000010110011010001000001101101111001000011101001000110010110111100011111011001100011110100110100111001110000101010001010001101001101001011001111010011001101010000001111010110011100001010100011100110100011011110011100101000001110010010111100111110011001110011111001010": TestData(n, 2) = "1" '
612.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
613.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000100000000000001100000000000000000000000000000000000000000010000000000000000000000000000000001000000000000000000000000000000000001000000000000100000000000000000000000000000000000000000000000001100000000000000000000000000000000000000000000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
614.     n = n + 1: TestData(n, 1) = "00100000011101101100000000000000000000001010001010001010010000000011101000010100001000000110000110100000000010001000111100100100001010110000011000001010110100110011000010001000110101001001100001011000001000000000000010110000100000110000001001000000100000110100100100100001010011000000010101010010100101000000001011100010000000001100000110100010100010000001110000000100000001110010100100001110000001100110000100001000001000000000010000001000001000000001001100000000010011110100000000001010100001111111": TestData(n, 2) = "0" '
615.     n = n + 1: TestData(n, 1) = "01010110100011101001111011101011111111101001100000010100001001111110010111100011101100011111110001101101111000110011010011010011110000101111110110010001000001010100100100110011010010010110101011100000111111111101111110110011111101010011110000111101000010010011010000011100001000011011000011001101100011011101000101010101111011000100001111010100111001011100011100011011011000000010011010010100110010011001111011010010110011111000101110010111111100100100111110111010101001101011010100000001011010010000": TestData(n, 2) = "1" '
616.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000100000001000000000000000000000000000000000000000001000000000000000000000000000000000000000010000000000000010010100000000000001000000000001000100000000000000000000001000000000000000000000000000000010000000010000000000000000000000001000000010000000000000000000000000000000000000000010000000110000000000000000000000001000000000010000100000000000000000100000001000000010000000000000000000000010000000000000000001000000000000000": TestData(n, 2) = "0" '
617.     n = n + 1: TestData(n, 1) = "00000001100010111010101010001001000011001100000000000000010011000111001101001010110010010010010100101010000001001000111000000010110000010001001110100000000101101001110100010100000101000100000101000000010000110000010011010000100101001111000000011110001000001101101100000001000101000000011001011001110111100010010001000011110011110010010001000001110100100010101001110000010100000010010100000000101001000100101000011000000001001010111010110100000011001100101010000000100100100111111001110101000100000001": TestData(n, 2) = "0" '30
618.     n = n + 1: TestData(n, 1) = "11010010010101000010000011010000101110111010011001101000101111011101001110000001011110100101101111000100000010110001010101000110100001100000111000111100011110110011101101101111101010100100011101000000010010101110000011011100010010101110101010000001110001001111110011011101000010110000101111000000101100011100101100001001100001111110000101110000010010000001001010000000011011000001000101000100000111101100110011000111010000001000010000000000100101010001100001011000001010001000111111110110101000011111": TestData(n, 2) = "0" '
619.     n = n + 1: TestData(n, 1) = "11011111000111100000010011111111101111001100100010111010010000011000110100111010011000111101000111010000110110101010011010101011100110011101000001011011111110011100110100001001010000001000010010100101111011000101001000000011110011110001100100100011011001010000101101111110101011011100000111000111000011110101111011101000101010000111011110000111111101011101110110001000011000111011011011111100110000001011011010110101101111011001011000111100101100111010011100110111101100110110100110000010011111110101": TestData(n, 2) = "0" '
620.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
621.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
622.     n = n + 1: TestData(n, 1) = "00100000000000000011000000000000000000000110000010011111100000000000000001000000001000000000000000010110000110000001100010000000000011110000000001100000000000110011000011000000010000001110000000011000001000010000110100000010000000111101000000000000000000100000000001100000100011000000000100000000000101000000000011010000001100010100000110110010100001010000110000001000000001100000110000001100000000011010000000000000101001100000000000000000100000011010100000000010010000100100010000000000000001111000": TestData(n, 2) = "0" '
623.     n = n + 1: TestData(n, 1) = "00010100011101010101100000101000001100111001101101000000011001111001100110110111010111111011110001100000000001100000011001111000111001000110011010001110100110011001110111100000101000110001100110100111000111001000001001110101101110000000110000000000011001010101000110011101011001100011001001011001101100011110000101101001100011001010011000001100110000101000001111110110000000001100001100010010101111100101001101010000000110011011111100011111010000000101000000100101100111010110001101111010101010000110": TestData(n, 2) = "1" '
624.     n = n + 1: TestData(n, 1) = "00000010000000000001100000000000000001000000000000000000000000000000000000000000000001001000000000000000000100000000000000000000010000000000000000100100000101000001000000100001100000000000000000000000000010110000000000000000100001000000000000001000000001100010000000010000010000000000000110000000001000000000001000010000000000010000000000000000000000000000000000000100001000000000000100001000000000000000000100000000000100000000000000000000000001001000000000000000000001000010000000000010000011000000": TestData(n, 2) = "0" '
625.     n = n + 1: TestData(n, 1) = "11010000111110000000000011000001011000010011010100100000000000110011011101010010100100000000000000010001101001000001001010011000100101101000111011000001000010010000010000010100001000100110100001100100001001001001100011110010011000110111000011000000011000000000100110001000101101100000001000000000000100000000000001001110001110100000010100001011101010110100001001001000000010010100001010100111011111000100001010000011010001000011001101110001101110000011010101101001010100110100010001011100110100110111": TestData(n, 2) = "1" '
626.     n = n + 1: TestData(n, 1) = "00000000110110001000000011001000100000001110011010100010101101111100101100101000001010000000101101010100101011010000010001001110001001100001110101011010111010000100001011001010010100011001011000010000100001000000000100001111001000101011111110100001110010011000100001101000101001101011110001011111000110111010010101000001001011101101110000001011110000011001100011111001010100010101110011000100110000101101010010110000000000010011001001101101000010000010001110000011111100111101100100110000001000110000": TestData(n, 2) = "0" '
627.     n = n + 1: TestData(n, 1) = "00101101111001100011001000011101001000000001100000101001000010110101000011001101110010110011000010101100111010101111100101100111000010110111010100000000001010000111111011001000111011100100011111101010010101011111111010010110010001101010100101010110111010111000101111001101001101101111010101010010110001000110110110101000010100001000010011101010011110001000001111001100110001011010100011101011100000100000111001000111001010101111010010010100110111001000100011010110100011111011101001101010111101101010": TestData(n, 2) = "0" '40
628.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "0" '
629.     n = n + 1: TestData(n, 1) = "10000000100000000000000001001001000000100011010001010100000100000000010101100110101000000000000100000101010000000101000000000101100000000000010000001000001011000110100110100010010100010111000100000100001010000000101010001000111001000000010000100100000000000000100000001001000000110001010001001010010000000010101001000111011000100100100000010010000100100000000000001000010010000110010110000110100000000000101001010100000110010001110000111000000110000000000000000000000100101100001010000100000101100010": TestData(n, 2) = "0" '
630.     n = n + 1: TestData(n, 1) = "00001101011011101101111110010000011011010000101110101011001001111000101010010001010111100001110011011010100011011010101010111010001010100110101100000110110100101001011001010000001010100000111010111011100100110111010101010100000010000010101110001011010011001111011110110000110010001010001000110100101111101100000110111000000000000010001111101001011011010111110110000100101000111000101001110001010011110100010100100011110000001100001011000100100000011110111111100011000011000011100101111010111010010101": TestData(n, 2) = "1" '
631.     n = n + 1: TestData(n, 1) = "01110011000100111110101110110110101110011100101000000011111010011111101010001000000000111110011010111010001110111000111111010010011101111101100111110001000000011000001000001101101001001000010001011000010001111100010001100111000100111111100011010001101101110110000001010110001111000100101110010001101101010001010110110000100111011001010100101101110000001111001111110111100101101001001001111001011111111011000010101001001001101010001111000011011001111111001011111101111001010010110000100001010000011000": TestData(n, 2) = "0" '
632.     '''
633.     'n = 0
634.     '''
635.     ' Test: r1's custom quiz 2
636.     n = n + 1: TestData(n, 1) = "10000001001000000000000011000000000011010100000100010100010111001001000011100000000000101000000000000000000100000011000011010001000000010000000001001000001000000000000100000100000101001000010000000000100011001101010000000010000100010000001001000000010000010000010000010001100000010010000000000110110110000100110010000000000100000001001111110010011001000011000001101010001111111010101000010111111110000000000101000000000010001010101011000001101001000010000000010110001001000010010100010101000000011101": TestData(n, 2) = "?"
637.     n = n + 1: TestData(n, 1) = "10001000000000000000000100101000000000001100000000010000100000000000000011100000000010000100000000000101000100000000000011000000000000110000000000000100100000000000000100000011000000000000000000000000000000001001100000000100100100000000000000000100010000000000000000000000000000000000000000000001001000000000000000111000000000000000000000000010001011010010000000000000000100010101001000001000010010000100000001000001000100010000000001000000110000000000000011000000000000000000000100000000000000001000": TestData(n, 2) = "?"
638.     n = n + 1: TestData(n, 1) = "00001000000000000100000000000000010001000000000000000000000001100011000000000010000000001000101000000101000000000100000110000000001000000000010100000000000000100001010100000000000000000000110000010010000100000101000000000100100000000100010000110000010101000000010000000001000000000100001000000111000100000000000000000100000001000001000000000000000000000000000000000000100010000100000000100000001000000100000000000000100000001010000000000000000101000000000010000100000001100000000000000001000000000001": TestData(n, 2) = "?"
639.     n = n + 1: TestData(n, 1) = "00001000000000000000000000000000100000000000010010000000000000000000100000001000000001000000000000000000000001100000001100011001010000000000000000000000000100000001000000001001100010000000100000000100000001000000001001000001010000000000000000001000000000011000000000000000001100000000000001000000111000000010000000000000000000000101000000010000000000100000000000001000110100000000001000101000010000000000000000000000000000000000000000101000000000101010000010010000001000001000000000000000000100010000": TestData(n, 2) = "?"
640.     n = n + 1: TestData(n, 1) = "00001001111110110001110000000100000110000100000001000000100000010000111000001000001101000001001000000000000000101000110000001011100000100000110000001000000000100001100000010010011100000011100001000110001001000011001011000100010110000110000100111110111011001100000000000000000010000000011100000010000000000000000000111001010001000100000000001010001010000000000000000010101000001000011110100010000100010000001100100001000100000000111000011000000000000000000000010101011010001111000101000000100100110000": TestData(n, 2) = "?"
641.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "?"
642.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "?"
643.     n = n + 1: TestData(n, 1) = "00000001111000110110101000011001001111110101101100011010111100111010100101001010001001100100000100001011000100000100000110000110110000000100101001110001101001110010001000100010110000000110010010101010001000000110100000001001011100001000000100001011111010011011000000000110111100100000010000100001110000010000000000110001111110001100010111000100100001000011000010101110000001000000001101101001111000000010011000000110001000011100111011011000100100000000110000010010110011010110000110011010000010010110": TestData(n, 2) = "?"
644.     n = n + 1: TestData(n, 1) = "10001110100010001000100001110001001101100010100100111001000000001001100000001000111000001000001100001110010000000001001111000011110101100111001001111011101010110100001001001100100100001101000111010001111110101010101101000101011011111001010110000001010000000000111100100111011001010110000010001110010000001000111110011101111100111000000001100101000000000101111111100011001100111100101011101010011110000010011110001011110011101100010101110000100000011001000011001001010101110110101100111000000010000100": TestData(n, 2) = "?"
645.     n = n + 1: TestData(n, 1) = "00111001100110011100000000000000001000100100010100100010001101000111011100100010001111100000000110000001000001111001000100000101010011101000001000110100011111110001000110001101110000000010101100000111000001100110011111110000000000000100100000000110101001010110000000011100000010110100110000000110000000001010000101000001000000100000100010000000000100000011000000000010010100010001101100110010101010000010111100000111111100000001001010001001001000000000111000010011010011000000001101000000000010000011": TestData(n, 2) = "?"
646.     n = n + 1: TestData(n, 1) = "10000101100000010101000111000110011000100100000101000011001110000010000100000111001001100000011100000101001000000000111100000100011000000010001100111000001001110100100000010000110011110011000000000010100100010111000000000000000010010000010001010010101100110010000000100101000001101001010010000000000010000001110010000011000000010010001010000010011000011111101100000010100000001110011110100000101001011111011001100110001000100000001110001000010000000001110001010010010011100000000100100100110011000010": TestData(n, 2) = "?"
647.     n = n + 1: TestData(n, 1) = "01011100011100011000100100011010011000010011000011101100110010000000011000001100111001010010001001001101010101100100100011111110110111111111001011111011011001110011011000010001100100101100000111101001000100111110010110110101001000011011110101010010010001111011101111111100110000111110011001001111110111010000010110001001000101001100001101010010000000000110011110100001100000010000011001110110110010011000100000000110001001000001100000011001001100100100100011010001111100011001111101100000111100000000": TestData(n, 2) = "?"
648.     n = n + 1: TestData(n, 1) = "00110000100010000000100000000101000100000000000000000010000000100000110000101000110000100010000000001000100100000101000010110101001101100010001000100100010000000000000000000000100100011001001010001010000010010000000100001001000010000001010110010000100011010000100011010110110100100100001000000010110100000001010010000001111110000000100100100000001101000110111100011101001110010010001010110000000011110001101000000001110000100010100000010001000010001000100000010000000000000000000010011001011000010100": TestData(n, 2) = "?"
649.     n = n + 1: TestData(n, 1) = "10110010010010010000110011100101010001001001100011000001000010011000101001100000110110000000100011111000011000000111111000001000011011010111000000010001000101001110010001101101011001010001000110000010000110010100010000011001010000100000101100011100000110001001100111100110000110100010100000011000111100111010010100011000000000011000010111100000100001010100011110100000000000101101110010000000100110100001110000001110001000100000000000010010001100000000111100000001000000000000000000000000001001000000": TestData(n, 2) = "?"
650.     n = n + 1: TestData(n, 1) = "11010000100101101011010111010110101110101000001101001011100000111001010001100000101100110000010111000100100101110100001101111001011011001100110101111100010010111100010010111111010001111110010011110000110011110011010011010101100001101010011110101001110001100011001110111110011111111101100001100000011000000101101100111100011010001011010101001010000101010011000010011011010110110111011110000001110010100010000000101111101011101111000101010001011111100100101000011001011001101111101100010111010100111001": TestData(n, 2) = "?"
651.     n = n + 1: TestData(n, 1) = "00000000001110011101011110000001110100101110110111000101111000011010101110010001100110001000111101100010101110100010010110101110110110110001001001010010000011101111010010110010000110001000100001111110100001100000101011011000001100001011110001110100111010101110001011110000001111110101010101100101000001101010101001010010100001001000101000011000111101100111101001001010110010000100111010011010111010000100001011010101111111100100111101011001100111110010011110011100011110001110001001011000011010001101": TestData(n, 2) = "?"
652.     n = n + 1: TestData(n, 1) = "10001001110000001000010001011011000100011010010101101011010100011001000011010101101100011011000111010111100010110011001001101011100111101101001000100100101111011100001100100100010000001100000010000010011101001010001011100011100001001000010000100010001001111000000010001101000001001110000110011110011100011011001110101000101001111111001010111000111011100110110011111011010111000011100001111110110101010111010110100000110110010110010100011000111110111101110011001111111000011111111001111001001101011111": TestData(n, 2) = "?"
653.     n = n + 1: TestData(n, 1) = "10010011010111111001010001110000011011100100100110011110011111010011011111111101111001100001100110100100100110011111111100011011100010011011110010010100010100000000010010001111001001110010111100001001010111110010110111111100110001010011010100001111101011100110010111110111110000111100110101001010111001101011001001000101100001000110111100010111001001001001101011000110001011100011100010110000111101111101100100100011101100011011110011110000111100001100001100100011000111110000100000110101100011001011": TestData(n, 2) = "?"
654.     n = n + 1: TestData(n, 1) = "01111000000111010111111100110100011010111011110101000111000101111000111111100011010010001111001010111100111101101010000101110101000010101100001111010101011110011001011011100001110101101011111001010111001101110001110011111111100011000110100011111101000010100101010001001100101000100001000100000010101100011111001110101101111001111001110100011001101011001100111001100000010111000111000011001000011001000010011101011101110101010010110010111110111111010101100001111110011110011000010011000010010000110000": TestData(n, 2) = "?"
655.     n = n + 1: TestData(n, 1) = "11100101001100110010000000001111111011001011100100111101110111101000111000110110001100101000101110100101001000011011000111010110011101100010000100111010111010011010010010101110111011110010110110011001110101100111100010100010101000100001000100001000100101010101001111010111110101100101100111010110100100111000010101001101011100010110000000100110111100101111100001010011001100000100010101111111110110010111011011011001010111011100001001110010100100110110110101001101000001011001110111010110100000111010": TestData(n, 2) = "?"
656.     n = n + 1: TestData(n, 1) = "00101011100010110100010101100110110111001111000100100110011111000001101011100001110110100001110011111101001000100100010111000111110110001101101000101100011111101001010010001000111111110111011001100011011011010110000101101100100100011011101001011010101001100011111101110101111111010001010001001100110100100000011100111101110010011000011001001000001110001001010010101010000110101001011010100100111011010011011110101110110100010001000100100011000011110111111011000011101101100111101111100011000011010111": TestData(n, 2) = "?"
657.     n = n + 1: TestData(n, 1) = "00000100100101110000110100100011111110100110000101010001100010000000111111000111010011111111111110011000010011010111011010101101011011011010011000100100101100010110111011000111001110011110001111100000101101100001100011111010010100110100111010100101011100100001100111111010001100000001100010001000111110101000010000100100110010101111110011111111001111111101001000111100100100111100001111101000111110011111001111111001110100101001000011100010001010100110101011011001000001111010101100100110001011110111": TestData(n, 2) = "?"
658.     n = n + 1: TestData(n, 1) = "00000111111000010000101100011100110000100010111111110111011110010011000011110000001110000110001101101011010111010001100011000101100011111100010000010101010111111111010100000110111010001001100110111100011111000100101111111100010100110110100000101110010101000000000010000111111101011111111101110110111110111111111001101110100100110111101110111001100000100011011111010000101110011010111100000110100010110010001101001010100010000000101111110000111000001000010001000100010110011011111011101110100001101010": TestData(n, 2) = "?"
659.     n = n + 1: TestData(n, 1) = "10101101001001011100001000001110010001110011001011000111110010110110100011111111111001010000101010011110011110110010010001011010011111101000011001111100000011001011011001001110110000101001011000100111100011000111110011100000010011000000101001010011000111100000111000101110110111100001110000101011010001101010101101101110011011111100111001010100011000111011101111011111011101010000100100000100110101111100000101000000001001001110000111100100111011011100101101010110100101110101010111001010110010100011": TestData(n, 2) = "?"
660.     n = n + 1: TestData(n, 1) = "00111100000001100110111100111110110100001000001111100110011111100111110001100001100100110110000000011111110010111000111000101000000010000101011001010000011010110001111000010010010010000111010100110011000001000011110110110010010010011111111111111001100100010111101010000001100110010000110011000101000100001000001111010010101100001000101010101101001100000000001001101001011110001100100000000001110011111000100110101010000001111111111010001001011000100010000000100001000100011000100000110100101011000010": TestData(n, 2) = "?"
661.     n = n + 1: TestData(n, 1) = "00001100001100010100000100001111110011001111010000111001001111100010101101011000101100010010101010000011010111100100101100001110011001100000001011000111010000111000001100010000000100100111000100100000010101110100010000101010101110111011101001111000010110111110010000110110001010001111100101100011101010011010100110000101010110010100111101100100011000001011111110111001001101100000000001010011000010100000011001001011110000000000010100000000000100111110001000100101000100000000001000001001110000000000": TestData(n, 2) = "?"
662.     n = n + 1: TestData(n, 1) = "00010011100000101100010001010000111100001100101110110011000111111001111001111000010001011110111010100110101111100100111110000000001111010001100011100001101110100011010000010001111111000001111111010111001111001111111001000010000101101101000100100000011111011000011100100011001100110010000001000111111110100011111010101011000101111110000011001010101100100001001111001001000011111111010011110000110010100101111100110100111111011000110010010111000000010010001010010000110101100111110100100010011100110010": TestData(n, 2) = "?"
663.     n = n + 1: TestData(n, 1) = "10011100100001100111000000111010000100000000010000011011000010100001110000110000110100001000001000011001011110010000001001000111000100100001000000111001100000100011000000000000000011000000101011010100101000000010010100010000011000011100000111000010100110101010010111010000010000110000010000000110010001000001100100000001001000110100011010101001000010100100000001001000100010100010111010010100010111100011000001101100000011001110100010010001001100110001000010001010001000010111000010010000111001011000": TestData(n, 2) = "?"
664.     n = n + 1: TestData(n, 1) = "01001001001000000100101111110000000010011000000110011101110111111001100011100001000000101000000000000110001111001011010010110011101110010000001001001000000000000000000101000000010001111000011000010000000011001100110000000011100100100011001111000100100010011100010010010111110100010010000111001110011110010000110010100000000001001011001111110010001001011110000000011011001111111100100000110111111110000000111001000000000010111010101011000011111001110010000010011010001001110001011100010110000001111101": TestData(n, 2) = "?"
665.     n = n + 1: TestData(n, 1) = "10011000000000000100000010101001000000001100100000011001100011010001000011101000110010000100001000000000100100000000000011000000000000110000010100010100000000100000010110000011010000000000110000000000000000001001100000000100010000100000000100000100010000000000100010011110100100000000000000000001001001000100000000001000000000000000000000000000001011010010000000011000101000010101001000101000010110000100100101000001100000000000001011000000000010000000000011000111000000000010100100000100000001001000": TestData(n, 2) = "?"
666.     n = n + 1: TestData(n, 1) = "00001000100000100000000000001100000001000011100111101000000001100011111000001010110000000100101000000000100001000100101110000000001000110000010100001000100000100001110100000000000100000000000001010010011101010101001000000100100000110000110000110000010001000000010000000001000000000100000010001111000111000000000000100100001001000101100000000010000001000000000001000000100010000100000000100000001100000111000000010001110010011010000000000000001101000010000010000100000011110000100000000001000000000001": TestData(n, 2) = "?"
667.     n = n + 1: TestData(n, 1) = "00001000001011110101000000001000101000100000010110110000000001100000111000001000101001000000000000001100100001100000101100011001000001110000010001001000100100000011110011001000000100000000010001000110000001000101001001001001010000110100000100101110010000011000000000010000001100100000010000000000111000001010000000000100001000000110000100010100001001100000000000001000000100000000001000101000010000000100000001110010000100000000000000011000000001101010000010000000001010001000010010000000100100010000": TestData(n, 2) = "?"
668.     n = n + 1: TestData(n, 1) = "00001010101000010001100100000100000110111110000001111100000001110000001000000010111101010011000000000010100001110000110010011111100000000000111000011100100000100001100001000010011000000111100001010010011001010011001110001000010000000111010100011001111111111100010000100010000100000000111001000011000000100110000000111000111110000100001000100110100010001001100100001000111000001000011110000111100100011100001000000001000100000110011000011000000001000010000000110011111010111110000101010001110100110000": TestData(n, 2) = "?"
669.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "?"
670.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "?"
671.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000100100000000010100000000001000000000000010001010000100000000000100000010000000000100000000001101000001010000100000000000010000000000000000000000000000000000000011000000000000100000000000000000000000000000001000000000000000010000100000000000000000000000010000001000000100000000000000000000001000000000001000000000000000000000000100000000000000000000001010000000000000000100010001001000000100100000001100000000000000000000000001000000100000000000000000000100": TestData(n, 2) = "?"
672.     n = n + 1: TestData(n, 1) = "10000101000000000001000000000010000000001000000000000110100000000010000111100000000000000000000000000000000100000000000000001000110100100000001000001000000000001000001000000000000000000110000010000000000000000000000000100000000000000011000000000000001000000000000000000000000001000000000011000000000100001000000000000000000001000000010000000000001001010000000000000000000000000100100000000000000000000100000000100010001000000000010001000001000000000000100000000000011110011000000000000000100000001000": TestData(n, 2) = "?"
673.     n = n + 1: TestData(n, 1) = "00000000000000001000000100000000100000000000000000000000000000000000000000110001000110000000101000001000000010010000000000010000000010000000000000000000000000000001000010000000100000100000000000000000000100100000100001000000100000000010000000000000000001000100010010000010000100000000000000000010000000010000000001000000100001000000000000000000000000000000000100100000100010010000000100000000100000000100000000100000000000000100000000010000100001000000000100000000000000000000000000000110000000000000": TestData(n, 2) = "?"
674.     n = n + 1: TestData(n, 1) = "00000000000000000000000000100000000000000000000000000000110000001000000001000000000000000000000010000000010000000001001000000001100000000000000000000000000100000001000000001000001000000000000000000000000001000000100000000000000000000000000001011000000000000010000000000100000000001001000000001000010110000000100000000000000000000000000000000000000000000000010000000100000010000000001000000100100000000000000000000000000000000000000001000000101000001000100000000010000000001000101000000100000001001000": TestData(n, 2) = "?"
675.     n = n + 1: TestData(n, 1) = "00000000100000010000000000000000000000000000001011000000010000000001000000000001000100000000010010000000000010000000000001000000010000000010010000100000001010000100010000000001000000000000100000000000000001000000000010010000010000000010101000001000000000000000000000011000000000000000000000000000100000000000000000000000000000001000000101000000000000000000000000000000000000000000000000000000010000000010001000000000000000000000000000000010001010100000000001011000010001001010001010000000000000000000": TestData(n, 2) = "?"
676.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "?"
677.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "?"
678.     n = n + 1: TestData(n, 1) = "11110101001000011101011111110011000011111100111111111110011111111111101011101000001110011111001111000011000100000111111111110011110010000001101011111010111001000000010111001111110101111000111001010000110011001111110000100111100100110011111111110011011010011100100111111111110100011110000111001111111111110110110010010000111101011111111111110010011111111111000101111110101111111111111000110111111110000111111111101011000101111001101011000011111111110010000011110110001101110010011100010111100110001101": TestData(n, 2) = "?"
679.     n = n + 1: TestData(n, 1) = "01000110000100000101000001010000011010010000000000011000010110000001001010010110000000001000010000011010000100000011010010001001000010000010011001001110000000001010010001010000010110001011111111000100000010000000011000010000100100000100000000001000010001000010001010010000100100100001000000000000010100110101001000000111000001001000001000011001001001000010011000000010110110010000100001010110111011000000100000000000100100001100011000000101101001000010110100010010001101010000010011110000000000001100": TestData(n, 2) = "?"
680.     n = n + 1: TestData(n, 1) = "00101001011000000000110000110100010000100000000011000110110000100000100000100011000101000100001000011000001110000101000100011010110000001110010100000110000011000000000010010011000000000000010000010110000010001000100110110101000000000000000010000000100000100001001001010000010100111000110100000001010000000000011101010001010000000001110000000000001010001001011100000001000100000100100001010001000010111100000000000101100001001000000100000000000000100000000000111000001000001000000001100000110100001001": TestData(n, 2) = "?"
681.     n = n + 1: TestData(n, 1) = "00101101000010000110000001100000110000000100000000010010000000000100100001001001000000000000000001001000000100000010011000000000000000000001000101100000101100001010001100001000001000110100101001110001011000000000000000101000100111100100000000010001001110001001010010000000000000100011010000011100000001000000001010110100000101000000001000000000011000010011011100000010100100100000000000000000001001001110000001010000100000010000000000000100100110011100100010100010000110001001000101100001001010100010": TestData(n, 2) = "?"
682.     n = n + 1: TestData(n, 1) = "00000100010110011000000000100100010000000100000001010000111000010100000010001100000010100000110100100100010000011001001001000000001101000000001010101001100001000100010100101001000001001000010000000000100000100100000001010000010101010000000110000101000000000010000001011100000111000100010100000110000011010000100000000001010010100100000010100000011000000010100100011000100000000000000000001000000000001110101101010010000000011000100000000101000010110110110000010001100010000001001100000010011000001000": TestData(n, 2) = "?"
683.     n = n + 1: TestData(n, 1) = "01000000000000000100001001010000011110101010100001001000000000000100010100000010000100000100000011001000000001101010100001011100000100011100011000000110000100000010010000001000100100000001101001011010000000101000010000000000011010000001101000000010001000000000010110001100000010110001011000000001010100010000000010010100100100100010010000010011000001000000110000101100110010110000000011000000101010000000000011001010000001010110010001000000111010100110000010001001000100100000000001110001100000000000": TestData(n, 2) = "?"
684.     n = n + 1: TestData(n, 1) = "10000000000100001110001001011001100101100000000100000010000011010001000110010010101011000001000000101001000100000000000000110000000000100000000001001010001010100001000001000100100110100011010000001001000010000000010000000000110101000000000010000000100000000100000100000000010100000000000000000000100011000110111000100000110000001010000100000100010001101101111010000001100000000000000000010001001101000101100000000010100000001001000000000000000000001001000110000000010001000000000111001000001001000100": TestData(n, 2) = "?"
685.     n = n + 1: TestData(n, 1) = "00010001111000000010010000000001000000101000000100011000010001011001100010110011100000000011001000000100000010010100000001000110010010000000010010011101001001101000000010000001000010011001100101000001000110001010000010010010010100101001010000001000001101000101101100000100100010101010000001000000000000010001000000000000100010010100000000100100001001000001100000011111011100100001000000100000000010000000001001000010001000000010000010101010011110000000000001000001000011000000001000000000000001000001": TestData(n, 2) = "?"
686.     n = n + 1: TestData(n, 1) = "00000111001100000000100100010000000100000111100100010000100001010110000000000000000000000000000110000100110100010010001000001000000010000001010001101110110100000001000001000001100100101010000001100001110000000000101100000000000000010000001000000000111000000010000010101010001000110000000000000010100110000000000000010010000101010000000000000010010000010101110000100100000000100010100000001101000001010010000000000000001001000101010001100001000001010000000001001000000010110010000010000000010100100010": TestData(n, 2) = "?"
687.     n = n + 1: TestData(n, 1) = "00000000001100001001010000001000000101011100100101001011110010001001000001011010000010000000100100001010010001111001000100000000000010000000010000000010000000000001010000100000010010100100000001000101010100100000110011100000000010010010001100000000101010100000100000001001110000000100010000100101010101100100011000100100001001000000101110010000010000000000001000000000101010001001010011100000000100010000000000100000101000000100000000011001000100001000000000010000001110001000000000100010011010010110": TestData(n, 2) = "?"
688.     n = n + 1: TestData(n, 1) = "00010001000000000101011010001010000001000001010100000000001011000010000000000000000001010000100001000101010101100100010011100100100000000000100000001000000000000100010100000000000110000010010000000110000100001100110101110000110001000100110000010000010000011000000010100000100001010100010110001000100000000001000000000000001000110000001001000111010000010100011000000010010000000101000000000011001001101100001000000010000000000000000000000011101000000110000000110010010000110000001000000000100010000001": TestData(n, 2) = "?"
689.     n = n + 1: TestData(n, 1) = "00000000000110100000100011000000100000100100000000000000011011100000010101100001101010110000000000000000000000111101001001100110001000110001001101000101010000110010010001000000010001000000001000011000000000000000000010000000000001000100000001010010000001000001000101111110000100010010000010011010000000000000100100001001010100001000010100001001000100101000001000000001000000010101000100000010000001110000000000000000001011000011001000010000001110001001000101011110011010000101000000000000000110000000": TestData(n, 2) = "?"
690.     n = n + 1: TestData(n, 1) = "00010000100010110000000010111001000111010001000000001000100010000100001010010000000001101010000010000001000000000011000010000000010100100100010000110100000100001001100011010010000000011110100010111010110001110000100000100100000100000000010000000000000000110001001010000000000000100100010001110001110000010101010000001010000011101101011010000000001000110000000110110001001100101010000100000001010110001011001100010010000010100011100100001001100000011110000000110001110001100100000100101000101000010000": TestData(n, 2) = "?"
691.     n = n + 1: TestData(n, 1) = "00110000000000000000000000000010100000000001000000000000000001000000001000111000000100000000100000010001000000000010000010011110010100011110000010000000000000000000000000010010010000000001000000000000000000000000000000010011010000000000110000000001010001010110000000100000000000010010000000000111100000000000010000000000100000001010000000000001000010001110001001010100000000000000000100000000000000001000000010011000000000000000001000011010000000011100000001100000000100110000000100100101011100100100": TestData(n, 2) = "?"
692.     n = n + 1: TestData(n, 1) = "01000000000000000100000101010000000010010000000110011000010100000001000010001000000000101000000000000010000100000011000010000000000010000000000001001010000000000000000000000000000000001000010000000000000011000000010000000000000100010000000000000000010000000000010010010100100100000000000000000000010100010100000000000000000000001100001000000000001001000010000000000010000110010000000000010000111010000000100000010000000110000010001000000000101000000010000000010010001101010000010000000001000000001100": TestData(n, 2) = "?"
693.     n = n + 1: TestData(n, 1) = "00000001000000000000000000000010000000000000100000000100000000000010000000000100000100000001000000100000001110000000000000000010000000000000000100000100000000010000000010000101000000000010010000000000000000000000101000000000000000001000000010000000000000000000000000000000000000000001000000000000010000000000000000010001000000000010100000010000001010000000000000100000000100000000000101000000000000000100000000000000000000000000000000000000000000000000000000010000001000000000000000000000000000000101": TestData(n, 2) = "?"
694.     n = n + 1: TestData(n, 1) = "11100110000000000000100000010010000010000000000000100100000010010000000000000000000000000000000110000000001011000000000000000001000000100000001100000000000000001001000000000100000000000000000000111000000000001000000000000000000000100100010000000000000000000000100100000110000000000000000000000000000000000000000111000001001000000000000000010000001000010000100000000000000000000000000000000000010000101010001000010100000000000000000000000001100100000000000000000000010000000100000100000000000000000000": TestData(n, 2) = "?"
695.     n = n + 1: TestData(n, 1) = "00000000000000000000011000000000001000000000000000000000011100000100110000000000000000100000000000001000010000000000100000000000000000010000000000100000000000001000000000000001001100000100000010100000010001000000001001000000000000000010000000000000000000000001000000000000011000000010000000000001000000000000000000000000000000000000000000111000000100000001100011000000000000001000000000010000101000000000000101000000000100000100000000001000000000010000010000100000000000000100000000000000000000000010": TestData(n, 2) = "?"
696.     n = n + 1: TestData(n, 1) = "00000000000010000000000000100000000000000000000000100000000011000000000000000010000000000000000000000001000000010000000000000000001000000000000001100000000000000000010000001001000000000000100000100000000110000000000000010000000000000001000010000000001100000010000000100000000000000010100100000001000000000010001000000010000000000000001000000000000000000000000000000000100000010000000000000000001000100000000000000000001000001000000001000000000000100001000100000000000000000000100000000000000000010000": TestData(n, 2) = "?"
697.     n = n + 1: TestData(n, 1) = "00010000000000000000000000000000000100000000001000000000000000000000000000010000000000000000000010010000000100001001010010001001000000000000000010000001000000000000000100000000001000000001000000001000000000000000000000010000011010000000000000110001000000001000000000001000000000000100010000000010000000000100000000000100000100000010000100000000000000000000000000000000000100000000000000000000100110000010001010000111000000000000000000000000001000000010001000000000001001000000000000000000000010001000": TestData(n, 2) = "?"
698.     n = n + 1: TestData(n, 1) = "00000000000100000000000000000000010000100001000001000000000001010000000001000000000000100000000000000000000000000000000000000110000000100000010000000001000000000100000000000000000000000100000001001000000000000000100000000000000000010000000000000000111000000000010000010000001000000000000000001010000000000000000000101001100000000000000100001000000000000000000000000000000000000101010001000100000000000000000100000000010000000000000010000000000000000000000000000100000000000000000000000100000100000000": TestData(n, 2) = "?"
699.     n = n + 1: TestData(n, 1) = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": TestData(n, 2) = "?"
700.     n = n + 1: TestData(n, 1) = "00000000001000000000000000000010010101001001000000100000000011110001000011001100000100010001000000111001010000010100001001100000000100001000001100000010110000000100100011000000000000000010000101101000100000011000101001110000001000111000100011100010001000001010000000000010000001100000000000011000000000010111000000000100001000000000000000000001000001000001000100010000011100001000001100000001000110101000001010000000000000000000000011000000000000001000000011001000001010000001010101100010010000000100": TestData(n, 2) = "?"
701.     n = n + 1: TestData(n, 1) = "10000001100110110010010000000000001000000000100011100010000010100101010001100000100010001001001111110010000010000101001100000110000100100000111100000111100101010000101000010000000010000111010000000011000000101100001010000100100000001010101001100001010110001000010100001100100000000110100101000110000101101110010101000011010010100110010000100010110111000010011000000000100111000010110110011110000010010001010011101101101110010011000011110010010011000001100000100000100000000010011011000110010000000000": TestData(n, 2) = "?"
702.     n = n + 1: TestData(n, 1) = "01001100101100110101101011000000100000111001001011100101010010101101000111100010010110100100001100011111111100111111100001010100100000111110000001000101010110000110010000010100100110010001000001110110010111100101001011111011011000000100000000110001110000010010001010011000010001110001001010111111001100101011010101111100110010001001010100011001000000010010000111100011100100111001100000000000100001111111100000000111111000100010001101101100011100011110011010111101001010010100001011000010100100100011": TestData(n, 2) = "?"
703.     n = n + 1: TestData(n, 1) = "00100100110010011100000010000100010011110000101011111000110110100000110111000100000100000011110100000011001000010010011110010000110011111010111001101111001001000011000011000000101101000011100000010101001011100000110010010010011000011100000010001000110011000011001111101100011101011010100001101100110000100001010110000001011111011100110000010100000001000010000000000010010000000000011000101011001001101000000010000000100000010001000001100110000101001111000000000011000000100100010010001111100010000100": TestData(n, 2) = "?"
704.     n = n + 1: TestData(n, 1) = "00000100010010000111111000011000001000001000000010000110111000100100001000000000101010100010101001111011111100010001000000110000000011001100100001000000001000000000000000100000011010100101111000011001001011100011010110010000000000011111101000100000110101011011001100110111101000011010000100001010000000101110110110010100100111100100000000000100010001001000011000000000000010000000100000000000110000001000100000000011000110010000000001100010010000000001000101001111000011010111001001000100000110110110": TestData(n, 2) = "?"
705.     n = n + 1: TestData(n, 1) = "00010011011010111001011100100100101100010110100111001001100011000011110101001110111001000010011000011001000000001000010100110101010000000111101000100110011111100000000010110000010001110001100101000011100001010011000010000111101110000111000100010110101001110001100010000000010001111000110001110001000001100000110111111110000101110100000101000011110011000101001101101100001000100100000000000001000000000100000101000001001000110110110001010010000001010100001101000010100000000001010001111000011010100101": TestData(n, 2) = "?"
706.     n = n + 1: TestData(n, 1) = "00000000000000001001100001001000010101000000010001000000000001010000000000001000000000000000000010100001100000100010010000100000000011000001001111000000000101011100000101110001100000001100000100000100000101001000100010000100101110000000010000101101110101000111000010110011000000111010000110100101110001000000001001101000010000010001000010010000100110000011010000100001001000100011000010000000000000100000010000101100100000010000001100000100000000000000000000001000000110100010100110000010001000010000": TestData(n, 2) = "?"
707.     n = n + 1: TestData(n, 1) = "00100000010001011000001000001010000100100001100111000000010001010001000001001011001011101000001010000001001010001010011100100001011000010100010011010100000000001000010011100000000100000100000110000101011001011100010111000000100011001010011100110111011010100100000000100000000000000001000100010000011001000000001001101000000110001000010011111000101000000000000010000100000000100000000000000000000000001100010000001111100110000101001000110000010000000101000001001000110000001000001100011000010011000000": TestData(n, 2) = "?"
708.     n = n + 1: TestData(n, 1) = "00100000000000001000111000000010010001100011000011000100111000001100000111000100010000000001010011001000001000000011111000011100100000000000000100001100010010010100000010000011111101010010100101100000001110010010000100000000000001010000000000000001010010010001000000100000011111000011010001001100000000100011101000000001001010000000001101111101011000100000110011000000001001000000010000000000011010000001001001000100000000110110010000110011000000000010010110100000100001001010100000000001000100001000": TestData(n, 2) = "?"
709.     n = n + 1: TestData(n, 1) = "00001100001100010100000100001111110011001111010000111001001111100010101101011000101100010010101010000011010111100100101100001110011001100000001011000111010000111000001100010000000100100111000100100000010101110100010000101010101110111011101001111000010110111110010000110110001010001111100101100011101010011010100110000101010110010100111101100100011000001011111110111001001101100000000001010011000010100000011001001011110000000000010100000000000100111110001000100101000100000000001000001001110000000000": TestData(n, 2) = "?"
710.     n = n + 1: TestData(n, 1) = "00001010001000010000010100010010000011000010000110000010101110101011000011000000100101100000010000001100101010000100010000001101001000010001100110000110010000000000101000000000000001101000100000110110000010100110000111100110000000100000000010110000100000011000010000010001000100010001000001100001101000010010001000000110000010100000000010010110100010010011000100100110000111110001000010111000010101100010000001000010010001001001010000010000000010110110011000101001011000011011000100011100100000010010": TestData(n, 2) = "?"
711.     n = n + 1: TestData(n, 1) = "00100000001000011000000000100010000000001010010000000100000100001000010100001100001000110000100010011101001000010000010000000100001010100100001000000100110000100111010000110000110010000010010000101001011101100010000100000100000000000100000000001011000000000000001100000100000000001010000011000100000110011000010001100000000000001000001000011000001000110011000000000100001010000000011010100000010001000100000100000010100000110100000011001010110000000000000011000000000000000000010100011010001100001101": TestData(n, 2) = "?"
712.     n = n + 1: TestData(n, 1) = "00110011100000011100111100110011001100001100110110110011010111111001111100110000001001010100001001010111110101100100111110000111111111100111101011100011001111010100100000010001111111001101111111100111001111001111111001110010000101101111001100111000011110011001111100100111010100110010110111010111111110001111111100101011000101111110011011011111001110000001001111001111000011111000001011110000111110011111111101110100111111011001011111110010000010010010000010010000110011110101110101000011111100111110": TestData(n, 2) = "?"
713.     n = n + 1: TestData(n, 1) = "00100101100100010000001001001010000001110100000101000000001011001000110101000111000110111001000000100001000100100110000000010001001010000010001000000000001000010001000100010100110110110000010100001010010100010100011100000010101110000101000101000000011000110101011100001000000000100011100111010010010000100111000010010000010000101010000001000000100000010000001010100000001000000000001010000000010001010000001101001111001110110010000001000000110100000010001000000000000010001000100100001110000100110010": TestData(n, 2) = "?"
714.     n = n + 1: TestData(n, 1) = "01100010000100001101011110010000001010011110010010000110000100000001001011000011110000110001111000000000110100000001100000010100001000000001000001010010000000001000011100001010011010010011010001000000110011011001000001000011100001100000000100001110000011111110101000110100001000101000000111000100110110100000010000000011100000110100100010000000101001001100000000001010001010000001100100110000000100000111000001100010000000000000110010001000011001000101000000000000000000000000100000000001100000101000": TestData(n, 2) = "?"
715.     n = n + 1: TestData(n, 1) = "00100000100001101010000001000100010000001011111101011101011111100010100000000000000010110100100001000000000000001010001000000100111001011010000000101000001001000000110011000101010010001110010000000000010001000100001010100000010010011011001000111010100000000000011000000101010010001100100011111110000110000000011100001100010101000001010101000010001010000000000000100000001011111110000000100000100000010100001010010011010111000011000010101101010010111000000000000001000001001011001010000100000010001010": TestData(n, 2) = "?"
716.     n = n + 1: TestData(n, 1) = "11100000010000010110100000000110001000000001100000111000010000101001011110000100010000110100000101000011110000000000100100101010111011010000001110000010000110000001100010010000111010001100010001001000010110001000000110111001010001111110000010000100100100000000101110010000001100010110010011101001001001000000100000000000100010001001100110100011000001011100000100000010101000010001001010011000010011100010010100000010000001111000001001110000110011010001100000110001011000000000000101001011000101000000": TestData(n, 2) = "?"
717.     n = n + 1: TestData(n, 1) = "00110000001110000010001000000100100000010101100000011000110000100100000001110011000001110101000001000000000110000000000001010000111001010000010000000000000000100110100110100000010011011100111000110000011000110000100010100010110000011010010100000000100000110100001000000000000001100100000111101000010000100000000001000000000000100001001100010010110000000011100000010000011100010000000000000101000000001000000001000010000001000000000000100000010010010000000001000011000000010100100000000000010000100000": TestData(n, 2) = "?"
718.     n = n + 1: TestData(n, 1) = "10011001110100010000011010000011000010011011011001010111100001100010110101001010000001100011000000110000000000000000101101000011101110110000111111111110010000110100001110011001011000110101001100000010111110001010001000011011011001010000000100000110001010010000011110100010100011000101110110100100110000011000100001010100110011001110010000001001110010001100000010100110101111010110000101000111111010000100111000001110000000000000000000110001101000000011110001011110000100000000000100110010000100111000": TestData(n, 2) = "?"
719.     n = n + 1: TestData(n, 1) = "01111000100000000100000001000001101000000000000101000000001011010001101010111000010011110010000000000000111011000010110011000000001000100110010000000110111000000000000000000100011010000000011001010100010010001100001000000001000011100001000000000100000000000000111000010000001001000000101011010010000000011000000000000000111000000000100011001100010001001100000000100111001000000001000001010001000000011010001000000011100110000110000100000010010001000001000000000010000000111100010000010101011000000111": TestData(n, 2) = "?"
720.     n = n + 1: TestData(n, 1) = "11010000010110110011000011100001011111011000011110011101100000110000100000010000010001010000111110010110101001000000101110000110001000010001110100000010000001000011101101010000110010001100000100000011101100100001000000001100111001010100000100110001011100010000010111001110000100010010000010001111100000100100100001000110110001100110001101111011000001011001000000011100100101010011001100101011010001100010011010001001000001101101111011011111000011110010011000000000010010110010000000110001000100110111": TestData(n, 2) = "?"
721.     n = n + 1: TestData(n, 1) = "00000100000010111110001000101100000010001010000000101101111001011001001011100000010101110001111001010110010000111100000010000111100100111101001000001110000110110001000000100011001101000011111101100101100011000100010101001000111111000011100000101010011000100011010000000000001100000001100111000000010111000000000100101000000110001000110000000000001000100001111000000010011001111000000010100000000001010110001101001000101000001100000100000010000011110010110111000011101011111100000110100011001100010000": TestData(n, 2) = "?"
722.     n = n + 1: TestData(n, 1) = "10101110010100010000010000010000011111110110000001100001001110100001000011000000100100100000011001101101011010010100101000010000100111001010010001001100011000100010110010001111000000101000100001111011000001100000111111100110010011000000100011011000000110000000011100010011000100111111100001000001010001111100000100100100001101100100100000010010100111100101001000110011010111110010000111101000101001010001000101000010011001000111101011100010001000110010010111000011000010010100000000000010001000110010": TestData(n, 2) = "?"
723.     n = n + 1: TestData(n, 1) = "00000111101011000100000110000011010111110011111001001111011000010000010010010101000001000001100100100000000010000000111110010110001100110000110011000110010001000100110011111000000001111100111111001000001001001110011010010000011001100001010000000011111111110100011111100100001011111111010000001100010100011010100000110010011100111010000011001110000000001101001010000001110011000010011100001000110010100011111100100001111110011100011111100100000110100100100001001001101100000000000110011000001000000010": TestData(n, 2) = "?"
724.     n = n + 1: TestData(n, 1) = "11111110010011111111100001100100100001111111110110101011110000111101011111111111110011100111111001100111111111111111110010101010111111110011111111110011110010000001111111100111111110111000111111100001100010011001111111111011100010101101000100111111111010110011110011110011100111100001000101111100111001010111001010111111100001111011000100000111111001000111100100111111111000000001000000110110111001111000001010011001111111011011111000000100111110101100000011111111001111100001101100011010001111111100": TestData(n, 2) = "?"
725.     n = n + 1: TestData(n, 1) = "00111010110000001111101100000000010100000110001000000001010110100100011011110111100001001110000000000000000100001000010101011010001011101000111011010010000000000001101101101001101001100001110000100100100111000110000101101010100000010010001000001100110000001011010000000000100000011010101100001001001101100100010010100001100001001100101000000000000000110010101010000000111001010111100100110001000011001100111111011001101110000010000111101000001100000000000000100010111110100010101000001011100001111001": TestData(n, 2) = "?"
726.     n = n + 1: TestData(n, 1) = "00000001000011100110011001101000000000001110000001011000100011000001000101111001101110011101101111101110111100100010010110110011001000100000100000000101110010000010100111011110000111101001011001111100000110000110011001010001000000011100001111111101111100101101111011000000000100000000001111011000000001001011100100010001000001001100010000010011001110011000110011101001010110100110001110010000101111111011101101101100000010000100001100001100100011101011110110000110000010100110100010000110100110100100": TestData(n, 2) = "?"
727.     n = n + 1: TestData(n, 1) = "10111000101111101010011001001100001111110011000111011010000001110001010110100110011010110000011100110011100010100101010010001100010010000111001010111011000110110100000000110010100011001010001100111111111010001111001101000111010111111100100010000011110010011010100100100110001000010010011101010000000000100011001000011111001110010011101100011111110010000111100001001001001000100001000101111001001000111000110011001010101010010101100000010101000011100011001000001000100110000000000000111000001110010001": TestData(n, 2) = "?"
728.     n = n + 1: TestData(n, 1) = "11111001000101111111100011111101110101111110110001111101010100010000111111111111111110011111001110101111001101011111100010111111110100011100111110101110011001110011111111100101011000000101011100110110111100000101110000100100111110011110000111111111011011111100001100100110011001001101000001000101111001111101011101010110111100011100010011001000010000111110010001011110011111111111111001010111111101011111001110000000101001111010100111111101011000100101000011111001011001010011001101000110000100111111": TestData(n, 2) = "?"
729.     n = n + 1: TestData(n, 1) = "11001000011100110101111111001111010111100011011111101101101011011101101010011111111010111001110011110011111001000011111111111110001011111100111000011111111111111011000110011100110011001111010000010010011011011111101010011100111111111001111111001100111111101001101111010111110101100111111110011111110101101110010010001101000000011111110000001111111111111100000101000000111100011011001111111110011101110010101011111111000110111010001100100111111111111111111100001110011000011100001100011010001100000111": TestData(n, 2) = "?"
730.     n = n + 1: TestData(n, 1) = "01110000001111111111110011101001011000011111111111001111111100111111111111010110100011111110101110101001110000111000011111111001000000111100111100111100111101010011100111111110011111111100100111010001111111001100111001111111110011111111111101011111111000011111110100010101111110110111000010011110000100111010110010011111111100100111111111111111101101111100101010011110110110011110000110000001101101111101101111110011111111001111111101101101000100111101011101011111111001001111111111100110011111110010": TestData(n, 2) = "?"
731.     n = n + 1: TestData(n, 1) = "00100110010011111110100011001111110011100111111111111111111111111100010111101000111111010111111010111010010111111001000011100111111111001111001111111111111100111111111111110101001010111101010010011100101011111000001010110111001100110000111111110011001101010011101010011111111100100110011111110101001111111100100001110011100111111111111111110011111111001110000010111001111001101100010000111111001101001011111111111010110001011111110011111111111001000011100001100110000111111100110010011100101011001111": TestData(n, 2) = "?"
732.     n = n + 1: TestData(n, 1) = "01111001111110000010111001111101011111111000000101011111111100100111100001111111001101011110011110000111100111111110100101110000100001000010111101110101110000010001001110101111100100111111010010001100111111111111100111111111111111111110011111111110010011111100100001000011001001110011111111111111111111100001111111001000010011111111100111111100100001000011111111111111000000111111111001010110011111100110011001110011100111110011100111110011111010111100111111100000011111111110011110011001001101011100": TestData(n, 2) = "?"
733.     n = n + 1: TestData(n, 1) = "11111111111101101111111100111001111110010011111000011010111111111110011110011111110010011111111111111100111111111111100111110011111111111001111111110110111111111111000101000011111111111001000011110100010010011111001111110010111010000111110010011111111001001110011111111101010011100000011100111111010100001110011111111111111111110110111100101110111111111010111100111111111111111100001110000110011111111111100100111111111111010111100111111001100111111111100001111111111111101010110111111001111111100001": TestData(n, 2) = "?"
734.     n = n + 1: TestData(n, 1) = "10111001000011101011111011000110000100101000111000011110110001111100111101101000000001110010100001000111001001111010101011010110011110100110010101101001100001001000000100110000001011011111010000101010001011001011111101001011010110011010100100110101010101011000000111010110101000100111000000010000100111000111000001000101111101011100000011100111000001001011000000000011001011110010110000110001111111010101110110111110101010000001011011101111011100010101001110000111101001010001011001100100110011101111": TestData(n, 2) = "?"
735.     n = n + 1: TestData(n, 1) = "00011000111110101110110100111010001110101001010110011110000101101100100000101000111000111100001111101110110011110111010010011111011100101001010110000110011110011001111000000100110101010010111100001111101010011101110110000111111100000101111100101011110000010001000111111010111100101010111110010011111100111100111100100000011111100100111101111011010111000110011101110000110011001010110101110001000100000100001001010101010111110001011110000011011111100110011001111110011111011000100110011001100000110100": TestData(n, 2) = "?"
736.     n = n + 1: TestData(n, 1) = "11111000010101110101001110011110000111001101100000010000110100111100111110101000011100001000001011101001100110100101001100110101101100001111001000101101100010010011110100010000101011010110011011011001100001100111111001011001100101010111000111000010111111101011101011010100001101011010000001010101101011001100111010110011101010010010000100001101010101011101111000010010100110111101101110011101001001011111101000111101011000010001110000110010001100101010101111010111100101100001000000111101101011000010": TestData(n, 2) = "?"
737.     n = n + 1: TestData(n, 1) = "10000000000101100111000000010100011011010001111000101010111110011101101100011101001101111001000100100100000101111001110010011110010100011010100111111111101000100011000101010011111000011001111000011000000100010001000011100110111000001010111101001101001000100010001011100111111001111010011010010010111011111011001110111000001000110000101011010010010000010001100011100101010101101011111000111011101010101111111010001011000111110011111100010001010011011000100110011010101010110011100011010011111000111011": TestData(n, 2) = "?"
738.     n = n + 1: TestData(n, 1) = "11010000010011101000010111000000011000011010011110010011001110001001010110110011100111000000101011100110101001110011110000000001110100001010111111111111001011011110000001100111111010100111110101001100010110000010101100110001000010011010100001001100110011101101111100100110110110111010100100010011000110111001101001110111101010010000011011001001110011111111010000011111011100111010111110110101011011110010011010000100101000010001001011100111100110101010101011001011011001100110101001111001010000100010": TestData(n, 2) = "?"
739.     n = n + 1: TestData(n, 1) = "11010110011010111111001111010011110111100111001110010011101000111010010011001100011110011010000101010110111101011101101011010001111011001111010000011010110000100100011111000001110100110000100110010000111111010010100111000100101110110100110000001010111100010000101000100010100111000111000010000010010110101111001000010010011100111010000111010111011011011000010101100111100110010101001101101101100101100111100110110001101001001001011111001110100010101101110000010101111101010011111000111100000111010110": TestData(n, 2) = "?"
740.     n = n + 1: TestData(n, 1) = "00000100110111011101011011011101001011000100011001010111110100001100000011011001110010110011101111001111111000100111010101100111001111001101100001001110111110010110110101001001001010001100001100001010101011001100000100011000001010101001100100100100001111010110011101101110100101111100101001101001001010110010001011111111110010111001100000011101111101001101100101100101110101101100111000111010001110000111100100000100011000010110111110011000000101000111111001110011011111000110111101010111100001001101": TestData(n, 2) = "?"
741.     n = n + 1: TestData(n, 1) = "01111111101101010001101000100100111100001101111000111100011111000111111101101001100100110001101111001100110100010110111100010010111111100001100011010010101111111111001111010010000000100001101101111010011101000110111110101110011111111101001000000000000011100001110101110100010011000111001011111100011110001110001001011001001101010100000101101100100001110110111111111111000100000100111011000111100111111000101110010110101010011010011011110100001011100001110011110111110010010000010100010110101011111010": TestData(n, 2) = "?"
742.     n = n + 1: TestData(n, 1) = "01010010100000101100110000111011100101010111001101011001101011110001001011001111100011011101011110001100000001111100111010010010101101111101100100000110100010010101111110011111110011001101001001100011101000100010110001011000001111011001100101110001110111101110000011011010101111000001111000011010101101110101001011011111110101100100101100110011000010011101101001110111000011010111001100101100001101001001100101011100111010000010110100000101111111010001110000110101110101000110011001011011011101000110": TestData(n, 2) = "?"
743.     n = n + 1: TestData(n, 1) = "11001000101011011111101000010000110111111111000011010000010101000000100110111110010000000111110110111111100110101010111110011010001110010110100101000010111111000000111100111000011100100111001100111111110100010110000010010011000111001110001110110100111110101111011010100010000101001001101111111101010101111010111111001001001111111100101011011011101001100000100010111110101010100001110000110011001110101100101000101000111100100101110110011111001101011001100011100101001001100010101010011001010001111101": TestData(n, 2) = "?"
744.     n = n + 1: TestData(n, 1) = "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111": TestData(n, 2) = "?"
745.     n = n + 1: TestData(n, 1) = "00100000000010000000000100000011000110110001001110101010010011010001100000101001000000000000010001110100001001101000001000000000010001101001011000010000000000010000000010011010011001001000000100000100000000001000000001000101001000001110001001000100000000000100000111000011010000000000010001000000110010000000011000000000100100001000001000010001001001110000000010000000100000000000000010000100000010000000101110011000001000100000011010100001010000001000010100000000001000001100000100010010000101100000": TestData(n, 2) = "?"
746.     n = n + 1: TestData(n, 1) = "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111": TestData(n, 2) = "?"
747.     n = n + 1: TestData(n, 1) = "00001101110100101100011001010001001010010110000110000000100001000100100110000000010010100011000100110000110000100010000011001000000000100000001000100100100001100110100000101000101000010001110001111001000101000000100100001000000001110110100010001001000100100000011011000001000000000101000010000100010000110101001010010010001000110010110000000110010000110000001000101010001001101111001000010000101100011000000110001011110000001111001000000000000011110011100000000101010000000101110001000100000000100000": TestData(n, 2) = "?"
748. End Sub

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 14, 2021, 11:42:53 pm

STxAxTIC

I added your latest code to my main program and everything seems to be working as expected.
I'm not getting quite the results I had hoped for but I have not had time to run enough test to
really tell one way or the other.   

One question I do have has to do with my process bar.  Where would be the best place to put
a counter so that it closely approximates the overall number of iterations each prediction takes?
Nothing big, just thought you might have good idea where to place it.     

R1

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 15, 2021, 02:30:16 am

Hey R1,

Good question. I'll think about where precisely to inject some kind of percentage counter that gives a sense of how long an iteration takes.

So as usual, I updated the code again, and it's now a factor of about 100 times more productive than it ever was. (Almost literally 100 more answers per second compared to the old versions.) It occurred to me that its silly to do *one* test per entire string all the way at the end. So instead, we still feed it big random strings, but instead the program gives a new prediction every for every character in the string. I commented out the order 11,12,13 alphabets, so the thing is so fast now it needs a delay to watch. If i ever feel it lacks accuracy we can just bring the bigger alphabets back.

Even better too: it's been tested with real data generated by different humans and different RNGs. The results are nothing but pleasing. I'll resume this tomorrow, but I wanted you to have the latest:

Code: QB64: [Select]

1. Option _Explicit
2.  
3. Screen _NewImage(100, 30)
4.  
5. ' Version: 11
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. Dim As Integer j, k
44. Dim As Double f
45. Dim TheString As String
46. Dim predictedGuess As Integer
47. Dim correctGuesses As Double
48. Dim totalGuesses As Double
49. Dim progressReport(1 To _Width) As Double
50.  
51. 'TheString = "110111001100010110010011101011100111010101100001100101011010101111110000111100010101110000010010110001" ' Wolfram 30
52. 'TheString = "001100000000001111111111111110110000000010111000000000111111111011111111100000000000110000000011111111110100011111100000000110110000110100111111111001101110100000000101000001100101110011111101001111000000000000000010000111001110011111111110111110000000000000000001100110001000011001011110000000000000000000000000000000000110101111100000000000000001100000000000000001111101111000000000000010000000000000011110111111111111000000000001100111110000111101111111111111100000000111110111110001111011111111111101110000000011111111000000000000000111111111111000000111100000000000000000000111110011110001010111100000110000000000000011110111110001111011110000000000010000000111100111111111111110000000000000110000001111001111100011111111110000000000000000000111111010110011111111110000000011000110000111110001010001111101111000000000011110001110110011010000110001111110000000111000011111000001010000111001111100000000000000111110011111001000000100111110011000000111111111111111111000000001111111111111111111111111111111000011000000100001110111111111111111111110100000000000111000111101111011111111111111000000000001111100111110000000011111111110000000100000001111011110000001111111111111110011010001111111111111000011111111111111110101101111111111011111001001111111111111" ' Chia
53. 'TheString = "101000110111011000000001110011010010101011111010100110010111010000011110101101100001010110110000011001001001010101011011111111100100010010101110100001111001100000010011110000110011100011110010000000011101001101001100111110100001001110111100001110001101011010110100011110111110010110010000010111101100110110000011101100000100111100011000000111010110010101010000101001000111000011110011000101000100100010001100101110111000001000000111001011111101000111100001101010011010011001010100001101100001010111011011110000101111111000001011111000010001100010101011011110100010111110010100111001101001001001110100111010011100110101100110110110101101011000010000010101110111100010100001110111011101111100001010001110000011001110010100010001110111000111101000100100111110000011001111011000001111100101011100000111001110110011010011001111110110001100000100001010011100100011111001011111011101011100101000111010110011111011111100010101011001100011100000100111111010001010001010010010001101101001001001111011001100011100001000001010100000000011001111010011101101010111101101010011010000001011000010111100110011100101011011011101111110011000010000000001111001000111011101010000101001010001100110001010110100000100110101110001000110110110011001001100010111110111100010000010001010101110100010000001110011010111101010101101000000110000000110100111101011100101001100001111100100101010101010101101000111100000101011101100011010110010110101011101011010111101100110101010111100000100100100001011000100001100001010100010100011101011100111000101010101001000000010001010111100111001101011111110011100001000110110001001001101000100011111100011101010010111110101100101101110000111000100001101110101111010000011001110000000100111100001011010100101010010011100011101000110000110000111001001011100010010100110001101110001110010010101010001110011001111011101011000110101000110101011100100110011001100010010011100000110100100000010000001011110000110101011001011011111100000101100100110010101010010011101100011111111010001011000011111101010011100100010011101110010" ' Cobalt 3k
54. 'TheString = "1011001010010100100100110010101010101001010101010101011010010101001010101001010010100110101011010101010101011010101101010101010101010010110101010101100101010101010110101101011010010101010010100110101101001010110101011010010101101010110100101111010101010011011011010010110101010010110100101101010100101011010010101001010101010001011101011010010101011100111010010001101011110010011010001011100110101010010011010101001001010010000101010110001" ' loudar
55. 'TheString = "11111011110100101011111111110100000011011110101100111100111111110111101110100111100110011111110101111111010111101111100111110111111111111011100111110111111110010000101011111001110101101010110111110" ' Spriggs 2
56. 'TheString = "1010001101110110000000011100110100101010111110101001100101110100000111101011011000010101101100000110010010010101010110111111111001000100101011101000011110011000000100111100001100111000111100100000000111010011010011001111101000010011101111000011100011010110101101000111101111100101100100000101111011001101100000111011000001001111000110000001110101100101" ' Coalt legit
57. 'TheString = "01001111011010000010110000100000010010010010000001110111011011110110111001100100011001010111001000100000011010000110111101110111001000000110100101110100001000000111011101101001011011000110110000100000011001000110111100100000011101110110100101110100011010000010000001110011011101000111010101100110011001100010000001101100011010010110101101100101001000000110001101101111011011100111011001100101011100100111010001101001011011100110011100100000011011100110111101110010011011010110000101101100001000000111010001100101011110000111010000100000011101000110111100100000011000100110100101101110011000010111001001111001" ' Zach binary thing
58. 'TheString = "1000000111011011110101111000000010101111000111011001111101010001010001100100110101111000001000000111010111100101101110111011001001100101000101001100011010000010101011100100101000011010010011011100100000110000000100001011110000010011111101011111101110001011011011111100110011100101010101000000000000101001100110111111100000001101000000110010001011111010011101100101100011001101001110101101100010100001100110101010001010010101011011101001011010000110110011111001101010001111100010100111101011100110101111001100001011000000110010110010010011110111001101111111110010111010001100000011000110111101011111000000000111010011000101101010001101101000001010110010100110101101010010001101101000000000001011101011110111110101000000010101001010001111110100101101001111010111000001011110101010011100100011101000101101100101101100111010100011100100100001010100110011111010000100100101010110100110101011011100011101110111011011100011101010111010010001000001001000110011110101011001010111000011101010101011011010100100001110010001100010001111010100000000011011110100101001011111001001100011110110010100100101111101111010001111011011110101111000010101111001011101010011101001000010110110101011110110000000001010101100111101000001101011001101100110100110110000000100001001001111100111111110010111011001000000100110011010110011110100011000000011101101010111001101101110011010001010110010010100001111001011000001010001111110100011101010101110011111100010101110100001101000011010111011111010101101111110110000010010010000101001011001000001011101000111101110010001000101011001010000011101110101010110100001000111100000011100110011111111011111100111000001010010011101111001110101001111001011011101101010101001101100110010010100101100110101100011000001000100110010100101111011011100110110001010011000011001110110100110110011111110110111011100010110010110011110101111001110011011010001001111010000111001001110001110001111101101111000000101001011001101110110100100001111100010001101111011000101101001110101010101001001111111011100001101110011000100011100011111011111001010010110001010111010101100010010101101100111110000010000110110110000101001111001110111001101100010111011110110001101101000011011111001111101100011100101010100001010000101111001101010000001000010100001111110110100100101011110000100001000001100110111010001110100011111101100001111000001011010011011111110110011010011011100001010100011001110100001001101111111110000100101011111010011111010111111110101111100101001011001001101011011101001000011101100100001100010000111011000100111101010011010100010110101001111101011101010000111100100011010001011011001010010111001001010100000101001111000101001011111011101011101001010000100111110111011110010010100101111000010001101100010010111111000110000110011010011110000101011011101001100101010000001010001111000110110011000110000010001010110110001011111001100100000110100100011110001010110011110010001000000100101111000111110101100011001010000110101001001010000100000101100010001011001110100010110100101010100010110110000100101000011111010000011110101010100100110101000001001110100101000010110100011111000110011111010010010000111101110111001111110000010110101101010010101011101001010001010101111110001101001101010010001011101011100101101010110001101010101101011101100111101110101111110011101110010100110111100101011110100110111111100110101011011111000100000100100011100111011111010111100111100111110100000010001011110111011000100101111100100100101000100110000110110111101010111001011011010000111000111111111001011000101011011000001011111000100001001011001111011011011101101011111000000000100110010011111000000111000110100010110101101001010110110100001100000011110011100110000101000101101010000010011011110000011001010111001011100000101111011110110100100010011100111000001001000110110111010101001011100010111010000101010001010001000001110011100001101010011001100011101010001111011111101001001010000010000011100110110001110000000100111010011111110011100111101000000011011000101101001011001110000110010001100000111101110010010100000101110010111110111000100001110011111111001111100101010110000110101101000000100110111000000110111001011110101100111100110101011000100000110110101100001000111010111101100000000100110101101101000101010100001110110010101011110010011100001010010100011010111110001010111001111011111001000110110001001100000010001001110001011000101101010111011101101110111100100000101011110000011001001110100111111010001001010000110010001111110000000010001011111000001001101101010111110111100011011011001000101100110010010100110110011110111110110101010010011000100101110011101010100010011110011001011100010101100000101011000111001111100010101010000100100110010110011001110111100100000001010001101111010011100110010101011101001110100111110100001111000111111101000110000001010001010010010111110011011011011010101000100101010011111100011111110101010101110001011110100100110001011011100100000010111010001010111101101100100111001001110101010000111010111111110000010011100101110101110010111100101010100001110100000111110010111111001110011101110001101100000011011110000111100101111100101111101010101001110110011010111110110011100000000010101001000000011100001111000011000110101001010101100110100110111001001010101001110010111000111111111101001111001101100001000010110000000100110110010001110000110001001111000011111110111011010111101001000010001110010101110000000100011100110101110111011000101100010100000101010110100111010010000111110011111100110010110111101010011000000101001001001100111010001001101101111010101110000010000111000101011111100010010101000110001010011101001111101110010110101110101011110011001001100011001011111100011011001000010101101100010110010011010111011111111110011011010111000100011011110100100111111110010100100100100010001000001111100100010011001101000100010110111001111100001010001010110100111111101110000000010100001111101000100011101110000100111011101100100111101110011011011000100010000100001111111011010010001001101000111000000100011011111101110100001100010000111110001110100111011010001001000111000010101100001101001000101001000111100100101000011111110001011011101110010011000110111100110000110111010111111001010100001010001110010100101001001001101111001000010010000111011011010000100111111100011111110100110111001111011001111011010000010001111010100000111010010011110000010011111111001100001010100110001111010001010110101100000010001101000101001110001100111111000101111011000001111110110001011110000001011010001110010011001001011110101001111010011000110001101111101000011110111011000000011100101011101100010010001101101011100000100000000101000101011101100011011100011001101010110011111100010011001110001010010011010110011111111111001010100110100101111001010100001010001001100101110110100111101100101010100000111110000011110001011000010110101110110001001100110011111111010101100100000100110010101000001001110101101100001000100110111011101011110100100110101010000110011111000101001011110111111010100000010000111010110110010001100001011100001100001001000001001011111011111011011100100100101001101110010101000111111000000100001101101010011110111000001000010100110111100100111110101111000110111110111000010110100110000001110110010000001111011000100110101010000100010110100101110010011001110100010111011100101100111011101110000011101100111010001010010100001011101010101101000111100100100110010010110001100010100101001010100111111010001100111111111001110001011101000101011101010110010101100011111101100010000000001111000011100010010001100100100001010000000000011100000001101110101111111110001011001101000101101000101001001000110000101110100000110001010011001001010100100111001110111001101010101101111000001011000100000001101000011000001001011001110101110101010010000100011100011010010001000100001011101000100101001111100010110001110101001011000101110010011101000001001111100110001000101010011011001111101101011111011010110101101101001001100100011001010001001011101000101000101110001101101110110010110011010000100000010101110111100001100111101111111110000001010111111001110100101010010100000110001001011111110001100011110101001011110000010111110000010000101110111000011001010011100010010101011101101110111001001110110101110110111011110001100010100101101011111111010011110000011010100111111001101010000101001000111000011110011000101000100100010001100101110111000001000000111001011111101000111100001101010011010011001010100001101100001010111011011110000101111111000001011111000010001100010101011011110100010111110010100111001101001001001110100111010011100110101100110110110101101011000010000010101110111100010100001110111011101111100001010001110000011001110010100010001110111000111101000100100111110000011001111011000001111100101011100000111001110110011010011001111110110001100000100001010011100100011111001011111011101011100101000111010110011111011111100010101011001100011100000100111111010001010001010010010001101101001001001111011001100011100001000001010100000000011001111010011101101010111101101010011010000001011000010111100110011100101011011011101111110011000010000000001111001000111011101010000101001010001100110001010110100000100110101110001000110110110011001001100010111110111100010000010001010101110100010000001110011010111101010101101000000110000000110100111101011100101001100001111100100101010101010101101000111100000101011101100011010110010110101011101011010111101100110101010111100000100100100001011000100001100001010100010100011101011100111000101010101001000000010001010111100111001101011111110011100001000110110001001001101000100011111100011101010010111110101100101101110000111000100001101110101111010000011001110000000100111100001011010100101010010011100011101000110000110000111001001011100010010100110001101110001110010010101010001110011001111011101011000110101000110101011100100110011001100010010011100000110100100000010000001011110000110101011001011011111100000101100100110010101010010011101100011111111010001011000011111101010011100100010011101110010101110101111011111001010010000100110101110011000100001010110011111001011010000100011011110001000101011100001100011001111000111111010" ' Cobol
59. TheString = "10111010101010101010101001010101010101001010101001010101010101010101010101010101010101010101010101010101001010100100100101010101010101001010100101010101010100101010100101010101010101010101001010010110010101010010101010101010101010101010100101001001001010101010101010101010101001010101001001101010010" ' Spriggs hand
60. 'TheString = "01100101001010001100001101101111011010010101010110110101001000001111001111110101000101111011010101111101010101101010101001010101011000010101010101001011010100110100110100110011010101010101110101010111111101011010100000001101111000010111000110111001000010100001101010110100000111101011111100001011001010110010110" ' Luke 50
61. 'TheString = "010101111010111100110000001001100100101100000101110001100101000010001001111101111111111100011110000011011110011000100011100100001101110011001001011001000011110010001000111100011100011110010110011110111010110100001000110000010000111000111011100110011010101111111100100010001111111100010100001011000011" 'Spriggs
62. 'TheString = "10101010101011101000011101010111010101010101100111001010100111100001011011110101000001111010101101010000001111110011111110111101110111001110110010000100010101010101010100101011010110101010101010101001000000001111110000011110101010101010100010101110101010101101111111111111111111101010101010101000000" ' 63
63. 'TheString = "11100101110011011010110100110011111011010110100100000110000100101001001010011100111101101110000001000000011011100101110000000111100100011101000000101000110100001000000001111010101011000010001110111110001001110101011000010101001111010100100000011100110110110000111010001010000011010000101111101011000" ' using RND function
64. 'TheString = "00101010001100101010010101010100101010010100101010010101010100100000101011110101001010010101010010000011101010100101010101001010010101010101010110101001010100101010101001010100101010100101010100101010101001010010101010010101010101010100101010101010101010101001010101010100101010101001010101001101010" ' 78
65. 'TheString = "11100101010011001001001010101001010000101001000010100010110111010101010011010100100100110101010010010110100101001001010010101010010010100101001010010100100101001001010010010110010010101010101001010101001010101010010101001001010101001010101010101010101010101010101010010101001010010100101001010101001" ' 68
66. 'TheString = "10101011100101100101010101010101010101010101010101010101010010011010100000000011111111111001011001101010101010110010101010101010101010101010100101100101010101010110011101011110101010101010101101101010101111010101100101001011010010101010101011010101001110101010111101110011010011001101001101011000101" ' 68
67. 'TheString = "10101101000110101000101010101010101010100101010101010100101110010101001001010100101010101001001010101001010000010010001010010010101010100110010101010101010101010110010101010010100101010010101010101001010101010101010010101010101010101010010101010101010101010101010010101001001010010100101010101010101" ' 76
68.  
69. For j = 1 To Len(TheString)
70.     Cls
71.     Locate 1, 1
72.     Print "Analyzing:"
73.     Print
74.     Print Left$(TheString, j) + "["; Right$(TheString, Len(TheString) - j); "]"
75.     Print
76.  
77.     ' Main prediction call:
78.     predictedGuess = Analyze(Left$(TheString, j), 0)
79.  
80.     Print "Prediction: "; _Trim$(Str$(predictedGuess))
81.     Print "Actual:     "; _Trim$(Mid$(TheString, j + 1, 1))
82.     If (predictedGuess = Val(Mid$(TheString, j + 1, 1))) Then
83.         correctGuesses = correctGuesses + 1
84.     End If
85.     totalGuesses = totalGuesses + 1
86.     Print "I have been correct for "; _Trim$(Str$(Int(100 * correctGuesses / totalGuesses))); "% of "; _Trim$(Str$(totalGuesses)); " guesses."
87.  
88.     f = (_Width - 1) / Int(Len(TheString))
89.     If (f > 1) Then f = 1 / f
90.     progressReport(1 + Int(j * f)) = correctGuesses / totalGuesses
91.  
92.     For k = 1 To 1 + Int(j * (_Width - 1) / Int(Len(TheString)))
93.         Locate 25 - Int(10 * progressReport(1 + Int(k * f))), k: Print "*"
94.     Next
95.  
96.     _Delay .05
97.     _Display
98. Next
99.  
100. End
101.  
102. Function Analyze (TheStringIn As String, pswitch As Integer)
103.     Dim TheReturn As Integer
104.     Dim As Integer n
105.     Dim As Double r, j, k, h
106.     Dim Fingerprint(16) As String
107.     Dim p(2 To 10, 2) As Double ' Change the upper bound to a higer number for more accuracy.
108.  
109.     ' Create shifted versions of string, i.e. ABCD -> BCDA, CDAB, DABC, ABCD, BCDA, etc.
110.     Fingerprint(1) = TheStringIn
111.     For n = 2 To UBound(Fingerprint)
112.         Fingerprint(n) = Right$(Fingerprint(n - 1), Len(Fingerprint(n - 1)) - 1) + Left$(Fingerprint(n - 1), 1)
113.     Next
114.  
115.     ' Initialize partial results.
116.     For n = LBound(p) To UBound(p)
117.         p(n, 1) = -999
118.     Next
119.  
120.     Call CreateHisto(Fingerprint(), Alphabet2(), 2)
121.     Call CreateHisto(Fingerprint(), Alphabet3(), 3)
122.     Call CreateHisto(Fingerprint(), Alphabet4(), 4)
123.     Call CreateHisto(Fingerprint(), Alphabet5(), 5)
124.     Call CreateHisto(Fingerprint(), Alphabet6(), 6)
125.     Call CreateHisto(Fingerprint(), Alphabet7(), 7)
126.     Call CreateHisto(Fingerprint(), Alphabet8(), 8)
127.     Call CreateHisto(Fingerprint(), Alphabet9(), 9)
128.     Call CreateHisto(Fingerprint(), Alphabet10(), 10)
129.     'Call CreateHisto(Fingerprint(), Alphabet11(), 11)
130.     'Call CreateHisto(Fingerprint(), Alphabet12(), 12)
131.     'Call CreateHisto(Fingerprint(), Alphabet13(), 13)
132.  
133.     If (pswitch = 1) Then
134.         For n = 1 To _Width
135.             Print "-";
136.         Next
137.         Print
138.     End If
139.  
140.     If (pswitch = 1) Then
141.         If (Len(TheStringIn) >= 2) Then Call PrintHisto(Alphabet2(), 3) ' Set the last number >=1 to print stats for that histogram.
142.         If (Len(TheStringIn) >= 3) Then Call PrintHisto(Alphabet3(), 3)
143.         If (Len(TheStringIn) >= 4) Then Call PrintHisto(Alphabet4(), 0)
144.         If (Len(TheStringIn) >= 5) Then Call PrintHisto(Alphabet5(), 0)
145.         If (Len(TheStringIn) >= 6) Then Call PrintHisto(Alphabet6(), 0)
146.         If (Len(TheStringIn) >= 7) Then Call PrintHisto(Alphabet7(), 0)
147.         If (Len(TheStringIn) >= 8) Then Call PrintHisto(Alphabet8(), 0)
148.         If (Len(TheStringIn) >= 9) Then Call PrintHisto(Alphabet9(), 0)
149.         If (Len(TheStringIn) >= 10) Then Call PrintHisto(Alphabet10(), 0)
150.         'If (Len(TheStringIn) >= 11) Then Call PrintHisto(Alphabet11(), 0)
151.         'If (Len(TheStringIn) >= 12) Then Call PrintHisto(Alphabet12(), 0)
152.         'If (Len(TheStringIn) >= 13) Then Call PrintHisto(Alphabet13(), 0)
153.         Print
154.     End If
155.  
156.     If (Len(TheStringIn) >= 2) Then Call MakeGuess(TheStringIn, Alphabet2(), 2, p(), pswitch) ' Set the last number =1 to print guess for that histogram.
157.     If (Len(TheStringIn) >= 3) Then Call MakeGuess(TheStringIn, Alphabet3(), 3, p(), pswitch)
158.     If (Len(TheStringIn) >= 4) Then Call MakeGuess(TheStringIn, Alphabet4(), 4, p(), 0)
159.     If (Len(TheStringIn) >= 5) Then Call MakeGuess(TheStringIn, Alphabet5(), 5, p(), 0)
160.     If (Len(TheStringIn) >= 6) Then Call MakeGuess(TheStringIn, Alphabet6(), 6, p(), 0)
161.     If (Len(TheStringIn) >= 7) Then Call MakeGuess(TheStringIn, Alphabet7(), 7, p(), 0)
162.     If (Len(TheStringIn) >= 8) Then Call MakeGuess(TheStringIn, Alphabet8(), 8, p(), 0)
163.     If (Len(TheStringIn) >= 9) Then Call MakeGuess(TheStringIn, Alphabet9(), 9, p(), 0)
164.     If (Len(TheStringIn) >= 10) Then Call MakeGuess(TheStringIn, Alphabet10(), 10, p(), 0)
165.     'If (Len(TheStringIn) >= 11) Then Call MakeGuess(TheStringIn, Alphabet11(), 11, p(), 0)
166.     'If (Len(TheStringIn) >= 12) Then Call MakeGuess(TheStringIn, Alphabet12(), 12, p(), 0)
167.     'If (Len(TheStringIn) >= 13) Then Call MakeGuess(TheStringIn, Alphabet13(), 13, p(), 0)
168.     If (pswitch = 1) Then Print
169.  
170.     If (pswitch = 1) Then
171.         Print "Analyzing:"
172.         Print TheStringIn
173.  
174.         Print
175.         Print "Thinking:";
176.         For k = LBound(p) To UBound(p)
177.             If (p(k, 1) <> -999) Then
178.                 Print p(k, 1);
179.             Else
180.                 Print "_ ";
181.             End If
182.         Next
183.         Print
184.     End If
185.  
186.     j = 0
187.     r = 0
188.  
189.     For k = UBound(p) To LBound(p) Step -1
190.         If (p(k, 1) <> -999) Then
191.  
192.             ' This is the made-up part of the model:
193.             ' The variable r contributes to weighted average.
194.             ' The variable j is used for normalization.
195.             ' Scaling factor h influences weighted average calculaton.
196.             ' The factors multiplying h are totally arbitrary. Notes:
197.             '   setting o(h^2) means the later alphabets count for more.
198.             '   p(k, 1) euqals the calculated guess at frequency k.
199.             '   p(k, 2) euqals the peak count of the unscaled histogram.
200.             '   ...while p(k, 2) is here, it does not seem to help calculations.
201.  
202.             h = 1 + k - LBound(p)
203.  
204.             h = h ^ 2
205.  
206.             ' Standard weighted average:
207.             r = r + h * p(k, 1)
208.             j = j + h
209.  
210.         End If
211.     Next
212.     If (j <> 0) Then
213.         r = r / j
214.     End If
215.  
216.     If (pswitch = 1) Then Print "Predicting:  "; _Trim$(Str$(r))
217.  
218.     If (r > .5) Then
219.         r = 1
220.     Else
221.         r = 0
222.     End If
223.  
224.     If (pswitch = 1) Then
225.         Print "Rounding to: "; _Trim$(Str$(r))
226.     End If
227.  
228.     TheReturn = r
229.     Analyze = TheReturn
230. End Function
231.  
232. Sub MakeGuess (OrigString As String, arralpha() As LetterBin, wid As Integer, arrbeta() As Double, pswitch As Integer)
233.     Dim TheReturn As Double
234.     Dim As Integer j, k, n
235.     TheReturn = 0
236.     j = 1 '0
237.     k = 0
238.     For n = 1 To UBound(arralpha)
239.         If (Left$(arralpha(n).Signature, wid - 1) = Right$(OrigString, wid - 1)) Then
240.             If (arralpha(n).Count >= j) Then
241.                 If (pswitch = 1) Then Print "Order-"; Right$("0" + _Trim$(Str$(wid)), 2); " guess: "; arralpha(n).Signature; " . "; _Trim$(Str$(arralpha(n).Count))
242.                 TheReturn = TheReturn + Val(Right$(arralpha(n).Signature, 1))
243.                 k = k + 1
244.                 j = arralpha(n).Count
245.             End If
246.         End If
247.     Next
248.     If (k <> 0) Then
249.         TheReturn = TheReturn / k
250.         arrbeta(wid, 1) = TheReturn
251.         arrbeta(wid, 2) = j
252.     Else
253.         TheReturn = .5
254.         arrbeta(wid, 1) = TheReturn
255.         arrbeta(wid, 2) = j
256.     End If
257. End Sub
258.  
259. Sub CreateHisto (arrfinger() As String, arralpha() As LetterBin, w As Integer)
260.     Dim As Integer j, k, n
261.     For n = 1 To UBound(arralpha)
262.         arralpha(n).Count = 0
263.     Next
264.     For j = 1 To w
265.         For k = 1 To Len(arrfinger(j)) - (Len(arrfinger(j)) Mod w) Step w '- 0 Step 1 'w 'make the 0 a -w? might not matter at all
266.             For n = 1 To UBound(arralpha)
267.                 If (Mid$(arrfinger(j), k, w) = arralpha(n).Signature) Then
268.                     arralpha(n).Count = arralpha(n).Count + 1
269.                 End If
270.             Next
271.         Next
272.     Next
273.     Call QuickSort(arralpha(), 1, UBound(arralpha))
274. End Sub
275.  
276. Sub PrintHisto (arr() As LetterBin, w As Integer)
277.     Dim As Integer j, n
278.     If (w > 0) Then
279.         If (w > UBound(arr)) Then
280.             j = UBound(arr)
281.         Else
282.             j = w
283.         End If
284.         Print "Histogram: "; _Trim$(Str$(UBound(arr))); "-letter regroup, showing top "; _Trim$(Str$(w))
285.         For n = 1 To j
286.             Print arr(n).Signature; arr(n).Count
287.         Next
288.     End If
289. End Sub
290.  
291. Sub NewAlphabet (arrold() As LetterBin, arrnew() As LetterBin)
292.     Dim As Integer j, k, n
293.     n = 0
294.     For k = 1 To 2
295.         For j = 1 To UBound(arrold)
296.             n = n + 1
297.             arrnew(n).Signature = arrold(j).Signature
298.         Next
299.     Next
300.     For j = 1 To UBound(arrnew)
301.         If (j <= UBound(arrnew) / 2) Then
302.             arrnew(j).Signature = "0" + arrnew(j).Signature
303.         Else
304.             arrnew(j).Signature = "1" + arrnew(j).Signature
305.         End If
306.     Next
307. End Sub
308.  
309. Sub QuickSort (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
310.     Dim As Long piv
311.     If (LowLimit < HighLimit) Then
312.         piv = Partition(arr(), LowLimit, HighLimit)
313.         Call QuickSort(arr(), LowLimit, piv - 1)
314.         Call QuickSort(arr(), piv + 1, HighLimit)
315.     End If
316. End Sub
317.  
318. Function Partition (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
319.     Dim As Long i, j
320.     Dim As Double pivot, tmp
321.     pivot = arr(HighLimit).Count
322.     i = LowLimit - 1
323.     For j = LowLimit To HighLimit - 1
324.         tmp = arr(j).Count - pivot
325.         If (tmp >= 0) Then
326.             i = i + 1
327.             Swap arr(i), arr(j)
328.         End If
329.     Next
330.     Swap arr(i + 1), arr(HighLimit)
331.     Partition = i + 1
332. End Function
333.  

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 15, 2021, 12:32:32 pm

Hey r1, know what occurs to me? The progress indictor thing is already here, the answer was on screen the whole time and I wasn't noticing.

Just to get it out of the way, updated code:

Code: QB64: [Select]

1. Option _Explicit
2.  
3. Screen _NewImage(100, 30)
4.  
5. ' Version: 12
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. Dim TheString As String
43.  
44. Dim As Integer j, k
45. Dim As Double f
46. Dim predictedGuess As Integer
47. Dim correctGuesses As Double
48. Dim totalGuesses As Double
49. Dim streakGuess As Integer
50.  
51. Dim ProgressGraph(1 To _Width) As Double
52.  
53. 'TheString = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
54. 'TheString = "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
55. 'TheString = "01010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101"
56. 'TheString = "00000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100000010000001000000100"
57. TheString = "01010111000101101010101011010101011100010110101010101101010101110001011010101010110101010111000101101010101011010101011100010110101010101101"
58. 'TheString = "00110000110001110001110010110011110101111000110001110011110010110001110011110100110101110101111000111001110001110100110100110010110011110011110011110111110111110110110001110000111001111000110111110001110101111001110111110010110101111000110100110100110001111000110001110110110111110110110101110001110000111001110100110110110001110111110111110001110001110010111000110110110101110111110100110110110011110110111000110111110101110000110010110101110001110010110001110011111001110011110001111001110110110100110001111000110011110001110111111000110001110001" ' Fibonacci
59. 'TheString = "11010000100101101011010111010110101110101000001101001011100000111001010001100000101100110000010111000100100101110100001101111001011011001100110101111100010010111100010010111111010001111110010011110000110011110011010011010101100001101010011110101001110001100011001110111110011111111101100001100000011000000101101100111100011010001011010101001010000101010011000010011011010110110111011110000001110010100010000000101111101011101111000101010001011111100100101000011001011001101111101100010111010100111001"
60. 'TheString = "110111001100010110010011101011100111010101100001100101011010101111110000111100010101110000010010110001" ' Wolfram 30
61. 'TheString = "001100000000001111111111111110110000000010111000000000111111111011111111100000000000110000000011111111110100011111100000000110110000110100111111111001101110100000000101000001100101110011111101001111000000000000000010000111001110011111111110111110000000000000000001100110001000011001011110000000000000000000000000000000000110101111100000000000000001100000000000000001111101111000000000000010000000000000011110111111111111000000000001100111110000111101111111111111100000000111110111110001111011111111111101110000000011111111000000000000000111111111111000000111100000000000000000000111110011110001010111100000110000000000000011110111110001111011110000000000010000000111100111111111111110000000000000110000001111001111100011111111110000000000000000000111111010110011111111110000000011000110000111110001010001111101111000000000011110001110110011010000110001111110000000111000011111000001010000111001111100000000000000111110011111001000000100111110011000000111111111111111111000000001111111111111111111111111111111000011000000100001110111111111111111111110100000000000111000111101111011111111111111000000000001111100111110000000011111111110000000100000001111011110000001111111111111110011010001111111111111000011111111111111110101101111111111011111001001111111111111" ' Chia
62. 'TheString = "1011001010010100100100110010101010101001010101010101011010010101001010101001010010100110101011010101010101011010101101010101010101010010110101010101100101010101010110101101011010010101010010100110101101001010110101011010010101101010110100101111010101010011011011010010110101010010110100101101010100101011010010101001010101010001011101011010010101011100111010010001101011110010011010001011100110101010010011010101001001010010000101010110001" ' loudar
63. 'TheString = "11111011110100101011111111110100000011011110101100111100111111110111101110100111100110011111110101111111010111101111100111110111111111111011100111110111111110010000101011111001110101101010110111110" ' Spriggs 2
64. 'TheString = "1010001101110110000000011100110100101010111110101001100101110100000111101011011000010101101100000110010010010101010110111111111001000100101011101000011110011000000100111100001100111000111100100000000111010011010011001111101000010011101111000011100011010110101101000111101111100101100100000101111011001101100000111011000001001111000110000001110101100101" ' Coalt legit
65. 'TheString = "01001111011010000010110000100000010010010010000001110111011011110110111001100100011001010111001000100000011010000110111101110111001000000110100101110100001000000111011101101001011011000110110000100000011001000110111100100000011101110110100101110100011010000010000001110011011101000111010101100110011001100010000001101100011010010110101101100101001000000110001101101111011011100111011001100101011100100111010001101001011011100110011100100000011011100110111101110010011011010110000101101100001000000111010001100101011110000111010000100000011101000110111100100000011000100110100101101110011000010111001001111001" ' Zach binary thing
66. 'TheString = "10111010101010101010101001010101010101001010101001010101010101010101010101010101010101010101010101010101001010100100100101010101010101001010100101010101010100101010100101010101010101010101001010010110010101010010101010101010101010101010100101001001001010101010101010101010101001010101001001101010010" ' Spriggs hand
67. 'TheString = "01100101001010001100001101101111011010010101010110110101001000001111001111110101000101111011010101111101010101101010101001010101011000010101010101001011010100110100110100110011010101010101110101010111111101011010100000001101111000010111000110111001000010100001101010110100000111101011111100001011001010110010110" ' Luke 50
68. 'TheString = "010101111010111100110000001001100100101100000101110001100101000010001001111101111111111100011110000011011110011000100011100100001101110011001001011001000011110010001000111100011100011110010110011110111010110100001000110000010000111000111011100110011010101111111100100010001111111100010100001011000011" 'Spriggs
69. 'TheString = "10101010101011101000011101010111010101010101100111001010100111100001011011110101000001111010101101010000001111110011111110111101110111001110110010000100010101010101010100101011010110101010101010101001000000001111110000011110101010101010100010101110101010101101111111111111111111101010101010101000000" ' 63
70. 'TheString = "11100101110011011010110100110011111011010110100100000110000100101001001010011100111101101110000001000000011011100101110000000111100100011101000000101000110100001000000001111010101011000010001110111110001001110101011000010101001111010100100000011100110110110000111010001010000011010000101111101011000" ' using RND function
71. 'TheString = "00101010001100101010010101010100101010010100101010010101010100100000101011110101001010010101010010000011101010100101010101001010010101010101010110101001010100101010101001010100101010100101010100101010101001010010101010010101010101010100101010101010101010101001010101010100101010101001010101001101010" ' 78
72. 'TheString = "11100101010011001001001010101001010000101001000010100010110111010101010011010100100100110101010010010110100101001001010010101010010010100101001010010100100101001001010010010110010010101010101001010101001010101010010101001001010101001010101010101010101010101010101010010101001010010100101001010101001" ' 68
73. 'TheString = "10101011100101100101010101010101010101010101010101010101010010011010100000000011111111111001011001101010101010110010101010101010101010101010100101100101010101010110011101011110101010101010101101101010101111010101100101001011010010101010101011010101001110101010111101110011010011001101001101011000101" ' 68
74. 'TheString = "10101101000110101000101010101010101010100101010101010100101110010101001001010100101010101001001010101001010000010010001010010010101010100110010101010101010101010110010101010010100101010010101010101001010101010101010010101010101010101010010101010101010101010101010010101001001010010100101010101010101" ' 76
75.  
76. For j = 1 To Len(TheString)
77.  
78.     Cls
79.     Locate 1, 1
80.     Print "Analyzing:"
81.     Print
82.     Print Left$(TheString, j) + "["; Right$(TheString, Len(TheString) - j); "]"
83.     Print
84.  
85.     ' Main prediction call
86.     predictedGuess = Analyze(Left$(TheString, j), 0)
87.  
88.     ' Reconciliation
89.     Print "Prediction: "; _Trim$(Str$(predictedGuess))
90.     Print "Actual:     "; _Trim$(Mid$(TheString, j + 1, 1))
91.     Print
92.     If (predictedGuess = Val(Mid$(TheString, j + 1, 1))) Then
93.         correctGuesses = correctGuesses + 1
94.         streakGuess = streakGuess + 1
95.         Print "I was right."
96.     Else
97.         streakGuess = 0
98.         Print "I was wrong."
99.     End If
100.     totalGuesses = totalGuesses + 1
101.     Print "I'm on a "; _Trim$(Str$(streakGuess)); "-game winning streak."
102.     Print "I have been correct on "; _Trim$(Str$(Int(100 * correctGuesses / totalGuesses))); "% of "; _Trim$(Str$(totalGuesses)); " guesses."
103.  
104.     ' Draw bottom graph
105.     f = (_Width - 1) / Int(Len(TheString))
106.     If (f > 1) Then f = 1 / f
107.     ProgressGraph(1 + Int(j * f)) = correctGuesses / totalGuesses
108.     For k = 1 To 1 + Int(j * (_Width - 1) / Int(Len(TheString)))
109.         Locate 25 - Int(10 * ProgressGraph(1 + Int(k * f))), k: Print "*"
110.     Next
111.  
112.     _Delay .015
113.     _Display
114. Next
115.  
116. End
117.  
118. Function Analyze (TheStringIn As String, pswitch As Integer)
119.     Dim TheReturn As Integer
120.     Dim As Integer n
121.     Dim As Double r, j, k, h
122.     Dim Fingerprint(16) As String
123.     Dim Partialguess(2 To 10, 2) As Double ' Change the upper bound to a higer number for more accuracy.
124.  
125.     ' Create shifted versions of string, i.e. ABCD -> BCDA, CDAB, DABC, ABCD, BCDA, etc.
126.     Fingerprint(1) = TheStringIn
127.     For n = 2 To UBound(Fingerprint)
128.         Fingerprint(n) = Right$(Fingerprint(n - 1), Len(Fingerprint(n - 1)) - 1) + Left$(Fingerprint(n - 1), 1)
129.     Next
130.  
131.     ' Initialize partial results.
132.     For n = LBound(Partialguess) To UBound(Partialguess)
133.         Partialguess(n, 1) = -999
134.     Next
135.  
136.     Call CreateHisto(Fingerprint(), Alphabet2(), 2)
137.     Call CreateHisto(Fingerprint(), Alphabet3(), 3)
138.     Call CreateHisto(Fingerprint(), Alphabet4(), 4)
139.     Call CreateHisto(Fingerprint(), Alphabet5(), 5)
140.     Call CreateHisto(Fingerprint(), Alphabet6(), 6)
141.     Call CreateHisto(Fingerprint(), Alphabet7(), 7)
142.     Call CreateHisto(Fingerprint(), Alphabet8(), 8)
143.     Call CreateHisto(Fingerprint(), Alphabet9(), 9)
144.     Call CreateHisto(Fingerprint(), Alphabet10(), 10)
145.     'Call CreateHisto(Fingerprint(), Alphabet11(), 11)
146.     'Call CreateHisto(Fingerprint(), Alphabet12(), 12)
147.     'Call CreateHisto(Fingerprint(), Alphabet13(), 13)
148.  
149.     If (pswitch = 1) Then
150.         For n = 1 To _Width
151.             Print "-";
152.         Next
153.         Print
154.     End If
155.  
156.     If (pswitch = 1) Then
157.         If (Len(TheStringIn) >= 2) Then Call PrintHisto(Alphabet2(), 3) ' Set the last number >=1 to print stats for that histogram.
158.         If (Len(TheStringIn) >= 3) Then Call PrintHisto(Alphabet3(), 3)
159.         If (Len(TheStringIn) >= 4) Then Call PrintHisto(Alphabet4(), 0)
160.         If (Len(TheStringIn) >= 5) Then Call PrintHisto(Alphabet5(), 0)
161.         If (Len(TheStringIn) >= 6) Then Call PrintHisto(Alphabet6(), 0)
162.         If (Len(TheStringIn) >= 7) Then Call PrintHisto(Alphabet7(), 0)
163.         If (Len(TheStringIn) >= 8) Then Call PrintHisto(Alphabet8(), 0)
164.         If (Len(TheStringIn) >= 9) Then Call PrintHisto(Alphabet9(), 0)
165.         If (Len(TheStringIn) >= 10) Then Call PrintHisto(Alphabet10(), 0)
166.         'If (Len(TheStringIn) >= 11) Then Call PrintHisto(Alphabet11(), 0)
167.         'If (Len(TheStringIn) >= 12) Then Call PrintHisto(Alphabet12(), 0)
168.         'If (Len(TheStringIn) >= 13) Then Call PrintHisto(Alphabet13(), 0)
169.         Print
170.     End If
171.  
172.     If (Len(TheStringIn) >= 2) Then Call MakeGuess(TheStringIn, Alphabet2(), 2, Partialguess(), pswitch) ' Set the last number =1 to print guess for that histogram.
173.     If (Len(TheStringIn) >= 3) Then Call MakeGuess(TheStringIn, Alphabet3(), 3, Partialguess(), pswitch)
174.     If (Len(TheStringIn) >= 4) Then Call MakeGuess(TheStringIn, Alphabet4(), 4, Partialguess(), 0)
175.     If (Len(TheStringIn) >= 5) Then Call MakeGuess(TheStringIn, Alphabet5(), 5, Partialguess(), 0)
176.     If (Len(TheStringIn) >= 6) Then Call MakeGuess(TheStringIn, Alphabet6(), 6, Partialguess(), 0)
177.     If (Len(TheStringIn) >= 7) Then Call MakeGuess(TheStringIn, Alphabet7(), 7, Partialguess(), 0)
178.     If (Len(TheStringIn) >= 8) Then Call MakeGuess(TheStringIn, Alphabet8(), 8, Partialguess(), 0)
179.     If (Len(TheStringIn) >= 9) Then Call MakeGuess(TheStringIn, Alphabet9(), 9, Partialguess(), 0)
180.     If (Len(TheStringIn) >= 10) Then Call MakeGuess(TheStringIn, Alphabet10(), 10, Partialguess(), 0)
181.     'If (Len(TheStringIn) >= 11) Then Call MakeGuess(TheStringIn, Alphabet11(), 11, Partialguess(), 0)
182.     'If (Len(TheStringIn) >= 12) Then Call MakeGuess(TheStringIn, Alphabet12(), 12, Partialguess(), 0)
183.     'If (Len(TheStringIn) >= 13) Then Call MakeGuess(TheStringIn, Alphabet13(), 13, Partialguess(), 0)
184.     If (pswitch = 1) Then Print
185.  
186.     If (pswitch = 1) Then
187.         Print "Analyzing:"
188.         Print TheStringIn
189.  
190.         Print
191.         Print "Thinking:";
192.         For k = LBound(Partialguess) To UBound(Partialguess)
193.             If (Partialguess(k, 1) <> -999) Then
194.                 Print Partialguess(k, 1);
195.             Else
196.                 Print "_ ";
197.             End If
198.         Next
199.         Print
200.     End If
201.  
202.     j = 0
203.     r = 0
204.  
205.     For k = UBound(Partialguess) To LBound(Partialguess) Step -1
206.         If (Partialguess(k, 1) <> -999) Then
207.  
208.             ' This is the made-up part of the model:
209.             ' The variable r contributes to weighted average.
210.             ' The variable j is used for normalization.
211.             ' Scaling factor h influences weighted average calculaton.
212.             ' The factors multiplying h are totally arbitrary. Notes:
213.             '   setting o(h^2) means the later alphabets count for more.
214.             '   Partialguess(k, 1) euqals the calculated guess at frequency k.
215.             '   Partialguess(k, 2) euqals the peak count of the unscaled histogram.
216.             '   ...while Partialguess(k, 2) is here, it does not seem to help calculations.
217.  
218.             h = 1 + k - LBound(Partialguess)
219.  
220.             h = h ^ 2
221.  
222.             ' Standard weighted average:
223.             r = r + h * Partialguess(k, 1)
224.             j = j + h
225.  
226.         End If
227.     Next
228.     If (j <> 0) Then
229.         r = r / j
230.     End If
231.  
232.     If (pswitch = 1) Then Print "Predicting:  "; _Trim$(Str$(r))
233.  
234.     If (r > .5) Then
235.         r = 1
236.     Else
237.         r = 0
238.     End If
239.  
240.     If (pswitch = 1) Then
241.         Print "Rounding to: "; _Trim$(Str$(r))
242.     End If
243.  
244.     TheReturn = r
245.     Analyze = TheReturn
246. End Function
247.  
248. Sub MakeGuess (TheStringIn As String, arralpha() As LetterBin, wid As Integer, arrbeta() As Double, pswitch As Integer)
249.     Dim TheReturn As Double
250.     Dim As Integer j, k, n
251.     TheReturn = 0
252.     j = 1 '0
253.     k = 0
254.     For n = 1 To UBound(arralpha)
255.         If (Left$(arralpha(n).Signature, wid - 1) = Right$(TheStringIn, wid - 1)) Then
256.             If (arralpha(n).Count >= j) Then
257.                 If (pswitch = 1) Then Print "Order-"; Right$("0" + _Trim$(Str$(wid)), 2); " guess: "; arralpha(n).Signature; " . "; _Trim$(Str$(arralpha(n).Count))
258.                 TheReturn = TheReturn + Val(Right$(arralpha(n).Signature, 1))
259.                 k = k + 1
260.                 j = arralpha(n).Count
261.             End If
262.         End If
263.     Next
264.     If (k <> 0) Then
265.         TheReturn = TheReturn / k
266.         arrbeta(wid, 1) = TheReturn
267.         arrbeta(wid, 2) = j
268.     Else
269.         TheReturn = .5
270.         arrbeta(wid, 1) = TheReturn
271.         arrbeta(wid, 2) = j
272.     End If
273. End Sub
274.  
275. Sub CreateHisto (arrfinger() As String, arralpha() As LetterBin, w As Integer)
276.     Dim As Integer j, k, n
277.     For n = 1 To UBound(arralpha)
278.         arralpha(n).Count = 0
279.     Next
280.     For j = 1 To w
281.         For k = 1 To Len(arrfinger(j)) - (Len(arrfinger(j)) Mod w) Step w '- 0 Step 1 'w 'make the 0 a -w? might not matter at all
282.             For n = 1 To UBound(arralpha)
283.                 If (Mid$(arrfinger(j), k, w) = arralpha(n).Signature) Then
284.                     arralpha(n).Count = arralpha(n).Count + 1
285.                 End If
286.             Next
287.         Next
288.     Next
289.     Call QuickSort(arralpha(), 1, UBound(arralpha))
290. End Sub
291.  
292. Sub PrintHisto (arr() As LetterBin, w As Integer)
293.     Dim As Integer j, n
294.     If (w > 0) Then
295.         If (w > UBound(arr)) Then
296.             j = UBound(arr)
297.         Else
298.             j = w
299.         End If
300.         Print "Histogram: "; _Trim$(Str$(UBound(arr))); "-letter regroup, showing top "; _Trim$(Str$(w))
301.         For n = 1 To j
302.             Print arr(n).Signature; arr(n).Count
303.         Next
304.     End If
305. End Sub
306.  
307. Sub NewAlphabet (arrold() As LetterBin, arrnew() As LetterBin)
308.     Dim As Integer j, k, n
309.     n = 0
310.     For k = 1 To 2
311.         For j = 1 To UBound(arrold)
312.             n = n + 1
313.             arrnew(n).Signature = arrold(j).Signature
314.         Next
315.     Next
316.     For j = 1 To UBound(arrnew)
317.         If (j <= UBound(arrnew) / 2) Then
318.             arrnew(j).Signature = "0" + arrnew(j).Signature
319.         Else
320.             arrnew(j).Signature = "1" + arrnew(j).Signature
321.         End If
322.     Next
323. End Sub
324.  
325. Sub QuickSort (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
326.     Dim As Long piv
327.     If (LowLimit < HighLimit) Then
328.         piv = Partition(arr(), LowLimit, HighLimit)
329.         Call QuickSort(arr(), LowLimit, piv - 1)
330.         Call QuickSort(arr(), piv + 1, HighLimit)
331.     End If
332. End Sub
333.  
334. Function Partition (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
335.     Dim As Long i, j
336.     Dim As Double pivot, tmp
337.     pivot = arr(HighLimit).Count
338.     i = LowLimit - 1
339.     For j = LowLimit To HighLimit - 1
340.         tmp = arr(j).Count - pivot
341.         If (tmp >= 0) Then
342.             i = i + 1
343.             Swap arr(i), arr(j)
344.         End If
345.     Next
346.     Swap arr(i + 1), arr(HighLimit)
347.     Partition = i + 1
348. End Function
349.  

Alright, so the rest can be explained in the screenshot.

  [ This attachment cannot be displayed inline in 'Print Page' view ]  

The fake little "graph" made of asterisks is designed to trace across the screen exactly like a progress indicator. It moves along linearly, doesn't jump around, and has only one speed. (It won't do that microsoft thing where 99% takes a month to complete.) The lines of code that are responsible for this graph are highlighted, and you can basically ignore the y-value in it. Hope that helps!

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 15, 2021, 04:24:15 pm

Wow, 100 times more productive.  I should have some time tomorrow to update my end.

Many thanks for everything.

R1   

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 15, 2021, 04:36:03 pm

Ran a quick test using real data, amazing!!!
R1.

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 15, 2021, 04:41:22 pm

Glad it's looking better and better r1!

It's still evolving little by little: today I re-included the order-1 alphabets (so literally just 0 and 1) and this thing's putting game improved yet again. I also improved a few things about how it looks, and it also reports on its best streak now too, cause why not? Anyway, here's the latest and greatest:

Code: QB64: [Select]

1. Option _Explicit
2.  
3. Screen _NewImage(120, 40)
4.  
5. ' Version: 13
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. Dim TheString As String
43.  
44. Dim As Integer j, k
45. Dim As Double f, g
46. Dim predictedGuess As Integer
47. Dim correctGuesses As Double
48. Dim totalGuesses As Double
49. Dim streakGuess As Integer
50. Dim streakBest As Integer
51.  
52. Dim ProgressGraph(1 To _Width) As Double
53.  
54. '''
55. ' Systematic cases:
56. '''
57. '                                                                                                                                         Score / Ending
58. '                                                                                                                                                 Streak:
59. '                                                                                                                                         ---------------
60. 'TheString = "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" ' (100% / 119)
61. 'TheString = "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" ' (100% / 119)
62. 'TheString = "010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101" ' (96%  / 112)
63. 'TheString = "101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010" ' (96%  / 112)
64. 'TheString = "001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001" ' (96%  / 108)
65. 'TheString = "010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010" ' (96%  / 109)
66. 'TheString = "100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100100" ' (93%  / 108)
67. 'TheString = "110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110110" ' (96%  / 108)
68. 'TheString = "101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101101" ' (96%  / 109)
69. 'TheString = "011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011011" ' (93%  / 108)
70. '
71. '''
72. ' Community hand-typed cases:
73. '''
74. '            (from Cobalt) (Results in: 48%  -  Claims he made this data hand but behavior in Discord raises doubt.)
75. 'TheString = "1010001101110110000000011100110100101010111110101001100101110100000111101011011000010101101100000110010010010101010110111111111001000100101011101000011110011000000100111100001100111000111100100000000111010011010011001111101000010011101111000011100011010110101101000111101111100101100100000101111011001101100000111011000001001111000110000001110101100101"
76. '            (from Loudar) (Results in: 71%)
77. 'TheString = "1011001010010100100100110010101010101001010101010101011010010101001010101001010010100110101011010101010101011010101101010101010101010010110101010101100101010101010110101101011010010101010010100110101101001010110101011010010101101010110100101111010101010011011011010010110101010010110100101101010100101011010010101001010101010001011101011010010101011100111010010001101011110010011010001011100110101010010011010101001001010010000101010110001"
78. '            (from Luke) (Results in: 51%  -  I have long suspected Luke to be a computer. The numbers are now in.)
79. 'TheString = "01100101001010001100001101101111011010010101010110110101001000001111001111110101000101111011010101111101010101101010101001010101011000010101010101001011010100110100110100110011010101010101110101010111111101011010100000001101111000010111000110111001000010100001101010110100000111101011111100001011001010110010110" ' Luke 50
80. '            (from Sarafromct) (Results in: 64%)
81. 'TheString = "10101010101011101000011101010111010101010101100111001010100111100001011011110101000001111010101101010000001111110011111110111101110111001110110010000100010101010101010100101011010110101010101010101001000000001111110000011110101010101010100010101110101010101101111111111111111111101010101010101000000" ' 63
82. '            (from Spriggs) (Results in: 85%)
83. TheString = "10111010101010101010101001010101010101001010101001010101010101010101010101010101010101010101010101010101001010100100100101010101010101001010100101010101010100101010100101010101010101010101001010010110010101010010101010101010101010101010100101001001001010101010101010101010101001010101001001101010010"
84. '            (from Spriggs) (Results in: 67%)
85. 'TheString = "11111011110100101011111111110100000011011110101100111100111111110111101110100111100110011111110101111111010111101111100111110111111111111011100111110111111110010000101011111001110101101010110111110"
86. '            (from Hotpants) (Results in: 62%)
87. 'TheString = "01010100011001010010101010101010101000110101010111101010100100011010101010100100101110010010010100001010101001010101010110010001001011000100100110101001001001010000000001010101101111101001010100010101001001010101000100101001100100010011010101010101010111010010101011101011011010110100100010010100100100010010001001" ' Tom
88. '
89. '''
90. ' Known-Random cases:
91. '''
92. '            (using RND) (Results in: 45%)
93. 'TheString = "11100101110011011010110100110011111011010110100100000110000100101001001010011100111101101110000001000000011011100101110000000111100100011101000000101000110100001000000001111010101011000010001110111110001001110101011000010101001111010100100000011100110110110000111010001010000011010000101111101011000"
94. '            (from Spriggs) (Results in: 52%)
95. 'TheString = "010101111010111100110000001001100100101100000101110001100101000010001001111101111111111100011110000011011110011000100011100100001101110011001001011001000011110010001000111100011100011110010110011110111010110100001000110000010000111000111011100110011010101111111100100010001111111100010100001011000011"
96. '            (Wolfrm rule 30, central column) (Results in: 47%)
97. 'TheString = "110111001100010110010011101011100111010101100001100101011010101111110000111100010101110000010010110001"
98. '            (using RND) (Results in: 46%)
99. 'TheString = "111001011100110110101101001100111110110101101001000001100001001010010010100111001111011011100000010000000110111001011100000001111001000111010000001010001101000010000000011110101010110000100011101111100010011101010110000101010011110101001000000111001101101100001110100010100000110100001011111010110000"
100. '            (using RND) (Results in: 46%)
101. 'TheString = "111001011100110110101101001100111110110101101001000001100001001010010010100111001111011011100000010000000110111001011100000001111001000111010000001010001101000010000000011110101010110000100011101111100010011101010110000101010011110101001000000111001101101100001110100010100000110100001011111010110000101110111110011100001000110010010001100111101000001101011000010101101011111010010001010010110110011000001001101000011100000011110001110011100010101010111101100100100001001000101101110110101100001111011101000100111110000001110000111011101000110110100111101101001100100110000111110111101001100010011110"
102. '            (using RND) (Results in: 45%)
103. 'TheString = "111001011100110110101101001100111110110101101001000001100001001010010010100111001111011011100000010000000110111001011100000001111001000111010000001010001101000010000000011110101010110000100011101111100010011101010110000101010011110101001000000111001101101100001110100010100000110100001011111010110000101110111110011100001000110010010001100111101000001101011000010101101011111010010001010010110110011000001001101000011100000011110001110011100010101010111101100100100001001000101101110110101100001111011101000100111110000001110000111011101000110110100111101101001100100110000111110111101001100010011110111001001100111000110011011000100101100010101010000010000111111010111111011100011100001000011000100100111001100001111010001010000001011100000101110000110010111110010101010110111110011100100001011101010000011011110110100010110111000100000110000001001010001011010000010001111110100100010011100011001000"
104. '            (using RND) (Results in: 48%)
105. 'TheString = "111001011100110110101101001100111110110101101001000001100001001010010010100111001111011011100000010000000110111001011100000001111001000111010000001010001101000010000000011110101010110000100011101111100010011101010110000101010011110101001000000111001101101100001110100010100000110100001011111010110000101110111110011100001000110010010001100111101000001101011000010101101011111010010001010010110110011000001001101000011100000011110001110011100010101010111101100100100001001000101101110110101100001111011101000100111110000001110000111011101000110110100111101101001100100110000111110111101001100010011110111001001100111000110011011000100101100010101010000010000111111010111111011100011100001000011000100100111001100001111010001010000001011100000101110000110010111110010101010110111110011100100001011101010000011011110110100010110111000100000110000001001010001011010000010001111110100100010011100011001000011101011010100110110000110010010011110111001001011111011000000100010011011100111110111011111101100011011101001111110100011010000111001001010111011101000001010010010100111010001001010101001000010011100111010101000110010110101111001110000010110110010101001000011000101000001100110100111101000110111101101010011011000101100101001010001100110101000101110000101100110010011010001010101010101101110101110110101100101001111100110110101011001000001100101001011000101100001001000001010111010100010100101011001111001011011100011001110010111011110010111101011101000100100010111010000001010011101010001110110110101011000101010100000001110110101011110101111100100101101000001011000101001110010010010000111001101010100101111101001110010001011000001001000111010001000011000111000000111001110111110011110110101100111011001100101101010101100010100100001010010110010000001100110010010100110011110110000001001000111001001010010000011111110011110010001100011100011010000111100111111010010001010011100100111100111101111110101000010011100011111100010000011111101101010010100000011011001110001100001011111100111000001110111011001111110011011100111000110110110011110000111000010011011000011001111111110010100000111110011111100100001100000000110001111101101011100011111011110001100100001100011100011111000000110011011100110101101001001111101101000000110101101001100011100011001110001000000111111100110101001110100010010010100000010100001010001011011001101010011111001101110110010101000111101100111000011000111001100011011011010100111111001100000100100110000100101001111111100110010111100000111101101001111001010011010011011100101001001001110101110001101010001111010101100101010111000111000011000001010010010101010100001110010001001001110110011100110011111001100111010011110100100110010000100011010001110000000100001100000010000111000111111000111100010001101011000101000010100011100011111000100010101000001001011001000101101111110111110110001101001001011100011110001101100010100101101011001001100111000000111111110110100010111111101000000001111000100001111111011000101001111110010000110101100010000011100110111101011011100110"
106.  
107.  
108.  
109.  
110. 'Cls
111. 'Locate 1, 1
112. 'Print " Press 0 or 1 as randomly as you can. The longer the string, the better."
113. 'Input "", TheString
114.  
115.  
116.  
117.  
118.  
119. For j = 1 To Len(TheString)
120.  
121.     Cls
122.     Locate 1, 1
123.     For k = 1 To _Width
124.         Print "_";
125.     Next
126.     Print
127.     Print "Analyzing: (string length "; _Trim$(Str$(Len(TheString))); ")"
128.     Print
129.     Color 7
130.     Print Left$(TheString, j);
131.     Color 8
132.     Print "["; Right$(TheString, Len(TheString) - j); "]"
133.     Color 7
134.     Print
135.  
136.     ' Main prediction call
137.     predictedGuess = Analyze(Left$(TheString, j), 0)
138.  
139.     ' Reconciliation
140.     Print "Prediction: "; _Trim$(Str$(predictedGuess))
141.     If (j < Len(TheString)) Then
142.         Print "Actual:     "; _Trim$(Mid$(TheString, j + 1, 1))
143.         If (predictedGuess = Val(Mid$(TheString, j + 1, 1))) Then
144.             correctGuesses = correctGuesses + 1
145.             streakGuess = streakGuess + 1
146.             If (streakGuess > streakBest) Then streakBest = streakGuess
147.             Print "I am RIGHT this round."
148.         Else
149.             streakGuess = 0
150.             Print "I am WRONG this round."
151.         End If
152.         totalGuesses = totalGuesses + 1
153.     Else
154.         Print "Actual:     ?"
155.     End If
156.     Print
157.     Print "I'm on a "; _Trim$(Str$(streakGuess)); "-round winning streak."
158.     Print "My best streak has been "; _Trim$(Str$(streakBest)); "."
159.     Print "My correctness rate is "; _Trim$(Str$(Int(100 * correctGuesses / totalGuesses))); "% in "; _Trim$(Str$(totalGuesses)); " guesses."
160.     If (j = Len(TheString)) Then
161.         Print
162.         Print "Complete."
163.     End If
164.  
165.     ' Draw bottom graph
166.     If (1 = 1) Then
167.         For k = 1 To _Width
168.             Locate _Height - 5, k: Print "_"
169.             Locate _Height - 5 - Int(10), k: Print "_"
170.         Next
171.         Locate _Height - 5 + 1, 1: Print "0%"
172.         Locate _Height - 5 - Int(10) - 1, 1: Print "100%"
173.         f = (_Width - 1) / Int(Len(TheString))
174.         If (f > 1) Then f = 1 / f
175.         ProgressGraph(1 + Int(j * f)) = correctGuesses / totalGuesses
176.         g = (_Width - 0) / Int(Len(TheString))
177.         If (g > 1) Then g = 1
178.         For k = 1 To Int(j * g)
179.             Locate _Height - 5 - Int(10 * ProgressGraph(1 + Int(k * f))), k: Print "*"
180.         Next
181.     End If
182.  
183.     _Delay .015
184.     _Display
185. Next
186.  
187. End
188.  
189. Function Analyze (TheStringIn As String, pswitch As Integer)
190.     Dim TheReturn As Integer
191.     Dim As Integer n
192.     Dim As Double r, j, k, h
193.     Dim Fingerprint(16) As String
194.     Dim Partialguess(1 To 10, 2) As Double ' Change the upper bound to a higer number for more accuracy.
195.  
196.     ' Create shifted versions of string, i.e. ABCD -> BCDA, CDAB, DABC, ABCD, BCDA, etc.
197.     Fingerprint(1) = TheStringIn
198.     For n = 2 To UBound(Fingerprint)
199.         Fingerprint(n) = Right$(Fingerprint(n - 1), Len(Fingerprint(n - 1)) - 1) + Left$(Fingerprint(n - 1), 1)
200.     Next
201.  
202.     ' Initialize partial results.
203.     For n = LBound(Partialguess) To UBound(Partialguess)
204.         Partialguess(n, 1) = -999
205.     Next
206.  
207.     Call CreateHisto(Fingerprint(), Alphabet1(), 1)
208.     Call CreateHisto(Fingerprint(), Alphabet2(), 2)
209.     Call CreateHisto(Fingerprint(), Alphabet3(), 3)
210.     Call CreateHisto(Fingerprint(), Alphabet4(), 4)
211.     Call CreateHisto(Fingerprint(), Alphabet5(), 5)
212.     Call CreateHisto(Fingerprint(), Alphabet6(), 6)
213.     Call CreateHisto(Fingerprint(), Alphabet7(), 7)
214.     Call CreateHisto(Fingerprint(), Alphabet8(), 8)
215.     Call CreateHisto(Fingerprint(), Alphabet9(), 9)
216.     Call CreateHisto(Fingerprint(), Alphabet10(), 10)
217.     'Call CreateHisto(Fingerprint(), Alphabet11(), 11)
218.     'Call CreateHisto(Fingerprint(), Alphabet12(), 12)
219.     'Call CreateHisto(Fingerprint(), Alphabet13(), 13)
220.  
221.     If (pswitch = 1) Then
222.         For n = 1 To _Width
223.             Print "-";
224.         Next
225.         Print
226.     End If
227.  
228.     If (pswitch = 1) Then ' Set the last number >=1 to print stats for that histogram.
229.         If (Len(TheStringIn) >= 1) Then Call PrintHisto(Alphabet1(), 2)
230.         If (Len(TheStringIn) >= 2) Then Call PrintHisto(Alphabet2(), 3)
231.         If (Len(TheStringIn) >= 3) Then Call PrintHisto(Alphabet3(), 3)
232.         If (Len(TheStringIn) >= 4) Then Call PrintHisto(Alphabet4(), 0)
233.         If (Len(TheStringIn) >= 5) Then Call PrintHisto(Alphabet5(), 0)
234.         If (Len(TheStringIn) >= 6) Then Call PrintHisto(Alphabet6(), 0)
235.         If (Len(TheStringIn) >= 7) Then Call PrintHisto(Alphabet7(), 0)
236.         If (Len(TheStringIn) >= 8) Then Call PrintHisto(Alphabet8(), 0)
237.         If (Len(TheStringIn) >= 9) Then Call PrintHisto(Alphabet9(), 0)
238.         If (Len(TheStringIn) >= 10) Then Call PrintHisto(Alphabet10(), 0)
239.         'If (Len(TheStringIn) >= 11) Then Call PrintHisto(Alphabet11(), 0)
240.         'If (Len(TheStringIn) >= 12) Then Call PrintHisto(Alphabet12(), 0)
241.         'If (Len(TheStringIn) >= 13) Then Call PrintHisto(Alphabet13(), 0)
242.         Print
243.     End If
244.  
245.     If (Len(TheStringIn) >= 1) Then Call MakeGuess(TheStringIn, Alphabet1(), 1, Partialguess(), pswitch)
246.     If (Len(TheStringIn) >= 2) Then Call MakeGuess(TheStringIn, Alphabet2(), 2, Partialguess(), pswitch) ' Set the last number =1 to print guess for that histogram.
247.     If (Len(TheStringIn) >= 3) Then Call MakeGuess(TheStringIn, Alphabet3(), 3, Partialguess(), pswitch)
248.     If (Len(TheStringIn) >= 4) Then Call MakeGuess(TheStringIn, Alphabet4(), 4, Partialguess(), 0)
249.     If (Len(TheStringIn) >= 5) Then Call MakeGuess(TheStringIn, Alphabet5(), 5, Partialguess(), 0)
250.     If (Len(TheStringIn) >= 6) Then Call MakeGuess(TheStringIn, Alphabet6(), 6, Partialguess(), 0)
251.     If (Len(TheStringIn) >= 7) Then Call MakeGuess(TheStringIn, Alphabet7(), 7, Partialguess(), 0)
252.     If (Len(TheStringIn) >= 8) Then Call MakeGuess(TheStringIn, Alphabet8(), 8, Partialguess(), 0)
253.     If (Len(TheStringIn) >= 9) Then Call MakeGuess(TheStringIn, Alphabet9(), 9, Partialguess(), 0)
254.     If (Len(TheStringIn) >= 10) Then Call MakeGuess(TheStringIn, Alphabet10(), 10, Partialguess(), 0)
255.     'If (Len(TheStringIn) >= 11) Then Call MakeGuess(TheStringIn, Alphabet11(), 11, Partialguess(), 0)
256.     'If (Len(TheStringIn) >= 12) Then Call MakeGuess(TheStringIn, Alphabet12(), 12, Partialguess(), 0)
257.     'If (Len(TheStringIn) >= 13) Then Call MakeGuess(TheStringIn, Alphabet13(), 13, Partialguess(), 0)
258.     If (pswitch = 1) Then Print
259.  
260.     If (pswitch = 1) Then
261.         Print "Thinking:";
262.         For k = LBound(Partialguess) To UBound(Partialguess)
263.             If (Partialguess(k, 1) <> -999) Then
264.                 Print Partialguess(k, 1);
265.             Else
266.                 Print "_ ";
267.             End If
268.         Next
269.         Print
270.     End If
271.  
272.     j = 0
273.     r = 0
274.  
275.     For k = UBound(Partialguess) To LBound(Partialguess) Step -1
276.         If (Partialguess(k, 1) <> -999) Then
277.  
278.             ' This is the made-up part of the model:
279.             ' The variable r contributes to weighted average.
280.             ' The variable j is used for normalization.
281.             ' Scaling factor h influences weighted average calculaton.
282.             ' The factors multiplying h are totally arbitrary. Notes:
283.             '   setting o(h^2) means the later alphabets count for more.
284.             '   Partialguess(k, 1) euqals the calculated guess at frequency k.
285.             '   Partialguess(k, 2) euqals the peak count of the unscaled histogram.
286.             '   ...while Partialguess(k, 2) is here, it does not seem to help calculations.
287.  
288.             h = 1 + k - LBound(Partialguess)
289.  
290.             h = h ^ 2
291.  
292.             ' Standard weighted average:
293.             r = r + h * Partialguess(k, 1)
294.             j = j + h
295.  
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: Print
319.     End If
320.  
321.     TheReturn = r
322.     Analyze = TheReturn
323. End Function
324.  
325. Sub MakeGuess (TheStringIn As String, arralpha() As LetterBin, wid As Integer, arrbeta() As Double, pswitch As Integer)
326.     Dim TheReturn As Double
327.     Dim As Integer j, k, n
328.     TheReturn = 0
329.     j = 1 '0
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.         arrbeta(wid, 1) = TheReturn
344.         arrbeta(wid, 2) = j
345.     Else
346.         TheReturn = .5
347.         arrbeta(wid, 1) = TheReturn
348.         arrbeta(wid, 2) = j
349.     End If
350. End Sub
351.  
352. Sub CreateHisto (arrfinger() As String, arralpha() As LetterBin, w As Integer)
353.     Dim As Integer j, k, n
354.     For n = 1 To UBound(arralpha)
355.         arralpha(n).Count = 0
356.     Next
357.     For j = 1 To w
358.         For k = 1 To Len(arrfinger(j)) - (Len(arrfinger(j)) Mod w) Step w '- 0 Step 1 'w 'make the 0 a -w? might not matter at all
359.             For n = 1 To UBound(arralpha)
360.                 If (Mid$(arrfinger(j), k, w) = arralpha(n).Signature) Then
361.                     arralpha(n).Count = arralpha(n).Count + 1
362.                 End If
363.             Next
364.         Next
365.     Next
366.     Call QuickSort(arralpha(), 1, UBound(arralpha))
367. End Sub
368.  
369. Sub PrintHisto (arr() As LetterBin, w As Integer)
370.     Dim As Integer j, n
371.     If (w > 0) Then
372.         If (w > UBound(arr)) Then
373.             j = UBound(arr)
374.         Else
375.             j = w
376.         End If
377.         Print "Histogram: "; _Trim$(Str$(UBound(arr))); "-letter regroup, showing top "; _Trim$(Str$(w))
378.         For n = 1 To j
379.             Print arr(n).Signature; arr(n).Count
380.         Next
381.     End If
382. End Sub
383.  
384. Sub NewAlphabet (arrold() As LetterBin, arrnew() As LetterBin)
385.     Dim As Integer j, k, n
386.     n = 0
387.     For k = 1 To 2
388.         For j = 1 To UBound(arrold)
389.             n = n + 1
390.             arrnew(n).Signature = arrold(j).Signature
391.         Next
392.     Next
393.     For j = 1 To UBound(arrnew)
394.         If (j <= UBound(arrnew) / 2) Then
395.             arrnew(j).Signature = "0" + arrnew(j).Signature
396.         Else
397.             arrnew(j).Signature = "1" + arrnew(j).Signature
398.         End If
399.     Next
400. End Sub
401.  
402. Sub QuickSort (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
403.     Dim As Long piv
404.     If (LowLimit < HighLimit) Then
405.         piv = Partition(arr(), LowLimit, HighLimit)
406.         Call QuickSort(arr(), LowLimit, piv - 1)
407.         Call QuickSort(arr(), piv + 1, HighLimit)
408.     End If
409. End Sub
410.  
411. Function Partition (arr() As LetterBin, LowLimit As Long, HighLimit As Long)
412.     Dim As Long i, j
413.     Dim As Double pivot, tmp
414.     pivot = arr(HighLimit).Count
415.     i = LowLimit - 1
416.     For j = LowLimit To HighLimit - 1
417.         tmp = arr(j).Count - pivot
418.         If (tmp >= 0) Then
419.             i = i + 1
420.             Swap arr(i), arr(j)
421.         End If
422.     Next
423.     Swap arr(i + 1), arr(HighLimit)
424.     Partition = i + 1
425. End Function
426.  

Looks like this now while running:

  [ This attachment cannot be displayed inline in 'Print Page' view ]  

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 15, 2021, 07:16:07 pm

If it gets any better the possibilities will expand exponentially.  I think it's has already
surpassed my expectations but more is better. 

Your quickly becoming my best new friend, LOL.  Can't wait for future improvements.

R1

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 15, 2021, 08:10:15 pm

I am going to add stats for each prediction be it a 0 or 1.  This way I can track the
percentages of correct predictions for each value.

Also in my main program, if a string contains all 0's or all 1's then it skips the predictor
stage and uses the digit that makes up the entire string as the prediction.  Nothing to be
gained by processing a string if there's only one choice.

I have ran several strings that I consider the hardest to predict and while the overall is
lower, high 60's to low 70's, the streaks seem to increase in size. 

R1     


     

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 15, 2021, 08:29:46 pm

Hey r1,

I have made such a weird discovery, I don't even know its implications yet, but follow me for a minute.

* Suppose I have a string that starts just as a "1". To be definite, call this x$. So x$ = "1".
* Next I feed this through the analyzer, and the analyzer tells me that another "1" is most likely to come next. Ok, so at this stage, lets do the *opposite*.
* Append x$ with a "0", having predicted a 1. So x$ = "10" now.
* Feed this new x$ through the analyzer, and it predicts a "1" should follow the "10". But we're doing the opposite, so I append x$ = "100".

See what I'm doing? Start with a seed, and whatever the predictor says, make a string that's the opposite of whats predicted. The result is hilarious. You wind up with a thing I'll call a "pathological string", where all predictions are WRONG by definition. Look at this result!

  [ This attachment cannot be displayed inline in 'Print Page' view ]  

It's flat zeros! Don't do any fretting though, we're out on impossible limb. For real data to behave this way randomly would take longer than the age of the universe. Or, put another way, some system that feeds you such data would be indistinguishable, in that moment, from the program you're looking at now. (Weird.) It turns out I can generate probably infinite of these "pathological strings". But it gets even more interesting. Change even a single digit, such as the first digit, and everything downstream of that shatters like glass, and its back to a usual-looking pattern. Here is the same sequence minus the first character:

  [ This attachment cannot be displayed inline in 'Print Page' view ]  

Even though the entire string is meant to "trick" the analyzer, the entire string needs to be intact for the trick to happen. That's super interesting. There is nothing fundamental about the so-called pathological string, I mean in terms of their contents. They are strictly dependent on the model being used, and that is buried in my Analyze function. Their existence will always persist though, regardless of the model. There's got to be some kind of theorem about this... Anyway, thought you'd find this academically interesting. Has very little bearing on the task at hand, but here are what some more patholgical strings look like:

Code: QB64: [Select]

1.     '''
2.     ' Pathological cases:
3.     '''
4.     n = n + 1: TestData(n) = "011111101111111110101111110011111110110111110111011110111001110111010110111101001111101010111110010111100110111011010110" ' seed 0
5.     n = n + 1: TestData(n) = "100000010000000001010000001100000001001000001000100001000110001000101001000010110000010101000001101000011001000100101001" ' seed 1
6.     n = n + 1: TestData(n) = "001111111110111111101011111100111110111011110110111110101011110111100110111111000111111110010111110011101110101101110010" ' seed 00
7.     n = n + 1: TestData(n) = "011111101111111110101111110011111110110111110111011110111001110111010110111101001111101010111110010111100110111011010110" ' seed 01
8.     n = n + 1: TestData(n) = "100000010000000001010000001100000001001000001000100001000110001000101001000010110000010101000001101000011001000100101001" ' seed 10
9.     n = n + 1: TestData(n) = "110000000001000000010100000011000001000100001001000001010100001000011001000000111000000001101000001100010001010010001101" ' seed 11
10.     n = n + 1: TestData(n) = "000111111111011111101101111101011111110011111110101011101110110110101110011101111011101010011110110011111011110011011110" ' seed 000
11.     n = n + 1: TestData(n) = "001111111110111111101011111100111110111011110110111110101011110111100110111111000111111110010111110011101110101101110010" ' seed 001
12.     n = n + 1: TestData(n) = "010111111111011111101101111101011110111011110101011111100111111110010111110111001110111110001111110100111110101101110100" ' seed 010
13.     n = n + 1: TestData(n) = "011111101111111110101111110011111110110111110111011110111001110111010110111101001111101010111110010111100110111011010110" ' seed 011
14.     n = n + 1: TestData(n) = "100000010000000001010000001100000001001000001000100001000110001000101001000010110000010101000001101000011001000100101001" ' seed 100
15.     n = n + 1: TestData(n) = "101000000000100000010010000010100001000100001010100000011000000001101000001000110001000001110000001011000001010010001011" ' seed 101

And those are sensitive - change one thing and the graph explodes like you're taking apart a wristwatch. Full code below:

Code: QB64: [Select]

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

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 15, 2021, 11:05:15 pm

STxAxTIC

I haven't tested but one string in this manner but the 1 to 0 prediction ratio is 1 in 17.52.
The predictor predicted (0) 473 times vs only 27 (1's) in a string of 500 entries. 

I then looked at the full string of 1422 entries and it shows the overall counts are 916 zeros
vs 506 ones.  This gives us a ratio of 1 in 2.81 for the full string. 

The full string shows (0) makes up 64.4% of the data while (1) makes up 35.5%.  Next I will
test the number predicted (1) guesses to see how many of those were correct.

We might need to step back and reevaluate a few things.

R1

 
     

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 15, 2021, 11:14:31 pm

Deep breath r1,

The eval core hasn't changed in quite a while, and when it does, all of my metrics improve. Can you paste in a string you find "interesting" so I can do my own analysis?

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 16, 2021, 07:26:13 am

STxAxTIC

Here is the string I am using, it's a update of a earlier posted string. Difficultly rating = 7
 
00101000111101101011000010000100001100110110100001100001100000000010011001000101000010001000000111011100000100000000010111010110000000010001110010110111000001011010111100101101010000011101110011010000110010011101011111000001000011001000000010011110011000000010101010011100100000010100010010111100100100100001000010011001101101001101110100011001100000010100000010001000010110100010100011000010001010101011110000000000110000011001000000100001110000100100010000001110000010100000101010100010001101000010

I can provide the full length strings if needed, I will place them in a .bas file so word wrap is not a problem, let me know.

I added counters to show the counts for the number of 0's and the number of 1's the predictor makes.
I also counted the number of correct guesses for each.

Results
The predictor predicted a zero 473 times, of those it correctly predicted a (0) 299 times for  63.2%
The predictor predicted a one 27 times, of those it correctly predicted a (1) 13 times for 48.%1

My concerns center on the total number of 1's the predictor makes.  Some strings tested have a
greater number of 1's with hit rates running in the mid 40's. 

My primal thoughts on this is that maybe a small weight could be added to the ones column but this
might produce unwanted results.  I have a control panel that would allow me to tinker with weight
values, don't know if this would help or not. In past attempts I was able to tweak the results for
the better but not enough to make any real progress.  Like to know your thoughts.
 

R1

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 16, 2021, 01:32:14 pm

Morning R1,

That string looks fine, I'll fix up some comments on it later.

(edit: deleted some crap i decided wasnt true)

---

Alright, so you raise another point about tweaking the model. This part is subtle, and is frankly the only "human decision" made throughout this entire code. Here's the heart:

Code: QB64: [Select]

1.     For k = UBound(Partialguess) To LBound(Partialguess) Step -1
2.         If (Partialguess(k, 1) <> -999) Then
3.  
4.             ' This is the made-up part of the model:
5.             ' The variable r contributes to weighted average.
6.             ' The variable j is used for normalization.
7.             ' Scaling factor h influences weighted average calculaton.
8.             ' The factors multiplying h are totally arbitrary. Notes:
9.             '   setting o(h^2) means the later alphabets count for more.
10.             '   Partialguess(k, 1) euqals the calculated guess at frequency k.
11.             '   Partialguess(k, 2) euqals the peak count of the unscaled histogram.
12.             '   ...while Partialguess(k, 2) is here, it does not seem to help calculations.
13.  
14.             h = 1 + k - LBound(Partialguess)
15.  
16.             h = h ^ 2
17.  
18.             ' Standard weighted average:
19.             r = r + h * Partialguess(k, 1)
20.             j = j + h
21.  
22.         End If
23.     Next
24.     If (j <> 0) Then
25.         r = r / j
26.     End If
27.  

All you need to pay attention to is the variable h. Right now, the model is set so that h is proportional to the library size we're using, and then I let h -> h^2 so that later, longer guesses count for more. If you want all partial guesses to count the same, let h=1. If you want early guesses to count for more, let h -> sqr(h) or something. I haven't changed this part in quite some time, so beware what you get! (There are probably even better models waiting to be discovered right here but I haven't really needed to yet...)

---

OH and I almost forgot. Want better accuracy? uncomment alphabets 11,12, and 13. It will look for deeper patterns in trade for a little speed.

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 16, 2021, 09:02:46 pm

STxAxTIC

Un-commenting the alphabets should not present a speed issue on my end.  My mention of the
added weight is to introduce a user defined static value just before the final prediction is made.
Like I said I have a control panel already set up for this sort a thing.  However I would like to
wait until we think the predictor is fully developed before coding the CP into the main program. 
When the predictor is fully developed then it will run in sort of a silent mode so to say with just
a process bar to indicate the overall progress.  I will add the print switch to all the printed stuff
so that it can be blocked when it's no longer needed.

Attached is a picture of the predictors front end showing process bars,  Red is data gathering,
Green = formatting, blue = predictor process, larger pink bar to the right indicates overall
progress.  Picture shows a 10 string run.

Second picture shows the yet unfinished config menu.  This writes any user settings to a .ini file
which is then read just before the predictor is ran. 

R1       

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 17, 2021, 05:15:34 am

Hey R1,

You mentioned plenty in the above, but I wanted to expound on this part a little:

Quote

My mention of the added weight is to introduce a user defined static value just before the final prediction is made. Like I said I have a control panel already set up for this sort a thing.

Throughout using this program, it occurred to me that my variable "h" explained above does not need to be a single value, but can be an array h() with one "weight" per value, much like you're talking about. The novel idea comes next: This array h() can actually be "trained" by the machine itself using whatever input strings we want, kindof exactly like a real AI project. So far all my code does is a big dumb deterministic calculation, but imagine if it tweaked its own model in order to maximize performance on the full suite of test strings? It's not even that difficult, the way I set things up.

I can't get to work on that yet though, because off to the side I'm trying to document all the progress we've made so far. This code doesn't speak well enough for itself, and certainly doesn't defend itself against... ahem... attacks... so I'm drafting a fake article on this as we speak. This will explain why I'm going to stop using the forum as a dev blog, too, haha.

Keep me posted with your updates, I like the screenshots too!

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 17, 2021, 04:04:35 pm

STxAxTIC

I understand and agree.  If even what we have already discussed could be successfully implemented
then it might become very lucrative tool, don't blame you for going undercover so to say.   Please
stay in touch via private message if you have anything more to share.  As I've said I have been
working on this for years using different approaches but find my lack of skill in converting certain
math's into working code a problem.  As you probability already know, most mathematicians kind
of roll their eyes at something like this, some, not all.   

Many thanks for everything.

R1.

P.S.
My program makes a bunch of statistical calculations before the strings are ever presented to the
predictor.  I have not  implemented any of them yet as I need to first streamline your code so
that it integrates perfectly with the main program code.  I will add several controls to the config
menu like the string length, number of calls, weights, threshold, trigger etc... 

Again thanks for your post.             

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 17, 2021, 04:16:24 pm

Ah hey R1!

So maybe I wasn't a thousand percent clear in my post above - I'm not really going underground with this work as much as I'm getting out of everyone's hair with it. Since the whole idea here isn't so obvious, it deserves a proper explanation rather than just code and forum posts... So that means I'm putting the work elsewhere, namely here:

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

It's barely a third of the way done as I sit here now, but within the next few days it should be fully drafted. I do this in notepad without spell check cause I'm a madlad, so this page is subject to corrections. Anyway, the full story is now going there ^

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 17, 2021, 07:36:36 pm

STxAxTIC

The information in the link has already filled in several blanks I had in understanding your
code, stupid me.  I should be able to adapt it now so that it fits seamlessly into my existing
code.     

Big thumbs up on the link and I look forward to the finished project.  Maybe were on the same
page now.  I admit I've been a bit cryptic in my postings.         

Thanks 

R1 

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 17, 2021, 11:01:56 pm

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 (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.  

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 19, 2021, 02:57:46 pm

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 (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.

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 20, 2021, 01:29:55 am

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   

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 20, 2021, 07:02:30 am

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.  

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 20, 2021, 02:04:07 pm

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.  

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 20, 2021, 09:22:22 pm

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   

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 23, 2021, 02:50:51 am

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

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 23, 2021, 03:51:04 am

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!

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 23, 2021, 05:40:29 pm

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

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 23, 2021, 05:55:52 pm

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 (https://i.postimg.cc/q7jZfNCQ/p1-ps.png)

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 24, 2021, 12:14:13 pm

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.

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 24, 2021, 03:47:09 pm

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.  

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 24, 2021, 05:53:09 pm

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 
   

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 28, 2021, 12:16:45 pm

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 (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.  

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 28, 2021, 04:24:55 pm

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     

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on December 28, 2021, 08:54:35 pm

Quote from: random1 on December 28, 2021, 04:24:55 pm

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.

Ya know, this thought crossed my mind but I haven't had the nuts to try it. It's kindof a fascinating idea - for the model to study and find patterns in its own performance (it's a binary sequence after all), so that it may predict its own performance and improve upon it. There is so much to mess with there...!

This reminds me of another hunt I wanted to launch that looks for "eigenstrings". I just made up that word up, it's a play on "eigenvector" which (from linear algebra) is a vector x that would satisfy Ax=x, where A is a matrix. In our case, A is the predictor and x is the sequence. This means that the sequence would be identical to the correctness record. Crazy stuff!

Reeling things back in a second... this kind of thing gets dangerously close to alchemy, which is to say just peering into sacrificial goat entrails for patterns. We could do this for eternity and never notice when the mathematics stopped and the mad hattery began. Luckily we aren't there yet. I think the future of this work is less about the algorithms working blindly, and more about using any meta-knowledge you have about the input sequences themselves. This is to say, "where is this data coming from?"

Anyhow I'll keep writing up the interesting stuff - will let you know if anything new interesting stuff pops up.

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 29, 2021, 01:59:45 am

 STxAxTIC

Mad hattery, so many rabbit holes to explore, lol.  Just hope this does not cause you
to move to Lincoln Montana and start making bombs.  My math skills ran out a ways
back and I am feeling a little parasitic feeding off your knowledge.   

I think if it can be done, you are the one to do it.  It's already surpassed my expectations
so everything right, our should I say, left of here is a bonus. 

Thanks

R1
 

   
   

Title: Re: Looking for old program or help recreating it
Post by: random1 on December 29, 2021, 03:48:44 am

Here is a simple Gap / Frequency tool.  I once used something like this as a secondary
predictor to kind of second guess the main predictors output.  Don't remember how
well if fared.  Notice that a gap of 35 shows a perfect string of (0's), 6 I think.  The
sample data string is very short and is not a real output string.  Just a simple code bit
to illustrate an idea.

Code: QB64: [Select]

1. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
2. 'Frequency / Gap tool.  Cartoon code                                                                                                       '
3. 'This is a gaps analysis tool.  It is set go check every gap from 2 to 50 between any two points of the output data string  '
4. 'The goal is to find the best gap value between two consecutive 1 or 0.                                                     '
5. 'The first count is offset by one to sync up with the next event                                                            '
6. '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
7. Title1$ = "Gap Analysis"
8. _Title Title1$
9. A& = _NewImage(600,200,32)
10. SCREEN A&
11. _SCREENMOVE _Middle
12.  
13. Dim OutString as string '<- The output from the predictor
14. 'small sample string
15. OutString = "01010000100010000110100100000101100110000110101100110100100000110000000010010001101101110011100001000110000001100100000001111001011011000000001000000111010100001100001000010010001110100011000111111000110000000000100000111000010000100000010011110110000000001101"
16. Prediction$=""
17.  
18. Gap = 2  '<- start gap value
19. Do while Gap <= 50
20. NewStr$="" '<- build a result string' here for illistration only.  This string will be a condenced version of the one being processed
21.  
22. hit=0:mis=0
23. L1=Gap-1 '<- offset counter by 1 so data is synced for prediction
24.   Do while L1 <= Len(OutString)-Gap
25.       If Mid$(OutString,L1,1)="1" Then hit=hit+1 else mis=mis+1
26.       If Mid$(OutString,L1,1)="1" Then NewStr$=NewStr$+"1" else NewStr$=NewStr$+"0" '<- create a results string for multi processing if needed
27.   L1=L1+Gap
28. Loop
29.  
30. 'simple analysis
31. 'if results consist entirely of 0's or 1's then update predicted value
32. If Instr(NewStr$,"1") < 1 Then Prediction$=Prediction$+"0"
33. If Instr(NewStr$,"0") < 1 Then Prediction$=Prediction$+"1"
34.  
35. 'Print results for each gap
36. Color _RGB32(192,192,192),_RGB32(0,0,0)
37. _PrintString (2, 4), "Gap -> " + _Trim$(Str$(Gap))
38. _PrintString (2,20), "Gap hit (1) -> " + _Trim$(Str$(hit))
39. _PrintString (2,36), "Gap hit (0) -> " + _Trim$(Str$(mis))
40. _PrintString (2,52), NewStr$
41.  
42. Sleep  '<- comment out to automate the process
43. Gap=Gap+1 '<- Add 1 to gap
44. Color _RGB32(0,0,0),_RGB32(0,0,0)
45. If Gap < 50 Then CLS
46. Loop
47.  
48. 'overall results
49. Color _RGB32(192,192,192),_RGB32(0,0,0)
50. _PrintString (2,68), "Overall findings -> " + Prediction$
51. _PrintString(2,180), "Press any key to exit"
52. Sleep
53. System
54.  
55.  

R1

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on January 01, 2022, 12:46:14 am

Hey R1,

I have a happy little update and a little storyline to go with it. So apart from all of the eggheaded things I was planning to do with this code, I was quiet about *one* endeavor - just in case it failed - and it held up production until today - it's finally finished. What I've managed to do is use my unaltered Analyze function as a random number generator. I went through serious pain to make sure it gives "real" randomness, and almost quit looking several times thinking it may be impossible. Way too much to unpack here, but the conclusion is I used what was laying around to find a full-blown PRNG.

This came about by thinking along the lines of what you said, namely

Quote

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.

... and thought about it a lot, and realized that's kindof what's going on when I build "pathological" sequences. To refresh: suppose you have a given model W. The "pathological" sequence is the sequence that W gets *wrong* every single turn. I detailed how to build these things on the web page. Anyway, to make a random number generator, I figured, "let's build a pathological string but find a way to randomize W while building it." The way I "randomize" W is to replace W with a sample of the output sequence itself.

Just for comparison, here is how I use QB64's in-house RND function to generate a random sequence of a given length from a given seed:

Code: QB64: [Select]

1. Function QBPRNG$ (TheSeed As Double, TheLength As Integer)
2.     Dim TheReturn As String
3.     Randomize TheSeed
4.     Do
5.         If (Rnd > .5) Then
6.             TheReturn = TheReturn + "1"
7.         Else
8.             TheReturn = TheReturn + "0"
9.         End If
10.     Loop Until (Len(TheReturn) = TheLength)
11.     QBPRNG$ = TheReturn
12. End Function

And here is the new kid in town. Also makes random sequences but without RND:

Code: QB64: [Select]

1. Function ProtoRand$ (TheSeed As String, TheLength As Integer)
2.     Dim TheReturn As String
3.     Dim WorkingString As String
4.     TheReturn = ""
5.     WorkingString = "0100100010" + TheSeed
6.     Do
7.         Call InitializeModelLiteral(Right$(WorkingString, 10))
8.         If (Analyze(WorkingString, AlphaWeight(), 0) = 1) Then
9.             TheReturn = TheReturn + "0"
10.             WorkingString = WorkingString + "0"
11.         Else
12.             TheReturn = TheReturn + "1"
13.             WorkingString = WorkingString + "1"
14.         End If
15.         If (Len(WorkingString) > 80) Then WorkingString = Right$(WorkingString, 80)
16.     Loop Until Len(TheReturn) = TheLength
17.     ProtoRand$ = TheReturn
18. End Function

You can see that I "replace W with a sample of the output sequence itself" right after the DO statement. Pretty esoteric stuff if you don't remember exactly how we got to this point, but nonetheless there it is! That move puzzles things enough so that the output is just utterly jumbled. (I can explain why the number 80 appears in this code, it can really be any number bigger than a few dozen.) Now I can exhale a second time. (And write some of this stuff up. All of these notes will go up on the page soon enough.)

Alright happy new year!

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 02, 2022, 07:30:44 am

STxAxTIC

Cool, can't wait for the update.  I finished the little 3 stage predictor tool have been working
on the last couple weeks.  It's more of a idea I decided to test and see what happens.

What I did was to combine three simple predictors where each one outputted a probability
which are then combined in the final prediction.

The calculations go like this, the predictors end count for 0 and 1 are converted into probabilities.
Next I add a small boost weight to the 1's and then use p^2 to both the 0's and 1's calculation. 
It then moves to the next prediction tool and repeats the process. 

After all active predictors have ran the last stage sums the probabilities and then divides by the
number of active predictors, Remember I can run any configuration of the three, 1 & 2 or 1 & 3
etc...   The value with the greatest probability is the end prediction.

The config/settings menu allows adjusting certain things like the length of the string to process,
search sample size, number of iterations, weights etc...  I was able to fine the three predictors
close to 70 percent hit rates when ran one at a time.

The problem.
Tuning the predictors one at a time for maximum hit rates seemed fine but when I run them 
combined the results dropped like a rock, around 70% down to mid 40's to low 50's mostly
because it predicts way too many ones, 60 to 80 for a average.  Lowering the boost value
does not seem to help.   This tool is designed to only predict (1's), all other value are ignored
and the data strings are non-standard so to say.   There are around 112 strings used by this
tool where around 30% repeat day to day.  The idea is to predict 20 to 25 1's out of the 112
strings with a very high accuracy.   

Anyway, that's where I am at.  Still thinking I might be able to improve it, maybe set one of the
predictors to boost (0) counts to decrease the overall 1's predicted.  I am still playing around with
the settings in the configuration menu but think I may have to go back into the code and change
a few things.

I check your links each day for updates, thanks again.  Hope you and yours have a great new year.
 
R1   
 

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 03, 2022, 04:33:32 am

Hi all

I need some help with a scoring method for the above mentioned prediction tool.
Below is a picture of the scoreboard so to say but what I want to do is combine
all the data into a overall score so that I can track the overall effects of my fine
tuning.


https://i.postimg.cc/L6sKrkMs/SCORE.png
 (https://i.postimg.cc/L6sKrkMs/SCORE.png)

This results shown in the picture are based on a real data back-test.  This allows
me to analyze the predictors results to the actual event.  The first item in the pic
shows the back-test number, the second shows the number of strings processed
by the predictor.   The third is the number of predictions made by the predictor.
The forth value shows the actual number of strings that did repeat. The fifth value
shows the number of correct predictions from the possible 42 that did repeat.
The sixth line is the number of incorrect predictions made.  The seventh is a
simple probability gotten form dividing the total correct guesses by the number
of predictions made.  36/67= .5373. 

So out of 105 strings processed, there were a possible 42 correct choices for a (1)
to repeat.  Of these the predictor managed to predict 36 for 36/42=0.857 correct.

I need to combine everything in such a way that I can score the predictors overall
performance.  Also remember the predictor only predicts (1's) ie repeats.
         
overall predictions = 67/105=.638
correct predictions = 36/67=.537 but we need to factor in the 105 strings processed
at least I think this needs to be included.  etc..

Thanks in advance.

PS.  The predictor guessed correctly 36 times from a pool of the 42 possible in 67 predictions
made from analyzing 105 strings.  Calculate a score given all the variables.

R1

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 03, 2022, 05:22:56 am

Hi all

I figured out my own question, since the predictor predicts both zeros and ones
even though the ones are the only values tracked.  All I had to do was count the
number of correct (0) guesses and add that to the ones then divide the sum by
the number of strings processed.  This gives me a overall hit rate which is really
all I needed.  Stupid monkey, get some sleep. LOL

R1
 

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on January 03, 2022, 06:40:55 am

Good evening R1 -

Close call with that question you just pitched - I was about to roll up my sleeves before the alarm was suddenly silenced.

Just wanted to let you know that the page is now "fully" caught up to everything I was talking about. I'll probably notice little typos as time goes on, but the main flow is there. Doing a quick scroll up and down the page, it's a lot more dense than part 1. I know you have the link but for completeness: http://barnes.x10host.com/pages/Binary-Analyzer/Binary-Analyzer-Two.php (http://barnes.x10host.com/pages/Binary-Analyzer/Binary-Analyzer-Two.php)

I've also done a very little bit of quality-of-life cleanup to the code. It's now set to simply process a file if you drag+drop onto it, or if you don't, it can be hacked by band. All of the delays and limits are commented out. Right now it's default thing is to crank through the "troublesome" sequence you pasted on (I think) the 16's of Dec. I'm still running it right now, but that string is at least 63% predictable so far.

I'm basically happy with zipping up this project for long-term storage at this point. (The game I play is, pretend I forget all the details and rediscover my own project later on - will it still make sense? My answer right now is "prolly".) I'll attach the "final" code at the bottom. It can of course be butchered for its Analyze() function. Everything in the main loop can be deleted and the core will still do its job.

You said some interesting stuff above, particularly when combining models. Isn't it funny how the results drop when you do that? It reminds me of how hurricanes are modeled on the news. You always see this bundle of possible trajectories on the statewide map which represent competing models. You might say, "hey, why not bundle those lines together and just imagine one thick bold line?" Sure, but then you have to combine uncertainies too. The possible trajectory widens to a huge cone, and you're back to wondering at random where the hurricane's gonna go. It might be better to just pick one model from the many and not melt them all together.

I'm not sure how exactly you're optimizing your solution, but imagine a search in parameter space. Lemme freestyle this... Suppose your models are M1, M2, and M3. Then the nth digit in your sequence is predicted by each model, denoted as M1(n), M2(n), M3(n). Okay, so you talked about switching these on or off. Did you try blending them? Like this:

P(n) = w(1)*M1(n) + w(2)*M2(n) + w(3)*M3(n)

This means the total prediction of the nth bit is the weighted average of all three models, and the question becomes what the hell do we do with w(1), w(2), and w(3)? The most prudent thing possible is to imagine a sphere... actually ya know what? Let me do this in two dimensions first. Suppose for clarity you have only two models. Then we can skip the third everything:

P(n) = w(1)*M1(n) + w(2)*M2(n)

Now check this out. Suppose w(1) = cos(q), w(2)=sin(q). If you're trigonometrically inclined, I'm now imagining a circle of radius 1, and the weights w(1), w(2) are the x,y coordinates of a point on this circle at angle q. Then, if you want to cycle through all possible combinations of models M1 and M2, let the q-variable step from 0 to 2pi at a fine interval. (Adjust the interval to avoid negative weights but the gist is there.)

Tell me if I'm out in right field. If this sounds appealing, we can develop the 3d case based on a sphere.

Code: QB64: [Select]

1. ' Version: 2022-01-03
2.  
3. OPTION _EXPLICIT
4.  
5. DO UNTIL _SCREENEXISTS: LOOP
6. _TITLE "Binary Analyzer"
7.  
8. SCREEN _NEWIMAGE(120, 40)
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 BestBinaryModel AS INTEGER
62. DIM WorstBinaryModel 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.     '''
73.     ' Load test cases at bottom of code:
74.     'ReDim _Preserve TestData(LoadTestData(0))
75.     '''
76.  
77.     '''
78.     ' Play area:
79.     REDIM _PRESERVE TestData(1)
80.     'Call InitializeModelCustom("-1")
81.     'Call InitializeModelLiteral("0010101000")
82.     'Call InitializeModelIndexed(23)
83.     TestData(1) = "00101000111101101011000010000100001100110110100001100001100000000010011001000101000010001000000111011100000100000000010111010110000000010001110010110111000001011010111100101101010000011101110011010000110010011101011111000001000011001000000010011110011000000010101010011100100000010100010010111100100100100001000010011001101101001101110100011001100000010100000010001000010110100010100011000010001010101011110000000000110000011001000000100001110000100100010000001110000010100000101010100010001101000010"
84.     'TestData(1) = Pathological$("1", 25000)
85.     'TestData(1) = ProtoRand$("", 1000)
86.     'TestData(1) = QBPRNG$(1, 1000)
87.     '''
88. END IF
89.  
90. GuessRatioBest = 0
91. GuessRatioWorst = 1
92. GuessStreakBest = 0
93. WorstBinaryModel = 1
94.  
95. ' This outer loop is for cycling through models.
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.     ' This enclosed loop is for looping through test strings.
106.     FOR m = 1 TO UBOUND(TestData)
107.  
108.         GuessPredicted = -1
109.         GuessCorrect = 0
110.         GuessTotal = 0
111.         GuessStreak = 0
112.         GuessStreakMax = 0
113.  
114.         ' This core loop goes through ine (literal) bit of a test string per iteration.
115.         ' Set upper limit to infinity for game mode.
116.         FOR n = 1 TO LEN(TestData(m)) '9999
117.  
118.             '''
119.             ' Auto-feed Mode:
120.             TheString = LEFT$(TestData(m), n)
121.             '''
122.  
123.             '''
124.             ' Gaming Mode:
125.             'Call InitializeModelIndexed(16)               ' This 5-gram case (16) works well for game mode.
126.             'Call InitializeModelIndexed(18)               ' Learning algo discoverd this is good against humans.
127.             'Call InitializeModelIndexed(82)               ' Learning algo discoverd this is good against humans.
128.             'Call InitializeModelLiteral("0000101000")     ' Experimental default.
129.             'Cls
130.             'Locate 1, 1
131.             'Print "Press LEFT or RIGHT."
132.             'k = 0
133.             'Do: k = _KeyHit: Loop Until ((k = 19200) Or (k = 19712))
134.             'Select Case k
135.             '    Case 19200
136.             '        TheString = TheString + "0"
137.             '    Case 19712
138.             '        TheString = TheString + "1"
139.             'End Select
140.             '_KeyClear
141.             '''
142.  
143.             CLS
144.             COLOR 7
145.             LOCATE 1, 1
146.             FOR k = 1 TO _WIDTH
147.                 PRINT "_";
148.             NEXT
149.             PRINT "Model";
150.             PRINT " ("; _TRIM$(STR$(BinaryModelIndex)); ")";
151.             PRINT ":";
152.             FOR k = 1 TO 10 'UBound(AlphaWeight)
153.                 PRINT AlphaWeight(k);
154.             NEXT
155.             PRINT
156.             PRINT
157.             PRINT "Sequence (index "; _TRIM$(STR$(m)); ") (length "; _TRIM$(STR$(LEN(TheString))); "):"
158.             PRINT RIGHT$(TheString, 400);
159.             COLOR 8
160.             PRINT LEFT$(RIGHT$(TestData(m), LEN(TestData(m)) - n), 400);
161.             COLOR 7
162.             PRINT
163.  
164.             ' Reconciliation
165.             IF (GuessPredicted <> -1) THEN
166.                 PRINT
167.                 PRINT "I predicted "; _TRIM$(STR$(GuessPredicted)); " and you typed "; RIGHT$(TheString, 1); "."
168.                 IF (GuessPredicted = VAL(RIGHT$(TheString, 1))) THEN
169.                     PRINT "I am RIGHT this round."
170.                     GuessCorrect = GuessCorrect + 1
171.                     GuessStreak = GuessStreak + 1
172.                     IF (GuessStreak > GuessStreakMax) THEN GuessStreakMax = GuessStreak
173.                     Grade(n, 2) = 1
174.                 ELSE
175.                     PRINT "I am WRONG this round."
176.                     GuessStreak = 0
177.                     Grade(n, 2) = 0
178.                 END IF
179.                 GuessTotal = GuessTotal + 1
180.                 Grade(n, 1) = GuessCorrect / GuessTotal
181.             END IF
182.  
183.             IF (GuessTotal > 0) THEN
184.                 PRINT
185.                 PRINT "I'm on a "; _TRIM$(STR$(GuessStreak)); "-round winning streak."
186.                 PRINT "My best streak has been "; _TRIM$(STR$(GuessStreakMax)); "."
187.                 IF (GuessTotal <> 0) THEN
188.                     PRINT "My correctness rate is "; _TRIM$(STR$(INT(100 * GuessCorrect / GuessTotal))); "% in "; _TRIM$(STR$(GuessTotal)); " trials."
189.                 END IF
190.             END IF
191.  
192.             GuessPredicted = Analyze(TheString, AlphaWeight(), 0)
193.  
194.             '''
195.             ' Reverse polarity if needed for any reason.
196.             'If (GuessPredicted = 0) Then
197.             '    GuessPredicted = 1
198.             'Else
199.             '    GuessPredicted = 0
200.             'End If
201.             '''
202.  
203.             PRINT
204.             'Print "I have made a new prediction."
205.             'Print "Press LEFT or RIGHT to test me."
206.             PRINT "The best performer was model #"; _TRIM$(STR$(BestBinaryModel)); ", rated "; _TRIM$(STR$(INT(GuessRatioBest * 100))); "%, best streak of "; _TRIM$(STR$(GuessStreakBest)); "."
207.             PRINT "The worst performer was model #"; _TRIM$(STR$(WorstBinaryModel)); ", rated "; _TRIM$(STR$(INT(GuessRatioWorst * 100))); "%."
208.  
209.             ' Draw bottom graph if there's enough room.
210.             IF (CSRLIN <= 23) THEN
211.                 IF (GuessTotal <> 0) THEN
212.                     CALL PrintGraph(TheString, Grade())
213.                 END IF
214.             END IF
215.  
216.             _DISPLAY
217.             '_Delay .02
218.             '_Limit 240
219.         NEXT
220.  
221.         IF (GuessTotal > 0) THEN
222.             IF (GuessCorrect / GuessTotal >= GuessRatioBest) THEN
223.                 BestBinaryModel = BinaryModelIndex
224.                 GuessRatioBest = GuessCorrect / GuessTotal
225.                 GuessStreakBest = GuessStreakMax
226.             END IF
227.             IF (GuessCorrect / GuessTotal <= GuessRatioWorst) THEN
228.                 WorstBinaryModel = BinaryModelIndex
229.                 GuessRatioWorst = GuessCorrect / GuessTotal
230.             END IF
231.         END IF
232.  
233.         '_Delay 3
234.     NEXT
235.  
236. LOOP
237.  
238. END
239.  
240. FUNCTION Analyze (TheStringIn AS STRING, arrweight() AS DOUBLE, pswitch AS INTEGER)
241.     DIM TheReturn AS INTEGER
242.     DIM AS INTEGER n
243.     DIM AS DOUBLE r, j, k
244.     DIM StringPhase(UBOUND(arrweight)) AS STRING
245.     DIM Partialguess(LBOUND(arrweight) TO UBOUND(arrweight), 2) AS DOUBLE
246.  
247.     StringPhase(1) = TheStringIn
248.     'For n = 2 To UBound(StringPhase) ' Phase analysis.
249.     '    StringPhase(n) = Right$(StringPhase(n - 1), Len(StringPhase(n - 1)) - 1) + Left$(StringPhase(n - 1), 1)
250.     'Next
251.  
252.     IF (pswitch = 1) THEN
253.         PRINT
254.         FOR n = 1 TO _WIDTH
255.             PRINT "-";
256.         NEXT
257.         PRINT
258.     END IF
259.  
260.     IF (arrweight(1) <> 0) THEN CALL CreateHisto(StringPhase(), 1, Alphabet1())
261.     IF (arrweight(2) <> 0) THEN CALL CreateHisto(StringPhase(), 2, Alphabet2())
262.     IF (arrweight(3) <> 0) THEN CALL CreateHisto(StringPhase(), 3, Alphabet3())
263.     IF (arrweight(4) <> 0) THEN CALL CreateHisto(StringPhase(), 4, Alphabet4())
264.     IF (arrweight(5) <> 0) THEN CALL CreateHisto(StringPhase(), 5, Alphabet5())
265.     IF (arrweight(6) <> 0) THEN CALL CreateHisto(StringPhase(), 6, Alphabet6())
266.     IF (arrweight(7) <> 0) THEN CALL CreateHisto(StringPhase(), 7, Alphabet7())
267.     IF (arrweight(8) <> 0) THEN CALL CreateHisto(StringPhase(), 8, Alphabet8())
268.     IF (arrweight(9) <> 0) THEN CALL CreateHisto(StringPhase(), 9, Alphabet9())
269.     IF (arrweight(10) <> 0) THEN CALL CreateHisto(StringPhase(), 10, Alphabet10())
270.     IF (arrweight(11) <> 0) THEN CALL CreateHisto(StringPhase(), 11, Alphabet11())
271.     IF (arrweight(12) <> 0) THEN CALL CreateHisto(StringPhase(), 12, Alphabet12())
272.     IF (arrweight(13) <> 0) THEN CALL CreateHisto(StringPhase(), 13, Alphabet13())
273.  
274.     IF (pswitch = 1) THEN ' Set the last argument >=1 to print stats for that histogram.
275.         IF ((LEN(TheStringIn) >= 1) AND (arrweight(1) <> 0)) THEN CALL PrintHisto(Alphabet1(), 0)
276.         IF ((LEN(TheStringIn) >= 2) AND (arrweight(2) <> 0)) THEN CALL PrintHisto(Alphabet2(), 0)
277.         IF ((LEN(TheStringIn) >= 3) AND (arrweight(3) <> 0)) THEN CALL PrintHisto(Alphabet3(), 0)
278.         IF ((LEN(TheStringIn) >= 4) AND (arrweight(4) <> 0)) THEN CALL PrintHisto(Alphabet4(), 0)
279.         IF ((LEN(TheStringIn) >= 5) AND (arrweight(5) <> 0)) THEN CALL PrintHisto(Alphabet5(), 4)
280.         IF ((LEN(TheStringIn) >= 6) AND (arrweight(6) <> 0)) THEN CALL PrintHisto(Alphabet6(), 0)
281.         IF ((LEN(TheStringIn) >= 7) AND (arrweight(7) <> 0)) THEN CALL PrintHisto(Alphabet7(), 0)
282.         IF ((LEN(TheStringIn) >= 8) AND (arrweight(8) <> 0)) THEN CALL PrintHisto(Alphabet8(), 0)
283.         IF ((LEN(TheStringIn) >= 9) AND (arrweight(9) <> 0)) THEN CALL PrintHisto(Alphabet9(), 0)
284.         IF ((LEN(TheStringIn) >= 10) AND (arrweight(10) <> 0)) THEN CALL PrintHisto(Alphabet10(), 0)
285.         IF ((LEN(TheStringIn) >= 11) AND (arrweight(11) <> 0)) THEN CALL PrintHisto(Alphabet11(), 0)
286.         IF ((LEN(TheStringIn) >= 12) AND (arrweight(12) <> 0)) THEN CALL PrintHisto(Alphabet12(), 0)
287.         IF ((LEN(TheStringIn) >= 13) AND (arrweight(13) <> 0)) THEN CALL PrintHisto(Alphabet13(), 0)
288.         PRINT
289.     END IF
290.  
291.     ' Set the last argument =1 to print guess for that histogram.
292.     IF ((LEN(TheStringIn) >= 1) AND (arrweight(1) <> 0)) THEN CALL MakeGuess(TheStringIn, 1, Alphabet1(), Partialguess(), 0)
293.     IF ((LEN(TheStringIn) >= 2) AND (arrweight(2) <> 0)) THEN CALL MakeGuess(TheStringIn, 2, Alphabet2(), Partialguess(), 0)
294.     IF ((LEN(TheStringIn) >= 3) AND (arrweight(3) <> 0)) THEN CALL MakeGuess(TheStringIn, 3, Alphabet3(), Partialguess(), 0)
295.     IF ((LEN(TheStringIn) >= 4) AND (arrweight(4) <> 0)) THEN CALL MakeGuess(TheStringIn, 4, Alphabet4(), Partialguess(), 0)
296.     IF ((LEN(TheStringIn) >= 5) AND (arrweight(5) <> 0)) THEN CALL MakeGuess(TheStringIn, 5, Alphabet5(), Partialguess(), pswitch)
297.     IF ((LEN(TheStringIn) >= 6) AND (arrweight(6) <> 0)) THEN CALL MakeGuess(TheStringIn, 6, Alphabet6(), Partialguess(), 0)
298.     IF ((LEN(TheStringIn) >= 7) AND (arrweight(7) <> 0)) THEN CALL MakeGuess(TheStringIn, 7, Alphabet7(), Partialguess(), 0)
299.     IF ((LEN(TheStringIn) >= 8) AND (arrweight(8) <> 0)) THEN CALL MakeGuess(TheStringIn, 8, Alphabet8(), Partialguess(), 0)
300.     IF ((LEN(TheStringIn) >= 9) AND (arrweight(9) <> 0)) THEN CALL MakeGuess(TheStringIn, 9, Alphabet9(), Partialguess(), 0)
301.     IF ((LEN(TheStringIn) >= 10) AND (arrweight(10) <> 0)) THEN CALL MakeGuess(TheStringIn, 10, Alphabet10(), Partialguess(), 0)
302.     IF ((LEN(TheStringIn) >= 11) AND (arrweight(11) <> 0)) THEN CALL MakeGuess(TheStringIn, 11, Alphabet11(), Partialguess(), 0)
303.     IF ((LEN(TheStringIn) >= 12) AND (arrweight(12) <> 0)) THEN CALL MakeGuess(TheStringIn, 12, Alphabet12(), Partialguess(), 0)
304.     IF ((LEN(TheStringIn) >= 13) AND (arrweight(13) <> 0)) THEN CALL MakeGuess(TheStringIn, 13, Alphabet13(), Partialguess(), 0)
305.     IF (pswitch = 1) THEN PRINT
306.  
307.     IF (pswitch = 1) THEN
308.         PRINT "Thinking:   ";
309.         FOR k = LBOUND(Partialguess) TO UBOUND(Partialguess)
310.             IF ((LEN(TheStringIn) >= k) AND (arrweight(k) <> 0)) THEN
311.                 PRINT Partialguess(k, 1);
312.             ELSE
313.                 PRINT "_ ";
314.             END IF
315.         NEXT
316.         PRINT
317.     END IF
318.  
319.     j = 0
320.     r = 0
321.  
322.     ' Weighted average calculation
323.     FOR k = LBOUND(Partialguess) TO UBOUND(Partialguess)
324.         IF ((LEN(TheStringIn) >= k) AND (arrweight(k) <> 0)) THEN
325.             r = r + arrweight(k) * Partialguess(k, 1)
326.             j = j + arrweight(k)
327.         END IF
328.     NEXT
329.     IF (j <> 0) THEN
330.         r = r / j
331.     END IF
332.  
333.     IF (pswitch = 1) THEN PRINT "Predicting:  "; _TRIM$(STR$(r))
334.  
335.     IF (r > .5) THEN
336.         r = 1
337.     ELSE
338.         r = 0
339.     END IF
340.  
341.     IF (pswitch = 1) THEN PRINT "Rounding to: "; _TRIM$(STR$(r))
342.  
343.     IF (pswitch = 1) THEN
344.         FOR n = 1 TO _WIDTH
345.             PRINT "-";
346.         NEXT
347.         PRINT
348.     END IF
349.  
350.     TheReturn = r
351.     Analyze = TheReturn
352. END FUNCTION
353.  
354. SUB MakeGuess (TheStringIn AS STRING, wid AS INTEGER, arralpha() AS LetterBin, arrguess() AS DOUBLE, pswitch AS INTEGER)
355.     DIM TheReturn AS DOUBLE
356.     DIM AS INTEGER j, k, n
357.     TheReturn = 0
358.     j = 1
359.     k = 0
360.     FOR n = 1 TO UBOUND(arralpha)
361.         IF (LEFT$(arralpha(n).Signature, wid - 1) = RIGHT$(TheStringIn, wid - 1)) THEN
362.             IF (arralpha(n).Count >= j) THEN
363.                 IF (pswitch = 1) THEN PRINT "Order-"; RIGHT$("0" + _TRIM$(STR$(wid)), 2); " guess: "; arralpha(n).Signature; " . "; _TRIM$(STR$(arralpha(n).Count))
364.                 TheReturn = TheReturn + VAL(RIGHT$(arralpha(n).Signature, 1))
365.                 k = k + 1
366.                 j = arralpha(n).Count
367.             END IF
368.         END IF
369.     NEXT
370.     IF (k <> 0) THEN
371.         TheReturn = TheReturn / k
372.     ELSE
373.         TheReturn = .5
374.     END IF
375.     arrguess(wid, 1) = TheReturn
376.     arrguess(wid, 2) = j
377. END SUB
378.  
379. SUB InitializeModelIndexed (TheIndexIn AS INTEGER)
380.     '0 to 1023
381.     CALL InitializeModelLiteral(BIN$(TheIndexIn))
382. END SUB
383.  
384. SUB InitializeModelLiteral (Weights AS STRING)
385.     DIM AS INTEGER k
386.     FOR k = 1 TO 10
387.         AlphaWeight(k) = VAL(MID$(Weights, k, 1))
388.     NEXT
389.     AlphaWeight(11) = 0
390.     AlphaWeight(12) = 0
391.     AlphaWeight(13) = 0
392. END SUB
393.  
394. SUB InitializeModelCustom (Weights AS STRING)
395.     DIM AS INTEGER k
396.     IF (Weights = "-1") THEN
397.         FOR k = LBOUND(AlphaWeight) TO UBOUND(AlphaWeight)
398.             AlphaWeight(k) = k ^ 2
399.         NEXT
400.     END IF
401.     AlphaWeight(11) = 0
402.     AlphaWeight(12) = 0
403.     AlphaWeight(13) = 0
404. END SUB
405.  
406. FUNCTION BIN$ (n AS INTEGER)
407.     ' Butchered from the Wiki. Ugliest function ever.
408.     DIM AS INTEGER max, i, msb
409.     DIM AS STRING b
410.     max% = 8 * LEN(n%)
411.     FOR i = max% - 1 TO 0 STEP -1
412.         IF (n% AND 2 ^ i) THEN msb% = 1: b$ = "1" + b$ ELSE IF msb% THEN b$ = "0" + b$
413.     NEXT
414.     b$ = LEFT$(b$ + "0000000000", 10)
415.     BIN$ = b$
416. END FUNCTION
417.  
418. SUB CreateHisto (arrseqphase() AS STRING, wid AS INTEGER, arralpha() AS LetterBin)
419.     DIM AS INTEGER j, k, n
420.     FOR n = 1 TO UBOUND(arralpha)
421.         arralpha(n).Count = 0
422.     NEXT
423.     ' Hack j=1 to use base string only.
424.     ' Let the loop's upper limit =wid for phase analysis.
425.     FOR j = 1 TO 1 'wid
426.         FOR k = 1 TO LEN(arrseqphase(j)) - (LEN(arrseqphase(j)) MOD wid) STEP wid
427.             FOR n = 1 TO UBOUND(arralpha)
428.                 IF (MID$(arrseqphase(j), k, wid) = arralpha(n).Signature) THEN
429.                     arralpha(n).Count = arralpha(n).Count + 1
430.                 END IF
431.             NEXT
432.         NEXT
433.     NEXT
434.     CALL QuickSort(arralpha(), 1, UBOUND(arralpha))
435. END SUB
436.  
437. SUB PrintHisto (arr() AS LetterBin, wid AS INTEGER)
438.     DIM AS INTEGER j, n
439.     IF (wid > 0) THEN
440.         IF (wid > UBOUND(arr)) THEN
441.             j = UBOUND(arr)
442.         ELSE
443.             j = wid
444.         END IF
445.         PRINT "Histogram: "; _TRIM$(STR$(UBOUND(arr))); "-letter regroup, showing top "; _TRIM$(STR$(wid))
446.         FOR n = 1 TO j
447.             PRINT arr(n).Signature; arr(n).Count
448.         NEXT
449.     END IF
450. END SUB
451.  
452. SUB PrintGraph (TheString AS STRING, arrgrade() AS DOUBLE)
453.     DIM AS INTEGER j, k
454.     DIM AS DOUBLE f, g
455.     FOR k = 1 TO _WIDTH
456.         LOCATE _HEIGHT - 5, k: PRINT "_"
457.         LOCATE _HEIGHT - 5 - 10, k: PRINT "_"
458.     NEXT
459.     LOCATE _HEIGHT - 5 + 1, 1: PRINT "0%"
460.     LOCATE _HEIGHT - 5 - 10 - 1, 1: PRINT "100%"
461.     f = (_WIDTH) / LEN(TheString)
462.     IF (f > 1) THEN f = 1
463.     FOR j = 2 TO LEN(TheString)
464.         g = INT(j * f)
465.         IF (g = 0) THEN g = 1
466.         LOCATE _HEIGHT - 5 - INT(10 * arrgrade(j, 1)), g
467.         IF (arrgrade(j, 2) = 1) THEN
468.             PRINT CHR$(251)
469.         ELSE
470.             PRINT "x"
471.         END IF
472.     NEXT
473. END SUB
474.  
475. SUB NewAlphabet (arrold() AS LetterBin, arrnew() AS LetterBin)
476.     DIM AS INTEGER j, k, n
477.     n = 0
478.     FOR k = 1 TO 2
479.         FOR j = 1 TO UBOUND(arrold)
480.             n = n + 1
481.             arrnew(n).Signature = arrold(j).Signature
482.         NEXT
483.     NEXT
484.     FOR j = 1 TO UBOUND(arrnew)
485.         IF (j <= UBOUND(arrnew) / 2) THEN
486.             arrnew(j).Signature = "0" + arrnew(j).Signature
487.         ELSE
488.             arrnew(j).Signature = "1" + arrnew(j).Signature
489.         END IF
490.     NEXT
491. END SUB
492.  
493. SUB QuickSort (arr() AS LetterBin, LowLimit AS LONG, HighLimit AS LONG)
494.     DIM AS LONG piv
495.     IF (LowLimit < HighLimit) THEN
496.         piv = Partition(arr(), LowLimit, HighLimit)
497.         CALL QuickSort(arr(), LowLimit, piv - 1)
498.         CALL QuickSort(arr(), piv + 1, HighLimit)
499.     END IF
500. END SUB
501.  
502. FUNCTION Partition (arr() AS LetterBin, LowLimit AS LONG, HighLimit AS LONG)
503.     DIM AS LONG i, j
504.     DIM AS DOUBLE pivot, tmp
505.     pivot = arr(HighLimit).Count
506.     i = LowLimit - 1
507.     FOR j = LowLimit TO HighLimit - 1
508.         tmp = arr(j).Count - pivot
509.         IF (tmp >= 0) THEN
510.             i = i + 1
511.             SWAP arr(i), arr(j)
512.         END IF
513.     NEXT
514.     SWAP arr(i + 1), arr(HighLimit)
515.     Partition = i + 1
516. END FUNCTION
517.  
518. FUNCTION Pathological$ (TheSeed AS STRING, TheLength AS INTEGER)
519.     DIM TheReturn AS STRING
520.     TheReturn = TheSeed
521.     DO
522.         IF (Analyze(TheReturn, AlphaWeight(), 0) = 1) THEN
523.             TheReturn = TheReturn + "0"
524.         ELSE
525.             TheReturn = TheReturn + "1"
526.         END IF
527.     LOOP UNTIL LEN(TheReturn) = TheLength
528.     Pathological$ = TheReturn
529. END FUNCTION
530.  
531. FUNCTION ProtoRand$ (TheSeed AS STRING, TheLength AS INTEGER)
532.     DIM TheReturn AS STRING ' Actual output.
533.     DIM WorkingString AS STRING ' So-called working string.
534.     TheReturn = ""
535.     WorkingString = "0100100010" + TheSeed ' ...in case user sends blank seed.
536.     DO
537.         ' Change prediction model based on working string.
538.         CALL InitializeModelLiteral(RIGHT$(WorkingString, 10))
539.         ' Make prediction based on working string.
540.         ' Store the opposite result.
541.         IF (Analyze(WorkingString, AlphaWeight(), 0) = 1) THEN
542.             TheReturn = TheReturn + "0" ' Analyze returned a 1.
543.             WorkingString = WorkingString + "0"
544.         ELSE
545.             TheReturn = TheReturn + "1" ' Analyze returned a 0.
546.             WorkingString = WorkingString + "1"
547.         END IF
548.         ' Keep working string reasonably short so runtime remains O(L).
549.         IF (LEN(WorkingString) > 80) THEN WorkingString = RIGHT$(WorkingString, 80)
550.     LOOP UNTIL LEN(TheReturn) = TheLength
551.     ProtoRand$ = TheReturn
552. END FUNCTION
553.  
554. FUNCTION QBPRNG$ (TheSeed AS DOUBLE, TheLength AS INTEGER)
555.     DIM TheReturn AS STRING
556.     RANDOMIZE TheSeed
557.     DO
558.         IF (RND > .5) THEN
559.             TheReturn = TheReturn + "1"
560.         ELSE
561.             TheReturn = TheReturn + "0"
562.         END IF
563.     LOOP UNTIL (LEN(TheReturn) = TheLength)
564.     QBPRNG$ = TheReturn
565. END FUNCTION
566.  
567. FUNCTION LoadTestFile (alwayszero AS INTEGER, TheFile AS STRING, ReversalToggle AS INTEGER)
568.     DIM AS INTEGER j, k
569.     DIM n AS INTEGER
570.     DIM a AS STRING
571.     n = alwayszero
572.     OPEN TheFile FOR INPUT AS #1
573.     DO WHILE NOT EOF(1)
574.         n = n + 1
575.         LINE INPUT #1, a
576.         TestData(n) = a
577.     LOOP
578.     CLOSE #1
579.     IF (ReversalToggle = -1) THEN
580.         FOR k = 1 TO n
581.             a = TestData(k)
582.             TestData(k) = ""
583.             FOR j = LEN(a) TO 1 STEP -1
584.                 TestData(k) = TestData(k) + MID$(a, j, 1)
585.             NEXT
586.         NEXT
587.     END IF
588.     LoadTestFile = n
589. END FUNCTION
590.  
591. FUNCTION LoadTestData (alwayszero AS INTEGER)
592.     DIM n AS INTEGER
593.     n = alwayszero
594.  
595.     '''
596.     ' Percussive cases:
597.     '''
598.     n = n + 1: TestData(n) = "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
599.     n = n + 1: TestData(n) = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
600.     n = n + 1: TestData(n) = "0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101"
601.     n = n + 1: TestData(n) = "1010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010"
602.     n = n + 1: TestData(n) = "0001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011000111001100011100110001110011"
603.     n = n + 1: TestData(n) = "0100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111010001011101000101110100010111"
604.  
605.     '''
606.     ' Human samples:
607.     '''
608.     ' (from Keybone)
609.     n = n + 1: TestData(n) = "101010101010101010101001010101010101001010111001010101010101010101010100010101010101010100101001010101001100101010001010100101010100101010100101010101010101010011011110010101010100100101010110010011001010011001010100010100101010010101010101010010101010101010010101001010101010100110010101010100101010101010011001001010100101010010101010100101010010101001010100101001010010101010111010100110011001010101010100110101001010101010100101001010111010101010101010100101001010101010010101010101001010101001010101001010100101010100101010010101010101001010101001010101010101001010101001010100101010101010010101010010010101010101010101010010100101010101001010100101001010101001111101010101010100101010110011001010101010101010110101010101101010101010100101010010101010010101010101101110010101001010101010110010100101010101001011010101010100110101010100101010010101010100101010101001010101010101001010101010011010101010101110110100101010111010101011011001011001010101001010101010101010101010011001010101010100101010101010101010010100101"
610.     ' (from Keybone)
611.     n = n + 1: TestData(n) = "0101110101100011010100101011001110001011001010001110101111010100111011100100101001010011110101101000101010001010101111001010111010101010100001010101000101101100101111101010010101110110111001000101000011010101010001001001001111101011101010100010110101110101100000101010101110111010100100100001110111100101011110101010001010001110010110111110110010101001001011101000101001011100011101000010101010101101010010110100101101000101111010101110111001010011101111010101000010101111100010101011110101011011110100001010110"
612.     ' (from Loudar)
613.     n = n + 1: TestData(n) = "1011001010010100100100110010101010101001010101010101011010010101001010101001010010100110101011010101010101011010101101010101010101010010110101010101100101010101010110101101011010010101010010100110101101001010110101011010010101101010110100101111010101010011011011010010110101010010110100101101010100101011010010101001010101010001011101011010010101011100111010010001101011110010011010001011100110101010010011010101001001010010000101010110001"
614.     ' (from Luke)
615.     n = n + 1: TestData(n) = "01100101001010001100001101101111011010010101010110110101001000001111001111110101000101111011010101111101010101101010101001010101011000010101010101001011010100110100110100110011010101010101110101010111111101011010100000001101111000010111000110111001000010100001101010110100000111101011111100001011001010110010110"
616.     ' (from Sarafromct)
617.     n = n + 1: TestData(n) = "10101010101011101000011101010111010101010101100111001010100111100001011011110101000001111010101101010000001111110011111110111101110111001110110010000100010101010101010100101011010110101010101010101001000000001111110000011110101010101010100010101110101010101101111111111111111111101010101010101000000"
618.     ' (from Spriggs)
619.     n = n + 1: TestData(n) = "10111010101010101010101001010101010101001010101001010101010101010101010101010101010101010101010101010101001010100100100101010101010101001010100101010101010100101010100101010101010101010101001010010110010101010010101010101010101010101010100101001001001010101010101010101010101001010101001001101010010"
620.     ' (from Spriggs)
621.     n = n + 1: TestData(n) = "11111011110100101011111111110100000011011110101100111100111111110111101110100111100110011111110101111111010111101111100111110111111111111011100111110111111110010000101011111001110101101010110111110"
622.     ' (from Hotpants)
623.     n = n + 1: TestData(n) = "01010100011001010010101010101010101000110101010111101010100100011010101010100100101110010010010100001010101001010101010110010001001011000100100110101001001001010000000001010101101111101001010100010101001001010101000100101001100100010011010101010101010111010010101011101011011010110100100010010100100100010010001001"
624.     ' (from [banned user])
625.     n = n + 1: TestData(n) = "11011011011101011010001011001110001101011001001111110000110111011101100100101110110001110011001100111110011011001110100000101001011010001100011100011100011100010011100101110100011011001101000111001111100110111011101110110000111011101010010010011000101100011010001111100100100011100111001100011110001"
626.  
627.     LoadTestData = n
628. END FUNCTION
629.  

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 03, 2022, 03:09:25 pm

 STxAxTIC

Thanks, it will take me a while to digest everything so as to decide what will best fit
what I am doing right now.  You mentioned my combining the tools but last night I
got to thinking and had the though, what if I added a negative value as the weight.
I set M1 positive but M2 and M3 both to a negative value and guess what?  I saw a
improvement right off.  After toying around I was able to get above 70% and the
big thing was the overall predicted (1's) dropped but the hit ratio improved.

Most days after a data update I check to see how many values repeat from the previous
update.  I have several sets of data but the one set I use most often normally has around
35 to 40 repeats out of 105 strings I track.  Setting the M2 and M3 weights to a negative
value gave the thing a big push.  I am seeing around 35 (1's) in the output with a hit rate
close to 70%.  In one test the program came up with 38 predictions and 32 were correct,
Wow, never seen that coming.   Anyway, still tinkering with the settings, must be millions
of ways to adjust things, each run takes a few minutes so it's a slow slow process and already
thinking of how to automate it.  I have six or seven old Dell 6000 that were configured for
max performance just setting in my closet collecting dust.  I may have to dig them out and
put them to work.  Come to think of it, a couple of them are in like new condition which were
never used.       

Anyway, mucho gracias and will let you know how it all works out.

R1

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 06, 2022, 12:53:57 am

I think I got everything put together, the picture show the results before any fine tuning
and without the weights set.  Looking good so far.
R1


https://i.postimg.cc/6q3V8W0F/RESULTS.png
 (https://i.postimg.cc/6q3V8W0F/RESULTS.png)

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 06, 2022, 10:51:50 am

STxAxTIC

Quote

I'm not sure how exactly you're optimizing your solution, but imagine a search in parameter space. Lemme freestyle this... Suppose your models are M1, M2, and M3. Then the nth digit in your sequence is predicted by each model, denoted as M1(n), M2(n), M3(n). Okay, so you talked about switching these on or off. Did you try blending them? Like this:

P(n) = w(1)*M1(n) + w(2)*M2(n) + w(3)*M3(n)

This means the total prediction of the nth bit is the weighted average of all three models, and the question becomes what the hell do we do with w(1), w(2), and w(3)? The most prudent thing possible is to imagine a sphere... actually ya know what? Let me do this in two dimensions first. Suppose for clarity you have only two models. Then we can skip the third everything:

P(n) = w(1)*M1(n) + w(2)*M2(n)

I'm still working on several methods, I added a setting to the configuration so that I and have more
that one option.  Right now it allows up to 4 different methods to be used.  what I did was add the
raw data output, ie, probabilities from each predictor to an array which can be passed directly to the
method set in the config utility.  This way I can test them against each other.  I also automated the
test option so that it's possible to run 100's of test unsupervised.  The results are written to a text
file which can then be analyzed by hand.

If your still tinkering around with this and have some suggestions then I will try them out.  I am in
the process of adding the methods mentioned above.

R1

Picture of the config setting for selecting the blending method.  I suppose it's only limited to the
imagination, but right now it's set to allow 4 different methods.  Who knows, maybe some kind
of crazy strange code will take it over the top.  I am open to anything.   


https://i.postimg.cc/DZ8Yst1N/BLEND.png
 (https://i.postimg.cc/DZ8Yst1N/BLEND.png)

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 07, 2022, 12:11:57 pm

I have been tinkering with fine tuning the prediction tool and wanted to post the test results
of my last test run.  So far the best hit rate I have been able to achieve was 38 of 40 correct
for a score of  95% for  40 strings.  Most test show mid 70's with a few 80's in the results
but I am just getting started with the fine tuning.  Below I attached a file showing the results
of 50 back-test that I use to evaluate my configuration settings.  This is not the best but one
the many I have tried so far.  I also attached a picture that shows to read the results. 

Anyway, anyone interested in how the project is going can take a peek.

R1

Picture instructions on reading the results

https://i.postimg.cc/Pq4BR3Kj/TEST.png
 (https://i.postimg.cc/Pq4BR3Kj/TEST.png)   

The results file

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 07, 2022, 04:33:11 pm

Best score today

Test # 76
Total Strings = 40
[P1 =10]  [Hits = 8]  [Misses = 2]
[P0 =30]  [Hits =29]  [Misses = 1]
Actual 1's = 9   H-Ratio =.8888
Actual 0's =31   H-Ratio =.9354
Overall hits=37 of 40
Predictors score =.925
1's Missed on string =24,32
0's Missed on string =23
A=0000-0001-0001-0011-0001-0010-0001-0000-0000-0011
P=0000-0001-0001-0011-0001-0001-0001-0001-0000-0011

Still tinkering

R1

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 10, 2022, 08:48:31 am

All set up to do some serious fine tuning, wife walked in and laughed.
Ever see a old nerd's man cave.  On the bright side,  all seven of the
dell inspiron 6000 booted without a hitch.  Some have not been booted
for five or six years, even the batteries seem to have taken a full charge.
Anyway, I am ready to do some serious testing.

https://i.postimg.cc/prLkPy01/posted.png (https://i.postimg.cc/prLkPy01/posted.png) 
 

R1

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on January 10, 2022, 09:37:20 am

Dude that is a serious mancave, you should pull up a matrix screensaver on each machine and recreate the setup from the movies!

Happy tuning btw!

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 11, 2022, 03:12:52 pm

STxAxTIC

LOL, I had to drag out another portable table and make a u-shaped configuration.
It was too time consuming closing the lids so I could get to the back row to make
adjustments.  Overall the test yielded nothing, after 5 hours the best was around
90% and the overall average was in the high 70's.  Going to have to try something
else.

I hate to bother you with another request but today I came up with another idea
for tuning.  If interested the attached file contains comma delimited entries of
the raw outputs of the 3 predictors plus a 4th that shows the overall hit shows for
both 0's and 1,s and the last entry in each line is the correct prediction value.

This data is compiled by taking the 3 predictors output probabilities and then using
P^2, and nothing else.  The data contains 100 test with a blank line at the end of
each run to separate them.  I used 40 strings in the test so each run contains 40
results.   

The first 4 columns are the (0) output probabilities, the second 4 are for the (1's).
The last entry is the actual value that showed in the next update.  The lines that
have all 1'a are the strings that are made up of all zeros, ie, no ones in the string
being processed. 

The idea is to try to find a small range that could be added at the end of each
prediction represented by each row.  As it is now I add the 3 predictors outputs
and then divide by 3 for both 0's and 1's then take whichever is higher and use
that value as the prediction.

Here is one of the best results from yesterday's test.  I was hoping for high 90's or maybe
even 100% No such luck
 
Test # 64
Total Strings = 40
[P1 =18]  [Hits =14]  [Misses = 4]
[P0 =22]  [Hits =22]  [Misses = 0]
Actual 1's =14   H-Ratio =1
Actual 0's =26   H-Ratio =.8461
Overall hits=36 of 40
Predictors score =.9
1's Missed on string/s ->12,27,31,38
0's Missed on string/s ->
A=0001-0111-0000-0011-0001-0011-0001-0001-0001-0011
P=0001-0111-0001-0011-0001-0011-0011-0011-0001-0111
End of prediction.............

The goal of the file below would be to use it as a training set in order to calculate  lower and
upper threshold range that can be applied in the final stage to tip the output in the direction
so to increase the overall hits.  This data was calculated without my so called boost weights.

Anyway, if you have the time to mess with it, otherwise please don't feel any obligation.  Just
throwing it out there.  I am going to calculate a running average then calculate a tipping value
which would be the value needed to off set the predicted enough to swing the prediction in
favor of the correct value.  Sounds simple enough but may need a new training set after each
update.       
 

 File image, explains the data structure.
 
https://i.postimg.cc/zDdmYrTx/help.png (https://i.postimg.cc/zDdmYrTx/help.png)

     

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 12, 2022, 05:51:09 pm

Hi all

I was getting a bit discouraged with my project and decided to do a random test.
I set the prng to generate a integer between 0 and 100 and then used mod 2 to
get a odd / even value, even=0 and odd<>0 =1.  I ran 100 test and it's best hit
rate was 70% with a overall average or just over 50%.

The project's best so far is in the mid 90's with a overall average of .775.  The overall
is showing around 27 points higher on average, maybe I am making more progress
than I thought.   

R1

Title: Re: Looking for old program or help recreating it
Post by: STxAxTIC on January 12, 2022, 06:04:38 pm

Hey random1,

I've been trying to cook up a response but have been swamped with all other kinds of self-induced distractions. You brought up a lot of different things and I'm admittedly way far behind. Everyone else is still in last year with respect to this discussion, I think. It's just you and me.

I'm trying to understand what's happening in your latest update. Are you saying that you used QB64 to generate random data, and then through your models, you can get prediction scores in the 70s? How long are these samples? Because when I do this, I get 50% plus or minus a standard deviation. See why I'm picking on this discrepancy though? Something's responsible for 70%. What are those details?

Since the details are really piling on - and maybe you'll benefit from doing this the same way I did - are you able to write up (in some preservable format) what's happening on your end? Would it be too much for me to say "I'll take the answer to my question off the air, and instead wait for your book"? Just kidding...

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 13, 2022, 10:28:28 am

STxAxTIC

It's my fault because I have been jumping around all over the place with respect to
just about everything.  I am working with several different data-sets and with two
different predictors.

Ok, for clarity I will stick to one data set attached file below named Temp.txt.  This file
contains 40 strings each with 750 entries or data-points.

What I did for the random test was to use my prng function that's old as the hills and
needs updated.  It uses a time based seed with a few extra things thrown in to try and
make it more random.

For the test mentioned in that post I simply added the prng at the end of the prediction
process.  What it does is ignore the predicted value and generates a random value.  The
Prng  generates a value from 1 to 100 which I will call (r).  After the value is generated
I use r=r mod 2.  If r > 0 then the prediction is (1), if r=(0) then the prediction is 0.
 
Because the prng is time based I allow the predictors to run I just swap out the prediction
with the randomly generated value.  I could have used Rand(0,1) to get the value but
by allowing it to first generate a value between 1 and 100 then using mod to get a odd
even value it seems to be more random.  The plan is to swap out the old prng with the
one you posted, just haven't got to it yet.

In the random test the prng managed one 70% correct prediction across the entire 40 string
run.  Most however were in the high 40's but some were as low as 30% correct.  With the
prng I am using the test results were expected.  The overall average gotten from storing the
individual results and then dividing to get a average came out to be something like 50%.  Since
working with 0 or 1 as the prediction I would think the results "were as" expected.

I have been playing around with the 3 in 1 predictor I mentioned early in the topic, specifically
with blending outputs into a single prediction via playing with the weights.  I have two weights
for each predictor, one of which is a sort of static boost that is used when processing strings where
zeros outnumber the ones by a large margin.  Without these boost-weights the zero biased strings
will always be predicted (0).  Probably not a good method, just another rabbit hole grasping a straws
to try and improve the overall.

There is a forth value that is generated for each string which is the population of 0's and 1's within
the entire string being analyzed.  I haven't figured how to use it but think it might be processed into
the main predictions to help with the zero biased strings.

The best test score for the 3 in 1 predictor was one 38 out of 40 or a 95% correct.  Being the
stupid monkey that I am, I did not save the configuration settings for that run.  My best score
since then has been been 92.5%, 37 out of 40 correct.  These 90% plus hits are few and far
between, sad to say.   In general, running 100 test I end up with an average overall score of
77% and a best of 90%. Very few show better than 90%

It seems that I have hit a wall and can't fine tune beyond my current level.  I do however have
hope that I can somehow include the 4th value, ie, the overall counts for both 0's and 1's into
the prediction and push it a little higher.   

If I compare the random test vs the 3 in 1 results then it does seem that I have made some
progress but it turns out it's not enough to meet my needs. 

A couple post back I posted a file that contains the raw outputs for each of the 3 in 1 predictors
plus the 4th overall 0 and 1 counts.  This was generated to allow me to try and fine tune the
predictor without running it.  The first four values are the 0's values, the second 4 are the 1's.
The last entry is the correct value, ie, the value that should be predicted.

The file is comma delimited which makes it easy to load the 3 in 1 predictors outputs which I then
play around with trying to configure the weights in such a way to increase the hits.  Doing a 40
string 100 event test takes several minutes but doing it this way, it takes less than a second when
just working with the predictors raw outputs.

I did find your thoughts on dissipation of patterns interesting.  Patterns emerge, run for some
extended length and then dissolve for some unknown length of time only to reappear.  Will they
start up again and if so when; that's the million dollar question.  Lets say we are working with a
6 digit binary pattern.  The pattern has finite arrangements of 000000 to 111111 6^2=64.  If
dealing with random strings one would expect each to appear 1 in 64 on average +/-  some small
standard deviation. 

Whenever we see patterns repeating at a greater than expected average then it seems that some
thing else may be going on that's not easily derived.  Also the lack of some patterns adds to the
dilemma.   

Anyway this is getting long so I will close. 

R1



   
 

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 13, 2022, 11:50:12 am

STxAxTIC

I am posting a test from the strings posted above.  The attached pic shows the Mal-9K
predictor tool so that you can see the user settings and the overall results which are
the last line in the lower window.

The user settings are divided by predictors, ie, the 3 in 1 tool.  The first column is for
predictor 1, the second for predictor 2 etc..

The top entries control the string length for each predictor.
The second and third cells in the first column control the length of the pattern, low/high alphas
So for this setup it uses lengths of 4 to 5 digits.

Bwt's = the static boost weights for all 3 predictors

Lm1 to lm3 are _limit values in the main iteration loops used only to make the left process bars
look normal.  These are set to 7000 for speed reasons, makes the bar graph unreadable, just 
flickers.

The lowest rows first cell set the number of back-test, the 2nd sets the blending method and
the third activates the predictors.  It allows setting active any or all three prediction tool active.
Here it is set to use all 3.

The second column 2nd cell sets the sample size and the 3rd sets the iterations for predictor 2

The second and 3rd values in the third column sets the 3rd predictors gap start and finish.  Here
it is set to just look at every 10th to every 60th value in the string.  The predictor first goes through'
the string counting only every 10th entry then every 11th etc up to gaps of 60. Very simple tool.

https://i.postimg.cc/B6QSbPD1/test-run.png (https://i.postimg.cc/B6QSbPD1/test-run.png)

The save button causes the program to write the predictor test data to a file.  These are the two
attached files below. 

The first file shows the raw data output with the boost value added.  The second shows the stats
for the 100 test predictions. 

Anyway, just throwing this out if your interested.  Might help you understand my post.  I have a
place dug out for your predictor once your totally finished with it.  Waiting patiently

R1   

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 13, 2022, 11:59:36 am

P.S.

In the test above it's set to add the boost weight to the predictors (0) output values.
which is part of blending method 1, blending method 2 adds the boost to the 1's output.
Just wanted to clear that up.  There are 5 different blending methods of which #5 is the
random test option.  The blending methods can also be combined but I have never tested
that option yet.

R1

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 13, 2022, 02:50:13 pm

Here's something interesting, for a while now I have noticed when scrolling through the
mal.txt file that many of the predictors missed (1) predictions fall on every 4th string, ie 
4,8,12,16,20,24,28,32,36,40.  This got me to thinking that I need to add a reevaluation
algorithm for these strings, a second look so to say that's based on some other type of
analysis whenever a (1) is predicted for these strings.  Maybe do the same thing for
other strings that produce the most missed (0) predictions.

https://i.postimg.cc/xqVJxr62/t44.png (https://i.postimg.cc/xqVJxr62/t44.png)

R1
   

Title: Re: Looking for old program or help recreating it
Post by: random1 on January 15, 2022, 12:59:21 pm

STxAxTIC

I think I have reached the end and although the overall results are better than I expected
they fall short of my needs.  The best result for a single 40 string run have been 38 of 40
correct for a hit rate of 95% but the overall average for 100 back-test runs has been .77%

I think I have exhausted my options for the predictors I am working on and don't see anyway
to improve it beyond it"s current rate.  Predictors 1 and 2 closely mimic the one you built
with minor differences so unless you find something magical to add then I think we can call
it finished.

Anyway, thanks for everything.

R1 
 

 
   

Text Only | Text with Attachments