Bio/CodonUsage/Table.pm

filter: Statementstmt 26.4% 64 / 242 Branchbran 17.1% 12 / 70 Conditioncond 8.5% 4 / 47 MC/DCmcdc 0.0% 0 / 26 Subroutinesub 42.3% 11 / 26 Podpod 100% 15 / 15 totaltotal 24.8% 106 / 426 CC 71 SCAR 36.9
CC
71
Cov
22%
_init_from_aa
132.0
new
93.7
genetic_code
72.0
CRAP 40.1
« Bio/Seq/PrimedSeq.pm ↑ Summary Bio/Tools/Alignment/Consed.pm »
1 #
2 # BioPerl module for Bio::CodonUsage::Table
3 #
4 # Please direct questions and support issues to <bioperl-l@bioperl.org>
5 #
6 # Cared for by Richard Adams (richard.adams@ed.ac.uk)
7 #
8 # Copyright Richard Adams
9 #
10 # You may distribute this module under the same terms as perl itself
11  
12 # POD documentation - main docs before the code
13  
14 =head1 NAME
15  
16 Bio::CodonUsage::Table - for access to the Codon usage Database
17 at http://www.kazusa.or.jp/codon.
18  
19 =head1 SYNOPSIS
20  
21 use Bio::CodonUsage::Table;
22 use Bio::DB::CUTG;
23 use Bio::CodonUsage::IO;
24 use Bio::Tools::SeqStats;
25  
26 # Get a codon usage table from web database
27 my $cdtable = Bio::DB::CUTG->new(-sp => 'Mus musculus',
28 -gc => 1);
29  
30 # Or from local file
31 my $io = Bio::CodonUsage::IO->new(-file => "file");
32 my $cdtable = $io->next_data();
33  
34 # Or create your own from a Bio::PrimarySeq compliant object,
35 # $codonstats is a ref to a hash of codon name /count key-value pairs
36 my $codonstats = Bio::Tools::SeqStats->count_codons($Seq_objct);
37  
38 # '-data' must be specified, '-species' and 'genetic_code' are optional
39 my $CUT = Bio::CodonUsage::Table->new(-data => $codonstats,
40 -species => 'Hsapiens_kinase');
41  
42 print "leu frequency is ", $cdtable->aa_frequency('LEU'), "\n";
43 print "freq of ATG is ", $cdtable->codon_rel_frequency('ttc'), "\n";
44 print "abs freq of ATG is ", $cdtable->codon_abs_frequency('ATG'), "\n";
45 print "number of ATG codons is ", $cdtable->codon_count('ATG'), "\n";
46 print "GC content at position 1 is ", $cdtable->get_coding_gc('1'), "\n";
47 print "total CDSs for Mus musculus is ", $cdtable->cds_count(), "\n";
48  
49 =head1 DESCRIPTION
50  
51  
52 This class provides methods for accessing codon usage table data.
53  
54 All of the methods at present are simple look-ups of the table or are
55 derived from simple calculations from the table. Future methods could
56 include measuring the codon usage of a sequence , for example, or
57 provide methods for examining codon usage in alignments.
58  
59 =head1 SEE ALSO
60  
61 L<Bio::Tools::CodonTable>,
62 L<Bio::WebAgent>,
63 L<Bio::CodonUsage::IO>,
64 L<Bio::DB::CUTG>
65  
66 =head1 FEEDBACK
67  
68 =head2 Mailing Lists
69  
70  
71 User feedback is an integral part of the evolution of this and other
72 Bioperl modules. Send your comments and suggestions preferably to one
73 of the Bioperl mailing lists. Your participation is much appreciated.
74  
75 bioperl-l@bioperl.org - General discussion
76 http://bioperl.org/wiki/Mailing_lists - About the mailing lists
77  
78 =head2 Support
79  
80 Please direct usage questions or support issues to the mailing list:
81  
82 I<bioperl-l@bioperl.org>
83  
84 rather than to the module maintainer directly. Many experienced and
85 reponsive experts will be able look at the problem and quickly
86 address it. Please include a thorough description of the problem
87 with code and data examples if at all possible.
88  
89 =head2 Reporting Bugs
90  
91 Report bugs to the Bioperl bug tracking system to help us keep track
92 the bugs and their resolution. Bug reports can be submitted via the
93 web:
94  
95 https://github.com/bioperl/bioperl-live/issues
96  
97 =head1 AUTHORS
98  
99 Richard Adams, Richard.Adams@ed.ac.uk
100  
101 =head1 APPENDIX
102  
103 The rest of the documentation details each of the object
104 methods. Internal methods are usually preceded with a _
105  
106 =cut
107  
108  
109 # Let the code begin...
110  
111 package Bio::CodonUsage::Table;
112 3 $Bio::CodonUsage::Table::VERSION = '1.7.8';
113 3 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
114 3 ▶use vars qw(%STRICTAA @AA);
Subroutine BEGIN: called CC=1 SCAR=0.0
115 3 ▶use Bio::SeqUtils;
Subroutine BEGIN: called CC=1 SCAR=0.0
116 3 ▶use Bio::Tools::CodonTable;
Subroutine BEGIN: called CC=1 SCAR=0.0
117  
118 3 ▶use base qw(Bio::Root::Root);
Subroutine BEGIN: called CC=1 SCAR=0.0
119  
120 3 ▶BEGIN{
Subroutine BEGIN: called CC=1 SCAR=0.0
121 3 @AA = qw(A C D E F G H I K L M N P Q R S T V W Y *);
122 3 map {$STRICTAA{$_} = undef} @AA;
123 }
124  
125 =head2 new
126  
127 Title : new
128 Usage : my $cut = Bio::CodonUsage::Table->new(-data => $cut_hash_ref,
129 -species => 'H.sapiens_kinase'
130 -genetic_code =>1);
131 Returns : a reference to a new Bio::CodonUsage::Table object
132 Args : none or a reference to a hash of codon counts. This constructor is
133 designed to be compatible with the output of
134 Bio::Tools::SeqUtils::count_codons()
135 Species and genetic code parameters can be entered here or via the
136 species() and genetic_code() methods separately.
137  
138 =cut
139  
140 1 ▶sub new {
Subroutine new: called CC=11 SCAR=45.4
Pod documented
141 1 my ($class, @args) = @_;
142 1 my $self= $class->SUPER::new(@args);
143 1 ▶ if (@args) {
Branch: 1 branch
BranchTrueFalseTotal
if (@args) 0 1 1
144 0 $self->_rearrange([qw(DATA)], @args);
145 0 shift @args; # get rid of key
146 0 my $arg = shift @args;
147 0 ▶ $self->throw("need a hash reference, not a [" . ref($arg). "] reference") if ref($arg) ne 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
if ref $arg ne "HASH" 0 0 0
148 ### flags to detect argument type, can be either to start with ##
149 0 my $is_codon_hash = 1;
150 0 my $is_Aa_hash = 1;
151 0 for my $k (keys %$arg) {
152 ## convert to UC
153 0 $k =~ s/(\w+)/\U$1/;
154 0 ▶ if (!exists($STRICTAA{$k}) ){
Branch: 2 branches
BranchTrueFalseTotal
if (not exists $Bio::CodonUsage::Table::STRICTAA{$k}) { } 0 0 0
elsif ($k =~ /[^ATCGatcg]/) { } 0 0 0
155 0 $is_Aa_hash = 0;
156 }
157 elsif ($k =~ /[^ATCGatcg]/) {
158 0 $is_codon_hash = 0;
159 }
160 }
161 0 ▶ if (!$is_codon_hash && !$is_Aa_hash) {
Branch: 3 branches
BranchTrueFalseTotal
if (not $is_codon_hash || $is_Aa_hash) { } 0 0 0
elsif ($is_Aa_hash) { } 0 0 0
elsif ($is_codon_hash) { } 0 0 0
Condition0%0/3
$is_codon_hash || $is_Aa_hash
l!l&&r!l&&!r
000
MC/DC0%0/2
$is_codon_hash || $is_Aa_hash
$is_codon_hash $is_Aa_hash
Truth table0%0/3
A || B
A= $is_codon_hashB= $is_Aa_hash
ABresult
1X1
011
000
162 0 $self->throw(" invalid key values in CUT hash - must be unique aa or nucleotide identifiers");
163 }
164 elsif ($is_Aa_hash) {
165 0 $self->_init_from_aa($arg);
166 }
167 elsif($is_codon_hash) {
168 0 $self->_init_from_cod($arg);
169 }
170 0 ▶ while (@args) {
Branch: 1 branch
BranchTrueFalseTotal
if (@args) 0 0 0
171 0 my $key = shift @args;
172 0 $key =~ s/\-(\w+)/\L$1/;
173
174 0 $self->$key(shift @args);
175 }
176 }
177
178 1 return $self;
179 }
180  
181 =head2 all_aa_frequencies
182  
183 Title : all_aa_frequencies
184 Usage : my $freq = $cdtable->all_aa_frequencies();
185 Returns : a reference to a hash where each key is an amino acid
186 and each value is its frequency in all proteins in that
187 species.
188 Args : none
189  
190 =cut
191  
192 0 ▶sub all_aa_frequencies {
Subroutine all_aa_frequencies: not called CC=2 SCAR=17.9
Pod documented
193 0 my $self = shift;
194 0 my %aa_freqs =();
195 0 for my $aa (keys %STRICTAA) {
196 0 my $freq = $self->aa_frequency($aa);
197 0 $aa_freqs{$aa} = $freq;
198 }
199 0 return \%aa_freqs;
200 }
201  
202 =head2 codon_abs_frequency
203  
204 Title : codon_abs_frequency
205 Usage : my $freq = $cdtable->codon_abs_frequency('CTG');
206 Purpose : To return the frequency of that codon as a percentage
207 of all codons in the organism.
208 Returns : a percentage frequency
209 Args : a non-ambiguous codon string
210  
211 =cut
212  
213 0 ▶sub codon_abs_frequency {
Subroutine codon_abs_frequency: not called CC=2 SCAR=17.9
Pod documented
214 0 my ($self, $a) = @_;
215 0 my $cod = uc $a;
216 0 ▶ if ($self->_check_codon($cod)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_check_codon($cod)) { } 0 0 0
217 0 my $ctable = Bio::Tools::CodonTable->new;
218 0 $ctable->id($self->genetic_code() );
219 0 my $aa =$Bio::SeqUtils::THREECODE {$ctable->translate($cod)};
220  
221 0 return $self->{'_table'}{$aa}{$cod}{'per1000'}/10 ;
222 }
223 0 else {return 0;}
224 }
225  
226 =head2 codon_rel_frequency
227  
228 Title : codon_rel_frequency
229 Usage : my $freq = $cdtable->codon_rel_frequency('CTG');
230 Purpose : To return the frequency of that codon as a percentage
231 of codons coding for the same amino acid. E.g., ATG and TGG
232 would return 100 as those codons are unique.
233 Returns : a percentage frequency
234 Args : a non-ambiguous codon string
235  
236 =cut
237  
238  
239 0 ▶sub codon_rel_frequency {
Subroutine codon_rel_frequency: not called CC=2 SCAR=17.9
Pod documented
240 0 my ($self, $a) = @_;
241 0 my $cod = uc $a;
242 0 ▶ if ($self->_check_codon($cod)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_check_codon($cod)) { } 0 0 0
243 0 my $ctable = Bio::Tools::CodonTable->new;
244 0 $ctable->id($self->genetic_code () );
245 0 my $aa =$Bio::SeqUtils::THREECODE {$ctable->translate($cod)};
246 0 return $self->{'_table'}{$aa}{$cod}{'rel_freq'};
247 }
248 else {
249 0 return 0;
250 }
251 }
252  
253 =head2 probable_codons
254  
255 Title : probable_codons
256 Usage : my $prob_codons = $cd_table->probable_codons(10);
257 Purpose : to obtain a list of codons for the amino acid above a given
258 threshold % relative frequency
259 Returns : A reference to a hash where keys are 1 letter amino acid codes
260 and values are references to arrays of codons whose frequency
261 is above the threshold.
262 Arguments: a minimum threshold frequency
263  
264 =cut
265  
266 1 ▶sub probable_codons {
Subroutine probable_codons: called CC=8 SCAR=22.3
Pod documented
267 1 my ($self, $threshold) = @_;
268 1 ▶ if (!$threshold || $threshold < 0 || $threshold > 100) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $threshold or $threshold < 0 or $threshold > 100) 0 1 1
Condition33%2/6
not $threshold or $threshold < 0 or $threshold > 100
l!l&&r!l&&!r
001
not $threshold or $threshold < 0
l!l&&r!l&&!r
001
MC/DC0%0/3
not $threshold or $threshold < 0 or $threshold > 100
not $threshold $threshold < 0 $threshold > 100
Truth table25%1/4
not(A) or B or C
A= not $thresholdB= $threshold < 0C= $threshold > 100
ABCresult
1XX1
01X1
0011
0000
269 0 $self->throw(" I need a threshold percentage ");
270 }
271 1 my %return_hash;
272 1 for my $a(keys %STRICTAA) {
273 21 my @common_codons;
274 21 my $aa =$Bio::SeqUtils::THREECODE{$a};
275 21 for my $codon (keys %{ $self->{'_table'}{$aa}}) {
276 64 ▶ if ($self->{'_table'}{$aa}{$codon}{'rel_freq'} > $threshold/100){
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"_table"}{$aa}{$codon}{"rel_freq"} > $threshold / 100) 50 14 64
277 50 push @common_codons, $codon;
278 }
279 }
280 21 $return_hash{$a} = \@common_codons;
281 }
282 ## check to make sure that all codons are populated ##
283 1 ▶ if (grep{scalar @{$return_hash{$_}} == 0} keys %return_hash) {
Branch: 1 branch
BranchTrueFalseTotal
if (grep {scalar @{$return_hash{$_};} == 0;} keys %return_hash) 0 1 1
284 0 $self->warn("Threshold is too high, some amino acids do not" .
285 " have any codon above the threshold!");
286 }
287 1 return \%return_hash;
288 }
289
290  
291 =head2 most_common_codons
292  
293 Title : most_common_codons
294 Usage : my $common_codons = $cd_table->most_common_codons();
295 Purpose : To obtain the most common codon for a given amino acid
296 Returns : A reference to a hash where keys are 1 letter amino acid codes
297 and the values are the single most common codons for those amino acids
298 Arguments: None
299  
300 =cut
301  
302 1 ▶sub most_common_codons {
Subroutine most_common_codons: called CC=5 SCAR=16.3
Pod documented
303 1 my $self = shift;
304  
305 1 my %return_hash;
306  
307 1 for my $a ( keys %STRICTAA ) {
308  
309 21 my $common_codon = '';
310 21 my $rel_freq = 0;
311 21 my $aa = $Bio::SeqUtils::THREECODE{$a};
312  
313 21 ▶ if ( ! defined $self->{'_table'}{$aa} ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $self->{"_table"}{$aa}) 0 21 21
314 0 $self->warn("Amino acid $aa ($a) does not have any codons!");
315 0 next;
316 }
317  
318 21 for my $codon ( keys %{ $self->{'_table'}{$aa}} ) {
319 64 ▶ if ($self->{'_table'}{$aa}{$codon}{'rel_freq'} > $rel_freq ){
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"_table"}{$aa}{$codon}{"rel_freq"} > $rel_freq) 37 27 64
320 37 $common_codon = $codon;
321 37 $rel_freq = $self->{'_table'}{$aa}{$codon}{'rel_freq'};
322 }
323 }
324 21 $return_hash{$a} = $common_codon;
325 }
326
327 1 return \%return_hash;
328 }
329  
330 =head2 codon_count
331  
332 Title : codon_count
333 Usage : my $count = $cdtable->codon_count('CTG');
334 Purpose : To obtain the absolute number of the codons in the
335 organism.
336 Returns : an integer
337 Args : a non-ambiguous codon string
338  
339 =cut
340  
341 0 ▶sub codon_count {
Subroutine codon_count: not called CC=3 SCAR=24.8
Pod documented
342 0 my $self = shift;
343 0 ▶ if (@_) {
Branch: 1 branch
BranchTrueFalseTotal
if (@_) { } 0 0 0
344 0 my $a = shift;
345 0 my $cod = uc $a;
346 0 ▶ if ($self->_check_codon($cod)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_check_codon($cod)) { } 0 0 0
347 0 my $ctable = Bio::Tools::CodonTable->new;
348 0 $ctable->id($self->genetic_code());
349 0 my $aa =$Bio::SeqUtils::THREECODE {$ctable->translate($cod)};
350 0 return $self->{'_table'}{$aa}{$cod}{'abs_count'};
351 }
352 0 else {return 0;}
353 }
354 else {
355 0 $self->warn(" need to give a codon sequence as a parameter ");
356 0 return 0;
357 }
358
359 }
360  
361 =head2 get_coding_gc
362  
363 Title : get_coding_gc
364 Usage : my $count = $cdtable->get_coding_gc(1);
365 Purpose : To return the percentage GC composition for the organism at
366 codon positions 1,2 or 3, or an average for all coding sequence
367 ('all').
368 Returns : a number (%-age GC content) or 0 if these fields are undefined
369 Args : 1,2,3 or 'all'.
370  
371 =cut
372  
373 0 ▶sub get_coding_gc {
Subroutine get_coding_gc: not called CC=4 SCAR=30.0
Pod documented
374 0 my $self = shift;
375 0 ▶ if (! @_) {
Branch: 1 branch
BranchTrueFalseTotal
if (not @_) { } 0 0 0
376 0 $self->warn(" no parameters supplied must be a codon position (1,2,3) or 'all'");
377 0 return 0;
378 }
379 else{
380 0 my $n = shift;
381 ##return request if valid ##
382 0 ▶ if ( exists($self->{'_coding_gc'}{$n} ) ) {
Branch: 2 branches
BranchTrueFalseTotal
if (exists $self->{'_coding_gc'}{$n}) { } 0 0 0
elsif (exists $self->{'_coding_gc'}{'all'}) { } 0 0 0
383 0 return sprintf("%.2f", $self->{'_coding_gc'}{$n});
384 }
385 ##else return 'all' value if exists
386 elsif (exists($self->{'_coding_gc'}{'all'} )) {
387 0 $self->warn("coding gc doesn't have value for [$n], returning gc content for all CDSs");
388 0 return sprintf("%.2f", $self->{'_coding_gc'}{'all'});
389 }
390 ### else return 0,
391 else {
392 0 $self->warn("coding gc values aren't defined, returning 0");
393 0 return 0;
394 }
395  
396 }#end of outer else
397
398 }
399  
400 =head2 set_coding_gc
401  
402 Title : set_coding_gc
403 Usage : my $count = $cdtable->set_coding_gc(-1=>55.78);
404 Purpose : To set the percentage GC composition for the organism at
405 codon positions 1,2 or 3, or an average for all coding sequence
406 ('all').
407 Returns : void
408 Args : a hash where the key must be 1,2,3 or 'all' and the value the %age GC
409 at that codon position..
410  
411 =cut
412  
413 0 ▶sub set_coding_gc {
Subroutine set_coding_gc: not called CC=2 SCAR=17.9
Pod documented
414 0 my ($self, $key, $value) = @_;
415 0 my @allowed = qw(1 2 3 all);
416 0 $key =~ s/\-//;
417 0 ▶ if (!grep {$key eq $_} @allowed ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (grep {$key eq $_;} @allowed) 0 0 0
418 0 $self->warn ("invalid key! - must be one of [ ". (join " ", @allowed) . "]");
419 0 return;
420 }
421 0 $self->{'_coding_gc'}{$key} = $value;
422
423  
424 }
425  
426 =head2 species
427  
428 Title : species
429 Usage : my $sp = $cut->species();
430 Purpose : Get/setter for species name of codon table
431 Returns : Void or species name string
432 Args : None or species name string
433  
434 =cut
435  
436 1 ▶sub species {
Subroutine species: called CC=3 SCAR=11.4
Pod documented
437 1 my $self = shift;
438 1 ▶ if (@_ ){
Branch: 1 branch
BranchTrueFalseTotal
if (@_) 1 0 1
439 1 $self->{'_species'} = shift;
440 }
441 1 ▶ return $self->{'_species'} || "unknown";
Condition50%1/2
$self->{'_species'} || 'unknown'
l!l
10
MC/DC0%0/1
$self->{'_species'} || 'unknown'
$self->{'_species'}
Truth table50%1/2
A
A= $self->{'_species'}
Aresult
11
00
442 }
443  
444 =head2 genetic_code
445  
446 Title : genetic_code
447 Usage : my $sp = $cut->genetic_code();
448 Purpose : Get/setter for genetic_code name of codon table
449 Returns : Void or genetic_code id, 1 by default
450 Args : None or genetic_code id, 1 by default if invalid argument.
451  
452 =cut
453  
454 0 ▶sub genetic_code {
Subroutine genetic_code: not called CC=8 SCAR=42.8
Pod documented
455 0 my $self = shift;
456 0 ▶ if (@_ ){
Branch: 1 branch
BranchTrueFalseTotal
if (@_) 0 0 0
457 0 my $val = shift;
458 0 ▶ if ($val < 0 || $val >16 || $val =~ /[^\d]/
Branch: 1 branch
BranchTrueFalseTotal
if ($val < 0 or $val > 16 or $val =~ /[^\d]/ or $val == 7 or $val == 8) { } 0 0 0
Condition0%0/12
$val < 0 or $val > 16 or $val =~ /[^\d]/ or $val == 7 or $val == 8
l!l&&r!l&&!r
000
$val < 0 or $val > 16 or $val =~ /[^\d]/ or $val == 7
l!l&&r!l&&!r
000
$val < 0 or $val > 16 or $val =~ /[^\d]/
l!l&&r!l&&!r
000
$val < 0 or $val > 16
l!l&&r!l&&!r
000
MC/DC0%0/5
$val < 0 or $val > 16 or $val =~ /[^\d]/ or $val == 7 or $val == 8
$val < 0 $val > 16 $val =~ /[^\d]/ $val == 7 $val == 8
Truth table0%0/6
A or B or C or D or E
A= $val < 0B= $val > 16C= $val =~ /[^\d]/D= $val == 7E= $val == 8
ABCDEresult
1XXXX1
01XXX1
001XX1
0001X1
000011
000000
459 || $val ==7 || $val ==8) {
460 0 $self->warn ("invalid genetic code - must be 1-16 but not 7 or 8,setting to default [1]");
461 0 $self->{'_genetic_code'} = 1;
462 }
463 else {
464 0 $self->{'_genetic_code'} = shift;
465 }
466 }
467 0 ▶ return $self->{'_genetic_code'} || 1;
Condition0%0/2
$self->{'_genetic_code'} || 1
l!l
00
MC/DC0%0/1
$self->{'_genetic_code'} || 1
$self->{'_genetic_code'}
Truth table0%0/2
A
A= $self->{'_genetic_code'}
Aresult
11
00
468 }
469  
470 =head2 cds_count
471  
472 Title : cds_count
473 Usage : my $count = $cdtable->cds_count();
474 Purpose : To retrieve the total number of CDSs used to generate the Codon Table
475 for that organism.
476 Returns : an integer
477 Args : none (if retrieving the value) or an integer( if setting ).
478  
479 =cut
480  
481 1 ▶sub cds_count {
Subroutine cds_count: called CC=5 SCAR=18.1
Pod documented
482 1 my $self= shift;
483 1 ▶ if (@_) {
Branch: 1 branch
BranchTrueFalseTotal
if (@_) 1 0 1
484 1 my $val = shift;
485 1 ▶ if ($val < 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($val < 0) { } 0 1 1
486 0 $self->warn("can't have negative count initializing to 1");
487 0 $self->{'_cds_count'} = 0.00;
488 }
489 else{
490 1 $self->{'_cds_count'} = $val;
491 }
492 }
493 $self->warn("cds_count value is undefined, returning 0")
494 1 ▶ if !exists($self->{'_cds_count'});
Branch: 1 branch
BranchTrueFalseTotal
unless exists $self->{"_cds_count"} 0 1 1
495  
496 1 ▶ return $self->{'_cds_count'} || 0.00;
Condition50%1/2
$self->{'_cds_count'} || 0.0
l!l
10
MC/DC0%0/1
$self->{'_cds_count'} || 0.0
$self->{'_cds_count'}
Truth table50%1/2
A
A= $self->{'_cds_count'}
Aresult
11
00
497 }
498  
499 =head2 aa_frequency
500  
501 Title : aa_frequency
502 Usage : my $freq = $cdtable->aa_frequency('Leu');
503 Purpose : To retrieve the frequency of an amino acid in the organism
504 Returns : a percentage
505 Args : a 1 letter or 3 letter string representing the amino acid
506  
507 =cut
508  
509
510  
511 0 ▶sub aa_frequency {
Subroutine aa_frequency: not called CC=4 SCAR=30.0
Pod documented
512 0 my ($self, $a) = @_;
513 ## process args ##
514  
515 ## deal with cases ##
516 0 my $aa = lc $a;
517 0 $aa =~ s/^(\w)/\U$1/;
518 0 ▶ if (!exists($STRICTAA{$aa}) && !exists($Bio::SeqUtils::ONECODE{$aa}) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $Bio::CodonUsage::Table::STRICTAA{$aa} or exists $Bio::SeqUtils::ONECODE{$aa}) 0 0 0
Condition0%0/3
exists $Bio::CodonUsage::Table::STRICTAA{$aa} or exists $Bio::SeqUtils::ONECODE{$aa}
l!l&&r!l&&!r
000
MC/DC0%0/2
exists $Bio::CodonUsage::Table::STRICTAA{$aa} or exists $Bio::SeqUtils::ONECODE{$aa}
exists $Bio::CodonUsage::Table::STRICTAA{$aa} exists $Bio::SeqUtils::ONECODE{$aa}
Truth table0%0/3
A or B
A= exists $Bio::CodonUsage::Table::STRICTAA{$aa}B= exists $Bio::SeqUtils::ONECODE{$aa}
ABresult
1X1
011
000
519 0 $self->warn("Invalid amino acid! must be a unique 1 letter or 3 letter identifier");
520 0 return;
521 }
522 #translate to 3 letter code for Ctable #
523 0 ▶ my $aa3 = $Bio::SeqUtils::THREECODE{$aa} || $aa;
Condition0%0/3
$Bio::SeqUtils::THREECODE{$aa} || $aa
l!l&&r!l&&!r
000
MC/DC0%0/2
$Bio::SeqUtils::THREECODE{$aa} || $aa
$Bio::SeqUtils::THREECODE{$aa} $aa
Truth table0%0/3
A || B
A= $Bio::SeqUtils::THREECODE{$aa}B= $aa
ABresult
1X1
011
000
524  
525 ## return % of all amino acids in organism ##
526 0 my $freq = 0;
527 0 map {$freq += $self->{'_table'}{$aa3}{$_}{'per1000'} } keys %{$self->{'_table'}{$aa3}};
528 0 return sprintf("%.2f", $freq/10);
529 }
530  
531 =head2 common_codon
532  
533 Title : common_codon
534 Usage : my $freq = $cdtable->common_codon('Leu');
535 Purpose : To retrieve the frequency of the most common codon of that aa
536 Returns : a percentage
537 Args : a 1 letter or 3 letter string representing the amino acid
538  
539 =cut
540  
541 0 ▶sub common_codon{
Subroutine common_codon: not called CC=5 SCAR=34.0
Pod documented
542  
543 0 my ($self, $a) = @_;
544 0 my $aa = lc $a;
545 0 $aa =~ s/^(\w)/\U$1/;
546  
547 0 ▶ if ($self->_check_aa($aa)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_check_aa($aa)) { } 0 0 0
548 0 my $aa3 = $Bio::SeqUtils::THREECODE{$aa} ;
549 0 ▶ $aa3 ||= $aa;
Condition0%0/3
$aa3 ||= $aa
l!l&&r!l&&!r
000
MC/DC0%0/2
$aa3 ||= $aa
$aa3 $aa
Truth table0%0/3
A ||= B
A= $aa3B= $aa
ABresult
1X1
011
000
550 0 my $max = 0;
551 0 for my $cod (keys %{$self->{'_table'}{$aa3}}) {
552 $max = ($self->{'_table'}{$aa3}{$cod}{'rel_freq'} > $max) ?
553 0 ▶ $self->{'_table'}{$aa3}{$cod}{'rel_freq'}:$max;
Branch: 1 branch
BranchTrueFalseTotal
$self->{'_table'}{$aa3}{$cod}{'rel_freq'} > $max ? : 0 0 0
554 }
555 0 return $max;
556 0 }else {return 0;}
557 }
558  
559 =head2 rare_codon
560  
561 Title : rare_codon
562 Usage : my $freq = $cdtable->rare_codon('Leu');
563 Purpose : To retrieve the frequency of the least common codon of that aa
564 Returns : a percentage
565 Args : a 1 letter or 3 letter string representing the amino acid
566  
567 =cut
568  
569 0 ▶sub rare_codon {
Subroutine rare_codon: not called CC=5 SCAR=34.0
Pod documented
570 0 my ($self, $a) = @_;
571 0 my $aa = lc $a;
572 0 $aa =~ s/^(\w)/\U$1/;
573 0 ▶ if ($self->_check_aa($aa)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_check_aa($aa)) { } 0 0 0
574 0 my $aa3 = $Bio::SeqUtils::THREECODE{$aa};
575 0 ▶ $aa3 ||= $aa;
Condition0%0/3
$aa3 ||= $aa
l!l&&r!l&&!r
000
MC/DC0%0/2
$aa3 ||= $aa
$aa3 $aa
Truth table0%0/3
A ||= B
A= $aa3B= $aa
ABresult
1X1
011
000
576 0 my $min = 1;
577 0 for my $cod (keys %{$self->{'_table'}{$aa3}}) {
578 $min = ($self->{'_table'}{$aa3}{$cod}{'rel_freq'} < $min) ?
579 0 ▶ $self->{'_table'}{$aa3}{$cod}{'rel_freq'}:$min;
Branch: 1 branch
BranchTrueFalseTotal
$self->{'_table'}{$aa3}{$cod}{'rel_freq'} < $min ? : 0 0 0
580 }
581 0 return $min;
582 0 }else {return 0;}
583  
584  
585 }
586  
587  
588 ## internal sub that checks a codon is correct format
589 0 ▶sub _check_aa {
Subroutine _check_aa: not called CC=3 SCAR=24.8
590 0 my ($self, $aa ) = @_;
591 0 ▶ if (!exists($STRICTAA{$aa}) && !exists($Bio::SeqUtils::ONECODE{$aa}) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (not exists $Bio::CodonUsage::Table::STRICTAA{$aa} || exists $Bio::SeqUtils::ONECODE{$aa}) { } 0 0 0
Condition0%0/3
exists $Bio::CodonUsage::Table::STRICTAA{$aa} || exists $Bio::SeqUtils::ONECODE{$aa}
l!l&&r!l&&!r
000
MC/DC0%0/2
exists $Bio::CodonUsage::Table::STRICTAA{$aa} || exists $Bio::SeqUtils::ONECODE{$aa}
exists $Bio::CodonUsage::Table::STRICTAA{$aa} exists $Bio::SeqUtils::ONECODE{$aa}
Truth table0%0/3
A || B
A= exists $Bio::CodonUsage::Table::STRICTAA{$aa}B= exists $Bio::SeqUtils::ONECODE{$aa}
ABresult
1X1
011
000
592 0 $self->warn("Invalid amino acid! must be a unique 1 letter or 3 letter identifier");
593 0 return 0;
594 0 }else {return 1;}
595 }
596  
597
598  
599  
600 0 ▶sub _check_codon {
Subroutine _check_codon: not called CC=3 SCAR=24.8
601 0 my ($self, $cod) = @_;
602 0 ▶ if ($cod =~ /[^ATCG]/ || $cod !~ /\w\w\w/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($cod =~ /[^ATCG]/ or not $cod =~ /\w\w\w/) { } 0 0 0
Condition0%0/3
$cod =~ /[^ATCG]/ or not $cod =~ /\w\w\w/
l!l&&r!l&&!r
000
MC/DC0%0/2
$cod =~ /[^ATCG]/ or not $cod =~ /\w\w\w/
$cod =~ /[^ATCG]/ not $cod =~ /\w\w\w/
Truth table0%0/3
A or not(B)
A= $cod =~ /[^ATCG]/B= not $cod =~ /\w\w\w/
ABresult
1X1
011
000
603 0 $self->warn(" impossible codon - must be 3 letters and just containing ATCG");
604 0 return 0;
605 }
606 0 else {return 1;}
607 }
608 0 ▶sub _init_from_cod {
Subroutine _init_from_cod: not called CC=2 SCAR=17.9
609  
610 ## make hash based on aa and then send to _init_from_aa
611 0 my ($self, $ref) = @_;
612 0 my $ct = Bio::Tools::CodonTable->new();
613 0 my %aa_hash;
614 0 for my $codon(keys %$ref ) {
615 0 my $aa = $ct->translate($codon);
616 0 $aa_hash{$aa}{$codon} = $ref->{$codon};
617 }
618 0 $self->_init_from_aa(\%aa_hash);
619 }
620  
621  
622 0 ▶sub _init_from_aa {
Subroutine _init_from_aa: not called CC=11 SCAR=48.8
623 0 my ($self, $ref) = @_;
624 ## abs counts and count codons
625 0 my $total_codons = 0;
626 0 my %threeletter;
627 0 map{$threeletter{$Bio::SeqUtils::THREECODE{$_}} = $ref->{$_} } keys %$ref;
628 0 $ref = \%threeletter;
629 0 for my $aa (keys %$ref) {
630 0 for my $cod(keys %{$ref->{$aa}} ) {
631 0 $self->{'_table'}{$aa}{$cod}{'abs_count'} = $ref->{$aa}{$cod};
632 0 $total_codons += $ref->{$aa}{$cod};
633 }
634 }
635
636 ## now calculate abs codon frequencies
637 0 for my $aa (keys %$ref) {
638 0 for my $cod(keys %{$ref->{$aa}} ) {
639 $self->{'_table'}{$aa}{$cod}{'per1000'} =
640 0 sprintf("%.2f",$ref->{$aa}{$cod} /$total_codons * 1000) ;
641 }
642 }
643 ## now calculate rel codon_frequencies
644 0 for my $aa (keys %$ref) {
645 0 my $aa_freq = 0;
646 0 map{$aa_freq += $ref->{$aa}{$_} }
647 0 keys %{$ref->{$aa}};
648 0 for my $cod(keys %{$ref->{$aa}} ) {
649 $self->{'_table'}{$aa}{$cod}{'rel_freq'}=
650 0 sprintf("%.2f",$ref->{$aa}{$cod}/ $aa_freq );
651 }
652
653 }
654  
655 ## now calculate gc fields
656 0 my %GC;
657 0 for my $aa (keys %$ref) {
658 0 for my $cod(keys %{$ref->{$aa}} ) {
659 0 for my $index (qw(1 2 3) ) {
660 0 ▶ if (substr ($cod, $index -1, 1) =~ /g|c/oi) {
Branch: 1 branch
BranchTrueFalseTotal
if (substr($cod, $index - 1, 1) =~ /g|c/io) 0 0 0
661 0 $GC{$index} += $ref->{$aa}{$cod};
662 }
663 }
664 }
665 }
666 0 my $tot = 0;
667 0 map{$tot += $GC{$_}} qw(1 2 3);
668 0 $self->set_coding_gc('all', $tot/(3 *$total_codons) * 100);
669 0 map{$self->set_coding_gc($_,$GC{$_}/$total_codons * 100)} qw(1 2 3);
670
671 ##
672 0 return $self;
673 }
674  
675 0 ▶sub _gb_db {
Subroutine _gb_db: not called CC=2 SCAR=17.9
676 0 my $self = shift;
677 0 ▶ return $self->{'_gd_db'} || "unknown";
Condition0%0/2
$self->{'_gd_db'} || 'unknown'
l!l
00
MC/DC0%0/1
$self->{'_gd_db'} || 'unknown'
$self->{'_gd_db'}
Truth table0%0/2
A
A= $self->{'_gd_db'}
Aresult
11
00
678 }
679  
680 3 1;
« Bio/Seq/PrimedSeq.pm ↑ Summary Bio/Tools/Alignment/Consed.pm »