Gfsm-XL
view release on metacpan or search on metacpan
#/*-*- Mode: C -*- */
MODULE = Gfsm::XL PACKAGE = Gfsm::XL::Cascade PREFIX = gfsmxl_cascade_
##=====================================================================
## Constructors etc.
##=====================================================================
##-- disable perl prototypes
PROTOTYPES: DISABLE
##--------------------------------------------------------------
## Constructor: new()
gfsmxlCascadePerl*
new(char *CLASS, guint depth=0, gfsmSRType srtype=gfsmAutomatonDefaultSRType)
CODE:
RETVAL = gfsmxl_perl_cascade_new();
RETVAL->csc = gfsmxl_cascade_new_full(depth, srtype);
GFSMXL_DEBUG_EVAL(g_printerr("Gfsm::XL::Cascade::new(): returning cascade=%p, csc=%p\n", RETVAL, RETVAL->csc);)
OUTPUT:
RETVAL
##--------------------------------------------------------------
## clear
void
gfsmxl_cascade_clear(gfsmxlCascadePerl *cscp)
CODE:
if (cscp) gfsmxl_perl_cascade_clear(cscp);
##--------------------------------------------------------------
## Destructor: DESTROY()
void
DESTROY(gfsmxlCascadePerl* cscp)
CODE:
GFSMXL_DEBUG_EVAL(g_printerr("Gfsm::XL::Cascade::DESTROY(cscp=%p : cscp->csc=%p, cscp->csc->depth=%u)\n", cscp, (cscp ? cscp->csc : NULL), (cscp && cscp->csc ? cscp->csc->depth : 0));)
if (cscp) gfsmxl_perl_cascade_free(cscp);
GFSMXL_BLOW_CHUNKS();
##=====================================================================
## High-level Access
##=====================================================================
guint
gfsmxl_cascade_depth(gfsmxlCascadePerl *cscp)
CODE:
RETVAL = cscp->csc->depth;
OUTPUT:
RETVAL
gfsmSRType
gfsmxl_cascade_semiring_type(gfsmxlCascadePerl *cscp, ...)
CODE:
if (items > 1) {
gfsmxl_cascade_set_semiring_type(cscp->csc, (gfsmSRType)SvIV(ST(1)));
}
RETVAL = (cscp->csc->sr ? cscp->csc->sr->type : gfsmSRTUnknown);
OUTPUT:
RETVAL
void
gfsmxl_cascade_sort_all(gfsmxlCascadePerl *cscp, gfsmArcCompMask sort_mask)
CODE:
gfsmxl_cascade_sort_all(cscp->csc, sort_mask);
##=====================================================================
## Component Access
##=====================================================================
void
_append(gfsmxlCascadePerl *cscp, ...)
INIT:
int i;
CODE:
for (i=1; i < items; i++) {
//-- type-checking from "perlobject.map" -> INPUT -> O_OBJECT
SV *xfsm_sv_i = ST(i);
if( !sv_isobject(xfsm_sv_i) && (SvTYPE(SvRV(xfsm_sv_i)) == SVt_PVMG) ) {
warn( "Gfsm::XL::Cascade::append() -- item %d is not a blessed SV reference", i );
XSRETURN_UNDEF;
}
gfsmxl_perl_cascade_append_sv(cscp,xfsm_sv_i);
}
SV*
gfsmxl_cascade_get(gfsmxlCascadePerl *cscp, int i)
CODE:
RETVAL = gfsmxl_perl_cascade_get_sv(cscp,i);
OUTPUT:
RETVAL
SV*
gfsmxl_cascade_pop(gfsmxlCascadePerl *cscp)
CODE:
if (cscp->csc->depth<=0) { XSRETURN_UNDEF; }
RETVAL = gfsmxl_perl_cascade_pop_sv(cscp);
OUTPUT:
RETVAL
SV*
_set(gfsmxlCascadePerl *cscp, guint n, SV *xfsm_sv)
CODE:
if( !sv_isobject(xfsm_sv) && (SvTYPE(SvRV(xfsm_sv)) == SVt_PVMG) ) {
warn( "Gfsm::XL::Cascade::set() -- xfsm_sv is not a blessed SV reference" );
XSRETURN_UNDEF;
}
RETVAL = gfsmxl_perl_cascade_get_sv(cscp,n);
//if (RETVAL) { SvREFCNT_dec(RETVAL); }
gfsmxl_perl_cascade_set_sv(cscp,n,xfsm_sv);
OUTPUT:
RETVAL
##=====================================================================
## I/O
##=====================================================================
##--------------------------------------------------------------
## I/O: binary: FILE*
#/** Load a cascade from a stored binary file (implicitly clear()s cascade) */
gboolean
_load(gfsmxlCascadePerl *cscp, FILE *f)
PREINIT:
gfsmError *err=NULL;
gfsmIOHandle *ioh=NULL;
CODE:
ioh = gfsmio_new_zfile(f,"rb",-1);
gfsmxl_perl_cascade_clear(cscp);
RETVAL = gfsmxl_cascade_load_bin_handle(cscp->csc, ioh, &err);
gfsmxl_perl_cascade_refresh_av(cscp);
if (err && err->message) {
SV *perlerr = get_sv("Gfsm::Error",TRUE);
sv_setpv(perlerr, err->message);
g_error_free(err);
}
if (ioh) {
/*gfsmio_close(ioh);*/
gfsmio_handle_free(ioh);
}
OUTPUT:
RETVAL
#/** Save a cascade to a binary FILE* */
gboolean
_save(gfsmxlCascadePerl *cscp, FILE *f, int zlevel=-1)
PREINIT:
gfsmError *err=NULL;
gfsmIOHandle *ioh=NULL;
CODE:
ioh = zlevel ? gfsmio_new_zfile(f,"wb",zlevel) : gfsmio_new_file(f);
RETVAL = gfsmxl_cascade_save_bin_handle(cscp->csc, ioh, &err);
if (err && err->message) {
SV *perlerr = get_sv("Gfsm::Error",TRUE);
sv_setpv(perlerr, err->message);
g_error_free(err);
}
if (ioh) {
if (ioh->iotype==gfsmIOTZFile) gfsmio_close(ioh);
gfsmio_handle_free(ioh);
}
OUTPUT:
RETVAL
##--------------------------------------------------------------
## I/O: binary: SV*
#/** Load a cascade from a scalar buffer (implicitly clear()s cascade) */
gboolean
load_string(gfsmxlCascadePerl *cscp, SV *str)
PREINIT:
gfsmError *err=NULL;
gfsmIOHandle *ioh=NULL;
CODE:
ioh = gfsmperl_io_new_sv(str,0);
gfsmxl_perl_cascade_clear(cscp);
RETVAL = gfsmxl_cascade_load_bin_handle(cscp->csc, ioh, &err);
gfsmxl_perl_cascade_refresh_av(cscp);
if (err && err->message) {
SV *perlerr = get_sv("Gfsm::Error",TRUE);
sv_setpv(perlerr, err->message);
g_error_free(err);
}
if (ioh) {
gfsmperl_io_free_sv(ioh);
}
OUTPUT:
RETVAL
#/** Save an automaton to a scalar */
gboolean
save_string(gfsmxlCascadePerl *cscp, SV *str)
PREINIT:
gfsmError *err=NULL;
gfsmIOHandle *ioh=NULL;
CODE:
ioh = gfsmperl_io_new_sv(str,0);
RETVAL=gfsmxl_cascade_save_bin_handle(cscp->csc, ioh, &err);
if (err && err->message) {
SV *perlerr = get_sv("Gfsm::Error",TRUE);
sv_setpv(perlerr, err->message);
g_error_free(err);
}
if (ioh) {
gfsmperl_io_free_sv(ioh);
}
OUTPUT:
RETVAL
testme.perl: added debugging utility gfsm-indexed-dump.perl --
still no joy really
* [r704] Cascade.xs, GfsmXLPerl.c, GfsmXLPerl.h, Lookup.xs,
XL/Cascade.pm, XL/Cascade/Lookup.pm: + fixes for set_nth (still
weird perl bug with setzen/sezen)
* [r703] XL/Cascade/Lookup.pm: + added rudimentary docs (summary)
for Gfsm::XL::Cascade::Lookup
v0.06 2012-11-16 moocow
* [r701] Cascade.xs, GfsmXLPerl.c, GfsmXLPerl.h, csc2.tfst,
testme.perl: + added cascade set_nth() and pop() methods for
dynamic target-language switching
* [r700] Cascade.xs, GfsmXLPerl.c, GfsmXLPerl.h, Makefile.PL,
XL.pm, XL/Cascade.pm, XL/Cascade/Lookup.pm: + added cascade
methods pop(), set(N,XFSM)
* [r699] t/01_ini.t: + verbose t/01_ini.t
v0.05 2012-03-19 moocow
* [r690] Makefile.PL: * set default OPTIMIZE key in Makefile.PL
v0.05 2011-10-21 moocow
* [r661] Cascade.xs, GfsmXLPerl.c, Lookup.xs, XL.xs, testme.perl: +
chased memory bugs appearing with new slice allocators
- seems to work now (small dta subset eqrw db builds ok)
GfsmXLPerl.c view on Meta::CPAN
void gfsm_perl_free(gpointer mem)
{
Safefree(mem);
}
/*======================================================================
* Gfsm::XL::Cascade Utilities
*/
//----------------------------------------------------------------------
gfsmxlCascadePerl *gfsmxl_perl_cascade_new(void)
{
gfsmxlCascadePerl *cscp = gfsm_slice_new0(gfsmxlCascadePerl);
cscp->av = newAV();
return cscp;
}
//----------------------------------------------------------------------
void gfsmxl_perl_cascade_clear(gfsmxlCascadePerl *cscp)
{
if (cscp->csc) gfsmxl_cascade_clear(cscp->csc,FALSE);
if (cscp->av) av_clear(cscp->av);
}
//----------------------------------------------------------------------
void gfsmxl_perl_cascade_free(gfsmxlCascadePerl *cscp)
{
if (cscp) {
gfsmxl_perl_cascade_clear(cscp);
av_undef(cscp->av);
if (cscp->csc) gfsmxl_cascade_free(cscp->csc,FALSE);
gfsm_slice_free(gfsmxlCascadePerl,cscp);
}
}
//----------------------------------------------------------------------
SV *gfsmxl_perl_cascade_get_sv(gfsmxlCascadePerl *cscp, int i)
{
SV **fetched = av_fetch(cscp->av, i, 0);
if (fetched) {
SV *rv = sv_mortalcopy(*fetched);
SvREFCNT_inc(rv);
return rv;
}
return &PL_sv_undef;
}
//----------------------------------------------------------------------
SV *gfsmxl_perl_cascade_pop_sv(gfsmxlCascadePerl *cscp)
{
SV *rv = gfsmxl_perl_cascade_get_sv(cscp, cscp->csc->depth-1);
av_delete(cscp->av, cscp->csc->depth-1, G_DISCARD);
gfsmxl_cascade_pop(cscp->csc);
return rv;
}
//----------------------------------------------------------------------
void gfsmxl_perl_cascade_append_sv(gfsmxlCascadePerl *cscp, SV *xfsm_sv)
{
gfsmIndexedAutomaton *xfsm = (gfsmIndexedAutomaton*)GINT_TO_POINTER( SvIV((SV*)SvRV(xfsm_sv)) );
SV *xfsm_sv_copy;
GFSMXL_DEBUG_EVAL( g_printerr("cascade_append_sv(cscp=%p, cscp->csc=%p): xfsm_sv=%p, xfsm=%p\n", cscp, cscp->csc, xfsm_sv, xfsm); )
//
xfsm_sv_copy = sv_mortalcopy(xfsm_sv); //-- array-stored value (mortal)
SvREFCNT_inc(xfsm_sv_copy); // : mortal needs incremented refcnt
av_push(cscp->av, xfsm_sv_copy); // : store
//
gfsmxl_cascade_append_indexed(cscp->csc, xfsm);
}
//----------------------------------------------------------------------
void gfsmxl_perl_cascade_set_sv(gfsmxlCascadePerl *cscp, guint n, SV *xfsm_sv)
{
gfsmIndexedAutomaton *xfsm = (gfsmIndexedAutomaton*)GINT_TO_POINTER( SvIV((SV*)SvRV(xfsm_sv)) );
SV *xfsm_sv_copy;
I32 key = n;
GFSMXL_DEBUG_EVAL( g_printerr("cascade_set_sv(cscp=%p, cscp->csc=%p, n=%u): BEGIN: xfsm_sv=%p, xfsm=%p\n", cscp, cscp->csc, n, xfsm_sv, xfsm); )
av_delete(cscp->av, n, G_DISCARD); //-- delete old value (if any)
//
xfsm_sv_copy = sv_mortalcopy(xfsm_sv); //-- array-stored value (mortal)
SvREFCNT_inc(xfsm_sv_copy); // : mortal needs incremented refcnt
av_store(cscp->av, key, xfsm_sv_copy); // : store at position $n
//
gfsmxl_cascade_set_nth_indexed(cscp->csc, n, xfsm, FALSE); //-- don't free old automaton (perl refcount should take care of that)
}
//----------------------------------------------------------------------
void gfsmxl_perl_cascade_refresh_av(gfsmxlCascadePerl *cscp)
{
int i;
av_clear(cscp->av);
for (i=0; i < cscp->csc->depth; i++) {
gfsmIndexedAutomaton *xfsm = gfsmxl_cascade_index(cscp->csc,i);
SV *svrv = newSV(0);
sv_setref_pv(svrv, "Gfsm::Automaton::Indexed", (void*)xfsm);
av_push(cscp->av, svrv);
}
}
/*======================================================================
* Gfsm::XL::Cascade::Lookup Utilities
*/
//----------------------------------------------------------------------
void gfsmxl_perl_cascade_lookup_set_cascade_sv(gfsmxlCascadeLookupPerl *clp, SV *csc_sv)
{
SvSetSV(clp->csc_sv, csc_sv);
clp->cl->csc = NULL; //-- must be explicit, or else madness may ensue
if (csc_sv && SvROK(csc_sv)) {
gfsmxlCascadePerl *cscp = (gfsmxlCascadePerl*)GINT_TO_POINTER( SvIV((SV*)SvRV(csc_sv)) );
//SvREFCNT_inc((SV*)SvRV(csc_sv)); //-- should NOT be necessary if the reference itself was copied using SvSetSV()!
//GFSMXL_DEBUG_EVAL(g_printerr(": cl_set_cascade_sv[clp=%p, csc_sv=%p, clp->csc_sv=%p]: copy()\n", clp, csc_sv, clp->csc_sv);)
gfsmxl_cascade_lookup_set_cascade(clp->cl, cscp->csc);
} else {
//GFSMXL_DEBUG_EVAL(g_printerr(": cl_set_cascade_sv[clp=%p, csc_sv=%p, clp->csc_sv=%p]: clp->csc_sv=NULL\n", clp, csc_sv, clp->csc_sv);)
gfsmxl_cascade_lookup_set_cascade(clp->cl, NULL);
}
//GFSMXL_DEBUG_EVAL(g_printerr(": cl_set_cascade_sv[clp=%p, csc_sv=%p, clp->csc_sv=%p]: exiting.\n", clp, csc_sv, clp->csc_sv);)
}
//----------------------------------------------------------------------
gfsmxlCascadeLookupPerl *gfsmxl_perl_cascade_lookup_new(SV *csc_sv, gfsmWeight max_w, guint max_paths, guint max_ops)
{
gfsmxlCascadeLookupPerl *clp = (gfsmxlCascadeLookupPerl*)gfsm_slice_new0(gfsmxlCascadeLookupPerl);
clp->cl = gfsmxl_cascade_lookup_new_full(NULL, max_w, max_paths, max_ops);
clp->csc_sv = newSV(0);
GFSMXL_DEBUG_EVAL( g_printerr("cascade_lookup_new(clp=%p): created clp->csc_sv=%p (REFCNT=%u)\n", clp, clp->csc_sv, SvREFCNT(clp->csc_sv)); )
gfsmxl_perl_cascade_lookup_set_cascade_sv(clp, csc_sv);
GFSMXL_DEBUG_EVAL( g_printerr("cascade_lookup_new(clp=%p): post set_cascade_sv: clp->csc_sv=%p (REFCNT=%u)\n", clp, clp->csc_sv, SvREFCNT(clp->csc_sv)); )
return clp;
}
//----------------------------------------------------------------------
void gfsmxl_perl_cascade_lookup_free (gfsmxlCascadeLookupPerl *clp)
{
clp->cl->csc = NULL;
gfsmxl_cascade_lookup_free(clp->cl);
SvREFCNT_dec(clp->csc_sv);
gfsm_slice_free(gfsmxlCascadeLookupPerl,clp);
}
/*======================================================================
* Type conversions
*/
//----------------------------------------------------------------------
AV *gfsm_perl_ptr_array_to_av_uv(GPtrArray *ary)
GfsmXLPerl.h view on Meta::CPAN
void gfsm_perl_free(gpointer mem);
/*======================================================================
* Gfsm::XL::Cascade Utilities
*/
typedef struct {
gfsmxlCascade *csc;
AV *av; //-- holds automaton scalars
} gfsmxlCascadePerl;
gfsmxlCascadePerl *gfsmxl_perl_cascade_new(void);
void gfsmxl_perl_cascade_clear(gfsmxlCascadePerl *cscp);
void gfsmxl_perl_cascade_free (gfsmxlCascadePerl *cscp);
void gfsmxl_perl_cascade_append_sv(gfsmxlCascadePerl *cscp, SV *xfsm_sv);
void gfsmxl_perl_cascade_set_sv(gfsmxlCascadePerl *cscp, guint n, SV *xfsm_sv);
SV* gfsmxl_perl_cascade_get_sv(gfsmxlCascadePerl *cscp, int i);
SV* gfsmxl_perl_cascade_pop_sv(gfsmxlCascadePerl *cscp);
void gfsmxl_perl_cascade_refresh_av(gfsmxlCascadePerl *cscp); //-- create cscp->av from csc->csc->xfsms
/*======================================================================
* Gfsm::XL::Cascade::Lookup Utilities
*/
typedef struct {
gfsmxlCascadeLookup *cl; //-- underlying gfsmxlCascadeLookup struct
SV *csc_sv; //-- holds SV* for underlying cascade
} gfsmxlCascadeLookupPerl;
gfsmxlCascadeLookupPerl *gfsmxl_perl_cascade_lookup_new(SV *csc_sv, gfsmWeight max_w, guint max_paths, guint max_ops);
void gfsmxl_perl_cascade_lookup_set_cascade_sv(gfsmxlCascadeLookupPerl *clp, SV *csc_sv);
void gfsmxl_perl_cascade_lookup_free (gfsmxlCascadeLookupPerl *clp);
/*======================================================================
* Type conversions
*/
//AV *gfsm_perl_paths_to_av(gfsmSet *paths_s);
//HV *gfsm_perl_path_to_hv(gfsmPath *path);
//AV *gfsm_perl_ptr_array_to_av_uv(GPtrArray *ary);
AV *gfsm_perl_ptr_array_to_av_uv(GPtrArray *ary);
HV *gfsm_perl_path_to_hv(gfsmPath *path);
#/*-*- Mode: C -*- */
MODULE = Gfsm::XL PACKAGE = Gfsm::XL::Cascade::Lookup PREFIX = gfsmxl_cascade_lookup_
##-- disable perl prototypes
PROTOTYPES: DISABLE
##=====================================================================
## Constructors etc.
##=====================================================================
##--------------------------------------------------------------
## Constructor: new()
gfsmxlCascadeLookupPerl*
new(char *CLASS, SV *csc_sv, gfsmWeight max_w=0, guint max_paths=1, guint max_ops=-1)
CODE:
RETVAL = gfsmxl_perl_cascade_lookup_new(csc_sv, max_w, max_paths, max_ops);
GFSMXL_DEBUG_EVAL(g_printerr("Gfsm::XL::Cascade::Lookup::new(): returning clp=%p, clp->cl=%p, clp->csc_sv=%p; clp->cl->csc=%p\n", RETVAL, RETVAL->cl, RETVAL->csc_sv, RETVAL->cl->csc);)
OUTPUT:
RETVAL
##--------------------------------------------------------------
## Destructor: DESTROY()
void
DESTROY(gfsmxlCascadeLookupPerl* clp)
CODE:
GFSMXL_DEBUG_EVAL(g_printerr("Gfsm::XL::Cascade::Lookup::DESTROY(clp=%p : clp->cl=%p / csc_sv=%p, csc=%p)\n", clp, (clp ? clp->cl : NULL), (clp ? clp->csc_sv : NULL), (clp && clp->cl ? clp->cl->csc : NULL));)
if (clp) gfsmxl_perl_cascade_lookup_free(clp);
GFSMXL_BLOW_CHUNKS();
##=====================================================================
## High-level Access: Attributes
##=====================================================================
##--------------------------------------------------------------
## Attributes: cascade
SV*
_cascade_get(gfsmxlCascadeLookupPerl *clp)
CODE:
RETVAL = sv_mortalcopy(clp->csc_sv);
SvREFCNT_inc(RETVAL);
OUTPUT:
RETVAL
void
_cascade_set(gfsmxlCascadeLookupPerl *clp, SV *cascade_sv)
CODE:
gfsmxl_perl_cascade_lookup_set_cascade_sv(clp,cascade_sv);
##--------------------------------------------------------------
## Attributes: max_weight
gfsmWeight
_max_weight_get(gfsmxlCascadeLookupPerl *clp)
CODE:
RETVAL = clp->cl->max_w;
OUTPUT:
##=====================================================================
## Operations
##=====================================================================
##--------------------------------------------------------------
## Operations: reset
void
reset(gfsmxlCascadeLookupPerl *clp)
CODE:
gfsmxl_cascade_lookup_reset(clp->cl);
##--------------------------------------------------------------
## Operations: n-best lookup (FST)
void
_lookup_nbest(gfsmxlCascadeLookupPerl *clp, gfsmLabelVector *input, gfsmAutomaton *result)
CODE:
gfsmxl_cascade_lookup_nbest(clp->cl, input, result);
CLEANUP:
g_ptr_array_free(input,TRUE);
AV *
lookup_nbest_paths(gfsmxlCascadeLookupPerl *clp, gfsmLabelVector *input)
PREINIT:
gfsmxlPathArray *paths_a;
CODE:
paths_a = gfsmxl_cascade_lookup_nbest_paths(clp->cl, input, NULL);
RETVAL = gfsmxl_perl_patharray_to_av(paths_a);
gfsmxl_patharray_free(paths_a);
OUTPUT:
RETVAL
CLEANUP:
g_ptr_array_free(input,TRUE);
{
"abstract" : "Perl interface to libgfsmxl finite-state cascade library",
"author" : [
"Bryan Jurish <moocow@cpan.org>"
],
"dynamic_config" : 1,
"generated_by" : "ExtUtils::MakeMaker version 7.1002, CPAN::Meta::Converter version 2.150010",
"license" : [
"perl_5"
],
"meta-spec" : {
"url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec",
---
abstract: 'Perl interface to libgfsmxl finite-state cascade library'
author:
- 'Bryan Jurish <moocow@cpan.org>'
build_requires:
ExtUtils::MakeMaker: '0'
configure_requires:
Alien::Gfsm: '0.001'
Alien::GfsmXL: '0.001'
ExtUtils::MakeMaker: '6.52'
Gfsm: '0.0404'
dynamic_config: 1
Makefile.PL view on Meta::CPAN
##----------------------------------------------------------------------
## MAIN
##----------------------------------------------------------------------
WriteMakefile
(
NAME => 'Gfsm::XL',
#DISTNAME => 'gfsmxl-perl',
DISTNAME => 'Gfsm-XL',
AUTHOR => 'Bryan Jurish <moocow@cpan.org>',
ABSTRACT => 'Perl interface to libgfsmxl finite-state cascade library',
VERSION_FROM => 'XL.pm',
LICENSE => 'perl',
##-- prerequisites
CONFIGURE_REQUIRES => \%prereq,
PREREQ_PM => \%prereq,
##-- user variables
#CC => 'c++', ##-- your c++ compiler
LIBS => join(' ', Alien::Gfsm->libs, Alien::GfsmXL->libs), ##-- additional libraries
README.rpod view on Meta::CPAN
=encoding utf8
=pod
README for perl package Gfsm::XL (formerly known as gfsmxl-perl)
=head1 ABSTRACT
Gfsm::XL - Perl interface to the libgfsmxl finite-state cascade library
=head1 REQUIREMENTS
=over 4
=item libgfsmxl E<gt>= v0.0.11
Current sources for the libgfsmxl package should be available from
http://kaskade.dwds.de/~moocow/projects/gfsm/#gfsmxl
=back
=head1 DESCRIPTION
The Gfsm::XL package provides Perl bindings for the libgfsmxl finite-state cascade library.
=head2 Citations
If you use the Gfsm::XL package in a scientific publication, please acknowledge its use by citing
the following paper:
=over 4
Bryan Jurish. "Efficient online k-best lookup in weighted finite-state cascades."
In Thomas Hanneforth and Gisbert Fanselow, editors,
I<Language and Logos: Studies in Theoretical and Computational Linguistics>,
volume 72 of I<Studia grammatica>.
Akademie Verlag, Berlin, 2010.
ISBN 978-3-05-004931-1.
=back
=head1 AUTHOR
README for perl package Gfsm::XL (formerly known as gfsmxl-perl)
ABSTRACT
Gfsm::XL - Perl interface to the libgfsmxl finite-state cascade library
REQUIREMENTS
libgfsmxl >= v0.0.11
Current sources for the libgfsmxl package should be available from
http://kaskade.dwds.de/~moocow/projects/gfsm/#gfsmxl
DESCRIPTION
The Gfsm::XL package provides Perl bindings for the libgfsmxl
finite-state cascade library.
Citations
If you use the Gfsm::XL package in a scientific publication, please
acknowledge its use by citing the following paper:
Bryan Jurish. "Efficient online k-best lookup in weighted
finite-state cascades." In Thomas Hanneforth and Gisbert Fanselow,
editors, *Language and Logos: Studies in Theoretical and
Computational Linguistics*, volume 72 of *Studia grammatica*.
Akademie Verlag, Berlin, 2010. ISBN 978-3-05-004931-1.
AUTHOR
Bryan Jurish <moocow@cpan.org>
1;
__END__
# Below is stub documentation for your module. You'd better edit it!
=pod
=head1 NAME
Gfsm::XL - Perl interface to the libgfsmxl finite-state cascade library
=head1 SYNOPSIS
use Gfsm;
use Gfsm::XL;
##... stuff happens
=head1 DESCRIPTION
The Gfsm::XL module provides an object-oriented interface to the libgfsmxl
library for finite-state cascade lookup operations.
=head1 SEE ALSO
Gfsm(3perl),
perl(1),
gfsmutils(1),
fsm(1).
=head1 AUTHOR
XL/Cascade.pm view on Meta::CPAN
1;
__END__
# Below is stub documentation for your module. You'd better edit it!
=pod
=head1 NAME
Gfsm::XL::Cascade - object-oriented interface to libgfsmxl finite-state cascades
=head1 SYNOPSIS
use Gfsm;
use Gfsm::XL;
##------------------------------------------------------------
## Constructors, etc.
$csc = Gfsm::XL::Cascade->new();
$csc = Gfsm::XL::Cascade->new($depth, $srtype);
$csc->clear(); # clear cascade
##------------------------------------------------------------
## Accessors/Manipulators: Properties
$csc = $csc->append(@fsms); # append a Gfsm::Automaton::Indexed (by reference if possible)
$xfsm = $csc->get($n); # retrieve reference to $n-th automaton in the cascade (indexed)
@xfsms = $csc->get_all(); # retrieve list of references to all automata in cascade
$xold = $csc->set($n,$fsm); # set the $n-th automaton in the cascade; returns old $n-th automaton
$xold = $csc->pop(); # pop the deepest automaton in the cascade
$depth = $csc->depth(); # get cascade depth
$srtype = $csc->semiring_type(?$srtype); # get/set semiring type
$csc->sort_all($sort_mask); # sort all automata in cascade
##--------------------------------------------------------------
## I/O
$bool = $csc->load($filename_or_handle); # load binary file
$bool = $csc->save($filename_or_handle); # save binary file
$bool = $csc->load_string($buffer); # load from in-memory buffer $string
$bool = $csc->save_string($buffer); # save to in-memory buffer $string
XL/Cascade/Lookup.pm view on Meta::CPAN
## + defines sub "$attrName()" for get/set
sub _wrap_attribute {
my $attr = shift;
eval
"sub $attr {
\$_[0]->_${attr}_set(\@_[1..\$#_]) if (\$#_ > 0);
return \$_[0]->_${attr}_get();
}";
}
_wrap_attribute('cascade');
_wrap_attribute('max_weight');
_wrap_attribute('max_paths');
_wrap_attribute('max_ops');
_wrap_attribute('n_ops');
}
##======================================================================
## Operation
##======================================================================
XL/Cascade/Lookup.pm view on Meta::CPAN
##======================================================================
##--------------------------------------------------------------
## I/O: Wrappers: Binary: Storable
## ($serialized, $ref1, ...) = $cl->STORABLE_freeze($cloning)
sub STORABLE_freeze {
my ($cl,$cloning) = @_;
#return $cl->clone if ($cloning); ##-- weirdness
## $saveref = { cascade=>$csc, max_weight=>$w, ... }
my $saveref = { map { ($_=>$cl->can($_)->($cl)) } qw(cascade max_weight max_paths max_ops n_ops) };
return ('',$saveref);
}
## $cl = STORABLE_thaw($cl, $cloning, $serialized, $ref1,...)
sub STORABLE_thaw {
my ($cl,$cloning) = @_[0,1];
##-- STRANGENESS (race condition on perl program exit)
## + Storable already bless()d a reference to undef for us: this is BAD
## + hack: set its value to 0 (NULL) so that DESTROY() ignores it
XL/Cascade/Lookup.pm view on Meta::CPAN
1;
__END__
# Below is stub documentation for your module. You'd better edit it!
=pod
=head1 NAME
Gfsm::XL::Cascade::Lookup - libgfsmxl finite-state cascade lookup routines
=head1 SYNOPSIS
use Gfsm;
use Gfsm::XL;
##------------------------------------------------------------
## Constructors, etc.
$cl = Gfsm::XL::Cascade::Lookup->new($max_weight, $max_paths, $max_ops);
##--------------------------------------------------------------
## Attributes
$csc = $cl->cascade(); ##-- get underlying cascade
$csc = $cl->cascade($csc); ##-- set underlying cascade
$w = $cl->max_weight(?$w); ##-- get/set max weight (-1 for none)
$n = $cl->max_paths(?$n); ##-- get/set max number of paths (-1 for none)
$n = $cl->max_ops(?$n); ##-- get/set max number of heap extractions (-1 for none)
$n = $cl->n_ops(); ##-- get number of heap extractions for last run
##--------------------------------------------------------------
## Lookup
$fst = $cl->lookup(\@ilabs,?$result); ##-- n-best lookup (FST)
( run in 0.674 second using v1.01-cache-2.11-cpan-49f99fa48dc )