/// <summary> Checks the specified morpheme is exist in the morpheme chart.</summary>
/// <param name="morpheme">- the list of indices of the morphemes to check
/// </param>
/// <param name="morphemeLen">- the length of the list
/// </param>
/// <param name="tag">- morpheme tag ID
/// </param>
/// <param name="phoneme">- phoneme
/// </param>
/// <param name="nextPosition">- the index of the next morpheme
/// </param>
/// <param name="nextTagType">- the type of the next morpheme tag
/// </param>
/// <param name="str">- plain string
/// </param>
/// <returns> true: the morpheme is in the chart, false: not exist
/// </returns>
public virtual bool checkChart(int[] morpheme, int morphemeLen, int tag, int phoneme, int nextPosition, int nextTagType, System.String str)
{
for (int i = 0; i < morphemeLen; i++)
{
Morpheme morph = chart[morpheme[i]];
if (morph.tag == tag && morph.phoneme == phoneme && morph.nextPosition == nextPosition && morph.nextTagType == nextTagType && morph.str.Equals(str))
{
return(true);
}
}
return(false);
}
public void IsComplete()
{
AdTree adTree = new AdTree(new Morpheme(myAttributesModel, "book", EnglishAttributes.O.Lexeme), EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme));
Assert.IsTrue(adTree.IsComplete());
// Missing morph.
adTree = new AdTree(new Morpheme(myAttributesModel, "", EnglishAttributes.O.Lexeme), EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme));
Assert.IsFalse(adTree.IsComplete());
// Missing attributes.
adTree = new AdTree(new Morpheme(myAttributesModel, "book", 0), EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme));
Assert.IsFalse(adTree.IsComplete());
adTree = new AdTree(new Morpheme(myAttributesModel, "", EnglishAttributes.A.Lexeme), EnglishPattern.MonoTransference("O>A", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme))
{
Left = null,
Right = new AdTree(new Morpheme(myAttributesModel, "", 0), new Pattern()),
};
Assert.IsTrue(adTree.IsComplete());
// Right is missing.
adTree = new AdTree(new Morpheme(myAttributesModel, "", EnglishAttributes.A.Lexeme), EnglishPattern.MonoTransference("O>A", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme))
{
Left = null,
Right = null,
};
Assert.IsFalse(adTree.IsComplete());
adTree = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.EpsilonAdPosition("A-O", "", EnglishAttributes.A, EnglishAttributes.O))
{
Left = new AdTree(new Morpheme(myAttributesModel, "", 0), new Pattern()),
Right = new AdTree(new Morpheme(myAttributesModel, "", 0), new Pattern()),
};
Assert.IsTrue(adTree.IsComplete());
adTree = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.EpsilonAdPosition("A-O", "", EnglishAttributes.A, EnglishAttributes.O))
{
Left = null,
Right = new AdTree(new Morpheme(myAttributesModel, "", 0), new Pattern()),
};
Assert.IsFalse(adTree.IsComplete());
adTree = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.EpsilonAdPosition("A-O", "", EnglishAttributes.A, EnglishAttributes.O))
{
Left = new AdTree(new Morpheme(myAttributesModel, "", 0), new Pattern()),
Right = null,
};
Assert.IsFalse(adTree.IsComplete());
}
public void Generate(Namespace name_space)
{
name = name_space.name + "." + name;
@this = new Morpheme(name, MorphemeAttribute.Class, this, null, new Core.Type(name, Tag.BASIC, 2));
foreach (var def in defs)
{
def.Generate(this);
}
foreach (var method in methods)
{
method.Generate(this);
}
}
///<summary>
///Generate a single span (morpheme)
///</summary>
private string GenerateSpan(Morpheme morpheme, bool firstWord = false)
{
string gloss = morpheme.Gloss;
string original = morpheme.Original;
string labels = "labels='" + string.Join(" ", morpheme.Labels) + "'";
if (firstWord)
{
original = original.FirstCharToUpper();
}
return($"<span class='morpheme' gloss='{gloss}' {labels}>{original}</span>");
}
public void CanAttachToLeft()
{
IAdTree adTree = new AdTree(Morpheme.Epsilon(myAttributesModel),
new Pattern()
{
LeftRule = EnglishMorphemeRule.O_Lexeme,
}
);
IAdTree adTreeElement = new AdTree(new Morpheme(myAttributesModel, "car", EnglishAttributes.O.Lexeme),
new Pattern()
{
UpRule = EnglishMorphemeRule.O_Lexeme
});
Assert.IsTrue(adTree.CanAttachToLeft(adTreeElement, myAttributesModel));
// Primitive transference.
adTree = new AdTree(Morpheme.Epsilon(myAttributesModel),
new Pattern()
{
LeftRule = EnglishMorphemeRule.A_Lexeme,
}
);
adTreeElement = new AdTree(new Morpheme(myAttributesModel, "", EnglishAttributes.A.Lexeme),
EnglishPattern.MonoTransference("O>A", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme))
{
Right = new AdTree(new Morpheme(myAttributesModel, "car", EnglishAttributes.O.Lexeme),
new Pattern()
{
UpRule = EnglishMorphemeRule.O_Lexeme
})
};
Assert.IsTrue(adTree.CanAttachToLeft(adTreeElement, myAttributesModel));
adTree = new AdTree(Morpheme.Epsilon(myAttributesModel),
new Pattern()
{
LeftRule = EnglishMorphemeRule.O_Lexeme,
}
);
adTreeElement = new AdTree(new Morpheme(myAttributesModel, "green", EnglishAttributes.A.Lexeme),
new Pattern()
{
UpRule = EnglishMorphemeRule.A_Lexeme
});
Assert.IsFalse(adTree.CanAttachToLeft(adTreeElement, myAttributesModel));
}
private static void RecordElem(string elem, List <Morpheme> mlist)
{
foreach (Morpheme mo in mlist)
{
if (mo.Name == elem)
{
mo.Count++;
return;
}
}
Morpheme mor = new Morpheme(elem, 1);
mlist.Add(mor);
}
public void GetNonconformities_MonoTransference()
{
AdTree adTree = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.EpsilonAdPosition("A-O", "", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme))
{
Right = new AdTree(new Morpheme(myAttributesModel, "car", EnglishAttributes.O.Lexeme), EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme)),
Left = new AdTree(new Morpheme(myAttributesModel, "", EnglishAttributes.A.Lexeme), EnglishPattern.MonoTransference("O>A", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme))
{
Right = new AdTree(new Morpheme(myAttributesModel, "race", EnglishAttributes.O.Lexeme), EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme)),
Left = null,
},
};
List <IAdTree> nonconformities = adTree.GetNonconformities(myAttributesModel).ToList();
Assert.AreEqual(0, nonconformities.Count);
}
public void CanAttachToLeft_Substitution()
{
IAdTree adTree = new AdTree(Morpheme.Epsilon(myAttributesModel),
new Pattern()
{
LeftRule = EnglishMorphemeRule.O_Lexeme,
}
);
IAdTree adTreeElement = new AdTree(Morpheme.Epsilon(myAttributesModel),
new Pattern()
{
UpRule = MorphemeRule.Epsilon, LeftRule = EnglishMorphemeRule.A_Lexeme, RightRule = EnglishMorphemeRule.O_Lexeme
})
{
Right = new AdTree(new Morpheme(myAttributesModel, "car", EnglishAttributes.O.Lexeme),
new Pattern()
{
UpRule = EnglishMorphemeRule.Is(MorphRules.Something, EnglishAttributes.O.Lexeme)
}),
};
Assert.IsTrue(adTree.CanAttachToLeft(adTreeElement, myAttributesModel));
// Substitution is not allowed.
adTree = new AdTree(Morpheme.Epsilon(myAttributesModel),
new Pattern()
{
LeftRule = EnglishMorphemeRule.O_Lexeme,
}.SetSubstitutionForLeft(SubstitutionRules.Nothing)
);
adTreeElement = new AdTree(Morpheme.Epsilon(myAttributesModel),
new Pattern()
{
UpRule = MorphemeRule.Epsilon, LeftRule = EnglishMorphemeRule.A_Lexeme, RightRule = EnglishMorphemeRule.O_Lexeme
})
{
Right = new AdTree(new Morpheme(myAttributesModel, "car", EnglishAttributes.O.Lexeme),
new Pattern()
{
UpRule = EnglishMorphemeRule.Is(MorphRules.Something, EnglishAttributes.O.Lexeme)
}),
};
Assert.IsFalse(adTree.CanAttachToLeft(adTreeElement, myAttributesModel));
}
public void CanAttachToRight_Substitution_Morphemic()
{
IAdTree adTree = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.EpsilonAdPosition("O-A", "", EnglishAttributes.O.Lexeme, EnglishAttributes.A.Lexeme))
{
Left = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.EpsilonAdPosition("A-O", "", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme))
};
IAdTree adTreeElement = new AdTree(new Morpheme(myAttributesModel, "car", EnglishAttributes.O.Lexeme), EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme));
Assert.IsTrue(adTree.Left.CanAttachToRight(adTreeElement, myAttributesModel));
// The morpheme is not attached to the right yet - so only rules are evaluated.
adTreeElement = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.EpsilonAdPosition("A-O", "", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme));
Assert.IsTrue(adTree.Left.CanAttachToRight(adTreeElement, myAttributesModel));
// The morpheme is not attached to the right yet - so only rules are evaluated => incorrect rules.
adTreeElement = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.EpsilonAdPosition("O-A", "", EnglishAttributes.O.Lexeme, EnglishAttributes.A.Lexeme));
Assert.IsFalse(adTree.Left.CanAttachToRight(adTreeElement, myAttributesModel));
adTree = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.EpsilonAdPosition("O-A", "", EnglishAttributes.O.Lexeme, EnglishAttributes.A.Lexeme))
{
Left = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.EpsilonAdPosition("A-O", "", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme))
{
Right = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.EpsilonAdPosition("A-O", "", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme))
}
};
// Now try to attach the morpheme.
adTreeElement = new AdTree(new Morpheme(myAttributesModel, "car", EnglishAttributes.O.Lexeme), EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme));
Assert.IsTrue(adTree.Left.Right.CanAttachToRight(adTreeElement, myAttributesModel));
// Attach to the right on the root.
adTree = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.EpsilonAdPosition("A-O", "", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme));
adTreeElement = new AdTree(new Morpheme(myAttributesModel, "car", EnglishAttributes.O.Lexeme), EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme));
Assert.IsTrue(adTree.CanAttachToRight(adTreeElement, myAttributesModel));
// Attach to the right on the root - incorrect morpheme.
adTree = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.EpsilonAdPosition("A-O", "", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme));
adTreeElement = new AdTree(new Morpheme(myAttributesModel, "green", EnglishAttributes.A.Lexeme), EnglishPattern.Morpheme(EnglishAttributes.A.Lexeme));
Assert.IsFalse(adTree.CanAttachToRight(adTreeElement, myAttributesModel));
}
/// <summary>
/// Returns the morpheme for Morpheme, MonoTransference or PairTransference adtree.
/// </summary>
/// <remarks>
/// Returns null if the
/// </remarks>
/// <param name="adTree"></param>
/// <returns></returns>
public static Morpheme TryGetTransferenceMorpheme(this IAdTree adTree)
{
Morpheme result = null;
if (adTree.Pattern.IsMorpheme)
{
result = adTree.Morpheme;
}
else if (adTree.Pattern.IsMonoTransference)
{
result = new Morpheme(adTree.Morpheme.AttributesModel, adTree.Right?.Morpheme.Morph, adTree.Morpheme.Attributes);
}
else if (adTree.Pattern.IsPairTransference)
{
result = new Morpheme(adTree.Morpheme.AttributesModel, adTree.Phrase, adTree.Morpheme.Attributes);
}
return(result);
}
private MorphemeRelevantAdTrees GetAdTreesForMorpheme(Morpheme morpheme)
{
using (Trace.Entering())
{
var result = new MorphemeRelevantAdTrees();
IEnumerable <Pattern> matchingPatterns = myConstructiveDictionary.FindPatterns(morpheme);
// Go via patterns matching the morpheme.
foreach (Pattern pattern in matchingPatterns)
{
// Create the adtree element from the morpheme and its pattern.
IAdTree newAdTree = new AdTree(morpheme, pattern);
result.AdTrees.Add(newAdTree);
}
return(result);
}
}
private XElement CreateMorphemeElement(Morpheme morpheme)
{
var msaID = (int?)morpheme.Properties["ID"] ?? 0;
IMoMorphSynAnalysis msa;
if (msaID == 0 || !m_cache.ServiceLocator.GetInstance <IMoMorphSynAnalysisRepository>().TryGetObject(msaID, out msa))
{
return(null);
}
var inflTypeID = (int?)morpheme.Properties["InflTypeID"] ?? 0;
ILexEntryInflType inflType = null;
if (inflTypeID != 0 && !m_cache.ServiceLocator.GetInstance <ILexEntryInflTypeRepository>().TryGetObject(inflTypeID, out inflType))
{
return(null);
}
return(HCParser.CreateMorphemeElement(msa, inflType));
}
public HangerdResult <MorphemeDto> AddMorpheme(MorphemeDto morphemeDto)
{
return(TryOperate(() =>
{
using (var unitOfWork = DbContextFactory.CreateContext())
{
var morphemeRepository = unitOfWork.GetRepository <IMorphemeRepository>();
var morpheme = new Morpheme(
morphemeDto.Standard,
morphemeDto.Variant,
morphemeDto.Description,
(MorphemeType)morphemeDto.Type);
morphemeRepository.Add(morpheme);
unitOfWork.Commit();
return Mapper.Map <Morpheme, MorphemeDto>(morpheme);
}
}));
}
public List <Morpheme> Analyse(string str)
{
StringReader outputlines;
string line;
List <Morpheme> res = new List <Morpheme>();
Process p = new Process();
// Redirect the output stream of the child process.
p.StartInfo.FileName = @"C:\Program Files (x86)\MeCab\bin\Mecab.exe";
p.StartInfo.UseShellExecute = false;
p.StartInfo.RedirectStandardInput = true;
p.StartInfo.RedirectStandardOutput = true;
p.Start();
StreamWriter myStreamWriter = p.StandardInput;
myStreamWriter.WriteLine(str);
myStreamWriter.Close();
// Do not wait for the child process to exit before
// reading to the end of its redirected stream.
// p.WaitForExit();
// Read the output stream first and then wait.
string output = p.StandardOutput.ReadToEnd();
p.WaitForExit();
p.Close();
outputlines = new StringReader(output);
while ((line = outputlines.ReadLine()) != null)
{
if (line != "EOS")
{
String[] substrings = line.Split('\t', ',');
Morpheme wordanalytic = new Morpheme(substrings[0], substrings[1]);
res.Add(wordanalytic);
}
}
return(res);
}
public void RulingGrammarCharacter_E()
{
AdTree adTree = new AdTree(new Morpheme(myAttributesModel, ".", EnglishAttributes.U), EnglishPattern.MorphematicAdPosition("I-U-I", "", EnglishAttributes.U.NonLexeme.PunctuationMark, EnglishAttributes.I.Lexeme, EnglishAttributes.I.Lexeme))
{
Right = new AdTree(new Morpheme(myAttributesModel, "in", EnglishAttributes.E), EnglishPattern.MorphematicAdPosition("O-E-I", "", EnglishAttributes.E.Lexeme, EnglishAttributes.O.Lexeme, EnglishAttributes.I.Lexeme))
{
Right = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.O1_I)
{
Right = new AdTree(new Morpheme(myAttributesModel, "read", EnglishAttributes.I), EnglishPattern.Morpheme(EnglishAttributes.I.Lexeme)),
Left = new AdTree(new Morpheme(myAttributesModel, "I", EnglishAttributes.O), EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme))
},
Left = new AdTree(new Morpheme(myAttributesModel, "in", EnglishAttributes.E), EnglishPattern.EpsilonAdPosition("A-O", "", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme))
{
Right = new AdTree(new Morpheme(myAttributesModel, "room", EnglishAttributes.O), EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme)),
Left = new AdTree(new Morpheme(myAttributesModel, "the", EnglishAttributes.A), EnglishPattern.Morpheme(EnglishAttributes.A.Lexeme))
}
}
};
// Although there is E in between but the ruling grammar character is I.
Assert.AreEqual(GrammarCharacter.I, adTree.RulingGrammarCharacter);
}
/// <summary>
/// Returns the deep copy of the sub-adTree. (adTree will be the root of the returned adTree)
/// </summary>
/// <param name="adTree"></param>
/// <returns></returns>
public static IAdTree MakeDeepCopy(this IAdTree adTree)
{
var root = adTree;
// <original, copy>
Stack <Tuple <IAdTree, IAdTree> > stack = new Stack <Tuple <IAdTree, IAdTree> >();
var rootMorpheme = new Morpheme(root.Morpheme);
var rootPattern = new Pattern(root.Pattern);
IAdTree rootCopy = new AdTree(rootMorpheme, rootPattern);
stack.Push(Tuple.Create(root, rootCopy));
while (stack.Count > 0)
{
Tuple <IAdTree, IAdTree> aThis = stack.Pop();
if (aThis.Item1.Left != null)
{
var morpheme = new Morpheme(aThis.Item1.Left.Morpheme);
var pattern = new Pattern(aThis.Item1.Left.Pattern);
IAdTree leftCopy = new AdTree(morpheme, pattern);
aThis.Item2.Left = leftCopy;
stack.Push(Tuple.Create(aThis.Item1.Left, leftCopy));
}
if (aThis.Item1.Right != null)
{
var morpheme = new Morpheme(aThis.Item1.Right.Morpheme);
var pattern = new Pattern(aThis.Item1.Right.Pattern);
IAdTree rightCopy = new AdTree(morpheme, pattern);
aThis.Item2.Right = rightCopy;
stack.Push(Tuple.Create(aThis.Item1.Right, rightCopy));
}
}
return(rootCopy);
}
/// -----------------------------------------------------------------------------------
/// <summary>
/// An abstract method used to convert a morpheme.
/// Subclasses must override this method to do an appropriate conversion.
/// </summary>
/// -----------------------------------------------------------------------------------
internal virtual void Convert()
{
foreach (Morpheme m in s_gd.Morphemes)
{
if (m.MID == m_morphname)
{
m_morpheme = m;
break;
}
}
if (m_morpheme == null)
{
m_morpheme = new Morpheme(m_type, m_morphname);
s_gd.Morphemes.Add(m_morpheme);
}
m_dataLayerMorpheme.MIDREF = m_morpheme.MID;
if (m_underlyingForm != null)
{
string xml = "<ANAInfo underlyingForm=\'" + m_underlyingForm + "\' />";
m_morpheme.Other = new Other(xml);
}
if (m_category != null ||
m_decomposition != null)
{
string xml = "<ANAInfo";
if (m_category != null)
{
xml += " category=\'" + m_category + "\'";
}
if (m_decomposition != null)
{
xml += " decomposition=\'" + m_decomposition + "\'";
}
xml += " />";
m_dataLayerMorpheme.Other = new Other(xml);
}
}
public void TryGetTransferenceMorpheme_MonoTransference()
{
AdTree adTree = new AdTree(Morpheme.Epsilon(myAttributesModel), EnglishPattern.EpsilonAdPosition("A-O", "", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme))
{
Right = new AdTree(new Morpheme(myAttributesModel, "car", EnglishAttributes.O.Lexeme), EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme)),
// Mono-transference.
Left = new AdTree(new Morpheme(myAttributesModel, "", EnglishAttributes.A.Lexeme), EnglishPattern.MonoTransference("O>A", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme))
{
Right = new AdTree(new Morpheme(myAttributesModel, "race", EnglishAttributes.O.Lexeme), EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme)),
Left = null,
},
};
Assert.IsTrue(adTree.Left.Pattern.IsMonoTransference);
var result = adTree.Left.TryGetTransferenceMorpheme();
// Attributes shall be taken from the parent.
Assert.AreEqual(adTree.Left.Morpheme.Attributes, result.Attributes);
// Morph shall be taken from the child.
Assert.AreEqual(adTree.Left.Right.Morpheme.Morph, result.Morph);
}
/// <summary> Constructor.</summary>
/// <param name="tagSet">- the morpheme tag set
/// </param>
/// <param name="connection">- the morpheme connection rules
/// </param>
/// <param name="systemDic">- the system morpheme dictionary
/// </param>
/// <param name="userDic">- the user morpheme dictionary
/// </param>
/// <param name="numDic">- the number dictionary
/// </param>
/// <param name="simti">- the SIMple Trie Index
/// </param>
/// <param name="resEojeolList">- the list of eojeols to store the analysis result
/// </param>
public MorphemeChart(TagSet tagSet, Connection connection, Trie systemDic, Trie userDic, NumberDic numDic, Simti simti, LinkedList <Eojeol> resEojeolList)
{
chart = new Morpheme[MAX_MORPHEME_CHART];
for (int i = 0; i < MAX_MORPHEME_CHART; i++)
{
chart[i] = new Morpheme(this);
}
this.sp = new SegmentPosition();
this.tagSet = tagSet;
this.connection = connection;
this.exp = new Exp(this, tagSet);
this.systemDic = systemDic;
this.userDic = userDic;
this.numDic = numDic;
this.simti = simti;
this.resEojeols = resEojeolList;
resMorphemes = new List <String>();
resTags = new List <String>();
chiReplacementList = new LinkedList <String>();
engReplacementList = new LinkedList <String>();
}
/// <summary> It performs morphological anlysis on the morpheme chart from the specified index in the chart.</summary>
/// <param name="chartIndex">- the index of the chart to analyze
/// </param>
/// <param name="tagType">- the type of next morpheme
/// </param>
/// <returns> the number of analysis results
/// </returns>
private int analyze(int chartIndex, int tagType)
{
int from, to;
int i, j, x, y;
int mp;
char c;
int nc_idx;
TNODE node;
LinkedList <INFO> infoList = null;
INFO info = null;
int sidx = 1;
int uidx = 1;
int nidx = 1;
Position fromPos = null;
Position toPos = null;
Morpheme morph = chart[chartIndex];
from = morph.nextPosition;
fromPos = sp.getPosition(from);
switch (sp.getPosition(from).state)
{
default:
return(0);
/* dictionary search */
case SegmentPosition.SP_STATE_N:
i = 0;
bufString = "";
// searches all combinations of words segmented through the dictionaries
for (to = from; to != SegmentPosition.POSITION_START_KEY; to = sp.nextPosition(to))
{
toPos = sp.getPosition(to);
c = toPos.key;
if (sidx != 0)
{
sidx = systemDic.node_look(c, sidx);
}
if (uidx != 0)
{
uidx = userDic.node_look(c, uidx);
}
if (nidx != 0)
{
nidx = numDic.node_look(c, nidx);
}
toPos.sIndex = sidx;
toPos.uIndex = uidx;
toPos.nIndex = nidx;
bufString += c;
segmentPath[i++] = to;
}
nidx = 0;
for (; i > 0; i--)
{
to = segmentPath[i - 1];
toPos = sp.getPosition(to);
// system dictionary
if (toPos.sIndex != 0)
{
node = systemDic.get_node(toPos.sIndex);
if ((infoList = node.info_list) != null)
{
for (j = 0; j < infoList.Count; j++)
{
info = infoList.Get_Renamed(j);
nc_idx = addMorpheme(info.tag, info.phoneme, sp.nextPosition(to), 0);
chart[nc_idx].str = bufString.Substring(0, (i) - (0));
fromPos.morpheme[fromPos.morphCount++] = nc_idx;
}
}
}
// user dictionary
if (toPos.uIndex != 0)
{
node = userDic.get_node(toPos.uIndex);
if ((infoList = node.info_list) != null)
{
for (j = 0; j < infoList.Count; j++)
{
info = infoList.Get_Renamed(j);
nc_idx = addMorpheme(info.tag, info.phoneme, sp.nextPosition(to), 0);
chart[nc_idx].str = bufString.Substring(0, (i) - (0));
fromPos.morpheme[fromPos.morphCount++] = nc_idx;
}
}
}
// number dictionary
if (nidx == 0 && toPos.nIndex != 0)
{
if (numDic.isNum(toPos.nIndex))
{
nc_idx = addMorpheme(tagSet.numTag, TagSet.PHONEME_TYPE_ALL, sp.nextPosition(to), 0);
chart[nc_idx].str = bufString.Substring(0, (i) - (0));
fromPos.morpheme[fromPos.morphCount++] = nc_idx;
nidx = toPos.nIndex;
}
else
{
nidx = 0;
}
}
}
fromPos.state = SegmentPosition.SP_STATE_D;
/* chart expansion regarding various rules */
goto case SegmentPosition.SP_STATE_D;
case SegmentPosition.SP_STATE_D:
exp.prule(from, morph.str, bufString, sp);
sp.getPosition(from).state = SegmentPosition.SP_STATE_R;
/* recursive processing */
goto case SegmentPosition.SP_STATE_R;
case SegmentPosition.SP_STATE_R:
x = 0;
for (i = 0; i < fromPos.morphCount; i++)
{
mp = fromPos.morpheme[i];
// It prevents a recursive call for '습니다', which needs to be improved.
if (tagSet.checkTagType(tagType, chart[mp].tag) == false)
{
continue;
}
// It prevents some redundant processing
if (chart[mp].state == MORPHEME_STATE_INCOMPLETE)
{
y = analyze(mp, chart[mp].nextTagType);
x += y;
if (y != 0)
{
chart[mp].state = MORPHEME_STATE_SUCCESS;
}
else
{
chart[mp].state = MORPHEME_STATE_FAIL;
}
}
else
{
x += chart[mp].connectionCount;
}
}
if (x == 0)
{
if (tagType == TagSet.TAG_TYPE_ALL)
{
fromPos.state = SegmentPosition.SP_STATE_F;
}
return(0);
}
if (tagType == TagSet.TAG_TYPE_ALL)
{
fromPos.state = SegmentPosition.SP_STATE_M;
}
/* connecton rule */
goto case SegmentPosition.SP_STATE_M;
case SegmentPosition.SP_STATE_M:
for (i = 0; i < fromPos.morphCount; i++)
{
mp = fromPos.morpheme[i];
if (chart[mp].state == MORPHEME_STATE_SUCCESS && connection.checkConnection(tagSet, morph.tag, chart[mp].tag, morph.str.Length, chart[mp].str.Length, morph.nextTagType))
{
morph.connection[morph.connectionCount++] = mp;
}
}
break;
}
return(morph.connectionCount);
}
// 특정 단어들 분류해서 레벨 나누기 위함
public static int lv_count(string tex)
{
int lv = 0;
Morpheme mo = new Morpheme();
if (mo.Name.Contains("소풍"))
{
lv = 1;
}
if (mo.Name.Contains("여행"))
{
lv = 1;
}
if (mo.Name.Contains("데이트"))
{
lv = 1;
}
if (mo.Name.Contains("나들이"))
{
lv = 1;
}
if (mo.Name.Contains("피크닉"))
{
lv = 1;
}
if (mo.Name.Contains("야외활동"))
{
lv = 1;
}
if (mo.Name.Contains("date"))
{
lv = 1;
}
if (mo.Name.Contains("picnic"))
{
lv = 1;
}
if (mo.Name.Contains("레저"))
{
lv = 2;
}
if (mo.Name.Contains("탁구"))
{
lv = 2;
}
if (mo.Name.Contains("축구"))
{
lv = 2;
}
if (mo.Name.Contains("농구"))
{
lv = 2;
}
if (mo.Name.Contains("야구"))
{
lv = 2;
}
if (mo.Name.Contains("헬스"))
{
lv = 2;
}
if (mo.Name.Contains("달리기"))
{
lv = 2;
}
if (mo.Name.Contains("조깅"))
{
lv = 2;
}
return(lv);
}
// 카드 데이터 불러오기
public void CardLoad()
{
cards.Clear();
morphemes.Clear();
spacing = false;
CardCheck();
FileInfo fi = new FileInfo("cardData" + slot + ".data");
if (!fi.Exists)
{
FileStream fs = File.Create("cardData" + slot + ".data");
fs.Close();
StreamWriter sw = new StreamWriter("cardData" + slot + ".data");
sw.WriteLine("--------");
sw.Close();
}
else
{
StreamReader sr = new StreamReader("cardData" + slot + ".data");
string s;
int g = 0, n = 0;
// 카드와 조합식 저장
while ((s = sr.ReadLine()) != "--------")
{
// 숫자면 해당 번호에 (줄바꿈) 이름 저장
if (char.IsDigit(s[0]))
{
g = Convert.ToInt32(s.Split(' ')[0]);
n = Convert.ToInt32(s.Split(' ')[1]);
s = sr.ReadLine();
cards[g - 1][n - 1].name = s;
}
// "면 지금 번호에 조합식 저장
else if (s[0] == '"')
{
CardCombine c = new CardCombine();
c.style = s.Split('"')[1];
if (!spacing && c.style[0] == ' ')
{
spacing = true;
}
string p = s.Split('"')[2];
c.position = p.Split(' ')[0] == "f" ? true : false;
c.combinedWith = Convert.ToInt32(p.Split(' ')[1]);
c.bias = Convert.ToInt32(p.Split(' ')[2]);
c.position = p.Split(' ')[3] == "e" ? true : false;
c.root = p.Split('#')[1];
cards[g - 1][n - 1].combines.Add(c);
}
// §면 다음 번호로
else if (s[0] == '§')
{
continue;
}
}
// 형태소 저장
while ((s = sr.ReadLine()) != null)
{
// §면 다음 번호로
if (s[0] == '§')
{
continue;
}
// "면 지금 형태소에 조합 저장
else if (s[0] == '"')
{
string p = s.Split('"')[1];
string q = s.Split('"')[2];
int b = Convert.ToInt32(q.Split(' ')[1]);
MorphemeConnect mc = new MorphemeConnect();
mc.bias = b;
string[] k = sr.ReadLine().Split(' ');
foreach (string kk in k)
{
if (kk != "")
{
mc.connectWith.Add(Convert.ToInt32(kk));
}
}
if (q.Split(' ')[0] == "f")
{
morphemes[morphemes.Count - 1].fronts.Add(p, mc);
}
else
{
morphemes[morphemes.Count - 1].backs.Add(p, mc);
}
}
// 아니면 새로운 형태소로 저장
else
{
string name = s;
string c = sr.ReadLine();
int group = Convert.ToInt32(c.Split(' ')[0]);
int num = Convert.ToInt32(c.Split(' ')[1]);
Morpheme mm = new Morpheme(name, group, num);
morphemes.Add(mm);
}
}
sr.Close();
}
}
internal bool HasTransition(Morpheme prev, Morpheme next)
{
return(_graph.ContainsTransition(prev.SequenceId, next.SequenceId));
}
internal IEnumerable <string> GetMorphemesWithEmptyTransitions(Morpheme prev)
{
return(_graph.GetEmptyTransitions(prev.SequenceId).Select(t => t.Target));
}
internal bool IsTerminal(Morpheme morpheme)
{
return(_graph.IsTerminal(morpheme.SequenceId));
}
public AdTree(Morpheme morpheme, Pattern pattern)
{
Morpheme = morpheme ?? throw new ArgumentNullException(nameof(morpheme));
Pattern = pattern ?? throw new ArgumentNullException(nameof(pattern));
}
public Morpheme[] Analyse(string str)
{
LinkedList <string> resultpos = new LinkedList <string>();
LinkedList <string> resultsurface = new LinkedList <string>();
//解析する文字列はURLエンコードする
String postString = String.Format("appid=dj00aiZpPW4zVzlxV2lWUXdXWCZzPWNvbnN1bWVyc2VjcmV0Jng9OTY-&sentence=" + str);
//UTF8でバイト配列にエンコードする
byte[] postData = Encoding.UTF8.GetBytes(postString);
//Webリクエストを生成する
WebRequest webReq = WebRequest.Create("http://jlp.yahooapis.jp/MAService/V1/parse");
webReq.Method = "POST";
webReq.ContentType = "application/x-www-form-urlencoded";
webReq.ContentLength = postData.Length;
//Postするデータを出力する
using (Stream writer = webReq.GetRequestStream())
{
writer.Write(postData, 0, postData.Length);
}
//結果をうけとってDOMオブジェクトにする
WebResponse webRes = webReq.GetResponse();
XmlDocument resultXml = new XmlDocument();
using (StreamReader reader = new StreamReader(webRes.GetResponseStream()))
{
resultXml.Load(reader);
}
//結果XML中の[word]タグのリストを取得する
XmlNodeList wordList = resultXml.GetElementsByTagName("word");
//[word]以下のノードに含まれる内容をmorphemeに記録
foreach (XmlNode wordNode in wordList)
{
foreach (XmlNode resultNode in wordNode.ChildNodes)
{
if (resultNode.Name == "pos")
{
resultpos.AddLast(resultNode.InnerText);
}
else if (resultNode.Name == "surface")
{
resultsurface.AddLast(resultNode.InnerText);
}
}
}
Morpheme[] result = new Morpheme[resultsurface.Count];
int length = resultsurface.Count;
for (int i = 0; i < length; i++)
{
Morpheme mor = new Morpheme(resultsurface.First.Value, resultpos.First.Value);
result[i] = mor;
resultpos.RemoveFirst();
resultsurface.RemoveFirst();
}
return(result);
}
/// <summary>
/// Checks if the morpheme matches the rule.
/// </summary>
/// <param name="morpheme"></param>
/// <returns></returns>
public bool Evaluate(Morpheme morpheme)
{
bool result = MorphRule.Evaluate(morpheme.Morph) && AttributesRule.Evaluate(morpheme.Attributes);
return(result);
}
private static bool CanAttachViaRule(this IAdTree adTree, IAdTree adTreeToAttach, AttachingPosition attachPosition, IAttributesModel attributesModel)
{
// Get rule to evalute.
MorphemeRule rule = attachPosition == AttachingPosition.ChildOnLeft ? adTree.Pattern.LeftRule : adTree.Pattern.RightRule;
// If the rule allows to attach and the order of attaching is correct.
if (!rule.Equals(MorphemeRule.Nothing) && IsAttachingOrderCorrect(adTree, attachPosition))
{
// If the adtree where to attach is morphematic then it is not possible to attach the second child until the morpheme is set.
if (adTree.Pattern.IsMorphematicAdPosition() && (adTree.Right != null || adTree.Left != null) && string.IsNullOrEmpty(adTree.Morpheme.Morph))
{
return(false);
}
// Note: from the tree to attach we need to get the adtree representing the morpheme which shall be evaluated.
IAdTree morphemeAdTree = null;
// If the adTreeToAttach is a morpheme or a transference.
if (adTreeToAttach.Pattern.IsLikeMorpheme)
{
morphemeAdTree = adTreeToAttach;
}
// It is an adposition.
else if (adTreeToAttach.Pattern.IsEpsilonAdPosition() ||
adTreeToAttach.Pattern.IsMorphematicAdPosition())
{
// If a substitution (because adTreeToAttach is adposition) can be attached.
if (rule.SubstitutionRule.Evaluate(adTreeToAttach.Morpheme.GrammarCharacter))
{
// If it shall be attached to the right and
// the valency position is specified then check correctness with regard to presence of previously filled valencies.
if (attachPosition == AttachingPosition.ChildOnRight)
{
IAdTree valencyElement = adTree.GetSequenceToRoot()
.TakeUntil(x => x.IsOnRight)
.FirstOrDefault(x => x.Pattern.ValencyPosition > 0);
if (valencyElement != null)
{
IAdTree previousValencyElement = adTreeToAttach.GetRightSequence()
.FirstOrDefault(x => x.Pattern.ValencyPosition > 0);
if (previousValencyElement == null && valencyElement.Pattern.ValencyPosition > 1 ||
previousValencyElement != null && valencyElement.Pattern.ValencyPosition != previousValencyElement.Pattern.ValencyPosition + 1)
{
return(false);
}
}
}
// Try to get the driving morpheme.
morphemeAdTree = adTreeToAttach.RightChildren.FirstOrDefault(x => x.Pattern.IsLikeMorpheme);
// If the governor is not attached yet then check only rules.
if (morphemeAdTree == null)
{
IEnumerable <IAdTree> rightSequence = new IAdTree[] { adTreeToAttach }.Concat(adTreeToAttach.RightChildren);
if (rightSequence.Any(x => !x.Pattern.RightRule.IsSubruleOf(rule) && !rule.IsSubruleOf(x.Pattern.RightRule)))
{
return(false);
}
return(true);
}
}
}
if (morphemeAdTree != null)
{
// If it shall be attached to the right the morpheme is a verb then check the valency.
if (attachPosition == AttachingPosition.ChildOnRight && attributesModel.IsVerb(morphemeAdTree.Morpheme.Attributes))
{
int valency = attributesModel.GetNumberOfValencies(morphemeAdTree.Morpheme.Attributes);
if (valency > -1)
{
// Get already filled valency positions.
int[] valencyPositions = morphemeAdTree.GetSequenceToRoot()
.TakeWhile(x => x != adTree) // This is to not make an assuption if it is already attached or not.
.TakeUntil(x => x.IsOnRight)
.Concat(adTree.GetSequenceToRoot().TakeUntil(x => x.IsOnRight))
.Where(x => x.Pattern.ValencyPosition > 0)
.Select(x => x.Pattern.ValencyPosition)
.ToArray();
// If such valency is already filled.
if (valencyPositions.Length > valency)
{
return(false);
}
for (int i = 0; i < valencyPositions.Length; ++i)
{
if (valencyPositions[i] != i + 1)
{
return(false);
}
}
}
}
Morpheme morphemeToEvaluate = morphemeAdTree.TryGetTransferenceMorpheme();
if (string.IsNullOrEmpty(morphemeToEvaluate?.Morph) && morphemeAdTree.Pattern.IsPairTransference)
{
// The morpheme with the morph is not attached yet so check only attributes.
if (rule.AttributesRule.Evaluate(morphemeAdTree.Morpheme.Attributes))
{
return(true);
}
else
{
return(false);
}
}
// Check if the morpheme passes the rule.
bool result = rule.Evaluate(morphemeToEvaluate);
return(result);
}
}
return(false);
}
/// <summary> It generates the final mophological analysis result from the morpheme chart.</summary>
/// <param name="chartIndex">- the start index of the chart to generate final result
/// </param>
private void printChart(int chartIndex)
{
int i;
Morpheme morph = chart[chartIndex];
int engCnt = 0;
int chiCnt = 0;
if (chartIndex == 0)
{
for (i = 0; i < morph.connectionCount; i++)
{
resMorphemes.Clear();
resTags.Clear();
printChart(morph.connection[i]);
}
}
else
{
System.String morphStr = Code.toString(morph.str.ToCharArray());
int idx = 0;
engCnt = 0;
chiCnt = 0;
while (idx != -1)
{
if ((idx = morphStr.IndexOf(ENG_REPLACE)) != -1)
{
engCnt++;
morphStr = morphStr.ReplaceFirst(ENG_REPLACE, engReplacementList.Get_Renamed(engReplaceIndex++));
}
else if ((idx = morphStr.IndexOf(CHI_REPLACE)) != -1)
{
chiCnt++;
morphStr = morphStr.ReplaceFirst(CHI_REPLACE, chiReplacementList.Get_Renamed(chiReplaceIndex++));
}
}
resMorphemes.Add(morphStr);
resTags.Add(tagSet.getTagName(morph.tag));
for (i = 0; i < morph.connectionCount && printResultCnt < MAX_CANDIDATE_NUM; i++)
{
if (morph.connection[i] == 0)
{
System.String[] mArray = resMorphemes.ToArray();
System.String[] tArray = resTags.ToArray();
resEojeols.AddLast(new Eojeol(mArray, tArray));
printResultCnt++;
}
else
{
printChart(morph.connection[i]);
}
}
resMorphemes.RemoveAt(resMorphemes.Count - 1);
resTags.RemoveAt(resTags.Count - 1);
if (engCnt > 0)
{
engReplaceIndex -= engCnt;
}
if (chiCnt > 0)
{
chiReplaceIndex -= chiCnt;
}
}
}
/// <summary> Constructor.</summary>
/// <param name="tagSet">- the morpheme tag set
/// </param>
/// <param name="connection">- the morpheme connection rules
/// </param>
/// <param name="systemDic">- the system morpheme dictionary
/// </param>
/// <param name="userDic">- the user morpheme dictionary
/// </param>
/// <param name="numDic">- the number dictionary
/// </param>
/// <param name="simti">- the SIMple Trie Index
/// </param>
/// <param name="resEojeolList">- the list of eojeols to store the analysis result
/// </param>
public MorphemeChart(TagSet tagSet, Connection connection, Trie systemDic, Trie userDic, NumberDic numDic, Simti simti, LinkedList<Eojeol> resEojeolList)
{
chart = new Morpheme[MAX_MORPHEME_CHART];
for (int i = 0; i < MAX_MORPHEME_CHART; i++)
{
chart[i] = new Morpheme(this);
}
this.sp = new SegmentPosition();
this.tagSet = tagSet;
this.connection = connection;
this.exp = new Exp(this, tagSet);
this.systemDic = systemDic;
this.userDic = userDic;
this.numDic = numDic;
this.simti = simti;
this.resEojeols = resEojeolList;
resMorphemes = new List<String>();
resTags = new List<String>();
chiReplacementList = new LinkedList<String>();
engReplacementList = new LinkedList<String>();
}
