[bioinfo] fonction qui renvoie chaîne à autre fonction

**perlaud** · 16/07/2004, 12h15

Voilà, j'ai une fonction DICE qui découpe une longue chaine en plus petite chaine ( chaine de 19 caractères) puis j'applique à ces petites chaînes différents traitements ( par exemple, la fonction pourcentage_GC qui calcule le %GC de chaque séquence)

Voici mon code ( j'espère qu'il n'est pas trop long!)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
#!/usr/bin/perl 
 
use Getopt::Long; 
 
my @sequence; my @table; my @table;
my $GC; my $fichier; my $sequence;
my $longueur_ARNm; my $boucle=0; my $lim;
# Declaration des variables utilisees pour le calcul des scores
my $score_GC; my $pourcentage_GC;
my $l; my $c; # pour l'affichages des résultats 
my @resultat;
my $lg_siRNA=13; # pour le calcul de la TM
 
#######################################################################################
# Fonction Getopt lit les options passées en ligne de commande (avec des raccourcis de commande)
Getopt::Long::GetOptions('G=s' => \$GC);
 
# Calcul du pourcentage de GC 
 
sub pourcentage_GC
 
	{	
my ($sequence)=@_;
my $total_pb;
my $pourcentage_GC;
my $A=0; my $G=0; my $C=0; my $U=0;
 
while ($sequence =~ /A/gi) { $A =$A+1; }
while ($sequence =~ /G/gi) { $G =$G+1; }
while ($sequence =~ /U/gi) { $U =$U+1; }
while ($sequence =~ /C/gi) { $C =$C+1; }
 
print "C $C\t G $G\t A $A\t U $U\n";
 
$total_pb = $C+$G+$A+$U;
print "$total_pb\n";
$pourcentage_GC=($C+ $G)/ $total_pb *100;
$pourcentage_GC = int ( $pourcentage_GC);
print "\n$pourcentage_GC%\n";
return ($pourcentage_GC);
	}
 
sub DICE
{
my ($sequence) =@_;
my $boucle=0; 
my $LENGTH=19;
my $longueur=length($sequence);
my $lim= $longueur-$LENGTH+1;
my @table;
 
while ($boucle< $lim)
	{
$table[$boucle]=substr ($sequence, $boucle, $LENGTH);
print "$table[$boucle]\n";
$boucle ++;	
	}
return @table;
}
 
print "Chemin du fichier a traiter : "; 
chomp ($fichier = <STDIN>); 
open (FIC , "$fichier") || die "Probleme d'ouverture: $!"; 
while ($seq = <FIC>) 
{ chomp $seq; 
$sequence=$sequence.$seq; } 
close FIC; 
DICE ($sequence);
 
$longueur=length($sequence);
$lim= $longueur-$LENGTH+1;
 
$boucle =0;
while ($boucle< $lim)
	{
#appel de la fonction
($table[$boucle])=  uc ($table[$boucle]); 
$table[$boucle]=~tr/T/U/; 
 
if ($GC!=0) { ($score_GC) = pourcentage_GC($table[$boucle]); } 
else { $score_GC = 0; }
 
$boucle++;		
	}

et le pbl est que j'ai tjrs le même message d'erreur qui est :

Illegal division by zero at ./Khvorova_reuni.pl line 37

la ligne 37 correspond à :

$pourcentage_GC=($C+ $G)/ $total_pb *100;

et en fait ca ne calcule pas le % en GC car ca na compte même pas les A les G les C et les T.

Dc je pense qu'il y a un pbl de "transmission" de ma séquence ( de paramètre) lorsqu'elle aété traitée par la fonction DICE ( car si je supprime la fonction DICE, la fonction calcul de % en GC marche très bien)

Au fait je suis sous mac os 10 et pour executer le programme il faut faire :

./Khvorova_reuni.pl -G 1

car j'utilise la fonction GetOption

j'ai vraiment besoin d'aide!!!!

merci

**fsapet** · 16/07/2004, 12h38

salut

je jette un coup d'oeil,

mais premiere remarque apres avoir copie-colle ton code pour tester : ou sont passes

use strict;
et
use warnings;

il y a deja deux fois la declaration de my @tables

"my" variable @table masks earlier declaration in same scope at ./test.pl lineGlobal symbol "$seq" requires explicit package name at ./test.pl line

et toutes les variables ne sont pas declarees

Global symbol "$seq" requires explicit package name at ./test.pl line
Global symbol "$longueur" requires explicit package name at ./test.pl l
Global symbol "$longueur" requires explicit package name at ./test.pl
Global symbol "$LENGTH" requires explicit package name at ./test.pl

**Jedai** · 16/07/2004, 12h45

Le pb est plus surement là :
$lim= $longueur-$LENGTH+1; (pas dans la fonction DICE, mais à l'extérieur)

Comme $LENGTH n'est défini que dans la fonction DICE, et que tu n'utilises pas "use strict;", $LENGTH est déclaré silencieusement, et prend la valeur undef, qui se traduit par 0 pour un calcul... Autrement dit, $lim vaut $longueur+1 !! Problème !

--
Jedaï

**fsapet** · 16/07/2004, 12h56

il y a aussi un souci ici : if ($GC!=0) au lieu de if ($GC != 0) sinon on cherche a affecter 0 a la variable $GC!

sans le use strict et les warnings c'est tres dur ensuite de debugger

**perlaud** · 16/07/2004, 13h00

sorry, je ne savais pas que je pouvais mettre use strict et use GetOption ensemble, c'ets super j'apprends des choses ( il me semblait que j'avais eu un message d'erreur la fis où je l'ai fait)
j'ai rectifier le code au niveau des déclarations et j'ai tjrs le même message d'erreur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#!/usr/bin/perl -w
use strict;
use Getopt::Long; 
 
my @sequence; my @table; 
my $GC; my $fichier; my $sequence; my $seq; my $longueur;
my $longueur_ARNm; my $boucle=0; my $lim;
# Declaration des variables utilisees pour le calcul des scores
my $score_GC; my $pourcentage_GC;
my $l; my $c; # pour l'affichages des résultats 
my @resultat;
my $lg_siRNA=13; # pour le calcul de la TM
my $LENGTH=19;
 
#######################################################################################
# Fonction Getopt lit les options passées en ligne de commande (avec des raccourcis de commande)
Getopt::Long::GetOptions('G=s' => \$GC);
 
# Calcul du pourcentage de GC 
 
sub pourcentage_GC
 
	{	
my ($sequence)=@_;
my $total_pb;
my $pourcentage_GC;
my $A=0; my $G=0; my $C=0; my $U=0;
 
while ($sequence =~ /A/gi) { $A =$A+1; }
while ($sequence =~ /G/gi) { $G =$G+1; }
while ($sequence =~ /U/gi) { $U =$U+1; }
while ($sequence =~ /C/gi) { $C =$C+1; }
 
print "C $C\t G $G\t A $A\t U $U\n";
 
$total_pb = $C+$G+$A+$U;
print "$total_pb\n";
$pourcentage_GC=($C+ $G)/ $total_pb *100;
$pourcentage_GC = int ( $pourcentage_GC);
print "\n$pourcentage_GC%\n";
return ($pourcentage_GC);
	}
 
sub DICE
{
my ($sequence) =@_;
my $boucle=0; 
my $LENGTH=19;
my $longueur=length($sequence);
my $lim= $longueur-$LENGTH+1;
my @table;
 
while ($boucle< $lim)
	{
$table[$boucle]=substr ($sequence, $boucle, $LENGTH);
print "$table[$boucle]\n";
$boucle ++;	
	}
return @table;
}
 
print "Chemin du fichier a traiter : "; 
chomp ($fichier = <STDIN>); 
open (FIC , "$fichier") || die "Probleme d'ouverture: $!"; 
while ($seq = <FIC>) 
{ chomp $seq; 
$sequence=$sequence.$seq; } 
close FIC; 
DICE ($sequence);
 
$longueur=length($sequence);
$lim= $longueur-$LENGTH+1;
 
$boucle =0;
while ($boucle< $lim)
	{
#appel de la fonction
($table[$boucle])=  uc ($table[$boucle]); 
$table[$boucle]=~tr/T/U/; 
 
if ($GC!=0) { ($score_GC) = pourcentage_GC($table[$boucle]); } 
else { $score_GC = 0; }
 
$boucle++;		
	}

merci bcp

**fsapet** · 16/07/2004, 13h13

il me semble que j'ai resolu ton pb,

je te donne quelques pistes pour que tu trouves pqr toi meme,

ta fonction DICE retourne un tableau, il serais donc preferable de faire appel a cette fonction de cette maniere

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

my @tab_de_retour_de_DICE = DICE ($sequence);

voici ce que j'ai obtenu en corrigeant deux ou trois petites erreurs de ton script (avec un sequence test)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
SEQ:AAAAAAAAAAAATTTTTTTTTGGGGGGGGCCCCCCCGGGGGGGCCCCCCGGGGGATTTTTCGATCGGATTTTTTTTTTTTTCGGGGGGGGGGGGATCGATCGATCGTCTAGTCTCT
TEST:AAAAAAAAAAAAUUUUUUU
C 0      G 0     A 12    U 7
19
 
0%
TEST:AAAAAAAAAAAUUUUUUUU
C 0      G 0     A 11    U 8
19
 
0%
TEST:AAAAAAAAAAUUUUUUUUU
C 0      G 0     A 10    U 9
19
 
0%
TEST:AAAAAAAAAUUUUUUUUUG
C 0      G 1     A 9     U 9
19
 
5%
TEST:AAAAAAAAUUUUUUUUUGG
C 0      G 2     A 8     U 9
19

**fsapet** · 16/07/2004, 13h17

Envoyé par perlaud

sorry, je ne savais pas que je pouvais mettre use strict et use GetOption ensemble, c'ets super j'apprends des choses ( il me semblait que j'avais eu un message d'erreur la fis où je l'ai fait)

aucun pb pour mettre plusieurs use quelquechose; au debut de ton script
voici le header de mon test.pl dans lequel je teste les pb poses sur le forum (enfin pas tous non plus), c'est un bon moyen de progresser je pense

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
#!/bin/perl -w
 
use strict;
use diagnostics;
use warnings;
use Bio::Seq;
use Bio::SeqIO;
use Bio::Tools::SeqStats;
use DBI;
use Bio::SeqFeatureI;
use Bio::SeqFeature::Gene::TranscriptI;
use Getopt::Long;

**perlaud** · 16/07/2004, 15h11

merci pour le renseignement sur les "use", (en fait, je m'en doutais un peu car en c++, je le fais, mais je ne sais pas pourquoi une fois ca n'a pas marché ms je pense que c'était dû à d'autre erreurs!.)

par contre pour mon code, j'ai bien compris qu'il y avait un pbl car la fonction DICE retourne un tableau et la fonction %GC prend en argument une chaîne!! mais je ne sais comment faire, donc pour appeler ma fonction DICE j'ai changer contre ce que tu m'as dit

my @tab_de_retour_de_DICE = DICE ($sequence);

mais après, je coince.....

tu peux m'en dire + ?
merci

**fsapet** · 16/07/2004, 15h28

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
my @tab_de_retour_de_DICE ;
@tab_de_retour_de_DICE  = DICE ($sequence);
 
my $longueur=length($sequence);
$lim= $longueur-$LENGTH+1;
 
$boucle = 0;
while ($boucle< $lim) {
  #appel de la fonction
  ($tab[$boucle]) =  uc ($tab[$boucle]);
  $tab[$boucle] =~ tr/T/U/;
  if ($GC != 0) {
    ($score_GC) = pourcentage_GC($tab[$boucle]);
  }
  else {
    $score_GC = 0;
  }
  $boucle++;
}

sur la premiere ligne tu declares ton tableau tab_de_retour_de_DICE qui est vide
sur la seconde ligne, tu le rempli en fait, grace a la fonction DICE
et ensuite dans ta boucle while, pour chaque sequence de 19 bases que tu as precedement fabriques, tu calcules le pourcentage de GC.

ton script ne fonctionne pas, parce que dans ton exemple, le tableau, qui selon toi doit contenir ces sequences de 19 bases, est vide et dans ton while la fonction pourcentage_GC ne recoit rien

en fait je pense que tu peux remplacer ton while par un parcours du tableau comme ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
foreach my $cutted_sequence (@tab) {
  $cutted_sequence = uc ($cutted_sequence);
  $cutted_sequence =~ tr/T/U/;
if ($GC != 0) {
   ($score_GC) = pourcentage_GC($cutted_sequence);
  }
  else {
    $score_GC = 0;
  }
}

non ?
je ne vois pas pourquoi tu calcules une limite pour sortir de ta boucle avec ces deux lignes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
my $longueur=length($sequence);
my $lim= $longueur-$LENGTH+1;

en supprimant ces deux lignes et en remplacant ton while par le simple parcours du tableau, j'obtiens le meme resultat (enfin je pense, j'ai teste de facon rapide)

voila
tiens nous au courant

**perlaud** · 16/07/2004, 15h52

encore moi!

voici le code que j'essaie de corriger:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
#!/usr/bin/perl -w
use strict;
use Getopt::Long; 
 
my @sequence; my @table; 
my $GC; my $fichier; my $sequence; my $seq; my $longueur;
my $longueur_ARNm; my $boucle=0; my $lim;
# Declaration des variables utilisees pour le calcul des scores
my $score_GC; my $pourcentage_GC;
my $l; my $c; # pour l'affichages des résultats 
my @resultat;
my $lg_siRNA=13; # pour le calcul de la TM
my $LENGTH=19;my @res_dice;
 
#######################################################################################
# Fonction Getopt lit les options passées en ligne de commande (avec des raccourcis de commande)
Getopt::Long::GetOptions('G=s' => \$GC);
 
# Calcul du pourcentage de GC 
 
sub pourcentage_GC
 
	{	
my ($sequence)=@_;
my $total_pb;
my $pourcentage_GC;
my $A=0; my $G=0; my $C=0; my $U=0;
 
while ($sequence =~ /A/gi) { $A =$A+1; }
while ($sequence =~ /G/gi) { $G =$G+1; }
while ($sequence =~ /U/gi) { $U =$U+1; }
while ($sequence =~ /C/gi) { $C =$C+1; }
 
print "C $C\t G $G\t A $A\t U $U\n";
 
$total_pb = $C+$G+$A+$U;
print "$total_pb\n";
$pourcentage_GC=($C+ $G)/ $total_pb *100;
$pourcentage_GC = int ( $pourcentage_GC);
print "\n$pourcentage_GC%\n";
return ($pourcentage_GC);
	}
 
sub DICE
{
my ($sequence) =@_;
my $boucle=0; 
my $LENGTH=19;
my $longueur=length($sequence);
my $lim= $longueur-$LENGTH+1;
my @table;
 
	while ($boucle< $lim)
	{
	$table[$boucle]=substr ($sequence, $boucle, $LENGTH);
	print "$table[$boucle]\n";
	$boucle ++;	
	}
return @table;
}
 
print "Chemin du fichier a traiter : "; 
chomp ($fichier = <STDIN>); 
open (FIC , "$fichier") || die "Probleme d'ouverture: $!"; 
	while ($seq = <FIC>) 
	{chomp $seq; 
	$sequence=$sequence.$seq; } 
close FIC; 
@res_dice = DICE ($sequence);
 
foreach my $cutted_sequence (@table) 
{
$cutted_sequence = uc ($cutted_sequence);
$cutted_sequence =~tr/T/U/; 
if ($GC!=0) { ($score_GC) = pourcentage_GC($cutted_sequence); } 
else { $score_GC = 0; }
}

donc avec ce code je n'ai plus de message d'erreur! ouf! mais je n'ai pas l'affichage du % en GC.

**fsapet** · 16/07/2004, 15h58

aaaaaaaaaaaaaahhhhhhhhhhhhhhhh !!!

regarde bien ton code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

foreach my $cutted_sequence (@table)

que contient @table a ton avis ?
le resultat de la fonction DICE surement non ?

mais alors pourquoi avir fait

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

@res_dice = DICE ($sequence);

**perlaud** · 16/07/2004, 16h06

cooooooool!!!!!!!! ca amrche merci bcp!!!!! fsapet!!!!!

et c'est très sympas tes "jeu de piste"

à + ( tu vas encore entendre parlé de moi étant donné mon niveau!)

bon je te laisse, il faut que je "cogite" sur tout ce que tu as dit.

merci encore
perlaud

[bioinfo] fonction qui renvoie chaîne à autre fonction

Bioinformatique Perl

Discussions similaires

Partager

Partager