Result:
found more than 560 distributions - search limited to the first 2001 files matching your query
( run in 0.769 )
JavaScript-Duktape-XS
view release on metacpan or search on metacpan
*/
duk_fatal_function fatal_func;
/* Main list of allocated heap objects. Objects are either here,
* in finalize_list waiting for processing, or in refzero_list
* temporarily while a DECREF refzero cascade finishes.
*/
duk_heaphdr *heap_allocated;
/* Temporary work list for freeing a cascade of objects when a DECREF
* (or DECREF_NORZ) encounters a zero refcount. Using a work list
* allows fixed C stack size when refcounts go to zero for a chain of
* objects. Outside of DECREF this is always a NULL because DECREF is
* processed without side effects (only memory free calls).
*/
*
* List processing assumes refcounts are kept up-to-date at all times, so
* that once the finalizer returns, a zero refcount is a reliable reason to
* free the object immediately rather than place it back to the heap. This
* is the case because we run outside of refzero_list processing so that
* DECREF cascades are handled fully inline.
*
* For mark-and-sweep queued objects (had_zero_refcount false) the object
* may be freed immediately if its refcount is zero after the finalizer call
* (i.e. finalizer removed the reference loop for the object). If not, the
* next mark-and-sweep will collect the object unless it has become reachable
* the refcounts.
*
* Note that any of the DECREFs may cause a refcount to drop to zero. If so,
* the object won't be refzero processed inline, but will just be queued to
* refzero_list and processed by an earlier caller working on refzero_list,
* eliminating C recursion from even long refzero cascades. If refzero
* finalization is triggered by mark-and-sweep, refzero conditions are ignored
* (objects are not even queued to refzero_list) because mark-and-sweep deals
* with them; refcounts are still updated so that they remain in sync with
* actual references.
*/
* - When we're done with the current object, read its 'prev' pointer and
* free the object. If 'prev' is NULL, we've reached head of list and are
* done: set refzero_list to NULL and process pending finalizers. Otherwise
* continue processing the list.
*
* A refzero cascade is free of side effects because it only involves
* queueing more objects and freeing memory; finalizer execution is blocked
* in the code path queueing objects to finalize_list. As a result the
* initial refzero call (which triggers duk__refcount_free_pending()) must
* check finalize_list so that finalizers are executed snappily.
*
* If finalize_list processing starts first, refzero may occur while we're
* processing finalizers. That's fine: that particular refzero cascade is
* handled to completion without side effects. Once the cascade is complete,
* we'll run pending finalizers but notice that we're already doing that and
* return.
*
* This could be expanded to allow incremental freeing: just bail out
* early and resume at a future alloc/decref/refzero. However, if that
#endif
DUK_HEAP_INSERT_INTO_FINALIZE_LIST(heap, hdr);
/* Process finalizers unless skipping is explicitly
* requested (NORZ) or refzero_list is being processed
* (avoids side effects during a refzero cascade).
* If refzero_list is processed, the initial refzero
* call will run pending finalizers when refzero_list
* is done.
*/
if (!skip_free_pending && heap->refzero_list == NULL) {
heap->refzero_list = hdr;
if (root == NULL) {
/* Object is now queued. Refzero_list was NULL so
* no-one is currently processing it; do it here.
* With refzero processing just doing a cascade of
* free calls, we can process it directly even when
* NORZ macros are used: there are no side effects.
*/
duk__refcount_free_pending(heap);
DUK_ASSERT(heap->refzero_list == NULL);
/* Process finalizers only after the entire cascade
* is finished. In most cases there's nothing to
* finalize, so fast path check to avoid a call.
*/
#if defined(DUK_USE_FINALIZER_SUPPORT)
if (!skip_free_pending && DUK_UNLIKELY(heap->finalize_list != NULL)) {
/*
* Incref and decref functions.
*
* Decref may trigger immediate refzero handling, which may free and finalize
* an arbitrary number of objects (a "DECREF cascade").
*
* Refzero handling is skipped entirely if (1) mark-and-sweep is running or
* (2) execution is paused in the debugger. The objects are left in the heap,
* and will be freed by mark-and-sweep or eventual heap destruction.
*
*
* Also, a GC triggered during this reallocation process must not interfere
* with the object being resized. This is currently controlled by preventing
* finalizers (as they may affect ANY object) and object compaction in
* mark-and-sweep. It would suffice to protect only this particular object
* from compaction, however. DECREF refzero cascades are side effect free
* and OK.
*
* Note: because we need to potentially resize the valstack (as part
* of abandoning the array part), any tval pointers to the valstack
* will become invalid after this call.
}
DUK_DD(DUK_DDPRINT("-> throw not caught by current thread, yield error to resumer and recheck longjmp"));
/* Not caught by current thread, thread terminates (yield error to resumer);
* note that this may cause a cascade if the resumer terminates with an uncaught
* exception etc (this is OK, but needs careful testing).
*/
DUK_ASSERT(thr->resumer != NULL);
DUK_ASSERT(thr->resumer->callstack_top >= 2); /* ECMAScript activation + Duktape.Thread.resume() activation */
JavaScript-Embedded
view release on metacpan or search on metacpan
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
*/
duk_fatal_function fatal_func;
/* Main list of allocated heap objects. Objects are either here,
* in finalize_list waiting for processing, or in refzero_list
* temporarily while a DECREF refzero cascade finishes.
*/
duk_heaphdr *heap_allocated;
/* Temporary work list for freeing a cascade of objects when a DECREF
* (or DECREF_NORZ) encounters a zero refcount. Using a work list
* allows fixed C stack size when refcounts go to zero for a chain of
* objects. Outside of DECREF this is always a NULL because DECREF is
* processed without side effects (only memory free calls).
*/
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
*
* List processing assumes refcounts are kept up-to-date at all times, so
* that once the finalizer returns, a zero refcount is a reliable reason to
* free the object immediately rather than place it back to the heap. This
* is the case because we run outside of refzero_list processing so that
* DECREF cascades are handled fully inline.
*
* For mark-and-sweep queued objects (had_zero_refcount false) the object
* may be freed immediately if its refcount is zero after the finalizer call
* (i.e. finalizer removed the reference loop for the object). If not, the
* next mark-and-sweep will collect the object unless it has become reachable
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
* the refcounts.
*
* Note that any of the DECREFs may cause a refcount to drop to zero. If so,
* the object won't be refzero processed inline, but will just be queued to
* refzero_list and processed by an earlier caller working on refzero_list,
* eliminating C recursion from even long refzero cascades. If refzero
* finalization is triggered by mark-and-sweep, refzero conditions are ignored
* (objects are not even queued to refzero_list) because mark-and-sweep deals
* with them; refcounts are still updated so that they remain in sync with
* actual references.
*/
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
* - When we're done with the current object, read its 'prev' pointer and
* free the object. If 'prev' is NULL, we've reached head of list and are
* done: set refzero_list to NULL and process pending finalizers. Otherwise
* continue processing the list.
*
* A refzero cascade is free of side effects because it only involves
* queueing more objects and freeing memory; finalizer execution is blocked
* in the code path queueing objects to finalize_list. As a result the
* initial refzero call (which triggers duk__refcount_free_pending()) must
* check finalize_list so that finalizers are executed snappily.
*
* If finalize_list processing starts first, refzero may occur while we're
* processing finalizers. That's fine: that particular refzero cascade is
* handled to completion without side effects. Once the cascade is complete,
* we'll run pending finalizers but notice that we're already doing that and
* return.
*
* This could be expanded to allow incremental freeing: just bail out
* early and resume at a future alloc/decref/refzero. However, if that
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
#endif
DUK_HEAP_INSERT_INTO_FINALIZE_LIST(heap, hdr);
/* Process finalizers unless skipping is explicitly
* requested (NORZ) or refzero_list is being processed
* (avoids side effects during a refzero cascade).
* If refzero_list is processed, the initial refzero
* call will run pending finalizers when refzero_list
* is done.
*/
if (!skip_free_pending && heap->refzero_list == NULL) {
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
heap->refzero_list = hdr;
if (root == NULL) {
/* Object is now queued. Refzero_list was NULL so
* no-one is currently processing it; do it here.
* With refzero processing just doing a cascade of
* free calls, we can process it directly even when
* NORZ macros are used: there are no side effects.
*/
duk__refcount_free_pending(heap);
DUK_ASSERT(heap->refzero_list == NULL);
/* Process finalizers only after the entire cascade
* is finished. In most cases there's nothing to
* finalize, so fast path check to avoid a call.
*/
#if defined(DUK_USE_FINALIZER_SUPPORT)
if (!skip_free_pending && DUK_UNLIKELY(heap->finalize_list != NULL)) {
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
/*
* Incref and decref functions.
*
* Decref may trigger immediate refzero handling, which may free and finalize
* an arbitrary number of objects (a "DECREF cascade").
*
* Refzero handling is skipped entirely if (1) mark-and-sweep is running or
* (2) execution is paused in the debugger. The objects are left in the heap,
* and will be freed by mark-and-sweep or eventual heap destruction.
*
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
*
* Also, a GC triggered during this reallocation process must not interfere
* with the object being resized. This is currently controlled by preventing
* finalizers (as they may affect ANY object) and object compaction in
* mark-and-sweep. It would suffice to protect only this particular object
* from compaction, however. DECREF refzero cascades are side effect free
* and OK.
*
* Note: because we need to potentially resize the valstack (as part
* of abandoning the array part), any tval pointers to the valstack
* will become invalid after this call.
lib/JavaScript/Embedded/C/lib/duktape.c view on Meta::CPAN
}
DUK_DD(DUK_DDPRINT("-> throw not caught by current thread, yield error to resumer and recheck longjmp"));
/* Not caught by current thread, thread terminates (yield error to resumer);
* note that this may cause a cascade if the resumer terminates with an uncaught
* exception etc (this is OK, but needs careful testing).
*/
DUK_ASSERT(thr->resumer != NULL);
DUK_ASSERT(thr->resumer->callstack_top >= 2); /* ECMAScript activation + Duktape.Thread.resume() activation */
JavaScript-ExtJS-V3
view release on metacpan or search on metacpan
share/ext-3.4.1/adapter/ext/ext-base-debug.js view on Meta::CPAN
* @type Boolean
*/
enableListenerCollection : false,
/**
* EXPERIMENTAL - True to cascade listener removal to child elements when an element is removed.
* Currently not optimized for performance.
* @type Boolean
*/
enableNestedListenerRemoval : false,
JavaScript-Packer
view release on metacpan or search on metacpan
t/scripts/s18.js view on Meta::CPAN
this._super( value );
this.element.attr( "aria-disabled", value );
// Support: IE8 Only
// #5332 / #6059 - opacity doesn't cascade to positioned elements in IE
// so we need to add the disabled class to the headers and panels
this._toggleClass( null, "ui-state-disabled", !!value );
this._toggleClass( this.headers.add( this.headers.next() ), null, "ui-state-disabled",
!!value );
},
Jifty-DBI
view release on metacpan or search on metacpan
t/02searches_joins.t view on Meta::CPAN
$users_obj->limit( alias => $groups_alias, column => 'name', value => 'Developers' );
#diag $users_obj->build_select_query;
is( $users_obj->count, 3, "three members" );
}
diag "cascaded LEFT JOIN optimization" if $ENV{'TEST_VERBOSE'};
{
$users_obj->clean_slate;
is_deeply( $users_obj, $clean_obj, 'after clean_slate looks like new object');
ok( !$users_obj->_is_joined, "new object isn't joined");
my $alias = $users_obj->join(
Jifty-Plugin-RecordHistory
view release on metacpan or search on metacpan
lib/Jifty/Plugin/RecordHistory.pm view on Meta::CPAN
When you're importing the mixin you have several options to control the behavior
of history. Here are the defaults:
use Jifty::Plugin::RecordHistory::Mixin::Model::RecordHistory (
cascaded_delete => 1,
delete_change => 0,
);
If C<cascaded_delete> is true, then
L<Jifty::Plugin::RecordHistory::Model::Change> and
L<Jifty::Plugin::RecordHistory::Model::ChangeField> records are deleted at the
same time the original record they refer to is deleted. If C<cascaded_delete>
is false, then the Change and ChangeField records persist even if the original
record is deleted.
If C<delete_change> is true, then when your record is deleted we create a
L<Jifty::Plugin::RecordHistory::Model::Change> record whose type is C<delete>.
If C<delete_change> is false, then we do not record the deletion. If
both C<cascaded_delete> I<and> C<delete_change> are true, then you will end up
with only one change after the record is deleted -- the C<delete>.
=head2 Grouping
By default, the only mechanism that groups together change_fields onto a single
Jifty
view release on metacpan or search on metacpan
lib/Jifty/Handler.pm view on Meta::CPAN
$static->add( Plack::App::File->new
( root => Jifty->config->framework('Web')->{DefaultStaticRoot} )->to_app );
# the buffering and unsetting of psgi.streaming is to vivify the
# responded res from the $static cascade app.
builder {
enable 'Plack::Middleware::ConditionalGET';
enable
sub { my $app = shift;
sub { my $env = shift;
Kevin-Command-kevin
view release on metacpan or search on metacpan
t/pg_worker.t view on Meta::CPAN
use Minion;
# Isolate tests
require Mojo::Pg;
my $pg = Mojo::Pg->new($ENV{TEST_ONLINE});
$pg->db->query('drop schema if exists minion_worker_test cascade');
$pg->db->query('create schema minion_worker_test');
my $minion = Minion->new(Pg => $ENV{TEST_ONLINE});
$minion->backend->pg->search_path(['minion_worker_test']);
# Basics
t/pg_worker.t view on Meta::CPAN
is_deeply $status->{queues}, ['default'], 'right structure';
is $status->{performed}, 1, 'right value';
ok $status->{repair_interval}, 'has a value';
# Clean up once we are done
$pg->db->query('drop schema minion_worker_test cascade');
done_testing();
KiokuDB-Backend-DBI
view release on metacpan or search on metacpan
lib/KiokuDB/Backend/DBI.pm view on Meta::CPAN
my $batch_size = $self->batch_size || scalar(@ids);
my @ids_copy = @ids;
while ( my @batch_ids = splice @ids_copy, 0, $batch_size ) {
if ( $self->extract ) {
# FIXME rely on cascade delete?
my $sth = $dbh->prepare_cached("DELETE FROM gin_index WHERE id IN (" . join(", ", ('?') x @batch_ids) . ")");
$sth->execute(@batch_ids);
$sth->finish;
}
Kossy
view release on metacpan or search on metacpan
lib/Kossy.pm view on Meta::CPAN
};
1;
## views/index.tx
: cascade base
: around content -> {
<: $greeting :>
: }
=head1 DESCRIPTION
LRU-Cache
view release on metacpan or search on metacpan
0.05 2026-04-27
- Fix t/007-map-grep.t on Perl 5.8.x: replace `// "UNDEF"`
(defined-or, 5.10+) with an explicit `defined(...) ? ... : ...`
form so the test parses on 5.8 (where // is regex match,
which cascaded into "Global symbol requires explicit package
name" errors at later lines and failed the whole file).
- Fix Perl_custom_op_register fallback in xop_compat.h for
pre-5.14 Perls: replace the broken fixed-arity macro with a
real function whose signature matches native 5.14+; the
C compiler then handles aTHX_ expansion at the call site.
LaTeX-PGF-Diagram2D
view release on metacpan or search on metacpan
doc-src/diagram-en.tex view on Meta::CPAN
for a distance of 0,1 (lines 22 and 23).
The \textit{axis()\/} method of the diagram object returns a reference
for an axis object. A number of axis object methods is used to
set up the axis. Each of the methods returns the axis object reference,
so the methods can be cascaded.
The \textit{plot()\/} method of the diagram object creates a new
plot object and returns the reference to it (line 23).
The \textit{set\textunderscore{}xy\textunderscore{}fct()\/} method
configures the plot object to use the \textit{I()\/} to calculate
LaTeXML-Plugin-LtxMojo
view release on metacpan or search on metacpan
lib/LaTeXML/Plugin/LtxMojo/public/js/external/ace-min/mode-pgsql.js view on Meta::CPAN
define("ace/mode/pgsql",["require","exports","module","ace/lib/oop","ace/mode/text","ace/tokenizer","ace/mode/pgsql_highlight_rules","ace/range"],function(e,t,n){var r=e("../lib/oop"),i=e("../mode/text").Mode,s=e("../tokenizer").Tokenizer,o=e("./pgsq...
LaTeXML
view release on metacpan or search on metacpan
lib/LaTeXML/Package/TeX.pool.ltxml view on Meta::CPAN
$token = shift(@toks);
$gullet->unread(@toks); }
$token; },
undigested => 1);
# Stub register for misdefinitions, to avoid a cascade of Errors.
DefRegisterI('\lx@DUMMY@REGISTER', undef, Tokens());
# Read a variable, ie. a token (after expansion) that is a writable register.
DefParameterType('Variable', sub {
my ($gullet) = @_;
Language-Haskell
view release on metacpan or search on metacpan
hugs98-Nov2003/fptools/libraries/GLUT/Graphics/UI/GLUT.hs view on Meta::CPAN
-- * /Stereo:/ A frame buffer capability providing left and right color buffers
-- for creating stereoscopic renderings. Typically, the user wears LCD
-- shuttered goggles synchronized with the alternating display on the screen
-- of the left and right color buffers.
--
-- * /Sub-menu:/ A menu cascaded from some sub-menu trigger.
--
-- * /Sub-menu trigger:/ A menu item that the user can enter to cascade another
-- pop-up menu.
--
-- * /Subwindow:/ A type of window that is the child window of a top-level
-- window or other subwindow. The drawing and visible region of a subwindow
-- is limited by its parent window.
Launcher-Cascade
view release on metacpan or search on metacpan
lib/Launcher/Cascade/Container.pm view on Meta::CPAN
package Launcher::Cascade::Container;
=head1 NAME
Launcher::Cascade::Container - a class to run L::C::Base launchers in cascade
=head1 SYNOPSIS
use Launcher::Cascade::Base::...;
use Launcher::Cascade::Container;
Lemonldap-NG-Manager
view release on metacpan or search on metacpan
site/htdocs/static/bwr/angular-animate/angular-animate.js view on Meta::CPAN
animationPaused = false;
close();
}
};
// checking the stagger duration prevents an accidentally cascade of the CSS delay style
// being inherited from the parent. If the transition duration is zero then we can safely
// rely that the delay value is an intentional stagger delay style.
var maxStagger = itemIndex > 0
&& ((timings.transitionDuration && stagger.transitionDuration === 0) ||
(timings.animationDuration && stagger.animationDuration === 0))
Lemonldap-NG-Portal
view release on metacpan or search on metacpan
site/htdocs/static/common/favicon.ico
site/htdocs/static/common/fi.png
site/htdocs/static/common/fonts/password.ttf
site/htdocs/static/common/fr.png
site/htdocs/static/common/he.png
site/htdocs/static/common/icons/application_cascade.png
site/htdocs/static/common/icons/arrow_refresh.png
site/htdocs/static/common/icons/calendar.png
site/htdocs/static/common/icons/comments.png
site/htdocs/static/common/icons/decryptValue.png
site/htdocs/static/common/icons/door_out.png
License-SPDX
view release on metacpan or search on metacpan
share/exceptions.json view on Meta::CPAN
"detailsUrl": "https://spdx.org/licenses/OCCT-exception-1.0.json",
"referenceNumber": 67,
"name": "Open CASCADE Exception 1.0",
"licenseExceptionId": "OCCT-exception-1.0",
"seeAlso": [
"http://www.opencascade.com/content/licensing"
]
},
{
"reference": "https://spdx.org/licenses/OpenJDK-assembly-exception-1.0.html",
"isDeprecatedLicenseId": false,
Lingua-Align
view release on metacpan or search on metacpan
lib/Lingua/Align/LinkSearch.pm view on Meta::CPAN
intersection ........... intersection between src2trg and trg2src
NTfirst ................ align non-terminals nodes first
NTonly ................. align only non-terminals
Tonly .................. align only termnal nodes
PaCoMT ................. used in PaCoMT project
cascaded ............... conbine search strategies (sequentially)
=cut
use 5.005;
use strict;
lib/Lingua/Align/LinkSearch.pm view on Meta::CPAN
my %attr=@_;
# my $type = $attr{-link_search} || 'greedy';
my $type = $attr{-link_search} || 'threshold';
if ($type=~/^cascaded/i){
return new Lingua::Align::LinkSearch::Cascaded(%attr);
}
if ($type=~/^viterbi/i){
return new Lingua::Align::LinkSearch::Viterbi(%attr);
}
Lingua-EN-Ngram
view release on metacpan or search on metacpan
etc/rivers.txt view on Meta::CPAN
the salt billows of the ocean on Plum Island beach. At first it
comes on murmuring to itself by the base of stately and retired
mountains, through moist primitive woods whose juices it
receives, where the bear still drinks it, and the cabins of
settlers are far between, and there are few to cross its stream;
enjoying in solitude its cascades still unknown to fame; by long
ranges of mountains of Sandwich and of Squam, slumbering like
tumuli of Titans, with the peaks of Moosehillock, the Haystack,
and Kearsarge reflected in its waters; where the maple and the
raspberry, those lovers of the hills, flourish amid temperate
dews;--flowing long and full of meaning, but untranslatable as
etc/rivers.txt view on Meta::CPAN
inexhaustible ledges of granite, with Squam, and Winnipiseogee,
and Newfound, and Massabesic Lakes for its mill-ponds, it falls
over a succession of natural dams, where it has been offering its
_privileges_ in vain for ages, until at last the Yankee race came
to _improve_ them. Standing at its mouth, look up its sparkling
stream to its source,--a silver cascade which falls all the way
from the White Mountains to the sea,--and behold a city on each
successive plateau, a busy colony of human beaver around every
fall. Not to mention Newburyport and Haverhill, see Lawrence,
and Lowell, and Nashua, and Manchester, and Concord, gleaming one
above the other. When at length it has escaped from under the
etc/rivers.txt view on Meta::CPAN
the same channel, but a new water every instant.
"Virtues as rivers pass,
But still remains that virtuous man there was."
Most men have no inclination, no rapids, no cascades, but
marshes, and alligators, and miasma instead. We read that when
in the expedition of Alexander, Onesicritus was sent forward to
meet certain of the Indian sect of Gymnosophists, and he had told
them of those new philosophers of the West, Pythagoras, Socrates,
and Diogenes, and their doctrines, one of them named Dandamis
Lingua-EN-Opinion
view release on metacpan or search on metacpan
lib/Lingua/EN/Opinion/Emotion.pm view on Meta::CPAN
cartouche => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
cartridge => { anger => 0, anticipation => 0, disgust => 0, fear => 1, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
carve => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
carver => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
carving => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
cascade => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 1, sadness => 0, surprise => 0, trust => 0 },
case => { anger => 0, anticipation => 0, disgust => 0, fear => 1, joy => 0, negative => 1, positive => 0, sadness => 1, surprise => 0, trust => 0 },
casein => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
cash => { anger => 1, anticipation => 1, disgust => 0, fear => 1, joy => 1, negative => 0, positive => 1, sadness => 0, surprise => 0, trust => 1 },
cashier => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 1 },
cashmere => { anger => 0, anticipation => 0, disgust => 0, fear => 0, joy => 0, negative => 0, positive => 0, sadness => 0, surprise => 0, trust => 0 },
Lingua-EN-SENNA
view release on metacpan or search on metacpan
lib/Lingua/EN/SENNA/third-party/senna/hash/ner.loc.lst view on Meta::CPAN
casa grande
casablanca
casablance
casanova
casar
cascade
cascade locks
cascadia
cascais
cascavel
cascilla
casco
Lingua-EN-Segment
view release on metacpan or search on metacpan
share/count_1w.txt view on Meta::CPAN
cruiser 3735652
hendrix 3734885
cumberland 3734672
gifted 3733747
esteem 3733585
cascade 3732995
endorse 3732894
strokes 3732810
shelby 3732559
hen 3732543
homeowner 3732354
share/count_1w.txt view on Meta::CPAN
rewriting 1160587
bahama 1160583
unrest 1160513
idl 1160460
loretta 1160225
cascades 1160207
druid 1160196
dunbar 1160179
outsider 1160162
lingvosoft 1160159
dax 1160128
share/count_1w.txt view on Meta::CPAN
iwon 183906
patchogue 183905
digestibility 183900
archaea 183898
enquired 183895
cascaded 183890
aphorisms 183889
sharkoon 183884
cmj 183869
spyderco 183865
compleat 183864
Lingua-EN-Tagger
view release on metacpan or search on metacpan
Tagger/words.yml view on Meta::CPAN
Carver: { nnp: 3 }
carves: { vbz: 1 }
carving: { vbg: 1 }
Caryl: { nnp: 1 }
Casablanca: { nnp: 4 }
cascade: { nn: 2 }
Cascade: { nnp: 5 }
cascading: { jj: 1, vbg: 1 }
case-by-case: { jj: 5 }
CASE: { nn: 1 }
case: { nn: 384 }
Lingua-Identify-Blacklists
view release on metacpan or search on metacpan
lib/Lingua/Identify/Blacklists.pm view on Meta::CPAN
assumed => $assumed_lang
langs => \@list_of_possible_langs
use_margin => $score
If C<langs> are specified, it runs the classifier with blacklists for those languages (in a cascaded way, i.e. best1 = lang1 vs lang2, best2 = best1 vs lang3, ...). If C<use_margin> is specified, it runs all versus all and returns the language that w...
If the C<assumed> language is given, it runs the blacklist classifier for all languages that can be confused with $assumed_lang (if blacklist models exist for them).
If neither C<langs> not C<assumed> are specified, it first runs a general-purpose language identification (using Lingua::Identify::CLD and Lingua::Identify) and then checks with the blacklist classifier whether the detected language can be confused w...
lib/Lingua/Identify/Blacklists.pm view on Meta::CPAN
The following functions are not exported and are mainly used for internal purposes (but may be used from the outside if needed).
initialize() # reset the repository of blacklists
identify_language($text) # return lang-ID for $text (using CLD)
classify(\%dic,%options) # run the classifier
classify_cascaded(\%dic,@langs) # run a cascade of binary classifications
# run all versus all and return the one that wins most binary decisions
# (a score margin is used to adjust the reliability of the decisions)
classify_with_margin(\%dic,$margin,@langs)
lib/Lingua/Identify/Blacklists.pm view on Meta::CPAN
@langs = available_languages() unless (@langs);
return &classify_with_margin( $dic, $options{use_margin}, @langs )
if ($options{use_margin});
return &classify_cascaded( $dic, @langs );
}
sub classify_cascaded{
my $dic = shift;
my @langs = @_;
my $lang1 = shift(@langs);
foreach my $lang2 (@langs){
Lingua-Identify-CLD2
view release on metacpan or search on metacpan
src/cld2/public/compact_lang_det.h view on Meta::CPAN
uint16 pad; // Make multiple of 4 bytes
} ResultChunk;
typedef std::vector<ResultChunk> ResultChunkVector;
// These initial simple versions all cascade through the full-blown last
// version which it would be better for you to use directly because you will
// get better results passing in any available hints.
// Scan interchange-valid UTF-8 bytes and detect most likely language
// If the input is in fact not valid UTF-8, this returns immediately with
Lingua-Lexicon-IDP
view release on metacpan or search on metacpan
lib/Lingua/Lexicon/IDP/Data/en_es.txt view on Meta::CPAN
carve tallar
carved tallado
casa casa (house)
casa house[Conjunction]
casaba casaba ( vegetable )
cascade cascada
cascades cascadas
cash efectivo
cashier cajero
cashier el cajero
cashiers cajeros
casino casino
Lingua-Stem
view release on metacpan or search on metacpan
examples/collected_works_poe.txt view on Meta::CPAN
prevent the escape of the deer. Nothing of the fence kind was
observable elsewhere; for nowhere else was an artificial enclosure
needed: -- any stray sheep, for example, which should attempt to make
its way out of the vale by means of the ravine, would find its
progress arrested, after a few yards' advance, by the precipitous
ledge of rock over which tumbled the cascade that had arrested my
attention as I first drew near the domain. In short, the only ingress
or egress was through a gate occupying a rocky pass in the road, a
few paces below the point at which I stopped to reconnoitre the
scene.
examples/collected_works_poe.txt view on Meta::CPAN
time afterward we came to understand that such was the appearance of
the streams throughout the whole group. I am at a loss to give a
distinct idea of the nature of this liquid, and cannot do so without
many words. Although it flowed with rapidity in all declivities where
common water would do so, yet never, except when falling in a
cascade, had it the customary appearance of limpidity. It was,
nevertheless, in point of fact, as perfectly limpid as any limestone
water in existence, the difference being only in appearance. At first
sight, and especially in cases where little declivity was found, it
bore resemblance, as regards consistency, to a thick infusion of
gum arabic in common water. But this was only the least remarkable of
Lingua-XFST
view release on metacpan or search on metacpan
privates/xfsm_api.h view on Meta::CPAN
maps each input string to the outputs that meet the constraint
if there are any, eliminating the outputs that violate the
constraint. However, if none of the outputs of a given input
meet the constraint, all of them remain. That is, lenient
composition guarantees that every input has outputs. A set
of ranked OT constraints can be implemented as a cascade of
lenient compositions with the most higly ranked constraint on
the top of the cascade. */
NETptr close_sigma(NETptr net, ALPHABETptr new_symbols,
int copy_p, int minimize_p);
/* Error handling */
( run in 0.769 second using v1.01-cache-2.11-cpan-39bf76dae61 )