view release on metacpan or  search on metacpan

lib/Bigtop/Backend/Model.pm  view on Meta::CPAN

Inside the table, you can include a foreign_display statement.  The
value must be a quoted string like this:

    foreign_display `%last_name, %first_name`;

Any percent and the Perl identifier after it will be replaced with the
current row's values for those columns.  This is useful when a model
needs to deliver a user meaningful value for the current row.

=item model_base_class

 view release on metacpan or  search on metacpan

lib/Bio/AutomatedAnnotation/SpreadsheetOfGeneOccurances.pm  view on Meta::CPAN

sub _totals {
    my ($self) = @_;
    my $footer = ['% Total'];

    for my $gene_name ( @{ $self->gene_occurances->sorted_all_gene_names } ) {
        my $percentage_total_for_gene = ( $self->gene_occurances->all_gene_names->{$gene_name} ) / $self->gene_occurances->number_of_files;
        push( @{$footer}, $percentage_total_for_gene );
    }
    return $footer;
}

sub create_spreadsheet {

 view release on metacpan or  search on metacpan

lib/Bio/BPWrapper/AlnManipulations.pm  view on Meta::CPAN

	    next if $mA eq '-' || $mB eq '-'; 
	    $ct_valid++;
	    $ct_diff++ unless $mA eq $mB;
#	    next if $match_symbols[$i] eq '*'; 
	}
	my $pairdiff = $pair->percentage_identity();
	print join "\t", ($refId, $idB, $ct_diff, $ct_valid, $pair->length());
	printf "\t%.4f\t%.4f\n", $pairdiff, 1-$pairdiff/100;
    }
    exit;
}

lib/Bio/BPWrapper/AlnManipulations.pm  view on Meta::CPAN

		next if $mA eq '-' || $mB eq '-';
		$ct_valid++;
		$ct_diff++ unless $mA eq $mB;
	    }
#	    while ($mask =~ /[^\0]/g) { $ct_diff++ }
	    my $pairdiff = $pair->percentage_identity();
	    print join "\t", ($idA, $idB, $ct_valid, $num_var, $ct_diff, $gap_included_diff, $pair->length());
	    printf "\t%.4f\t%.4f\t%.4f\t%.4f\n", $pairdiff, 1-$pairdiff/100, $ct_diff/$ct_valid, $gap_included_diff/$num_var;
	}
    }
    exit;

lib/Bio/BPWrapper/AlnManipulations.pm  view on Meta::CPAN

    exit;
}

=head2 print_avp_id

Print the average percent identity of an alignment.

Wraps
L<Bio::SimpleAlign-E<gt>average_percentage_identity()|https://metacpan.org/pod/Bio::SimpleAlign#average_percentage_identity>.


=cut

sub print_avp_id {
    printf "%.4f\n", $aln->average_percentage_identity();
    exit
}

=head2 boostrap()

lib/Bio/BPWrapper/AlnManipulations.pm  view on Meta::CPAN

sub avg_id_by_win {
    my $window_sz = $opts{"window"};
    for my $i (1 .. ($aln->length() - $window_sz + 1)) {
        my $slice = $aln->slice($i, $i + $window_sz - 1);
        my $pi = (100 - $slice->average_percentage_identity()) / 100;
        printf "%d\t%d\t%.4f\n", $i, $i + $window_sz - 1, $pi
    }
    exit
}

lib/Bio/BPWrapper/AlnManipulations.pm  view on Meta::CPAN

    }
    exit
}

sub get_consensus {
    my $percent_threshold = $opts{"consensus"};
    my $consense = Bio::LocatableSeq->new(
        -seq   => $aln->consensus_string($percent_threshold),
        -id    => "Consensus_$percent_threshold",
        -start => 1,
        -end   => $aln->length()
   );
    $aln->add_seq($consense)
}

lib/Bio/BPWrapper/AlnManipulations.pm  view on Meta::CPAN

=item *
Document your method in pod using C<=head2>. For example:

    =head2 print_avpid

    Print the average percent identity of an alignment.

    Wraps
    L<Bio::SimpleAlign-E<gt>average_percentage_identity()|https://metacpan.org/pod/Bio::SimpleAlign#average_percentage_identity>.

    =cut

See L<C<print_avpid()>|/print_avpid> for how this gets rendered.

 view release on metacpan or  search on metacpan

bin/BS_PCRTagger.pl  view on Meta::CPAN

  die "\n ERROR: The amplicon length parameters do not parse.\n\n";
}

if ($p{MINPERDIFF} > $MAXMINPERDIFF || $p{MINPERDIFF} <= $MINMINPERDIFF )
{
  die "\n ERROR: The minimum percent difference does not parse.\n\n";
}

if ($p{ITERATE} ne 'genome' && $p{ITERATE} ne 'chromosome')
{
  die "BSERROR: Argument to iterate must be 'genome' or 'chromosome'.\n";

bin/BS_PCRTagger.pl  view on Meta::CPAN

   repository). Pairs of tags are selected in such a way that they will not
   amplify any other genomic sequence under 1000 bases long. Each synthetic
   counterpart to a wild type tag is recoded with GeneDesign's "most different"
   algorithm to guarantee maximum nucleotide sequence difference while
   maintaining identical protein sequence and, hopefully, minimizing any effect
   on gene expression. The synthetic tags are all at least I<MINPERDIFF> percent
   recoded from the wild type tags. Each tag is positioned in such a way that
   the first and last nucleotides correspond to the wobble of a codon that can
   be edited to change its wobble without changing its amino acid.  This usually
   automatically excludes methionine or tryptophan, but it can exclude others
   when a I<MINRSCUVAL> filter is in place. The wobble restriction ensures that

bin/BS_PCRTagger.pl  view on Meta::CPAN

   one amplicon chosen per kilobase of ORF. Each amplicon is between
   I<MINAMPLEN> and I<MAXAMPLEN> base pairs long, ensuring that they will all
   fall within an easily identifiable range on an agarose gel. No amplicon will
   be chosen within the first I<FIVEPRIMESTART> base pairs of an ORF to avoid
   disrupting unknown regulatory features. Amplicons are forbidden from
   overlapping each other by more than I<MAXAMPOLAP> percent.

=head1 ARGUMENTS

Required arguments:

bin/BS_PCRTagger.pl  view on Meta::CPAN

                 plus 1
  --MAXTAGLEN  : (default 28) Maximum length for tags. Must be a multiple of 3,
                 plus 1
  --MINAMPLEN  : (default 200) Minimum span for a pair of tags
  --MAXAMPLEN  : (default 500) Maximum span for a pair of tags
  --MAXAMPOLAP : (default 25) Maximum percentage of overlap allowed between
                 different tag pairs
  --MINORFLEN  : (default 501) Minimum size of gene for tagging eligibility
  --FIVEPRIMESTART : (default 101) The first base in a gene eligible for a tag
  --MINRSCUVAL : (default 0.06) The minimum RSCU value for any replacement codon
                 in a tag

 view release on metacpan or  search on metacpan

lib/Bio/Community.pm  view on Meta::CPAN

}


=head2 get_rel_ab

 Function: Determine the relative abundance (in percent) of a member in the
           community.
 Usage   : my $rel_ab = $community->get_rel_ab($member);
 Args    : a Bio::Community::Member object
 Returns : an integer between 0 and 100 for the relative abundance of this member

 view release on metacpan or  search on metacpan

LICENSE  view on Meta::CPAN

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

 view release on metacpan or  search on metacpan

lib/Bio/DB/Das/Chado.pm  view on Meta::CPAN

    $name =~ s/\*(?=\s)/:\*/g;      # convert trailing * (word end) into :*

  }
  else {
    $name =~ s/_/\\_/g;  # escape underscores in name
    $name =~ s/\%/\\%/g; # ditto for percent signs

    $name =~ s/\*/%/g;
  }

  return $name;

 view release on metacpan or  search on metacpan

lib/Bio/DB/GFF.pm  view on Meta::CPAN

score

For annotations that are associated with a numeric score (for example,
a sequence similarity), this field describes the score.  The score
units are completely unspecified, but for sequence similarities, it is
typically percent identity.  Annotations that don't have a score can
use "."

=item 7.

strand

 view release on metacpan or  search on metacpan

LICENSE  view on Meta::CPAN

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

 view release on metacpan or  search on metacpan

t/transfac_pro.t  view on Meta::CPAN

                my $diff = abs(abs($check[$i]) - abs($A[$i]));
                $var += $diff;
                $max = $diff if ($diff > $max);
            }
            my $avg = $var / @check;
            cmp_ok $avg, '<', 0.01; # Loss of data under 1 percent
            
            # SiteMatrixI methods
            is $matrix->id, 'V$E47_01';
            is $matrix->accession_number, $matrix_id;
            is $matrix->consensus, 'ATGCATGCATGC';

 view release on metacpan or  search on metacpan

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

=head2 Analysis results per sequencing run

These functions take arguments in the form of a hash. These usually
consist of a study accession, or one or more run accessions, plus a value for
"minimum_mapped_reads". This value represents the minimum percentage of mapped
reads to allow for each run in the results. Only information for runs with a
percentage of mapped reads greater than or equal to this value will be
returned. To get all available information, set "minimum_mapped_reads" to zero.

Analysis information for each run is returned in an anonymous hash. Some
functions return anonymous arrays with one anonymous hash per run found. See
below for examples and more information about the results.

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

=item B<get_expression_by_organism_genesymbol>

Accesses the API's C<getExpression> endpoint. Provide arguments as a hash,
passing an organism name and a gene symbol, as well as a value for the minimum
percentage of mapped reads to allow:

 my $geneExpressionInfo = $rnaseqAPI->get_expression(
    minimum_mapped_reads => 0,
    organism    => "oryza_sativa",
    gene_symbol => "BURP7"

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

=item B<get_expression_by_gene_id>

Accesses the API's C<getExpression> endpoint, but instead of querying by
organism and gene symbol (see L</get_expression_by_organism_genesymbol>), this
function queries by gene identifier. Also expects a value for the minimum
percentage of mapped reads to allow.

 my $geneExpressionInfo = $rnaseqAPI->get_expression(
    gene_identifer  => "ENSG00000172023",
    minimum_mapped_reads => 0
 );

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

    my $userAgent = $self->get_user_agent;

    # Start building the query URL.
    my $url = $self->get_api_base . "/json/";
    
    # If we're passed a minimum percentage of mapped reads, add this to the URL
    # next.
    if( defined( $args->{ "minimum_mapped_reads" } ) ) {

        $url .= $args->{ "minimum_mapped_reads" } . "/";
    }

 view release on metacpan or  search on metacpan

lib/Bio/EnsEMBL/BaseAlignFeature.pm  view on Meta::CPAN

         -HSEQNAME   => $self->{'hseqname'},
         -HSTART     => $hstart,
         -HEND       => $hend,
         -HSTRAND    => $strand2,
         -SCORE      => $self->{'score'},
         -PERCENT_ID => $self->{'percent_id'},
         -ANALYSIS   => $self->{'analysis'},
         -P_VALUE    => $self->{'p_value'},
         -EXTERNAL_DB_ID => $self->{'external_db_id'},
         -HCOVERAGE   => $self->{'hcoverage'},
         -GROUP_ID    => $self->{'group_id'},

lib/Bio/EnsEMBL/BaseAlignFeature.pm  view on Meta::CPAN

  my $slice       = $f[0]->slice();
  my $hslice       = $f[0]->hslice();
  my $name        = $slice ? $slice->name() : undef;
  my $hname       = $f[0]->hseqname;
  my $score       = $f[0]->score;
  my $percent     = $f[0]->percent_id;
  my $analysis    = $f[0]->analysis;
  my $pvalue      = $f[0]->p_value();
  my $external_db_id = $f[0]->external_db_id;
  my $hcoverage   = $f[0]->hcoverage;
  my $group_id    = $f[0]->group_id;

lib/Bio/EnsEMBL/BaseAlignFeature.pm  view on Meta::CPAN

    }
    if ( defined($score) && $score ne $f->score) {
      throw("Inconsisent scores in feature array [$score - " .
            $f->score . "]");
    }
    if (defined($f->percent_id) && $percent ne $f->percent_id) {
      throw("Inconsistent pids in feature array [$percent - " .
            $f->percent_id . "]");
    }
    if(defined($pvalue) && $pvalue != $f->p_value()) {
      throw("Inconsistant p_values in feature arraw [$pvalue " .
            $f->p_value() . "]");
    }

lib/Bio/EnsEMBL/BaseAlignFeature.pm  view on Meta::CPAN

  $self->{'start'}      = $f1start;
  $self->{'end'}        = $f1end;
  $self->{'seqname'}    = $seqname;
  $self->{'strand'}     = $strand;
  $self->{'score'}      = $score;
  $self->{'percent_id'} = $percent;
  $self->{'analysis'}   = $analysis;
  $self->{'slice'}      = $slice;
  $self->{'hslice'}     = $hslice;
  $self->{'hstart'}     = $f2start;
  $self->{'hend'}       = $f2end;

 view release on metacpan or  search on metacpan

lib/Bio/FastParsers/Blast/Table.pm  view on Meta::CPAN

## use critic

my @attrs = qw(
    query_id hit_id
    percent_identity hsp_length mismatches gaps
    query_from  query_to
      hit_from    hit_to
    evalue bit_score
    query_strand
      hit_strand

 view release on metacpan or  search on metacpan

lib/Bio/FdrFet.pm  view on Meta::CPAN



=item C<new([$fdrcutoff])>

Creates a new Bio::FdrFet object. The optional parameter is the False
Discovery Rate cutoff in units of percent. See the C<fdr_cutoff>
method below for more details.

=cut

sub new {

lib/Bio/FdrFet.pm  view on Meta::CPAN

 ODDS      Odds ratio. 
 Q         Number of genes in the pathway passing the FDR cutoff
 M         Number of genes overall passing the FDR cutoff
 N         Number of genes in the system minus C<M> above.
 K         Number of genes in the pathway.
 FDR       FDR cutoff in percent giving the best pvalue.
 LOCI      Reference to an array of gene names in the pathway
           that satisfy FDR cutoff.

If C<$all_flag> is specified and has the value, "all", then this
returns an array of values for all the attempted FDR cutoffs, except

 view release on metacpan or  search on metacpan

GMOD/Admin/Update.pm  view on Meta::CPAN

  my ($mount_point, $available_space);
  my $counter;
  while (<IN>) {
    next unless /^\//;
    my ($filesystem, $blocks, $used, $available, $use_percent, $mounted_on) = split(/\s+/);
    $mount_point = $mounted_on;
    $available_space = sprintf("%.2f", $available/1048576);
    $counter++;
  }

 view release on metacpan or  search on metacpan

lib/Bio/GeneDesign.pm  view on Meta::CPAN

object.

the count function counts the bases in a DNA sequence and returns a hash
reference where each base (including the ambiguous bases) are keys and the
values are the number of times they appear in the sequence. There are also the
special values GCp and ATp for GC and AT percentage.

=cut

sub count
{

lib/Bio/GeneDesign.pm  view on Meta::CPAN

=head2 GC_windows

takes a nucleotide sequence, a window size, and minimum and maximum values.
returns lists of real coordinates of subsequences that violate mimimum or
maximum GC percentages.

Values are returned inside an array reference such that the first value is an
array ref of minimum violators (as array refs of left/right coordinates), and
the second value is an array ref of maximum violators.

lib/Bio/GeneDesign.pm  view on Meta::CPAN

  my ($self, @args) = @_;

  my ($rlen, $rgc, $rstop)
    = $self->_rearrange([qw(
        length
        gc_percentage
        no_stops)], @args);

  $self->throw("no codon table has been defined")
    if ($rstop && ! $self->{codontable});

  $rgc = $rgc || 50;
  $self->throw("gc_percentage must be between 0 and 100")
    if ($rgc && ($rgc < 0 || $rgc > 100));

  if (! $rlen || $rlen < 1)
  {
    return q{};

 view release on metacpan or  search on metacpan

lib/Bio/Graphics/Glyph/merged_alignment.pm  view on Meta::CPAN

=head2 SAMPLE CONFIGURATION

Sample gbrowse configuration stanzas for an alignment feature
using this glyph.  The scores are assumed to be expressed 
as percent identity (0-100).

 # base configuration
 [BLASTZ]
 feature      = blastz_alignment
 glyph        = merged_alignment

 view release on metacpan or  search on metacpan

lib/Bio/Grep/Backend/Vmatch.pm  view on Meta::CPAN

                end              => $upstream + $fields[$COL_LENGTH],
                alignment        => Bio::SimpleAlign->new(),
                sequence_id      => $internal_seq_id,
                remark           => q{},
                evalue           => $fields[$COL_EVALUE],
                percent_identity => $fields[$COL_IDENTITY],
                query            => Bio::Seq->new(
                    -id   => $query->id,
                    -desc => $query->desc . $rct,
                    -seq  => $rcs,
                ),

 view release on metacpan or  search on metacpan

bin/distribution  view on Meta::CPAN

		$barWidth->[$i] = log($count) / $maxLog;
	} else {
		$barWidth->[$i] = $count / $maxVal;
	}

	# determine the percent of key frequency
	my $percentile = $count / $totalValues * 100;

	# graph axis labels, really
	$ctText->[$i] = sprintf ("%d", $count);
	$pctText->[$i] = $count > 0 ? sprintf ("(%3.02f%%)", $percentile) : '';
	$preBarLen = length ($ctText->[$i]) + length ($pctText->[$i]);

	# determine the longest key name and longest count/percent text for
	# aligning the output
	if ($preBarLen > $maxPreBarLen) { $maxPreBarLen = $preBarLen; }
	if (length ($sortedKeys[$i]) > $maxKeyLen) { $maxKeyLen = length ($sortedKeys[$i]); }
}

bin/distribution  view on Meta::CPAN

}

# the arrays, hashes, variables must be all-correct for this to
# work, TODO: list out which ones they are, convert to functional
# keyText->[]  - list of the keys
# pctText->[]  - list of the percents
# ctText->[]   - list of the counts
# barWidth->[] - list of the widths of the bars
sub outputGraph {
	# print a header with alignment from key names
	print STDERR "min";

bin/distribution  view on Meta::CPAN

	print "        num      ^\\d+\$        - tokens/lines must be entirely numeric\n";
	print "  --numonly[=N]  input is numerics, simply graph values without labels\n";
	print "        abs      input is absolute values (default)\n";
	print "        mon      input monotonically-increasing, graph differences (of 2nd and later values)\n";
	print "  --palette=P    comma-separated list of ANSI colour values for portions of the output\n";
	print "                 in this order: regular, key, count, percent, graph. implies --color.\n";
	print "  --rcfile=F     use this rcfile instead of \$HOME/.distributionrc - must be first argument!\n";
	print "  --size=S       size of histogram, can abbreviate to single character, overridden by --width/--height\n";
	print "        small    40x10\n";
	print "        medium   80x20\n";
	print "        large    120x30\n";

 view release on metacpan or  search on metacpan

lib/Bio/Homology/InterologWalk.pm  view on Meta::CPAN

     
          #lastly I store those new ids never seen in the starting dataset
          $new_id_set{$idOUT} = 1 unless(exists($start_data_set{$idOUT})); 
     }
     my $number_of_old_IDs = keys %old_id_present;
     my $percentage = ($number_of_old_IDs / $number_of_elements_start_ds) * 100;
     print("Number of IDs from the original dataset that appear in the network: $number_of_old_IDs\n");
     print("Percentage of IDs from the original dataset that appear in the final dataset: $percentage\n");
     
     my $number_of_new_IDs = keys %new_id_set;
     my $number_of_network_nodes = keys %all_seen;
     $percentage= ($number_of_new_IDs / $number_of_network_nodes) * 100;
     if($onetoone_only){
          print("Number of total UNIQUE IDs in interaction dataset (considering ONE-TO-ONE ortologies only): $number_of_network_nodes\n");
     }else{
          print("Number of total UNIQUE IDs in interaction dataset: $number_of_network_nodes\n");
     }
     print("Number of NEW ids (e.g. not seen in starting data set): $number_of_new_IDs\n");
     print("Percentage of new ids over the total: $percentage\n");
     
     
     #I save all the new ids in a flat file. This might be useful to do some analysis of their functional annotation
     foreach my $id (sort keys %new_id_set){
          #print ("$id\t$new_id_set{$id}\n");

lib/Bio/Homology/InterologWalk.pm  view on Meta::CPAN

          
               $DF_oname = $homology_member->display_label;

               #OPI
               my $pairwise_alignment_from_multiple = $homology->get_SimpleAlign;
               $DF_opi = $pairwise_alignment_from_multiple->overall_percentage_identity;
               #$opi = sprintf("%.3f", $overall_pid); #rounded
          
               $DF_orthologue_id = '-' if(!$DF_orthologue_id);
               $DF_oname         = '-' if(!$DF_oname); 
               $DF_odesc         = '-' if(!$DF_odesc);

lib/Bio/Homology/InterologWalk.pm  view on Meta::CPAN

             We can divide the metadata features in two broad classes:
             - features related to the interaction. These include: Interaction Type, Interaction 
               Detection Method, Interaction coming from a SPOKE-expanded complex, interaction recon-
               firmed through multiple taxa, interaction reconfirmed through multiple detection methods
             - features related to the two orthology mappings. These include: orthology type 
               (one-to-one, one-to-many, many-to-one, many-to-many), OPI (percentage identity of the 
               conserved columns - see Bio::SimpleAlign), node to node distance, distance from the 
               first shared ancestor, (under development) dN/dS ratio
             The IPX computation will also involve a normalisation stage. The subroutine requires 
             five arguments (meanscore_x) representing mean values to be used for normalisation.
             The actual means are computed in get_mean_scores(), which is pre-requisite to 

lib/Bio/Homology/InterologWalk.pm  view on Meta::CPAN

             -meanscore_me_dm : mean 'multiple detection methods' score for normalisation
             -meanscore_me_taxa : mean 'multiple taxa' score for normalisation
 Throws    : -
 Comment   : -

See Also   : L<http://search.cpan.org/~cjfields/BioPerl-1.6.1/Bio/SimpleAlign.pm#overall_percentage_identity>, L</get_mean_scores>, C<doScores.pl> for sample usage

=cut


sub compute_prioritisation_index{

 view release on metacpan or  search on metacpan

lib/Bio/KBase/CDMI/CDMI_APIImpl.pm  view on Meta::CPAN

in which hundreds of corresponding genes are detected, but they all come from
very closely related genomes.

The significance of the score relates to the number of genomes in the database.
We recommend that you take the time to look at a set of scored pairs and determine
approximately what percentage appear to be actually related for a few cutoff values.

=back

=cut

 view release on metacpan or  search on metacpan

lib/Bio/Kmer.pm  view on Meta::CPAN

                          software like jellyfish.
  gt           1          If the count of kmers is fewer 
                          than this, ignore the kmer. This 
                          might help speed analysis if you 
                          do not care about low-count kmers.
  sample       1          Retain only a percentage of kmers.
                          1 is 100%; 0 is 0%
                          Only works with the perl kmer counter.
  verbose      0          Print more messages.

  Examples:

 view release on metacpan or  search on metacpan

MAGE/Measurement/ConcentrationUnit.pm  view on Meta::CPAN

use constant UNITNAMECV_PM => 'pM';
use constant UNITNAMECV_MG_PER_ML => 'mg_per_mL';
use constant UNITNAMECV_OTHER => 'other';
use constant UNITNAMECV_UM => 'uM';
use constant UNITNAMECV_M => 'M';
use constant UNITNAMECV_MASS_PER_VOLUME_PERCENT => 'mass_per_volume_percent';
use constant UNITNAMECV_GRAM_PERCENT => 'gram_percent';
use constant UNITNAMECV_MASS_PER_MASS_PERCENT => 'mass_per_mass_percent';
use constant UNITNAMECV_NM => 'nM';

=head1 NAME

Bio::MAGE::Measurement::ConcentrationUnit - Class for the MAGE-OM API

MAGE/Measurement/ConcentrationUnit.pm  view on Meta::CPAN

=item $val = $concentrationunit->setUnitNameCV($val)

The restricted setter method for the C<unitNameCV> attribute.

C<unitNameCV> is an B<enumerated> attribute - it can only be set to C<undef> or one of the following values: M mM uM nM pM fM mg_per_mL mL_per_L g_per_L gram_percent mass_per_volume_percent  mass_per_mass_percent other


Input parameters: the value to which the C<unitNameCV> attribute will be set 

Return value: the current value of the C<unitNameCV> attribute 

Side effects: none

Exceptions: will call C<croak()> if no input parameters are specified, or
if too many input parameters are specified, or if C<$val> is not one of the accepted enumeration values: M mM uM nM pM fM mg_per_mL mL_per_L g_per_L gram_percent mass_per_volume_percent  mass_per_mass_percent other

=cut


sub setUnitNameCV {

MAGE/Measurement/ConcentrationUnit.pm  view on Meta::CPAN

  croak(__PACKAGE__ . "::setUnitNameCV: no arguments passed to setter")
    unless @_;
  croak(__PACKAGE__ . "::setUnitNameCV: too many arguments passed to setter")
    if @_ > 1;
  my $val = shift;
    croak(__PACKAGE__ . "::setUnitNameCV: expected one of enum values : M mM uM nM pM fM mg_per_mL mL_per_L g_per_L gram_percent mass_per_volume_percent  mass_per_mass_percent other, got $val")
    unless (not defined $val) or (grep {$val eq $_} qw(M mM uM nM pM fM mg_per_mL mL_per_L g_per_L gram_percent mass_per_volume_percent  mass_per_mass_percent other));

  return $self->{__UNITNAMECV} = $val;
}

MAGE/Measurement/ConcentrationUnit.pm  view on Meta::CPAN

The restricted getter method for the C<unitNameCV> attribute.

Input parameters: none

Return value: the current value of the C<unitNameCV> attribute : an instance of type C<M mM uM nM pM fM mg_per_mL mL_per_L g_per_L gram_percent mass_per_volume_percent  mass_per_mass_percent other>.

Side effects: none

Exceptions: will call C<croak()> if any input parameters are specified

 view release on metacpan or  search on metacpan

lib/Bio/MAGETAB/Util/DBLoader.pm  view on Meta::CPAN

            }
        }

        # Warn the user about a known Tangram bug.
        if ( $value && $value =~ /\%/ ) {
            warn("Warning: ID fields containing the percent character (%) may"
                ." lead to problems with object retrieval. See the documentation for "
                .__PACKAGE__." for a discussion of this bug.\n");
        }

        {

 view release on metacpan or  search on metacpan

lib/Bio/MLST/Blast/BlastN.pm  view on Meta::CPAN

  my ($start, $end) = ($row[8], $row[9]);
  ($start, $end, my $reverse) = $start <= $end ? ($start, $end, 0) : ($end, $start, 1);
  return {
    'allele_name' => $row[0],
    'source_name' => $row[1],
    'percentage_identity' => $row[2],
    'sample_alignment_length' => $row[3],
    'matches' => $row[12],
    'source_start' => $start,
    'source_end' => $end,
    'reverse' => $reverse,

lib/Bio/MLST/Blast/BlastN.pm  view on Meta::CPAN

sub _filter_best_hits
{
  my($self, $hits, $tollerance) = @_;
  $tollerance = defined($tollerance) ? $tollerance : 2.0;
  my @percentages = map { $_->{'percentage_identity'} } @$hits;
  my $top_percentage = max @percentages;
  my @top_hits = grep { $_->{'percentage_identity'} >= $top_percentage - $tollerance } @$hits;
  return \@top_hits;
}

sub _group_overlapping_hits
{

lib/Bio/MLST/Blast/BlastN.pm  view on Meta::CPAN

sub _best_hit_in_group
{
  ###
  # The best hit has the greatest number of matching bases.  If two hits have
  # the same number of matching bases, the one with the greater
  # percentage identity is selected.
  ###
  my($self, $hits) = @_;
  my @lengths = map { $_->{'matches'} } @$hits;
  my $max_length = max @lengths;
  my @longest_hits = grep { $_->{'matches'} == $max_length } @$hits;

  my $best_hit = reduce { $a->{'percentage_identity'} > $b->{'percentage_identity'} ? $a : $b } @longest_hits;
  return $best_hit;
}

sub _blastn_cmd
{

lib/Bio/MLST/Blast/BlastN.pm  view on Meta::CPAN

  $bins = $self->_merge_similar_bins($bins);
  my $groups = $self->_bins_to_groups($bins);

  # Find the best match
  my @best_in_groups = map { $self->_best_hit_in_group($_) } @$groups;
  $top_hit = reduce { $a->{'percentage_identity'} > $b->{'percentage_identity'} ? $a : $b } @best_in_groups;

  if (defined $top_hit)
  {
    $top_hit->{'percentage_identity'} = int($top_hit->{'percentage_identity'});
    delete $top_hit->{'sample_alignment_length'};
    delete $top_hit->{'matches'};
  }
  else {
    $top_hit = {};

lib/Bio/MLST/Blast/BlastN.pm  view on Meta::CPAN

Returns a hash containing details about the top blast result.

The attributes returned in the hash are:
  allele_name
  percentage_identity
  source_name
  source_start
  source_end
  reverse
  contamination

 view release on metacpan or  search on metacpan

bin/compress-db.pl  view on Meta::CPAN

=for Euclid: n.type:    n > 15
    n.default: 40

=item --cap3-p=<n>

Overlap percent identity cutoff for CAP3 (should be > 65) [default: 90].

=for Euclid: n.type:    n > 65
    n.default: 90

=item --verbosity=<level>

 view release on metacpan or  search on metacpan

bin/physeter.pl  view on Meta::CPAN

            next HIT;
        }

        # skip weak hits (classical mode)
        next HIT if $hit->hsp_length       < $ARGV_tax_min_len;
        next HIT if $hit->percent_identity < $ARGV_tax_min_ident;
        next HIT if $hit->bit_score        < $ARGV_tax_min_score;

        # fetch hit taxonomy and org
        # optimized code (requires taxon_id|accession seq_ids)
        my $taxon_id = ( split m{\|}xms, $hit->hit_id )[0];

bin/physeter.pl  view on Meta::CPAN

Enable greedy behavior when interpreting the ambiguous taxa provided in the
required argument C<--taxon-list> [default: no].

=item --tax-min-ident=<n>

Minimum identity percentage to consider a hit when computing a LCA [default:
n.default].

=for Euclid: n.type: +number
    n.default: 0

 view release on metacpan or  search on metacpan

bin/split-rates-ali.pl  view on Meta::CPAN

        }
    }

    ### Computing masks from stats
    my %args;
    $args{percentile} = 1 if $ARGV_percentile;
    $args{cumulative} = 1 if $ARGV_cumulative;
    $args{descending} = 1 if $ARGV_descending;
    my @masks = $rates->bin_rates_masks($ARGV_bin_number, \%args);

    # output one Ali per bin

bin/split-rates-ali.pl  view on Meta::CPAN

Number of bins to define [default: 10].

=for Euclid: n.type:    number
    n.default: 10

=item --percentile

Define bins containing an equal number of sites rather than bins of equal width
in terms of rates [default: no].

=item --cumulative

 view release on metacpan or  search on metacpan

bin/annotate-ali.pl  view on Meta::CPAN

use Bio::MUST::Drivers;


# TODO: add support for prebuilt reference database (e.g. nr)

# convert fractional identity threshold to percentage (see Euclid)
$ARGV_identity *= 100.0 if 0 < $ARGV_identity && $ARGV_identity <= 1;

### Building database: $ARGV_ref_file
my $blastdb = Bio::MUST::Drivers::Blast::Database::Temporary->new(
    seqs => $ARGV_ref_file

bin/annotate-ali.pl  view on Meta::CPAN

    my $curr_id = q{};

    HIT:
    while ( my $hit = $parser->next_hit ) {
        my ($qid, $hid, $evalue, $identity)
            = map { $hit->$_ } qw(query_id hit_id evalue percent_identity);

        next HIT if $identity < $ARGV_identity;     # skip weak-identity hits

        unless ($ARGV_hit_list) {
            next HIT if $qid eq $curr_id;           # skip non-first hits

bin/annotate-ali.pl  view on Meta::CPAN

=item --identity [=] <number>

Identity threshold for annotating a sequence [default: 0]. When specified as a
fraction between 0 and 1 (included), it is first multiplied by 100 to be
interpreted in percentage.

=for Euclid: number.type: number
    number.default: 0

=item --max-hits [=] <number>

 view release on metacpan or  search on metacpan

bin/tag-loc-ids.pl  view on Meta::CPAN

    HIT:
    # loop through first hits for each query
    while (my $hit = $report->next_query) {

        # consider only hits over percent_id threshold
        next HIT if $hit->percent_identity < $ARGV_percent_id;

        # strict check of length unless percent_id filter only
        unless ($ARGV_pid_only) {
            next HIT
                unless ( $hit->query_end - $hit->query_start )
                    == (   $hit->hit_end -   $hit->hit_start )
            ;

bin/tag-loc-ids.pl  view on Meta::CPAN

infile (e.g., IDM files) and outfile names [default: none].

=for Euclid: str.type: string
    repeatable

=item --percent-id=<n>

Min percentage identity to consider a hit.

=for Euclid: n.type: n
    n.default: 99

=item --fasta[-suffix]=<suffix>