UNIX - MODULE TIME : TEMPS D'UNE FONCTION ALGORITHMIQUE AVEC TIME() ET CLOCK()

## Unix -- Rapidité d'algorithme --
"""
clock();
    On Unix, return the current processor time as a floating point
    number expressed in seconds. The precision, and in fact the very
    definition of the meaning of ``processor time'', depends on that
    of the C function of the same name, but in any case, this is the
    function to use for benchmarking Python or timing algorithms.

Time():
    Return the time as a floating point number expressed in seconds since
    the epoch, in UTC. Note that even though the time is always returned
    as a floating point number, not all systems provide time with a better
    precision than 1 second. While this function normally returns
    non-decreasing values, it can return a lower value than a previous
    call if the system clock has been set back between the two calls. 

En français :

Clock():
    Sous Unix, retourne le temps en valeur décimal(type float) exprimé
    en seconde du temps du processeur courant
    La précision, est la signification même du temps exprimé par le processeur,
    elle dépend de celle de la fonction de C du même nom, mais de toute façon,
    c'est la fonction à employer pour le benchmark sous python, ou le test sur
    la rapidité des algorithmes.
    
Time():
    Retoune le temps en valeur décimal(type float) exprimé en seconde depuis la
    date d'Epoch, de l'UTC.
    Notez que même si le temps est retourné en nombre décimal, les systèmes
    n'ont pas tous une précision plus petite qu'une seconde. 
    Attention toutefois, cette fonction renvoie normalement des valeurs 
    croissantes à chaque appel, sauf si l'horloge du système a été modifié 
    entre deux appels de fonction.

'UTC' : Coordinated Universal Time (UTC) est une grande précision du temps
international, utilise partout dans le monde. C'est un standard.

'Epoch' : représente la date initiale à partir de laquelle est mesuré le
temps par les systèmes d'exploitation
-sous UNIX, c'est 1er janvier 1970 à 0 heure (UTC)
(source : wikipédia)


Ce sont les deux fonctions temps les plus utilisés.
Néanmoins la fonction clock(), n'est pas assez précise. 
Sa précision après la virgule n'excède pas le centième.
Il sera arrondis.

Ma fonction propose d'utiliser les deux fonctions, de les appellé 10fois,
et faire une moyenne.
(lorsque bien sur le résultat de clock est différent de 0)

Pour effectuer le test d'une de vos fonctions, remplacez "testb" par votre
fonction.

Pensez à fermez vos programmes

"""

import time

#Fonction inutile, juste pour le test (à remplaçer par votre algo)
def testb():
    for i in range(500):
        for i2 in range(100):
            v=(i*i2)

def getTime(mfunc, verbose=0):

    t0=time.time()
    mfunc()
    t1=time.time()
    t=t1-t0
    
    c0=time.clock()
    mfunc()
    c1=time.clock()
    c=c1-c0

    if (verbose):
        print "time() : ",t
        print "clock() : ",c


    if (c > 0):
        result=(t+c)/2
    else :
        result=t

    return result

print "Demarrage du test, veuillez patientez..."

# On stock nos temps dans la liste
tab_result=[]

# On appel 10 fois la fonction getTime pour stocker son résultat dans tab_result
for i in range(10):
    tab_result.append(getTime(testb,0))

moy=0
for num in tab_result:
    moy=moy+num
moy=moy/len(tab_result)

print moy