void Population::buildRelation(std::list<Population>::iterator itSelf, std::list<Population>::reverse_iterator itOther){
// std::cout << "Building relation\nof " << (*this) << "to " << (*itOther) << std::endl;
Relation newRel(m_specie, itOther->m_specie, itOther->m_n);
if( newRel.isEmpty() ){
// std::cout << "Done building empty relation from " << m_specie.m_id << " to " << itOther->m_specie.m_id << std::endl;
return;
}
// std::cout << "Nonempty relation found from " << m_specie.m_id << " to " << itOther->m_specie.m_id << ": " << newRel;
m_lambda += newRel.m_psi;
m_ksi = m_lambda*((PROPFLOAT) m_n);
m_listOfRelations.push_back(newRel);
auto itToNewRelation = m_listOfRelations.end();
itToNewRelation--;
itOther->addDependentRelation(itSelf, itToNewRelation);
// std::cout << "Done building relation\n\n";
}
void CEngSemStructure::InfinitiveAndIf(int iEngNode)
{
if( m_Nodes[iEngNode].m_MainWordNo==-1 )
return;
int iRusNode = m_Nodes[iEngNode].RusNode;
if( iRusNode == -1 )
return;
int iSemMainWord = RusStr.GetNode(iRusNode).m_MainWordNo;
if( iSemMainWord == -1 )
return;
CEngSemNode& engNode = m_Nodes[iEngNode];
if (!HasSubjAsFirstValency(engNode))
return;
// проверим, что это (строго) инфинитив
CEngSemWord& engWord = engNode.m_Words[engNode.m_MainWordNo];
const CSemNode& rusNode = RusStr.GetNode(engNode.RusNode);
const CSemWord& rusWord = rusNode.GetWord(iSemMainWord);
if( !rusWord.HasPOS(INFINITIVE) )
return;
// такие конструкции возможны только с глаголом, у которого SF1 = 1 ANIM
if( rusNode.GetType()==NoneRoss || rusNode.GetUnitNo()==ErrUnitNo )
return;
if( !GetRossHolder(rusNode.GetType())->HasFieldValue(string("SF"),string("ANIM"),rusNode.GetUnitNo(),1) ) return;
// проверим, что есть межклаузная связь с "если"
vector<long> inRels;
GetIncomingRelations(iEngNode, inRels, false);
if( inRels.size() != 1 )
return;
if( !IsRelBetweenClauses(m_Relations[inRels[0]]))
return;
if( m_Relations[inRels[0]].m_RusRel == -1)
return;
const CSemRelation& rusRel = *RusStr.GetRelation(m_Relations[inRels[0]].m_RusRel);
if( rusRel.m_SynReal.m_Conj.m_DictType != OborRoss )
return;
if( rusRel.m_SynReal.m_Conj.m_UnitNo == ErrUnitNo )
return;
string strOb = GetRoss(OborRoss)->GetEntryStr(rusRel.m_SynReal.m_Conj.m_UnitNo);
if( strOb.find("если") == -1)
return;
// проверим, что нет subj
vector<long> outRels;
GetOutcomingRelations(iEngNode,outRels);
for( int i=0; i<outRels.size(); i++ )
{
if( IsSubj(m_Relations[outRels[i]]) )
return;
}
// добавим "one"
CEngSemNode newNode;
CreateSimpleEnglNode("one",newNode,0,true);
assert(newNode.m_Words.size()==1);
newNode.m_Words[0].AddFormGrammem(eSingular);
newNode.m_ClauseNo = engNode.m_ClauseNo;
long wNo = m_Nodes[iEngNode].GetMinWordNo();
FreeWordNo(wNo);
newNode.m_Words[0].m_WordNo = wNo;
m_Nodes.push_back(newNode);
CEngSemRelation newRel(CValency("InfinitiveAndIf",A_C),iEngNode,m_Nodes.size()-1,"");
newRel.m_Valency = engNode.m_Vals[0];
newRel.m_SynReal.m_Cortege = engNode.m_Patterns[0].m_GramCorteges[0];
newRel.m_Position = "<";
newRel.m_PosType = FromAlgorithmPosType;
m_Relations.push_back(newRel);
//
m_Nodes[iEngNode].m_Words[m_Nodes[iEngNode].m_MainWordNo].SetTense(present_smp_tn,"InfinitiveAndIf");
m_Nodes[iEngNode].m_Words[m_Nodes[iEngNode].m_MainWordNo].AddFormGrammem(eSingular);
}
void CEngSemStructure::ImpersonalVerb(int iEngNode)
{
// не применяется, если граф не собран
if( !IsConnected() )
return;
//
if( m_Nodes[iEngNode].m_MainWordNo==-1 )
return;
int iRusNode = m_Nodes[iEngNode].RusNode;
if( iRusNode == -1 )
return;
const CSemNode& rusNode = RusStr.GetNode(iRusNode);
//
CEngSemNode& engNode = m_Nodes[iEngNode];
CEngSemWord& engWord = engNode.m_Words[engNode.m_MainWordNo];
if( !engWord.HasPOS(eVERB) && !engWord.HasPOS(eMOD) )
return;
if( engNode.HasRelOperator("_мягк_пригласит_наклонение") ||
engNode.HasRelOperator("_пригласит_наклонение") )
return;
if( engNode.m_Words[0].m_Lemma=="have" )
return;
if( engNode.m_Words[0].m_Lemma=="keep" )
return;
vector<long> inRels;
GetIncomingRelations(iEngNode, inRels, false);
for( int k=0; k<inRels.size(); k++ )
{
if( m_Nodes[m_Relations[inRels[k]].m_SourceNodeNo].m_Words[0].m_Lemma=="keep" )
return;
}
if (!HasSubjAsFirstValency(engNode))
return;
// модальный глагол
bool bModCX = ( engNode.GetType()!=NoneRoss && GetRossHolder(engNode.GetType())->HasFieldValue("SF","MODL",engNode.GetUnitNo()) );
// (3|прш) + мн
bool bCase1 = (engWord.HasOneGrammem(eThirdPerson) || is_past(engWord.GetTense()))
&& engWord.HasOneGrammem(ePlural);
// (3|(ср&прш)) + ед
bool bCase2 = ( engWord.HasOneGrammem(eThirdPerson)
|| (is_past(engWord.GetTense())
&& !engWord.HasOneGrammem(eMasculinum)
&& !engWord.HasOneGrammem(eFeminum))
)
&& engWord.HasOneGrammem(eSingular);
if( !bCase1 && !bCase2 )
return;
// если есть subj
if ( GetSubj(iEngNode) != -1 ) return;
// для помет pass(ADR) ищем адресата
vector<long> outRels;
GetOutcomingRelations(iEngNode,outRels);
int iAdrRel = -1;
if( HasALG(m_Nodes[iEngNode].GetType(),m_Nodes[iEngNode].GetUnitNo(),"pass(ADR)") )
{
for( int i=0; i<outRels.size(); i++ )
{
int iSrc = m_Nodes[m_Relations[outRels[i]].m_SourceNodeNo].m_ClauseNo;
int iTrg = m_Nodes[m_Relations[outRels[i]].m_TargetNodeNo].m_ClauseNo;
if( iSrc != iTrg )
continue;
if( m_Relations[outRels[i]].m_Valency.m_RelationStr=="ADR" ) {
iAdrRel = outRels[i];
break;
}
}
}
// ищем объект, который не subj
int iObjRel = -1;
for(int i=0; i<outRels.size(); i++ )
{
int iSrc = m_Nodes[m_Relations[outRels[i]].m_SourceNodeNo].m_ClauseNo;
int iTrg = m_Nodes[m_Relations[outRels[i]].m_TargetNodeNo].m_ClauseNo;
if( iSrc != iTrg )
continue;
if( IsObjPattern(m_Relations[outRels[i]]) )
{
iObjRel = outRels[i];
break;
}
}
// будующий subj
int iSubRel = iAdrRel;
if( iSubRel==-1 )
iSubRel = iObjRel;
// если есть кого - переведем его в subj, проставим Passive и число
if( iSubRel != -1 )
{
m_Relations[iSubRel].m_SynReal.m_Cortege = engNode.m_Patterns[0].m_GramCorteges[0];
m_Relations[iSubRel].m_Valency = engNode.m_Vals[0];
m_Relations[iSubRel].m_Position = "<";
m_Relations[iSubRel].m_PosType = FromAlgorithmPosType;
CEngSemNode& impNode = m_Nodes[m_Relations[iSubRel].m_SourceNodeNo];
CEngSemNode& objNode = m_Nodes[m_Relations[iSubRel].m_TargetNodeNo];
int iImpMainWord = impNode.m_MainWordNo;
assert( iImpMainWord != -1 );
impNode.m_Words[iImpMainWord].m_bMorphologicalPassiveForm = true;
int iRusObj = objNode.RusNode;
if( iRusObj != -1 )
TransferNumberGrammems(RusStr.GetNode(iRusObj),impNode.m_Words[iImpMainWord]);
// тот же пассив надо проставить всем "и" узлам без Subj
for( int i=0; i<outRels.size(); i++ )
{
int iSrc = m_Nodes[m_Relations[outRels[i]].m_SourceNodeNo].m_ClauseNo;
int iTrg = m_Nodes[m_Relations[outRels[i]].m_TargetNodeNo].m_ClauseNo;
if( iSrc == iTrg )
continue;
if( m_Relations[outRels[i]].m_Valency.m_RelationStr != "AND" )
continue;
int iNode = m_Relations[outRels[i]].m_TargetNodeNo;
if( !m_Nodes[iNode].HasPOS(eVERB) )
continue;
vector<long> outRels2;
GetOutcomingRelations(iNode,outRels2);
bool bHasSub = false;
for( int j=0; j<outRels2.size(); j++ )
{
if( IsSubj(m_Relations[outRels2[j]]) )
bHasSub = true;
}
if( bHasSub )
continue;
if( m_Nodes[iNode].m_MainWordNo == -1 )
continue;
m_Nodes[iNode].m_Words[m_Nodes[iNode].m_MainWordNo].m_bMorphologicalPassiveForm = true;
if( iRusObj != -1 )
TransferNumberGrammems(RusStr.GetNode(iRusObj),m_Nodes[iNode].m_Words[m_Nodes[iNode].m_MainWordNo]);
}
return;
}
for( int k=0; k<inRels.size(); k++ )
{
int iSrc = m_Nodes[m_Relations[inRels[k]].m_SourceNodeNo].m_ClauseNo;
int iTrg = m_Nodes[m_Relations[inRels[k]].m_TargetNodeNo].m_ClauseNo;
if( iSrc == iTrg )
continue;
if( m_Relations[inRels[k]].m_Valency.m_RelationStr == "AND" )
return; // часть глагольной MUA
}
// нет объекта
CEngSemNode newNode;
if( bCase1 )
{
CreateSimpleEnglNode("they",newNode,0,true);
newNode.m_Words[0].AddFormGrammem (ePlural);
}
else if( !bModCX )
{
CreateSimpleEnglNode("it",newNode,0,true);
newNode.m_Words[0].AddFormGrammem(eSingular);
}
else
{
CreateSimpleEnglNode("one",newNode,0,true);
newNode.m_Words[0].AddFormGrammem(eSingular);
}
newNode.m_ClauseNo = m_Nodes[iEngNode].m_ClauseNo;
long wNo = m_Nodes[iEngNode].GetMinWordNo();
FreeWordNo(wNo);
newNode.m_Words[0].m_WordNo = wNo;
m_Nodes.push_back(newNode);
CEngSemRelation newRel(CValency("ImpersonalVerb",A_C),iEngNode,m_Nodes.size()-1,"");
newRel.m_bInterpreted = false;
if (!engNode.m_Patterns.empty() && !engNode.m_Patterns[0].m_GramCorteges.empty())
newRel.m_SynReal.m_Cortege = engNode.m_Patterns[0].m_GramCorteges[0];
if (!engNode.m_Vals.empty())
newRel.m_Valency = engNode.m_Vals[0];
newRel.m_Position = "<";
newRel.m_PosType = FromAlgorithmPosType;
m_Relations.push_back(newRel);
}
void CEngSemStructure::ApplyPredicativeRule(int iEngNode)
{
if( m_Nodes[iEngNode].m_MainWordNo==-1 )
return;
int iRusNode = m_Nodes[iEngNode].RusNode;
if( iRusNode == -1 )
return;
int iSemMainWord = RusStr.GetNode(iRusNode).m_MainWordNo;
if( iSemMainWord == -1 )
return;
if( RusStr.GetNode(iRusNode).GetType() != Ross )
return;
if( !GetRossHolder(Ross)->HasFieldValue(string("GF"),string("ПРЕДК:ГГ"),RusStr.GetNode(iRusNode).GetUnitNo())
&& !GetRossHolder(Ross)->HasFieldValue(string("GF"),string("ГЛ:ГГ_безл"),RusStr.GetNode(iRusNode).GetUnitNo())
)
return;
if( m_Nodes[iEngNode].HasPOS(eVBE) ||
m_Nodes[iEngNode].HasPOS(eMOD) ||
m_Nodes[iEngNode].HasPOS(eVERB) )
return;
vector<long> inRels;
GetIncomingRelations(iEngNode,inRels,false);
for( int i=0; i<inRels.size(); i++ )
{
int iSrc = m_Nodes[m_Relations[inRels[i]].m_SourceNodeNo].m_ClauseNo;
int iTrg = m_Nodes[m_Relations[inRels[i]].m_TargetNodeNo].m_ClauseNo;
if( iSrc != iTrg )
continue;
CEngSemNode& engNode = m_Nodes[m_Relations[inRels[i]].m_SourceNodeNo];
if( engNode.HasPOS(eVBE) || engNode.HasPOS(eMOD) || engNode.HasPOS(eVERB) )
return;
}
// определим тип
bool bTypeIam = false;
if( m_Nodes[iEngNode].GetType() != NoneRoss )
{
if( GetRossHolder(m_Nodes[iEngNode].GetType())->HasFieldValue("RESTR","predic",m_Nodes[iEngNode].GetUnitNo()) ||
GetRossHolder(m_Nodes[iEngNode].GetType())->HasFieldValue("RESTR","subj", m_Nodes[iEngNode].GetUnitNo()) )
bTypeIam = true;
}
CEngSemNode newNode;
int iSubjPattern = -1,iObjPattern = -1;
CreateBeSemNode(newNode,iSubjPattern,iObjPattern);
assert( (iObjPattern!=-1) && (iSubjPattern!=-1) );
newNode.RusNode = m_Nodes[iEngNode].RusNode;
newNode.m_ClauseNo = m_Nodes[iEngNode].m_ClauseNo;
TransferTimeGrammems(RusStr.GetNode(iRusNode), newNode,"ApplyPredicativeRule");
if( newNode.m_Words[0].GetTense() == zero_tn )
newNode.m_Words[0].SetTense(present_smp_tn, "ApplyPredicativeRule");
m_Nodes[iEngNode].m_Words[0].SetTense(zero_tn, "ApplyPredicativeRule");
long wNo = m_Nodes[iEngNode].GetMinWordNo();
FreeWordNo(wNo);
assert(newNode.m_Words.size()==1);
newNode.m_Words[0].m_WordNo = wNo;
m_Nodes.push_back(newNode); // be
int iBeNode = m_Nodes.size()-1;
CEngSemRelation newRel(CValency("S-ACT",A_C),m_Nodes.size()-1,iEngNode,""); newRel.m_bInterpreted = true;
newRel.m_Valency.m_RossHolder = GetRossHolder(m_Nodes[iBeNode].GetType());
newRel.m_Valency.m_UnitNo = m_Nodes[iBeNode].GetUnitNo();
newRel.m_Valency.m_LeafId = 2;
newRel.m_Pattern = m_Nodes[iBeNode].m_Patterns[iObjPattern];
newRel.m_SynReal.m_Cortege = m_Nodes[iBeNode].m_Patterns[iObjPattern].m_GramCorteges[0];
newRel.m_Position = ">";
newRel.m_PosType = FromAlgorithmPosType;
m_Relations.push_back(newRel); // be->Pred
// поищем Subj, поставим предлог for
vector<long> outRels;
GetOutcomingRelations(iEngNode,outRels);
int iSubjRel = -1;
for( int i=0; i<outRels.size(); i++ )
{
if( m_Nodes[m_Relations[outRels[i]].m_SourceNodeNo].m_ClauseNo !=
m_Nodes[m_Relations[outRels[i]].m_TargetNodeNo].m_ClauseNo )
continue;
//
if( m_Relations[outRels[i]].m_Valency.m_RelationStr == "CONTEN" )
m_Relations[outRels[i]].m_SynReal.m_Cortege.SetItem(0, -1);
//
if( m_Relations[outRels[i]].m_Valency.m_RelationStr == "SUB" ||m_Relations[outRels[i]].m_Valency.m_RelationStr == "PACIEN" )
{
iSubjRel = outRels[i];
if( !bTypeIam )
{
SetSimpleEngPrep("for",-1,outRels[i]);
m_Relations[outRels[i]].m_Position = ">";
m_Relations[outRels[i]].m_PosType = FromAlgorithmPosType;
}
continue;
}
}
// два варианта
if( !bTypeIam || iSubjRel<0 )
{
newNode.m_Words.clear();
CreateSimpleEnglNode("it",newNode,0,true);
assert(newNode.m_Words.size()==1);
newNode.m_Words[0].AddFormGrammem(eSingular);
newNode.RusNode = -1;
newNode.m_ClauseNo = m_Nodes[iEngNode].m_ClauseNo;
FreeWordNo(wNo);
newNode.m_Words[0].m_WordNo = wNo;
m_Nodes.push_back(newNode);
CEngSemRelation subRel(CValency("F-ACT",A_C),iBeNode,m_Nodes.size()-1,""); subRel.m_bInterpreted = true;
subRel.m_Pattern = m_Nodes[iBeNode].m_Patterns[iSubjPattern];
subRel.m_Valency = m_Nodes[iBeNode].m_Vals[0];
subRel.m_SynReal.m_Cortege = m_Nodes[iBeNode].m_Patterns[iSubjPattern].m_GramCorteges[0];
subRel.m_Position = "<";
subRel.m_PosType = FromAlgorithmPosType;
m_Relations.push_back(subRel); // be->it
m_Nodes[iBeNode].m_Words[0].AddFormGrammem (eSingular);
}
else
{
m_Relations[iSubjRel].m_SourceNodeNo = iBeNode;
m_Relations[iSubjRel].m_bInterpreted = true;
m_Relations[iSubjRel].m_Pattern = m_Nodes[iBeNode].m_Patterns[iSubjPattern];
m_Relations[iSubjRel].m_Valency = m_Nodes[iBeNode].m_Vals[0];
m_Relations[iSubjRel].m_SynReal.m_Cortege = m_Nodes[iBeNode].m_Patterns[iSubjPattern].m_GramCorteges[0];
CEngSemNode& engSubj = m_Nodes[m_Relations[iSubjRel].m_TargetNodeNo];
int iRusSubj = engSubj.RusNode;
if( iRusSubj != -1 )
{
if( RusStr.GetNode(iRusSubj).m_NodeType == MNA )
newNode.m_Words[0].AddFormGrammem(ePlural);
else
TransferNumberGrammems(RusStr.GetNode(iRusSubj),m_Nodes[iBeNode].m_Words[0]);
}
}
// связи
MoveMeaningRelsToNewNode(iEngNode,iBeNode);
}
void CEngSemStructure::ApplyAdjShortRule(int iEngNode)
{
if( m_Nodes[iEngNode].m_MainWordNo==-1 )
return;
int iRusNode = m_Nodes[iEngNode].RusNode;
if( iRusNode == -1 )
return;
int iSemMainWord = RusStr.GetNode(iRusNode).m_MainWordNo;
if( iSemMainWord == -1 )
return;
//
if( !RusStr.GetNode(iRusNode).HasPOS(ADJ_SHORT) )
return;
if( m_Nodes[iEngNode].HasPOS(eVBE) ||
m_Nodes[iEngNode].HasPOS(eMOD) ||
m_Nodes[iEngNode].HasPOS(eVERB) )
return;
/*
если валентность требует, чтобы краткое прилагательное
стояло в инфинитиве, тогда нужно сделать, как хочет валентность
Например, "он оказался полезен" -> "He proved to be useful"
Здесь для краткого прилагательного "полезен" будет
создан инфинитив "to be"
Сокирко 31 июня 2001 года
*/
vector<long> Rels;
GetIncomingRelations(iEngNode, Rels, false);
if (Rels.size() == 1)
if (HasGramFet(m_Relations[Rels[0]], "to be+ADJECTIVE"))
{
MakeBeNodeForEngNode(iEngNode,"ApplyAdjShortRule");
GetIncomingRelations(iEngNode, Rels, false);
assert (Rels.size() == 1);
m_Nodes[m_Relations[Rels[0]].m_SourceNodeNo].m_Words[0].SetTense(present_inf_tn,"ApplyAdjShortRule");
return;
};
//
if( !RusStr.GetNode(iRusNode).HasOneGrammem(rPerfective) )
{
MakeBeNodeForEngNode(iEngNode,"ApplyAdjShortRule");
return;
}
//
CEngSemNode newNode;
CreateSimpleEnglNode("become",newNode,eVERB,false);
assert( newNode.m_Words.size()==1 );
newNode.RusNode = m_Nodes[iEngNode].RusNode;
newNode.m_ClauseNo = m_Nodes[iEngNode].m_ClauseNo;
TransferTimeGrammems(RusStr.GetNode(iRusNode),newNode,"ApplyAdjShortRule");
if( newNode.m_Words[0].GetTense() == zero_tn )
newNode.m_Words[0].SetTense(present_smp_tn,"ApplyAdjShortRule");
m_Nodes[iEngNode].m_Words[m_Nodes[iEngNode].m_MainWordNo].SetTense(zero_tn,"ApplyAdjShortRule");
long wNo = m_Nodes[iEngNode].GetMinWordNo();
FreeWordNo(wNo);
newNode.m_Words[0].m_WordNo = wNo;
m_Nodes.push_back(newNode); // become
int iNewNode = m_Nodes.size()-1;
CEngSemRelation newRel(CValency("AdjShort",A_C),iNewNode,iEngNode,"");
m_Relations.push_back(newRel); // become->Node
// поищем Subj
vector<long> outRels;
GetOutcomingRelations(iEngNode,outRels);
int iSubRel = -1;
for( int i=0; i<outRels.size(); i++ )
{
if( IsSubj(m_Relations[outRels[i]]) )
{
iSubRel = outRels[i];
break;
}
if( m_Relations[outRels[i]].m_RusRel != -1 &&
RusStr.IsRusSubj(m_Relations[outRels[i]].m_RusRel) )
{
iSubRel = outRels[i];
break;
}
}
if( iSubRel!=-1 )
{
m_Relations[iSubRel].m_SourceNodeNo = iNewNode;
m_Relations[iSubRel].m_Valency.m_RelationStr = "AdjShort";
m_Relations[iSubRel].m_bInterpreted = false;
//приписываем отношению первую валентость
m_Relations[iSubRel].m_SynReal.m_Cortege = newNode.m_Patterns[0].m_GramCorteges[0];
m_Relations[iSubRel].m_Valency = newNode.m_Vals[0];
CEngSemNode& subNode = m_Nodes[m_Relations[iSubRel].m_TargetNodeNo];
if( subNode.m_NodeType == MNA )
m_Nodes[iNewNode].AddOneGrammemRich(ePlural);
else
m_Nodes[iNewNode].AddGrammemsRich( subNode.GetGrammemsRich() & eAllNumbers );
}
else
m_Nodes[iNewNode].AddOneGrammemRich( eSingular);
// связи
MoveMeaningRelsToNewNode(iEngNode,iNewNode);
}
void CEngSemStructure::ApplyComparativeRule(int iEngNode)
{
if( m_Nodes[iEngNode].m_MainWordNo==-1 )
return;
int iRusNode = m_Nodes[iEngNode].RusNode;
if( iRusNode == -1 )
return;
int iSemMainWord = RusStr.GetNode(iRusNode).m_MainWordNo;
if( iSemMainWord == -1 )
return;
const CSemNode& rusNode = RusStr.GetNode(iRusNode);
if( rusNode.m_NodeType != MNA )
return;
if( ! rusNode.GetWord(iSemMainWord).HasOneGrammem(rComparative) )
return;
// у меня больше денег, чем у тебя
if( m_Nodes[iEngNode].HasPOS(eVBE) )
return;
// будем искать Subj
vector<long> inRels;
GetIncomingRelationsInThisClause(iEngNode,inRels);
if( inRels.size() > 1 )
return; // это нечто, чего мы не понимаем
PrintNodes();
PrintRelations();
/*
IsSimilarAdjCase - истина, если обрабатывается однородный ряд прилагательных, например:
"золото было красивее и дороже серебра"
*/
bool IsSimilarAdjCase = (inRels.size() == 1)
&& (m_Nodes[m_Relations[inRels[0]].m_SourceNodeNo].m_NodeType == MNA);
int iRelSubj = -1;
int iEnode, iRnode, iRword;
if( inRels.size()==1 )
{
iEnode = m_Relations[inRels[0]].m_SourceNodeNo;
iRnode = m_Nodes[iEnode].RusNode;
if( iRnode==-1 )
return;
iRword = RusStr.GetNode(iRnode).m_MainWordNo;
if( iRword==-1 )
return;
// если есть (единственная) входящая связь от сущ.,
// то будем считать Subj это сущ. или его MUA родителя
if( RusStr.GetNode(iRnode).GetWord(iRword).HasPOS(NOUN)
|| RusStr.GetNode(iRnode).GetWord(iRword).HasPOS(PRONOUN)
)
{
iRelSubj = inRels[0];
vector<long> inRelsSubj;
GetIncomingRelationsInThisClause(iEnode,inRelsSubj);
if( inRelsSubj.size() > 1 )
return; // это нечто, чего мы не понимаем
if( inRelsSubj.size()==0 )
{
ReverseRelation(iRelSubj);
m_Relations[iRelSubj].m_bReverseRel = false;
m_Relations[iRelSubj].m_SynReal.m_Preps.clear();
// приписываем отношению первую валентность глагола to be
m_Relations[iRelSubj].m_Valency = m_Nodes[iEngNode].m_Vals[0];
m_Relations[iRelSubj].m_SynReal.m_Cortege = m_Nodes[iEngNode].m_Patterns[0].m_GramCorteges[0];
}
else if( inRelsSubj.size()==1 )
{
// Случай однородных подлежащих
int iSubjMNA = m_Relations[inRelsSubj[0]].m_SourceNodeNo;
if( m_Nodes[iSubjMNA].m_NodeType != MNA )
return; // это нечто, чего мы не понимаем
m_Relations[iRelSubj].m_SourceNodeNo = iEngNode;
m_Relations[iRelSubj].m_TargetNodeNo = iSubjMNA;
// приписываем отношению первую валентность глагола to be
m_Relations[iRelSubj].m_Valency = m_Nodes[iEngNode].m_Vals[0];
m_Relations[iRelSubj].m_SynReal.m_Cortege = m_Nodes[iEngNode].m_Patterns[0].m_GramCorteges[0];
}
}
else if( RusStr.GetNode(iRnode).GetWord(iRword).HasPOS(VERB)
|| RusStr.GetNode(iRnode).GetWord(iRword).HasPOS(ADJ_SHORT)
|| RusStr.GetNode(iRnode).m_NodeType==MNA
)
{
}
else
{
return; // это нечто, чего мы не понимаем
}
}
// ищем субъект (неименованные связи)
vector<long> outRels;
if( iRelSubj==-1 )
{
vector<long> outRelsRaw;
GetOutcomingRelations(iEngNode,outRelsRaw);
for( int j=0; j<outRelsRaw.size(); j++ )
{
if( m_Relations[outRelsRaw[j]].m_Valency.m_RelationStr == "" &&
m_Relations[outRelsRaw[j]].m_SyntacticRelation == "" )
{
outRels.push_back(outRelsRaw[j]);
}
}
if( outRels.size() < 1 )
return;
iRelSubj = outRels[0];
int iWord0 = RusStr.GetNode(m_Nodes[m_Relations[iRelSubj].m_TargetNodeNo].RusNode).GetMinWordNo();
for( int k=1; k<outRels.size(); k++ ) // возможен неверный порядок
{
int iWord1 = RusStr.GetNode(m_Nodes[m_Relations[outRels[k]].m_TargetNodeNo].RusNode).GetMinWordNo();
if( iWord1<iWord0 )
{
iRelSubj = outRels[k];
iWord0 = iWord1;
}
}
}
// проверим Subj
CEngSemNode& engSubj = m_Nodes[m_Relations[iRelSubj].m_TargetNodeNo];
int iRusSubj = engSubj.RusNode;
if( iRusSubj == -1 )
return;
int iSemSubjWord = RusStr.GetNode(iRusSubj).m_MainWordNo;
if( iSemSubjWord == -1 )
return;
// Subj Ok
int iNodeMNA = iEngNode;
int iNodeTim = iEngNode;
// золото было красивее и дороже серебра
if(IsSimilarAdjCase)
{
int iParent = m_Relations[inRels[0]].m_SourceNodeNo;
int iParRus = m_Nodes[iParent].RusNode;
const CSemNode& rusNode = RusStr.GetNode(iParRus);
if( RusStr.GetNode(iParRus).m_NodeType == MNA )
iNodeMNA = m_Relations[inRels[0]].m_SourceNodeNo;
vector<long> outMna;
GetOutcomingRelations(iParent,outMna);
for( int i=0; i<outMna.size(); i++ )
{
/*
пустые стрелки идут только из узла типа MUA */
if( m_Relations[outMna[i]].m_Valency.m_RelationStr == "" )
{
iNodeTim = m_Relations[outMna[i]].m_TargetNodeNo;
break;
}
}
}
// если есть (единственная) входящая от глагола или краткого прилагательного
// то надо только перевесить Subj и создать связь Modifier
if( inRels.size()==1
&& ( RusStr.GetNode(iRnode).GetWord(iRword).HasPOS(VERB)
|| RusStr.GetNode(iRnode).GetWord(iRword).HasPOS(ADJ_SHORT)
)
)
{
CEngSemRelation newRel(CValency("Modifier",A_C),m_Relations[inRels[0]].m_SourceNodeNo,m_Relations[inRels[0]].m_TargetNodeNo,"");
/*
конструкция с than должна стоять после прямой син. валентности
например
I love him more than Peter.
*/
newRel.m_Position = ">";
newRel.m_PosType = FromAlgorithmPosType;
m_Relations.push_back(newRel);
m_Relations[inRels[0]].m_TargetNodeNo = m_Relations[iRelSubj].m_TargetNodeNo;
EraseRelation(iRelSubj);
return;
}
CEngSemNode newNode;
int iSubjPattern = -1, iObjPattern = -1;
CreateBeSemNode(newNode,iSubjPattern,iObjPattern);
assert( (iObjPattern!=-1) && (iSubjPattern!=-1) );
assert(newNode.m_Words.size()==1);
newNode.RusNode = iRusNode;
newNode.m_ClauseNo = m_Nodes[iEngNode].m_ClauseNo;
// время
TransferTimeGrammems(RusStr.GetNode(m_Nodes[iNodeTim].RusNode),newNode,"ApplyComparativeRule");
if( newNode.m_Words[0].GetTense() == zero_tn )
newNode.m_Words[0].SetTense(present_smp_tn, "ApplyComparativeRule");
m_Nodes[iNodeTim].m_Words[0].SetTense(zero_tn, "ApplyComparativeRule");
// число
if( RusStr.GetNode(iRusSubj).m_NodeType == MNA )
newNode.m_Words[0].AddFormGrammem(ePlural);
else
TransferNumberGrammems(RusStr.GetNode(iRusSubj),newNode.m_Words[0]);
long wNo = m_Nodes[iEngNode].GetMinWordNo();
FreeWordNo(wNo);
newNode.m_Words[0].m_WordNo = wNo;
m_Nodes.push_back(newNode); // be
int iNewNode = m_Nodes.size()-1;
m_Relations[iRelSubj].m_SourceNodeNo = iNewNode; // be->subj
m_Relations[iRelSubj].m_bInterpreted = true;
m_Relations[iRelSubj].m_Valency.m_RelationStr = "rComparative";
m_Relations[iRelSubj].m_Valency.m_RossHolder = GetRossHolder(newNode.GetType());
m_Relations[iRelSubj].m_Valency.m_UnitNo = newNode.GetUnitNo();
m_Relations[iRelSubj].m_Valency.m_LeafId = 1;
m_Relations[iRelSubj].m_Pattern = newNode.m_Patterns[iSubjPattern];
m_Relations[iRelSubj].m_SynReal.m_Cortege = newNode.m_Patterns[iSubjPattern].m_GramCorteges[0];
CEngSemRelation newRel(CValency("rComparative",A_C),iNewNode,iNodeMNA,"");
newRel.m_bInterpreted = true;
newRel.m_Valency.m_RossHolder = GetRossHolder(newNode.GetType());
newRel.m_Valency.m_UnitNo = newNode.GetUnitNo();
newRel.m_Valency.m_LeafId = 2;
newRel.m_Pattern = newNode.m_Patterns[iObjPattern];
newRel.m_SynReal.m_Cortege = newNode.m_Patterns[iObjPattern].m_GramCorteges[0];
m_Relations.push_back(newRel); // be->comp|mna
// связи
MoveMeaningRelsToNewNode(iNodeMNA,iNewNode);
}
void CEngSemStructure::CreateOneselfNodes()
{
// создание
for( int i=0; i<m_Nodes.size(); i++ )
{
for( int k=0; k<m_Nodes[i].m_Words.size(); k++ )
{
if( m_Nodes[i].m_Words[k].m_OneselfStr.empty() )
continue;
CEngSemNode newNode;
CRossInterp OneselfInterp(Aoss,GetRoss(Aoss)->LocateUnit(m_Nodes[i].m_Words[k].m_OneselfStr.c_str(),1));
CreateSimpleEnglNodeWithInterp(OneselfInterp, newNode);
newNode.RusNode = -1;
newNode.m_ClauseNo = m_Nodes[i].m_ClauseNo;
long wNo = m_Nodes[i].GetMinWordNo()+1;
FreeWordNo(wNo);
newNode.m_Words[0].m_WordNo = wNo;
m_Nodes.push_back(newNode);
CEngSemRelation newRel(CValency("#oneself",A_C,GetRossHolder(Aoss)),i,m_Nodes.size()-1,"obj");
m_Relations.push_back(newRel);
}
}
// проведение доп. связи THESAME
for( int NodeNo=0; NodeNo<m_Nodes.size(); NodeNo++ )
{
if( !( m_Nodes[NodeNo].IsPrimitive() )
|| !( (m_Nodes[NodeNo].m_Words[0].m_Lemma == "#oneself")
|| (m_Nodes[NodeNo].m_Words[0].m_Lemma == "#one's")
)
)
continue;
// если в русской структуре в отношениях были прописана стрелка DEGREE ( пассивная валентность "сам"),
// тогда нужно взять эту стрелку и успокоиться
// например, "сам он этого не сделает"
if( m_Nodes[NodeNo].RusNode != -1 )
{
vector<long> Rels;
RusStr.GetIncomingRelations(m_Nodes[NodeNo].RusNode, Rels, false);
long i=0;
for (; i < Rels.size();i++)
if ( (RusStr.GetRelation(Rels[i])->m_bReverseRel)
&& (RusStr.GetRelation(Rels[i])->m_Valency.m_RelationStr == "DEGREE")
)
break;
if (i <Rels.size())
{
long parent = GetEngNodeByRusNode(RusStr.GetRelation(Rels[i])->m_SourceNodeNo);
if (parent != -1)
m_DopRelations.push_back(CEngSemRelation(CValency("THESAME", A_C), NodeNo, parent, ""));
continue;
};
};
if (GetEquNode(NodeNo) != -1) continue;
// в противном случае, нужно искать узел, у которого есть субъектная стрелка
int parent = NodeNo;
// есть ли среди хозяев узла хотя бы один инфинитив
bool bHasParentInfinitive = false;
while(true)
{
vector<long> Rels;
GetIncomingRelations(parent, Rels);
if (Rels.size() == 0) break;
int rel = Rels[0];
parent = m_Relations[rel].m_SourceNodeNo;
bHasParentInfinitive |= is_infinitive(m_Nodes[parent].GetTense());
// ищем первый узел, у которго есть субъектная стрелка доходим до первого не инфинитива
if( GetSubj(parent) != -1 )
break;
}
if( parent != NodeNo )
{
long AntecedentNodeNo = GetSubj(parent);
if (bHasParentInfinitive)
{
vector<long> Rels;
GetOutcomingRelations(parent,Rels);
for (long i=0; i< Rels.size(); i++)
if ( (m_Relations[Rels[i]].m_Valency.m_RelationStr == "C-AGENT")
|| (m_Relations[Rels[i]].m_Valency.m_RelationStr == "OBJ")
|| (m_Relations[Rels[i]].m_Valency.m_RelationStr == "ADR")
)
if (IsObjPattern(m_Relations[Rels[i]]))
if ( (m_Nodes[m_Relations[Rels[i]].m_TargetNodeNo].GetGrammemsRich() & _QM(eAnimative))
|| HasSemFet(m_Nodes[m_Relations[Rels[i]].m_TargetNodeNo],"ANIM")
)
AntecedentNodeNo = m_Relations[Rels[i]].m_TargetNodeNo;
}
if( AntecedentNodeNo != -1 )
m_DopRelations.push_back(CEngSemRelation(CValency("THESAME", A_C),NodeNo,AntecedentNodeNo,"")); }
}
}
