NUOVO AMBIENTE SCRIPT AREA TECNICA

[Rookie]

Cerchiamo di capirci...
Se io voglio fare una ricerca sulle sestine dell'enalotto che sono oltre 622M, devo creare un vettore di 622M righe?
No. Assolutamente. Faccio una ricerca contando quante possono essere quelle che producono il risultato rispetto alle condizione della ricerca. E ci lavoro sopra finche' cio' che ottengo e' usabile, sensato e migliorabile. Se non lo faccio, non sapro' mai di che cosa mi sto' occupando. Il programmatore deve essere il Re nel dominio in cui sta operando... cioe' deve conoscere ogni dettaglio di quanto dovra' usare per risolvere il problema.
Serve avere un'idea piuttosto precisa di cosa si ottiene dall'elaborazione finale. Adeguando opportunamente, con sufficiente margine di sicurezza per NON creare errori durante l'esecuzione...

 

[LuigiB]

ecco prendiamo l'esempio ddei 623milioni di sestine , , facciamo che voglio sapere la piu ritardata per terno.Facciamo che voglio sapere le prime 20 piu ritardate , è inutile saperne di piu , magari ne voglio sapere 30 o 50 ma non certo 1000 ... .. il mio agoritmo giustamente calcolera il ritardo di ogni sestina , pero mentre faccio l'elaborazione vado a registrare (se è il caso) quella setina dentro il mio array di 20 elementi nella posizione corretta e faccio shiftare gli altri elementi .. alal fine delal routine avro le mie 20 sestine gia ordinate ..cioè non è che dveo prima calcolarle tutte e poi ordinarle ...

 

[i legend]

Luigi , se è fattibile e hai voglia e pensi che possa tornare utile, potresti fare una video lezione o scrivere qualcosina per creare un semplicissimo udt?
Proprio le basi.
Qualche controllo e una griglia.
O solo qualche controllo .

in ogni caso grazie

 

[LuigiB]

non c'è bisgno di una video lezione perche la cosa è alquanto semplice.

la prima cosa è sapere cosa sia un udt , questo lo sai spero ... senno dillo cosi facciamo un esempio

 

[i legend]

Io pensavo che il riordino fatto più volte prendesse più tempo che in un unica volta.
Questi sono i tipi I trick e lo studio.
A volte penso che, parlo per me , vi debba sembrare di parlare con un bambino dell asilo che non sa neanche contare e voglia fare le addizioni

 

[i legend]

Da quello che ho capito l udt
Sono un gruppo di controlli assemblati insieme per svolgere un compito preciso, o un controllo che non è standard.

 

[LuigiB]

per ordinare un array di 620 milioni di righe o di 2 righe devi sempre fare il confronto tra i valori e nel caso scambiare le variabili , quindi tanto vale farlo nel mentre piuttosto che alal fine , tra l'altro nel mentre non devi fare nessun ordinamento ma solo scoprire in che posizione inserire la rua sestina e far shiftare le altre

 

[LuigiB]

ti confondi con gli user control .. gli udt sono i tipi di dati definiti dall'utente .. le strutture ..

public type struct_combinazione
bNumeri (90) as boolean
Ritardo as long
Frequenza as long

end type


come vedi usando i tipoi di base abbiamo creato un nuovo tipo di variabile infatti possiamo scrivere dim V as struct_combinazione

 

[i legend]

Ok.
Si mi stavo confondendo.
Si ho capito

 

[LuigiB]

ebbene mentre elabori le tue colonne che possono essere sia le note 623milioni sia un numero indefinito , ovviamente per ogni colonna tu lanci la funzione per calcolare i valori statistici, devi sempicemente fare un ciclo per individuare la posizione dentro l'array di X posizioni previsto all'inizio e far shiftare gli altri elmenti , ovviamente un elemento andrà perso perche non rientra piu tra i primi n ed è cosi che alal fine avari il tuo array ordinato.

se io ho un array

dim aPrime20 ( 20) as struct_combinazione

gni volta che ho una nuova combinazione faccio un ciclo che parte da 1 e confronta il ritardo della nuova combinazione con quello dell'elemento x del mio array , se è maggiore o uguale so che devo inserire la mia combinazione nuova nella posizione x dell'array
sicche prima faccio shiftare gli elmenti di una posizione a partire da x e poi nella posizione x inserisco la mia nuova combinazione.

for k = 20 to x+1 step -1
lset aPrime20 (k) =aPrime20 (k-1)
next
lset aPrime20 (x) = v


la parte del ciclo per essere piu veloci si potrebeb fare con copymemory pero è piu complesso lasciamo perdere ..

 

[lotto_tom75]

Concordo al 1000% con rookie e luigi quando dicono che è inutile e pernicioso.. cercare di elaborare prima l'intera massa di formazioni e poi cercare di ordinarle infatti non è quello che intendo neppure io... Non per nulla la ricerca spasmodica sui gruppi abs e semi abs sempre + contenuti intende proprio diminuire la massa numerica iniziale con stabilità teorica più o meno fissa... di sfaldamento in pochi colpi nel maggior numero di estrazioni passate possibile... Ma questo va fuori dall'argomento principale anche se un esempino in realtà potrebbe rappresentare un valido punto di partenza sui cui poter esercitarci io e legend e chi vorrà con la supervisione dei due proff. Ovvero una abs di soli.. 16 elementi x A su sole 7 ruote nelle ultime sole 60 estrazioni. Il compito sarebbe quello di generare in una list box relativa ordinata per RA decrescente solo.. le prime 100 formazioni con ra max (unici o isocroni) x A su 1 ruota singola sulle 11440 formazioni generabili in classe 7 nel minor tempo possibile...

Io per adesso adottando la tecnica suggerita, poco sopra anche da luigi, usando spaziometria (non twinbasic) e riducendola purtroppo solo ad un solo elemento (=formazione soddisfacente il filtro di ricerca) ricerco via via in run time in tempi relativamente veloci... il valore massimo e verifico se è unico o meno... per cercare di evitare i casi di ramificazioni riduzionali poco gestibili...

con 16 elementi si generano in modo integrale

x classe 1 : 16 formazioni
x classe 2 : 120 formazioni
x classe 3 : 560 formazioni
x classe 4 : 1820 formazioni
x classe 5 : 4368 formazioni
x classe 6 : 8008 formazioni
x classe 7 : 11440 formazioni <<
x classe 8 : 12870 formazioni << in realtà la miglior "cuspide elaborazionale" da cercare di gestire sarebbe questa...
x classe 9 : 11440 formazioni
x classe 10 : 8008 formazioni
x classe 11 : 4368 formazioni
x classe 12 : 1820 formazioni
x classe 13 : 560 formazioni
x classe 14 : 120 formazioni
x classe 15 : 16 formazioni
x classe 16 : 1 formazioni


ovviamente poi questo micro esempio, che si dovrebbe riuscire a svolgere in pochissimi secondi di elaborato, si può estendere idealmente alle 622 milioni e passa di sestine dell'esempio extremo da voi indicato o a qualsiasi altro tipo di ricerca su ruote singole e/o unite e/o unite in gruppi di classe dinamici a girare... (vedi robot boss...)

Per quanto riguarda il target finale della ricerca di esempio... non sarebbe solo quello di privilegiare il ritardo massimo ma quello di avere anche la possibilità di analizzare in tempi rapidissimi e da più sfaccettatura di punti di vista diversi il micro gruppo abs o semi abs preso di volta in volta in esame con una matrice aggiornabile e ordinabile per i parametri voluti per il numero di elementi in output desiderati (es primi 100) in tempi più rapidi possibili.

Ricordo che per abs io intendo absolute ovvero RA=RS=0 per la sorte, le ruote e il range temporale impostati... E per semi abs semi absolute ovvero con RS <= valore tot deciso e generalmente il + basso possibile rilevato dalla ricerca relativa... (es. RS di 9 estrazioni x A in classe 9 su TT dalla es 8117 ecc... ).

 

[lotto_tom75]

è sempre sbagliato. . come prima ... che ci devi fare con 100.000 righe ?

Quindi nella matrice basta che dichiari le 100 che voglio visualizzare nella list box? Ma quante righe può contenere al massimo per curiosità una list box?

 

[i legend]

Prova a popolarla.
Fai un ciclo da a a 100000
E scrivi il numero. L ultimo potrebbe essere il valore limite, ma non so se dipende dal numero di caratteri della stringa .
Non so come si fanno sti calcoli.

 

[LuigiB]

ecco l'esempio , per velocità l'ho impostato sulle terrzine . .questo tipo di routine andebebro fatte sempre girare in compilato non dall'ambiente

Sub MyScriptRoutine()
      
        Dim aN () As Long
        Dim nClasse As Long = 3
        ReDim aCol(nClasse) As Long
        Dim nCombTot As Long
        Dim Inizio As Long, Fine As Long, Sorte As Long
        Dim frz As STRUCT_FRZ_STATISTICA_SINGOLO_ESITO
        Dim Ruota As Long = 1
        Dim nMaxElementi  As Long = 10
        Dim k As Long, x As Long
        Dim nElab As Long
        Dim sNumeri As String
        
        ReDim aReport(nMaxElementi) As STRUCT_FRZ_STATISTICA_SINGOLO_ESITO
        
        
        Inizio = EstrazioneIni
        Fine = EstrazioneFin
        Sorte = 1
        
        Call GetArrayNumPerSviluppo(aN)
        
        
        nCombTot = InitSviluppoIntegrale (aN, nClasse)
        Do While GetCombSviluppo(aCol)
            
            Call StatisticaSingoloEsito(aCol, Inizio, Fine, Sorte, frz, Ruota)
            For k = 1 To nMaxElementi
                If frz.RetValori.Ritardo >= aReport(k).RetValori.Ritardo Then
                    For x = nMaxElementi To k + 1 Step -1
                        LSet aReport(x) = aReport(x - 1)
                    Next
                    LSet aReport(x) = frz
                    Exit For
                End If
            Next
            nElab + = 1
            If nElab Mod 1000 = 0 Then
                Call AvanzamentoElaborazione(nElab, nCombTot)
                If bScriptInterrotto Then Exit Do
                DoEvents
            End If
            
        Loop
        
        ReDim aV(1) As String
        aV (0) = "Colonna"
        aV(1) = "Ritardo"
        Call InitTabella(aV)
        
         For k = 1 To nMaxElementi
            sNumeri = StringaNumeriB (aReport(k).aBNumeri)
            If sNumeri <> "" Then
                aV(0) = sNumeri
                aV(1) = aReport(k).RetValori.Ritardo
                Call AddRigaTabella(aV)
            End If
        Next
        
        Call CreaTabella
        
                   
    End Sub
    
    Function StringaNumeriB(aB() As Byte) As String
        Dim sRet As String
        Dim k As Long
        
        For k = 1 To UBound(aB)
            If aB(k) Then
                sRet = sRet & Format2(k) & "."
            End If
        Next
        Return RimuoviLastChar(sRet, ".")
        
    End Function

 

[LuigiB]

si potrebebro fare delel ottimizzazioni per la velocità ma non servono per capire i lconcetto..anzi complicherebebro le cose

 

[i legend]

Quindi fare un exe.
Dalle prove che ho fatto non ho notate differenze significative tra l exe e il lancio da ide.
In ogni caso è veloce.
Se ho capito cosa intendi.

 

[LuigiB]

bisogna vedere che comparazione hai fatto . .qui una parte del lavoro è demandata alal routine che deve far shiftare gl ielementi percio in compilato va sicuramente meglio

 

[lotto_tom75]

Dunque ci sono quasi ma non ancora



Ho provato ad evidenziare i vari parametri che un'analisi di questo tipo multi ruota con numero variabile di ruote a girare comporta per il carico della matrice... e per classi di gruppo basse tipo 2 ruote unite al massimo scegliendo tre di base... non ci sono problemi.. In pochissimi secondi ottengo i dati ordinabili in un istante dalla combo box... Questo se la matrice ha uno spazio dichiarato di <= 100 o al massimo 1000 righe. La combobox riesce a operare solo con i valori messi nella matrice non più di 1000 e quando la uso oltre ai valori corretti ordinati in modo corretto mi aggiunge le righe senza dati dichiarate per la matrice.. come ho evidenziato con il rettagolo rosso ma questo non sarebbe un grosso problema...

Il problema nasce quando si supera il valore dichiarato della matrice (es 100) perchè anche se non carico tutti i valori dell'elaborazione all'interno della stessa ma solo al massimo 100 poi la combo non riesce a pescare per l'ordinamento corretto da tutti i valori ma solo da quei 100 immessi nella matrice. Come ha giustamente consigliato il maestro dovrei mettere nella matrice solo i valori rispettanti il filtro di ordinamento voluto (es. fq max ecc... e visualizzarne alla fine la lista aggiornata) ma in questo caso la combo dell'ordinamento andrebbe attivata prima dell'elaborazione giusto? Intendo dire...

scelgo il valore di ordinamento (es. fq max decrescente)
elaboro il gruppo base con le ruote unite volute a girare...
durante l'elaborazione filtro quelle con fq max o fq max uguale a quella max rilevata
inserisco le formazioni rispettanti il filtro fino al riempimento della matrice
visualizzo alla fine la list box così composta che fino alla fine dovrà in qualche modo refresharsi...

giusto?

O sono completamente out of the street?

ps: Qualcuno sa quale sia la formula matematica per avere il numero totale di formazioni create prima di generarle avendo come parametri:

elementi del gruppo base
classe di sviluppo
numero di ruote unite minimo
numero di ruote unite massimo

Riuscissi ad ottenerlo con una formuletta forse potrei scegliere il dimensionamento fisso ma "selezionato" con un Select Case ad esempio x la matrice che assumerebbe valori di numero di riga diversi in base appunto al risultato della formula applicata ai 4 parametri noti...

 

[LuigiB]

durante l'elaborazine devi registrare in array differenti , uno per ritardo , uno per frequenza ecc i valori migliori , poi quando clicchi sulla combo fai alimentare la lista con i dati di quell'array.

 

[lotto_tom75]

durante l'elaborazine devi registrare in array differenti , uno per ritardo , uno per frequenza ecc i valori migliori , poi quando clicchi sulla combo fai alimentare la lista con i dati di quell'array.

Bho.. ci proverò ma la vedo dura...