- Home
- Premium Memberships
- Lottery Results
- Forums
- Predictions
- Lottery Post Videos
- News
- Search Drawings
- Search Lottery Post
- Lottery Systems
- Lottery Charts
- Lottery Wheels
- Worldwide Jackpots
- Quick Picks
- On This Day in History
- Blogs
- Online Games
- Premium Features
- Contact Us
- Whitelist Lottery Post
- Rules
- Lottery Book Store
- Lottery Post Gift Shop
The time is now 10:12 am
You last visited
May 11, 2024, 10:02 am
All times shown are
Eastern Time (GMT-5:00)
Visual Basic Programing and MathPrev TopicNext Topic
-
When I first started exploring trends in lottery numbers I knew nothing about calculating probabilities and was a novice coder. When I turned to the internet to help with the math and coding there was not a whole lot available. Most of the code snippets out there referred to business use case scenarios and even when I did find math online that could potentially help me with my quest it was often quite difficult to figure out how to translate it into usable code. In the end, I was left to figure a lot of things out on my own.
I settled on VB as my language of choice because I was kind of familiar with the basic syntax, had access to a development tool in Visual Studio and there were plenty of resources available to help with syntax issues.
For a lot of the things I have done I’m sure there is an appropriate math terminology that I wound up in making up my own name for, so my apologies if I offend the sensibilities of any mathematicians out there. My goal was to find a trend, not to become a mathematician.
It is the same thing with coding. I was learning as I was doing and the goal was the solution, not to become a developer so much of my code doesn’t follow field standards, especially the earlier stuff.
This thread is going to be a listing of some the code snippets that I wish that I had been able to find online when I started out on this journey. Hopefully they will save the next person starting out down this road some time. The second reason is that if someone sees an opportunity to improve on the work I’ve done I would certainly welcome the opportunity to learn a different and more efficient way of achieving the same results.
In trying to find trends one of the things I needed to see were all the possible combinations of a number set. To figure out all possible combinations picking 2 numbers out of 10 I would write the following code:
Dim NumList As New List(Of String)
Dim PH(40), PE(40), Base As Byte
Base = 10
For DC = 1 To 10
If DC <= Digits Then
PE(DC) = Base
End If
Next DC
For P1 = 1 To PE(1)
PH(1) = P1
For P2 = (PH(1) + 1) To PE(2)
PH(2) = P2
Dim Pattern As String = ""
For DC = 1 To Digits
Pattern = Pattern & "," & PH(DC)
Next DC
NumList.Add(Pattern.substring(1))
Next
Next
The nice thing about this code is that it did the job and did it quickly. The problem with this code was that it was not overly flexible if I wanted to change the number of digits. I eventually did figure out a way around that issue that involved multiplying the start and end values of the for/next loops of the digits that I did not want to use by 0.
The other big downside was that I was always limited to doing whatever calculations I within the innermost for/next loop. With numbers that were 10 digits long it was a lot of code to have paste repeatedly so I made the decision to find another way.
It took a lot of time for me to figure this method out, but this is the code that I now use to show all combinations:
Public Function Calc_Permutations(ByVal Base As Integer, ByVal Digits As Integer) As Long
m_Base = Base
m_Digits = Digits
Dim BaseSum As Double = 1
Dim DigitsSum As Double = 1
For DC = 0 To Digits - 1
BaseSum = BaseSum * (Base - DC)
DigitsSum = DigitsSum * (Digits - DC)
Next
m_TotalCombos = BaseSum / DigitsSum
Return m_TotalCombos
End Function
Public Sub Combos_Seq_Initialize(ByVal Base As Integer, ByVal Digits As Byte)
m_Base = Base
m_Digits = Digits
m_TotalCombos = Calc_Permutations(m_Base, m_Digits)
For DC = 1 To m_Digits
m_RotVal(DC) = DC
m_RotCap(DC) = m_Base - (m_Digits - DC)
Next
m_RotVal(m_Digits + 1) = 1
m_RotCap(m_Digits + 1) = 1
End Sub
Public Function Combos_Seq_Next_Digit(ByVal DC As Byte, ByVal PID As Long) As Integer
If PID = 1 And DC = 1 Then Call Combos_Seq_Initialize(m_Base, m_Digits)
Dim Digit As Integer = m_RotVal(DC)
m_Digit(DC) = Digit
If m_RotVal(DC + 1) + 1 > m_RotCap(DC + 1) Then
m_RotVal(DC) += 1
If m_RotVal(DC) > m_RotCap(DC) Then
m_RotVal(DC) = m_RotVal(DC - 1) + 1
End If
End If
Return Digit
End Function
It runs just as fast as the other code, but more importantly it supports any number of digits (although this version is capped at 255) and I can wrap it up in a class so that now whenever I want to run it I can write the following code:
Dim WinDigits as byte = 10
Dim PickDigits as byte = 2
Dim Combos As New clNumUtilities(WinDigits, PickDigits)
Dim NumList As New List(Of String)
For PID = 1 To Combos.TotalCombos
Dim Pattern As String = ""
For DC = 1 To PickDigits
Pattern = Pattern & "," & Combos.Combos_Seq_Next_Digit(DC, PID)
Next
NumList.Add(Pattern.substring(1))
Next
-
While trying to find trends one of the things I wanted to be to do was to know what the number value represented a set of numbers. For instance, in a pick 5 out of 30 1,2,3,4,5 would be represented as 1, 26,27,28,29,30 would be 142506. Those are easy, the problem was getting all values in between. I also needed to make sure that if I picked a value that I could then get the number set from that value.
The following code is a sample of the class library that I used to accomplish this.
Public Class clNumberConversion
Private m_PidBase As Byte
Private m_DigitsPerLevel(10, 80) As Long
Private m_Base As Byte
Private m_Digits As Byte
Private m_Nums(10) As Byte
Private m_PID As Long
Private m_NumString As String = ""
Public Sub New()
End Sub
Public Sub Set_Nums_From_String(NumString As String)
Dim Pos As Byte = 0
For Each RW In NumString.Split(",")
Pos += 1
Set_Num(Pos, RW)
Next
End Sub
Public Sub Set_Num(Pos As Byte, N0 As Byte)
m_Nums(Pos) = N0
End Sub
Public Sub PID_For_Seq_Nums_Initialize(Base As Byte, Digits As Byte)
m_Base = Base
m_Digits = Digits
ReDim m_Nums(m_Digits)
ReDim m_DigitsPerLevel(m_Digits, m_Base)
m_PidBase = (m_Base - m_Digits)
Dim PidChangeSum As Long
For DC = 0 To m_PidBase
m_DigitsPerLevel(m_Digits, DC) = 1
Next DC
For DC = m_Digits - 1 To 1 Step -1
For N = 0 To m_PidBase
PidChangeSum = 0
For Z = N To m_PidBase
PidChangeSum = PidChangeSum + m_DigitsPerLevel(DC + 1, Z)
Next Z
m_DigitsPerLevel(DC, N) = PidChangeSum
Next N
Next DC
End Sub
Public Function Calc_PID_For_Seq_Nums() As Long
Dim StartDigit As Integer
Dim StartBlock As Integer
Dim Diff As Long
Dim LastDiff As Long
m_PID = 0
If m_Nums(m_Digits) <> m_Digits Then
StartDigit = 1
Do While StartDigit - m_Nums(StartDigit) = 0
StartDigit = StartDigit + 1
Loop
StartBlock = 0
LastDiff = 0
For DC = StartDigit To m_Digits
Diff = m_Nums(DC) - DC
If LastDiff <> Diff Then
For Z = StartBlock To Diff - 1
m_PID = m_PID + m_DigitsPerLevel(DC, Z)
Next Z
End If
StartBlock = Diff
LastDiff = Diff
Next DC
End If
m_PID += 1
Return m_PID
End Function
Public Function Calc_Seq_Nums_From_PID(PID As Long) As String
m_PID = PID
Dim Rot(20) As Integer
Dim StartDigit As Integer = 1
For DC = m_Digits To 1 Step -1
If m_DigitsPerLevel(DC, 0) < m_PID Then StartDigit = DC
Next DC
If StartDigit <> m_Digits Then
Dim CPID As Long = 0
Dim StartBlock As Long = 0
Dim LastDiff As Long = 0
For DC = StartDigit To m_Digits
Dim CD As Long = StartBlock
Do While CPID < m_PID
CPID = CPID + m_DigitsPerLevel(DC, CD)
CD = CD + 1
Loop
StartBlock = CD - 1
Rot(DC) = CD - 1
CPID = CPID - m_DigitsPerLevel(DC, CD - 1)
Next DC
Else
Rot(m_Digits) = m_PID - 1
End If
m_NumString = ""
For DC = 1 To m_Digits
m_Nums(DC) = DC + Rot(DC)
m_NumString = m_NumString & "," & m_Nums(DC)
Next DC
m_NumString = m_NumString.Substring(1)
Return m_NumString
End Function
End Class
Here is a sample of the code in use:
Running the code looks like this:
Dim NumCon As New clNumberConversion
NumCon.PID_For_Seq_Nums_Initialize(tbVal1.Text, tbVal2.Text.Split(",").Length)
NumCon.Set_Nums_From_String(tbVal2.Text)
lbResults.Items.Insert(0, "Numbers: " & tbVal2.Text & " PID: " & NumCon.Calc_PID_For_Seq_Nums())
The Initialization of the base values is separate from the calculation portion because most of the time I am converting millions of numbers at a time and running the initialization each time would slow it down.
I found being able to look at the numerical values of numbers very helpful as it allowed me to explore different ways of finding trends and generating numbers.
For example, if I wanted to randomly pick a number for a P5B30 game I can just pick a number between 1 and 142506 as opposed to having to pick 5 numbers and then sort them. It also allowed me to look at trends in terms of where they fell in number ranges as opposed to just the picked number values.
I wrote this about 8 years ago, have learned a lot since then and could probably write something that is more efficient, but the code runs quite quickly and is flexible so I have not bothered to update it. If anyone has any better ideas for accomplishing the same result I would definitely appreciate seeing them.
-
Hi Novan60, I use VB6 for my study Italian lottery. I'm no expert, and so far I have not found the web VB source code for the study of lottery combinations. Millions of combinations in a pick 5 out of 90 lottery requires a lot of processing time if you use it for next cycles. Is there a faster way? I read the tartaglia triangle and use of binary numbers ...... ..I can you help?
Cordiality -
Quote: Originally posted by mirapep on Mar 6, 2017
Hi Novan60, I use VB6 for my study Italian lottery. I'm no expert, and so far I have not found the web VB source code for the study of lottery combinations. Millions of combinations in a pick 5 out of 90 lottery requires a lot of processing time if you use it for next cycles. Is there a faster way? I read the tartaglia triangle and use of binary numbers ...... ..I can you help?
CordialityYou should get away from VB6 and upgrade to the latest version of Visual Studio so that you can leverage the functionality in some of the more recent Frameworks. More importantly the full feature version of Visual Studio is now free.
As for what you are trying to accomplish I am curious as to why you feel the need to run through all 43,949,268 combinations of numbers. Interestingly enough this was the same path that I started down in my early endeavors I thought that in order to find the winning combination I needed to run through every possible combination of numbers to get to a winner. It took me a while, but I eventually figured out that is not the case although trying to figure out faster ways of running through combinations eventually wound up in being helpful later on.
My suggestion is that instead of focusing on all of the possible combinations, find a way to group the numbers into segments of numbers that result in a manageable amount of combinations. This is basically how most strategies work. They separate the numbers using various methodologies resulting in sub sets of likely numbers.
For instance if you separate the numbers by the number of drawings since they last appeared you would wind up with at a minimum 18 sets of 5 numbers, but more realistically it would probably be somewhere north of 35 sets with most containing 1-3 numbers. You would then be faced with determining which sets the numbers are going to come from.
In probably about 30% of the drawings the winning number would come from 5 different sets because that number represents the bulk of the possible number combinations. If there were 35 sets and you chose any 5 of them that would be 324,632 combinations of sets. Ideally you would have some strategy for reducing the number of possible sets likely to appear in the next drawing and maybe be able to narrow it down to 10 sets result in 252 combinations of numbers if you picked 5 out of the 10.
If each set averaged 3 numbers that would result in 243 possible combinations if you took one number from each set. If you decided to pull 5 from all 15 then there would be 3003 combinations.
Another example is the hot/cold strategy. If you divide the numbers into hot, cold and warm you get 3 groups of numbers averaging about 30 numbers each. You may choose to take 3 from the hot group and 1 each from the cold and warm groups. The hot group would give you 435 two digit combinations. The total number of combinations with all the groups would be 391,500.
-
Thanks for your kind response. I worked a lot on its own to understand VB6 and switch to other programming language ............ ..Bhum! I have tried many strategies but in the end I'm giving up. There is no way to win on the bench. I also built virtual archives to multiply favorable assumptions of play.
In short, I would only predict a number but any bet progression does not work. A single number pays 1 to 11 the bet against a likely favorable than 1/18.
He was curious about his strategy with binary numbers and do not know if it can work with the Italian lottery.
I apologize but I use google translator.
Thanks again -
Quote: Originally posted by mirapep on Mar 6, 2017
Thanks for your kind response. I worked a lot on its own to understand VB6 and switch to other programming language ............ ..Bhum! I have tried many strategies but in the end I'm giving up. There is no way to win on the bench. I also built virtual archives to multiply favorable assumptions of play.
In short, I would only predict a number but any bet progression does not work. A single number pays 1 to 11 the bet against a likely favorable than 1/18.
He was curious about his strategy with binary numbers and do not know if it can work with the Italian lottery.
I apologize but I use google translator.
Thanks againWith the latest version of Visual Studio you would still be able to program in VB and it will import your current projects (be sure to make backups). Some syntax has changed and new functionality has been added, but the core of it is essentially the same and well with the upgrade.
Unfortunately there is no way to predict what the winning number for a specific drawing is going to be. The only thing you can really do is look for high probability patterns that limit your choices to a number of combinations that offer reasonable odds.
There are two issues with that though, statistics do not matter in a single drawing. By that I mean that within a single drawing the statistics reset themselves making almost anything possible including the exact same numbers that appeared the day before, appearing again.
The other is that the more conditions that are added to a pattern the larger the gap is between each drawing that the pattern occurs. For instance if I split the numbers evenly between hot and cold and say that I'm going to pick 3 from the hot and 2 from the cold that would mean there are 14,040,100 possible combinations. Given that 14 million is roughly 1/3 of the 44 million combinations that means that statistically I could expect to see a winner once every three drawings.
If I add another condition to the strategy where 2 of the numbers are even. That would lower the possible number of combinations to 1 in 2,816,396 million if one side had 22 even number and each side had to have 1 even number. This would mean that on average one of these numbers has a chance of appearing once every 16 or so drawings and that you should be prepared for some instances when they may not appear for 100 drawings, but that would be statistically rare.
I get to those numbers using the following math:
90 /2 = 45 for our hot and cold
We are picking 3 numbers from the hot side and 22 of them are odd. Because 1 has to be odd that means that there are 253 possible combinations of odd pairs. 253 * 22 = 5,566 combinations of hot numbers
On the cold side there are 23 even number and 22 odd numbers. Since we are only picking 2 from the cold side and one has to be even that means 22 * 23 = 506 possible combinations on the cold side.
5,566 * 506 = 2,816,396 possible combination. 43.9 /2.8 = 15.7 which means that about once every 16 drawings we would have a 1 in 2.8 million chance of picking the right drawing.
And this is the essential problem of almost any strategy system. The more conditions the larger the window and unfortunately most of us will not live long enough to be able to play a strategy that would offer winnable odds when the guaranteed pattern occurs as that window is several thousand drawings.
To offset this many strategies increase the number of conditions played within the strategy hoping to shrink the window. The problem with this is that shrinking the window usually means playing more games per drawing and even significant spends per drawing do not decrease the window significantly enough to make the jackpot worth what was spent.
If you do not have your program draw every combination on screen the code posted for above for listing combinations will run through all combinations in less than a minute. Drawing to the display takes a lot of processing power. To give you some idea of the difference in 45 minutes it had only processed 5 million rows when I had it draw the combinations to the screen.
Depending on what math you are doing it certainly is possible to run through all the combinations in a reasonable amount of time. That said I would highly advise loading any historical data into memory as calls to a database are extremely slow and could potentially add hours if not days to how long it takes to run through all of the combinations.
Dim WinDigits as byte = 90
Dim PickDigits as byte = 5
Dim Combos As New clNumUtilities(WinDigits, PickDigits)
Dim NumList As New List(Of String)
For PID = 1 To Combos.TotalCombos
Dim Pattern As String = ""
Dim ValidNum as boolean = false
For DC = 1 To PickDigits
Dim V as byte = Combos.Combos_Seq_Next_Digit(DC, PID)
Pattern= Pattern & "," & V
'Do some trend stuff here to evaluate whether it should be a possible set to pick from
Next
if ValidNum then NumList.Add(Pattern.substring(1))
Next
-
Private Sub Main()
frmSplash.Show
frmSplash.Refresh
Dim y1 As Long, y As Long, temp2 As Stringtemp2 = "c:\temp1\Arfitlotto" + ".dat" ' This routine for virtual history data.This file is a random sequence 1 to 90 for
Open temp2 For Binary As #4 ' create 10000 virtual history data.
For y1 = 1 To 10000
For y = 1 To 90
Get #4, , x(y1, y)
Next
Next
Close #4
Dim l As Single, a As String, FileLength
Dim lunrec As Double, ruota, posizione, indice, numtmp(1 To 5)
ruota = 1
posizione = 0
indice = 0
Form1.Cbestrini.Clear
Form1.Cbestrfin.Clear
Open "c:\Archivio.txt" For Input As 1
FileLength = LOF(1) ' Get length of file.
lunrec = 100 / Int(FileLength / 111)
While Not EOF(1)
Line Input #1, a
frmSplash.ProgressBar1.Value = frmSplash.ProgressBar1.Value + lunrec
Form1.Cbestrini.AddItem Left(a, 10)
Form1.Cbestrfin.AddItem Left(a, 10)
Principale.CbEstrazione.AddItem Left(a, 10)
indice = indice + 1
For l = 11 To Len(a) Step 2
posizione = posizione + 1
If posizione = 6 Then
posizione = 1
ruota = ruota + 1
If ruota = 11 Then ruota = 1
End If
num(ruota, posizione, indice) = Val(Mid(a, l, 2)) ' matrix with history data
numtmp(posizione) = Val(Mid(a, l, 2))
Next
Wend
Close #1
Form1.Cbestrini.ListIndex = Form1.Cbestrini.ListCount - Form1.Cbestrini.ListCount
Form1.Cbestrfin.ListIndex = Form1.Cbestrfin.ListCount - 1
Form1.Estrini(0).Caption = Format(Form1.Cbestrini.ListIndex + 1, "###0")
Form1.Estrfin(1).Caption = Format(Form1.Cbestrfin.ListIndex + 1, "###0")
Form1.Estrtot(0).Caption = (Format(Form1.Cbestrfin.ListIndex + 1, "###0") - Format(Form1.Cbestrini.ListIndex + 1, "###0")) + 1
estrazioneini = Val(Form1.Estrini(0).Caption)
estrazionefin = Val(Form1.Estrfin(1).Caption)Unload frmSplash
Form1.ShowEnd Sub
To do the job you suggested use within seconds
Which method you use to search for hot and cold numbers?
Thank you
-
Something about the virtual archives.
For each draw, starting at 1 and up to 90 extraction and then start from 1,
high to 5 numbers drawn the random number. In this way
It creates a virtual extraction linked to the real one.
In practice, imagine that the same extraction procedure of
NY lottery is adopted in other 1000 or more states . You would have 1000 statistics
and to compare different hot and cold numbers for example.
Then to extrapolate the most probable numbers you must convert the number
Virtual in real number
Very briefly. If interested we can continueWe feel when you wake up. Good sleepFor me, the day has just begun -
I must admit that I am not certain what you are trying to accomplish. For instance why does your virtual historical data needs to contain all 90 numbers?
With the pick 10 if I were to store every combination of 10 digit winning combinations I would need to save 184,756 rows of data for every single drawing. Instead what I do is store is the 20 winning numbers and then convert the winning combinations as I need them. the process to convert them faster than it would take to load them all into memory.
For instance in the following sample if I wanted to see what the most common sum of winning number was. I'm sure that some mathematician could right a formula to calculate what that average would be based on all the combinations of number, but I'm stuck having to count on my fingers so I would write something that does this:
As you can see to process 100 drawing it took less than a minute. It is processing 184,756 combinations per drawing and 383 appears to be the most common sum for the winning numbers.
Here is the code that does that:
Private Sub See_Num_Sum_Freq()
tblValue1.Clear()
bsTotals.Sort = ""
bsTotals.DataSource = ""
bsTotals.DataSource = tblValue1
dgvTotals.DataSource = ""
dgvTotals.DataSource = bsTotals
bsTotals.Sort = "Drwing desc , minhits desc,AvgHits desc, AllHits desc, value1"
Dim PlayDays As Integer = CInt(tbCondition1.Text) - 1
dgvTotals.Columns(0).HeaderText = "NumSums"
For Each Clm As DataGridViewColumn In dgvTotals.Columns
Clm.AutoSizeMode = DataGridViewAutoSizeColumnMode.DisplayedCells
Next
Dim MinSum As Integer = 0
Dim MaxSum As Integer = 0
For DC = 1 To 10
MinSum += DC
MaxSum += NumBase - (DC - 1)
Next
For DC = MinSum To MaxSum
tblValue1.AddtblValues1Row(DC, 0, 99999999, 0, 0, 0, 0, 0)
Next
Dim Combos As New clNumUtilities(WinDigits, PickDigits)
Dim StartDrwing As Integer = tbStartDrwing.Text
Dim EndDrwing As Integer = StartDrwing + CInt(tbDrwings.Text) - 1
Dim Cntr As Integer = 0
Dim BreakCntr As Integer = 0
Dim DYS As Integer = 0
Dim AllHits As Integer = 0
MasterDrwings.Load_tblDrawings(StartDrwing, EndDrwing)
Dim Interval As New clIntervalTimer
For Each DrwingRW As dsWork.tblDrawingsRow In MasterDrwings.tblDrawings
MasterDrwings.Load_NumData(DrwingRW.Drwing, DrwingRW.Drwing + PlayDays)
Dim Hits(MaxSum) As Integer
For Each WinRW As DataRow In MasterDrwings.tblWinNums.Rows
For DC = 1 To WinDigits
Combos.Add_Num(DC, WinRW("N" & DC))
Next
For PID = 1 To Combos.TotalCombos
Dim NumSum As Integer = 0
For DC = 1 To PickDigits
NumSum += Combos.Combos_Seq_Next_DigitByNums(DC, PID)
Next
Hits(NumSum) += 1
Application.DoEvents()
Next
Next
Cntr += 1
For Each RW As dsWork.tblValues1Row In tblValue1.Rows
If Hits(RW.Value1) > 0 Then
RW.LastDrwing = DrwingRW.Drwing
RW.Drwing += 1
RW.AllHits += Hits(RW.Value1)
RW.AvgHits = RW.AllHits / RW.Drwing
If RW.MinHits > Hits(RW.Value1) Then RW.MinHits = Hits(RW.Value1)
If RW.MaxHits < Hits(RW.Value1) Then RW.MaxHits = Hits(RW.Value1)
End If
RW.HitPercent = RW.Drwing / Cntr
Next
dgvTotals.FirstDisplayedCell = dgvTotals.Rows(0).Cells(0)
lbResults.Items.Insert(0, DrwingRW.Drwing & " " & Cntr & " of " & MasterDrwings.tblDrawings.Rows.Count & Interval.CurrentIntervalWithTimeEstimate(MasterDrwings.tblDrawings.Rows.Count, Cntr))
Application.DoEvents()
If Abort Then
lbResults.Items.Insert(0, "Aborted." & Interval.CurrentInterval)
Exit Sub
End If
Next
lbResults.Items.Insert(0, "All Done." & Interval.CurrentInterval)
End SubSome of the code refers to routines that I use over and over again and are in classes. The routine for calculating the combinations is already posted earlier in this thread.
My historical data is stored in a SQL database and looks like this:
I would highly advise getting a SQL database to store your data in as it gives you all kinds of options for storing summary and statistical data that you can then use in your analysis.
For instance this table stores some statistical summary data that I was using in a strategy that I was trying. By compiling the summary data in advance and having the routine call it at the start of each drawing it saved 10 seconds of processing time per drawing. 10 seconds does not sound like a lot, but when sampling over 3000 drawings that adds over 8 hours of processing time to complete the whole analysis.
-
Well, unfortunately the translation from English into Italian does not make such a simple technical dialogue. My story lottery is contained in a txt file. When I open my application is loaded in a variable and from here all my research. Of a history of 5000 drawings takes a few seconds to search for sums, hot, cold and etc ... .. And if I need to save this data, I create a text file.
Regarding the virtual archives, use a string of 90 numbers because many are those from which they are drawn 5 to every line. For example, if the first virtual sequence is 1,2,3,4,5, .................. ..88,89,90 to the first history line, of the example, 15,34,56,61,90 i sum the number 1 and becomes 16,35,57,62,91. 91 is greater than 90, 91> 90, and then 91-90 = 1. The second line of history sum the number 2, then 3 and so on ....
Reached the last number of the virtual sequence starts again from the first. In this way it transforms the real history in a first virtual history.
If by the virtual history study shows, according to an x method of play, which one or more numbers are ready to play, you need to convert them into real numbers. For example, if the last line of the real history I added the number 2 of the virtual sequence, the next will be 3. Therefore, if the next line I have to bet on the virtual number 5 it will be in reality 5 + 90-3 = 92 .... But 92> 90, and then 92-90 = 2. The number 2 will be the one to bet . -
Quote: Originally posted by mirapep on Mar 8, 2017
Well, unfortunately the translation from English into Italian does not make such a simple technical dialogue. My story lottery is contained in a txt file. When I open my application is loaded in a variable and from here all my research. Of a history of 5000 drawings takes a few seconds to search for sums, hot, cold and etc ... .. And if I need to save this data, I create a text file.
Regarding the virtual archives, use a string of 90 numbers because many are those from which they are drawn 5 to every line. For example, if the first virtual sequence is 1,2,3,4,5, .................. ..88,89,90 to the first history line, of the example, 15,34,56,61,90 i sum the number 1 and becomes 16,35,57,62,91. 91 is greater than 90, 91> 90, and then 91-90 = 1. The second line of history sum the number 2, then 3 and so on ....
Reached the last number of the virtual sequence starts again from the first. In this way it transforms the real history in a first virtual history.
If by the virtual history study shows, according to an x method of play, which one or more numbers are ready to play, you need to convert them into real numbers. For example, if the last line of the real history I added the number 2 of the virtual sequence, the next will be 3. Therefore, if the next line I have to bet on the virtual number 5 it will be in reality 5 + 90-3 = 92 .... But 92> 90, and then 92-90 = 2. The number 2 will be the one to bet .I guess my pointy is why not just write the program to calculate this data real time as needed instead of storing the full data?
-
I'm sorry I'm out for two days
-
Hi, I wrote that I'm not a professional programmer. However I believe that many requests for external functions to the calculation routines are bad for the execution speed. Also, what do you need software that does those investigations? In the web there are many free software that are already running this !!
I use my programs to simulate game choices and check how many times have been winning, etc .... -
Here is a picture of my matrix digit calculator that can calculate the stats for any digit 0 to 9 within any matrix up to a 9-99 for both decade
and ones place digits. Takes a fraction of a second to run.
Here is another pic of a matrix overall and positional number calculator.
I have several tools that can convert a set to it's lexicographical index or the lexicographical to a set. I mentioned before that we think
alike. We both seem to have taken similar paths.
Here is a pic of a wheeling system that can wheel up to a 13 digit lexicographical index into number sets. The user tries to predict/guess as
many lexie digits as possible then wheel them into lines of numbers to play. In a 5-39 matrix setting 4 of the lexie digits correctly will produce
100 unfiltered lines with very high prize hits.
Here are the results of a typical 4-digit lexie run for my 5-39 game. This program takes less than a second to run and generate the lines.
Nice to see others working on similar stuff. When working on huge number sets speed is a major factor. Being able to make calculations
very quickly often ups the limits of what we can accomplish within the time frame we have to produce our lines. When playing Keno style
games it's a must.
RL
....
-
Quote: Originally posted by mirapep on Mar 11, 2017
Hi, I wrote that I'm not a professional programmer. However I believe that many requests for external functions to the calculation routines are bad for the execution speed. Also, what do you need software that does those investigations? In the web there are many free software that are already running this !!
I use my programs to simulate game choices and check how many times have been winning, etc ....When I first started out I had no idea what classes were so I would copy the same code over and over again. It was not very efficient.
Calls to classes and functions are not necessarily speed killers. In many instances it is much more efficient to call a function than to have to repeatedly copy the same code blocks throughout an application. Plus by using a class it ensures that each time I am performing the same set of calculations exactly the same way each time.
The really big advantage that I got from using classes was that it considerably sped up the development of different strategies as I did not have to keep re-writing code to do common functions that I may have used in other strategies.
The game I focus on in NY Pick 10, it is basically a Keno game where 20 winning digits are chosen from 80, I try to match 10. There are 184,756 combinations of 10 digit winning numbers per drawing. I need speed to process all that data.
The routines that I posted above run through all of the combinations in less than 2 seconds if I am not doing any sort of complex evaluations of each winning number. On average it takes about 11 seconds per drawing when I'm comparing the results to trend data.