obrebski/utt
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Bug fixes: bubbles,props

Browse Source
This commit is contained in:
Tomasz Obrebski 2014-03-30 23:59:06 +02:00
parent f924e4be28
commit 519eaf5085
10 changed files with 254 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
share/Makefile
View File

@ -27,6 +27,7 @@ ifdef LANG_DIR
install -m 0644 pl_PL.ISO-8859-2/pl_PL.ISO-8859-2.sym $(LANG_DIR)/pl_PL.ISO-8859-2 install -m 0644 pl_PL.ISO-8859-2/pl_PL.ISO-8859-2.sym $(LANG_DIR)/pl_PL.ISO-8859-2
install -m 0644 pl_PL.UTF-8/lem.bin $(LANG_DIR)/pl_PL.UTF-8 install -m 0644 pl_PL.UTF-8/lem.bin $(LANG_DIR)/pl_PL.UTF-8
install -m 0644 gram.dgp $(LANG_DIR) install -m 0644 gram.dgp $(LANG_DIR)
install -m 0644 gram.dgc $(LANG_DIR)
install -m 0644 weights.kor $(LANG_DIR) install -m 0644 weights.kor $(LANG_DIR)
endif endif

2
share/gram.dgc
View File

@ -11,6 +11,7 @@
#==================================================================================================== #====================================================================================================
FLAG RQ FLAG RQ
FLAG TESTFLAGGG
FLAG init FLAG init
#==================================================================================================== #====================================================================================================
@ -422,7 +423,6 @@ LINK ADV ADV ncoord
LONG relagr subj,rel^ LONG relagr subj,rel^
LONG relagr cmpl_a,rel^ LONG relagr cmpl_a,rel^
AGR relagr C
AGR relagr N AGR relagr N
AGR relagr G AGR relagr G

BIN
share/pl_PL.ISO-8859-2/lem.bin
View File

Binary file not shown.

2
src/compdic/compdic
View File

@ -180,4 +180,4 @@ rm -r $tempdir
echo generating cats file ... echo generating cats file ...
cat $1 | cut -d ',' -f 2 | sort -u $2.cats cat $1 | cut -d ',' -f 2 | sort -u > $2.cats

5
src/dgc/dgc
View File

@ -292,8 +292,9 @@ for my $x (@{$in{link}})
} }
my $hflagconstr = @{$x->{hflagconstr}} ? "//@{$x->{hflagconstr}}" : ""; my $hflagconstr = @{$x->{hflagconstr}} ? "//@{$x->{hflagconstr}}" : "";
my $dflagconstr = @{$x->{dflagconstr}} ? "//@{$x->{dflagconstr}}" : ""; my $dflagconstr = @{$x->{dflagconstr}} ? "//@{$x->{dflagconstr}}" : "";
my $props = join(map { "\&$_" } $x->{props}); my $props = join('',map("\&$_", @{$x->{props}}));
print_outin("LINK $head->{cat}$hflagconstr $dep->{cat}$dflagconstr $x->{role}$props",$x, @agrs, @govs);
print_outin("LINK $head->{cat}$hflagconstr $dep->{cat}$dflagconstr $x->{role} $props",$x, @agrs, @govs);
} }
} }
} }

63
src/dgp/boubble.hh
View File

@ -23,20 +23,24 @@ enum Dir {UP=0,DOWN=1,AT_TARGET=2};
class Boubble class Boubble
{ {
public: public:
Boubble(list<Role> u, list<Role> d, LongRel l, int s=-1); Boubble() {};
Boubble(const char* pathstr, const char* l, int s=-1); Boubble(list<Role> u, list<Role> d, LongRel l, int s=-1, bool r=false);
// Boubble(const Boubble& b) {_src=b._src; _upath=b._upath; _dpath=b._dpath; _rel=b._rel; }; Boubble(const char* pathstr, const char* l, int s=-1, bool r=false);
//Boubble(const Boubble& b) {_src=b._src; _upath=b._upath; _dpath=b._dpath; _rel=b._rel; _reverse=b._reverse; };
Dir dir(); Dir dir() const;
LongRel rel(); LongRel rel() const;
int src(); int src() const;
void src(int s); void src(int s);
bool reverse() const;
void reverse(bool b);
Role next(); Role next();
Boubble* step(Role r, Dir d); Boubble* step(Role r, Dir d);
Boubble* reversed();
bool is_at_target(); bool is_at_target() const;
bool operator==(Boubble const& b) const; bool operator==(Boubble const& b) const;
bool operator!=(Boubble const& b) const; bool operator!=(Boubble const& b) const;
@ -51,18 +55,20 @@ private:
list<Role> _upath; list<Role> _upath;
list<Role> _dpath; list<Role> _dpath;
LongRel _rel; LongRel _rel;
bool _reverse;
}; };
//---------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------
inline inline
Boubble::Boubble(list<Role> u, list<Role> d, LongRel l, int s) : _upath(u), _dpath(d), _rel(l), _src(s) {} Boubble::Boubble(list<Role> u, list<Role> d, LongRel l, int s, bool r)
: _upath(u), _dpath(d), _rel(l), _src(s), _reverse(r) {}
//---------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------
inline inline
Boubble::Boubble(const char* pathstr, const char* l, int s) Boubble::Boubble(const char* pathstr, const char* l, int s, bool r)
{ {
Dir dir = UP; Dir dir = UP;
const char* p = pathstr; const char* p = pathstr;
@ -82,12 +88,13 @@ Boubble::Boubble(const char* pathstr, const char* l, int s)
_rel = LongRel(l); _rel = LongRel(l);
_src = s; _src = s;
_reverse = r;
} }
//---------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------
inline inline
Dir Boubble::dir() Dir Boubble::dir() const
{ {
if(!_upath.empty()) if(!_upath.empty())
return UP; return UP;
@ -99,13 +106,13 @@ Dir Boubble::dir()
//---------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------
inline inline
LongRel Boubble::rel() LongRel Boubble::rel() const
{ return _rel; } { return _rel; }
//---------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------
inline inline
int Boubble::src() int Boubble::src() const
{ return _src; } { return _src; }
//---------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------
@ -116,6 +123,18 @@ void Boubble::src(int s)
//---------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------
inline
bool Boubble::reverse() const
{ return _reverse; }
//----------------------------------------------------------------------------------------------------
inline
void Boubble::reverse(bool b)
{ _reverse=b; }
//----------------------------------------------------------------------------------------------------
inline inline
Role Boubble::next() Role Boubble::next()
{ {
@ -133,14 +152,14 @@ Boubble* Boubble::step(Role r, Dir d)
{ {
if(d==UP && !_upath.empty() && _upath.front() == r) if(d==UP && !_upath.empty() && _upath.front() == r)
{ {
Boubble* newboubble = new Boubble(_upath,_dpath,_rel,_src); Boubble* newboubble = new Boubble(_upath,_dpath,_rel,_src,_reverse);
newboubble->_upath.pop_front(); newboubble->_upath.pop_front();
return newboubble; return newboubble;
} }
if(d==DOWN && _upath.empty() && !_dpath.empty() && _dpath.front() == r) if(d==DOWN && _upath.empty() && !_dpath.empty() && _dpath.front() == r)
{ {
Boubble* newboubble = new Boubble(_upath,_dpath,_rel,_src); Boubble* newboubble = new Boubble(_upath,_dpath,_rel,_src,_reverse);
newboubble->_dpath.pop_front(); newboubble->_dpath.pop_front();
return newboubble; return newboubble;
} }
@ -150,7 +169,19 @@ Boubble* Boubble::step(Role r, Dir d)
//---------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------
inline inline
bool Boubble::is_at_target() Boubble* Boubble::reversed()
{
Boubble* newboubble = new Boubble(_dpath,_upath,_rel,-1,!_reverse);
newboubble->_upath.reverse();
newboubble->_dpath.reverse();
// cout << *this << "-----" << *newboubble << endl;
return newboubble;
}
//----------------------------------------------------------------------------------------------------
inline
bool Boubble::is_at_target() const
{ return _upath.empty() && _dpath.empty(); } { return _upath.empty() && _dpath.empty(); }
//---------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------
@ -207,6 +238,8 @@ std::ostream& operator<<(std::ostream& o, const Boubble& b)
o << ':'; o << ':';
o << b._rel.str(); o << b._rel.str();
o << "]"; o << "]";
if(b.reverse()) o << "!";
return o;
} }
//---------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------

276
src/dgp/dgp1.cc
View File

@ -1,3 +1,6 @@
#include <iostream>
using namespace std;
#include "dgp0.hh" #include "dgp0.hh"
#include "global.hh" #include "global.hh"
@ -78,11 +81,11 @@ int find_existing_node(int mnodeind, NodeProp p, bitset<MAXNODES>& newheadLH, bi
if(sgraph[*ps].LH==newheadLH && sgraph[*ps].LV==newheadLV) if(sgraph[*ps].LH==newheadLH && sgraph[*ps].LV==newheadLV)
{ {
ret = *ps; ret = *ps;
// fprintf(stderr,"FIND EXISTING NODE SUCCEEDED BEACAUSE OF LH/LV equality ()\n"); fprintf(stderr,"#\tsucceeded because of LH/LV equality ()\n");
} }
else else
{ {
// fprintf(stderr,"FIND EXISTING NODE FAILED BEACAUSE OF LH/LV inequality\n"); fprintf(stderr,"#\tfailed beacause of LH/LV inequality\n");
} }
} }
@ -157,78 +160,72 @@ void create_reverse_links(int n)
//==================================================================================================== //====================================================================================================
int create_new_head_node_left(int h, NodeProp& newheadprop, bitset<MAXNODES>& newheadLH, bitset<MAXNODES>& newheadLD, bitset<MAXNODES>& newheadLV) int create_new_head_node_left(int anc, NodeProp& prop, bitset<MAXNODES>& LH, bitset<MAXNODES>& LD, bitset<MAXNODES>& LV)
{ {
int newheadind = sgraph.clone(h,newheadprop); int newheadind = sgraph.clone(anc,prop);
// list<int>::iterator nextit=h; ++nextit;
// nodelist.insert(nextit,newheadind);
nodelist.push_back(newheadind); nodelist.push_back(newheadind);
sgraph[newheadind].LH=newheadLH; sgraph[newheadind].LH = LH;
sgraph[newheadind].LD = newheadLD; sgraph[newheadind].LD = LD;
sgraph[newheadind].in_LH=true; sgraph[newheadind].in_LH = true;
sgraph[newheadind].LV.reset(); sgraph[newheadind].LV.reset();
copy_links(h,newheadind); copy_links(anc,newheadind);
create_reverse_links(newheadind); create_reverse_links(newheadind);
if(debug) sgraph.print_node_debug(stderr,"C ",newheadind,h); if(debug) sgraph.print_node_debug(stderr,"add new",newheadind,anc);
// if(debug) print_sets(newheadind); // if(debug) print_sets(newheadind);
return newheadind; return newheadind;
} }
int create_new_dep_node_left(int d, NodeProp& prop, bitset<MAXNODES>& LH, bitset<MAXNODES>& LD, bitset<MAXNODES>& LV) int create_new_dep_node_left(int anc, NodeProp& prop, bitset<MAXNODES>& LH, bitset<MAXNODES>& LD, bitset<MAXNODES>& LV)
{ {
int newind = sgraph.clone(d,prop); int newind = sgraph.clone(anc,prop);
// list<int>::iterator nextit=d; ++nextit;
// nodelist.insert(nextit,newind);
nodelist.push_back(newind); nodelist.push_back(newind);
sgraph[newind].LH.reset(); sgraph[newind].LH.reset();
sgraph[newind].LD=LD; sgraph[newind].LD=LD;
sgraph[newind].in_LH=false; //??????? sgraph[newind].in_LH=false; //???????
sgraph[newind].LV.reset(); sgraph[newind].LV.reset();
copy_links(d,newind); copy_links(anc,newind);
create_reverse_links(newind); create_reverse_links(newind);
if(debug) sgraph.print_node_debug(stderr,"C ",newind,d); if(debug) sgraph.print_node_debug(stderr,"add new",newind,anc);
// if(debug) print_sets(newind); // if(debug) print_sets(newind);
return newind; return newind;
} }
int create_new_head_node_right(int h, NodeProp& newheadprop, bitset<MAXNODES>& newheadLH, bitset<MAXNODES>& newheadLD, bitset<MAXNODES>& newheadLV) int create_new_head_node_right(int anc, NodeProp& prop, bitset<MAXNODES>& newheadLH, bitset<MAXNODES>& newheadLD, bitset<MAXNODES>& newheadLV)
{ {
int newheadind = sgraph.clone(h,newheadprop); int newheadind = sgraph.clone(anc,prop);
// list<int>::iterator nextit=h; ++nextit;
// nodelist.insert(nextit,newheadind);
nodelist.push_back(newheadind); nodelist.push_back(newheadind);
sgraph[newheadind].LH=newheadLH; sgraph[newheadind].LH=newheadLH;
sgraph[newheadind].LD=newheadLD; sgraph[newheadind].LD=newheadLD;
sgraph[newheadind].in_LH=false; sgraph[newheadind].in_LH=false;
sgraph[newheadind].LV=newheadLV; sgraph[newheadind].LV=newheadLV;
copy_links(h,newheadind); copy_links(anc,newheadind);
create_reverse_links(newheadind); create_reverse_links(newheadind);
if(debug) sgraph.print_node_debug(stderr,"C ",newheadind,h); if(debug) sgraph.print_node_debug(stderr,"add new",newheadind,anc);
// if(debug) print_sets(newheadind); // if(debug) print_sets(newheadind);
return newheadind; return newheadind;
} }
int create_new_dep_node_right(int d, NodeProp& prop, bitset<MAXNODES>& LH, bitset<MAXNODES>& LD, bitset<MAXNODES>& LV) int create_new_dep_node_right(int anc, NodeProp& prop, bitset<MAXNODES>& LH, bitset<MAXNODES>& LD, bitset<MAXNODES>& LV)
{ {
int newind = sgraph.clone(d,prop); int newind = sgraph.clone(anc,prop);
nodelist.push_back(newind); nodelist.push_back(newind);
sgraph[newind].LH=LH; sgraph[newind].LH=LH;
sgraph[newind].LD=LD; sgraph[newind].LD=LD;
sgraph[newind].in_LH=true; //??????? sgraph[newind].in_LH=true; //???????
sgraph[newind].LV.reset(); sgraph[newind].LV.reset();
copy_links(d,newind); copy_links(anc,newind);
create_reverse_links(newind); create_reverse_links(newind);
if(debug) sgraph.print_node_debug(stderr,"C ",newind,d); if(debug) sgraph.print_node_debug(stderr,"ADD NEW",newind,anc);
// if(debug) print_sets(newind); // if(debug) print_sets(newind);
return newind; return newind;
@ -253,8 +250,6 @@ void connect_left(int h, int d, const Link& l, list<Boubble*>& new_head_boubbles
bitset<MAXNODES> newheadLV = sgraph[d].LV; bitset<MAXNODES> newheadLV = sgraph[d].LV;
bitset<MAXNODES> newheadLD = sgraph[h].LD; bitset<MAXNODES> newheadLD = sgraph[h].LD;
// vector<int> newedge;
newheadind = find_existing_node(sgraph[h].mnode, newheadprop, newheadLH, newheadLV); newheadind = find_existing_node(sgraph[h].mnode, newheadprop, newheadLH, newheadLV);
if( newheadind >= 0) // W£¡CZONE if( newheadind >= 0) // W£¡CZONE
sgraph[newheadind].LD |= newheadLD; sgraph[newheadind].LD |= newheadLD;
@ -301,10 +296,10 @@ void connect_left(int h, int d, const Link& l, list<Boubble*>& new_head_boubbles
sgraph[newheadind].LD.set(d); sgraph[newheadind].LD.set(d);
if(sgraph[d].saturated()) sgraph[newheadind].LD |= sgraph[d].LD; if(sgraph[d].saturated()) sgraph[newheadind].LD |= sgraph[d].LD;
if(debug) sgraph.print_arc(stderr,newheadind,d,l.role,0); if(debug) sgraph.print_arc(stderr,"new link",newheadind,d,l.role,0);
if(debug) sgraph.print_node_debug(stderr,"U ",newheadind,h); if(debug) sgraph.print_node_debug(stderr,"update",newheadind,h);
// if(debug) print_sets(newheadind); // if(debug) print_sets(newheadind);
if(debug) sgraph.print_node_debug(stderr,"U ",newdepind,d); if(debug) sgraph.print_node_debug(stderr,"update",newdepind,d);
// if(debug) print_sets(newdepind); // if(debug) print_sets(newdepind);
} }
@ -379,26 +374,105 @@ void connect_right(int h, int d, const Link& l, list<Boubble*>& new_head_boubble
if(sgraph[newheadind].saturated()) sgraph[newdepind].LH |= sgraph[newheadind].LH; if(sgraph[newheadind].saturated()) sgraph[newdepind].LH |= sgraph[newheadind].LH;
if(debug) sgraph.print_arc(stderr,newheadind,newdepind,l.role,1); if(debug) sgraph.print_arc(stderr,"new link",newheadind,newdepind,l.role,1);
if(debug) sgraph.print_node_debug(stderr,"U ",newheadind,h); if(debug) sgraph.print_node_debug(stderr,"update",newheadind,h);
if(debug) sgraph.print_node_debug(stderr,"U ",newdepind,d); if(debug) sgraph.print_node_debug(stderr,"update",newdepind,d);
} }
//==================================================================================================== //====================================================================================================
// bool check_meeting_boubles(list<Boubble*>& hboubbles, list<Boubble*>& dboubbles)
// {
// bool hremove=false; // czy usun±æ ostatnio sprawdzany b±bel
// bool dremove=false; // czy usun±æ ostatnio sprawdzany b±bel
// for(list<Boubble*>::iterator hb = hboubbles.begin(); hb != hboubbles.end(); hb = hremove ? hboubbles.erase(hb) : ++hb )
// {
// hremove=false;
// for(list<Boubble*>::iterator db = dboubbles.begin(); db != dboubbles.end(); db = dremove ? dboubbles.erase(db) : ++db )
// {
// dremove=false;
// if( (*hb)->rel()==(*db)->rel() && (*hb)->dir()==DOWN && (*db)->dir()==UP && (*hb)->reverse()!=(*db)->reverse() )
// {
// int srcnode,dstnode;
// if( (*hb)->reverse()==false )
// srcnode = (*hb)->src(), dstnode = (*db)->src();
// else
// srcnode = (*db)->src(), dstnode = (*hb)->src();
// if( grammar.check_longrel(sgraph.cat(srcnode), sgraph.cat(dstnode), (*hb)->rel()) )
// {
// hremove=dremove=true;
// if(debug) fprintf(stderr,"BOUBBLES MET!!!\n");
// }
// else
// {
// if(debug) fprintf(stderr,"BOUBBLES' MEETING FAILED!!!\n");
// return false;
// }
// }
// }
// }
// return true;
// }
//====================================================================================================
bool check_meeting_boubles(list<Boubble*>& boubbles)
{
bool hremove=false; // czy usun±æ ostatnio sprawdzany b±bel
bool dremove=false; // czy usun±æ ostatnio sprawdzany b±bel
for(list<Boubble*>::iterator hb = boubbles.begin(); hb != boubbles.end(); hb = hremove ? boubbles.erase(hb) : ++hb )
{
cout << endl << "hb:" << **hb ;
hremove=false;
for(list<Boubble*>::iterator db = hb; db != boubbles.end(); db = dremove ? boubbles.erase(db) : ++db )
{
cout << " db:" << **db;
dremove=false;
if( (*hb)->rel()==(*db)->rel() && (*hb)->reverse()!=(*db)->reverse() )
{
cout << "Z";
int srcnode,dstnode;
if( (*hb)->reverse()==false )
srcnode = (*hb)->src(), dstnode = (*db)->src();
else
srcnode = (*db)->src(), dstnode = (*hb)->src();
if( grammar.check_longrel(sgraph.cat(srcnode), sgraph.cat(dstnode), (*hb)->rel()) )
{
cout << " REMOVE ";
hremove=dremove=true;
if(debug) fprintf(stderr,"BOUBBLES MET!!!\n");
}
else
{
cout << " FAIL ";
if(debug) fprintf(stderr,"BOUBBLES' MEETING FAILED!!!\n");
return false;
}
}
}
}
return true;
}
//====================================================================================================
// sprawdza czy te, spo¶ród b±bli, które dotar³y do celu node // sprawdza czy te, spo¶ród b±bli, które dotar³y do celu node
// daj± wynik prawdziwy, dodatkowo - usuwa je z listy boubbles // daj± wynik prawdziwy, dodatkowo - usuwa je z listy boubbles
bool check_boubbles_at_target(list<Boubble*>& boubbles, int node) bool check_boubbles_at_target(list<Boubble*>& boubbles, int node)
{ {
list<Boubble*>::iterator last; // ostatnio sprawdzany b±bel
bool remove=false; // czy usun±æ ostatnio sprawdzany b±bel bool remove=false; // czy usun±æ ostatnio sprawdzany b±bel
for(list<Boubble*>::iterator b = boubbles.begin(); b != boubbles.end(); b = remove ? boubbles.erase(b) : ++b ) for(list<Boubble*>::iterator b = boubbles.begin(); b != boubbles.end(); b = remove ? boubbles.erase(b) : ++b )
if( (*b)->is_at_target() ) if( (*b)->is_at_target() )
if( grammar.check_longrel(sgraph.cat((*b)->src()), sgraph.cat(node), (*b)->rel()) ) if( grammar.check_longrel(sgraph.cat((*b)->src()), sgraph.cat(node), (*b)->rel()) )
remove=true; {
cout << endl << "REMOVE ChBatT " << **b << endl;
remove=true;
}
else else
return false; return false;
else else
@ -411,77 +485,93 @@ bool check_boubbles_at_target(list<Boubble*>& boubbles, int node)
void try_connect_dependents(int j) void try_connect_dependents(int j)
{ {
// for(list<int>::iterator i(j); i!=nodelist.begin(); --i)
// if(sgraph.visible(*i,*j) && sgraph.saturated(*i))
LViterator lvi(sgraph,j); LViterator lvi(sgraph,j);
int i; int i;
while((i=lvi.next()) >= 0) while((i=lvi.next()) >= 0)
if(sgraph.saturated(i)) {
{ //if(debug) sgraph.print_node_debug(stderr,"D-CUR>",i,-1);
if(debug) {fprintf(stderr,"## %d <-- %d ... ",i,j); }
list<const Link*> ji_links = grammar.connectable2( sgraph.cat(j), sgraph.cat(i), sgraph[j].prop.flags, sgraph[i].prop.flags); // ref do Roles!!! if(sgraph.saturated(i))
list<const Link*>::iterator ri = ji_links.begin();
if(ri == ji_links.end()) { if(debug) fprintf(stderr,"no roles\n"); }
else
{ {
for(; ri != ji_links.end(); ++ri ) if(debug) {fprintf(stderr,"%d <--",i); }
if(!grammar.check_constr2(sgraph[j].prop,sgraph[i].prop,0,**ri ))
{ if(debug) fprintf(stderr,"constraints failed\n"); } list<const Link*> ji_links = grammar.connectable2( sgraph.cat(j), sgraph.cat(i), sgraph[j].prop.flags, sgraph[i].prop.flags); // ref do Roles!!!
else list<const Link*>::iterator ri = ji_links.begin();
{ if(ri == ji_links.end()) { if(debug) fprintf(stderr," no roles\n"); }
list<Boubble*> new_head_boubbles = collect_head_boubbles(j,i,(*ri)->role); else
list<Boubble*> new_dep_boubbles = collect_dep_boubbles(j,i,(*ri)->role); {
for(; ri != ji_links.end(); ++ri )
if( !(check_boubbles_at_target(new_head_boubbles,j) && check_boubbles_at_target(new_dep_boubbles,i)) ) {
{ if(debug) fprintf(stderr,"boubbles failed\n"); } if(debug) fprintf(stderr," %s",(*ri)->role.str());
else if(!grammar.check_constr2(sgraph[j].prop,sgraph[i].prop,0,**ri ))
{ { if(debug) fprintf(stderr," ...constraints failed\n"); }
if(debug) fprintf(stderr,"success\n"); else
connect_left( j, i, **ri, new_head_boubbles, new_dep_boubbles); {
} list<Boubble*> new_head_boubbles = collect_head_boubbles(j,i,(*ri)->role);
} list<Boubble*> new_dep_boubbles = collect_dep_boubbles(j,i,(*ri)->role);
if( check_meeting_boubles(new_head_boubbles) &&
check_meeting_boubles(new_dep_boubbles) &&
check_boubbles_at_target(new_head_boubbles,j) &&
check_boubbles_at_target(new_dep_boubbles,i) )
{
if(debug) fprintf(stderr," ...SUCCESS!\n");
connect_left( j, i, **ri, new_head_boubbles, new_dep_boubbles);
}
else
{ if(debug) fprintf(stderr," ...boubbles failed\n"); }
}
}
}
} }
else
if(debug) {fprintf(stderr,"%d <-- unsaturated\n",i); }
} }
} }
//---------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------
void try_connect_heads(int j) void try_connect_heads(int j)
{ {
// for(list<int>::iterator i(j); i!=nodelist.begin(); --i)
// if(sgraph.visible(*i,*j) && sgraph.saturated(*j))
LViterator lvi(sgraph,j); LViterator lvi(sgraph,j);
int i; int i;
while((i=lvi.next()) >= 0) while((i=lvi.next()) >= 0)
if(sgraph.saturated(j))
{ {
if(debug) fprintf(stderr, "## %d --> %d ... ",i,j); // if(debug) sgraph.print_node_debug(stderr,"H-CUR> ",i,-1);
if(sgraph.saturated(j))
list<const Link*> ij_links = grammar.connectable2( sgraph.cat(i), sgraph.cat(j), sgraph[i].prop.flags, sgraph[j].prop.flags );
list<const Link*>::iterator ri = ij_links.begin();
if(ri == ij_links.end()) { if(debug) fprintf(stderr,"no roles\n"); }
else
{ {
for(; ri != ij_links.end(); ++ri ) if(debug) fprintf(stderr, "%d -->",i);
if( !grammar.check_constr2( sgraph[i].prop, sgraph[j].prop, 1, **ri ) )
{ if(debug) fprintf(stderr,"constraints failed\n"); } list<const Link*> ij_links = grammar.connectable2( sgraph.cat(i), sgraph.cat(j), sgraph[i].prop.flags, sgraph[j].prop.flags );
else list<const Link*>::iterator ri = ij_links.begin();
{ if(ri == ij_links.end()) { if(debug) fprintf(stderr," no roles\n"); }
list<Boubble*> new_head_boubbles = collect_head_boubbles(i,j,(*ri)->role); else
list<Boubble*> new_dep_boubbles = collect_dep_boubbles(i,j,(*ri)->role); {
for(; ri != ij_links.end(); ++ri )
if( !(check_boubbles_at_target(new_head_boubbles,i) && check_boubbles_at_target(new_dep_boubbles,j)) ) {
{ if(debug) fprintf(stderr,"boubbles failed\n"); } if(debug) fprintf(stderr," %s",(*ri)->role.str());
else if( !grammar.check_constr2( sgraph[i].prop, sgraph[j].prop, 1, **ri ) )
{ { if(debug) fprintf(stderr," ...constraints failed\n"); }
if(debug) fprintf(stderr,"success\n"); else
connect_right( i, j, **ri, new_head_boubbles, new_dep_boubbles ); {
} list<Boubble*> new_head_boubbles = collect_head_boubbles(i,j,(*ri)->role);
} list<Boubble*> new_dep_boubbles = collect_dep_boubbles(i,j,(*ri)->role);
if( check_meeting_boubles(new_head_boubbles) &&
check_meeting_boubles(new_dep_boubbles) &&
check_boubbles_at_target(new_head_boubbles,i) &&
check_boubbles_at_target(new_dep_boubbles,j) )
{
if(debug) fprintf(stderr," ...SUCCESS!\n");
connect_right( i, j, **ri, new_head_boubbles, new_dep_boubbles );
}
else
{ if(debug) fprintf(stderr," ...bubbles failed\n",i); }
}
}
}
} }
else
if(debug) {fprintf(stderr,"%d <-- unsaturated\n",j); }
} }
} }
@ -570,13 +660,13 @@ void dgp1()
set_initial_constraints(basenode); set_initial_constraints(basenode);
nodelist.push_back(basenode); nodelist.push_back(basenode);
if(debug) sgraph.print_node_debug(stderr,"B ",basenode,-1); // STDOUT!!! if(debug) sgraph.print_node_debug(stderr,"add base",basenode,-1); // STDOUT!!!
if(debug) print_sets(basenode); // if(debug) print_sets(basenode);
list<int>::iterator cursor=processed; list<int>::iterator cursor=processed;
while(++cursor != nodelist.end()) while(++cursor != nodelist.end())
{ {
if(debug) sgraph.print_node_debug(stderr,"> ",*cursor,-1); if(debug) sgraph.print_node_debug(stderr,"MAIN-CUR> ",*cursor,-1);
try_connect_dependents(*cursor); try_connect_dependents(*cursor);
try_connect_heads(*cursor); try_connect_heads(*cursor);
processed=cursor; processed=cursor;

5
src/dgp/grammar.hh
View File

@ -117,7 +117,7 @@ private:
vector< vector< LongRels > > longrel; //[Cat][Cat] vector< vector< LongRels > > longrel; //[Cat][Cat]
list< Boubble* > boubbles; list< Boubble* > boubbles;
vector< vector< list<Boubble*> > > uptrigger;//[Cat][Role] vector< vector< list<Boubble*> > > uptrigger;//[Cat][Role]
vector< vector< list<Boubble*> > > dntrigger;//[Cat][Role] vector< vector< list<Boubble*> > > dntrigger;//[Cat][Role]
@ -125,7 +125,8 @@ private:
void add_category(const char* s); void add_category(const char* s);
void add_type(const char* s); void add_type(const char* s);
void add_flag(const char* s) { Flag::add(s); } void add_flag(const char* s) { Flag::add(s); }
void add_long(const char* l, const char* p) { LongRel::add(l); boubbles.push_back( new Boubble(p,l) ); } void add_long(const char* l, const char* p) { LongRel::add(l); boubbles.push_back( new Boubble(p,l) );
boubbles.push_back( (new Boubble(p,l))->reversed() ); }
void add_triggers(Cat h, Cat d, LongRel l); void add_triggers(Cat h, Cat d, LongRel l);
void set_sgl(Role r) { sgl.set(r); } void set_sgl(Role r) { sgl.set(r); }

30
src/dgp/sgraph.cc
View File

@ -29,6 +29,8 @@ int SGraph::add_base_snode(int mnodeind)
newnode.edge.push_back(lastnodeind()); newnode.edge.push_back(lastnodeind());
newnode.edge_contains_self = true ;
return lastnodeind(); return lastnodeind();
} }
@ -84,12 +86,12 @@ int SGraph::print_node_debug(FILE* f, const char* pref, int n, int anc)
//---------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------
void SGraph::print_arc(FILE* f, int head, int dep, Role role, int dir) // 0 - left, 1 - right void SGraph::print_arc(FILE* f, const char* msg, int head, int dep, Role role, int dir) // 0 - left, 1 - right
{ {
if(dir==0) if(dir==0)
fprintf(f,"#A %s:%d <-- %d\n", role.str(), dep, head); fprintf(f,"%s %s:%d <-- %d\n", msg, role.str(), dep, head);
else else
fprintf(f,"#A %s:%d --> %d\n", role.str(), head, dep); fprintf(f,"%s %s:%d --> %d\n", msg, role.str(), head, dep);
} }
//==================================================================================================== //====================================================================================================
@ -112,20 +114,13 @@ int SGraph::sprint_node(char* buf, int nodeind, int anc, unsigned int info)
if (info&HEADS) if (info&HEADS)
for(vector<Arc>::iterator h=node.heads.begin(); h!=node.heads.end(); ++h) for(vector<Arc>::iterator h=node.heads.begin(); h!=node.heads.end(); ++h)
{ {
// if(cont) buf+=sprintf(buf,","); else cont=true;
buf+=sprintf(buf,"(++%s:%d)",h->role.str(),h->dst); buf+=sprintf(buf,"(++%s:%d)",h->role.str(),h->dst);
// buf+=sprintf(buf,"++%s-%d(%d~%d)",h->role.str(),h->dst,h->headanc,h->depanc);
// buf+=sprintf(buf,"(<-%s-%d)",h->role.str(),h->dst);
} }
if (info&DEPS) if (info&DEPS)
for(vector<Arc>::iterator d=node.deps.begin(); d!=node.deps.end(); ++d) for(vector<Arc>::iterator d=node.deps.begin(); d!=node.deps.end(); ++d)
{ {
// if(! nodes[d->dst].saturated()) continue; // NIE DRUKUJ NIENASYCONYCH PODRZEDNIKOW
// if(cont) buf+=sprintf(buf,","); else cont=true;
buf+=sprintf(buf,"(--%s:%d)",d->role.str(),d->dst); buf+=sprintf(buf,"(--%s:%d)",d->role.str(),d->dst);
// buf+=sprintf(buf,"--%s-%d(%d~%d)",d->role.str(),d->dst,d->headanc,d->depanc);
// buf+=sprintf(buf,"(-%s->%d)",d->role.str(),d->dst);
} }
if (info&SETS) if (info&SETS)
@ -176,15 +171,16 @@ int SGraph::sprint_node(char* buf, int nodeind, int anc, unsigned int info)
int SGraph::sprint_node_debug(char* buf, const char* pref, int n, int anc) int SGraph::sprint_node_debug(char* buf, const char* pref, int n, int anc)
{ {
char *buf0 = buf; char *buf0 = buf;
buf+=sprintf(buf,"#%s",pref); buf+=sprintf(buf,"%-10s",pref);
buf+=sprintf(buf,"%d.%s",n,form(n));
buf+=sprintf(buf,"%-16s",form(n)); buf+=sprintf(buf,";");
buf+=sprintf(buf,"%s ",cat(n).str());
while(buf-buf0<40) buf+=sprintf(buf," ");
buf+=sprint_node(buf,n,anc,HEADS|DEPS|SETS|CONSTRAINTS); buf+=sprint_node(buf,n,anc,HEADS|DEPS|SETS|CONSTRAINTS);
buf+=sprintf(buf,"/"); // buf+=sprintf(buf,"/");
for(vector<int>::iterator e = nodes[n].edge.begin(); e != nodes[n].edge.end(); e++ ) // for(vector<int>::iterator e = nodes[n].edge.begin(); e != nodes[n].edge.end(); e++ )
buf += sprintf(buf,"%d ", *e); // buf += sprintf(buf,"%d ", *e);
buf+=sprintf(buf,"\n"); buf+=sprintf(buf,"\n");
return buf-buf0; return buf-buf0;

7
src/dgp/sgraph.hh
View File

@ -227,7 +227,7 @@ public:
int print_node(FILE* f, int n, unsigned int info); int print_node(FILE* f, int n, unsigned int info);
int print_node_debug(FILE* f, const char* pref, int n, int anc); int print_node_debug(FILE* f, const char* pref, int n, int anc);
void print_arc(FILE* f, int left, int right, Role role, int dir); // 0 - left, 1 - right void print_arc(FILE* f, const char* msg, int left, int right, Role role, int dir); // 0 - left, 1 - right
//private: //private:
@ -326,11 +326,6 @@ inline LViterator::LViterator(SGraph& sg, int n, bool s=true) : sgraph(sg), mgra
} }
} }
// if(!strict)
// {
// push_ld(n);
// push_ln(n);
// }
} }
inline int LViterator::next() inline int LViterator::next()