view release on metacpan or  search on metacpan

lib/AI/Perceptron/Simple.pm  view on Meta::CPAN

        learning_rate => $data{ learning_rate },
        threshold => $data{ threshold },
        attributes_hash_ref => \%attributes,
    );
    
    bless \%processed_data, $class;
}

=head2 get_attributes

Obtains a hash of all the attributes of the perceptron

 view release on metacpan or  search on metacpan

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

our $VERSION = '1.0';
our $Debug   = 0;

sub new {
    my $class = shift;
    my $self  = bless {}, $class;
    return $self->init( @_ );
}

sub init {
    my $self = shift;

 view release on metacpan or  search on metacpan

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

# binding in the external interface, we need to stick with this as the default
Engine->raw_results(1);

sub new {
    my ( $class, $program ) = @_;
    my $self = bless {
        _prog   => Parser->consult($program),
        _query  => undef,
        _engine => undef,
    } => $class;
    lock_keys %$self;

 view release on metacpan or  search on metacpan

lib/AI/TensorFlow/Libtensorflow.pm  view on Meta::CPAN

$ffi->mangler(AI::TensorFlow::Libtensorflow::Lib->mangler_default);

sub new {
	my ($class) = @_;
	bless {}, $class;
}

$ffi->attach( 'Version' => [], 'string' );#}}}

1;

 view release on metacpan or  search on metacpan

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

                 inear2 => 1/($near * $near),
                 near_dim => $near ** $dim,
                 taken => 0,
		 dim => $dim };

    bless $self, $class;

    push @wood, $self->new_wood for (1..$n_wood);
    push @termites, $self->new_termite for (1..$n_termites);
    $self->iterate for (1..$iterations);
    $self;

 view release on metacpan or  search on metacpan

lib/AI/XGBoost/Booster.pm  view on Meta::CPAN

=head2 TO_JSON

Serialize the booster to JSON.

This method is to be used with the option C<convert_blessed> from L<JSON>.
(See L<https://metacpan.org/pod/JSON#OBJECT-SERIALISATION>)

Warning: this API is subject to changes

=head2 BUILD

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

sv_2uv_flags||5.009001|
sv_2uv|5.004000||p
sv_add_arena|||
sv_add_backref|||
sv_backoff|||
sv_bless|||
sv_cat_decode||5.008001|
sv_catpv_mg|5.006000||p
sv_catpvf_mg_nocontext|||pvn
sv_catpvf_mg|5.006000|5.004000|pv
sv_catpvf_nocontext|||vn

 view release on metacpan or  search on metacpan

LPP/lpp_name.pm  view on Meta::CPAN

    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;
}

sub lpp {
    my $self = shift;

LPP/lpp_name.pm  view on Meta::CPAN

sub read {
    my $class = shift;
    my $fh = shift;
    my $self = {};
    bless $self, $class;
    
    chomp (my $line = <$fh>);
    my ($format,$platform,$type,$name,$token) = split / /, $line;
    $self->lpp(NAME => $name, FORMAT => $format, TYPE => $type,
		PLATFORM => $platform);

 view release on metacpan or  search on metacpan

lib/AIX/LVM.pm  view on Meta::CPAN

sub new
{
    my $class = shift;
    my $self = {};
    bless $self, $class;
    return $self->init(@_);
}


sub init 

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

sv_2uv_flags||5.009001|
sv_2uv|5.004000||p
sv_add_arena|||
sv_add_backref|||
sv_backoff|||
sv_bless|||
sv_cat_decode||5.008001|
sv_catpv_mg|5.006000||p
sv_catpvf_mg_nocontext|||pvn
sv_catpvf_mg|5.006000|5.004000|pv
sv_catpvf_nocontext|||vn

 view release on metacpan or  search on metacpan

lib/ALBD.pm  view on Meta::CPAN

# output: a new LBD object
sub new {
    my $self = {};
    my $className = shift;
    my $optionsHashRef = shift;
    bless($self, $className);

    $self->_initialize($optionsHashRef);
    return $self;
}

 view release on metacpan or  search on metacpan

lib/ALPM/Conf.pm  view on Meta::CPAN

## Public methods.

sub new
{
	my($class, $path) = @_;
	bless { 'path' => $path }, $class;
}

sub custom_fields
{
	my($self, %cfields) = @_;

 view release on metacpan or  search on metacpan

examples/amfclient.pl  view on Meta::CPAN

BEGIN
  {
    no strict 'refs';

    # blessed hash object to JSON object
    map
      {
        my $amf_class = $_;
        my $foo = $amf_class."::TO_JSON";

        # unbless object
        *$foo = sub {
            my $f = $_[0];

            #process_amf_object ($f, $amf_class);

examples/amfclient.pl  view on Meta::CPAN

          # add your own remote service classes here - or use an SWFDecompiler

          'flex.messaging.messages.AcknowledgeMessage'
        );

    # blessed hash object to JSON array
    map
      {
        my $foo = $_."::TO_JSON";
        # unbless
        *$foo = sub {
            $_[0]->{'externalizedData'};
          }
      } (
          'flex.messaging.io.ArrayCollection'

examples/amfclient.pl  view on Meta::CPAN

my $json = JSON->new;
$json->ascii(1);
$json->utf8(1);
$json->pretty(1);
$json->allow_blessed(1);
$json->convert_blessed(1);
my $json_data = $json->encode( $response->getData );

if ( $response->is_success ) {
        print $json_data;
} else {

 view release on metacpan or  search on metacpan

doc/cpu.pl  view on Meta::CPAN

sub new
{
    my ($proto)=@_;
    my $self={};
    bless $self, $proto;
    return $self;
}

sub getCpuUsage
{

 view release on metacpan or  search on metacpan

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

my $DEFAULT_SWATCH = 'blue-red';

sub new {
    my $class = shift;
    my %args = (@_ == 1 && ref $_[0] && ref $_[0] eq 'HASH') ? %{$_[0]} : @_;
    my $self = bless { map => [], minmax => {} }, $class;
    $self->swatch($DEFAULT_SWATCH);
    $self->interpolate(0);
    $self->half(0);
    for my $field (@_fields, 'swatch') {
        $self->$field(delete $args{$field}) if exists $args{$field};

 view release on metacpan or  search on metacpan

SFLAP.pm  view on Meta::CPAN

    ipaddr	=> $ipaddr,
    port	=> $port,
    nickname	=> $nickname,
    sequence    => 1
  };
  bless($self);

  return $self;
}

sub destroy {

 view release on metacpan or  search on metacpan

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

    $t->login("", "");

    DEBUG("Waiting for prompt");
    $t->waitfor();

    bless $self, $class;
}

=item $conn->send_cmds("$cmd1\ncmd2\n...")

Send one or more commands, separated by newlines, AOLserver's

 view release on metacpan or  search on metacpan

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

    for my $need_param ( REQUIRE_PARAMS ) {
        confess "Parameter $need_param required!" unless $self->{ $need_param };
    }

    return bless $self, $class;
}

sub abstract_request {
    my ( $self, $data ) = @_;

 view release on metacpan or  search on metacpan

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

    confess "Required auth_user!"   unless $self->{auth_user};
    confess "Required auth_passwd!" unless $self->{auth_passwd};
    confess "Required host!"        unless $self->{host};

    return bless $self, $class;
}

# initialize components
sub init_components {
    my ( %c ) = @_;

 view release on metacpan or  search on metacpan

lib/API/Drip/Request.pm  view on Meta::CPAN

        confess "Missing configuration $key" unless defined $self->{$key};
    }

    $self->{debugger} = _mk_debugger( $self, %OPT );

    bless $self, $class;
    return $self;
}

sub _mk_debugger {
    my ($self, %OPT)  = @_;

 view release on metacpan or  search on metacpan

lib/API/Eulerian/EDW.pm  view on Meta::CPAN

use API::Eulerian::EDW::Peer::Rest();

sub new {
  my $proto = shift();
  my $class = ref($proto) || $proto;
  return bless({}, $class);
}

sub get_csv_file {
  my ($self, $rh_p, $query) = @_;

 view release on metacpan or  search on metacpan

lib/API/GitForge/Role/GitForge.pm  view on Meta::CPAN

    my ($class, %opts) = @_;
    croak "need domain!" unless exists $opts{domain};

    my %attrs = (_domain => $opts{domain});
    $attrs{_access_token} = $opts{access_token} if exists $opts{access_token};
    my $self = bless \%attrs => $class;

    $self->_make_api;

    return $self;
}

 view release on metacpan or  search on metacpan

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

  	die 'no json file specified!';
  }
  $h->{ua} = Mojo::UserAgent->new();
  $h->{debug} = $params->{debug};
  $h->{max_refresh_attempts} = $params->{max_refresh_attempts} || 5;
  return bless $h, $class;
}



sub refresh_access_token {

 view release on metacpan or  search on metacpan

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

sub new {
    my $class = shift;
    my ($credentials, $timeout, $max_results, $proxy) = @_;

    my $self = bless {
        credentials      => $credentials,
        user_agent       => undef,
        token_expiration => undef,
        max_results      => undef,
        debug_mode       => 0,

 view release on metacpan or  search on metacpan

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

        error => $request_params{error},
        request_xml => $request_params{request_xml},
        request_object => $request_params{request_object},
        out_format => $request_params{out_format},
    };
    bless $self, $class;
    return $self;
};

1;
# The preceding line will help the module return a true value

 view release on metacpan or  search on metacpan

lib/API/MailboxOrg/Types.pm  view on Meta::CPAN

use Type::Utils -all;
use Types::Standard -types;

use Carp;
use JSON::PP;
use Scalar::Util qw(blessed);

our $VERSION = '1.0.2'; # VERSION

my $meta = __PACKAGE__->meta;

lib/API/MailboxOrg/Types.pm  view on Meta::CPAN

    parent => InstanceOf['JSON::PP::Boolean'],
    constraint_generator => sub {
        return $meta->get_type('Boolean') if !@_;

        return sub {
            return if ! ( blessed $_ and $_->isa('JSON::PP::Boolean') );
            return 1;
        };
    },
    coercion_generator => sub {
        my ($parent, $child, $param) = @_;

 view release on metacpan or  search on metacpan

lib/API/MikroTik/Query.pm  view on Meta::CPAN

package API::MikroTik::Query;
use Mojo::Base '-base';

use Exporter 'import';
use Scalar::Util 'blessed';

our @EXPORT_OK = ('build_query');


sub build_query {
    my $query = blessed $_[0] ? $_[1] : $_[0];

    return $$query if ref $query eq 'REF' && ref $$query eq 'ARRAY';

    if (my $type = ref $query) {
        return [_block(_ref_op($type), $query)];

 view release on metacpan or  search on metacpan

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

	$args{api_queries} = 0;
	$args{cache_age} //= 30;

	die "An Octopart API token is required." if (!$args{token});

	return bless(\%args, $class);
}

=item * $o->has_stock($part, %opts) - Returns the number of items in stock

$part: The model number of the part

 view release on metacpan or  search on metacpan

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

        (@_)
    };

    map { confess "Field '" . $_ . "' required!" unless $self->{ $_ } } qw/username password server/;

    return bless $self, $class;
}

# "free" request. Basic method for requests

 view release on metacpan or  search on metacpan

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

        confess "Required username!" unless $self->{username};
        confess "Required password!" unless $self->{password};
    }
    confess "Required url!"      unless $self->{url};

    return bless $self, $class;
}

# sends request to Plesk API
sub send {
    my ( $self, $operator, $operation, $data, %params ) = @_;