je dispose d'une array d'entiers dans la plage 0 à n (n < 1000) representant
les valuers d'une courbe
du genre
a = array([1, 1, 1, 1, 2, 2, 3, 4, 3, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1])
(je sais elle est pas belle ma courbe)
je voudrais pouvoir sortir de cette array les abscisses correspondant à
l'intersection de la "courbe" avec un seuil telle que la zone
comprise entre les abscisses trouvées contiennent au moin une valeur superieur
a un seuil2
comme un dessin vaut mieux qu'un discours, ca donnerai a peu près ceci
4 + *
|
3 +-----------*---*---------------------- <- seuil2 = 3
|
2 +-------*-*-------*-*-------*-*-*-*- -- <- seuil1 = 2
|
1 * * * * * * * * *
|
0 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
^ ^ ^ ^ ^ ^
| b1 b2 | +---------+---- pas pris en compte il n'y a pas
s1 s2 de valeur >= seuil2 dans
l'intervalle
pour le momment je m'en sort en faisant des pirouettes grace aux methodes
des numarray pour trouver les bornes b1 et b2 des domaines qui contiennent
au moin une valeur >= seuil2, puis a partir de ses bornes je parcours a partir
de b2 en amont et en aval a partir de b1 jsuqu'a trouver le point validant
valeur <= seuil1
du genre pour determiner les bornes b1, b2, b(n)
tmp = numarray.nonzero(numarray.greater(self.coverage, cut_off-1))
suivi d'un parcour de tmp pour determiner si je suis au sein d'un pic ou si je
viens de changer de pic: ie calcul du delta entre 2 valeurs consecutives
delta == 1 ==> même pic
delta != 1 ==> 2 pics différents
c'est lourd et pas tres joli, une idée pour tourner la chose autrement ??
Subject: Numarray et extractikon de plages selon valeur ~~~~~~~~~~~
c'est moi le tikon, j'aurais du me relire ;-(
Eric
Jerome
Eric Deveaud wrote:
bonsoir,
l'exercice du vendredi ;-))
je dispose d'une array d'entiers dans la plage 0 à n (n < 1000) representant les valuers d'une courbe du genre a = array([1, 1, 1, 1, 2, 2, 3, 4, 3, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1])
(je sais elle est pas belle ma courbe)
je voudrais pouvoir sortir de cette array les abscisses correspondant à l'intersection de la "courbe" avec un seuil telle que la zone comprise entre les abscisses trouvées contiennent au moin une valeur superieur a un seuil2
comme un dessin vaut mieux qu'un discours, ca donnerai a peu près ceci
4 + * | 3 +-----------*---*---------------------- <- seuil2 = 3 | 2 +-------*-*-------*-*-------*-*-*-*- -- <- seuil1 = 2 | 1 * * * * * * * * * | 0 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ^ ^ ^ ^ ^ ^ | b1 b2 | +---------+---- pas pris en compte il n'y a pas s1 s2 de valeur >= seuil2 dans l'intervalle
pour le momment je m'en sort en faisant des pirouettes grace aux methodes des numarray pour trouver les bornes b1 et b2 des domaines qui contiennent au moin une valeur >= seuil2, puis a partir de ses bornes je parcours a partir de b2 en amont et en aval a partir de b1 jsuqu'a trouver le point validant valeur <= seuil1
du genre pour determiner les bornes b1, b2, b(n) tmp = numarray.nonzero(numarray.greater(self.coverage, cut_off-1)) suivi d'un parcour de tmp pour determiner si je suis au sein d'un pic ou si je viens de changer de pic: ie calcul du delta entre 2 valeurs consecutives delta == 1 ==> même pic delta != 1 ==> 2 pics différents
c'est lourd et pas tres joli, une idée pour tourner la chose autrement ??
Eric
PS je tiens le code a dispo de qui le veut.
Comment veux-tu gérer le cas où ta fonction est monotone, ou bien quand elle n'est pas continue ?
Eric Deveaud wrote:
bonsoir,
l'exercice du vendredi ;-))
je dispose d'une array d'entiers dans la plage 0 à n (n < 1000) representant
les valuers d'une courbe
du genre
a = array([1, 1, 1, 1, 2, 2, 3, 4, 3, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1])
(je sais elle est pas belle ma courbe)
je voudrais pouvoir sortir de cette array les abscisses correspondant à
l'intersection de la "courbe" avec un seuil telle que la zone
comprise entre les abscisses trouvées contiennent au moin une valeur superieur
a un seuil2
comme un dessin vaut mieux qu'un discours, ca donnerai a peu près ceci
4 + *
|
3 +-----------*---*---------------------- <- seuil2 = 3
|
2 +-------*-*-------*-*-------*-*-*-*- -- <- seuil1 = 2
|
1 * * * * * * * * *
|
0 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
^ ^ ^ ^ ^ ^
| b1 b2 | +---------+---- pas pris en compte il n'y a pas
s1 s2 de valeur >= seuil2 dans
l'intervalle
pour le momment je m'en sort en faisant des pirouettes grace aux methodes
des numarray pour trouver les bornes b1 et b2 des domaines qui contiennent
au moin une valeur >= seuil2, puis a partir de ses bornes je parcours a partir
de b2 en amont et en aval a partir de b1 jsuqu'a trouver le point validant
valeur <= seuil1
du genre pour determiner les bornes b1, b2, b(n)
tmp = numarray.nonzero(numarray.greater(self.coverage, cut_off-1))
suivi d'un parcour de tmp pour determiner si je suis au sein d'un pic ou si je
viens de changer de pic: ie calcul du delta entre 2 valeurs consecutives
delta == 1 ==> même pic
delta != 1 ==> 2 pics différents
c'est lourd et pas tres joli, une idée pour tourner la chose autrement ??
Eric
PS je tiens le code a dispo de qui le veut.
Comment veux-tu gérer le cas où ta fonction est monotone, ou bien quand
elle n'est pas continue ?
je dispose d'une array d'entiers dans la plage 0 à n (n < 1000) representant les valuers d'une courbe du genre a = array([1, 1, 1, 1, 2, 2, 3, 4, 3, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1])
(je sais elle est pas belle ma courbe)
je voudrais pouvoir sortir de cette array les abscisses correspondant à l'intersection de la "courbe" avec un seuil telle que la zone comprise entre les abscisses trouvées contiennent au moin une valeur superieur a un seuil2
comme un dessin vaut mieux qu'un discours, ca donnerai a peu près ceci
4 + * | 3 +-----------*---*---------------------- <- seuil2 = 3 | 2 +-------*-*-------*-*-------*-*-*-*- -- <- seuil1 = 2 | 1 * * * * * * * * * | 0 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ^ ^ ^ ^ ^ ^ | b1 b2 | +---------+---- pas pris en compte il n'y a pas s1 s2 de valeur >= seuil2 dans l'intervalle
pour le momment je m'en sort en faisant des pirouettes grace aux methodes des numarray pour trouver les bornes b1 et b2 des domaines qui contiennent au moin une valeur >= seuil2, puis a partir de ses bornes je parcours a partir de b2 en amont et en aval a partir de b1 jsuqu'a trouver le point validant valeur <= seuil1
du genre pour determiner les bornes b1, b2, b(n) tmp = numarray.nonzero(numarray.greater(self.coverage, cut_off-1)) suivi d'un parcour de tmp pour determiner si je suis au sein d'un pic ou si je viens de changer de pic: ie calcul du delta entre 2 valeurs consecutives delta == 1 ==> même pic delta != 1 ==> 2 pics différents
c'est lourd et pas tres joli, une idée pour tourner la chose autrement ??
Eric
PS je tiens le code a dispo de qui le veut.
Comment veux-tu gérer le cas où ta fonction est monotone, ou bien quand elle n'est pas continue ?
Eric Deveaud
Jerome wrote:
Comment veux-tu gérer le cas où ta fonction est monotone, ou bien quand elle n'est pas continue ?
ce n'est pas une fonction, ce sont des données collectés lors de séquençage shot gun. les valeurs représentent le nombre de fragments séquences pour une base du consensu.
Eric. pas matheux pour 2 sous ;-)
-- A noter que si on a installé Macsbug, on peut avoir accès à une fenêtre bien plus grande, bourrée d'information passionnantes, en couleur et clickodrome. Et tout pour planter geekement son Mac. -+- Ol. in Guide du Macounet Pervers : Savez-vous planter des choux..-+-
Jerome wrote:
Comment veux-tu gérer le cas où ta fonction est monotone, ou bien quand
elle n'est pas continue ?
ce n'est pas une fonction, ce sont des données collectés lors de séquençage
shot gun.
les valeurs représentent le nombre de fragments séquences pour une base du
consensu.
Eric. pas matheux pour 2 sous ;-)
--
A noter que si on a installé Macsbug, on peut avoir accès à une fenêtre
bien plus grande, bourrée d'information passionnantes, en couleur et
clickodrome. Et tout pour planter geekement son Mac.
-+- Ol. in Guide du Macounet Pervers : Savez-vous planter des choux..-+-
Comment veux-tu gérer le cas où ta fonction est monotone, ou bien quand elle n'est pas continue ?
ce n'est pas une fonction, ce sont des données collectés lors de séquençage shot gun. les valeurs représentent le nombre de fragments séquences pour une base du consensu.
Eric. pas matheux pour 2 sous ;-)
-- A noter que si on a installé Macsbug, on peut avoir accès à une fenêtre bien plus grande, bourrée d'information passionnantes, en couleur et clickodrome. Et tout pour planter geekement son Mac. -+- Ol. in Guide du Macounet Pervers : Savez-vous planter des choux..-+-
Gerard Flanagan
Eric Deveaud wrote:
bonsoir,
l'exercice du vendredi ;-))
je dispose d'une array d'entiers dans la plage 0 à n (n < 1000) represe ntant les valuers d'une courbe du genre a = array([1, 1, 1, 1, 2, 2, 3, 4, 3, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1])
(je sais elle est pas belle ma courbe)
je voudrais pouvoir sortir de cette array les abscisses correspondant à l'intersection de la "courbe" avec un seuil telle que la zone comprise entre les abscisses trouvées contiennent au moin une valeur su perieur a un seuil2
comme un dessin vaut mieux qu'un discours, ca donnerai a peu près ceci
4 + * | 3 +-----------*---*---------------------- <- seuil2 = 3 | 2 +-------*-*-------*-*-------*-*-*-*- -- <- seuil1 = 2 | 1 * * * * * * * * * | 0 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ^ ^ ^ ^ ^ ^ | b1 b2 | +---------+---- pas pris en compte il n'y a p as s1 s2 de valeur >= seuil2 dans l'intervalle
pour le momment je m'en sort en faisant des pirouettes grace aux methodes des numarray pour trouver les bornes b1 et b2 des domaines qui contiennent au moin une valeur >= seuil2, puis a partir de ses bornes je parcours a partir de b2 en amont et en aval a partir de b1 jsuqu'a trouver le point validant valeur <= seuil1
du genre pour determiner les bornes b1, b2, b(n) tmp = numarray.nonzero(numarray.greater(self.coverage, cut_off-1)) suivi d'un parcour de tmp pour determiner si je suis au sein d'un pic ou si je viens de changer de pic: ie calcul du delta entre 2 valeurs consecutives delta == 1 ==> même pic delta != 1 ==> 2 pics différents
c'est lourd et pas tres joli, une idée pour tourner la chose autrement ??
Eric
PS je tiens le code a dispo de qui le veut.
une idee (si j'ai compris le probleme):
from itertools import groupby
graph = lambda lst: enumerate(lst)
def iterarcs(lst, inf): for k,g in groupby( graph(a), lambda (x,y): y<inf ): if k is False: yield list(g)
def filtre(lst, sup): for (x, y) in lst: if y>sup: return True return False
intervalles = [ (X[0][0], X[-1][0]) for X in itergraph(a, seuil1) if filtre(X, seuil2) ]
print intervalles
out: [(4, 10)]
Gerard
Eric Deveaud wrote:
bonsoir,
l'exercice du vendredi ;-))
je dispose d'une array d'entiers dans la plage 0 à n (n < 1000) represe ntant
les valuers d'une courbe
du genre
a = array([1, 1, 1, 1, 2, 2, 3, 4, 3, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1])
(je sais elle est pas belle ma courbe)
je voudrais pouvoir sortir de cette array les abscisses correspondant à
l'intersection de la "courbe" avec un seuil telle que la zone
comprise entre les abscisses trouvées contiennent au moin une valeur su perieur
a un seuil2
comme un dessin vaut mieux qu'un discours, ca donnerai a peu près ceci
4 + *
|
3 +-----------*---*---------------------- <- seuil2 = 3
|
2 +-------*-*-------*-*-------*-*-*-*- -- <- seuil1 = 2
|
1 * * * * * * * * *
|
0 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
^ ^ ^ ^ ^ ^
| b1 b2 | +---------+---- pas pris en compte il n'y a p as
s1 s2 de valeur >= seuil2 dans
l'intervalle
pour le momment je m'en sort en faisant des pirouettes grace aux methodes
des numarray pour trouver les bornes b1 et b2 des domaines qui contiennent
au moin une valeur >= seuil2, puis a partir de ses bornes je parcours a partir
de b2 en amont et en aval a partir de b1 jsuqu'a trouver le point validant
valeur <= seuil1
du genre pour determiner les bornes b1, b2, b(n)
tmp = numarray.nonzero(numarray.greater(self.coverage, cut_off-1))
suivi d'un parcour de tmp pour determiner si je suis au sein d'un pic ou si je
viens de changer de pic: ie calcul du delta entre 2 valeurs consecutives
delta == 1 ==> même pic
delta != 1 ==> 2 pics différents
c'est lourd et pas tres joli, une idée pour tourner la chose autrement ??
Eric
PS je tiens le code a dispo de qui le veut.
une idee (si j'ai compris le probleme):
from itertools import groupby
graph = lambda lst: enumerate(lst)
def iterarcs(lst, inf):
for k,g in groupby( graph(a), lambda (x,y): y<inf ):
if k is False:
yield list(g)
def filtre(lst, sup):
for (x, y) in lst:
if y>sup:
return True
return False
je dispose d'une array d'entiers dans la plage 0 à n (n < 1000) represe ntant les valuers d'une courbe du genre a = array([1, 1, 1, 1, 2, 2, 3, 4, 3, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1])
(je sais elle est pas belle ma courbe)
je voudrais pouvoir sortir de cette array les abscisses correspondant à l'intersection de la "courbe" avec un seuil telle que la zone comprise entre les abscisses trouvées contiennent au moin une valeur su perieur a un seuil2
comme un dessin vaut mieux qu'un discours, ca donnerai a peu près ceci
4 + * | 3 +-----------*---*---------------------- <- seuil2 = 3 | 2 +-------*-*-------*-*-------*-*-*-*- -- <- seuil1 = 2 | 1 * * * * * * * * * | 0 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ^ ^ ^ ^ ^ ^ | b1 b2 | +---------+---- pas pris en compte il n'y a p as s1 s2 de valeur >= seuil2 dans l'intervalle
pour le momment je m'en sort en faisant des pirouettes grace aux methodes des numarray pour trouver les bornes b1 et b2 des domaines qui contiennent au moin une valeur >= seuil2, puis a partir de ses bornes je parcours a partir de b2 en amont et en aval a partir de b1 jsuqu'a trouver le point validant valeur <= seuil1
du genre pour determiner les bornes b1, b2, b(n) tmp = numarray.nonzero(numarray.greater(self.coverage, cut_off-1)) suivi d'un parcour de tmp pour determiner si je suis au sein d'un pic ou si je viens de changer de pic: ie calcul du delta entre 2 valeurs consecutives delta == 1 ==> même pic delta != 1 ==> 2 pics différents
c'est lourd et pas tres joli, une idée pour tourner la chose autrement ??
Eric
PS je tiens le code a dispo de qui le veut.
une idee (si j'ai compris le probleme):
from itertools import groupby
graph = lambda lst: enumerate(lst)
def iterarcs(lst, inf): for k,g in groupby( graph(a), lambda (x,y): y<inf ): if k is False: yield list(g)
def filtre(lst, sup): for (x, y) in lst: if y>sup: return True return False
intervalles = [ (X[0][0], X[-1][0]) for X in itergraph(a, seuil1) if filtre(X, seuil2) ]
print intervalles
out: [(4, 10)]
Gerard
Gerard Flanagan
Gerard Flanagan wrote:
Eric Deveaud wrote:
bonsoir,
l'exercice du vendredi ;-))
je dispose d'une array d'entiers dans la plage 0 à n (n < 1000) repre sentant les valuers d'une courbe du genre a = array([1, 1, 1, 1, 2, 2, 3, 4, 3, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1 ])
(je sais elle est pas belle ma courbe)
je voudrais pouvoir sortir de cette array les abscisses correspondant à l'intersection de la "courbe" avec un seuil telle que la zone comprise entre les abscisses trouvées contiennent au moin une valeur superieur a un seuil2
comme un dessin vaut mieux qu'un discours, ca donnerai a peu près ceci
4 + * | 3 +-----------*---*---------------------- <- seuil2 = 3 | 2 +-------*-*-------*-*-------*-*-*-*- -- <- seuil1 = 2 | 1 * * * * * * * * * | 0 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ^ ^ ^ ^ ^ ^ | b1 b2 | +---------+---- pas pris en compte il n'y a pas s1 s2 de valeur >= seuil2 dans l'intervalle
pour le momment je m'en sort en faisant des pirouettes grace aux method es des numarray pour trouver les bornes b1 et b2 des domaines qui contienn ent au moin une valeur >= seuil2, puis a partir de ses bornes je parcours a partir de b2 en amont et en aval a partir de b1 jsuqu'a trouver le point valid ant valeur <= seuil1
du genre pour determiner les bornes b1, b2, b(n) tmp = numarray.nonzero(numarray.greater(self.coverage, cut_off-1)) suivi d'un parcour de tmp pour determiner si je suis au sein d'un pic o u si je viens de changer de pic: ie calcul du delta entre 2 valeurs consecutives delta == 1 ==> même pic delta != 1 ==> 2 pics différents
c'est lourd et pas tres joli, une idée pour tourner la chose autremen t ??
Eric
PS je tiens le code a dispo de qui le veut.
une idee (si j'ai compris le probleme):
from itertools import groupby
graph = lambda lst: enumerate(lst)
def iterarcs(lst, inf): for k,g in groupby( graph(a), lambda (x,y): y<inf ): if k is False: yield list(g)
def filtre(lst, sup): for (x, y) in lst: if y>sup: return True return False
intervalles = [ (X[0][0], X[-1][0]) for X in itergraph(a, seuil1, seuil2) ]
print intervalles
-----------------------------------
Gerard
Gerard Flanagan wrote:
Eric Deveaud wrote:
bonsoir,
l'exercice du vendredi ;-))
je dispose d'une array d'entiers dans la plage 0 à n (n < 1000) repre sentant
les valuers d'une courbe
du genre
a = array([1, 1, 1, 1, 2, 2, 3, 4, 3, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1 ])
(je sais elle est pas belle ma courbe)
je voudrais pouvoir sortir de cette array les abscisses correspondant à
l'intersection de la "courbe" avec un seuil telle que la zone
comprise entre les abscisses trouvées contiennent au moin une valeur superieur
a un seuil2
comme un dessin vaut mieux qu'un discours, ca donnerai a peu près ceci
4 + *
|
3 +-----------*---*---------------------- <- seuil2 = 3
|
2 +-------*-*-------*-*-------*-*-*-*- -- <- seuil1 = 2
|
1 * * * * * * * * *
|
0 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
^ ^ ^ ^ ^ ^
| b1 b2 | +---------+---- pas pris en compte il n'y a pas
s1 s2 de valeur >= seuil2 dans
l'intervalle
pour le momment je m'en sort en faisant des pirouettes grace aux method es
des numarray pour trouver les bornes b1 et b2 des domaines qui contienn ent
au moin une valeur >= seuil2, puis a partir de ses bornes je parcours a partir
de b2 en amont et en aval a partir de b1 jsuqu'a trouver le point valid ant
valeur <= seuil1
du genre pour determiner les bornes b1, b2, b(n)
tmp = numarray.nonzero(numarray.greater(self.coverage, cut_off-1))
suivi d'un parcour de tmp pour determiner si je suis au sein d'un pic o u si je
viens de changer de pic: ie calcul du delta entre 2 valeurs consecutives
delta == 1 ==> même pic
delta != 1 ==> 2 pics différents
c'est lourd et pas tres joli, une idée pour tourner la chose autremen t ??
Eric
PS je tiens le code a dispo de qui le veut.
une idee (si j'ai compris le probleme):
from itertools import groupby
graph = lambda lst: enumerate(lst)
def iterarcs(lst, inf):
for k,g in groupby( graph(a), lambda (x,y): y<inf ):
if k is False:
yield list(g)
def filtre(lst, sup):
for (x, y) in lst:
if y>sup:
return True
return False
je dispose d'une array d'entiers dans la plage 0 à n (n < 1000) repre sentant les valuers d'une courbe du genre a = array([1, 1, 1, 1, 2, 2, 3, 4, 3, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1 ])
(je sais elle est pas belle ma courbe)
je voudrais pouvoir sortir de cette array les abscisses correspondant à l'intersection de la "courbe" avec un seuil telle que la zone comprise entre les abscisses trouvées contiennent au moin une valeur superieur a un seuil2
comme un dessin vaut mieux qu'un discours, ca donnerai a peu près ceci
4 + * | 3 +-----------*---*---------------------- <- seuil2 = 3 | 2 +-------*-*-------*-*-------*-*-*-*- -- <- seuil1 = 2 | 1 * * * * * * * * * | 0 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ^ ^ ^ ^ ^ ^ | b1 b2 | +---------+---- pas pris en compte il n'y a pas s1 s2 de valeur >= seuil2 dans l'intervalle
pour le momment je m'en sort en faisant des pirouettes grace aux method es des numarray pour trouver les bornes b1 et b2 des domaines qui contienn ent au moin une valeur >= seuil2, puis a partir de ses bornes je parcours a partir de b2 en amont et en aval a partir de b1 jsuqu'a trouver le point valid ant valeur <= seuil1
du genre pour determiner les bornes b1, b2, b(n) tmp = numarray.nonzero(numarray.greater(self.coverage, cut_off-1)) suivi d'un parcour de tmp pour determiner si je suis au sein d'un pic o u si je viens de changer de pic: ie calcul du delta entre 2 valeurs consecutives delta == 1 ==> même pic delta != 1 ==> 2 pics différents
c'est lourd et pas tres joli, une idée pour tourner la chose autremen t ??
Eric
PS je tiens le code a dispo de qui le veut.
une idee (si j'ai compris le probleme):
from itertools import groupby
graph = lambda lst: enumerate(lst)
def iterarcs(lst, inf): for k,g in groupby( graph(a), lambda (x,y): y<inf ): if k is False: yield list(g)
def filtre(lst, sup): for (x, y) in lst: if y>sup: return True return False
intervalles = [ (X[0][0], X[-1][0]) for X in itergraph(a, seuil1, seuil2) ]
print intervalles
-----------------------------------
Gerard
Gerard Flanagan
Gerard Flanagan wrote:
Gerard Flanagan wrote:
Eric Deveaud wrote:
bonsoir,
l'exercice du vendredi ;-))
je dispose d'une array d'entiers dans la plage 0 à n (n < 1000) rep resentant les valuers d'une courbe du genre a = array([1, 1, 1, 1, 2, 2, 3, 4, 3, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1])
(je sais elle est pas belle ma courbe)
je voudrais pouvoir sortir de cette array les abscisses correspondant à l'intersection de la "courbe" avec un seuil telle que la zone comprise entre les abscisses trouvées contiennent au moin une valeu r superieur a un seuil2
comme un dessin vaut mieux qu'un discours, ca donnerai a peu près c eci
4 + * | 3 +-----------*---*---------------------- <- seuil2 = 3 | 2 +-------*-*-------*-*-------*-*-*-*- -- <- seuil1 = 2 | 1 * * * * * * * * * | 0 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ^ ^ ^ ^ ^ ^ | b1 b2 | +---------+---- pas pris en compte il n'y a pas s1 s2 de valeur >= seuil2 dans l'intervalle
pour le momment je m'en sort en faisant des pirouettes grace aux meth odes des numarray pour trouver les bornes b1 et b2 des domaines qui contie nnent au moin une valeur >= seuil2, puis a partir de ses bornes je parcou rs a partir de b2 en amont et en aval a partir de b1 jsuqu'a trouver le point val idant valeur <= seuil1
du genre pour determiner les bornes b1, b2, b(n) tmp = numarray.nonzero(numarray.greater(self.coverage, cut_off-1)) suivi d'un parcour de tmp pour determiner si je suis au sein d'un pic ou si je viens de changer de pic: ie calcul du delta entre 2 valeurs consecuti ves delta == 1 ==> même pic delta != 1 ==> 2 pics différents
c'est lourd et pas tres joli, une idée pour tourner la chose autrem ent ??
------------------------------------------- from itertools import groupby
def groups(lst, inf): for k,g in groupby( enumerate(lst), lambda (x,y): y<inf ): if k is False: yield list(g)
def itergraph(lst, inf, sup): for X in groups(lst, inf): for (x, y) in X: if y>sup: yield X
pardon, un 'break' est essentiel ici pour eviter repetition:
def itergraph(lst, inf, sup): for X in groups(lst, inf): for (x, y) in X: if y>sup: yield X break
intervalles = [ (X[0][0], X[-1][0]) for X in itergraph(a, seuil1, seuil2) ]
print intervalles
-----------------------------------
Gerard
Gerard Flanagan wrote:
Gerard Flanagan wrote:
Eric Deveaud wrote:
bonsoir,
l'exercice du vendredi ;-))
je dispose d'une array d'entiers dans la plage 0 à n (n < 1000) rep resentant
les valuers d'une courbe
du genre
a = array([1, 1, 1, 1, 2, 2, 3, 4, 3, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1])
(je sais elle est pas belle ma courbe)
je voudrais pouvoir sortir de cette array les abscisses correspondant à
l'intersection de la "courbe" avec un seuil telle que la zone
comprise entre les abscisses trouvées contiennent au moin une valeu r superieur
a un seuil2
comme un dessin vaut mieux qu'un discours, ca donnerai a peu près c eci
4 + *
|
3 +-----------*---*---------------------- <- seuil2 = 3
|
2 +-------*-*-------*-*-------*-*-*-*- -- <- seuil1 = 2
|
1 * * * * * * * * *
|
0 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
^ ^ ^ ^ ^ ^
| b1 b2 | +---------+---- pas pris en compte il n'y a pas
s1 s2 de valeur >= seuil2 dans
l'intervalle
pour le momment je m'en sort en faisant des pirouettes grace aux meth odes
des numarray pour trouver les bornes b1 et b2 des domaines qui contie nnent
au moin une valeur >= seuil2, puis a partir de ses bornes je parcou rs a partir
de b2 en amont et en aval a partir de b1 jsuqu'a trouver le point val idant
valeur <= seuil1
du genre pour determiner les bornes b1, b2, b(n)
tmp = numarray.nonzero(numarray.greater(self.coverage, cut_off-1))
suivi d'un parcour de tmp pour determiner si je suis au sein d'un pic ou si je
viens de changer de pic: ie calcul du delta entre 2 valeurs consecuti ves
delta == 1 ==> même pic
delta != 1 ==> 2 pics différents
c'est lourd et pas tres joli, une idée pour tourner la chose autrem ent ??
-------------------------------------------
from itertools import groupby
def groups(lst, inf):
for k,g in groupby( enumerate(lst), lambda (x,y): y<inf ):
if k is False:
yield list(g)
def itergraph(lst, inf, sup):
for X in groups(lst, inf):
for (x, y) in X:
if y>sup:
yield X
pardon, un 'break' est essentiel ici pour eviter repetition:
def itergraph(lst, inf, sup):
for X in groups(lst, inf):
for (x, y) in X:
if y>sup:
yield X
break
je dispose d'une array d'entiers dans la plage 0 à n (n < 1000) rep resentant les valuers d'une courbe du genre a = array([1, 1, 1, 1, 2, 2, 3, 4, 3, 2, 2, 1, 1, 1, 2, 2, 2, 2, 1, 1])
(je sais elle est pas belle ma courbe)
je voudrais pouvoir sortir de cette array les abscisses correspondant à l'intersection de la "courbe" avec un seuil telle que la zone comprise entre les abscisses trouvées contiennent au moin une valeu r superieur a un seuil2
comme un dessin vaut mieux qu'un discours, ca donnerai a peu près c eci
4 + * | 3 +-----------*---*---------------------- <- seuil2 = 3 | 2 +-------*-*-------*-*-------*-*-*-*- -- <- seuil1 = 2 | 1 * * * * * * * * * | 0 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ^ ^ ^ ^ ^ ^ | b1 b2 | +---------+---- pas pris en compte il n'y a pas s1 s2 de valeur >= seuil2 dans l'intervalle
pour le momment je m'en sort en faisant des pirouettes grace aux meth odes des numarray pour trouver les bornes b1 et b2 des domaines qui contie nnent au moin une valeur >= seuil2, puis a partir de ses bornes je parcou rs a partir de b2 en amont et en aval a partir de b1 jsuqu'a trouver le point val idant valeur <= seuil1
du genre pour determiner les bornes b1, b2, b(n) tmp = numarray.nonzero(numarray.greater(self.coverage, cut_off-1)) suivi d'un parcour de tmp pour determiner si je suis au sein d'un pic ou si je viens de changer de pic: ie calcul du delta entre 2 valeurs consecuti ves delta == 1 ==> même pic delta != 1 ==> 2 pics différents
c'est lourd et pas tres joli, une idée pour tourner la chose autrem ent ??
------------------------------------------- from itertools import groupby
def groups(lst, inf): for k,g in groupby( enumerate(lst), lambda (x,y): y<inf ): if k is False: yield list(g)
def itergraph(lst, inf, sup): for X in groups(lst, inf): for (x, y) in X: if y>sup: yield X
pardon, un 'break' est essentiel ici pour eviter repetition:
def itergraph(lst, inf, sup): for X in groups(lst, inf): for (x, y) in X: if y>sup: yield X break
