bonjour a tous!
 
je suis sous delphi7.
 
j'ai un string du style:  
 
0___0_0____0___00_____0________0__  
 
 
'0' -> la goutte est tombée  
'_' -> la goutte n' est pas tombée  
 
 
et j'aimerai trouver une fonction qui me signale quand mon 'robinet' fuit de maniere  
constante :  
 
0___0___0___0___0___0___0___0  
 
ou encore:  
00_____00_____00_____00_____  
 
 
voila ..dur! dur! et merci a ceux qui pouront m'aider!  
 
 

Pour trouver une fréquence dans un signal, je ne vois que l'auto-corrélation.  
 
Avec des 1 et des 0, ça doit facilement s'implémenter à coup d'operateur logique.  
 
C'est interessant comme prob
 
C'est un exo de cours ?
 

merci pour cette premiere reponse, je suis satisfait que mon message soit comprehensible...
c'est une experience que je fait a titre personnel, pour essayer de 'pieger' le hasard..

Bon les maths et moi ca fait 2 alors avec les formules je suis fort nul, mais je te propose une idée de base:
tu choisis une séquence de longueur suffisante A et tu la compares avec le reste de la séquence B du signal, si ca correspond c'est que le signal est périodique, sinon tu décales de '1' ta position de B et tu recompares:
signal: 0___0___0___0___0___0___0___0
A:0___0
B( le reste du signal):___0___0___0___0___0___0
1ere passe: "0___0" et "___0_" différent
2ieme: "0___0" et "__0__" différent
3ieme: "0___0" et "_0___" différent
4ieme: "0___0" et "0___0" identique    
 
Après la qualité de l'algo viendra du choix de la séquence minimale de A (qui n'est pas optimal dans mon exemple! A= "0___" )
EDIT: dans le cas de A optimal, au lieu d'avancer de 1 'caractère' à la fois, on avance de longeur(A) si les comparaisons successives sont vérifiées, alors on peut en déduire une périodicité....

Bien qu'il doit avoir plusieurs approches (algorithmiques par exemple), je pense que ta méthode n'est pas assez générique, tu vas te retrouver avec plein de cas particuliers à gérer comme des 0__0_0 ( x n fois )
 
 
Le principe que j'entrevois comme ça, à l'instinct :
 
tu prends ta string => tu transformes les '_' en '0' pour en faire un signal numérique g(t) et tu comptes le nombre de '1', s, et sa taille, n (pour normaliser l'autocorrelation, mais autant rester avec des entiers maintenant)
 
ensuite  
pour chaque d compris entre 0 et n tu fais l'intégrale sur t de g(t).g(t+d)  
tu divises par s² (pour normaliser) tu obtiens C
tu obtiens donc une courbe C en fonction de d
ensuite faut voir la gueule qu'à C, de tête j'ai un peu de mal à vrai dire
mais l'idée, c'est qu'à chaque pic correspond une fréquence.  après, mes cours de traitements de signal sont un peu loin, désolé...
 
Le principe de l'autocorrelation, c'est un peu comme faire glisser une tapisserie au moment de la coller pour faire matcher les motifs.

voici exatement ce que je cherche:
 
0______0______0______0______0______0______ ?
 ecart6 ecart6 ecart6 ecart6 ecart6 ecart6 ..en cours..
 
je pars du principe que si mon string est regulier depuis X temps,
 ya pas re raison pour que ca change..
 
--> je m'attends a ce que le prochain charactere soit '0', je met la ligne en rouge..
 
 
autre exemple:
 
0______0_0______0_0______0_0______0_?
       ec1      ec1      ec1      ec1            ..en cours..
 
--> je m'attends a ce que le prochain charactere soit '0', je met la ligne en rouge..
 
 
l'ideal serait d'avoir en + avec une tolerance de +/- 1...
 
merci beaucoup pour vos idées..

Qu'attends tu de nous au juste on t'as déjà donnée de quoi débuter...

j'attends de vous que vous m'ecriviez la formule...nan je blague.....
 
par contre:
 
'tu fais l'intégrale sur t de g(t).g(t+d) '
 
j' avoue que ca me depasse.. moi non plus les maths, c'est vraiment pas mon fort!
 

Heu les intégrales c'est du niveau lycée alors bon y a une limite quand même.
 
Dès que tu fais du traitement du signal, tu as forcément des maths.
 

j'ai une autre approche du pb.
 
si c'est une question de fuite ou pas de fuite :
tu lis ton fichier et  le premier 0 -> indique la fuite
 
 
Apres si tu veux avoir une idée sur  frequence de fuite:
tu peux couper ton fichier en morceaux (morc_x) de +/- 500 - 1000 bits
puis tu calcul la longueur des segement (sans fuite) ( ----- ) et tu les classe dans un tableau (tab_x) en fonction de leurs longueurs
et tu compare les morc_x entre eux,  
 
 
ligne_2 = (deux tirets sans fuite)
ligne_3 = (3 tirets sans fuite)
etc ....  
 
s'il ya une frequence quelquonque on doit avoir le meme nombre de ligne_2, ligne_3, etc .. dans les diffrents tab_x (créés a partir des morc_x)
le lissage tu le controle avec la taille des morc_x
 
puis tu improvise en fonction des resultats
 
pour conclure tu peux utiliser les stats
ex : si sur 100 tab_x tu n'a que 5 qui sont differents, tu peux conclure qu'au risque de 5% la fuite suit une certaine  frequence .