test results from the CPAN

lib/AI/ParticleSwarmOptimization/Pmap.pm view on Meta::CPAN

-I<-posMax> (if I<-posMax> is negative I<-posMin> should be set more negative).

=item I<-randSeed>: number, optional

Seed for the random number generator. Useful if you want to rerun an
optimization, perhaps for benchmarking or test purposes.

=item I<-randStartVelocity>: boolean, optional

Set true to initialize particles with a random velocity. Otherwise particle
velocity is set to 0 on initalization.

view all matches for this distribution

AI-Pathfinding-AStar-Rectangle

1 match

examples/snake_labirint.pl view on Meta::CPAN

use ExtUtils::testlib;
use AI::Pathfinding::AStar::Rectangle;
use Data::Dumper;
#~ use constant WIDTH_X => 16;
#~ use constant WIDTH_Y => 10;
use constant WIDTH_X => 64;

view all matches for this distribution

AI-Pathfinding-AStar

1 match

lib/AI/Pathfinding/AStar.pm view on Meta::CPAN


=item * Heuristic

=back

Basically you should return an array reference like this: C<[ [$node1, $cost1, $h1], [$node2, $cost2, $h2], [...], ...];>  For more information on heuristics and the best ways to calculate them, visit the links listed in the I<SEE ALSO> section below...

As mentioned earlier, AI::Pathfinding::AStar provides two routines named C<findPath> and C<findPathIncr>.  C<findPath> requires as input the starting and target node identifiers.  It is unimportant what format you choose for your node IDs.  As long a...

=head1 PREREQUISITES

view all matches for this distribution

AI-Pathfinding-OptimizeMultiple

8 results

lib/AI/Pathfinding/OptimizeMultiple.pm view on Meta::CPAN

L<http://www.shlomifish.org/lecture/Freecell-Solver/The-Next-Pres/slides/multi-tasking/best-meta-scan/>

=head2 $self->calc_flares_meta_scan()

This function calculates the flares meta-scan: i.e: assuming that all atomic
scans are run one after the other and the shortest solutions of all
successful scans are being picked.

=head2 $calc_meta_scan->calc_board_iters($board_idx)

Calculates the iterations of the board $board_idx in all the scans.

lib/AI/Pathfinding/OptimizeMultiple.pm view on Meta::CPAN

=head1 ACKNOWLEDGEMENTS

B<popl> from Freenode's #perl for trying to dig some references to an existing
algorithm in the scientific literature.

=for :stopwords cpan testmatrix url bugtracker rt cpants kwalitee diff irc mailto metadata placeholders metacpan

=head1 SUPPORT

=head2 Websites

lib/AI/Pathfinding/OptimizeMultiple.pm view on Meta::CPAN


=item *

CPAN Testers

The CPAN Testers is a network of smoke testers who run automated tests on uploaded CPAN distributions.

L<http://www.cpantesters.org/distro/A/AI-Pathfinding-OptimizeMultiple>

=item *

CPAN Testers Matrix

The CPAN Testers Matrix is a website that provides a visual overview of the test results for a distribution on various Perls/platforms.

L<http://matrix.cpantesters.org/?dist=AI-Pathfinding-OptimizeMultiple>

=item *

CPAN Testers Dependencies

The CPAN Testers Dependencies is a website that shows a chart of the test results of all dependencies for a distribution.

L<http://deps.cpantesters.org/?module=AI::Pathfinding::OptimizeMultiple>

=back

=head2 Bugs / Feature Requests

lib/AI/Pathfinding/OptimizeMultiple.pm view on Meta::CPAN

=head1 BUGS

Please report any bugs or feature requests on the bugtracker website
L<https://github.com/shlomif/fc-solve/issues>

When submitting a bug or request, please include a test-file or a
patch to an existing test-file that illustrates the bug or desired
feature.

=head1 COPYRIGHT AND LICENSE

This software is Copyright (c) 2012 by Shlomi Fish.

view all matches for this distribution

AI-Pathfinding-SMAstar

3 results

    my $num_successors = $state_obj->get_num_successors();
    unless(Scalar::Util::looks_like_number($num_successors)){
	croak "Error:  Number of state successors is not numeric.  Cannot add state to queue.\n";	
    }

    # test out the iterator function to make sure it returns
    #  an object of the correct type
    my $classname = ref($state);
    my $test_successor_iterator = $state_obj->{_successors_iterator}->($state);
    my $test_successor = $test_successor_iterator->($state);
    my $succ_classname = ref($test_successor);

    unless($succ_classname eq $classname){
	croak "Error:  Successor iterator method of object $classname does " .
	    "not return an object of type $classname.\n";	
    }

 my $smastar = AI::Pathfinding::SMAstar->new(
        # evaluates f(n) = g(n) + h(n), returns a number
    	_state_eval_func           => \&FrontierObj::evaluate,

        # when called on a node, returns 1 if it is a goal
	_state_goal_p_func         => \&FrontierObj::goal_test,

        # must return the number of successors of a node
        _state_num_successors_func => \&FrontierObj::get_num_successors,      

        # must return *one* successor at a time




In the example above, a hypothetical object, C<FrontierObj>, is used to
represent a state, or I<node> in your search space.   To use SMA* search to
find a shortest path from a starting node to a goal in your search space, you must
define what a I<node> is, in your search space (or I<point>, or I<state>).

A common example used for informed search methods, and one that is used in Russell's
original paper, is optimal puzzle solving, such as solving an 8 or 15-tile puzzle
in the least number of moves.   If trying to solve such a puzzle, a I<node> in the
search space could be defined as a  configuration of that puzzle (a paricular
ordering of the tiles).

There is an example provided in the /t directory of this module's distribution,
where SMA* is applied to the problem of finding the shortest palindrome that
contains a minimum number of letters specified, over a given list of words.

Once you have a definition and representation of a node in your search space, SMA*
search requires the following functions to work:


=head2 Overview

Simplified Memory-bounded A* search (or SMA* search) addresses some of the
limitations of conventional A* search, by bounding the amount of space required
to perform a shortest-path search.   This module is an implementation of
SMA*, which was first introduced by Stuart Russell in 1992.   SMA* is a simpler,
more efficient variation of the original MA* search introduced by P. Chakrabarti
et al. in 1989 (see references below).


=head3 A* search

A* Search is an I<optimal> and I<complete> algorithm for computing a sequence of
operations leading from a system's start-state (node) to a specified goal.
In this context, I<optimal> means that A* search will return the shortest
(or cheapest) possible sequence of operations (path) leading to the goal,
and I<complete> means that A* will always find a path to 
the goal if such a path exists.

In general, A* search works using a calculated cost function on each node along a


=back


For a given admissible heuristic function, it can be shown that A* search
is I<optimally efficient>, meaning that,  in its calculation of the shortest
path, it expands fewer nodes in the search space than any other algorithm.

To be admissible, the heuristic I<h(n)> can never over-estimate the distance
from the node to the goal.   Note that if the heuristic I<h(n)> is set to
zero, A* search reduces to I<Branch and Bound> search.  If the cost-so-far


=head3 SMA* Search

Like A* search, SMA* search is an optimal and complete algorithm for finding
a least-cost path.   Unlike A*, SMA* will not run out of memory, I<unless the size
of the shortest path exceeds the amount of space in available memory>.

SMA* addresses the possibility of running out of memory 
by pruning the portion of the search-space that is being examined.  It relies on 
the I<pathmax>, or I<monotonicity> constraint on I<f(n)> to remove the shallowest 
of the highest-cost nodes from the search queue when there is no memory left to


the branching factor of the search space is large

=item *

there are many equivalent optimal solutions (or shortest paths)

=back


For solution spaces with these characteristics, stochastic methods or

argument (node) in the search space. 


=head2 state_goal_p_func()

 $smastar->state_goal_p_func(\&FrontierObj::goal_test);

Set/get the handle to the goal predicate function.   This is a function 
that returns 1 if the argument object is a goal node, or 0 otherwise.

view all matches for this distribution

AI-Perceptron-Simple

1 match

use Carp "croak";

use utf8;
binmode STDOUT, ":utf8";

require local::lib; # no local::lib in tests, this is also to avoid loading local::lib multiple times
use Text::CSV qw( csv );
use Text::Matrix;
use File::Basename qw( basename );
use List::Util qw( shuffle );

        $training_data_csv, $expected_column_name, $save_nerve_to, 
        $show_progress, $identifier); # these two parameters must go together


    # validate
    $nerve->take_lab_test( ... );
    $nerve->take_mock_exam( ... );

    # fill results to original file
    $nerve->validate( { 
        stimuli_validate => $validation_data_csv,

        predicted_column_index => 4,
        results_write_to => $new_csv
    } );


    # test - see "validate" method, same usage
    $nerve->take_real_exam( ... );
    $nerve->work_in_real_world( ... );
    $nerve->test( ... );


    # confusion matrix
    my %c_matrix = $nerve->get_confusion_matrix( { 
        full_data_file => $file_csv,

    portable_data => [ qw( preserve_as_yaml save_perceptron_yaml revive_from_yaml load_perceptron_yaml ) ],
);

=head1 DESCRIPTION

This module provides methods to build, train, validate and test a perceptron. It can also save the data of the perceptron for future use for any actual AI programs.

This module is also aimed to help newbies grasp hold of the concept of perceptron, training, validation and testing as much as possible. Hence, all the methods and subroutines in this module are decoupled as much as possible so that the actual script...

The implementation here is super basic as it only takes in input of the dendrites and calculate the output. If the output is higher than the threshold, the final result (category) will 
be 1 aka perceptron is activated. If not, then the result will be 0 (not activated).

Depending on how you view or categorize the final result, the perceptron will fine tune itself (aka train) based on the learning rate until the desired result is met. Everything from

    my @shuffled_stimuli_names = @_ 
        or croak "Please specify the output files for the shuffled data";
    
    my @aoa;
    for ( @shuffled_stimuli_names ) {
        # copied from _real_validate_or_test
        # open for shuffling
        my $aoa = csv (in => $stimuli, encoding => ":encoding(utf-8)");
        my $attrib_array_ref = shift @$aoa; # 'remove' the header, it's annoying :)
        @aoa = shuffle( @$aoa ); # this can only process actual array
        unshift @aoa, $attrib_array_ref; # put back the headers before saving file

    $data{ learning_rate } = LEARNING_RATE if not exists $data{ learning_rate };
    $data{ threshold } = THRESHOLD if not exists $data{ threshold };
    
    #####
    # don't pack this key checking process into a subroutine for now
    # this is also used in &_real_validate_or_test
    my @missing_keys;
    for ( qw( initial_value attribs ) ) {
        push @missing_keys, $_ unless exists $data{ $_ };
    }


All the validation methods here have the same parameters as the actual C<validate> method and they all do the same stuff. They are also used in the same way.

=head2 take_mock_exam (...)

=head2 take_lab_test (...)

=head2 validate ( \%options )

This method validates the perceptron against another set of data after it has undergone the training process.


The default behaviour will write the predicted output back into C<stimuli_validate> ie the original data. The sequence of the data will be maintained.

=back

I<*This method will call C<_real_validate_or_test> to do the actual work.>

=cut

sub take_mock_exam {
    my ( $self, $data_hash_ref ) = @_;
    $self->_real_validate_or_test( $data_hash_ref );
}

sub take_lab_test {
    my ( $self, $data_hash_ref ) = @_;
    $self->_real_validate_or_test( $data_hash_ref );
}

sub validate {
    my ( $self, $data_hash_ref ) = @_;
    $self->_real_validate_or_test( $data_hash_ref );
}

=head1 TESTING RELATED SUBROUTINES/METHODS

All the testing methods here have the same parameters as the actual C<test> method and they all do the same stuff. They are also used in the same way.

=head2 take_real_exam (...)

=head2 work_in_real_world (...)

=head2 test ( \%options )

This method is used to put the trained nerve to the test. You can think of it as deploying the nerve for the actual work or maybe putting the nerve into an empty brain and see how 
well the brain survives :)

This method works and behaves the same way as the C<validate> method. See C<validate> for the details.

I<*This method will call &_real_validate_or_test to do the actual work.>

=cut

# redirect to _real_validate_or_test
sub take_real_exam {
    my ( $self, $data_hash_ref ) = @_;
    $self->_real_validate_or_test( $data_hash_ref );
}

sub work_in_real_world {
    my ( $self, $data_hash_ref ) = @_;
    $self->_real_validate_or_test( $data_hash_ref );
}

sub test {
    my ( $self, $data_hash_ref ) = @_;
    $self->_real_validate_or_test( $data_hash_ref );
}

=head2 _real_validate_or_test ( $data_hash_ref )

This is where the actual validation or testing takes place. 

C<$data_hash_ref> is the list of parameters passed into the C<validate> or C<test> methods.

This is a B<method>, so use the OO way. This is one of the exceptions to the rules where private subroutines are treated as methods :)

=cut

sub _real_validate_or_test {

    my $self = shift;   my $data_hash_ref = shift;
    
    #####
    my @missing_keys;


}

=head2 &_fill_predicted_values ( $self, $stimuli_validate, $predicted_index, $aoa )

This is where the filling in of the predicted values takes place. Take note that the parameters naming are the same as the ones used in the C<validate> and C<test> method.

This subroutine should be called in the procedural way.

=cut


For C<%options>, the followings are needed unless mentioned:

=over 4

=item full_data_file => $filled_test_file

This is the CSV file filled with the predicted values. 

Make sure that you don't do anything to the actual and predicted output in this file after testing the nerve. These two columns must contain binary values only!

=item actual_output_header => $actual_column_name

=item predicted_output_header => $predicted_column_name

view all matches for this distribution

AI-PredictionClient-Alien-TensorFlowServingProtos

1 match

lib/AI/PredictionClient/Alien/TensorFlowServingProtos.pm view on Meta::CPAN


=cut

=head2 CPAN Testers Note

This module may fail CPAN Testers' tests. 
The build support tools needed by this module and especially the 
Alien::Google::GRPC module are normally installed on the 
CPAN Testers' machines, but not always.

The system build tools dependencies have been reduced, so hopefully

view all matches for this distribution

AI-PredictionClient

4 results

lib/AI/PredictionClient.pm view on Meta::CPAN


If you don't have an image handy --debug_camel will provide a sample image to send to the server. 
The image file argument still needs to be provided to make the command line parser happy.

If you don't have a server to talk to, but want to see if most everything else is working use 
the --debug_loopback_interface. This will provide a sample response you can test the client with. 
The module can use the same loopback interface for debugging your bespoke clients.

The --debug_verbose option will dump the data structures of the request and response to allow
you to see what is going on.

lib/AI/PredictionClient.pm view on Meta::CPAN


At this time only Linux builds are supported.

=head2 CPAN Testers Note

This module may fail CPAN Testers' tests. 
The build support tools needed by this module and especially the 
Alien::Google::GRPC module are normally installed on the 
CPAN Testers' machines, but not always.

The system build tools dependencies have been reduced, so hopefully 
a large number of machines will build without manually installing 
system dependencies.

=head2 NOTE

This is a complex package with a lot of moving parts. Please pardon if this first release has some minor bug or missing dependency that went undiscovered in my testing.

=head1 AUTHOR

Tom Stall <stall@cpan.org>

view all matches for this distribution

AI-Prolog

3 results

    # @PRIMITIVES.
    eval {
        $self->_adding_builtins(1);
        $self->{_db} = Parser->consult( <<'        END_PROG', $prog );
            ne(X, Y) :- not(eq(X,Y)).
            if(X,Y,Z) :- once(wprologtest(X,R)) , wprologcase(R,Y,Z).
            wprologtest(X,yes) :- call(X). wprologtest(X,no). 
            wprologcase(yes,X,Y) :- call(X). 
            wprologcase(no,X,Y) :- call(Y).
            not(X)  :- if(X,fail,true). 
            or(X,Y) :- call(X).
            or(X,Y) :- call(Y).

        }
    }
    return;
}

sub _print {    # convenient testing hook
    print @_;
}

sub _warn {     # convenient testing hook
    warn @_;
}

use constant RETURN => 2;


 Engine->formatted(1); # turn on formatting
 Engine->formatted(0); # turn off formatting (default)
 
 if (Engine->formatted) {
     # test if formatting is enabled
 }

B<Note>: if you choose to use the L<AI::Prolog|AI::Prolog> interface instead of
interacting directly with this class, that interface will set C<formatted> to
false.  You will have to set it back in your code if you do not wish this

 
 Engine->raw_results(1); # turn on raw results
 Engine->raw_results(0); # turn off raw results (default)
 
 if (Engine->raw_results) {
     # test if raw results is enabled
 }

=head2 C<trace($boolean)>

Set this to a true value to turn on tracing.  This will trace through the

view all matches for this distribution

AI-SimulatedAnnealing

1 match


# The use_brute_force() function takes a reference to an array of number
# specifications (which are references to hashes containing "LowerBound",
# "UpperBound", and "Precision" fields) and a reference to a cost function
# (which takes a list of numbers matching the specifications and returns a
# number representing a cost to be minimized).  The method tests every
# possible combination of numbers matching the specifications and returns a
# reference to an array containing the optimal numbers, where "optimal"
# means producing the lowest cost.
sub use_brute_force {
    my $number_specs = validate_number_specs($_[0]);

    # Populate @cursors with the starting position for each list of numbers:
    for (0..$#lists) {
        push @cursors, 0;
    } # next

    # Perform the tests:
    my $lowest_cost = undef;
    my $finished = $FALSE;

    do {
        # Perform a test using the current cursors:
        my @candidate_list;
        my $cost;

        for my $dex (0..$#lists) {
            push @candidate_list, $lists[$dex]->[$cursors[$dex]];

        unless (defined($lowest_cost) && $cost >= $lowest_cost) {
            $lowest_cost = $cost;
            @optimized_list = @candidate_list;
        } # end unless

        # Adjust the cursors for the next test if not finished:
        for my $dex (reverse(0..$#lists)) {
            my $cursor = $cursors[$dex];

            if ($cursor < $#{ $lists[$dex] }) {
                $cursor++;

number representing a cost to be minimized.

In order to work efficiently with the varying precisions, the anneal()
function converts each bound to an integer by multiplying it by 10 to
the power of the precision; then the function performs the temperature
reductions and randomization cycles (which include tests performed via
calls to the cost function) on integers in the resulting ranges.  When
passing an integer to the cost function or when storing the integer in
a collection of numbers to be returned by the function, anneal() first
converts the integer back to the appropriate decimal number by
dividing the integer by 10 to the power of the precision.

isn't already an integer).  When the temperature reaches zero,
annealing is immediately terminated.

  NOTE:  Annealing can sometimes complete before the temperature
  reaches zero if, after a particular temperature reduction, a
  brute-force optimization approach (that is, testing every possible
  combination of numbers within the subranges determined by the new
  temperature) would produce a number of tests that is less than or
  equal to the specified cycles per temperature.  In that case, the
  anneal() function performs the brute-force optimization to complete
  the annealing process.

After a temperature reduction, the anneal() function determines each

view all matches for this distribution

AI-XGBoost

9 results

examples/basic.pl view on Meta::CPAN


# We are going to solve a binary classification problem:
#  Mushroom poisonous or not

my $train_data = DMatrix->From(file => 'agaricus.txt.train');
my $test_data = DMatrix->From(file => 'agaricus.txt.test');

# With XGBoost we can solve this problem using 'gbtree' booster
#  and as loss function a logistic regression 'binary:logistic'
#  (Gradient Boosting Regression Tree)
# XGBoost Tree Booster has a lot of parameters that we can tune

examples/basic.pl view on Meta::CPAN

        max_depth => 2,
        silent => 1
    });

# For binay classification predictions are probability confidence scores in [0, 1]
#  indicating that the label is positive (1 in the first column of agaricus.txt.test)
my $predictions = $booster->predict(data => $test_data);

say join "\n", @$predictions[0 .. 10];

view all matches for this distribution

AIS-client

1 match

test.pl view on Meta::CPAN

# Before `make install' is performed this script should be runnable with
# `make test'. After `make install' it should work as `perl test.pl'

#########################

# change 'tests => 1' to 'tests => last_test_to_print';

use Test;
BEGIN { plan tests => 2 };
BEGIN {print <<EOF };
AIS::client redirects and exits, only achieving it's
aim of authenticating a user against a central AIS server
after at least three state-altering calls to itself.

If you can figure out a way to write a test harness for
it I'll gladly accept the patch.

under these lines you should see something like
Set-Cookie:/AIS_session=SomE1RanDoM5GaRBagE
Location: http://?AIS_INITIAL

test.pl view on Meta::CPAN

use AIS::client;
ok(1); # If we made it this far, we're ok.

#########################

# Insert your test code below, the Test module is use()ed here so read
# its man page ( perldoc Test ) for help writing this test script.

view all matches for this distribution

AIX-LPP

1 match

LPP/lpp_name.pm view on Meta::CPAN

    if (defined $param{PLATFORM}) { $self->{PLATFORM} = $param{PLATFORM}}
        else { $self->{PLATFORM} = 'R'}
    if (defined $param{TYPE}) { $self->{TYPE} = $param{TYPE}}
        else { $self->{TYPE} = 'I'}
    if (defined $param{NAME}) { $self->{NAME} = $param{NAME}}
        else { $self->{NAME} = 'test.lpp'}
    $self->{FILESET} = {};
    bless $self, $class;
    return $self;
}

LPP/lpp_name.pm view on Meta::CPAN

=head1 SYNOPSIS

  use AIX::LPP::lpp_name;

  $x = lpp_name->new();
  $x->lpp(NAME => 'test.lpp',TYPE => 'I',PLATFORM => 'R',FORMAT => '4');
  $x->fileset('test.lpp.rte', VRMF => '1.0.0.0',DISK => '01',BOSBOOT => 'N',
	CONTENT => 'I', LANG => 'en_US', DESCRIPTION => 'test.lpp description',
	COMMENTS => '');
  my @reqs = [ ['*prereq','bos.rte','4.3.3.0'] ];
  $x->requisites('test.lpp.rte', \@reqs);
  my %sizes = { '/usr' => '5', '/etc' => '1' };
  $x->sizeinfo('test.lpp.rte', \%sizes);
  $x->write(\*out_fh);

  or

  $x = lpp_name->read(\*in_fh);
  my %lppdata = $x->lpp();
  my %fsdata = $x->fileset('test.lpp.rte');
  my $req_ref = $x->requisites('test.lpp.rte');
  my $size_ref = $x->sizeinfo('test.lpp.rte');
  
=head1 DESCRIPTION

AIX::LPP::lpp_name is a class module for reading, creating, and modifying
AIX lpp_name files.  The lpp_name file is an internal component of AIX

view all matches for this distribution

AIX-ODM

1 match

test.pl view on Meta::CPAN

#!perl -w

# Before `make install' is performed this script should be runnable with
# `make test'. After `make install' it should work as `perl test.pl'

######################### We start with some black magic to print on failure.

# Change 1..1 below to 1..last_test_to_print .
# (It may become useful if the test is moved to ./t subdirectory.)

BEGIN { $| = 1; print "1..2\n"; }
END {print "not ok 1\n" unless $loaded;}
use AIX::ODM;
$loaded = 1;

view all matches for this distribution

AIX-Perfstat

1 match

=head2 assert_lib

This takes several named parameters, all of which are optional, and dies
with an error message if any of the libraries listed can
not be found.  B<Note>: dying in a Makefile.PL or Build.PL may provoke
a 'FAIL' report from CPAN Testers' automated smoke testers.  Use 
C<check_lib_or_exit> instead.

The named parameters are:

=over

=head1 PLATFORMS SUPPORTED

You must have a C compiler installed.  We check for C<$Config{cc}>,
both literally as it is in Config.pm and also in the $PATH.

It has been tested with varying degrees on rigourousness on:

=over

=item gcc (on Linux, *BSD, Mac OS X, Solaris, Cygwin)


=head1 WARNINGS, BUGS and FEEDBACK

This is a very early release intended primarily for feedback from
people who have discussed it.  The interface may change and it has
not been adequately tested.

Feedback is most welcome, including constructive criticism.
Bug reports should be made using L<http://rt.cpan.org/> or by email.

When submitting a bug report, please include the output from running:


David Cantrell E<lt>david@cantrell.org.ukE<gt>

David Golden E<lt>dagolden@cpan.orgE<gt>

Thanks to the cpan-testers-discuss mailing list for prompting us to write it
in the first place;

to Chris Williams for help with Borland support.

=head1 COPYRIGHT and LICENCE

view all matches for this distribution

AIX-SysInfo

1 match

SysInfo.pm view on Meta::CPAN


You can install it using the usual Perl fashion:

  perl Makefile.PL
  make
  make test
  make install

This module provides a Perl interface for accessing information about a pSeries machine running the AIX operating system.  It makes available a single function, B<get_sysinfo>, which returns a hash containing the following keys:

=over

SysInfo.pm view on Meta::CPAN


The value of this key contains the total amount of swap space in the system, in megabytes.

=item B<aix_version>

The value of this key contains the version of AIX and the latest complete maintenance level on ths system, in the form "VRMF-ML".

=item B<model_type>

The value of this key contains the hardware model as reported by uname -M (9117-570)

SysInfo.pm view on Meta::CPAN

   1.1   (released on Tue Jun 16 16:39:00 CDT 2009)
   1.0   (released 2000-07-03)

=head1 BUGS

With version 1.1 this module was rewritten from scratch. It has been tested on p570/p595 LPAR hardware and on several older stand-alone servers. This version works slower that version 1.0 because it relies on prtconf command which takes several secon...

=head1 TO-DO

=over 2

view all matches for this distribution

ALBD

5 results

lib/ALBD.pm view on Meta::CPAN


To install the module, run the following magic commands:

  perl Makefile.PL
  make
  make test
  make install

This will install the module in the standard location. You will, most
probably, require root privileges to install in standard system
directories. To install in a non-standard directory, specify a prefix

lib/ALBD.pm view on Meta::CPAN


##################################################
################ Time Slicing ####################
##################################################

#NOTE: This function isn't really tested, and is really slow right now
# Generates precision and recall values by varying the threshold
# of the A->B ranking measure.
# input:  none
# output: none, but precision and recall values are printed to STDOUT
sub timeSlicing_generatePrecisionAndRecall_explicit {

view all matches for this distribution

ALPM

1 match

t/preptests.pl view on Meta::CPAN

use File::Copy;
use File::Path qw(make_path remove_tree);
use File::Spec::Functions qw(rel2abs catfile);
use File::Basename qw(dirname);

my $PROG = 'preptests';
my $REPODIR = 'repos';

## Variables inside the test.conf need absolute paths, assigned later.
my ($REPOSHARE, $TESTROOT);
my $TESTCONF = 'test.conf';

sub createconf
{
	my($path, $root, $repos) = @_;
	open my $of, '>', $path
		or die "failed to open t/test.conf file: $!";
	print $of <<"END_CONF";
[options]
RootDir = $root
DBPath = $root/db
CacheDir = $root/cache
LogFile = $root/test.log
#GPGDir      = $root/gnupg/
HoldPkg     = pacman glibc
SyncFirst   = pacman
#XferCommand = /usr/bin/curl -C - -f %u > %o
#XferCommand = /usr/bin/wget --passive-ftp -c -O %o %u

t/preptests.pl view on Meta::CPAN

	make_path(@dirs, { mode => 0755 });
}

sub corruptpkg
{
	my $fqp = "$REPOSHARE/simpletest/corruptme-1.0-1-any.pkg.tar.xz";
	unlink $fqp or die "unlink: $!";

	open my $fh, '>', $fqp or die "open: $!";
	print $fh "HAHA PWNED!\n";
	close $fh or die "close: $!";

t/preptests.pl view on Meta::CPAN

		createconf($TESTCONF, $TESTROOT, $repos);
	}

	#corruptpkg();

	# Allows me to tweak the test.conf file and not have it overwritten...
	mkroot();

	return 0;
}

view all matches for this distribution

AMF-Connection

3 results

lib/AMF/Connection.pm view on Meta::CPAN


See the sample usage synopsis above to start using the module.

=head1 DATE TYPE SUPPORT

The latest 0.79 version of Storable::AMF added basic date support with the new_date() and perl_date() utilitiy functions. This is just great. Internally an AMF Date Type represents a timestamp in milliseconds since the epoch in UTC ("neutral") timezo...

 use Storable::AMF qw(new_date perl_date);

and make sure any date passed to an AMF::Connection as parameter is encoded with new_date().

view all matches for this distribution

AMF-Perl

1 match

lib/AMF/Perl/Util/RemotingService.pm view on Meta::CPAN

			{
				push @functions,  {
					"description" => $method->{"description"},
					"name" => $key,
					"version" => "1.0",
					"returns" => "testing",
					#"arguments" => {} 
				};
			}
		}

view all matches for this distribution

AMQP

3 results

lib/AMQP.pm view on Meta::CPAN


  package AMQP::MyUtility;
  use Mojo::Base 'AMQP';
 
  my $util = AMQP::MyUtility->new;
  $util->server('amqp://amqp.perl.org:5672/test');

=head1 DESCRIPTION

The AMQP class provides the basic functionality common to all AMQP utility classes.

view all matches for this distribution

ANSI-Palette

1 match

lib/ANSI/Palette.pm view on Meta::CPAN


	... 

	use ANSI::Palette qw/ansi_256/;

	background_text_256(208, 33, "This is a test for background_text_256\n");
	background_bold_256(160, 33, "This is a test for background_bold_256\n");
	background_underline_256(226, 33, "This is a test for background_underline_256\n");
	background_italic_256(118, 33, "This is a test for background_italic_256\n");	

=head1 EXPORT

A list of functions that can be exported.  You can delete this section
if you don't export anything, such as for a purely object-oriented module.

lib/ANSI/Palette.pm view on Meta::CPAN


=head2 text_8

print text using one of the 8 base colors.

	text_8(32, "This is a test for text_8\n");

=cut

=head2 text_16

print text using one of the 16 base colors.

	text_16(32, 1, "This is a test for text_16\n");

=cut

=head2 text_256

print text using one of the 256 base colors.

	text_256(32, "This is a test for text_256\n");

=cut

=head2 bold_8

print bold text using one of the 8 base colors.

	bold_8(32, "This is a test for bold_8\n");

=cut

=head2 bold_16 

print bold text using one of the 16 base colors.

	bold_16(32, 1, "This is a test for bold_16\n");

=cut

=head2 bold_256

print bold text using one of the 256 base colors.

	bold_256(32, "this is a test for bold_256\n");

=cut

=head2 underline_8

print underlined text using one of the 8 base colors.

	underline_8(32, "This is a test for underline_8\n");

=cut

=head2 underline_16

print underlined text using one of the 16 base colors.

	underline_16(32, 1, "This is a test for underline_16\n");

=cut

=head2 underline_256

print underlined text using one of the 256 base colors.

	underline_256(32, "This is a test for underline_256\n");

=cut

=head2 italic_8

print italic text using one of the 8 base colors.

	italic_8(32, "This is a test for italic_8\n");

=cut

=head2 italic_16

print italic text using one of the 16 base colors.

	italic_16(32, 1, "This is a test for italic_16\n");

=cut

=head2 italic_256

print italic text using one of the 256 base colors.

	italic_256(32, "This is a test for italic_256\n");

=cut

=head2 background_text_8

print text using one of the 8 base colors on a background using one of the 8 base colors.

	background_text_8(32, 40, "This is a test for background_text_8\n");

=cut

=head2 background_text_16

print text using one of the 16 base colors on a background using one of the 16 base colors (40-47) (100-107).

	background_text_16(32, 1, 41, "This is a test for background_text_16\n");

=cut

=head2 background_text_256

print text using one of the 256 base colors on a background using one of the 256 base colors.

	background_text_256(208, 33, "This is a test for background_text_256\n");

=cut

=head2 background_bold_8

print bold text using one of the 8 base colors on a background using one of the 8 base colors.

	background_bold_8(32, 40, "This is a test for background_bold_8\n");

=cut

=head2 background_bold_16

print bold text using one of the 16 base colors on a background using one of the 16 base colors (40-47) (100-107).

	background_bold_16(32, 1, 40, "This is a test for background_bold_16\n");

=cut

=head2 background_bold_256

print bold text using one of the 256 base colors on a background using one of the 256 base colors.

	background_bold_256(208, 33, "this is a test for background_bold_256\n");

=cut

=head2 background_underline_8

print underlined text using one of the 8 base colors on a background using one of the 8 base colors.

	background_underline_8(32, 40, "This is a test for background_underline_8\n");

=cut

=head2 background_underline_16

print underlined text using one of the 16 base colors using one of the 16 base colors (40-47) (100-107).

	background_underline_16(32, 1, 40, "This is a test for background_underline_16\n");

=cut

=head2 background_underline_256

print underlined text using one of the 256 base colors on a background using one of the 256 base colors.

	background_underline_256(208, 33, "This is a test for background_underline_256\n");

=cut

=head2 background_italic_8

print italic text using one of the 8 base colors on a background using one of the 8 base colors.

	background_italic_8(32, 40, "This is a test for background_italic_8\n");

=cut

=head2 italic_16

print italic text using one of the 16 base colors on a background using one of the 16 base colors (40-47) (100-107).

	background_italic_16(32, 1, 40, "This is a test for background_italic_16\n");

=cut

=head2 italic_256

print italic text using one of the 256 base colors on a background using on the 256 base colors.

	background_italic_256(32, "This is a test for background_italic_256\n");

=cut

=head1 AUTHOR

view all matches for this distribution

AOL-TOC

2 results

TOC.pm view on Meta::CPAN

  $toc->destroy();

  return;
}

sub test {
  my ($self) = @_;

  return \&test($self);
}

sub send_signoff {
  my ($self) = @_;

view all matches for this distribution

AOLserver-CtrlPort

1 match

lib/AOLserver/CtrlPort.pm view on Meta::CPAN


C<AOLserver::CtrlPort> uses C<Net::Telnet> to connect to a running
AOLserver's control port, issues commands there and returns the 
output.

It is useful for creating test suites for AOLserver applications which
can be controlled via the control port. 

To configure AOLserver's control port, use settings similar to the following
ones:

lib/AOLserver/CtrlPort.pm view on Meta::CPAN

internal debugging level by saying something like

    use Log::Log4perl qw(:easy);
    Log::Log4perl->easy_init($DEBUG);

in your test script before any AOLserver::CtrlPort commands are called.

Please check out the Log::Log4perl documentation for details.

=head1 AUTHOR

view all matches for this distribution

API-DirectAdmin

1 match

lib/API/DirectAdmin.pm view on Meta::CPAN


To install this module type the following:

   perl Makefile.PL
   make
   make test
   make install

=head1 DEPENDENCIES

This module requires these other modules and libraries:

view all matches for this distribution

API-Docker

5 results

lib/API/Docker.pm view on Meta::CPAN

    my $version = $docker->system->version;

    # Container management
    my $containers = $docker->containers->list(all => 1);
    my $result = $docker->containers->create(
        Image => 'nginx:latest',
        name  => 'my-nginx',
    );
    $docker->containers->start($result->{Id});

    # Image operations
    $docker->images->pull(fromImage => 'nginx', tag => 'latest');
    my $images = $docker->images->list;

    # Network and volume management
    my $networks = $docker->networks->list;
    my $volumes = $docker->volumes->list;

view all matches for this distribution

API-INSEE-Sirene

1 match

lib/API/INSEE/Sirene.pm view on Meta::CPAN


=back

B<Please note that this API is french so all fields names used in function calls are in french, including the aliases.>

This module has been tested with 3.9 INSEE API version.

=head1 DEPENDENCIES

=over 4

view all matches for this distribution

API-ISPManager

1 match

lib/API/ISPManager/software.pm view on Meta::CPAN

cost	7.7000
elid	361604
expiredate	2009-10-08
func	software.period
ip	83.222.14.204
licname	testserver1.hosting.reg.ru
payfrom	neworder
period	16
pricename	ISPmanager Pro (without support)
sok	ok

view all matches for this distribution

API-MailboxOrg

3 results

example/list_videochats.pl view on Meta::CPAN


use API::MailboxOrg;
use Data::Printer;

my $api = API::MailboxOrg->new(
    user     => 'test@example.tld',
    password => 'a_password',
);

my $result = $api->videochat->list( mail => 'test@example.tld' );

p $result;

view all matches for this distribution

API-MikroTik

1 match