[Func] Conversion millisecondes en y/d/h/m/s/m

[Alex74]

Bonjour à tous,

Pour mes besoins, j'ai du effectuer des conversions de millisecondes en années/jours/heures/minutes/secondes/millisecondes. Or je me suis retrouvé bloqué car je devais manipuler des nombres très grands (de l'ordre de 80^60) pour mes conversions. Or, apparemment de base, Autoit ne le permet pas. Heureusement, je suis tombé sur l'UDF BigNum.au3 (qui mériterait bien d'être inclus dans Autoit d'ailleurs):

http://www.autoitscript.com/forum/topic ... ignum-udf/

J'ai donc pu coder la fonction dont j'avais besoin. Elle permet la conversion en s'affranchissant des limites sur les grands nombres et renvoie une chaine ou un tableau.

Je ne savais pas trop si je devais la poster car elle utilise un UDF qui n'est pas inclus dans Autoit mais bon...Ce n'est pas la fonction de l'année ( ) mais si elle peut servir à quelqu'un un, ce sera toujours ça.

► Afficher le texte

Code : Tout sélectionner

#cs --------------------------------------------------------------------------------------

AutoIt Version: 3.3.6.0

Function: _BigMil_To_Ydhmsm
    Converti un nombre très grand en millisecondes sous la forme
    années/jours/heures/minutes/secondes/millisecondes.

Parameters:
    $milSec = entier (en millisecondes) à convertir
    $inArray = format du résultat:
                défaut 0 -> résultat en chaine ydhmsm
                1 -> résultat en tableau de 6 lignes
Return values:
    Si $inArray = 0 : $Ydhms = chaine
    Si $inArray = 1 : $arrayYdhms = tableau -> $arrayYdhms[0] = nombre d'années
                                                $arrayYdhms[1] = nombre de jours
                                                $arrayYdhms[2] = nombre d'heures
                                                $arrayYdhms[3] = nombre de minutes
                                                $arrayYdhms[4] = nombre de secondes
                                                $arrayYdhms[5] = nombre de millisecondes

Notes:
    - Utilise l'UDF BigNum.au3

Author: Alex74

#ce --------------------------------------------------------------------------------------

#include "BigNum.au3"

Func _BigMil_To_Ydhmsm($milSec, $inArray = 0)

    Local Const $nbreMilInYear = 31556926000 ;Nbre de millisecondes en 1 année
    Local Const $nbreMilInDay = 86400000 ;Nbre de millisecondes en 1 jour
    Local Const $nbreMilInHour = 3600000 ;Nbre de millisecondes en 1 heure
    Local Const $nbreMilInMin = 60000 ;Nbre de millisecondes en 1 minute
    Local Const $nbreMilInSec = 1000 ; Nbre de millisecondes en 1 seconde

    Local $years =  _BigNum_Div($milSec, $nbreMilInYear, 0)

    Local $days = Int(_BigNum_Sub($milSec, _BigNum_Mul($years, $nbreMilInYear)) / $nbreMilInDay)

    Local $hours = Int(_BigNum_Sub($milSec, _BigNum_Add(_BigNum_Mul($years, $nbreMilInYear), _BigNum_Mul($days, $nbreMilInDay))) / $nbreMilInHour)

    Local $minutes = Int(_BigNum_Sub($milSec, _BigNum_Add(_BigNum_Add(_BigNum_Mul($years, $nbreMilInYear), _BigNum_Mul($days, $nbreMilInDay)), ($hours * $nbreMilInHour))) / $nbreMilInMin)

    Local $seconds = Int(_BigNum_Sub($milSec, _BigNum_Add(_BigNum_Add(_BigNum_Add(_BigNum_Mul($years, $nbreMilInYear), ($days * $nbreMilInDay)), $hours * $nbreMilInHour), $minutes * $nbreMilInMin)) / $nbreMilInSec)

    Local $Mseconds = _BigNum_Sub($milSec, _BigNum_Add(_BigNum_Add(_BigNum_Add(_BigNum_Add(_BigNum_Mul($years, $nbreMilInYear), ($days * $nbreMilInDay)), $hours * $nbreMilInHour), $minutes * $nbreMilInMin), $seconds * $nbreMilInSec))

    ;Résultat sous forme de chaine
    If $inArray = 0 Then
        Local $Ydhms = $years&' '&'y'&' '&$days&' '&'d'&' '&$hours&' '&'h'&' '&$minutes&' '&'m'&' '&$seconds&' '&'s'&' '&$Mseconds&' '&'m'
        return $Ydhms
    ;Résultat en tableau
    Else
        Local $arrayYdhms[6]
        $arrayYdhms[0] = $years
        $arrayYdhms[1] = $days
        $arrayYdhms[2] = $hours
        $arrayYdhms[3] = $minutes
        $arrayYdhms[4] = $seconds
        $arrayYdhms[5] = $Mseconds
        return $arrayYdhms
    EndIf

EndFunc ;==>_BigMil_To_Ydhmsm

[jchd]

Pardon ? 80^60 pour gérer des millisecondes ???
Tu as un Kolossal problème avec tes unités.
AutoIt gère des entiers signés sur 32 ou 64 bits selon les besoins, soit un MaxInt positif
MS = 18446744073709551615.
Imaginons un instant que ce nombre MS soit un compte de ms, c'est donc
S = MS / 1000 ≃ 1.8446744073709552 10^16 secondes,
soit
M = S / 60 ≃ 3.074457345618259 10^14 minutes
soit
H = S / 60 ≃ 5.124095576030432 10^12 heures
soit
J = M / 24 ≃ 2.1350398233460132 10^11 jours
soit
A = J / 365.25 ≈ 5.845420460906265 10^8 années solaires moyennes

As-tu _vraiment_ le besoin impérieux de travailler à la milliseconde près sur des périodes de dépassant 584 millions d'années ? Cela n'a aucun sens physique.

[Alex74]

En fait, je l'ai adapté pour un autre calcul qui me permet de connaitre le temps maximal pour effectuer toutes les possibilités d'une action (équivalent au max à 94^64) par rapport à un nombre d'actions par seconde cette fois.
Là, je l'ai adapté aux millisecondes par soucis de précision et simplifiée pour quelle soit facilement modifiable. J'aurais peut-être pas dû

[jchd]

Cela a encore moins de sens. Tu peux expliquer comment tu parviens à ces valeurs titanesques n'ayant, encore une fois, aucun sens physique quand il s'agit d'opérations par seconde.

[Alex74]

On ne s'est pas bien compris : 94^64 est le nombre de possibilités résultant de la combinaisons de 2 facteurs, ce n'est pas le nombre de secondes. Mais j'ai du effectuer des calculs incluant un facteur temps sur ce total.
Enfin bref, si pas utile, vous pouvez mettre à la corbeille.

[jchd]

94^64 est le nombre de possibilités résultant de la combinaisons de 2 facteurs

C'est incompréhensible. Quels facteurs, par exemple ?

Mais j'ai du effectuer des calculs incluant un facteur temps sur ce total.

Un exemple du monde réel ?

Enfin bref, si pas utile, vous pouvez mettre à la corbeille.

Là n'est pas la question. Pourquoi avoir recours à _BigNum pour effectuer une simple conversion de temps en ms, c'est ça qui m'intrigue (hautement !) ? Le même calcul fonctionne très bien avec les entiers natifs d'AutoIt.

[Alex74]

Un exemple concret : je me code un petit générateur de mots de passe et clé Wpa (que je change de temps en temps et comme j'ai la flemme de les taper à la main). Pour agrémenter mon interface, je me suis amusé à calculer et afficher certaines informations concernant le mot de passe crée dont le nombre de combinaisons possible ainsi que le temps maximum pour effectuer toutes les combinaisons à raisons d'un nombre donné de combinaisons par secondes. Purement informatif mais bon, il y a un calcul à effectuer pouvant impliquer des grands nombres.

Le 94^64 correspond au nombre de combinaisons possible d'un mot de passe contenant des alphanumériques des 3 types ainsi que des caractères dits 'spéciaux ( 10 + 26 + 26 + 32) et d'une longueur de 64 caractères.

Donc rien que pour pouvoir reprendre le résultat de 94^64, je suis obligé d'utiliser l'UDF BigNum et ensuite pour effectuer des calculs sur ce résultat, je dois tout au long de ma fonction utiliser les fonctions de l'UDF.

A moins que vous ayez une autre méthode, dans ce cas là, je suis preneur aussi...

Après réflexion, c'est clair qu'en voulant simplifier la fonction, j'ai peut-être perdu en route son côté pratique par rapport à l'utilisation que j'en ai faites au départ. Mais comme j'en ai une utilisation bien spécifique et que j'ai trouvé très intéressante la possibilité de manipuler des grands nombres pour ce genre de calculs, j'ai souhaité l'adapter à un calcul simple. A tort peut-être...

[Tlem]

A partir du moment ou le calcul dépasse quelques années (je dirais une dizaine ou une vingtaine pour être large), je ne vois pas vraiment l'intérêt de spécifier un délai exact !!!
Vous imaginez-vous lancer le calcul d'une clé sur une durée aussi large ?
A la limite, spécifier le nombre de combinaison d'accord, mais une durée, cela n'a pas réellement de sens.

Peut être que dans quelques années l'ordinateur Quantique sera une réalité pour tout le monde et dans ce cas, les durées de calcul ne seront plus ce qu'elles étaient ...

[Alex74]

Oui, je suis d'accord, d'ailleurs au dessus de 9999 années, j'affiche 'supérieur à 10 000 ans' sinon ça ne rentre plus dans ma GUI Mais bon, j'aime bien mener mes calculs jusqu'au bout...

Peut être que dans quelques années l'ordinateur Quantique sera une réalité pour tout le monde et dans ce cas, les durées de calcul ne seront plus ce qu'elles étaient ...

Justement là, ou à l'heure actuelle les durée renvoyées semblent hors de la réalité, elle le seront beaucoup moins à ce moment là

[jchd]

S'il s'agit d'un calcul combinatoire exact, alors OK bignum peut certes s'avérer fort utile.

Mais dans le cas présenté, on peut tout à fait effectuer le calcul avec des flottants !
Pour obtenir 94^64, on fait :

► Afficher le texte

Local $nbClefs = Exp(64 * Log(94))

Pour savoir combien de temps il faudrait à un opposant pour tester l'espace des clés à raison de $N essais par ms :

► Afficher le texte

$nbClefs / $N

et on convertit le résultat en temps "humainement compréhensible" le plus bêtement du monde.

Ce calcul reposant sur une fiction, peu importe qu'il ne soit qu'approché à 10^-30 près. C'est comme vouloir exprimer la distance Terre - Lune à l'angström près, ça n'a aucun sens.

[timmalos]

Je precise pour les non mathématiciens que

[jchd]

@Alex74,

Ne crois pas que j'aie quoi que ce soit contre toi ni contre le sérieux que tu as déployé pour proposer ce que tu penses être correct. Mon propos est simplement qu'il est saugrenu d'employer des moyens ultra-précis (e.g. BigNum) et très lourds pour exprimer un simple ordre de grandeur qui n'a aucune chance de se concrétiser jamais et dont le calcul approché direct peut se faire en deux lignes.

Transposé à la réalisation de programmes, tous languages confondus, cela revient à s'acharner pendant des jours, voire des semaines, à dénicher des optimisations prématurées particulièrement subtiles et difficiles à maintenir pour gagner 43 ns, sans jamais se poser la question de l'adéquation de l'agorithme employé pour aborder le problème.

La beauté du geste ne s'applique pas ici : seule l'efficacité judicieuse compte.

Par contre, si tu es amené à te coltiner un calcul de combinatoire je suis tout à fait d'accord avec toi sur la rapide nécessité de recourir à BigNum dès que les valeurs grandissent, du fait de l'explosion combinatoire et le besoin de rester en calcul entier.

[ricky]

Hello,

merci pour ta fonction, je me suis permis de la reprendre et d'en faire une sans le bignum pour mes besoins :

► Afficher le texte

Code : Tout sélectionner

#cs --------------------------------------------------------------------------------------

AutoIt Version: 3.3.6.1

Function: MilToYdhmsm
    Converti un nombre très grand en millisecondes sous la forme
    années/jours/heures/minutes/secondes/millisecondes.

Parameters:
    $milSec = entier (en millisecondes) à convertir
    $DownmSec = format des milisecondes
        défaut 0 -> résultat arrondi aux milisecondes
                1 -> résultat brut
    $inArray = format du résultat:
        défaut 0 -> résultat en chaine ydhmsm
                1 -> résultat en tableau de 7 lignes
Return values:
    Si $inArray = 0 : $Ydhms = chaine
    Si $inArray = 1 : $arrayYdhms = tableau -> $arrayYdhms[0] = nombre de variables
                                                $arrayYdhms[1] = nombre d'années
                                                $arrayYdhms[2] = nombre de jours
                                                $arrayYdhms[3] = nombre d'heures
                                                $arrayYdhms[4] = nombre de minutes
                                                $arrayYdhms[5] = nombre de secondes
                                                $arrayYdhms[6] = nombre de millisecondes

Author: Ricky avec comme base le code d'Alex74
Topic : http://autoitscript.fr/forum/viewtopic.php?f=21&t=7369

#ce --------------------------------------------------------------------------------------

Func MilToYdhmsm($milSec, $DownmSec = 0, $inArray = 0)

    Local $arrayDiviseur[6]
    $arrayDiviseur[0] = 5
    $arrayDiviseur[1] = 31556926000 ;Nbre de millisecondes en 1 année
    $arrayDiviseur[2] = 86400000 ;Nbre de millisecondes en 1 jour
    $arrayDiviseur[3] = 3600000 ;Nbre de millisecondes en 1 heure
    $arrayDiviseur[4] = 60000 ;Nbre de millisecondes en 1 minute
    $arrayDiviseur[5] = 1000 ; Nbre de millisecondes en 1 seconde

    Local $arrayCalcul[2] ; retour de la fonction calcul avec la nouvelle valeur en secondes et le nombre calculé

    Local $arrayYdhms[7] ; Tableau avec les valeurs
    $arrayYdhms[0] = 6

    For $i=1 to $arrayDiviseur[0] step 1

        $arrayCalcul = Calcul ($milSec, $arrayDiviseur[$i])
        $milSec = $arrayCalcul[0]
        $arrayYdhms[$i] = $arrayCalcul[1]

    Next
    $arrayYdhms[6] = $milSec ; copie des dernière milisecondes
    if $DownmSec = 0 then $arrayYdhms[6] = int ($arrayYdhms[6])

    If $inArray = 0 Then
        Local $Ydhms = $arrayYdhms[1]&' '&'y'&' '&$arrayYdhms[2]&' '&'d'&' '&$arrayYdhms[3]&' '&'h'&' ' & _
        $arrayYdhms[4]&' '&'m'&' '&$arrayYdhms[5]&' '&'s'&' '&$arrayYdhms[6]&' '&'m'
        return $Ydhms
    ;Résultat en tableau
    Else
        return $arrayYdhms
    EndIf

EndFunc

Func Calcul ($Valeur , $Diviseur)
    ; cette fonction va calculer si la valeur est plus grande que le diviseur et soustraire la valeur trouvée.
    Local $arrayCalcul[2]
    $arrayCalcul[0] = $Valeur
    $arrayCalcul[1] = 0

    if $Valeur >= $Diviseur then
        $arrayCalcul[1] = int( $Valeur / $Diviseur )
        $arrayCalcul[0] = $Valeur - ($arrayCalcul[1] * $Diviseur)
    Else
        Return $arrayCalcul
    EndIf

    Return $arrayCalcul
EndFunc
 

Celle-ci est plus rapide, pour 1000 fois le même calcul, j'ai moins de 1 s contre plus de 25 s.
Le calcul maximum, basé sur ceci :

MS = 18446744073709551615.

Me donne une valeur de : 292277265 y 159 d 8 h 16 m 25 s 807 m
Ce qui est amplement suffisant pour moi.

Merci pour ton partage

[zeshrek]

Si je puis me permettre, sans même tenir compte de l'ordinateur quantique (qui a l'heure actuelle reste plus de la science fiction, puisqu'aux dernières nouvelles, on n'en est encore a chercher a fabriquer une mémoire et apres on s'interessera au processeur, c'est dire si il y a de la marge) ce calcul du temps de crackage du pass en force brute ne prend pas en compte la loi de Moore et donc les durées doivent etre singulièrement révisées a la baisse...
Doubler la puissance des ordis tous les 18 mois revient grossierement a diviser par 2 le temps de traitement a faire tous les 18 mois...

[Alex74]

Ne crois pas que j'aie quoi que ce soit contre toi ni contre le sérieux que tu as déployé pour proposer ce que tu penses être correct. Mon propos est simplement qu'il est saugrenu d'employer des moyens ultra-précis (e.g. BigNum) et très lourds pour exprimer un simple ordre de grandeur qui n'a aucune chance de se concrétiser jamais et dont le calcul approché direct peut se faire en deux lignes.

Pas de soucis, j'avoue qu'avec du recul, je n'avais pas intégré ce paramètre à ma réflexion.

@ricky

De rien

@zeshrek

Je lisais justement un article sur la loi Moore il y a quelque temps et sur sa fin programmé/supposée pour 2020 car les transistors seront tellement petits que les électrons sortiront des fils.

Récemment, un chercheur en sécurité a réussi à l'aide de la puissance d'un cloud bien connu (1 000 000 de combinaisons testées à la seconde) à cracker une clé de 6 lettres (je ne connais pas les types composant la clé par contre) en 43 minutes.