Result:
found more than 461 distributions - search limited to the first 2001 files matching your query
( run in 1.295 )
Algorithm-HITS-Lite
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
my $cwd = Cwd::cwd();
my $sym = "${who}::AUTOLOAD";
$sym->{$cwd} = sub {
my $pwd = Cwd::cwd();
if ( my $code = $sym->{$pwd} ) {
# delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
$$sym =~ /([^:]+)$/ or die "Cannot autoload $who - $sym";
unshift @_, ($self, $1);
goto &{$self->can('call')} unless uc($1) eq $1;
Algorithm-Heapify-XS
view release on metacpan or search on metacpan
lib/Algorithm/Heapify/XS.pm view on Meta::CPAN
# This allows declaration:
# use Algorithm::Heapify::XS ':all';
our %EXPORT_TAGS = (
'all' => [
'heap_parent_idx',
'heap_left_child_idx',
'heap_right_child_idx',
map { ("min_$_", "max_$_","minstr_$_","maxstr_$_") }
(
'heapify',
lib/Algorithm/Heapify/XS.pm view on Meta::CPAN
our $VERSION = '0.04';
require XSLoader;
XSLoader::load('Algorithm::Heapify::XS', $VERSION);
sub heap_parent_idx($) {
die "index must be non-negative" if $_[0] < 0;
return $_[0] ? int(($_[0] - 1) / 2) : undef;
}
sub heap_left_child_idx($) {
lib/Algorithm/Heapify/XS.pm view on Meta::CPAN
=head1 DESCRIPTION
A heap is an array based data structure where the array is treated as a balanced tree
of items where each item obeys a given inequality constraint with its parent and children,
but not with its siblings. This allows it to be put into "nearly" sorted order more
efficiently than an actual sort would.
This data structure has a number of nice properties:
a) the tree does not require "child" pointers, but instead infers parent/child
relationships from their position in the array. The parent of a node i is defined to
reside in position int((i-1)/2), and the left and right children of a node i reside in
position (i*2+1) and (i*2+2) respectively.
b) "heapifying" an array is O(N) as compared to N * log2(N) for a typical sort.
lib/Algorithm/Heapify/XS.pm view on Meta::CPAN
If the weight of a specific item in a heapified array has changed, this function will
adjust its position in the tree, and return the resulting new "top" (min/max) value.
If $idx is outside the array does nothing.
=item $idx= heap_parent_idx($idx)
Returns the defined location for the node residing at index $idx in a heap, or undef if the $idx is 0.
=item $idx= heap_left_child_idx($idx)
Algorithm-IncludeExclude
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
my $cwd = Cwd::cwd();
my $sym = "${who}::AUTOLOAD";
$sym->{$cwd} = sub {
my $pwd = Cwd::cwd();
if ( my $code = $sym->{$pwd} ) {
# delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
$$sym =~ /([^:]+)$/ or die "Cannot autoload $who - $sym";
unshift @_, ($self, $1);
goto &{$self->can('call')} unless uc($1) eq $1;
Algorithm-KernelKMeans
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
my $cwd = Cwd::cwd();
my $sym = "${who}::AUTOLOAD";
$sym->{$cwd} = sub {
my $pwd = Cwd::cwd();
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
Algorithm-Kmeanspp
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
my $cwd = Cwd::cwd();
my $sym = "${who}::AUTOLOAD";
$sym->{$cwd} = sub {
my $pwd = Cwd::cwd();
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
$$sym =~ /([^:]+)$/ or die "Cannot autoload $who - $sym";
my $method = $1;
if ( uc($method) eq $method ) {
Algorithm-LBFGS
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
my $cwd = Cwd::cwd();
my $sym = "${who}::AUTOLOAD";
$sym->{$cwd} = sub {
my $pwd = Cwd::cwd();
if ( my $code = $sym->{$pwd} ) {
# delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
$$sym =~ /([^:]+)$/ or die "Cannot autoload $who - $sym";
unshift @_, ($self, $1);
goto &{$self->can('call')} unless uc($1) eq $1;
Algorithm-LDA
view release on metacpan or search on metacpan
lib/Algorithm/LDA.pm view on Meta::CPAN
use strict;
use warnings FATAL => 'all';
use constant pi => 4*atan2(1, 1);
use constant e => exp(1);
use parent qw/Class::Accessor::Fast/;
use List::Util qw(shuffle sum max);
use List::MoreUtils qw(uniq first_index);
use JSON::XS;
Algorithm-LibLinear
view release on metacpan or search on metacpan
lib/Algorithm/LibLinear/Types.pm view on Meta::CPAN
use Types::Standard qw/Dict Int Map Num/;
my $Feature = __PACKAGE__->add_type(
constraint => q!List::MoreUtils::all { $_ > 0 } keys %$_!,
name => 'Feature',
parent => Map[Int, Num],
);
__PACKAGE__->add_type(
name => 'FeatureWithLabel',
parent => Dict[ feature => $Feature, label => Num ],
);
1;
Algorithm-Line-Lerp
view release on metacpan or search on metacpan
opmethod_stash|5.021007||Viu
OpMORESIB_set|5.021011|5.003007|p
OP_NAME|5.007003|5.007003|
op_null|5.007002|5.007002|
OPpALLOW_FAKE|5.015006||Viu
op_parent|5.025001|5.025001|n
OPpARG1_MASK|5.021004||Viu
OPpARG2_MASK|5.021004||Viu
OPpARG3_MASK|5.021004||Viu
OPpARG4_MASK|5.021004||Viu
OPpARGELEM_AV|5.025004||Viu
#ifndef OpMORESIB_set
# define OpMORESIB_set(o, sib) ((o)->op_sibling = (sib))
#endif
#ifndef OpLASTSIB_set
# define OpLASTSIB_set(o, parent) ((o)->op_sibling = NULL)
#endif
#ifndef OpMAYBESIB_set
# define OpMAYBESIB_set(o, sib, parent) ((o)->op_sibling = (sib))
#endif
#ifndef HEf_SVKEY
# define HEf_SVKEY -2
#endif
Algorithm-LineSegments
view release on metacpan or search on metacpan
0.04 March 2013
- https://rt.cpan.org/Ticket/Display.html?id=94055 should be
fixed using Test::Deeply now.
0.03 March 2013
- Floating point number serialisation apparently differs among
platforms, making a test fail; attempt to address that.
0.02 March 2014
- Removed accidental debug print
Algorithm-Loops
view release on metacpan or search on metacpan
lib/Algorithm/Loops.pm view on Meta::CPAN
Note also that by importing Filter via the C<use> statement:
use Algorithm::Loops qw( Filter );
it gets declared before the rest of our code is compiled so we don't have
to use parentheses when calling it. We I<can> if we want to, however:
my @copy= Filter( sub {s/\s/_/g}, @list );
=head3 Note on "Function BLOCK LIST" bugs
lib/Algorithm/Loops.pm view on Meta::CPAN
may give you this error:
Array found where operator expected
which can be fixed by dropping the parentheses:
... Filter {y/aeiou/UAEIO/} @list;
So if you need or want to use parentheses when calling Filter, it is best
to also include the C<sub> keyword and the comma:
# v <--------- These ---------> v
... Filter( sub {y/aeiou/UAEIO/}, @list );
# require ^^^ <--- these ---> ^ (sometimes)
Algorithm-MOS
view release on metacpan or search on metacpan
lib/Algorithm/MOS.pm view on Meta::CPAN
package Algorithm::MOS;
# ABSTRACT: Algorithm::MOS - Calculate MOS (Mean Opinion Score)
use Carp;
use parent 'Exporter';
our @EXPORT = ('calc_mos');
sub mos {
my ( $average, $jitter, $packet_loss ) = @_
or croak 'mos( average, jitter, packet_loss )';
Algorithm-MinPerfHashTwoLevel
view release on metacpan or search on metacpan
op_free|||
op_integerize|||
op_linklist||5.013006|
op_lvalue_flags|||
op_null||5.007002|
op_parent|||n
op_prepend_elem||5.013006|
op_refcnt_lock||5.009002|
op_refcnt_unlock||5.009002|
op_relocate_sv|||
op_sibling_splice||5.021002|n
#ifndef OpMORESIB_set
# define OpMORESIB_set(o, sib) ((o)->op_sibling = (sib))
#endif
#ifndef OpLASTSIB_set
# define OpLASTSIB_set(o, parent) ((o)->op_sibling = NULL)
#endif
#ifndef OpMAYBESIB_set
# define OpMAYBESIB_set(o, sib, parent) ((o)->op_sibling = (sib))
#endif
#ifndef HEf_SVKEY
# define HEf_SVKEY -2
#endif
Algorithm-NeedlemanWunsch
view release on metacpan or search on metacpan
Makefile.PL view on Meta::CPAN
use strict;
use warnings;
require 5.006_000; # $VERSION declaration apparently fails on 5.00505
use ExtUtils::MakeMaker;
WriteMakefile(
NAME => 'Algorithm::NeedlemanWunsch',
Algorithm-Odometer-Tiny
view release on metacpan or search on metacpan
t/Algorithm_Odometer_Tiny_Testlib.pm view on Meta::CPAN
L<http://perldoc.perl.org/perlartistic.html>.
=cut
BEGIN {
require Exporter; # "parent" pragma wasn't core until 5.10.1
our @ISA = qw/ Exporter /; ## no critic (ProhibitExplicitISA)
}
our @EXPORT = qw/ $AUTHOR_TESTS exception warns getverbatim /; ## no critic (ProhibitAutomaticExportation)
our $AUTHOR_TESTS;
Algorithm-Permute
view release on metacpan or search on metacpan
op_integerize|||
op_linklist||5.013006|
op_lvalue_flags|||
op_lvalue||5.013007|
op_null||5.007002|
op_parent|||n
op_prepend_elem||5.013006|
op_refcnt_dec|||
op_refcnt_inc|||
op_refcnt_lock||5.009002|
op_refcnt_unlock||5.009002|
#ifndef OpMORESIB_set
# define OpMORESIB_set(o, sib) ((o)->op_sibling = (sib))
#endif
#ifndef OpLASTSIB_set
# define OpLASTSIB_set(o, parent) ((o)->op_sibling = NULL)
#endif
#ifndef OpMAYBESIB_set
# define OpMAYBESIB_set(o, sib, parent) ((o)->op_sibling = (sib))
#endif
#ifndef SvRX
#if defined(NEED_SvRX)
static void * DPPP_(my_SvRX)(pTHX_ SV *rv);
Algorithm-QuadTree-XS
view release on metacpan or search on metacpan
typedef enum ShapeType ShapeType;
struct QuadTreeNode {
QuadTreeNode *children;
QuadTreeNode *parent;
DynArr *values;
double xmin, ymin, xmax, ymax;
bool has_objects;
};
{
push_array(arr, ptr);
SvREFCNT_inc(ptr);
}
QuadTreeNode* create_nodes(int count, QuadTreeNode *parent)
{
QuadTreeNode *node = malloc(count * sizeof *node);
int i;
for (i = 0; i < count; ++i) {
node[i].values = NULL;
node[i].children = NULL;
node[i].parent = parent;
node[i].has_objects = false;
}
return node;
}
if (node->children[i].has_objects) return;
}
}
node->has_objects = false;
if (node->parent != NULL) {
clear_has_objects(node->parent);
}
}
QuadTreeRootNode* create_root()
{
Algorithm-QuadTree
view release on metacpan or search on metacpan
lib/Algorithm/QuadTree.pm view on Meta::CPAN
non-Tk programs successfully. It is a classic memory/speed trade-off.
Lots of information about QTAs can be found on the web. But, very briefly,
a quadtree is a hierarchical data model that recursively decomposes a map into
smaller regions. Each node in the tree has 4 children nodes, each of which
represents one quarter of the area that the parent represents. So, the root
node represents the complete map. This map is then split into 4 equal quarters,
each of which is represented by one child node. Each of these children is now
treated as a parent, and its area is recursively split up into 4 equal areas,
and so on up to a desired depth.
Here is a somewhat crude diagram:
------------------------------
Algorithm-Retry
view release on metacpan or search on metacpan
lib/Algorithm/Retry/Constant.pm view on Meta::CPAN
our $VERSION = '0.002'; # VERSION
use strict;
use warnings;
use parent qw(Algorithm::Retry);
our %SPEC;
$SPEC{new} = {
v => 1.1,
Algorithm-SAT-Backtracking
view release on metacpan or search on metacpan
lib/Algorithm/SAT/Backtracking/DPLL.pm view on Meta::CPAN
use Data::Dumper;
use strict;
use warnings;
our $VERSION = "0.13";
# this allow to switch the parent implementation (needed for the Ordered alternative)
sub import {
my ( $class, $flag ) = @_;
if ($flag) {
eval "use base '$flag'";
}
Algorithm-SVM
view release on metacpan or search on metacpan
- SVM: Added binding for predict_values, improved memory usage
- DataSet: changed to use sparse format internally
internal format similar to what libsvm uses
added asArray function, improved memory usage
- All changes (except libsvm update which slightly changes the
learned models) are completely transparent to the user. No
changes in programs depending on this should be necessary.
0.13 Tue Jan 22 13:38:00 PDT 2008
- Updated the underlaying libsvm version to 2.85
Algorithm-Scale2x
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
my $cwd = Cwd::cwd();
my $sym = "${who}::AUTOLOAD";
$sym->{$cwd} = sub {
my $pwd = Cwd::cwd();
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
$$sym =~ /([^:]+)$/ or die "Cannot autoload $who - $sym";
my $method = $1;
if ( uc($method) eq $method ) {
Algorithm-Shape-RandomTree
view release on metacpan or search on metacpan
lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN
$self->create_branch( $stem, $level );
}
} else {
# Get the current level's parent branches
# ( i.e. the previous level's branches )
my @parent_branches = $self->filter_branches(
sub { $_->level = ( $level - 1 ) }
);
foreach my $parent ( @parent_branches ) {
# Number of sub branches
my $sub_branches = int( rand( $self->complexity ) );
# Create sub-branches for the current parent branch
foreach my $idx ( 1 .. $sub_branches ) {
$self->create_branch( $parent, $level );
}
}
}
}
lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN
return $stem;
}
# Linear algorithm's branch creation sub
sub create_branch {
my ( $self, $parent, $level ) = @_;
my $start_point = $parent->end_point;
my $verb = $self->verbose;
my ( $dx, $dy ) = $self->calc_new_deltas( $parent );
my ( $x_end, $y_end ) = $self->calc_new_endpoints(
$start_point, $dx, $dy
);
my $end_point = Algorithm::Shape::RandomTree::Branch::Point->new(
lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN
start_point => $start_point,
end_point => $end_point,
dx => $dx,
dy => $dy,
level => $level,
parent => $parent,
# nodulation => ,
# complexity => ,
);
$self->add_branch( $newbranch );
}
# Calculate New Deltas: uses the parent branch's attributes and random factors
# to modify a new branche's dx and dy values, who determin the angle and length
# of the new branch.
sub calc_new_deltas {
my ( $self, $parent ) = @_;
my $verb = $self->verbose;
# Get parent branch's deltas
my $old_dx = $parent->dx;
my $old_dy = $parent->dy;
# Calculate modifiers:
# These slightly change the dx and dy to create variation and randomness
# in branches lengths and angles.
# Modifiers range from -range_value to +range_value
lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN
);
# If the level is 0, it's the stem's children, so the falloff should be 1.5
# (so that they would still be a bit shorter than the stem).
# otherwise, it should be the level + 1
my $falloff = ( $parent->level == 0 ) ? 1.5 : $parent->level + 1;
# Apply modifiers
my $new_dx = int ( ( $old_dx + $dx_modifier ) / $falloff );
my $new_dy = int ( ( $old_dy + $dy_modifier ) / $falloff );
lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN
return( $x_end, $y_end );
}
# The recursive algorithm for creating all non-stem branches
sub create_branches_recursive {
my ( $self, $parent ) = @_;
my $verb = $self->verbose;
my $name = $parent->name;
$verb && print "[create_branches_recursive] on parent: $name\n";
# Create a new branch connected to parent
my $branch = $self->make_branch( $parent );
# Create this branche's sub-branches
if ( $branch->nodulation ) {
foreach my $idx ( 1 .. $branch->complexity ) {
$verb && print qq{
lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN
}
}
# Sub for creating single branches used by the recursive algorithm
sub make_branch {
my ( $self, $parent ) = @_;
my $start_point = $parent->end_point;
my $verb = $self->verbose;
my $name = $parent->name;
$verb && print "[make_branche] on parent: $name\n";
my ( $dx, $dy ) = $self->calc_new_deltas( $parent );
my ( $x_end, $y_end ) = $self->calc_new_endpoints(
$start_point, $dx, $dy
);
my $end_point = Algorithm::Shape::RandomTree::Branch::Point->new(
x => $x_end, y => $y_end
);
my $number = $self->count_branches + 1; # New branch's num (name)
my $nodulation = $self->calc_new_nodulation( $parent );
my $complexity = int( rand( $self->complexity ) ); # Calculate new complexity
# Calculate new width, and prevent a less than 1 width
my $falloff = ( $parent->level == 0 ) ? 1.5 : $parent->level + 1;
my $new_width = int ( $self->tree_width / $falloff );
my $width = $new_width ? $new_width : 1;
my $path_str = $self->create_path( $start_point, $end_point, $dx, $dy );
lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN
name => $number,
start_point => $start_point,
end_point => $end_point,
dx => $dx,
dy => $dy,
level => $parent->level + 1,
parent => $parent,
nodulation => $nodulation,
complexity => $complexity,
width => $width,
path_string => $path_str,
);
lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN
return $newbranch;
}
sub calc_new_nodulation {
my ( $self, $parent ) = @_;
my $verb = $self->verbose;
my $old = $parent->nodulation;
# Reduce ebbing factor from the parent's nodulation
my $new = $old - $self->ebbing_factor;
return $new;
}
Algorithm-SocialNetwork
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
my $sym = "$caller\::AUTOLOAD";
$sym->{$cwd} = sub {
my $pwd = Cwd::cwd();
if (my $code = $sym->{$pwd}) {
goto &$code unless $cwd eq $pwd; # delegate back to parent dirs
}
$$sym =~ /([^:]+)$/ or die "Cannot autoload $caller";
unshift @_, ($self, $1);
goto &{$self->can('call')} unless uc($1) eq $1;
};
Algorithm-SpatialIndex-Storage-Redis
view release on metacpan or search on metacpan
lib/Algorithm/SpatialIndex/Storage/Redis.pm view on Meta::CPAN
our $VERSION = '0.01';
use Scalar::Util qw(blessed);
use Redis;
use parent 'Algorithm::SpatialIndex::Storage';
use Sereal::Encoder;
use Sereal::Decoder;
use Class::XSAccessor {
getters => {
Algorithm-SpatialIndex-Strategy-MedianQuadTree
view release on metacpan or search on metacpan
lib/Algorithm/SpatialIndex/Strategy/MedianQuadTree.pm view on Meta::CPAN
use Carp qw(croak);
our $VERSION = '0.02';
use Algorithm::SpatialIndex::Strategy::QuadTree qw(:all);
use parent 'Algorithm::SpatialIndex::Strategy::QuadTree';
use Statistics::CaseResampling qw(median);
sub _node_split_coords {
my ($self, $node, $bucket, $coords) = @_;
Algorithm-SpatialIndex
view release on metacpan or search on metacpan
lib/Algorithm/SpatialIndex/Storage/DBI.pm view on Meta::CPAN
use warnings;
use Carp qw(croak);
our $VERSION = '0.02';
use parent 'Algorithm::SpatialIndex::Storage';
use constant DEBUG => 0;
=head1 NAME
Algorithm::SpatialIndex::Storage::DBI - DBI storage backend
Algorithm-Tree-NCA
view release on metacpan or search on metacpan
use 5.006;
use strict;
use warnings;
use fields qw(_run _magic _number _parent _leader _max _node);
sub new ($%) {
my $class = shift;
# Default values first, then the provided parameters
my %args = (_run => 0, # Corresponds to I(v)
_magic => 0, # Corresponds to A_v
_max => 0, # Maximum number assigned to subtree
_number => 0, # The DFS number assigned to this node
_parent => undef, # The parent node data for this node
_leader => undef, # The leader node data for this node
_node => undef, # The node that the data is for
@_);
my $self = fields::new($class);
# Computing magic number and leaders
$self->_compute_magic($root, $self->_data($root), 0);
}
# Enumerate each node of the tree with a number v and compute the run
# I(v) for each node. Also set the parent for each node.
sub _enumerate ($$$;$) {
my($self,$node,$number,$parent) = @_;
my $data = Algorithm::Tree::NCA::Data
->new(_node => $node,
_run => $number,
_parent => $parent,
_number => $number);
$self->{_data}->[$number] = $data;
$self->_set($node,$number);
# Form the number u consisting of the bits of I(x) to the left
# of position k, followed by a 1-bit in position k, followed by
# all zeroes. (u will be I(w))
my $u = ~(($k - 1) | $k) & $xd->{_run} | $k;
# Look up node L(I(w)), which must be node w. nx is then the parent
# of node w.
my $wd = $self->{_data}->[$u]->{_leader};
return $wd->{_parent};
}
sub nca ($$$) {
my($self,$x,$y) = @_;
=item -
A I<magic> number (L<"ALGORITHM">)
=item -
The I<parent> node for each node
=item -
The I<maximum> number assigned to a any node in the subtree
=back
ComputeMagic(root,root,0);
End;
In the first phase, we enumerate the tree, compute the I<run> for each
node, the I<max> number assigned to a node in the subtree, and also
the I<parent> of each node. If the parent is already available through
other means, that part is redundant. The run of a node is the number
of the node in the subtree with the largest height.
Function Enumerate(node,parent:Node; num:Integer) : (Integer,Integer)
Var run : Integer;
Begin
node.parent := parent;
node.number := num;
node.run := num;
run := num;
num := num + 1;
l := LSSB(n.magic);
If l = j Then Return x
k := MSSB((j - 1) AND x.magic);
u := ((NOT ((k - 1) OR k)) AND x.run) OR k
w := Leader(u);
Return w.parent; (* z = w.parent *)
End;
=head1 REFERENCES
=over 4
Algorithm-VSM
view release on metacpan or search on metacpan
examples/corpus_with_java_and_cpp/CrazyWindow.cc view on Meta::CPAN
#include "MyTextPanel.h"
#include "MyDrawPanel.h"
CrazyWindow::CrazyWindow( QWidget* parent, const char* name ) // (B)
: QWidget( parent, name )
{
QGridLayout* grid = new QGridLayout( this, 0, 1 ); // (C)
MyTextPanel* textPanel =
new MyTextPanel( this, "for text only" ); // (D)
( run in 1.295 second using v1.01-cache-2.11-cpan-a5abf4f5562 )