Result:
found more than 741 distributions - search limited to the first 2001 files matching your query
( run in 1.529 )
Bio-RNA-RNAaliSplit
view release on metacpan or search on metacpan
lib/Bio/RNA/RNAaliSplit/WrapRNAz.pm view on Meta::CPAN
# Bio::RNA::RNAaliSplit::WrapRNAz.pm: A versatile object-oriented
# wrapper for RNAz
#
# Requires RNAz executable available to the Perl interpreter.
# This package contains code fragments from the original RNAz Perl module
package Bio::RNA::RNAaliSplit::WrapRNAz;
use version; our $VERSION = qv('0.11');
use Carp;
Bio-Regexp
view release on metacpan or search on metacpan
lib/Bio/Regexp.pm view on Meta::CPAN
return if $self->{compiled_regexp};
$self->_arg_defaults;
my $regexp_index = 0;
my @regexp_fragments;
foreach my $regexp (@{ $self->{regexps} }) {
## Parse
my $ast = Bio::Regexp::AST->new($regexp, $self->{type}, $self->{arg});
lib/Bio/Regexp.pm view on Meta::CPAN
## Main "sense" strand
my $rendered = $ast->render;
push @regexp_fragments, "$rendered(?{ $regexp_index })";
$regexp_index++;
my $component = { regexp => $regexp, };
$component->{strand} = 1 if $self->{arg}->{strands} == 2;
lib/Bio/Regexp.pm view on Meta::CPAN
if ($self->{arg}->{strands} == 2) {
$ast->reverse_complement;
$rendered = $ast->render;
push @regexp_fragments, "$rendered(?{ $regexp_index })";
$regexp_index++;
my $component = { regexp => $regexp, strand => 2, };
push @{ $self->{components} }, $component;
lib/Bio/Regexp.pm view on Meta::CPAN
}
my $compiled_regexp = ($self->{arg}->{strict_case} ? '' : '(?i)') .
'(' .
($self->{arg}->{no_substr} ? '?:' : '') .
join('|', @regexp_fragments) .
')';
{
use re 'eval';
$self->{compiled_regexp} = qr{$compiled_regexp};
Bio-RetrieveAssemblies
view release on metacpan or search on metacpan
t/data/refweak.tsv view on Meta::CPAN
CCCK01 Escherichia coli Fragmented and genome much larger than expected
CDQN01 Escherichia coli Fragmented and genome much larger than expected
CDQS01 Escherichia coli Fragmented and genome much larger than expected
CDQW01 Escherichia coli Fragmented and genome much larger than expected
CDRO01 Escherichia coli Fragmented and genome much larger than expected
CFAX01 Streptococcus pneumoniae Too fragmented
CFDG01 Streptococcus pneumoniae Too small
CFDO01 Streptococcus pneumoniae Too small
CFEQ01 Streptococcus pneumoniae Too big
CFFF01 Streptococcus pneumoniae Too big
CFFU01 Streptococcus pneumoniae Too small
CFFY01 Streptococcus pneumoniae Too big
CFGZ01 Streptococcus pneumoniae Too fragmented
CFYQ01 Bordetella pertussis Too fragmented
CFYS01 Staphylococcus aureus Too many contigs
CFZH01 Bordetella pertussis Too fragmented
CGCX01 Mycobacterium tuberculosis Too fragmented
CGDO01 Mycobacterium tuberculosis Too fragmented
CGFZ01 Bordetella pertussis Too fragmented
CGWE01 Streptococcus pneumoniae Too fragmented
CGWL01 Streptococcus pneumoniae Too big
CGXO01 Streptococcus pneumoniae Too big
CHCS01 Streptococcus pneumoniae Too fragmented
CHCU01 Streptococcus pneumoniae Too fragmented
CHDS01 Mycobacterium tuberculosis Too fragmented
CHED01 Mycobacterium tuberculosis Too fragmented
CHEE01 Mycobacterium tuberculosis Too fragmented
CHHQ01 Streptococcus pneumoniae Too small
CHIQ01 Streptococcus pneumoniae Too small
CHKU01 Bordetella pertussis Too fragmented
CHKZ01 Bordetella pertussis Too fragmented
CHOP01 Streptococcus pneumoniae Too small
CHQU01 Streptococcus pneumoniae Too fragmented
CHRW01 Streptococcus pneumoniae Too big
CHTU01 Streptococcus pneumoniae Too big
CHVB01 Streptococcus pneumoniae Too big
CHVD01 Streptococcus pneumoniae Too big
CHXN01 Streptococcus pneumoniae Too Fragmented
CIBW01 Streptococcus pneumoniae Too fragmented
CIDG01 Streptococcus pneumoniae Too big
CIDK01 Streptococcus pneumoniae Too big
CIGT01 Bordetella pertussis Too fragmented
CIGY01 Bordetella pertussis Too fragmented
CIIO01 Streptococcus pneumoniae Too big
CKLU01 Streptococcus pneumoniae Too fragmented
CKMB01 Streptococcus pneumoniae Too fragmented
CKMC01 Streptococcus pneumoniae Too fragmented
CKMD01 Streptococcus pneumoniae Too fragmented
CKME01 Streptococcus pneumoniae Too fragmented
CKMG01 Streptococcus pneumoniae Too fragmented
CKML01 Streptococcus pneumoniae Too fragmented
CKMN01 Streptococcus pneumoniae Too fragmented
CLCA01 Streptococcus pneumoniae Too fragmented
CLCF01 Streptococcus pneumoniae Too fragmented
CLCT01 Streptococcus pneumoniae Too fragmented
CLCV01 Streptococcus pneumoniae Too fragmented
CLCW01 Streptococcus pneumoniae Too fragmented
CLDM01 Streptococcus pneumoniae Too fragmented
CLMB01 Streptococcus pneumoniae Too fragmented
CMMW01 Streptococcus pneumoniae Too fragmented
CMQU01 Streptococcus pneumoniae Too fragmented
CMTL01 Streptococcus pneumoniae Too fragmented
CNAO01 Streptococcus pneumoniae Too fragmented
CNBX01 Mycobacterium tuberculosis Too fragmented
CNCN01 Mycobacterium tuberculosis Too fragmented
CNCO01 Mycobacterium tuberculosis Too fragmented
CNDE01 Mycobacterium tuberculosis Too fragmented
CNDG01 Mycobacterium tuberculosis Too fragmented
CNFP01 Mycobacterium tuberculosis Too fragmented
CNFQ01 Mycobacterium tuberculosis Too fragmented
CNFR01 Mycobacterium tuberculosis Too fragmented
CNFS01 Mycobacterium tuberculosis Too fragmented
CNFT01 Mycobacterium tuberculosis Too fragmented
CNFU01 Mycobacterium tuberculosis Too fragmented
CNFV01 Mycobacterium tuberculosis Too fragmented
CNFW01 Mycobacterium tuberculosis Too fragmented
CNGE01 Mycobacterium tuberculosis Too fragmented
CNGG01 Mycobacterium tuberculosis Too fragmented
CNIS01 Mycobacterium tuberculosis Too fragmented
CNMV01 Mycobacterium tuberculosis Too fragmented
COIL01 Mycobacterium tuberculosis Too fragmented
CP002797 Escherichia coli UPEC ST131 See PubMed 24706808 for discussion on the quality of this genome
CP006958 Achromobacter xylosoxidans NBRC15126 ATCC27061 NCBI PRJNA209573 Illumina adapter contamination NA
CPAQ01 Mycobacterium tuberculosis Too fragmented
CPMC01 Streptococcus pneumoniae Too fragmented
CPMI01 Streptococcus pneumoniae Too fragmented
CPMN01 Streptococcus pneumoniae Too fragmented
CPNM01 Streptococcus pneumoniae Too fragmented
CPOJ01 Streptococcus pneumoniae Too fragmented
CPPR01 Streptococcus pneumoniae Too fragmented
CPQT01 Streptococcus pneumoniae Too fragmented
CPRN01 Streptococcus pneumoniae Too fragmented
CPSE01 Streptococcus pneumoniae Too fragmented
CPSU01 Streptococcus pneumoniae Too fragmented
CPUM01 Streptococcus pneumoniae Too fragmented
CPWZ01 Mycobacterium tuberculosis Too fragmented
CPZG01 Mycobacterium tuberculosis Too fragmented
CQPL01 Mycobacterium tuberculosis Too fragmented
CQPT01 Mycobacterium tuberculosis Too fragmented
CQPW01 Mycobacterium tuberculosis Too fragmented
CQQC01 Mycobacterium tuberculosis Too fragmented
CQTO01 Mycobacterium tuberculosis Too fragmented
CRBZ01 Streptococcus pneumoniae Too fragmented
CRCI01 Streptococcus pneumoniae Too fragmented
CRCN01 Streptococcus pneumoniae Too fragmented
CRCO01 Streptococcus pneumoniae Too fragmented
CRGB01 Streptococcus pneumoniae Too fragmented
CRRN01 Streptococcus pneumoniae Too fragmented
CRSC01 Streptococcus pneumoniae Too fragmented
CSAU01 Mycobacterium tuberculosis Too fragmented
CSAV01 Mycobacterium tuberculosis Too fragmented
CSAY01 Mycobacterium tuberculosis Too fragmented
CSBI01 Mycobacterium tuberculosis Too fragmented
CSBK01 Mycobacterium tuberculosis Too fragmented
CSLY01 Bordetella pertussis Too fragmented
CSMT01 Staphylococcus aureus Too fragmented
CSNC01 Staphylococcus aureus Too fragmented
CSPC01 Staphylococcus haemolyticus Too fragmented
CSPN01 Staphylococcus aureus Too fragmented
CSQX01 Bordetella pertussis Too fragmented
CSST01 Staphylococcus aureus Too fragmented
CSTN01 Chlamydia trachomatis Too fragmented
CSTQ01 Chlamydia trachomatis Too fragmented
CSTU01 Mycobacterium abscessus Too fragmented
CSVM01 Mycobacterium abscessus Too fragmented
CSVS01 Mycobacterium abscessus Too fragmented
CSZG01 Mycobacterium abscessus Too fragmented
CSZP01 Mycobacterium abscessus Too fragmented
CSZS01 Mycobacterium abscessus Too fragmented
CSZT01 Mycobacterium abscessus Too fragmented
CTBL01 Chlamydia trachomatis Too fragmented
CTRE01 Yersinia enterocolitica Too fragmented
CTZB01 Staphylococcus aureus Too fragmented
CTZD01 Staphylococcus aureus Too fragmented
CUAH01 Staphylococcus aureus Too fragmented
CUAL01 Staphylococcus aureus Too fragmented
CUAN01 Staphylococcus aureus Too fragmented
CUAQ01 Staphylococcus aureus Too fragmented
CUBB01 Staphylococcus aureus Too fragmented
CUCA01 Staphylococcus aureus Too fragmented
CUCB01 Staphylococcus aureus Too fragmented
CUDA01 Staphylococcus aureus Too fragmented
CUDH01 Staphylococcus aureus Too fragmented
CUDK01 Staphylococcus aureus Too fragmented
CUEG01 Staphylococcus aureus Too fragmented
CUEP01 Staphylococcus aureus Too fragmented
CVKS01 Streptococcus pneumoniae Too small
CVLR01 Streptococcus pneumoniae Too fragmented
CVLS01 Streptococcus pneumoniae Too big
CVNZ01 Chlamydia trachomatis More than 1 contig per expected gene NA
CVOF01 Streptococcus pneumoniae Too big
JPIO01 Salmonella enterica SUBSP. ENTERICA SEROVAR WELTEVREDEN Too few proteins
JSHN01 Escherichia coli Half expected size and highly fragmented
JSIP01 Escherichia coli Half expected size and highly fragmented
JSIZ01 Escherichia coli Half expected size and highly fragmented
JSJC01 Escherichia coli Half expected size and highly fragmented
JSJD01 Escherichia coli Half expected size and highly fragmented
JSJH01 Escherichia coli Half expected size and highly fragmented
JSJR01 Escherichia coli Half expected size and highly fragmented
JSJU01 Escherichia coli Half expected size and highly fragmented
JSJV01 Escherichia coli Half expected size and highly fragmented
JSJY01 Escherichia coli Half expected size and highly fragmented
JSKH01 Escherichia coli Half expected size and highly fragmented
JSKQ01 Escherichia coli Half expected size and highly fragmented
JSKV01 Escherichia coli Half expected size and highly fragmented
JSKW01 Escherichia coli Half expected size and highly fragmented
JSKY01 Escherichia coli Half expected size and highly fragmented
JSLH01 Escherichia coli Half expected size and highly fragmented
JSLM01 Escherichia coli Half expected size and highly fragmented
JSLO01 Escherichia coli Half expected size and highly fragmented
JSLS01 Escherichia coli Half expected size and highly fragmented
JSME01 Escherichia coli Half expected size and highly fragmented
JSMM01 Escherichia coli Half expected size and highly fragmented
JSPL01 Escherichia coli Fragmented and genome much larger than expected
JXSA01 Staphylococcus aureus Too many contigs
JXSG01 Staphylococcus aureus Too many contigs
JXSH01 Staphylococcus aureus Too many contigs
NC_017644 Escherichia coli UPEC ST131 See PubMed 24706808 for discussion on the quality of this genome
Bio-Roary
view release on metacpan or search on metacpan
lib/Bio/Roary/ExtractCoreGenesFromSpreadsheet.pm view on Meta::CPAN
has '_number_of_isolates' => ( is => 'rw', isa => 'Int' );
has '_gene_column' => ( is => 'rw', isa => 'Int' );
has '_num_isolates_column' => ( is => 'rw', isa => 'Int' );
has '_avg_sequences_per_isolate_column' => ( is => 'rw', isa => 'Int' );
has '_genome_fragement_column' => ( is => 'rw', isa => 'Int' );
has '_order_within_fragement_column' => ( is => 'rw', isa => 'Int' );
has '_min_no_isolates_for_core' => ( is => 'rw', isa => 'Num', lazy => 1, builder => '_build__min_no_isolates_for_core' );
sub _build__min_no_isolates_for_core {
my ($self) = @_;
my $threshold = $self->_number_of_isolates * $self->core_definition;
lib/Bio/Roary/ExtractCoreGenesFromSpreadsheet.pm view on Meta::CPAN
}
}
$self->_gene_column( $columns_of_interest_mappings{'Gene'} );
$self->_num_isolates_column( $columns_of_interest_mappings{'No. isolates'} );
$self->_avg_sequences_per_isolate_column( $columns_of_interest_mappings{'Avg sequences per isolate'} );
$self->_genome_fragement_column( $columns_of_interest_mappings{'Genome Fragment'} );
$self->_order_within_fragement_column( $columns_of_interest_mappings{'Order within Fragment'} );
$self->_update_number_of_isolates($header_row);
# Get the sample_names
my @sample_names;
for ( my $i = $self->_length_of_fixed_headers() ; $i < @{$header_row} ; $i++ ) {
lib/Bio/Roary/ExtractCoreGenesFromSpreadsheet.pm view on Meta::CPAN
next if ( !defined( $row->[ $self->_gene_column ] ) || $row->[ $self->_gene_column ] eq '' ); # no gene name
next
if ( !defined( $row->[ $self->_avg_sequences_per_isolate_column ] ) || $row->[ $self->_avg_sequences_per_isolate_column ] eq '' )
; # no average
next
if ( !defined( $row->[ $self->_genome_fragement_column ] ) || $row->[ $self->_genome_fragement_column ] eq '' )
; # fragment not defined
# next if($self->_number_of_isolates != $row->[$self->_num_isolates_column]); # if gene is not in all isolates
next if ( $row->[ $self->_num_isolates_column ] < $self->_min_no_isolates_for_core );
if ( $self->allow_paralogs ) {
lib/Bio/Roary/ExtractCoreGenesFromSpreadsheet.pm view on Meta::CPAN
}
else {
next if ( $row->[ $self->_avg_sequences_per_isolate_column ] != 1 );
}
$ordered_genes{ $row->[ $self->_genome_fragement_column ] }{ $row->[ $self->_order_within_fragement_column ] } =
$row->[ $self->_gene_column ];
$self->_populate_sample_to_gene_lookup_with_row($row);
}
my @ordered_core_genes;
for my $fragment_key ( sort { $a <=> $b } keys %ordered_genes ) {
for my $order_within_fragement ( sort { $a <=> $b } keys %{ $ordered_genes{$fragment_key} } ) {
push( @ordered_core_genes, $ordered_genes{$fragment_key}{$order_within_fragement} );
}
}
return \@ordered_core_genes;
}
Bio-SamTools
view release on metacpan or search on metacpan
lib/Bio/DB/Sam.pm view on Meta::CPAN
sub max_pileup_cnt {
my $self = shift;
return Bio::DB::Bam->max_pileup_cnt(@_);
}
# return a fragment of code that will be placed in the eval "" filter
# to eliminate alignments that don't match by name
sub _filter_by_name {
my $self = shift;
my $name = shift;
my $frag = "my \$name=\$a->qname; defined \$name or return; ";
if (my $regexp = $self->_glob_match($name)) {
$frag .= "return unless \$name =~ /^$regexp\$/i;\n";
} else {
$frag .= "return unless lc \$name eq '$name';\n";
}
}
# return a fragment of code that will be placed in the eval "" filter
# to eliminate alignments that don't match by attribute
sub _filter_by_attribute {
my $self = shift;
my $attributes = shift;
my $result;
Bio-SeqAlignment-Applications-SequencingSimulators-RNASeq-Polyester
view release on metacpan or search on metacpan
bin/polyester_polyA.pl view on Meta::CPAN
my @numreps;
my $outdir;
my $paired;
my $readsfile;
my $readlen;
my $fraglen;
my $fragsd;
my $seed;
my $strandspec;
my $taildist;
my $writeinfo;
# Configure Getopt::Long
GetOptions(
'bias|b:s' => \$bias, # fragment selection bias (optional, string)
'distparams|P=f{1,}' => \@distparams
, # distribution parameters (mandatory, list of numeric values)
'errormodel|e:s' => \$errormodel, # error model (optional, string)
'errorrate|E:f' => \$errorrate, # error probability (optional, float)
'fastafile|f=s' => \$fastafile, # fasta file (path) (mandatory, strings)
'fcfile|c:s' => \$fcfile, # fold change (path) (optional, string)
'fraglen|F:i' => \$fraglen, # fragment length (avg) (optional, integer)
'fragsd|S:i' => \$fragsd, # fragment length (sd) (optional, integer)
'gcbias|g:i' => \$gcbias, # gc bias (optional, integer)
'maxseqs|m:i' => \$max_sequences_per_file, # max sequences per file
'modformat|M:s' => \$modformat
, # case insensitive format for storing modifications (one of JSON, YAML, or MessagePack)
'numreps|n:i{,}' =>
bin/polyester_polyA.pl view on Meta::CPAN
numreps => \@numreps,
outdir => $outdir,
paired => $paired,
readsfile => $readsfile,
readlen => $readlen,
fraglen => $fraglen,
fragsd => $fragsd,
seed => $seed,
strandspec => $strandspec,
writeinfo => $writeinfo
);
bin/polyester_polyA.pl view on Meta::CPAN
my $numreps = $polyester_params{numreps};
my $outdir = $polyester_params{outdir};
my $paired = $polyester_params{paired};
my $readsfile = $polyester_params{readsfile};
my $readlen = $polyester_params{readlen};
my $fraglen = $polyester_params{fraglen};
my $fragsd = $polyester_params{fragsd};
my $seed = $polyester_params{seed};
my $strandspec = $polyester_params{strandspec};
my $writeinfo = $polyester_params{writeinfo};
my $r_command =
bin/polyester_polyA.pl view on Meta::CPAN
$r_command .= " --numreps \"@{$numreps}\"" if $numreps;
$r_command .= " --outdir \"$outdir\"" if defined $outdir;
$r_command .= " --paired $paired" if defined $paired;
$r_command .= " --readsfile \"$readsfile\"";
$r_command .= " --readlen $readlen" if defined $readlen;
$r_command .= " --fraglen $fraglen" if defined $fraglen;
$r_command .= " --fragsd $fragsd" if defined $fragsd;
$r_command .= " --seed $seed" if defined $seed;
$r_command .= " --strandspec $strandspec" if defined $strandspec;
$r_command .= " --writeinfo $writeinfo" if defined $writeinfo;
## Execute the R command
Bio-SeqAlignment-Examples-TailingPolyester
view release on metacpan or search on metacpan
lib/Bio/SeqAlignment/Examples/TailingPolyester.pm view on Meta::CPAN
=item * L<polyester|https://github.com/alyssafrazee/polyester>
Polyester is an R package designed to simulate RNA sequencing experiments with
differential transcript expression.Given a set of annotated transcripts,
Polyester will simulate the steps of an RNA-seq experiment (fragmentation,
reverse-complementing, and sequencing) and produce files containing simulated
RNA-seq reads. Simulated reads can be analyzed using your choice of downstream
analysis tools.
Polyester has a built-in wrapper function to simulate a case/control experiment
with differential transcript expression and biological replicates. Users are
Bio-ToolBox
view release on metacpan or search on metacpan
lib/Bio/ToolBox.pm view on Meta::CPAN
=over 4
=item L<bam2wig.pl>
Generate read or fragment coverage or point data representations of alignments.
=item L<data2bed.pl>
Convert a table containing coordinates into a properly formatted BED file.
Bio-Tools-Gel
view release on metacpan or search on metacpan
lib/Bio/Tools/Gel.pm view on Meta::CPAN
my $d = 'AAAAAAAAAGAATTCTTTTTTTTTTTTTTGAATTCGGGGGGGGGGGGGGGGGGGG';
my $seq1 = Bio::Seq->new(-id=>'groundhog day',-seq=>$d);
# cut it with an enzyme
my $ra=Bio::Restriction::Analysis->new(-seq=>$seq1);
@cuts = $ra->fragments('EcoRI'), 3;
# analyse the fragments in a gel
my $gel = Bio::Tools::Gel->new(-seq=>\@cuts,-dilate=>10);
my %bands = $gel->bands;
foreach my $band (sort {$b <=> $a} keys %bands){
print $band,"\t", sprintf("%.1f", $bands{$band}),"\n";
}
Bio-Tools-Primer3Redux
view release on metacpan or search on metacpan
lib/Bio/Tools/Primer3Redux/PrimerPair.pm view on Meta::CPAN
my ($self, $primer) = @_;
if ($primer) {
$self->throw("Not a Primer object") unless $primer->isa('Bio:::Tools::Primer3Redux::Primer');
# Note this doesn't expand to fit; the assumption is this is added
# after forward/reverse primers are added and acts to ensure the
# oligo is actually internal to the fragment (otherwise it throws)
$self->add_SeqFeature($primer);
}
my ($oligo) = grep {$_->primary_tag eq 'ss_oligo'} $self->get_SeqFeatures;
return $oligo;
}
Bio-Tools-Run-Alignment-Clustalw
view release on metacpan or search on metacpan
lib/Bio/Tools/Run/Alignment/Clustalw.pm view on Meta::CPAN
=head2 KTUPLE
Title : KTUPLE
Description : (optional) set the word size to be used in the alignment
This is the size of exactly matching fragment that is used.
INCREASE for speed (max= 2 for proteins; 4 for DNA),
DECREASE for sensitivity.
For longer sequences (e.g. >1000 residues) you may
need to increase the default
Bio-Tools-Run-Alignment-TCoffee
view release on metacpan or search on metacpan
lib/Bio/Tools/Run/Alignment/TCoffee.pm view on Meta::CPAN
1 indicates that this score is set equal to the score of
the best uninterrupted segment
1 can be useful when dealing with fragments of sequences.
=head2 SIM_MATRIX
Title : SIM_MATRIX
Args : string
Bio-Trace-ABIF
view release on metacpan or search on metacpan
lib/Bio/Trace/ABIF.pm view on Meta::CPAN
=head2 peaks()
Usage : @pks = $abif->peaks(1);
Returns : An array of peak hashes. Each peak hash contains the following attributes:
'position', 'height', 'beginPos', 'endPos', 'beginHI', 'endHI',
'area', 'volume', 'fragSize', 'isEdited', 'label';
() if the data item is not in the file.
ABIF Tag : PEAK
ABIF Type : user-defined structure
File Type : fsa
lib/Bio/Trace/ABIF.pm view on Meta::CPAN
=cut
sub peaks {
my ($self, $n) = @_;
my $k = '_PEAK' . $n;
my ($position, $height, $beginPos, $endPos, $beginHI, $endHI, $area, $volume, $fragSize, $isEdited, $label);
my $s = undef;
my @raw_data;
my @peak_array;
my $i;
unless (defined $self->{$k}) {
@raw_data = $self->get_data_item('PEAK', $n, '(NnNNnnNNB32nZ64)*');
for ($i = 0; $i < @raw_data; $i += 11) {
($position, $height, $beginPos, $endPos, $beginHI, $endHI, $area, $volume, $s, $isEdited, $label) = @raw_data[$i .. $i+10];
$fragSize = $self->_ieee2decimal($s) if (defined $s);
my $peak = {};
$peak->{position} = $position;
$peak->{height} = $height;
$peak->{beginPos} = $beginPos;
$peak->{endPos} = $endPos;
$peak->{beginHI} = $beginHI;
$peak->{endHI} = $endHI;
$peak->{area} = $area;
$peak->{volume} = $volume;
$peak->{fragSize} = $fragSize;
$peak->{isEdited} = $isEdited;
$peak->{label} = $label;
push @peak_array, $peak;
}
$self->{$k} = (@peak_array) ? [ @peak_array ] : [ ];
Bio-ViennaNGS
view release on metacpan or search on metacpan
lib/Bio/ViennaNGS/Bam.pm view on Meta::CPAN
if ($want_bed){printf $bed_neg "%s\n", "+";}
}
}
else {croak "Strand neither + nor - ...exiting!\n";}
}
else{ # 2nd mate; reverse strand since the fragment it belongs to is ALWAYS located
# on the other strand
if($verbose == 1) {print STDERR "SECOND_MATE\t".$strand." ";}
if ( $strand eq "1" ) {
$bam_neg->write1($read);
if ($want_bed){printf $bed_neg "%s\t%d\t%d\t%s\t%d\t",$seq_id,eval($start-1),$stop,$id,$score;}
lib/Bio/ViennaNGS/Bam.pm view on Meta::CPAN
printf "ERROR: paired-end + single-end != total alignments\n";
print Dumper(\%data);
croak $!;
}
unless ($data{count}{pos} + $data{count}{neg} == $data{count}{cur}) {
printf STDERR "%20d fragments on [+] strand\n",$data{count}{pos};
printf STDERR "%20d fragments on [-] strand\n",$data{count}{neg};
printf STDERR "%20d sum\n",eval($data{count}{pos}+$data{count}{neg});
printf STDERR "%20d unmapped reads\n",$data{count}{unmapped};
printf STDERR "%20d total alignment/read count\n",$data{count}{cur};
printf STDERR "ERROR: pos alignments + neg alignments != total alignments\n";
print Dumper(\%data);
lib/Bio/ViennaNGS/Bam.pm view on Meta::CPAN
printf LOG "%20d skipped\n", $data{count}{skip};
printf LOG "%20d alignments considered\n", $data{count}{cur};
printf LOG "%20d paired-end\n", $data{count}{pe_alis};
printf LOG "%20s single-end\n", $data{count}{se_alis};
if($data{count}{cur}>0){
printf LOG "%20d fragments on [+] strand (%7.2f%% of considered)\n",
$data{count}{pos},eval(100*$data{count}{pos}/$data{count}{cur});
printf LOG "%20d fragments on [-] strand (%7.2f%% of considered)\n",
$data{count}{neg},eval(100*$data{count}{neg}/$data{count}{cur});
}
else{
printf LOG "%20d fragments on [+] strand\n",$data{count}{pos};
printf LOG "%20d fragments on [-] strand\n",$data{count}{neg};
}
printf LOG "%20d unmapped\n", $data{count}{unmapped};
printf LOG "#-----------------------------------------------------------------\n";
printf LOG "Dumper output:\n". Dumper(\%data);
close(LOG);
lib/Bio/ViennaNGS/Bam.pm view on Meta::CPAN
argument), and forced output of a BED file corresponding to
strand-specific mapping, respectively. C<$log> holds name and path of
the log file.
Strand-splitting is done in a way that in paired-end alignments, FIRST
and SECOND mates (reads) are treated as _one_ fragment, ie FIRST_MATE
reads determine the strand, while SECOND_MATE reads are assigned the
opposite strand I<per definitionem>. This also holds if the reads are
not mapped in proper pairs and even if there is no mapping partner at
all.
lib/Bio/ViennaNGS/Bam.pm view on Meta::CPAN
C<$reverse> flag.
This routine returns an array whose fist two elements are the file
names of the newly generate BAM files with reads mapped to the
positive, and negative strand, respectively. Elements three and four
are the number of fragments mapped to the positive and negative
strand. If the C<$want_bed> option was given elements five and six are
the file names of the output BED files for positive and negative
strand, respectively.
NOTE: Filtering of unique mappers is only safe for single-end
experiments; In paired-end experiments, read and mate are treated
separately, thus allowing for scenarios where eg. one read is a
multi-mapper, whereas its associate mate is a unique mapper, resulting
in an ambiguous alignment of the entire fragment.
As mentioned above, the NH:i: SAM attribute is used for discriminating
unique and multi mappers, thus requiring this attribute to be present
in every SAM record. If this attribute is not found in I<all> SAM
entries, a warning will be issued and the log file will contain a note
Bio-WGS2NCBI
view release on metacpan or search on metacpan
- [info.ini](share/info.ini) - a file with key/value pairs whose contents will be
inserted in the FASTA headers of the sequence files. These key/value pairs have to
do with the organism that was sequenced, such as the taxon name, its sex, its
developmental stages, what tissues were sampled, and so on.
- [adaptors.ini](share/adaptors.ini) - this is a file that contains the coordinates
of sequence fragments that NCBI considers inadmissible. What will happen over the
course of your submission is that NCBI will scan your sequence data for suspicious
sequence fragments. These might be adaptor sequences of various sequencing platforms,
and fragments that NCBI thinks might be contaminants. Hence, during your first pass
it is more or less impossible to get the values right in this file: this part will
be an iterative process where you blank out parts of your data that NCBI really will
not accept. Start out with an empty file, and populate it based on the feedback you
will get, making sure you follow the same syntax as the provided example file.
- [products.ini](share/products.ini) - this is a file that contains mappings from
then the number of files thus produced will be the number of contigs, divided by
`chunksize`, rounded up to the nearest integer. However, contigs smaller than
`minlength`, if you have them, will be omitted, as NCBI won't accept these.
- the FASTA data that will be written will have any stretches specified in
[adaptors.ini](share/adaptors.ini) replaced with `NNNs`. These will be sequence
fragments that NCBI will specify as inadmissible because they might be sequence adaptors
(i.e. vendor-specific synthetic DNA) or contaminants.
- the FASTA files will have the `.fsa` file extension, as required by `tbl2asn`.
- the annotations from the GFF3 file, pre-processed in the previous step, will be written
out as feature tables (required extension: `.tbl`). There will be as many `.tbl` files
as there are `.fsa` files.
Bio-fastAPD
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
return 1;
}
sub postamble {
$PostambleUsed = 1;
my $fragment;
$fragment .= <<"AUTO_INSTALL" if !$InstallDepsTarget;
config :: installdeps
\t\$(NOECHO) \$(NOOP)
AUTO_INSTALL
$fragment .= <<"END_MAKE";
checkdeps ::
\t\$(PERL) $0 --checkdeps
installdeps ::
inc/Module/AutoInstall.pm view on Meta::CPAN
listalldeps ::
\t$PostambleActionsListAllDeps
END_MAKE
return $fragment;
}
1;
__END__
BioPerl-DB
view release on metacpan or search on metacpan
t/data/AP000868.gb view on Meta::CPAN
repeat_region complement(45781..46404)
/note="MER4B: matches 1 to 779 of consensus"
repeat_region 46607..47082
/note="LOR1a: matches 1 to 497 of consensus"
misc 1..19151
/note="Component DNA fragment"
/note="accession=AP002765.3"
/note="start=159020"
/note="end=178170"
/note="orientation=1"
variation complement(2261..2261)
t/data/AP000868.gb view on Meta::CPAN
/evidence="not_experimental"
/db_xref="dbSNP:2126708"
/db_xref="HGBASE:SNP001310527"
/db_xref="TSC-CSHL:TSC1134267"
misc 19152..181589
/note="Component DNA fragment"
/note="accession=AP000868.4"
/note="start=19153"
/note="end=181590"
/note="orientation=1"
variation 19560..19560
BioPerl-Network
view release on metacpan or search on metacpan
lib/Bio/Network/ProteinNet.pm view on Meta::CPAN
}
=head2 articulation_points
Name : articulation_points
Purpose : Find nodes in a graph that if removed will fragment
the graph into sub-graphs.
Usage : my @nodes = $gr->articulation_points
or
my $count = $gr->articulation_points
Arguments : None
Returns : An array or a count of the array of nodes that will fragment
the graph if deleted.
Notes : This method is currently broken due to bugs in Graph v. .69
and later
=cut
BioPerl-Run
view release on metacpan or search on metacpan
t/data/fontfile
t/data/FootPrinter.seq.fa
t/data/Ft.bam
t/data/Ft.bed
t/data/Ft.bed12
t/data/Ft.frag.fas
t/data/Ft.frag.fas.fai
t/data/gb_result.xml
t/data/Genscan.FastA
t/data/gerp/ENr111.gerp.tree
t/data/gerp/ENr111.mfa.gz
t/data/gumby/hmrd.mfa
BioPerl
view release on metacpan or search on metacpan
Bio/Assembly/Tools/ContigSpectrum.pm view on Meta::CPAN
Finally, based on a mixed contig spectrum, a cross contig spectrum can
be determined. In a cross contig spectrum, only contigs containing
sequences from different metagenomes are kept; "pure" contigs are
excluded. Additionally, the total number of singletons (1-contigs)
from each region that assembles with any fragments from other regions
is the number of 1-contigs in the cross contig spectrum.
=head2 Implementation
The simplest representation of a contig spectrum is as a hash
BioX-CLPM
view release on metacpan or search on metacpan
lib/BioX/CLPM/Engine.pm view on Meta::CPAN
my %sequences_of :ATTR( :get<sequences> :set<sequences> :default<[]> :init_arg<sequences> );
my %enzyme_of :ATTR( :get<enzyme> :set<enzyme> :default<''> :init_arg<enzyme> );
my %linker_of :ATTR( :get<linker> :set<linker> :default<''> :init_arg<linker> );
my %peaks_of :ATTR( :get<peaks> :set<peaks> :default<''> :init_arg<peaks> );
my %matches_of :ATTR( :get<matches> :set<matches> :default<''> :init_arg<matches> );
my %fragments_of :ATTR( :get<fragments> :set<fragments> :default<''> :init_arg<fragments> );
my %tolerance_of :ATTR( :get<tolerance> :set<tolerance> :default<''> :init_arg<tolerance> );
my %missed_clvg_of :ATTR( :get<missed_clvg> :set<missed_clvg> :default<''> :init_arg<missed_clvg> );
my %var_mod_of :ATTR( :get<var_mod> :set<var_mod> :default<''> :init_arg<var_mod> );
my %stat_mod_of :ATTR( :get<stat_mod> :set<stat_mod> :default<''> :init_arg<stat_mod> );
#my %attribute_of :ATTR( :get<attribute> :set<attribute> :default<''> :init_arg<attribute> );
lib/BioX/CLPM/Engine.pm view on Meta::CPAN
}
# Mark linking aa's
$self->mark_links();
# Cleave sequence into fragments
$self->cleave();
# Calculate masses
$self->masses();
lib/BioX/CLPM/Engine.pm view on Meta::CPAN
my ( $self, $arg_ref ) = @_;
my $enzyme = $self->get_enzyme();
my $linker = $self->get_linker();
my $missed_clvg = $self->get_missed_clvg();
my @sequences = defined $arg_ref->{sequences} ? @{ $arg_ref->{sequences} } : $self->sequences();
my @fragments;
warn "ENGINE cleave() \n";
my $last_index = 1;
for ( my $i = 0; $i < @sequences; $i++ ) {
@fragments = $self->_cleave({ sequence => $sequences[$i], enzyme => $enzyme });
@fragments = $self->_missed({ fragments => \@fragments, missed_clvg => $missed_clvg });
@fragments = $self->_filter({ fragments => \@fragments, index => $i });
#warn " setting fragments " . join( ', ', @fragments ) . "\n";
my $fragments = BioX::CLPM::Fragments->new({ sequence_id => $sequences[$i]->get_sequence_id(), index => $last_index, type => 'simple' });
foreach my $fragment ( @fragments ) { $fragments->add({ sequence => $fragment }); }
$sequences[$i]->set_fragments( $fragments->get_list() );
$last_index = $fragments->get_index();
}
$self->set_sequences( \@sequences );
return \@sequences;
}
lib/BioX/CLPM/Engine.pm view on Meta::CPAN
my ( $self, $arg_ref ) = @_;
my %var_mods = defined $arg_ref->{var_mod} ? %{ $arg_ref->{var_mod} } : $self->var_mods();
my @sequences = defined $arg_ref->{sequences} ? @{ $arg_ref->{sequences} } : $self->sequences();
my $aa_masses = $self->_stat_mod();
foreach my $sequence ( @sequences ) {
my @fragments = $sequence->fragments();
for ( my $i = 0; $i < @fragments; $i++ ) {
my $sequence = $fragments[$i]->get_sequence();
my @sequence = split( //, $sequence );
my $counts = {};
my $mass = 0;
foreach my $aa ( @sequence ) {
$aa = uc($aa);
$mass += $aa_masses->{$aa};
$counts->{$aa}++;
}
# Add mass of 1 molecule of water
$mass += 18.010565;
$fragments[$i]->set_mass( $mass );
# Keep counts for aa's affected by var_mod
my $keepers = {};
foreach my $var_mod ( keys %var_mods ) {
$keepers->{$var_mod} = $counts->{$var_mod};
}
$fragments[$i]->set_counts( $keepers );
}
$sequence->set_fragments( \@fragments );
}
$self->set_sequences( \@sequences );
return \@sequences;
}
lib/BioX/CLPM/Engine.pm view on Meta::CPAN
my ( $self, $arg_ref ) = @_;
my $list1 = defined $arg_ref->{list1} ? $arg_ref->{list1} : [];
my $list2 = defined $arg_ref->{list2} ? $arg_ref->{list2} : [];
my $type = defined $arg_ref->{type} ? $arg_ref->{type} : '';
my $linker = defined $arg_ref->{linker} ? $arg_ref->{linker} : $self->get_linker();
foreach my $frag1 ( @$list1 ) {
foreach my $frag2 ( @$list2 ) {
my $fragments = BioX::CLPM::Fragments->new({ type => 'linked' });
$fragments->add({ fragment_id_1 => $frag1->get_fragment_id(),
fragment_id_2 => $frag2->get_fragment_id(),
mass => $frag1->{mass} + $frag2->{mass} + $linker->get_mass() });
}
}
}
# PRIV
lib/BioX/CLPM/Engine.pm view on Meta::CPAN
my $rule = join( '', @chars );
my $sequence_str = $sequence->get_cl_sequence();
my @sequence_chars = split( //, $sequence_str );
my $cut = 0;
my ( $fragment, @fragments );
for ( my $i = 0; $i < @sequence_chars; ++$i ){
my $aa = $sequence_chars[$i];
$cut = 0;
$fragment .= $aa;
foreach my $clvg_site( $enzyme->clvg_sites() ){
if ( uc( $aa ) eq $clvg_site ){
my $next_chars = @sequence_chars[$i+1..$i+$length];
unless ( uc( $next_chars ) eq $rule ){
push( @fragments, $fragment );
$fragment='';
}
$cut = 1;
}
}
}
if ( !$cut ) { push( @fragments, $fragment ); }
return @fragments;
}
# PRIV
sub _missed {
my ( $self, $arg_ref ) = @_;
my @fragments = defined $arg_ref->{fragments} ? @{ $arg_ref->{fragments} } : ();
my $missed_clvg = defined $arg_ref->{missed_clvg} ? $arg_ref->{missed_clvg} : 0;
my ( @results, $k );
for ( my $i = $missed_clvg + 1; $i > 1; $i-- ) {
for ( my $j = 0; $j < @fragments - $i + 1; $j++ ) {
my $new_fragment = $fragments[$j];
for ( $k = 0; $k < $i - 1; $k++ ) {
$new_fragment .= $fragments[$j+$k+1];
}
while ( $new_fragment =~ m/[a-z]$/ and $i == $missed_clvg + 1){
if (! $fragments[$j+$k+1] ) { last; }
$new_fragment .= $fragments[$j+$k+1];
$k++;
}
push( @results, $new_fragment );
}
}
push( @fragments, @results );
return @fragments;
}
# PRIV
sub _filter {
my ( $self, $arg_ref ) = @_;
my @fragments = defined $arg_ref->{fragments} ? @{ $arg_ref->{fragments} } : ();
push @fragments, my $final_fragment = pop @fragments;
my $linker = defined $arg_ref->{linker} ? $arg_ref->{linker} : $self->get_linker();
my $index = defined $arg_ref->{index} ? $arg_ref->{index} : 0;
my @ends = $linker->ends();
my $end = $ends[$index];
my @results;
foreach my $fragment ( @fragments ) {
if ( $end ) { if ( $self->_has_lc($fragment) ){ if ( $self->_has_uc_last($fragment) or ( $fragment =~ m/$final_fragment$/ ) ) { push @results, $fragment; } } }
else { if ( $self->_has_uc_last($fragment) or ( $fragment =~ m/$final_fragment$/ ) ) { push @results, $fragment; } }
}
return @results;
}
# PRIV
lib/BioX/CLPM/Engine.pm view on Meta::CPAN
# UTIL
sub db_trunc {
my ( $self ) = @_;
warn "ENGINE db_trunc() \n";
$self->sqlexec("truncate table sequences");
$self->sqlexec("truncate table fragments");
$self->sqlexec("truncate table final_fragment_masses");
$self->sqlexec("truncate table run_data");
$self->sqlexec("truncate table file_masses");
$self->sqlexec("truncate table results");
$self->sqlexec("truncate table precursor_masses");
}
lib/BioX/CLPM/Engine.pm view on Meta::CPAN
# Create engine
my $engine = BioX::CLPM::Engine->new( $params );
my @sequences = $engine->sequences();
foreach my $sequence ( @sequences ) {
my @fragments = $sequence->fragments();
foreach my $fragment ( @fragments ) {
my %counts = %{ $fragment->get_counts() };
}
}
my $mass = $engine->linker()->get_mass();
Bioinf
view release on metacpan or search on metacpan
@name_types=($each_seq_name, $each_seq_name_range);
}else{
@name_types=($each_seq_name);
}
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Here I take chars from the sequ names, as dirs have fragments of chars
#_______________________________________________________________________________
for($s=1; $s <= $subdir_char_size ; $s++){ ## here, number 2 indicates, I check single or 2 char sub dir names
$sub_dir_head= substr($seq_names[$j], 0, $s);
push(@poss_sub_dir_heads, "\L$sub_dir_head") if (-d "\L$sub_dir_head" );
push(@poss_sub_dir_heads, "\U$sub_dir_head") if (-d "\U$sub_dir_head" );
$file_name_prot_up, $file_name_low_gz, $file_name_up_gz,
$file_name_prot_low_gz, $file_name_prot_up_gz);
$each_seq_name=$list[$j];
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Here I take chars from the sequ names, as dirs have fragments of chars
#_______________________________________________________________________________
for($s=1; $s <=2 ; $s++){ ## here, number 2 indicates, I check single or 2 char sub dir names
$sub_dir_head= substr($list[$j], 0, $s);
push(@sub_dir_heads, "\L$sub_dir_head") if (-d "\L$sub_dir_head" );
push(@sub_dir_heads, "\U$sub_dir_head") if (-d "\U$sub_dir_head" );
$file_name_prot_up, $file_name_low_gz, $file_name_up_gz,
$file_name_prot_low_gz, $file_name_prot_up_gz);
$each_seq_name=$list[$j];
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Here I take chars from the sequ names, as dirs have fragments of chars
#_______________________________________________________________________________
for($s=1; $s <=2 ; $s++){ ## here, number 2 indicates, I check single or 2 char sub dir names
$sub_dir_head= substr($list[$j], 0, $s);
push(@sub_dir_heads, "\L$sub_dir_head") if (-d "\L$sub_dir_head" );
push(@sub_dir_heads, "\U$sub_dir_head") if (-d "\U$sub_dir_head" );
#______________________________________________________________
# Title : get_sequence_complexity
# Usage : print "\n", ${&get_sequence_complexity(\$seq)};
# Function : caculates the single sequence's sequence complexity
# If the seq given is larger than 20, it divides it into
# frags of 20 aa and gets the average of it.
# Example : ${&get_sequence_complexity(\$seq)};
# while $seq='TTTTTACDEFGHIKLMNPQRSTVWYAAAAACCCADFADFA'
# Warning :
# Keywords : sequence_complexity, calc_sequence_complexity,
# calc_seq_complexity, get_seq_complexity, seg
# Argument : ref. of string.
# Category :
# Version : 1.3
#--------------------------------------------------------------
sub get_sequence_complexity{
my ($complexity, @seq,$i, $j, @frag);
my $win=20;
if(ref($_[0]) eq 'ARRAY'){
@seq=@{$_[0]};
}else{
$seq=${$_[0]} || $_[0];
$seq{$seq[$i]}++;
}
@keys= keys %seq;
$complexity=@keys/@seq;
}else{
my @frag=@{÷_array(\@seq, "s=$win")};
my @complexity=();
for($i=0; $i < @frag; $i++){
my (%seq, @keys);
my @arr=@{$frag[$i]};
for($j=0; $j< @arr; $j++){
$seq{$arr[$j]}++;
}
@keys=keys %seq;
push(@complexity, @keys/$win);
my($i,$j,$c,$d,$e,$f,$g,$h,$k,$l,$m,$n,$o,$p,$q,$r,$s,$t,$u,$v,$w,$x,$y,$z);
if($debug==1){print "\n\t\@hash=\"@hash\"
\@raw_string=\"@raw_string\"\n\t\@array=\"@array\"\n\t\@num_opt=\"@num_opt\"
\@char_opt=\"@char_opt\"\n\t\@file=\"@file\"\n\t\@string=\"@string\"\n" }
#""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
my ($connect_gap, @seq_frag, %digitized, $verbose, %hash, $best_block_opt);
my $margin=3;
my $threshold=0.8;
my $min_seqlet_size=25;
$connect_gap=5;
my @vars=keys %vars;
next;
}else{
push(@RANGE, $range);
}
}
@seq_frag=&get_seq_fragments(\%hash, @RANGE,
"l=$min_seqlet_size", "$range_in_name");
return(\@seq_frag);
}
#______________________________________________________________
# Title : add_columns
return(\@out);
}
#___________________________________________________________
# Title : get_seq_fragments
# Usage : @seq_frag=&get_seq_fragments(\%msf, @RANGE);
# Function : gets sequence(string) segments with defined
# ranges.
# Example :
# %test=('seq1', '1234AAAAAAAAAAAaaaaa', 'seq2', '1234BBBBBBB');
# @range = ('1-4', '5-8');
#
# %out = %{&get_seq_fragments(\%test, \@range)};
# %out => (seq1_5-8 AAAAA
# seq2_5-8 BBBBB
# seq1_1-4 1234
# seq2_1-4 1234 )
#
# Warning :
# Keywords : get_sequence_fragments,
# Options : _ for debugging.
# # for debugging.
# l= for min seqlet length
# r for adding ranges in the seq names
#
# Returns :
# Argument :
# Category :
# Version : 1.8
#-------------------------------------------------------
sub get_seq_fragments{
#"""""""""""""""""< handle_arguments{ head Ver 4.1 >"""""""""""""""""""
my(@A)=&handle_arguments(@_);my($num_opt)=${$A[7]};my($char_opt)=${$A[8]};
my(@hash)=@{$A[0]};my(@file)=@{$A[4]};my(@dir)=@{$A[3]};my(@array)=@{$A[1]};
my(@string)=@{$A[2]};my(@num_opt)=@{$A[5]};my(@char_opt)=@{$A[6]};
my(@raw_string)=@{$A[9]};my(%vars)=%{$A[10]};my(@range)=@{$A[11]};
}
if($char_opt=~/v/){ print "\n \$char_opt is $char_opt @char_opt\n"; }
if($char_opt=~/n/){ $no_range_in_name = 1 }
if($char_opt=~/r/){ $no_range_in_name = 0 }
print "\nget_seq_fragments \$no_range_in_name is $no_range_in_name \n";
for($i=0; $i< @hash; $i++){
my (%out_frag, $frag_name, $range_start, $range_end, @out_hash);
my %seqs = %{$hash[$i]};
my @names = keys %seqs;
if(@names==1){
for($j=0; $j < @names; $j++){
my $seq_name = $names[$j];
my $seq = $seqs{$seq_name};
for($k=0; $k< @range; $k++){
my $range = $range[$k];
if($no_range_in_name==1){
$frag_name = "$seq_name";
}else{
$frag_name = "$seq_name\_$range";
}
#if(length($frag_name)>14 ){
# $frag_name ='x'."${j}_${range}";
#}
($range_start, $range_end)=$range=~/(\d+\.?\d*)\-(\d+\.?\d*)/;
my $frag_len = $range_end-$range_start+1;
if($frag_len < $min_seqlet_size){
next;
}
my $fragment = substr($seq, $range_start-1, $frag_len);
$out_frag{$frag_name}=$fragment;
}
}
push(@out_hash, \%out_frag);
}elsif(@names > 1){
for($k=0; $k< @range; $k++){
my %out_frag=();
my $range=$range[$k];
($range_start, $range_end)=$range=~/(\d+\.?\d*)\-(\d+\.?\d*)/;
my $frag_len = $range_end-$range_start+1;
if($frag_len < $min_seqlet_size){
next;
}
for($j=0; $j < @names; $j++){
my $seq_name=$names[$j];
my $seq = $seqs{$seq_name};
if($no_range_in_name==1){
$frag_name = "$seq_name";
}else{
$frag_name = "$seq_name\_$range";
}
#if(length($frag_name)>15 ){
# $frag_name ='x'."${j}_${range}";
#}
if($range_start==0){ $range_start++; } ## This is a bugfix
my $fragment = substr($seq, $range_start-1, $frag_len);
$out_frag{$frag_name}=$fragment;
}
push(@out_hash, \%out_frag);
}
}
}
if(@out_hash > 1){ return(@out_hash)
}elsif(@out_hash==1){ return($out_hash[0]) }
$ref_target_hash = shift @hash;
%target = %{$ref_target_hash};
@names = keys %target;
$name_target = $names[0];
if($name_target =~/\w+(\d+)/){ $ori_target_seq_len = length($1); }
@target_frag = split(/ +/, $target{$name_target} );
for($i =0; $i< @hash; $i ++){
%db=%{$hash[$i]};
@db_name = keys %db;
for($j=0; $j < @db_name; $j ++){
$name = $db_name[$j];
@db_frag = split( / +/, $db{$name} );
for($k=0; $k < @target_frag; $k ++){
if( ($target_frag[$k]=~/H(\d+)/i)&&($db_frag[$k]=~/H(\d+)/i) ){
$simple_match_output{$name}++;
$leng_diff = abs($1 - $2)/15;
$simple_match_output{$name} = $simple_match_output{$name}- $leng_diff;
}elsif( ($target_frag[$k]=~/E(\d+)/i)&&($db_frag[$k]=~/H(\d+)/i) ){
$simple_match_output{$name}--;
#$leng_diff = abs($1 - $2)/10;
#$simple_match_output{$name} = $simple_match_output{$name}- $leng_diff;
}elsif( ($target_frag[$k]=~/H(\d+)/i)&&($db_frag[$k]=~/E(\d+)/i) ){
$simple_match_output{$name}--;
#$leng_diff = abs($1 - $2)/10;
#$simple_match_output{$name} = $simple_match_output{$name}- $leng_diff;
}elsif( ($target_frag[$k]=~/E(\d+)/i)&&($db_frag[$k]=~/E(\d+)/i) ){
$simple_match_output{$name}++;
$leng_diff = abs($1 - $2)/15;
$simple_match_output{$name} = $simple_match_output{$name}- $leng_diff;
}
}
# If you give array of 100 elem, with 5, you will
# get 5 arrays with 20 elem each.
# Example :
# Warning :
# Keywords : split_array_into_pieces, split_array, chop_array,
# fragment_array,
# Options : s= for dividing the array with sub array size
# eg) to get 20 elem length sub arrays from
# a big array
# @ar_ref=@{÷_array(\@array, 's=20')};
# Returns :
if($size_div==1){
while(@array){
push(@final_array_ref, [splice(@array, 0, $size)]);
}
}else{
my $frag_ar_size = int(@array/$denominator);
if($debug eq 1){ print "\n Frag arr size is : $frag_ar_size \n" }
$remaining = @array % $denominator;
if($debug eq 1){ print "\n Remnant elem size is : $remaining \n" }
for($i=0; $i < $denominator; $i++){
if($remaining > 0){
push(@final_array_ref, [splice(@array, 0, ($frag_ar_size+1),)] );
$remaining --;
}elsif(($remaining == 0)&&(@array>0)){
push(@final_array_ref, [splice(@array, 0, ($frag_ar_size),)] );
}
}
}
return(\@final_array_ref);
}
for($i=0; $i< @file; $i++){
open(FILE, $file[$i]);
$base_name=${&get_base_names($file[$i])};
$extension=${&get_extension_names($file[$i])};
$total_line_num=@lines=<FILE>;
$splited_frag_size=int(@lines/$division_factor);
for($j=0; $j< $division_factor; $j++){
#$frag_file="$base_name\_s${j}\.split${j}";
$frag_file="$base_name\_s${j}\.$extension";
push(@splited_files, $frag_file);
open(FRAGMENT_FILE, ">$frag_file");
for($k=0; $k<= $splited_frag_size; $k++){
print FRAGMENT_FILE $lines[$k];
}
splice(@lines, 0, $splited_frag_size);
}
print FRAGMENT_FILE @lines; # Writing the very last remaining lines
close (FRAGMENT_FILE);
}
# split_sequence(look at separate split_sequence sub),
# Options :
# $reverse_second_half=S by S -S
# $reverse_first_half =F by F -F
# $reverse_rest =R by R -R ## reversing all except the first
# $reverse_all =A by A -A # reverse all the fragments
# Returns :
# Argument :
# Category :
# Version : 1.3
#-----------------------------------------------------------
sub split_sequence{
my(@string, $frag_str_size, $remaining, @hash, $i, $j,
@seq_names, $denominator, %input_seq, @final_hash_ref,
$frag, $reverse_second_half, $reverse_first_half,
$reverse_rest, $reverse_all);
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Checking arguments
#________________________________________________
for($k=0; $k < @seq_names; $k++){
$seq_name=$seq_names[$k];
@string = split(//, $input_seq{ $seq_name });
$frag_str_size = int(@string/$denominator);
if($debug eq 1){ print "\n Frag str size is : $frag_str_size \n" }
$remaining = @string % $denominator;
for($j=0; $j < $denominator; $j++){
$frag_number=$j+1;
if($remaining > 0){
$frag=join('', splice(@string, 0, ($frag_str_size+1) ) );
$remaining --;
$seq_name_split="$seq_name\_$frag_number";
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~```
# Before final, set the seq types
#_________________________________________________________________
if($frag_number==1 and $reverse_first_half){
$frag=reverse($frag);
$seq_name_split="$seq_name_split\_rv";
}elsif($frag_number==2 and $reverse_second_half){
$frag=reverse($frag);
$seq_name_split="$seq_name_split\_rv";
}elsif($frag_number >2 and $reverse_rest){
$frag=reverse($frag);
$seq_name_split="$seq_name_split\_rv";
}elsif($reverse_all){
$frag=reverse($frag);
$seq_name_split="$seq_name_split\_rv";
}
$out_seq{$seq_name_split}=$frag;
}elsif( $remaining == 0 and @string>0){
$seq_name_split="$seq_name\_$frag_number";
$frag=join('', splice(@string, 0, $frag_str_size,) );
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~```
# Before final, set the seq types
#_________________________________________________________________
if($frag_number==1 and $reverse_first_half){
$frag=reverse($frag);
$seq_name_split="$seq_name_split\_rv";
}elsif($frag_number==2 and $reverse_second_half){
$frag=reverse($frag);
$seq_name_split="$seq_name_split\_rv";
}elsif($frag_number >2 and $reverse_rest){
$frag=reverse($frag);
$seq_name_split="$seq_name_split\_rv";
}elsif($reverse_all){
$frag=reverse($frag);
$seq_name_split="$seq_name_split\_rv";
}
$out_seq{$seq_name_split}=$frag;
}
}
}
push(@final_hash_ref, \%out_seq);
}
# Argument :
# Category :
# Version : 1.4
#-----------------------------------------------------------
sub divide_string{
my (@array, $i, $j, $denominator, @temp, @string, $frag_str_size,
$remaining, $frag);
for($i=0; $i< @_; $i++){
if(ref($_[$i]) eq 'ARRAY'){
push(@array, @{$_[$i]});
}elsif(ref($_[$i]) eq 'SCALAR'){
$denominator = 1;
}
for($i=0; $i< @array; $i++){
my @temp;
my @string = split(//, $array[$i]);
$frag_str_size = int(@string/$denominator);
if($debug eq 1){ print "\n Frag str size is : $frag_str_size \n" }
$remaining = @string % $denominator;
for($j=0; $j < $denominator; $j++){
if($remaining > 0){
$frag=join('', splice(@string, 0, ($frag_str_size+1) ) );
push(@temp, $frag);
$remaining --;
}elsif( $remaining == 0 and @string>0){
$frag=join('', splice(@string, 0, $frag_str_size,) );
push(@temp, $frag);
}
}
push(@final_array_ref, \@temp);
}
wantarray? \@final_array_ref : $final_array_ref[0];
# Argument :
# Category :
# Version : 1.1
#-----------------------------------------------------------
sub make_template_from_sec_str{
my(%out, @name, @fragments, %in, $name, $leng, $frag_seq, $name2);
#""""""""""""""""""""""< handle_arguments{ head Ver 1.1 >""""""""""""""""""""""""""""""""
my(@A ) = &handle_arguments( @_ ); my( $num_opt )=${$A[7]};my( $char_opt )=${$A[8]};
my(@hash) =@{$A[0]};my(@file) =@{$A[4]};my(@dir ) =@{$A[3]};my(@array)=@{$A[1]};
my(@string)=@{$A[2]};my(@num_opt)=@{$A[5]};my(@char_opt)=@{$A[6]};my(@raw_string)=@{$A[9]};
my($i, $j, $c, $d, $e, $f, $g, $h, $k, $l, $p, $q, $r, $s, $t, $u, $v, $w, $x,$y,$z);
$name = $name[$t];
print "\$name is $name\n", if($debug eq 1);
$leng=length($in{$name});
print "$leng\n", if($debug eq 1);
$name2 ="$name"."$leng"; # to attach sequence length
@fragments = split(/_+/, $in{$name});
print "\@fragments is @fragments\n", if($debug eq 1);
for($i = 0; $i < @fragments; $i++){
if($fragments[$i] =~/(\w)\w+/){
$fraglength = length($fragments[$i]);
$frag_seq .= "$1"."$fraglength "; # space is delimiter 'H5 E3 E5 E4'
print "\$frag_seq is $frag_seq\n", if($debug eq 1);
}
$out{$name2}=$frag_seq;
}
}
}
return(\%out);
}
}
close FILE_1;
}
if(defined(@range)){
%seq_fragments=%{&get_seq_fragments(\%sequence, \@range)};
return(\%seq_fragments);
}elsif($char_opt=~/s/i){ # when SIZE return only option is set
@seq_Names=keys %sequence;
for($i=0; $i < @seq_Names; $i++){
$Sizes{$seq_Names[$i]}=length($sequence{$seq_Names[$i]});
}
#""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
my (%sequence, %na_sequence, %HASH, @Keys, $seq_found1,
$S_start, $S_end, $seq_found,
$present_seq, @seq_Names, %Sizes, $bare_seq_name, $fasta_seq_idx_file,
%seq_fragments, $get_protein_seq, $reverse_seq, $translation_found);
$get_nucleic_acid_seq='n';
if($char_opt=~/r/){ $reverse_seq='r' }
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`~~~~~~~~~~~~~~~~~~~~~`
# (3) When ranges information is given(via \@range), seq in those ranges are returned
#______________________________________________________________________________________
if(defined(@range)){
%seq_fragments=%{&get_seq_fragments(\%sequence, \@range)};
if($reverse_seq){
%seq_fragments=%{&reverse_sequences(\%seq_fragments)};
}
return(\%seq_fragments);
}
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
# (4) When only size is asked with -s option
#_____________________________________________________________________________
elsif($char_opt=~/s/){ # when SIZE(length of seq) return only option is set
\@char_opt=\"@char_opt\"\n\t\@file=\"@file\"\n\t\@string=\"@string\"\n" }
#""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
my (%sequence, %HASH, @Keys, $seq_found1, $S_start, $S_end, $seq_found,
$present_seq, @seq_Names, %Sizes, $bare_seq_name, $fasta_seq_idx_file,
%seq_fragments, $reverse_seq);
if($char_opt=~/r/){ $reverse_seq='r' }
if(@file<1){
print "\n \@file has less than 1 elem. There is no fileinput for open_fasta_files\n";
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`~~~~~~~~~~~~~~~~~~~~~`
# (3) When ranges information is given(via \@range), seq in those ranges are returned
#______________________________________________________________________________________
if(defined(@range)){
%seq_fragments=%{&get_seq_fragments(\%sequence, \@range)};
if($reverse_seq){
%seq_fragments=%{&reverse_sequences(\%seq_fragments)};
}
return(\%seq_fragments);
}
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
# (4) When only size is asked with -s option
#_____________________________________________________________________________
elsif($char_opt=~/s/){ # when SIZE(length of seq) return only option is set
\@char_opt=\"@char_opt\"\n\t\@file=\"@file\"\n\t\@string=\"@string\"\n" }
#""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
#$| = 1;
my($sort_seq_names, $string, $string_leng, $na,$out_file_name_provided,
$write_pure_seq_only, $show_coil_region, %one_to_three, $each_reliability,
$each_seq_fragment, $each_str_fragment, $end_seq_point, $each_reliability_frag,
$protein_name, $omit_coil_region, $ext, $graphical_rep_of_str,
$show_on_screen_only, $seq_block_size);
my($output_file) ='default_out.pred'; ### when no output file name is given, this is used
$protein_name='pred_temp_name';
my $seq_block_size=80;
$sec_str=~s/[Cc]/~/g;
$sec_str=~s/_/ /g;
}
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~``
# writing down the 80 residue seq fragment
#______________________________________________________
$seq_ruler_line=' . . . . . . . .';
for($i=0; $i< @keys; $i+= $seq_block_size){
$each_seq_ruler_line=substr($seq_ruler_line, 0, @keys-$i-1);
$each_seq_fragment=substr($residue, $i, $seq_block_size);
$each_str_fragment=substr($sec_str, $i, $seq_block_size);
$end_seq_point=$i+length($each_seq_fragment);
unless($show_on_screen_only){
printf PRED_WRITE ("%5s %-${seq_block_size}s %-5s\n", ' ', $each_seq_ruler_line, ' ');
printf PRED_WRITE ("%5s %-${seq_block_size}s %-5s\n", $i+1, $each_seq_fragment, $end_seq_point);
}else{
printf ("%5s %-${seq_block_size}s %-5s\n", ' ', $each_seq_ruler_line, ' ');
printf ("%5s %-${seq_block_size}s %-5s\n", $i+1, $each_seq_fragment, $end_seq_point);
}
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# if you want to put reliability index line
#____________________________________________
if($put_reliability_line){
$each_reliability_frag=substr($reliability, $i, $seq_block_size);
if(! $show_on_screen_only){
printf PRED_WRITE ("%5s %-${seq_block_size}s %-5s\n", ' ', $each_str_fragment, ' ');
printf PRED_WRITE ("%5s %-${seq_block_size}s %-5s\n\n", ' ', $each_reliability_frag, ' ');
}else{
printf ("%5s %-${seq_block_size}s %-5s\n", ' ', $each_str_fragment, ' ');
printf ("%5s %-${seq_block_size}s %-5s\n\n", ' ', $each_reliability_frag, ' ');
}
}else{
if(! $show_on_screen_only){
printf PRED_WRITE ("%5s %-${seq_block_size}s %-5s\n\n", ' ', $each_str_fragment, ' ');
}else{
printf ("%5s %-${seq_block_size}s %-5s\n\n", ' ', $each_str_fragment, ' ');
}
}
}
close PRED_WRITE unless $show_on_screen_only;
splice(@hash, $n, 1); $n--;
#__________________________________________________________________________
# Title : open_hmmls_files
# Usage : %out=%{&open_hmmls_files(\@file)};
# Function : hmmls matches the full length model to target seq. while, hmmfs
# does for fragments as well.
# Example :
# Keywords :
# Options :
# t=$thresh for bits score threshold
# e=$evalue_thresh for bits score threshold
}
}
close FILE_1;
}
if(defined(@range)){
%seq_fragments=%{&get_seq_fragments(\%sequence, \@range)};
return(\%seq_fragments);
}elsif($char_opt=~/s/i){ # when SIZE return only option is set
@seq_Names=keys %sequence;
for($i=0; $i < @seq_Names; $i++){
$Sizes{$seq_Names[$i]}=length($sequence{$seq_Names[$i]});
}
if($simple_default_out_flag >=1){ %matched_seq=%simple_default_output; }
if($simple_default_out_flag > 1){ print "\n# You have asked me to open more than one file. I merge output into one hash\n"; }
if(defined(@range) && ($char_opt !~ /n/)){ ## m opt is for matched seq names only
%seq_fragments=%{&get_seq_fragments(\%matched_seq, \@range)};
return(\%seq_fragments);
}elsif($char_opt=~/s/){ # when SIZE return only option is set
@seq_Names=keys %matched_seq;
for($i=0; $i<@seq_Names; $i++){
$Sizes{$seq_Names[$i]}=length($matched_seq{$seq_Names[$i]});
}
Bison
view release on metacpan or search on metacpan
lib/Bison.pm view on Meta::CPAN
}
=head2 drop_bad_tcp_flags
Catches any malicious TCP packets into a badflags chain, then prefixes the log as that chain.
Should help prevent force fragment and XMAS packets. Also checks to make sure new TCP connections
are SYN packets.
This section could do with a bit more work, but this is still a beta release :)
=cut
Bit-Vector
view release on metacpan or search on metacpan
your machine.
Therefore, you should only use these methods if you are B<ABSOLUTELY CERTAIN>
that portability of your code is not an issue!
Note that you can use arbitrarily large chunks (i.e., fragments of bit vectors)
of up to 32 bits B<IN A PORTABLE WAY> using the methods whose names begin with
"C<Chunk_>".
=item *
adding two very large positive numbers or when adding two (by
their absolute value) very large negative numbers. See also
further below.
The carry in- and output is needed mainly for cascading, i.e.,
to add numbers that are fragmented into several pieces.
Example:
# initialize
significant bit) of the result is wrong. This can happen when
subtracting a very large negative number from a very large
positive number or vice-versa. See also further below.
The carry in- and output is needed mainly for cascading, i.e.,
to subtract numbers that are fragmented into several pieces.
Example:
# initialize
BlankOnDev
view release on metacpan or search on metacpan
seperti berikut :
# Configuration for the rng-tools initscript
# $Id: rng-tools.default,v 1.1.2.5 2008-06-10 19:51:37 hmh Exp $
# This is a POSIX shell fragment
# Set to the input source for random data, leave undefined
# for the initscript to attempt auto-detection. Set to /dev/null
# for the viapadlock driver.
#HRNGDEVICE=/dev/hwrng
Bluesky
view release on metacpan or search on metacpan
lib/Bluesky.pm view on Meta::CPAN
#
method _at_for ($method) {
if ( $method =~ /^chat\.bsky\./ ) {
# Chat requests are proxied via the PDS.
# Service ID fragment (#bsky_chat) is required.
say '[DEBUG] [Bluesky] Proxying chat request...' if $ENV{DEBUG};
$self->at->http->at_protocol_proxy('did:web:api.bsky.chat#bsky_chat');
return $at;
}
Boost-Geometry-Utils
view release on metacpan or search on metacpan
src/boost/config/compiler/intel.hpp view on Meta::CPAN
#endif
//
// Verify that we have actually got BOOST_NO_INTRINSIC_WCHAR_T
// set correctly, if we don't do this now, we will get errors later
// in type_traits code among other things, getting this correct
// for the Intel compiler is actually remarkably fragile and tricky:
//
#ifdef __cplusplus
#if defined(BOOST_NO_INTRINSIC_WCHAR_T)
#include <cwchar>
template< typename T > struct assert_no_intrinsic_wchar_t;
Boost-Graph
view release on metacpan or search on metacpan
include/boost/concept_check.hpp view on Meta::CPAN
TT j(i);
(void)*i; // require dereference operator
#ifndef BOOST_NO_STD_ITERATOR_TRAITS
// require iterator_traits typedef's
typedef typename std::iterator_traits<TT>::difference_type D;
// Hmm, the following is a bit fragile
//function_requires< SignedIntegerConcept<D> >();
typedef typename std::iterator_traits<TT>::reference R;
typedef typename std::iterator_traits<TT>::pointer P;
typedef typename std::iterator_traits<TT>::iterator_category C;
function_requires< ConvertibleConcept<C, std::input_iterator_tag> >();
Bootylicious
view release on metacpan or search on metacpan
lib/Bootylicious/Plugin/BootyHelpers.pm view on Meta::CPAN
link_to_full_content => sub {
my $self = shift;
my ($article, $preview_link) = @_;
my $href = $self->href_to_article($article);
$href->fragment('cut');
return $self->link_to($href => sub {$preview_link});
}
);
$app->helper(
lib/Bootylicious/Plugin/BootyHelpers.pm view on Meta::CPAN
$app->helper(
href_to_comments => sub {
my $self = shift;
my $article = shift;
return $self->href_to_article($article)->fragment('comments');
}
);
$app->helper(
href_to_comment => sub {
my $self = shift;
my $comment = shift;
return $self->href_to_article($comment->article)
->fragment('comment-' . $comment->number);
}
);
$app->helper(
link_to_comment => sub {
lib/Bootylicious/Plugin/BootyHelpers.pm view on Meta::CPAN
my $article = shift;
my $href = $self->href_to_article($article);
return $self->link_to(
$href->fragment('comment-form') => sub {'No comments'})
unless $article->comments->size;
return $self->link_to($href->fragment('comments') =>
sub { 'Comments (' . $article->comments->size . ') '; });
}
);
$app->helper(
Bot-BasicBot-Pluggable-Module-Collection
view release on metacpan or search on metacpan
inc/Spiffy.pm view on Meta::CPAN
? '{}'
: default_as_code($default);
my $code = $code{sub_start};
if ($args->{-init}) {
my $fragment = $args->{-weak} ? $code{weak_init} : $code{init};
$code .= sprintf $fragment, $field, $args->{-init}, ($field) x 4;
}
$code .= sprintf $code{set_default}, $field, $default_string, $field
if defined $default;
$code .= sprintf $code{return_if_get}, $field;
$code .= sprintf $code{set}, $field;
( run in 1.529 second using v1.01-cache-2.11-cpan-b16cb0d3907 )