Algorithm-Evolutionary
view release on metacpan or search on metacpan
lib/Algorithm/Evolutionary/Experiment.pm view on Meta::CPAN
my $indiSize = shift || carp "Empty individual size, no reasonable default, can't create\n";
for ( my $i = 0; $i < $popSize; $i ++ ) {
my $indi = Algorithm::Evolutionary::Individual::Base::new( $indiType,
{ length => $indiSize } );
$indi->randomize();
push @{$self->{_pop}}, $indi;
}
};
@_ || croak "Can't find an algorithm";
push @{$self->{_algo}}, @_;
bless $self, $class;
return $self
}
=head2 go
Applies the different operators in the order that they appear; returns the population
as a ref-to-array.
=cut
lib/Algorithm/Evolutionary/Fitness/Any.pm view on Meta::CPAN
=head2 new( $function )
Assigns default variables
=cut
sub new {
my $class = shift;
my $self = { _function => shift || croak "No functiona rray" };
bless $self, $class;
$self->initialize();
return $self;
}
=head2 apply( $individual )
Applies the instantiated problem to a chromosome. It is actually a
wrapper around C<_apply>.
=cut
lib/Algorithm/Evolutionary/Fitness/Base.pm view on Meta::CPAN
=head2 new()
Initializes common variables, like the number of evaluations. Cache is not initialized.
=cut
sub new {
my $class = shift;
my $self = {};
bless $self, $class;
$self->initialize();
return $self;
}
=head2 initialize()
Called from new, initializes the evaluations counter.
=cut
lib/Algorithm/Evolutionary/Fitness/ECC.pm view on Meta::CPAN
Creates a new instance of the problem, with the said number of bits and peaks
=cut
sub new {
my $class = shift;
my ($number_of_codewords, $min_distance ) = @_;
croak "Too few codewords" if !$number_of_codewords;
croak "Distance too small" if !$min_distance;
my $self = $class->SUPER::new();
bless $self, $class;
$self->initialize();
$self->{'number_of_codewords'} = $number_of_codewords;
return $self;
}
=head2 _really_apply
Applies the instantiated problem to a chromosome
=cut
lib/Algorithm/Evolutionary/Fitness/P_Peaks.pm view on Meta::CPAN
my $generator = new String::Random;
my @peaks;
my $regex = "\[01\]{$bits}";
for my $s ( VARS ) {
eval "\$self->{'$s'} = \$$s";
}
for my $p ( 1..$peaks ) {
push( @peaks, $generator->randregex($regex));
}
$self->{'peaks'} = \@peaks;
bless $self, $class;
$self->initialize();
return $self;
}
=head2 random_string()
Returns random string in the same style than the peaks. Useful for testing.
=cut
lib/Algorithm/Evolutionary/Fitness/String.pm view on Meta::CPAN
=head2 new()
Initializes the cache
=cut
sub new {
my $class = shift;
my $self = { _cache => {} };
bless $self, $class;
return $self;
}
=head2 _apply( $individual )
Applies the instantiated problem to a chromosome, delegating to a specific function
=cut
sub _apply {
lib/Algorithm/Evolutionary/Fitness/Trap.pm view on Meta::CPAN
my $class = shift;
my $number_of_bits = shift || croak "Need non-null number of bits\n";
my $a = shift || $number_of_bits - 1;
my $b = shift || $number_of_bits;
my $z = shift || $number_of_bits - 1;
croak "Z too big" if $z >= $number_of_bits;
croak "Z too small" if $z < 1;
croak "A must be less than B" if $a > $b;
my $self = $class->SUPER::new();
bless $self, $class;
$self->initialize();
$self->{'l'} = $number_of_bits;
$self->{'a'} = $a;
$self->{'b'} = $b;
$self->{'z'} = $z;
return $self;
}
=head2 _really_apply
lib/Algorithm/Evolutionary/Fitness/ZDT1.pm view on Meta::CPAN
=head2 new
Creates a new instance of the problem, with the said number of bits and peaks
=cut
sub new {
my $class = shift;
my $number_of_bits = shift || croak "Need non-null number of bits\n";
my $self = { '_number_of_bits' => $number_of_bits };
bless $self, $class;
$self->initialize();
return $self;
}
=head2 _really_apply
Applies the instantiated problem to a chromosome
=cut
lib/Algorithm/Evolutionary/Fitness/wP_Peaks.pm view on Meta::CPAN
my @peaks;
my $regex = "\[01\]{$bits}";
for my $s ( qw( bits generator regex ) ) {
eval "\$self->{'$s'} = \$$s";
}
while ( @weights ) {
my $this_w = shift @weights;
push( @peaks, [$this_w, $generator->randregex($regex)]);
}
$self->{'peaks'} = \@peaks;
bless $self, $class;
$self->initialize();
return $self;
}
=head2 random_string
Returns random string in the same style than the peaks. Useful for testing
=cut
lib/Algorithm/Evolutionary/Hash_Wheel.pm view on Meta::CPAN
#Now creates the accumulated array, putting the accumulated
#probability in the first element arrayref element, and the object
#in the second
my $aux = 0;
for ( sort keys %probs ) {
push @{$self->{_accProbs}}, [$probs{$_} + $aux,$_ ];
$aux += $probs{$_};
}
bless $self, $class;
return $self;
}
=head2 spin()
Returns a single individual whose probability is related to its fitness
TODO: should return many, probably
=cut
lib/Algorithm/Evolutionary/Individual/Base.pm view on Meta::CPAN
=cut
sub new {
my $class = shift;
if ( $class !~ /Algorithm::Evolutionary/ ) {
$class = "Algorithm::Evolutionary::Individual::$class";
}
my $options = shift;
my $self = { _fitness => undef }; # Avoid error
bless $self, $class; # And bless it
#If the class is not loaded, we load it.
if ( !$INC{"$class\.pm"} ) {
eval "require $class" || croak "Can't find $class Module";
}
if ( $options ) {
$self->set( $options );
}
return $self;
lib/Algorithm/Evolutionary/Individual/Bit_Vector.pm view on Meta::CPAN
sub _create_bit_vector {
my $length = shift || croak "No length!";
my $rander = new String::Random;
my $hex_string = $rander->randregex("[0-9A-F]{".int($length/4)."}");
return Bit::Vector->new_Hex( $length, $hex_string );
}
sub TIEARRAY {
my $class = shift;
my $self = { _bit_vector => Bit::Vector->new_Bin(scalar( @_), join("",@_)) };
bless $self, $class;
return $self;
}
=head2 Atom
Sets or gets the value of the n-th character in the string. Counting
starts at 0, as usual in Perl arrays.
=cut
lib/Algorithm/Evolutionary/Individual/String.pm view on Meta::CPAN
$self->{'_length'} = shift || 10;
$self->randomize();
return $self;
}
sub TIEARRAY {
my $class = shift;
my $self = { _str => join("",@_),
_length => scalar( @_ ),
_fitness => undef };
bless $self, $class;
return $self;
}
=head2 randomize
Assigns random values to the elements
=cut
sub randomize {
lib/Algorithm/Evolutionary/Individual/String.pm view on Meta::CPAN
=head2 clone
Similar to a copy ctor: creates a new individual from another one
=cut
sub clone {
my $indi = shift || croak "Indi to clone missing ";
my $self = { '_fitness' => undef };
bless $self, ref $indi;
for ( qw( _chars _str _length) ) {
$self->{ $_ } = $indi->{$_};
}
return $self;
}
=head2 asString
Returns the individual as a string with the fitness as a suffix.
lib/Algorithm/Evolutionary/Individual/Tree.pm view on Meta::CPAN
=cut
sub new {
my $class = shift;
my $self = {_primitives => shift,
_depth => shift,
_fitness => undef };
my @keys = keys %{$self->{_primitives}};
$self->{_keys} = \@keys;
bless $self, $class;
$self->randomize();
return $self;
}
=head2 set
Sets values of an individual; takes a hash as input
=cut
lib/Algorithm/Evolutionary/Individual/Tree.pm view on Meta::CPAN
Probably useless, in this case. To be evolved.
=cut
sub fromString {
my $class = shift;
my $str = shift;
my $sep = shift || ",";
my $self = { _array => split( $sep, $str ),
_fitness => undef };
bless $self, $class;
return $self;
}
=head2 clone
Similar to a copy ctor: creates a new individual from another one
=cut
sub clone {
my $indi = shift || croak "Indi to clone missing ";
my $self = { _fitness => undef,
_depth => $indi->{_depth} };
%{$self->{_primitives}} = %{$indi->{_primitives}};
@{$self->{_keys}} = @{$indi->{_keys}};
$self->{_tree} = $indi->{_tree}->copy_tree();
bless $self, __PACKAGE__;
return $self;
}
=head2 asString
Prints it
=cut
lib/Algorithm/Evolutionary/Individual/Vector.pm view on Meta::CPAN
sub new {
my $class = shift;
my $self;
$self->{_length} = shift || 10;
$self->{_array} = ();
$self->{_rangestart} = shift || 0;
$self->{_rangeend } = shift || 1;
$self->{_fitness} = undef;
bless $self, $class;
$self->randomize();
return $self;
}
=head2 size()
Returns vector size (dimension)
=cut
sub size {
my $self = shift;
return $self->{'_length'};
}
sub TIEARRAY {
my $class = shift;
my $self = { _array => \@_,
_length => scalar( @_ ),
_fitness => undef };
bless $self, $class;
return $self;
}
=head2 set( $ref_to_hash )
Sets values of an individual; takes a hash as input. The array is
initialized to a null array, and the start and end range are
initialized by default to 0 and 1
=cut
lib/Algorithm/Evolutionary/Individual/Vector.pm view on Meta::CPAN
=cut
sub fromString {
my $class = shift;
my $str = shift;
my $sep = shift || ",";
my @ary = split( $sep, $str );
my $self = { _array => \@ary,
_fitness => undef };
bless $self, $class;
return $self;
}
=head2 clone()
Similar to a copy ctor: creates a new individual from another one
=cut
sub clone {
my $indi = shift || croak "Indi to clone missing ";
my $self = { _fitness => undef,
_length => $indi->{_length} };
$self->{_array} = ();
push(@{$self->{_array}}, @{$indi->{_array}});
bless $self, ref $indi;
die "Something is wrong " if scalar( @{$self->{_array}} ) > scalar( @{$indi->{_array}} );
return $self;
}
=head2 asString()
Returns a string with chromosome plus fitness. OK, this is a bit confusing
=cut
lib/Algorithm/Evolutionary/Op/ArithCrossover.pm view on Meta::CPAN
=head2 create()
Creates the operator, but is more or less empty. Does not have instance variables
=cut
sub create {
my $class = shift;
my $self;
bless $self, $class;
return $self;
}
=head2 apply( $chromosome_1, $chromosome_2 )
Applies xover operator to a "Chromosome", a vector of stuff,
really. Can be applied only to I<victims> with the C<_array> instance
variable; but it checks before application that both operands are of
type L<Algorithm::Evolutionary::Individual::Vector|Algorithm::Evolutionary::Individual::Vector>.
Returns the resulting chromosome
lib/Algorithm/Evolutionary/Op/Base.pm view on Meta::CPAN
=cut
sub new {
my $class = shift;
carp "Should be called from subclasses" if ( $class eq __PACKAGE__ );
my $rate = shift || 1;
my $hash = shift; #No carp here, some operators do not need specific stuff
my $self = { rate => $rate,
_arity => eval( "\$"."$class"."::ARITY" )}; # Create a reference
bless $self, $class; # And bless it
$self->set( $hash ) if $hash ;
return $self;
}
=head2 create( [@operator_parameters] )
Creates an operator via its default parameters. Probably obsolete
=cut
sub create {
my $class = shift;
my $self;
for my $p ( keys %parameters ) {
$self->{"_$p"} = shift || $parameters{$p}; # Default
}
bless $self, $class;
return $self;
}
=head2 fromXML()
Takes a definition in the shape <op></op> and turns it into an object,
if it knows how to do it. The definition must have been processed using XML::Simple.
It parses the common part of the operator, and leaves specific parameters for the
subclass via the "set" method.
lib/Algorithm/Evolutionary/Op/Base.pm view on Meta::CPAN
if ( !defined $rate && $fragment->{'-rate'} ) {
$rate = $fragment->{'-rate'};
}
my $self = { rate => $rate }; # Create a reference
if ( $class eq __PACKAGE__ ) { #Deduct class from the XML
$class = $fragment->{'-name'} || shift || croak "Class name missing";
}
$class = "Algorithm::Evolutionary::Op::$class" if $class !~ /Algorithm::Evolutionary/;
bless $self, $class; # And bless it
my (%params, %code_fragments, %ops);
for ( @{ (ref $fragment->{'param'} eq 'ARRAY')?
$fragment->{'param'}:
[ $fragment->{'param'}] } ) {
if ( defined $_->{'-value'} ) {
$params{$_->{'-name'}} = $_->{'-value'};
} elsif ( $_->{'param'} ) {
my %params_hash;
lib/Algorithm/Evolutionary/Op/Bitflip.pm view on Meta::CPAN
=head2 create()
Creates a new mutation operator.
=cut
sub create {
my $class = shift;
my $self = {};
bless $self, $class;
return $self;
}
=head2 apply( $chromosome )
Applies mutation operator to a "Chromosome", a bitstring, really. Can be
applied only to I<victims> composed of [0,1] atoms, independently of representation; but
it checks before application that the operand is of type
L<BitString|Algorithm::Evolutionary::Individual::BitString>.
lib/Algorithm/Evolutionary/Op/Breeder.pm view on Meta::CPAN
Creates a breeder, with a selector and array of operators
=cut
sub new {
my $class = shift;
my $self = {};
$self->{'_ops'} = shift || croak "No operators found";
$self->{'_selector'} = shift
|| new Algorithm::Evolutionary::Op::Tournament_Selection 2;
bless $self, $class;
return $self;
}
=head2 apply( $population[, $how_many || $population_size] )
Applies the algorithm to the population, which should have
been evaluated first; checks that it receives a
ref-to-array as input, croaks if it does not.
Returns a sorted, culled, evaluated population for next generation.
lib/Algorithm/Evolutionary/Op/Breeder_Diverser.pm view on Meta::CPAN
Creates a breeder, with a selector and array of operators
=cut
sub new {
my $class = shift;
my $self = {};
$self->{_ops} = shift || croak "No operators found";
$self->{_selector} = shift
|| new Algorithm::Evolutionary::Op::Tournament_Selection 2;
bless $self, $class;
return $self;
}
=head2 apply( $population[, $how_many || $population_size] )
Applies the algorithm to the population, which should have
been evaluated first; checks that it receives a
ref-to-array as input, croaks if it does not. Returns a sorted,
culled, evaluated population for next generation.
lib/Algorithm/Evolutionary/Op/CX.pm view on Meta::CPAN
=head2 create
Creates a new Algorithm::Evolutionary::Op::CX operator. But this is just to have a non-empty chromosome
=cut
sub create {
my $class = shift;
my $self;
$self->{_numPoints} = shift || 2;
bless $self, $class;
return $self;
}
=head2 apply
Applies Algorithm::Evolutionary::Op::CX operator to a "Chromosome", a bitstring, really. Can be
applied only to I<victims> with the C<_bitstring> instance variable; but
it checks before application that both operands are of type
L<Individual::Vector|Algorithm::Evolutionary::Individual::Vector>.
lib/Algorithm/Evolutionary/Op/CanonicalGA.pm view on Meta::CPAN
$self->{_selrate} = shift || 0.4;
if ( @_ ) {
$self->{_ops} = shift;
} else {
#Create mutation and crossover
my $mutation = new Algorithm::Evolutionary::Op::Bitflip;
push( @{$self->{_ops}}, $mutation );
my $xover = new Algorithm::Evolutionary::Op::QuadXOver;
push( @{$self->{_ops}}, $xover );
}
bless $self, $class;
return $self;
}
=head2 apply( $population)
Applies a single generation of the algorithm to the population; checks
that it receives a ref-to-array as input, croaks if it does
not. Returns a sorted, culled, evaluated population for next
generation.
lib/Algorithm/Evolutionary/Op/Canonical_GA_NN.pm view on Meta::CPAN
$self->{'_selrate'} = shift || 0.4;
if ( @_ ) {
$self->{_ops} = shift;
} else {
#Create mutation and crossover
my $mutation = new Algorithm::Evolutionary::Op::Bitflip;
push( @{$self->{_ops}}, $mutation );
my $xover = new Algorithm::Evolutionary::Op::QuadXOver 2;
push( @{$self->{_ops}}, $xover );
}
bless $self, $class;
return $self;
}
=head2 apply( $population)
Applies a single generation of the algorithm to the population; checks
that it receives a ref-to-array as input, croaks if it does not. This
population should be already evaluated. Returns a new population for
next generation, unsorted.
lib/Algorithm/Evolutionary/Op/ChangeLengthMutation.pm view on Meta::CPAN
sub new {
my $class = shift;
my $rate = shift;
my $probplus = shift || 1;
my $probminus = shift || 1;
my $self = { rate => $rate,
_probplus => $probplus,
_probminus => $probminus };
bless $self, $class;
return $self;
}
=head2 create
Creates a new operator. It is called with 3 arguments: the rate it's
going to be applied, and the probability of adding and substracting an
element from the string each time it's applied. Rates default to one.
=cut
sub create {
my $class = shift;
my $rate = shift;
my $probplus = shift || 1;
my $probminus = shift || 1;
my $self = { _rate => $rate,
_probplus => $probplus,
_probminus => $probminus };
bless $self, $class;
return $self;
}
=head2 apply
This is the function that does the stuff. The probability of adding
and substracting are normalized. Depending on a random draw, a random
char is added to the string (at the end) or eliminated from a random
position within the string..
lib/Algorithm/Evolutionary/Op/Creator.pm view on Meta::CPAN
=cut
sub new {
my $class = shift;
my $number = shift || croak "What?? No number??\n";
my $classToGenerate = shift || croak "Need a class to generate, man!\n";
my $hash = shift; #No carp here, some operators do not need specific stuff
my $self = { _number => $number,
_class => $classToGenerate,
_hash => $hash };
bless $self, $class; # And bless it
return $self;
}
=head2 apply( $population_hash )
Generates the population according to the parameters passed in the ctor
=cut
sub apply ($) {
lib/Algorithm/Evolutionary/Op/EDA_step.pm view on Meta::CPAN
=cut
sub new {
my $class = shift;
my $self = {};
$self->{_eval} = shift || croak "No eval function found";
$self->{_replacementRate} = shift || 0.5; #Default to half replaced
$self->{_population_size} = shift || 100; #Default
$self->{_alphabet} = shift || [ 0, 1]; #Default
bless $self, $class;
return $self;
}
=head2 set( $ref_to_params_hash, $ref_to_code_hash, $ref_to_operators_hash )
Sets the instance variables. Takes a ref-to-hash as
input. Not intended to be used from outside the class
=cut
lib/Algorithm/Evolutionary/Op/Easy.pm view on Meta::CPAN
$self->{_selrate} = shift || 0.4;
if ( @_ ) {
$self->{_ops} = shift;
} else {
#Create mutation and crossover
my $mutation = new Algorithm::Evolutionary::Op::Bitflip;
push( @{$self->{_ops}}, $mutation );
my $xover = new Algorithm::Evolutionary::Op::Crossover;
push( @{$self->{_ops}}, $xover );
}
bless $self, $class;
return $self;
}
=head2 set( $hashref, codehash, opshash )
Sets the instance variables. Takes a ref-to-hash (for options), codehash (for fitness) and opshash (for operators)
=cut
lib/Algorithm/Evolutionary/Op/Easy_MO.pm view on Meta::CPAN
$self->{_selrate} = shift || 0.4;
if ( @_ ) {
$self->{_ops} = shift;
} else {
#Create mutation and crossover
my $mutation = new Algorithm::Evolutionary::Op::Bitflip;
push( @{$self->{_ops}}, $mutation );
my $xover = new Algorithm::Evolutionary::Op::Crossover;
push( @{$self->{_ops}}, $xover );
}
bless $self, $class;
return $self;
}
=head2 set( $hashref, codehash, opshash )
Sets the instance variables. Takes a ref-to-hash (for options), codehash (for fitness) and opshash (for operators)
=cut
lib/Algorithm/Evolutionary/Op/Eval/General.pm view on Meta::CPAN
Creates an algorithm, with no defaults except for the default
replacement operator (defaults to L<Algorithm::Evolutionary::Op::ReplaceWorst>)
=cut
sub new {
my $class = shift;
my $self = {};
$self->{_eval} = shift || croak "No eval function found";
bless $self, $class;
return $self;
}
=head2 set( $ref_to_params_hash, $ref_to_code_hash, $ref_to_operators_hash )
Sets the instance variables. Takes a ref-to-hash as
input. Not intended to be used from outside the class
=cut
lib/Algorithm/Evolutionary/Op/Eval/MO_Rank.pm view on Meta::CPAN
=head2 new( $evaluation_function )
Creates an evaluator object
=cut
sub new {
my $class = shift;
my $self = {};
$self->{'_eval'} = shift || croak "No eval function found";
bless $self, $class;
return $self;
}
=head2 set( $ref_to_params_hash, $ref_to_code_hash, $ref_to_operators_hash )
Sets the instance variables. Takes a ref-to-hash as input. Not
intended to be used from outside the class. This should go to base,
probably.
( run in 0.610 second using v1.01-cache-2.11-cpan-de7293f3b23 )