Result:
found more than 616 distributions - search limited to the first 2001 files matching your query
( run in 0.776 )
Acme-RequireModule
view release on metacpan or search on metacpan
RequireModule.xs view on Meta::CPAN
PL_check[OP_REQUIRE] = my_ck_require;
}
my_depth++;
RETVAL = newSV(0);
sv_setref_uv(RETVAL, HINT_KEY, my_depth);
OUTPUT:
RETVAL
void
DESTROY(...)
CODE:
Acme-ReturnValue
view release on metacpan or search on metacpan
t/pms/RayApp.pm view on Meta::CPAN
into requests for directories. As B<RayApp>'s output is dynamically
generated, pure B<DirectoryIndex> cannot be used.
If not set, nothing will be served for directory requests.
=item RayAppInputModule / RAYAPP_INPUT_MODULE
As already noted, B<RayApp> runs the B<handler> function found
in the application file (app.pl). Often applications share the same
context -- all of them want to be passed an open B<$dbh> database
handler (instead of doing their own DBI->connect), all of them want to
Acme-StringFormat
view release on metacpan or search on metacpan
StringFormat.xs view on Meta::CPAN
PL_check[OP_MODULO] = sf_ck_modulo;
}
sf_depth++;
RETVAL = newSV(0);
sv_setref_uv(RETVAL, HINT_KEY, sf_depth);
OUTPUT:
RETVAL
void
DESTROY(...)
CODE:
Acme-TestDist-Cpp-EUMM-EUCppGuess
view release on metacpan or search on metacpan
EUCppGuess.xs view on Meta::CPAN
MODULE = Acme::TestDist::Cpp::EUMM::EUCppGuess PACKAGE = Acme::TestDist::Cpp::EUMM::EUCppGuess
int
returnOne()
OUTPUT:
RETVAL
Acme-Text-Rhombus
view release on metacpan or search on metacpan
lib/Acme/Text/Rhombus.pm view on Meta::CPAN
case => 'upper',
fillup => '.',
forward => 1,
);
__OUTPUT__
.......C.......
......DDD......
.....EEEEE.....
....FFFFFFF....
...GGGGGGGGG...
Acme-Throw
view release on metacpan or search on metacpan
lib/Acme/Throw.pm view on Meta::CPAN
perl -MAcme::Throw /path/to/program.pl
=head1 DESCRIPTION
B<THIS CODE IS CRAP! IT'S SO BAD IT MAKES THE I<COMPUTER> ANGRY!!!>
Do you feel that the error messages in your code don't express your
frustration with enough I<oomph>? Do screens full of stack dumps fill
you with a deep-seated rage?
Acme-VOYAGEGROUP-ConferenceRoom
view release on metacpan or search on metacpan
lib/Acme/VOYAGEGROUP/ConferenceRoom.pm view on Meta::CPAN
normalization => qr/^ã‚ã˜ã¨|アジト$/ms,
position => qr{ \s(/*\|)$ }x,
},
);
my %OUTPUT_OF = (
color => 'Acme::VOYAGEGROUP::ConferenceRoom::Output::Color',
json => 'Acme::VOYAGEGROUP::ConferenceRoom::Output::JSON',
xml => 'Acme::VOYAGEGROUP::ConferenceRoom::Output::XML',
message_pack => 'Acme::VOYAGEGROUP::ConferenceRoom::Output::MessagePack',
);
lib/Acme/VOYAGEGROUP/ConferenceRoom.pm view on Meta::CPAN
for my $i (@{ $process->{lines} }) {
1 while $lines[$i] =~ s{$process->{position}}{$head$1$tail};
}
if ($output_type ne 'none') {
my $module = $OUTPUT_OF{$output_type};
croak "No Type: $output_type" unless $module;
return $module->convert(\@lines) if $module->use;
}
Acme-YAPC-Okinawa-Bus
view release on metacpan or search on metacpan
lib/Acme/YAPC/Okinawa/ppport.h view on Meta::CPAN
PUSHmortal|5.009002||p
PUSHn|||
PUSHp|||
PUSHs|||
PUSHu|5.004000||p
PUTBACK|||
PadARRAY||5.021008|
PadMAX||5.021008|
PadlistARRAY||5.021008|
PadlistMAX||5.021008|
PadlistNAMESARRAY||5.021008|
lib/Acme/YAPC/Okinawa/ppport.h view on Meta::CPAN
eval_sv(sv, G_SCALAR);
SvREFCNT_dec(sv);
SPAGAIN;
sv = POPs;
PUTBACK;
if (croak_on_error && SvTRUE(GvSV(errgv)))
croak(SvPVx(GvSV(errgv), na));
return sv;
Acme-require-case
view release on metacpan or search on metacpan
t/require.t view on Meta::CPAN
my @output = split "\n", capture { require wrapper };
my $oops = 0;
like( $output[0], qr/^0 wrapper/, "saw wrapper first in call stack" ) or $oops++;
like( $output[1], qr/^1 main /, "saw main next in call stack" ) or $oops++;
diag( "OUTPUT:\n", join("\n", @output) ) if $oops;
done_testing;
#
# This file is part of Acme-require-case
#
Activator
view release on metacpan or search on metacpan
bin/activator.pl view on Meta::CPAN
next;
}
# $fq_dest_file = "$config->{sync_conf_dir}/$out";
my $tt = Template->new( { DEBUG => 1,
ABSOLUTE => 1,
OUTPUT_PATH => $config->{sync_conf_dir},
}
);
DEBUG( qq(tt processing: $fq_source_file, $config, $out ));
$tt->process( $fq_source_file, $config, $out ) || Activator::Log->logdie( $tt->error()."\n");
}
bin/activator.pl view on Meta::CPAN
return unless $out;
DEBUG( qq( processing $file into ).$config->{apache2}->{ServerRoot}.'/'.$out );
my $tt = Template->new( { DEBUG => 1,
ABSOLUTE => 1,
OUTPUT_PATH => $config->{apache2}->{ServerRoot},
}
);
$tt->process( $fq, $config, $out ) || Activator::Log->logdie( $tt->error()."\n");
# TODO: use some smart hueristics to properly chmod that which
ActiveResource
view release on metacpan or search on metacpan
lib/ActiveResource/Connection.pm view on Meta::CPAN
sub put {
my ($self, $path, $body) = @_;
my $url = $self->url($path);
my $request = HTTP::Request->new("PUT", $url);
$request->header("Content-Type" => "text/xml");
$request->content($body);
return ua->request($request);
}
Activiti-Rest-Client
view release on metacpan or search on metacpan
lib/Activiti/Rest/Client.pm view on Meta::CPAN
params => {},
headers => {
'Content-Type' => "application/json",
Content => encode_json({ action => "suspend" })
},
method => "PUT"
);
Activiti::Rest::Response->from_http_response($res);
}
sub activate_process_instance {
my($self,%args)=@_;
lib/Activiti/Rest/Client.pm view on Meta::CPAN
params => {},
headers => {
'Content-Type' => "application/json",
Content => encode_json({ action => "activate" })
},
method => "PUT"
);
Activiti::Rest::Response->from_http_response($res);
}
=head2 query_process_instances
lib/Activiti/Rest/Client.pm view on Meta::CPAN
sub update_process_instance_variable {
my($self,%args)=@_;
my $res = $self->ua->request(
path => "/runtime/process-instances/".uri_escape($args{processInstanceId})."/variables/".uri_escape($args{variableName}),
params => {},
method => "PUT",
headers => {
'Content-Type' => "application/json",
Content => encode_json($args{content})
}
);
lib/Activiti/Rest/Client.pm view on Meta::CPAN
sub signal_execution {
my($self,%args)=@_;
my $res = $self->ua->request(
path => "/runtime/executions/".uri_escape($args{executionId}),
params => {},
method => "PUT",
headers => {
'Content-Type' => "application/json",
Content => encode_json($args{content})
}
);
lib/Activiti/Rest/Client.pm view on Meta::CPAN
send signal to execution
equal to rest call:
PUT runtime/executions/{executionId}
=cut
=head2 execution
Get an execution
lib/Activiti/Rest/Client.pm view on Meta::CPAN
Body parameters: see user guide (http://www.activiti.org/userguide/index.html#N148FA)
equal to rest call:
PUT runtime/tasks/:taskId
=cut
sub update_task {
my($self,%args)=@_;
my $res = $self->ua->request(
path => "/runtime/tasks/".uri_escape($args{taskId}),
params => {},
method => "PUT",
headers => {
'Content-Type' => "application/json",
Content => encode_json($args{content})
}
);
Ado
view release on metacpan or search on metacpan
lib/Ado/Command/generate/crud.pm view on Meta::CPAN
via => [qw(GET POST)],
to => "$route#create",
over => {authenticated => 1},
},
{ route => "/$route/update/:id",
via => [qw(GET PUT)],
to => "$route#update",
over => {authenticated => 1},
},
{ route => "/$route/delete/:id",
via => [qw(GET DELETE)],
Affix
view release on metacpan or search on metacpan
dyncall/CMakeLists.txt view on Meta::CPAN
add_custom_target(show-compiler-predefs COMMAND ${CMAKE_C_COMPILER_PREDEFINES_COMMAND})
# compile_asm(TARGET target ASM_FILES file1 [file2 ...] OUTPUT_OBJECTS [variableName])
# CMake does not support the ARM or ARM64 assemblers on Windows when using the
# MSBuild generator.
# credit to dotnet/runtime:
# https://github.com/dotnet/runtime/blob/e98fb61d8b4bb6687ccddead861d8b140751647b/eng/native/functions.cmake#L173-L207
function(compile_asm)
set(options "")
set(oneValueArgs TARGET OUTPUT_OBJECTS)
set(multiValueArgs ASM_FILES)
cmake_parse_arguments(COMPILE_ASM "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGV})
set (ASSEMBLED_OBJECTS "")
dyncall/CMakeLists.txt view on Meta::CPAN
# Produce object file where CMake would store .obj files for an OBJECT library.
# ex: artifacts\obj\coreclr\windows.arm64.Debug\src\vm\wks\cee_wks.dir\Debug\AsmHelpers.obj
set (OBJ_FILE "${CMAKE_CURRENT_BINARY_DIR}/${COMPILE_ASM_TARGET}.dir/${CMAKE_CFG_INTDIR}/${name}.obj")
# Need to compile asm file using custom command as include directories are not provided to asm compiler
add_custom_command(OUTPUT ${OBJ_FILE}
COMMAND "${CMAKE_ASM_COMPILER}" ${ASM_INCLUDE_DIRECTORIES} -o ${OBJ_FILE} ${ASM_FILE}
DEPENDS ${ASM_FILE}
COMMENT "Assembling ${ASM_FILE} ---> \"${CMAKE_ASM_COMPILER}\" ${ASM_INCLUDE_DIRECTORIES} -o ${OBJ_FILE} ${ASM_FILE}"+ COMMENT "Assembling ${ASM_FILE} ---> \"${CMAKE_ASM_COMPILER}\" ${ASM_INCLUDE_DIRECTO...
# mark obj as source that does not require compile
dyncall/CMakeLists.txt view on Meta::CPAN
# Add the generated OBJ in the dependency list so that it gets consumed during linkage
list(APPEND ASSEMBLED_OBJECTS ${OBJ_FILE})
endforeach()
set(${COMPILE_ASM_OUTPUT_OBJECTS} ${ASSEMBLED_OBJECTS} PARENT_SCOPE)
endfunction()
if(MSVC)
if("${CMAKE_GENERATOR_PLATFORM}" MATCHES "ARM64")
Aion-Surf
view release on metacpan or search on metacpan
lib/Aion/Surf.pm view on Meta::CPAN
}
sub head (;$) { my $x = @_ == 0? $_: shift; surf HEAD => ref $x? @{$x}: $x }
sub get (;$) { my $x = @_ == 0? $_: shift; surf GET => ref $x? @{$x}: $x }
sub post (@) { my $x = @_ == 0? $_: \@_; surf POST => ref $x? @{$x}: $x }
sub put (@) { my $x = @_ == 0? $_: \@_; surf PUT => ref $x? @{$x}: $x }
sub patch(@) { my $x = @_ == 0? $_: \@_; surf PATCH => ref $x? @{$x}: $x }
sub del (;$) { my $x = @_ == 0? $_: shift; surf DELETE => ref $x? @{$x}: $x }
use config TELEGRAM_BOT_TOKEN => undef;
lib/Aion/Surf.pm view on Meta::CPAN
given ($request->method . " " . $request->uri) {
$response->content("get") when $_ eq "GET http://example/ex";
$response->content("head") when $_ eq "HEAD http://example/ex";
$response->content("post") when $_ eq "POST http://example/ex";
$response->content("put") when $_ eq "PUT http://example/ex";
$response->content("patch") when $_ eq "PATCH http://example/ex";
$response->content("delete") when $_ eq "DELETE http://example/ex";
$response->content('{"a":10}') when $_ eq "PATCH http://example/json";
default {
lib/Aion/Surf.pm view on Meta::CPAN
head "http://example/not-found" # -> ""
surf HEAD => "http://example/ex" # -> 1
surf HEAD => "http://example/not-found" # -> ""
[map { surf $_ => "http://example/ex" } qw/GET HEAD POST PUT PATCH DELETE/] # --> [qw/get 1 post put patch delete/]
patch "http://example/json" # --> {a => 10}
[map patch, qw! http://example/ex http://example/json !] # --> ["patch", {a => 10}]
Akamai-Edgegrid
view release on metacpan or search on metacpan
t/testdata.json view on Meta::CPAN
]
},
"expectedAuthorization": "EG1-HMAC-SHA256 client_token=akab-client-token-xxx-xxxxxxxxxxxxxxxx;access_token=akab-access-token-xxx-xxxxxxxxxxxxxxxx;timestamp=20140321T19:34:21+0000;nonce=nonce-xx-xxxx-xxxx-xxxx-xxxxxxxxxxxx;signature=Knd/jc...
},
{
"testName": "PUT test",
"request": {
"method": "PUT",
"path": "/testapi/v1/t6",
"data": "PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP"
},
"expectedAuthorization": "EG1-HMAC-SHA256 client_token=akab-client-token-xxx-xxxxxxxxxxxxxxxx;access_token=akab-access-token-xxx-xxxxxxxxxxxxxxxx;timestamp=20140321T19:34:21+0000;nonce=nonce-xx-xxxx-xxxx-xxxx-xxxxxxxxxxxx;signature=GNBWEY...
}
Akamai-Open-Client
view release on metacpan or search on metacpan
lib/Akamai/Open/Request/EdgeGridV1.pm view on Meta::CPAN
sub sign_request {
my $self = shift;
# to create a valid auth header, we'll need
# the http request method (i.e. GET, POST, PUT)
my $http_method = $self->request->method;
# the http scheme in lowercases (i.e. http or https)
my $http_scheme = $self->request->uri->scheme;
# the http host header
my $http_host = $self->request->uri->host;
# the encoded uri including the query string if present
my $http_uri = $self->request->uri->path_query;
# the canonicalized headers which are choosed for signing
my $http_headers = $self->canonicalize_headers;
# the content hash for POST/PUT requests
my $content_hash = $self->content_hash;
# and the authorization header content
my $auth_header = sprintf('%s %s;', EDGEGRIDV1ALGO,
join(';', CLIENT_TOKEN . $self->client->client_token,
ACCESS_TOKEN . $self->client->access_token,
Algorithm-AM
view release on metacpan or search on metacpan
PUSHSTACK|5.005000||Viu
PUSHSTACKi|5.005000||Viu
PUSHSTACK_INIT_HWM|5.027002||Viu
PUSHTARG|5.003007||Viu
PUSHu|5.004000|5.003007|p
PUTBACK|5.003007|5.003007|
putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
eval_sv(sv, G_SCALAR);
SvREFCNT_dec(sv);
SPAGAIN;
sv = POPs;
PUTBACK;
D_PPP_CROAK_IF_ERROR(croak_on_error);
return sv;
}
Algorithm-AdaGrad
view release on metacpan or search on metacpan
lib/Algorithm/AdaGrad.xs view on Meta::CPAN
New(__LINE__, obj, 1, struct AdaGradS);
obj->classifers = new classifers_type();
obj->eta = eta;
RETVAL = obj;
}
OUTPUT:
RETVAL
int
update(AdaGradPtr self, SV* sv)
CODE:
lib/Algorithm/AdaGrad.xs view on Meta::CPAN
handleUpdate(self, *elm);
}
}
RETVAL = 0;
}
OUTPUT:
RETVAL
int
classify(AdaGradPtr self, SV* sv)
CODE:
lib/Algorithm/AdaGrad.xs view on Meta::CPAN
margin += ag->classify(gradient);
}
RETVAL = margin >= 0 ? POSITIVE_LABEL : NEGATIVE_LABEL;
}
OUTPUT:
RETVAL
void save(AdaGradPtr self, SV* sv)
CODE:
Algorithm-AhoCorasick-XS
view release on metacpan or search on metacpan
lib/Algorithm/AhoCorasick/XS.pm view on Meta::CPAN
=item new ( ARRAYREF_OF_SUBSTRINGS )
Constructs a matcher object given an arrayref of substrings. Builds the internal
automaton.
=item matches ( INPUT )
Given a string, returns a list of the substrings which are present in the input.
There may be duplicates if a substring occurs more than once.
=item unique_matches ( INPUT )
As above but runs C<uniq> on the list for you.
=item first_match ( INPUT )
Returns the first match only (or undef if none). This is efficient - the matcher
will stop once it encounters the first match, and the rest of the string will be
ignored.
=item match_details ( INPUT )
Returns a list of hashrefs, containing the keys C<word>, C<start> and C<end>.
These correspond to an occurence of a substring - the word, start and end offset
within the string.
Algorithm-BIT-XS
view release on metacpan or search on metacpan
PUSHmortal|5.009002||p
PUSHn|||
PUSHp|||
PUSHs|||
PUSHu|5.004000||p
PUTBACK|||
PadARRAY||5.021008|
PadMAX||5.021008|
PadlistARRAY||5.021008|
PadlistMAX||5.021008|
PadlistNAMESARRAY||5.021008|
eval_sv(sv, G_SCALAR);
SvREFCNT_dec(sv);
SPAGAIN;
sv = POPs;
PUTBACK;
if (croak_on_error && SvTRUE(GvSV(errgv)))
croak(SvPVx(GvSV(errgv), na));
return sv;
Algorithm-Bertsekas
view release on metacpan or search on metacpan
lib/Algorithm/Bertsekas.pm view on Meta::CPAN
=head1 EXPORT
"auction" function by default.
=head1 INPUT
The input matrix should be in a two dimensional array (array of array)
and the 'auction' subroutine expects a reference to this array.
=head1 OUTPUT
The $output_index_ref is the reference to the output_index array.
The $assignment_ref is the reference to the assignment hash.
The $optimal is the total benefit which can be a minimum or maximum value.
Algorithm-BinarySearch-Vec
view release on metacpan or search on metacpan
vp = (uchar *)SvPVbyte(vec, len);
if (len > i*nbits/8)
RETVAL = absv_vget(vp, i, nbits);
else
RETVAL = 0;
OUTPUT:
RETVAL
##--------------------------------------------------------------
void
vset(SV *vec, ABSV_UINT i, ABSV_UINT nbits, ABSV_UINT val)
#ifdef ABSV_HAVE_QUAD
RETVAL = 1;
#else
RETVAL = 0;
#endif
OUTPUT:
RETVAL
##--------------------------------------------------------------
ABSV_UINT
KEY_NOT_FOUND()
CODE:
RETVAL = KEY_NOT_FOUND;
OUTPUT:
RETVAL
##=====================================================================
## BINARY SEARCH, element-wise
CODE:
v = SvPV(vec,vlen);
ilo = items > 3 ? SvUV(ST(3)) : 0;
ihi = items > 4 ? SvUV(ST(4)) : (vlen*8/nbits);
RETVAL = absv_bsearch(v,key,ilo,ihi,nbits);
OUTPUT:
RETVAL
##--------------------------------------------------------------
ABSV_UINT
vbsearch_lb(SV *vec, ABSV_UINT key, ABSV_UINT nbits, ...)
CODE:
v = SvPV(vec,vlen);
ilo = items > 3 ? SvUV(ST(3)) : 0;
ihi = items > 4 ? SvUV(ST(4)) : (vlen*8/nbits);
RETVAL = absv_bsearch_lb(v,key,ilo,ihi,nbits);
OUTPUT:
RETVAL
##--------------------------------------------------------------
ABSV_UINT
vbsearch_ub(SV *vec, ABSV_UINT key, ABSV_UINT nbits, ...)
CODE:
v = SvPV(vec,vlen);
ilo = items > 3 ? SvUV(ST(3)) : 0;
ihi = items > 4 ? SvUV(ST(4)) : (vlen*8/nbits);
RETVAL = absv_bsearch_ub(v,key,ilo,ihi,nbits);
OUTPUT:
RETVAL
##=====================================================================
## BINARY SEARCH, array-wise
for (i=0; i<=n; ++i) {
SV **key = av_fetch(keys, i, 0);
ABSV_UINT found = absv_bsearch(v,SvUV(*key),ilo,ihi,nbits);
av_store(RETVAL, i, newSVuv(found));
}
OUTPUT:
RETVAL
##--------------------------------------------------------------
AV*
vabsearch_lb(SV *vec, AV *keys, ABSV_UINT nbits, ...)
for (i=0; i<=n; ++i) {
SV **key = av_fetch(keys, i, 0);
ABSV_UINT found = absv_bsearch_lb(v,SvUV(*key),ilo,ihi,nbits);
av_store(RETVAL, i, newSVuv(found));
}
OUTPUT:
RETVAL
##--------------------------------------------------------------
AV*
vabsearch_ub(SV *vec, AV *keys, ABSV_UINT nbits, ...)
for (i=0; i<=n; ++i) {
SV **key = av_fetch(keys, i, 0);
ABSV_UINT found = absv_bsearch_ub(v,SvUV(*key),ilo,ihi,nbits);
av_store(RETVAL, i, newSVuv(found));
}
OUTPUT:
RETVAL
##=====================================================================
## BINARY SEARCH, vec-wise
for (i=0; i<n; ++i) {
ABSV_UINT key = absv_vget(k,i,nbits);
ABSV_UINT found = absv_bsearch(v,key,ilo,ihi,nbits);
absv_vset(rv,i,32,found);
}
OUTPUT:
RETVAL
##--------------------------------------------------------------
SV*
vvbsearch_lb(SV *vec, SV *vkeys, ABSV_UINT nbits, ...)
for (i=0; i<n; ++i) {
ABSV_UINT key = absv_vget(k,i,nbits);
ABSV_UINT found = absv_bsearch_lb(v,key,ilo,ihi,nbits);
absv_vset(rv,i,32,found);
}
OUTPUT:
RETVAL
##--------------------------------------------------------------
SV*
vvbsearch_ub(SV *vec, SV *vkeys, ABSV_UINT nbits, ...)
for (i=0; i<n; ++i) {
ABSV_UINT key = absv_vget(k,i,nbits);
ABSV_UINT found = absv_bsearch_ub(v,key,ilo,ihi,nbits);
absv_vset(rv,i,32,found);
}
OUTPUT:
RETVAL
##=====================================================================
## SET OPERATIONS
for (; ai < na; ++ai, ++ci)
absv_vset(c,ci,nbits,absv_vget(a,ai,nbits));
for (; bi < nb; ++bi, ++ci)
absv_vset(c,ci,nbits,absv_vget(b,bi,nbits));
SvCUR_set(RETVAL, ci*nbits/8);
OUTPUT:
RETVAL
##--------------------------------------------------------------
SV*
vintersect(SV *avec, SV *bvec, ABSV_UINT nbits)
absv_vset(c,ci++,nbits,aval);
}
blo = bi;
}
SvCUR_set(RETVAL, ci*nbits/8);
OUTPUT:
RETVAL
##--------------------------------------------------------------
SV*
vsetdiff(SV *avec, SV *bvec, ABSV_UINT nbits)
blo = bi;
}
for ( ; ai < na; ++ai)
absv_vset(c,ci++,nbits,absv_vget(a,ai,nbits));
SvCUR_set(RETVAL, ci*nbits/8);
OUTPUT:
RETVAL
Algorithm-Bitonic-Sort
view release on metacpan or search on metacpan
lib/Algorithm/Bitonic/Sort.pm view on Meta::CPAN
my $up = shift;
my $single_bit = shift;
my @num = @_;
my @num_new;
say "_SOME_SORTING_ALGORITHM: INPUT: ".Dumper(@num) if DEBUG;
while (my $curr = shift @num) {
say "_SOME_SORTING_ALGORITHM: for: ".Dumper($curr, $single_bit, @num) if DEBUG;
if ($up and $single_bit < $curr) {
push @num_new, $single_bit;
Algorithm-BloomFilter
view release on metacpan or search on metacpan
BloomFilter.xs view on Meta::CPAN
PROTOTYPES: DISABLE
TYPEMAP: <<HERE
bloom_t* O_OBJECT
OUTPUT
O_OBJECT
sv_setref_pv( $arg, CLASS, (void*)$var );
INPUT
O_OBJECT
if ( sv_isobject($arg) && (SvTYPE(SvRV($arg)) == SVt_PVMG) )
$var = ($type)SvIV((SV*)SvRV( $arg ));
else
BloomFilter.xs view on Meta::CPAN
new(const char *CLASS, UV n_bits, UV k_hashes)
CODE:
RETVAL = bl_alloc(n_bits, k_hashes, bl_siphash);
if (!RETVAL)
croak("Out of memory!");
OUTPUT: RETVAL
void
DESTROY(bloom_t *bl)
CODE:
bl_free(bl);
BloomFilter.xs view on Meta::CPAN
const unsigned char *str;
STRLEN len;
CODE:
str = (const unsigned char *)SvPVbyte(value, len);
RETVAL = (IV)bl_test(bl, str, len);
OUTPUT: RETVAL
SV *
serialize(bloom_t *bl)
PREINIT:
char *out;
BloomFilter.xs view on Meta::CPAN
SvPOK_on(RETVAL);
#else
RETVAL = newSVpvn(out, len);
free(out);
#endif
OUTPUT: RETVAL
bloom_t *
deserialize(const char *CLASS, SV *blob)
PREINIT:
char *str;
STRLEN len;
CODE:
str = SvPVbyte(blob, len);
RETVAL = bl_deserialize(str, len, bl_siphash);
OUTPUT: RETVAL
void
merge(bloom_t *self, bloom_t *other)
PREINIT:
int result;
Algorithm-BreakOverlappingRectangles
view release on metacpan or search on metacpan
PUSHmortal|5.009002||p
PUSHn|||
PUSHp|||
PUSHs|||
PUSHu|5.004000||p
PUTBACK|||
PerlIO_clearerr||5.007003|
PerlIO_close||5.007003|
PerlIO_context_layers||5.009004|
PerlIO_eof||5.007003|
PerlIO_error||5.007003|
eval_sv(sv, G_SCALAR);
SvREFCNT_dec(sv);
SPAGAIN;
sv = POPs;
PUTBACK;
if (croak_on_error && SvTRUE(GvSV(errgv)))
croak(SvPVx(GvSV(errgv), na));
return sv;
Algorithm-CP-IZ
view release on metacpan or search on metacpan
ENTER;
SAVETMPS;
PUSHMARK(sp);
PUTBACK;
count = call_sv(findFreeVarPerlFunc, G_SCALAR);
SPAGAIN;
ret = -1;
if (count <= 0) {
PUSHMARK(sp);
XPUSHs(sv_2mortal(newSViv(index)));
XPUSHs(sv_2mortal(newSViv(val)));
PUTBACK;
count = call_sv(criteriaPerlFunc, G_SCALAR);
SPAGAIN;
ret = -1;
if (count == 0) {
ENTER;
SAVETMPS;
PUSHMARK(sp);
PUTBACK;
call_sv(foundPerlFunc, G_VOID);
SPAGAIN;
FREETMPS;
LEAVE;
PUSHMARK(sp);
/* index is pointing to context in perl code */
XPUSHs(sv_2mortal(newSViv(index)));
PUTBACK;
call_sv(backtrackPerlFunc, G_VOID);
SPAGAIN;
FREETMPS;
LEAVE;
ENTER;
SAVETMPS;
PUSHMARK(sp);
PUTBACK;
count = call_sv((SV*)ext, G_SCALAR);
SPAGAIN;
ret = -1;
if (count == 0) {
PUSHMARK(sp);
XPUSHs(sv_2mortal(newSViv(val)));
XPUSHs(sv_2mortal(newSViv(index)));
PUTBACK;
count = call_sv((SV*)ext, G_SCALAR);
SPAGAIN;
ret = -1;
if (count == 0) {
PUSHMARK(sp);
XPUSHs(sv_2mortal(newSViv(index)));
XPUSHs(sv_2mortal(newSViv(oldValue)));
PUTBACK;
count = call_sv((SV*)ext, G_SCALAR);
SPAGAIN;
ret = -1;
if (count == 0) {
paramVar = sv_newmortal();
sv_setiv(newSVrv(paramVar, PACKAGE_INT), PTR2IV(vars[index]));
XPUSHs(paramVar);
XPUSHs(sv_2mortal(newSViv(index)));
PUTBACK;
if (vsSimpleArray[index].init)
count = call_sv(vsSimpleArray[index].init, G_ARRAY);
else
count = 0;
SPAGAIN;
if (count > 0) {
obj = POPs;
SvREFCNT_inc(obj);
PUTBACK;
}
FREETMPS;
LEAVE;
}
sv_setiv(newSVrv(paramVar, PACKAGE_INT), PTR2IV(vars[index]));
XPUSHs(obj);
XPUSHs(paramVar);
XPUSHs(sv_2mortal(newSViv(index)));
PUTBACK;
count = call_method("next", G_ARRAY);
SPAGAIN;
if (count >= 2) {
SV *v = POPs;
}
else {
ret = FALSE;
}
PUTBACK;
FREETMPS;
LEAVE;
}
ENTER;
SAVETMPS;
PUSHMARK(sp);
PUTBACK;
count = call_sv(maxFailPerlFunc, G_SCALAR);
SPAGAIN;
ret = -1;
if (count <= 0) {
}
r = newRV_noinc((SV*)elements);
XPUSHs(sv_2mortal((SV*)r));
PUTBACK;
{
int count = call_method(meth, G_ARRAY);
SPAGAIN;
if (count > 0) {
ret = sv_true(POPs);
PUSHMARK(SP);
XPUSHs(sv_2mortal((SV*)newRV(ext)));
XPUSHs(sv_2mortal((SV*)newSViv(maxFails)));
PUTBACK;
call_method("search_start", G_DISCARD);
FREETMPS;
LEAVE;
}
XPUSHs(sv_2mortal((SV*)newRV(ext)));
XPUSHs(sv_2mortal((SV*)newSViv(result)));
XPUSHs(sv_2mortal((SV*)newSViv(nbFails)));
XPUSHs(sv_2mortal((SV*)newSViv(maxFails)));
PUTBACK;
call_method("search_end", G_DISCARD);
FREETMPS;
LEAVE;
}
XPUSHs(sv_2mortal((SV*)newSViv(depth)));
XPUSHs(sv_2mortal((SV*)newSViv(index)));
XPUSHs(sv_2mortal((SV*)newSViv(vs->method)));
XPUSHs(sv_2mortal((SV*)newSViv(vs->value)));
PUTBACK;
call_method("before_value_selection", G_DISCARD);
FREETMPS;
LEAVE;
}
XPUSHs(sv_2mortal((SV*)newSViv(depth)));
XPUSHs(sv_2mortal((SV*)newSViv(index)));
XPUSHs(sv_2mortal((SV*)newSViv(vs->method)));
XPUSHs(sv_2mortal((SV*)newSViv(vs->value)));
PUTBACK;
call_method("after_value_selection", G_DISCARD);
FREETMPS;
LEAVE;
}
PUSHMARK(SP);
XPUSHs(sv_2mortal((SV*)newRV(ext)));
XPUSHs(sv_2mortal((SV*)newSViv(depth)));
XPUSHs(sv_2mortal((SV*)newSViv(index)));
PUTBACK;
call_method("enter", G_DISCARD);
FREETMPS;
LEAVE;
}
PUSHMARK(SP);
XPUSHs(sv_2mortal((SV*)newRV(ext)));
XPUSHs(sv_2mortal((SV*)newSViv(depth)));
XPUSHs(sv_2mortal((SV*)newSViv(index)));
PUTBACK;
call_method("leave", G_DISCARD);
FREETMPS;
LEAVE;
}
SAVETMPS;
PUSHMARK(SP);
XPUSHs(sv_2mortal((SV*)newRV(ext)));
XPUSHs(sv_2mortal((SV*)newSViv(depth)));
PUTBACK;
count = call_method("found", G_SCALAR);
SPAGAIN;
ret = 0;
if (count > 0) {
for (i = 0; i<alen; i++) {
SV** pptr = av_fetch(av, i, 0);
array[i] = INT2PTR(CSint*, SvIV(*pptr));
}
OUTPUT:
RETVAL
void*
alloc_int_array(av)
AV *av;
for (i = 0; i<alen; i++) {
SV** pptr = av_fetch(av, i, 0);
array[i] = SvIV(*pptr);
}
OUTPUT:
RETVAL
void
free_array(ptr)
int
cs_saveContext()
CODE:
RETVAL = cs_saveContext();
OUTPUT:
RETVAL
void
cs_restoreContext()
CODE:
int get_nb_fails(iz)
void* iz
CODE:
RETVAL = cs_getNbFails();
OUTPUT:
RETVAL
void
cs_forgetSaveContext()
CODE:
int get_nb_choice_points(iz)
void* iz
CODE:
RETVAL = cs_getNbChoicePoints();
OUTPUT:
RETVAL
void*
cs_createCSint(min, max)
int min
int max
CODE:
RETVAL = cs_createCSint(min, max);
OUTPUT:
RETVAL
void*
cs_createCSintFromDomain(parray, size)
void* parray
CODE:
if (size <= 0)
RETVAL = 0;
else
RETVAL = cs_createCSintFromDomain(parray, size);
OUTPUT:
RETVAL
int
cs_search(av, func_id, func_ref, max_fail)
AV *av
max_fail = INT_MAX;
RETVAL = cs_searchFail(array,
(int)alen, findFreeVarWrapper, max_fail);
Safefree(array);
OUTPUT:
RETVAL
int
cs_searchCriteria(av, findvar_id, findvar_ref, criteria_ref, max_fail)
AV *av
(int)alen,
currentArray2IndexFunc,
criteriaPerlWrapper,
max_fail);
Safefree(array);
OUTPUT:
RETVAL
int
cs_findAll(av, findvar_id, findvar_ref, found_ref)
AV *av
}
RETVAL = cs_findAll(array, (int)alen,
findFreeVarWrapper, foundPerlWrapper);
Safefree(array);
OUTPUT:
RETVAL
void
cs_backtrack(vint, index, handler)
void* vint
int size
SV* handler
CODE:
RETVAL = cs_eventAllKnown(tint, size,
eventAllKnownPerlWrapper, SvRV(handler));
OUTPUT:
RETVAL
int
cs_eventKnown(tint, size, handler)
void* tint
int size
SV* handler
CODE:
RETVAL = cs_eventKnown(tint, size,
eventKnownPerlWrapper, SvRV(handler));
OUTPUT:
RETVAL
void
cs_eventNewMin(tint, size, handler)
void* tint
int
cs_getNbElements(vint)
void* vint
CODE:
RETVAL = cs_getNbElements(vint);
OUTPUT:
RETVAL
int
cs_getMin(vint)
void* vint
CODE:
RETVAL = cs_getMin(vint);
OUTPUT:
RETVAL
int
cs_getMax(vint)
void* vint
CODE:
RETVAL = cs_getMax(vint);
OUTPUT:
RETVAL
int
cs_getValue(vint)
void* vint
CODE:
if (cs_isFree(vint))
croak("variable is not unstantiated.");
RETVAL = cs_getValue(vint);
OUTPUT:
RETVAL
void
cs_domain(vint, av)
void* vint
cs_getNextValue(vint, val)
void* vint
int val
CODE:
RETVAL = cs_getNextValue(vint, val);
OUTPUT:
RETVAL
int
cs_getPreviousValue(vint, val)
void* vint
int val
CODE:
RETVAL = cs_getPreviousValue(vint, val);
OUTPUT:
RETVAL
int
cs_AllNeq(tint, size)
void* tint
int size
CODE:
RETVAL = cs_AllNeq(tint, size);
OUTPUT:
RETVAL
int
cs_InArray(vint, array, size)
void* vint
void* array
int size
CODE:
RETVAL = cs_InArray(vint, array, size);
OUTPUT:
RETVAL
int
cs_NotInArray(vint, array, size)
void* vint
void* array
int size
CODE:
RETVAL = cs_NotInArray(vint, array, size);
OUTPUT:
RETVAL
int
cs_InInterval(vint, minVal, maxVal)
void* vint
int minVal
int maxVal
CODE:
RETVAL = cs_InInterval(vint, minVal, maxVal);
OUTPUT:
RETVAL
int
cs_NotInInterval(vint, minVal, maxVal)
void* vint
int minVal
int maxVal
CODE:
RETVAL = cs_NotInInterval(vint, minVal, maxVal);
OUTPUT:
RETVAL
void*
cs_Add(vint1, vint2)
void* vint1
void* vint2
CODE:
RETVAL = cs_Add(vint1, vint2);
OUTPUT:
RETVAL
void*
cs_Mul(vint1, vint2)
void* vint1
void* vint2
CODE:
RETVAL = cs_Mul(vint1, vint2);
OUTPUT:
RETVAL
void*
cs_Sub(vint1, vint2)
void* vint1
void* vint2
CODE:
RETVAL = cs_Sub(vint1, vint2);
OUTPUT:
RETVAL
void*
cs_Div(vint1, vint2)
void* vint1
void* vint2
CODE:
RETVAL = cs_Div(vint1, vint2);
OUTPUT:
RETVAL
void*
cs_Sigma(tint, size)
void* tint
int size
CODE:
RETVAL = cs_Sigma(tint, size);
OUTPUT:
RETVAL
void*
cs_ScalProd(vars, coeffs, n)
void* vars
void* coeffs
int n
CODE:
RETVAL = cs_ScalProd(vars, coeffs, n);
OUTPUT:
RETVAL
void*
cs_Abs(vint)
void* vint
CODE:
RETVAL = cs_Abs(vint);
OUTPUT:
RETVAL
void*
cs_Min(tint, size)
void* tint
int size
CODE:
RETVAL = cs_Min(tint, size);
OUTPUT:
RETVAL
void*
cs_Max(tint, size)
void* tint
int size
CODE:
RETVAL = cs_Max(tint, size);
OUTPUT:
RETVAL
int
cs_IfEq(vint1, vint2, val1, val2)
void* vint1
void* vint2
int val1
int val2
CODE:
RETVAL = cs_IfEq(vint1, vint2, val1, val2);
OUTPUT:
RETVAL
int
cs_IfNeq(vint1, vint2, val1, val2)
void* vint1
void* vint2
int val1
int val2
CODE:
RETVAL = cs_IfNeq(vint1, vint2, val1, val2);
OUTPUT:
RETVAL
void*
cs_OccurDomain(val, array, size)
int val
void* array
int size
CODE:
RETVAL = cs_OccurDomain(val, array, size);
OUTPUT:
RETVAL
int
cs_OccurConstraints(vint, val, array, size)
void* vint
int val
void* array
int size
CODE:
RETVAL = cs_OccurConstraints(vint, val, array, size);
OUTPUT:
RETVAL
void*
cs_Index(array, size, val)
void* array
int size
int val
CODE:
RETVAL = cs_Index(array, size, val);
OUTPUT:
RETVAL
void*
cs_Element(index, values, size)
void* index
void* values
int size
CODE:
RETVAL = cs_Element(index, values, size);
OUTPUT:
RETVAL
void*
cs_VarElement(index, values, size)
void* index
void* values
int size
CODE:
RETVAL = cs_VarElement(index, values, size);
OUTPUT:
RETVAL
#if (IZ_VERSION_MAJOR == 3 && IZ_VERSION_MINOR >= 6)
void*
void* index
void* values
int size
CODE:
RETVAL = cs_VarElementRange(index, values, size);
OUTPUT:
RETVAL
int
cs_Cumulative(s, d, r, size, limit)
void* s
void* r
int size
void* limit
CODE:
RETVAL = cs_Cumulative(s, d, r, size, limit);
OUTPUT:
RETVAL
int
cs_Disjunctive(s, d, size)
void* s
void* d
int size
CODE:
RETVAL = cs_Disjunctive(s, d, size);
OUTPUT:
RETVAL
#endif /* (IZ_VERSION_MAJOR == 3 && IZ_VERSION_MINOR >= 6) */
#if (IZ_VERSION_MAJOR == 3 && IZ_VERSION_MINOR >= 7)
int q0
void* farray
int fsize
CODE:
RETVAL = cs_Regular(tint, size, darray, Q, S, q0, farray, fsize);
OUTPUT:
RETVAL
#endif /* (IZ_VERSION_MAJOR == 3 && IZ_VERSION_MINOR >= 6) */
int
}
}
else {
RETVAL = cs_getNextValue(vint, val);
}
OUTPUT:
RETVAL
#if (IZ_VERSION_MAJOR == 3 && IZ_VERSION_MINOR >= 6)
void
void*
cs_getValueSelector(vs)
int vs
CODE:
RETVAL = (void*)cs_getValueSelector(vs);
OUTPUT:
RETVAL
void*
valueSelector_init(vs, index, array, size)
void* vs;
Newx(ext, 1, int);
if (ext) {
cs_initValueSelector(vs, index, array, size, ext);
}
RETVAL = ext;
OUTPUT:
RETVAL
void
cs_selectNextValue(vs, index, array, size, ext)
void* vs
int rc;
CODE:
rc = cs_endValueSelector(vs, index, array, size, ext);
Safefree(ext);
RETVAL = rc;
OUTPUT:
RETVAL
void*
createSimpleValueSelector()
CODE:
if (vsSimpleObjRef == 0) {
vsSimpleObj = cs_createValueSelector(vsSimpleInit, vsSimpleNext, vsSimpleEnd);
}
vsSimpleObjRef++;
RETVAL = vsSimpleObj;
OUTPUT:
RETVAL
void
deleteSimpleValueSelector()
CODE:
RETVAL = TRUE;
}
else {
RETVAL = FALSE;
}
OUTPUT:
RETVAL
void*
cs_createNoGoodSet(av, size, prefilter_is_defined, max_no_good, ngsObj)
void* av
RETVAL = cs_createNoGoodSet(av, size,
(prefilter_is_defined
? noGoodSetPrefilterPerlWrapper : NULL),
max_no_good,
noGoodSetDestoryPerlWrapper, ngsObj);
OUTPUT:
RETVAL
void
cs_filterNoGood(ngs)
void* ngs
void* ngs
CODE:
if (!ngs)
croak("cs_getNbNoGoods: not initialized.");
RETVAL = cs_getNbNoGoods(ngs);
OUTPUT:
RETVAL
int
cs_searchValueSelectorFail(av, vs, findvar_id, findvar_ref, max_fail, nf_ref)
AV *av
currentArray2IndexFunc,
max_fail,
(nf_ref ? INT2PTR(CSsearchNotify*, SvIV(nf_ref)) : NULL));
Safefree(array);
Safefree(vs_array);
OUTPUT:
RETVAL
int
cs_searchValueSelectorRestartNG(av, vs, findvar_id, findvar_ref, max_fail_func, max_fail, ngs, nf_ref)
AV *av
max_fail,
INT2PTR(CSnoGoodSet*, SvIV(ngs)),
(nf_ref ? INT2PTR(CSsearchNotify*, SvIV(nf_ref)) : NULL));
Safefree(array);
Safefree(vs_array);
OUTPUT:
RETVAL
int
cs_selectValue(rv, method, value)
CSvalueSelection vs;
CODE:
vs.method = method;
vs.value = value;
RETVAL = cs_selectValue(INT2PTR(CSint*, SvIV(SvRV(rv))), &vs);
OUTPUT:
RETVAL
void*
cs_createSearchNotify(obj)
SV* obj
CODE:
RETVAL = cs_createSearchNotify(SvRV(obj));
OUTPUT:
RETVAL
void
searchNotify_set_search_start(notify)
SV* notify
int
nb_elements(rv)
SV* rv;
CODE:
RETVAL = cs_getNbElements(INT2PTR(CSint*, SvIV(SvRV(rv))));
OUTPUT:
RETVAL
int
nb_constraints(rv)
SV* rv;
CODE:
RETVAL = cs_getNbConstraints(INT2PTR(CSint*, SvIV(SvRV(rv))));
OUTPUT:
RETVAL
int
min(rv)
SV* rv;
CODE:
RETVAL = cs_getMin(INT2PTR(CSint*, SvIV(SvRV(rv))));
OUTPUT:
RETVAL
int
max(rv)
SV* rv;
CODE:
RETVAL = cs_getMax(INT2PTR(CSint*, SvIV(SvRV(rv))));
OUTPUT:
RETVAL
int
value(rv)
SV* rv;
CODE:
RETVAL = cs_getValue(INT2PTR(CSint*, SvIV(SvRV(rv))));
OUTPUT:
RETVAL
int
is_free(rv)
SV* rv;
CODE:
RETVAL = cs_isFree(INT2PTR(CSint*, SvIV(SvRV(rv))));
OUTPUT:
RETVAL
int
is_instantiated(rv)
SV* rv;
CODE:
RETVAL = cs_isInstantiated(INT2PTR(CSint*, SvIV(SvRV(rv))));
OUTPUT:
RETVAL
int
get_next_value(rv, val)
SV* rv;
int val;
CODE:
RETVAL = cs_getNextValue(INT2PTR(CSint*, SvIV(SvRV(rv))), val);
OUTPUT:
RETVAL
int
get_previous_value(rv, val)
SV* rv;
int val;
CODE:
RETVAL = cs_getPreviousValue(INT2PTR(CSint*, SvIV(SvRV(rv))), val);
OUTPUT:
RETVAL
int
is_in(rv, val)
SV* rv;
int val;
CODE:
RETVAL = cs_isIn(INT2PTR(CSint*, SvIV(SvRV(rv))), val);
OUTPUT:
RETVAL
int
Eq(rv, val)
SV* rv;
RETVAL = cs_Eq(vint1, vint2);
}
else {
RETVAL = cs_EQ(vint1, (int)SvIV(val));
}
OUTPUT:
RETVAL
int
Neq(rv, val)
SV* rv;
RETVAL = cs_Neq(vint1, vint2);
}
else {
RETVAL = cs_NEQ(vint1, (int)SvIV(val));
}
OUTPUT:
RETVAL
int
Le(rv, val)
SV* rv;
RETVAL = cs_Le(vint1, vint2);
}
else {
RETVAL = cs_LE(vint1, (int)SvIV(val));
}
OUTPUT:
RETVAL
int
Lt(rv, val)
SV* rv;
RETVAL = cs_Lt(vint1, vint2);
}
else {
RETVAL = cs_LT(vint1, (int)SvIV(val));
}
OUTPUT:
RETVAL
int
Ge(rv, val)
SV* rv;
RETVAL = cs_Ge(vint1, vint2);
}
else {
RETVAL = cs_GE(vint1, (int)SvIV(val));
}
OUTPUT:
RETVAL
int
Gt(rv, val)
SV* rv;
RETVAL = cs_Gt(vint1, vint2);
}
else {
RETVAL = cs_GT(vint1, (int)SvIV(val));
}
OUTPUT:
RETVAL
AV *
domain(rv)
SV* rv;
i = 0;
for (val = cs_getMin(vint); val <= maxVal; val++) {
if (!cs_isIn(vint, val)) continue;
av_store(RETVAL, i++, newSViv(val));
}
OUTPUT:
RETVAL
void
set_name(rv, s)
SV* rv;
vint = INT2PTR(CSint*, SvIV(SvRV(rv)));
cstr = cs_getName(vint);
if (!cstr) XSRETURN_UNDEF;
RETVAL = newSVpv(cstr, strlen(cstr));
SvUTF8_on(RETVAL);
OUTPUT:
RETVAL
Algorithm-CRF
view release on metacpan or search on metacpan
fprintf (stderr,"%s\n",encoder.what());
RETVAL = -1;
} else
RETVAL = 0;
}
OUTPUT:
RETVAL
Algorithm-Cluster
view release on metacpan or search on metacpan
perl/Record.pm view on Meta::CPAN
else {
$extension = 'atr';
$keyword = 'ARRY';
}
my $nnodes = $tree->length;
open OUTPUT, ">$jobname.$extension" or die 'Error: Unable to open output file';
my @nodeID = ('') x $nnodes;
my @nodedist;
my $i;
for ($i = 0; $i < $nnodes; $i++) {
my $node = $tree->get($i);
perl/Record.pm view on Meta::CPAN
}
for (my $nodeindex = 0; $nodeindex < $nnodes; $nodeindex++) {
my $min1 = $tree->get($nodeindex)->left;
my $min2 = $tree->get($nodeindex)->right;
$nodeID[$nodeindex] = "NODE" . ($nodeindex+1) . "X";
print OUTPUT $nodeID[$nodeindex];
print OUTPUT "\t";
if ($min1 < 0) {
my $index1 = -$min1-1;
print OUTPUT $nodeID[$index1];
print OUTPUT "\t";
if ($nodedist[$index1] > $nodedist[$nodeindex]) {
$nodedist[$nodeindex] = $nodedist[$index1];
}
}
else {
print OUTPUT $keyword . $min1 . "X\t";
}
if ($min2 < 0) {
my $index2 = -$min2-1;
print OUTPUT $nodeID[$index2];
print OUTPUT "\t";
if ($nodedist[$index2] > $nodedist[$nodeindex]) {
$nodedist[$nodeindex] = $nodedist[$index2];
}
}
else {
print OUTPUT $keyword . $min2 . "X\t";
}
print OUTPUT 1.0-$nodedist[$nodeindex];
print OUTPUT "\n";
}
close(OUTPUT);
# Now set up order based on the tree structure
return $tree->sort(\@order);
}
sub _savekmeans {
perl/Record.pm view on Meta::CPAN
}
else {
$label = 'ARRAY';
@names = @{$self->{expid}};
}
open OUTPUT, ">$filename" or die 'Error: Unable to open output file';
print OUTPUT "$label\tGROUP\n";
my $n = scalar @names;
my @result = sort { $order[$a] <=> $order[$b] } (0..$n-1);
my @sortedindex;
my $cluster = 0;
while (scalar @sortedindex < $n) {
foreach (@result) {
my $j = $_;
my $cid = $clusterids[$j];
if ($clusterids[$j]==$cluster) {
print OUTPUT $names[$j] . "\t$cluster\n";
push (@sortedindex, $j);
}
}
$cluster++;
}
close(OUTPUT);
return @sortedindex;
}
sub _savedata {
my ($self, %param) = @_;
perl/Record.pm view on Meta::CPAN
else {
@genename = @{$self->{geneid}};
}
my $ngenes = scalar @{$self->{geneid}};
my $nexps = scalar @{$self->{expid}};
open OUTPUT, ">$jobname.cdt" or die 'Error: Unable to open output file';
my @mask;
if (defined $self->{mask}) {
@mask = @{$self->{mask}};
}
else {
perl/Record.pm view on Meta::CPAN
}
else {
@eweight = (1) x $nexps;
}
if ($gid) {
print OUTPUT "GID\t";
}
print OUTPUT $self->{uniqid};
print OUTPUT "\tNAME\tGWEIGHT";
# Now add headers for data columns
foreach (@expindex) {
print OUTPUT "\t" . $self->{expid}[$_];
}
print OUTPUT "\n";
if ($aid) {
print OUTPUT "AID";
if ($gid) {
print OUTPUT "\t";
}
print OUTPUT "\t\t";
foreach (@expindex) {
print OUTPUT "\tARRY" . $_ . 'X';
}
print OUTPUT "\n";
}
print OUTPUT "EWEIGHT";
if ($gid) {
print OUTPUT "\t";
}
print OUTPUT "\t\t";
foreach (@expindex) {
print OUTPUT "\t" . $eweight[$_];
}
print OUTPUT "\n";
foreach (@geneindex) {
my $i = $_;
if ($gid) {
print OUTPUT "GENE" . $i . "X\t";
}
print OUTPUT $self->{geneid}[$i] . "\t" . $genename[$i] . "\t" . $gweight[$i];
foreach (@expindex) {
my $j = $_;
print OUTPUT "\t";
if ($mask[$i][$j]) {
print OUTPUT $self->{data}[$i][$j];
}
}
print OUTPUT "\n";
}
close(OUTPUT);
}
1;
Algorithm-ConsistentHash-CHash
view release on metacpan or search on metacpan
MODULE = Algorithm::ConsistentHash::CHash PACKAGE = Algorithm::ConsistentHash::CHash
TYPEMAP: <<HERE
struct chash_t * O_OBJECT
OUTPUT
O_OBJECT
sv_setref_pv( $arg, CLASS, (void*)$var );
INPUT
O_OBJECT
if ( sv_isobject($arg) && (SvTYPE(SvRV($arg)) == SVt_PVMG) )
$var = INT2PTR($type, SvIV((SV*)SvRV( $arg )));
else
/* fprintf(stderr, "nkeys => %u, replicas => %u\n", nkeys, replicas); */
RETVAL = chash_create(keys, lens, nkeys, replicas);
if (RETVAL == NULL)
croak("Unknown error");
OUTPUT: RETVAL
void
DESTROY(self)
struct chash_t *self
STRLEN key_len;
CODE:
key_str = SvPVbyte(key, key_len);
chash_lookup(self, key_str, key_len, &out_str, &out_str_len);
RETVAL = newSVpvn(out_str, out_str_len);
OUTPUT: RETVAL
( run in 0.776 second using v1.01-cache-2.11-cpan-d6f9594c0a5 )