def analyze():
patternDistance = PatternDistanceAnalyzer()
START_AT_N_CONC = 5
slider = ConcursoExt()
last_concurso = slider.get_last_concurso()
repeats_dict = Dict2()
for nDoConc in range(START_AT_N_CONC, last_concurso.nDoConc+1):
concurso = slider.get_concurso_by_nDoConc(nDoConc)
contrajogos_as_dezenas_list = last_concurso.get_contrajogos_as_dezenas_list_down_to_depth(depth=4, inclusive=True)
if contrajogos_as_dezenas_list == None:
continue
#print concurso.nDoConc, concurso.date, concurso.get_dezenas(), contrajogos_as_dezenas_list
repeats_array = jogos_functions.get_array_n_repeats_with_m_previous_games(concurso.get_dezenas(), contrajogos_as_dezenas_list)
token = ''.join(map(str, repeats_array))
patternDistance.add_pattern(token)
repeats_dict.add1_or_set1_to_key(token)
tokens_and_quants = repeats_dict.items()
tokens_and_quants.sort(key = lambda x : x[1])
tokens_and_quants.reverse()
for token_and_quant in tokens_and_quants:
token = token_and_quant[0]
quant = token_and_quant[1]
pattern = rightFillToNSpaces(token, 3)
zquant = leftFillToNSpaces(str(quant), 3)
print pattern, ':', zquant
patternDistance.mount_distances_histogram()
patternDistance.summarize()
analyze()
class HistFreqUpdater(object):
'''
'''
def __init__(self): # concurso_range
self.slider = ConcursoExt()
self.histfreqdbslider = HistFreqDBSlider()
self.update_db_if_needed()
self.verify_histfreqs_consistency()
def update_db_if_needed(self):
self.total_concursos = self.slider.get_total_concursos()
self.last_n_histfreq_updated = self.histfreqdbslider.get_total_histfreqs()
n_missing_histfreqs = self.total_concursos - self.last_n_histfreq_updated
if n_missing_histfreqs < 0:
error_msg = 'Inconsistent histfreqs size. It is greater than concursos. Program execution cannot continue.'
raise IndexError, error_msg
elif n_missing_histfreqs == 0:
# nothing to do! Sizes match.
return
print 'Need to update %d hist-freq concursos (from %d to %d)' %(n_missing_histfreqs, self.last_n_histfreq_updated, self.total_concursos)
self.update_histfreqs_from_last_updated()
def update_histfreqs_from_last_updated(self):
histfreqdbs_to_update = []
if self.last_n_histfreq_updated == 0:
numpy_histfreq = numpy.zeros(60,int)
else:
numpy_histfreq = self.histfreqdbslider.get_histfreq_at(self.last_n_histfreq_updated)
for nDoConc in range(self.last_n_histfreq_updated + 1, self.total_concursos + 1):
jogo = self.slider.get_concurso_by_nDoConc(nDoConc)
for dezena in jogo.get_dezenas():
index = dezena - 1
numpy_histfreq[index] += 1
histfreqdb = HistFreqDB()
histfreqdb.set_charfreqs(numpy_histfreq, nDoConc)
histfreqdbs_to_update.append(histfreqdb)
self.histfreqdbslider.update_histfreqs(histfreqdbs_to_update)
def verify_histfreqs_consistency(self):
print 'About to verify histfreqs consistency of %d concursos : Please, wait. ' %(self.total_concursos)
numpy_histfreq = numpy.array([0]*60)
for nDoConc in range(1, self.total_concursos + 1):
jogo = self.slider.get_concurso_by_nDoConc(nDoConc)
for dezena in jogo.get_dezenas():
index = dezena - 1
numpy_histfreq[index] += 1
self.compare_calc_histfreq_with_db(nDoConc, numpy_histfreq)
print 'Verified histfreqs consistency of %d concursos : ok! ' %(self.total_concursos)
def compare_calc_histfreq_with_db(self, nDoConc, numpy_histfreq):
histfreqdb = self.histfreqdbslider.get_histfreq_at(nDoConc)
bool_array = histfreqdb == numpy_histfreq
# unfortunately, comparison of numpy arrays should compare element by element
# old implementation
# one_to_one = zip(histfreqdb, numpy_histfreq)
# for pair in one_to_one:
# if pair[0] != pair[1]:
if False in bool_array:
error_msg = ' at nDoConc=%d histfreqdb != numpy_histfreq \n db = %s \n calculated = %s' %(nDoConc, histfreqdb, numpy_histfreq)
raise ValueError, error_msg
def generator_with_a_bet():
'''
The 4 most occurring repeats_array (processed on 2013-01-06)
repeats_array : occurrence (from nDoConc=5 to 1556)
2 : 363
1 : 300
3 : 218
21 : 132
'''
compare_repeat_lists = [[4], [3,1]]
gerador = Gerador()
slider = ConcursoExt()
last_concurso = slider.get_last_concurso()
contrajogos = last_concurso.get_contrajogos_as_dezenas_list_down_to_depth(depth=4, inclusive=True)
n_passed = 0; counter = 0; n_passed_for_each_compare_repeat_list = {0:0, 1:0}
for jogo_as_dezenas in gerador:
counter += 1
# if counter > 100:
# break
for compare_repeat_list in compare_repeat_lists:
passed = filter_functions.filter_in_those_within_n_repeats_with_m_previous_games(jogo_as_dezenas, contrajogos, compare_repeat_list)
if passed:
n_passed += 1
n_passed_for_each_compare_repeat_list[compare_repeat_lists.index(compare_repeat_list)]+=1
print n_passed, counter, 'Passed repeats_array', compare_repeat_list, str(jogo_as_dezenas) #, contrajogos, compare_repeat_list
break
print n_passed, counter, n_passed_for_each_compare_repeat_list
def set_history_ini_fin_range(self, history_ini_fin_range=None): ''' This method is private!!! From the "outside", use set_concurso_and_range() ''' slider = ConcursoExt() HIST_RANGE_DEFAULT = (1, slider.get_n_last_concurso()) self.history_ini_fin_range = volante_functions.return_int_range_or_default_or_raise_ValueError(history_ini_fin_range, HIST_RANGE_DEFAULT) self.redo_place_items_in_the_slots()
def set_nDoConc(self, nDoConc):
slider = ConcursoExt()
n_last_concurso = slider.get_n_last_concurso() # len(sl.getListAllConcursosObjs())
if nDoConc == None:
nDoConc = n_last_concurso
elif nDoConc < 1 or nDoConc > n_last_concurso:
indexErrorMsg = 'passed in nDoConcurso=%d and range acceptable is 1 to %d' %(nDoConc, n_last_concurso)
raise IndexError, indexErrorMsg
self.nDoConc = nDoConc
def adhoc_test1():
slider = ConcursoExt()
for nDoConc in range(1401, slider.get_n_last_concurso() + 1):
concurso = slider.get_concurso_by_nDoConc(nDoConc)
line = '%d ' %nDoConc
concursotil = ConcursoTil(concurso)
for n_slots in [2, 3, 4, 5, 6, 10, 12]:
concursotil.reset_n_slots(n_slots)
line += 'tslot%d%s ' %(n_slots, concursotil.get_tilpattern_interlaced_with_n_dozens_per_til()) #wpattern
print line
def adhoc_test(): slider = ConcursoExt() # last_nDoConc = find_last_nDoConc() # backtrack_amount = 400 # down_to_nDoConc = last_nDoConc - backtrack_amount # for nDoConc in range(last_nDoConc, down_to_nDoConc - 1, -1): concurso = slider.get_last_concurso() analyzer = Analyzer(concurso) analyzer.run() analyzer.report()
def process():
slider = ConcursoExt()
concursos = slider.get_all_concursos(); soma_anterior = None
for concurso in concursos:
soma = sum(concurso.get_dezenas())
if soma_anterior == None:
soma_anterior = soma
continue
difference = soma - soma_anterior
word = '(%d, %d, %d)' %(soma_anterior, soma, difference)
if difference > 0: # ie soma > soma_anterior:
prefix = 'up'
elif difference == 0: # ie soma == soma_anterior:
prefix = '~'
else: # difference < 0: # ie soma < soma_anterior:
prefix = 'down'
print '%s%s' %(prefix, word) ,
soma_anterior = soma
def adhoc_test3(): slider = ConcursoExt() last_concurso = slider.get_last_concurso() concursotil = ConcursoTil(last_concurso) print 'concursotil', concursotil, 'wpatt', concursotil.wpattern # tilproducer = TilProducer(5, 6) tilfreqslotter = TilFreqSlotSeparator(5) # print tilproducer.alltilwpatterns # patterns_as_intlist = tilproducer.get_alltilpatterns_as_intlist() # tilsets = tilfreqslotter.getTilSets() n_dozens_per_tilslot = tilfreqslotter.get_quantities_of_dozens_per_tilslot() print 'dezenas per tilslot:', n_dozens_per_tilslot # tilhistogram = tilfreqslotter.get_tilhistogram() #print 'tilhistogram:', tilhistogram # filtered_patterns_as_intlist, patterns_filtered_out = filter_out(patterns_as_intlist, tilhistogram) # print 'filtered_patterns_as_intlist', filtered_patterns_as_intlist, len(filtered_patterns_as_intlist) # print 'filtered out patterns', patterns_filtered_out, len(patterns_filtered_out) tilfreqslotter.show_slot_elements() print tilfreqslotter.show_tilhistogram_table()
def adhoc_test2():
slider = ConcursoExt()
for nDoConc in range(1401, slider.get_n_last_concurso() + 1):
concurso = slider.get_concurso_by_nDoConc(nDoConc)
concursotil = ConcursoTil(concurso)
concursotilr = TilR(n_slots = 5, concurso=concurso)
nDoConc_anterior = nDoConc - 1
print concurso.nDoConc, concurso.date, concurso.get_dezenas(), concurso.get_dezenas_in_orig_order()
print 'histfreq for conc', nDoConc_anterior, concursotil.get_histfreq_obj().get_histfreq_tuplelike_at(nDoConc_anterior)
#print concursotil.get_dezenas_and_their_frequencies_for_concurso()
for n_slots in [5, 6, 10]:
concursotil.reset_n_slots(n_slots)
print 'dezenas, frequencies, tils:', concursotil.get_dezenas_their_frequencies_and_til_for_concurso()
print 'concursotil', concursotil, 'wpatt', concursotil.wpattern
print 'BorderTupleOfTilSets', concursotil.getBorderTupleOfTilSets()
tilfreqslotter = TilFreqSlotSeparator(n_slots)
print tilfreqslotter.show_tilhistogram_table()
print '-'*50
print '=*'*27
def report():
slider = ConcursoExt()
concurso = slider.get_last_concurso()
aggregated_histogram = {}
N_SORTEADAS = len(concurso.get_dezenas())
N_SORTEADAS_MAIS_NENHUMA_COINCIDENCIA = N_SORTEADAS + 1
for i in range(N_SORTEADAS_MAIS_NENHUMA_COINCIDENCIA):
aggregated_histogram[i] = []
for i in range(10):
print i, concurso.nDoConc, concurso.get_dezenas()
coincides_histogram = jogos_fd.get_coincides_histogram_against_a_lookup_depth(concurso.get_dezenas(), up_to_nDoConc=concurso.nDoConc-1, LOOKUP_DEPTH=1000)
if coincides_histogram == None:
continue
print coincides_histogram
the_n_coincides = coincides_histogram.values()
print the_n_coincides, sum(the_n_coincides)
for i, coincide_quantity in enumerate(the_n_coincides):
aggregated_histogram[i].append(coincide_quantity)
concurso = concurso.get_previous()
analyzer = AnalyzerOfCoincides(aggregated_histogram)
analyzer.analyze()
def run_history():
slider = ConcursoExt()
volante_caract = VolanteCharacteristics(n_dezenas_no_volante=60, n_dezenas_no_sorteio=6)
tilfstats = TilStats(n_slots=5, soma=volante_caract.n_dezenas_no_sorteio)
tilrstats = TilStats(n_slots=5, soma=volante_caract.n_dezenas_no_sorteio)
tilfobj = TilF(n_slots=5, history_ini_fin_range = None, volante_caract=volante_caract)
tilrobj = TilR(n_slots=5, history_ini_fin_range = None, volante_caract=volante_caract)
for nDoConc in xrange(101, slider.get_n_last_concurso()+1):
concurso = slider.get_concurso_by_nDoConc(nDoConc)
# reuse tilrobj!
tilfobj.set_history_ini_fin_range(history_ini_fin_range = (1, nDoConc-1))
tilrobj.set_history_ini_fin_range(history_ini_fin_range = (1, nDoConc-1))
f_pattern_as_list, f_wpattern = tilfobj.get_items_tilpattern_as_list_and_str(concurso.get_dezenas())
r_pattern_as_list, r_wpattern = tilrobj.get_items_tilpattern_as_list_and_str(concurso.get_dezenas())
tilfstats.add_pattern_as_list(f_pattern_as_list)
tilrstats.add_pattern_as_list(r_pattern_as_list)
print 'f', f_wpattern, 'r', r_wpattern, concurso.get_dezenas_str(), nDoConc
tilfstats.print_summary()
print 'len(tilfstats)', len(tilfstats)
tilrstats.print_summary()
print 'len(tilrstats)', len(tilrstats)
def __init__(self): # concurso_range self.histfreqdbslider = HistFreqDBSlider() self.total_histfreqs = self.histfreqdbslider.get_total_histfreqs() self.slider = ConcursoExt() self.total_concursos = self.slider.get_total_concursos() self.update_histfreq_if_needed()
class HistFreq(object):
'''
A histfreq composes (ie, its attributes):
--------------------
+ bottomconc = the lower concurso number in the range composing the frequency histogram
+ topconc = the upper concurso number in the range composing the frequency histogram
+ (private) dezenasfreqs = sorted list of each dezena's total occurrence (ie, its frequency) in the related range (bottomconc, topconc)
--------------------
A histfreq does (ie, its methods):
+ mount_histfreq
'''
def __init__(self): # concurso_range
self.histfreqdbslider = HistFreqDBSlider()
self.total_histfreqs = self.histfreqdbslider.get_total_histfreqs()
self.slider = ConcursoExt()
self.total_concursos = self.slider.get_total_concursos()
self.update_histfreq_if_needed()
def reissueHistFreqUpdater(self):
HistFreqUpdater()
self.total_histfreqs = self.histfreqdbslider.get_total_histfreqs()
def update_histfreq_if_needed(self, secondTry=False):
if self.total_histfreqs < self.total_concursos:
self.reissueHistFreqUpdater()
if not secondTry:
return self.update_histfreq_if_needed(secondTry=True)
else:
error_msg = 'Failed to update histfreq array. It should have the same size (=%d) as "concursos (=%d)".' %(self.total_histfreqs, self.total_concursos)
raise ValueError, error_msg
def get_concurso_by_nDoConc(self, nDoConc):
'''
Just a "convenience" public method (not used internally by the class)
'''
return self.concursoSlider.get_concurso_by_nDoConc(nDoConc)
def get_histfreq_at(self, nDoConc=None, secondTry=False):
'''
histfreq is a numpy array that contains frequencies of all dozens (ex., in Megasena it's a 60-number array)
dozen 1 has its frequency at index 0, dozen 2, index 1, so on until dozen 60 at index 59
'''
if nDoConc == None:
nDoConc = self.total_concursos # JogoSlider().get_total_jogos() # ie, number of last one
elif nDoConc < 1 or nDoConc > self.total_concursos:
error_msg = 'nº (=%d) do concurso fora da faixa válida (1, %d) ' %(nDoConc, self.total_concursos)
raise ValueError, error_msg
elif nDoConc > self.total_histfreqs:
if secondTry:
error_msg = 'There is a size different between total_jogo (=%d) and total_histfreqs (=%d) and nDoConc = %d. Program cannot continue until this is corrected.' %(self.total_jogos, self.total_histfreqs, nDoConc)
raise ValueError, error_msg
else:
# this should be a very rare use case, ie, database has changed while this class is still instantiated and running :: try to update histfreqs so that total_histfreqs equals total_concursos
self.reissueHistFreqUpdater()
return self.get_concurso_by_nDoConc(nDoConc, secondTry=True)
# it return as a numpy array object
histfreq = self.histfreqdbslider.get_histfreq_at(nDoConc)
if histfreq == None:
error_msg = "histfreq for concurso %d was not found. It's missing in database." %nDoConc
raise IndexError, error_msg
return histfreq
# index = nDoConc - 1
# return self.allhistfreqs[index]
def get_histfreq_tuplelike_at(self, nDoConc=None, secondTry=False):
'''
Same as get_histfreq_at(), the plus is that it zips range(1, 61) with histfreq
'''
total_dezenas = len(self.get_histfreq_at(nDoConc))
dezenas = range(1, total_dezenas + 1)
return zip(dezenas, self.get_histfreq_at(nDoConc))
def get_freqstair_at(self, nDoConc=None):
'''
freqstair is an ordered array from minimum frequency (least occurred) to maximum frequency (most occurred) at nDoConc
'''
histstair = set ( self.get_histfreq_at(nDoConc) )
histstair = list( histstair )
histstair.sort()
return histstair
def get_freqstair_with_dozens_at(self, nDoConc=None):
'''
freqstair is an ordered array from minimum frequency (least occurred) to maximum frequency (most occurred) at nDoConc
'''
freqstair_with_dozens = []
freqstair = self.get_freqstair_at(nDoConc)
for freq in freqstair:
subset_dezenas = []; offset = 0; histfreq = list( self.get_histfreq_at(nDoConc) )
while 1:
try:
index = histfreq.index(freq)
del histfreq[ : index + 1]
dezena = offset + index + 1
offset += index + 1
subset_dezenas.append(dezena)
# print 'dezena', dezena, 'freq', freq, freqstair
# print histfreq, 'tam', len(histfreq)
if len(histfreq) == 0:
break
except ValueError:
break
freqstair_with_dozens.append( (freq, subset_dezenas) )
return freqstair_with_dozens
def get_histfreq_within_range(self, concurso_range=None):
if concurso_range == None:
return self.get_histfreq_at()
bottomconc = concurso_range[0]
topconc = concurso_range[1]
if bottomconc == 1:
return self.get_histfreq_at(topconc)
return self.get_deltahistfreq(bottomconc, topconc)
def get_deltahistfreq(self, bottomconc, topconc):
if bottomconc == 1:
return self.get_histfreq_at(topconc)
bottomfreqhist = self.get_histfreq_at(bottomconc-1)
topfreqhist = self.get_histfreq_at(topconc)
deltafreqhist = topfreqhist - bottomfreqhist # + self.numpy_ones
# it return as a numpy array object
return deltafreqhist # no need to hardcopy this one, because it's computed here
def get_histfreq_for_dezena_witin_range(self, dezena, concurso_range=None):
histfreq = self.get_histfreq_within_range(concurso_range)
if histfreq == None:
return None
if dezena < 1 or dezena > len(histfreq) + 1:
error_msg = 'Dezena (=%d) fora da faixa válida (%d, %d)' %(dezena, 1, len(histfreq) + 1)
raise ValueError, error_msg
index = dezena - 1
return histfreq[index]
def __str__(self):
return '<HistFreq self.total_histfreqs=%d>' %self.total_histfreqs
def __init__(self): # concurso_range self.slider = ConcursoExt() self.histfreqdbslider = HistFreqDBSlider() self.update_db_if_needed() self.verify_histfreqs_consistency()
def get_tilrwpattern_of_game(dezenas, n_slots=5, up_to_concurso=None):
slider = ConcursoExt()
if up_to_concurso == None:
up_to_concurso = slider.get_last_concurso()
tilr_obj = TilR(n_slots, up_to_concurso) #, inclusive=False, concurso_range = None)
return tilr_obj.get_tilrwpattern_of_game(dezenas)
