/// <summary>
/// Trace meronyms.
/// </summary>
/// <param name="pbase"></param>
/// <param name="fpos"></param>
/// <param name="depth"></param>
private void TraceInherit(PointerType pbase, PartOfSpeech fpos, int depth)
{
for (int i = 0; i < ptrs.Length; i++)
{
Pointer pt = ptrs[i];
if (pt.ptp.Ident == HYPERPTR && (pt.sce == 0 || pt.sce == whichword))
{
Spaces("TRACEI", depth);
SynonymSet cursyn = new SynonymSet(pt.off, pt.pos, this, netData);
search.WordsFrom(cursyn);
cursyn.Str("=> ", "\n", 1, 0, 0, 1);
// TDMS 6 Oct 2005 - build hierarchical results
// TODO: verify this
if (senses == null)
{
senses = new List <SynonymSet>();
}
cursyn.thisptr = pt; // TDMS 17 Nov 2005 - add this pointer type
// TODO: This is adding senses incorrectly
senses.Add(cursyn);
cursyn.TracePtrs(pbase, PartOfSpeech.Of("noun"), depth);
cursyn.TracePtrs(pbase + 1, PartOfSpeech.Of("noun"), depth);
cursyn.TracePtrs(pbase + 2, PartOfSpeech.Of("noun"), depth);
if (depth > 0)
{
depth = Depthcheck(depth);
cursyn.TraceInherit(pbase, cursyn.pos, depth + 1);
}
}
}
search.Trunc();
}
internal void Seealso()
{
/* Find all SEEALSO pointers from the searchword and print the
* word or synset pointed to. */
string prefix; // = " Also See-> ";
//WN3.0 added updated wording for verb see also
if (pos.Key == "verb")
{
prefix = " Phrasal Verb-> ";
}
else
{
prefix = " Also See-> ";
}
for (int i = 0; i < ptrs.Length; i++)
{
Pointer p = ptrs[i];
if (p.ptp.Ident == SEEALSOPTR &&
(p.sce == 0 || (p.sce == whichword)))
{
SynonymSet cursyn = new SynonymSet(p.off, p.pos, "", this, netData);
bool svwnsnsflag = WordNetOption.Opt("-s").flag;
WordNetOption.Opt("-s").flag = true;
cursyn.Str(prefix, "", 0, (p.dst == 0) ? 0 : p.dst, 0, 0);
prefix = "; ";
}
}
}
/// <summary>
/// Trace nominalizations.
/// </summary>
/// <param name="ptp"></param>
internal void Tracenomins(PointerType ptp) //,PartOfSpeech fpos)
{
for (int i = 0; i < ptrs.Length; i++)
{
Pointer pt = ptrs[i];
// TDMS 26/8/05 changed DERIVATION to NOMINALIZATIONS - verify this
if (pt.ptp.Ident == NOMINALIZATIONS && (pt.sce == 0 || pt.sce == whichword))
{
if (!search.prflag)
{
Strsns(sense + 1);
search.prflag = true;
}
Spaces("TRACEP", 0);
SynonymSet cursyn = new SynonymSet(pt.off, pt.pos, this, netData);
search.WordsFrom(cursyn);
cursyn.Str("RELATED TO-> ", "\n", 0, 0, 0, 0);
// TDMS 6 Oct 2005 - build hierarchical results
// TODO: verify this
if (senses == null)
{
senses = new List <SynonymSet>();
}
cursyn.thisptr = pt; // TDMS 17 Nov 2005 - add this pointer type
senses.Add(cursyn);
cursyn.TracePtrs(ptp, cursyn.pos, 0);
}
}
}
private string[] LookupSynonyms(Index index)
{
// OVERVIEW: For each sense, grab the synset associated with our index.
// Then, add the lexemes in the synset to a list.
ArrayList synonyms = new ArrayList(10);
// for each sense...
for (int s = 0; s < index.offs.Length; s++)
{
// read in the word and its pointers
SynonymSet synset = new SynonymSet(index.offs[s], index.pos, index.wd, null, s, netData);
// build a string out of the words
for (int i = 0; i < synset.words.Length; i++)
{
string word = synset.words[i].word.Replace("_", " ");
// if the word is capitalized, that means it's a proper noun. We don't want those.
if (word[0] <= 'Z')
{
continue;
}
// add it to the list if it's a different word
if (string.Compare(word, index.wd, true) != 0)
{
synonyms.Add(word);
}
}
}
return((string[])synonyms.ToArray(typeof(string)));
}
public bool HasHoloMero(PointerType p, Search search)
{
PointerType pbase;
if (p.Mnemonic == "HMERONYM")
{
pbase = PointerType.Of("HASMEMBERPTR");
}
else
{
pbase = PointerType.Of("ISMEMBERPTR");
}
if (offs != null)
{
for (int i = 0; i < offs.Length; i++)
{
SynonymSet s = new SynonymSet(offs[i], PartOfSpeech.Of("noun"), "", search, 0, netData);
if (s.Has(pbase) || s.Has(pbase + 1) || s.Has(pbase + 2))
{
return(true);
}
}
}
return(false);
}
internal void StrAnt(PartOfSpeech pos, int wdnum, string head, string tail)
{
int i, j, wdoff;
/* Go through all the pointers looking for anotnyms from the word
* indicated by wdnum. When found, print all the antonym's
* antonym pointers which point back to wdnum. */
for (i = 0; i < ptrs.Length; i++)
{
Pointer pt = ptrs[i];
if (pt.ptp.Ident == ANTPTR && pt.sce == wdnum)
{
SynonymSet psyn = new SynonymSet(pt.off, pos, this, netData);
for (j = 0; j < psyn.ptrs.Length; j++)
{
Pointer ppt = psyn.ptrs[j];
if (ppt.ptp.Ident == ANTPTR &&
ppt.dst == wdnum &&
ppt.off == hereiam)
{
wdoff = ppt.sce > 0 ? ppt.sce - 1 : 0;
search.buf += head;
/* Construct buffer containing formatted antonym,
* then add it onto end of return buffer */
search.buf += Deadjify(psyn.words[wdoff].word);
/* Print additional lexicographer information and
* WordNet sense number as indicated by flags */
isDirty = true; // TDMS 19 July 2006 - attempt to tie the logic which
// populates buf to the logic that defines whether the
// synset is populated with relevant information
if (search.prlexid && psyn.words[wdoff].uniq != 0)
{
search.buf += psyn.words[wdoff].uniq;
}
int s = Getsearchsense(wdoff + 1);
psyn.words[wdoff].wnsns = s;
if (WordNetOption.Opt("-s").flag)
{
search.buf += "#" + s;
isDirty = true; // TDMS 19 July 2006 - attempt to tie the logic which
// populates buf to the logic that defines whether the
// synset is populated with relevant information
}
search.buf += tail;
}
}
}
}
}
/// <summary>
/// Trace coordinate terms.
/// </summary>
/// <param name="ptp"></param>
/// <param name="fpos"></param>
/// <param name="depth"></param>
internal void TraceCoords(PointerType ptp, PartOfSpeech fpos, int depth)
{
for (int i = 0; i < ptrs.Length; i++)
{
Pointer pt = ptrs[i];
// WN2.1 if statement change - TDMS
if ((pt.ptp.Ident == HYPERPTR || pt.ptp.Ident == INSTANCE) &&
((pt.sce == 0) ||
(pt.sce == whichword)))
{
if (!search.prflag)
{
Strsns(sense + 1);
search.prflag = true;
}
Spaces("TRACEC", depth);
SynonymSet cursyn = new SynonymSet(pt.off, pt.pos, this, netData);
search.WordsFrom(cursyn);
cursyn.Str("-> ", "\n", 1, 0, 0, 1);
cursyn.TracePtrs(ptp, cursyn.pos, depth);
// TDMS 6 Oct 2005 - build hierarchical results
if (senses == null)
{
senses = new List <SynonymSet>();
}
cursyn.thisptr = pt; // TDMS 17 Nov 2005 - add this pointer type
senses.Add(cursyn);
if (depth > 0)
{
depth = Depthcheck(depth);
cursyn.TraceCoords(ptp, cursyn.pos, depth + 1);
// TDMS 6 Oct 2005 - build hierarchical results
// TODO: verify this
if (senses == null)
{
senses = new List <SynonymSet>();
}
cursyn.thisptr = pt; // TDMS 17 Nov 2005 - add this pointer type
senses.Add(cursyn);
}
}
}
}
/// <summary>
/// Trace adjective antonyms.
/// </summary>
internal void TraceAdjAnt()
{
SynonymSet newsynptr;
int i, j;
AdjSynSetType anttype = AdjSynSetType.DirectAnt;
SynonymSet simptr, antptr;
string similar = " => ";
/* This search is only applicable for ADJ synsets which have
* either direct or indirect antonyms (not valid for pertainyms). */
if (sstype == AdjSynSetType.DirectAnt || sstype == AdjSynSetType.IndirectAnt)
{
Strsns(sense + 1);
search.buf += "\n";
/* if indirect, get cluster head */
if (sstype == AdjSynSetType.IndirectAnt)
{
anttype = AdjSynSetType.IndirectAnt;
i = 0;
while (ptrs[i].ptp.Ident != SIMPTR)
{
i++;
}
newsynptr = new SynonymSet(ptrs[i].off, PartOfSpeech.Of("adj"), this, netData);
}
else
{
newsynptr = this;
}
/* find antonyms - if direct, make sure that the antonym ptr we're looking at is from this word */
for (i = 0; i < newsynptr.ptrs.Length; i++)
{
if (newsynptr.ptrs[i].ptp.Ident == ANTPTR && // TDMS 11 JUL 2006 // mnemonic=="ANTPTR" &&
((anttype == AdjSynSetType.DirectAnt &&
newsynptr.ptrs[i].sce == newsynptr.whichword) ||
anttype == AdjSynSetType.IndirectAnt))
{
/* read the antonym's synset and print it. if a direct antonym, print it's satellites. */
antptr = new SynonymSet(newsynptr.ptrs[i].off, PartOfSpeech.Of("adj"), this, netData);
search.WordsFrom(antptr);
// TDMS 6 Oct 2005 - build hierarchical results
if (senses == null)
{
senses = new List <SynonymSet>();
}
//TODO: check the ptrs reference
antptr.thisptr = newsynptr.ptrs[i]; // TDMS 17 Nov 2005 - add this pointer type
senses.Add(antptr);
if (anttype == AdjSynSetType.DirectAnt)
{
antptr.Str("", "\n", 1, 0, 1, 1);
for (j = 0; j < antptr.ptrs.Length; j++)
{
if (antptr.ptrs[j].ptp.Ident == SIMPTR) // TDMS 11 JUL 2006 - changed to INT //.mnemonic=="SIMPTR")
{
simptr = new SynonymSet(antptr.ptrs[j].off, PartOfSpeech.Of("adj"), this, netData);
search.WordsFrom(simptr);
simptr.Str(similar, "\n", 1, 0, 0, 1);
// TDMS 6 Oct 2005 - build hierarchical results
if (antptr.senses == null)
{
antptr.senses = new List <SynonymSet>();
}
antptr.senses.Add(simptr);
}
}
}
else
{
antptr.StrAnt("\n", anttype, 1);
}
}
}
}
}
/// <summary>
/// Trace classification.
/// </summary>
/// <param name="ptp"></param>
/// <param name="stp"></param>
internal void Traceclassif(PointerType ptp, SearchType stp) //,PartOfSpeech fpos)
{
int j;
int idx = 0;
string head = "";
int LASTTYPE = PointerType.Of("CLASS").Ident;
int OVERVIEW = LASTTYPE + 9;
int MAXSEARCH = OVERVIEW;
int CLASSIF_START = MAXSEARCH + 1;
int CLASSIF_CATEGORY = CLASSIF_START; /* ;c */
int CLASSIF_USAGE = CLASSIF_START + 1; /* ;u */
int CLASSIF_REGIONAL = CLASSIF_START + 2; /* ;r */
int CLASSIF_END = CLASSIF_REGIONAL;
int CLASS_START = CLASSIF_END + 1;
int CLASS_CATEGORY = CLASS_START; /* -c */
int CLASS_USAGE = CLASS_START + 1; /* -u */
int CLASS_REGIONAL = CLASS_START + 2; /* -r */
int CLASS_END = CLASS_REGIONAL;
ArrayList prlist = new ArrayList();
for (int i = 0; i < ptrs.Length; i++)
{
Pointer pt = ptrs[i];
if (((pt.ptp.Ident >= CLASSIF_START) &&
(pt.ptp.Ident <= CLASSIF_END) && stp.ptp.Ident == PointerType.Of("CLASSIFICATION").Ident) ||
((pt.ptp.Ident >= CLASS_START) &&
(pt.ptp.Ident <= CLASS_END) && stp.ptp.Ident == PointerType.Of("CLASS").Ident))
{
if (!search.prflag)
{
Strsns(sense + 1);
search.prflag = true;
}
SynonymSet cursyn = new SynonymSet(pt.off, pt.pos, this, netData);
// TDMS 6 Oct 2005 - build hierarchical results
// TODO: verify this
if (senses == null)
{
senses = new List <SynonymSet>();
}
cursyn.thisptr = pt; // TDMS 17 Nov 2005 - add this pointer type
senses.Add(cursyn);
for (j = 0; j < idx; j++)
{
if (pt.off == Convert.ToInt16(prlist[j]))
{
break;
}
}
if (j == idx)
{
prlist.Add(pt.off);
Spaces("TRACEP", 0);
if (pt.ptp.Ident == CLASSIF_CATEGORY)
{
head = "TOPIC->("; // WN2.1 - TDMS
}
else if (pt.ptp.Ident == CLASSIF_USAGE)
{
head = "USAGE->(";
}
else if (pt.ptp.Ident == CLASSIF_REGIONAL)
{
head = "REGION->(";
}
else if (pt.ptp.Ident == CLASS_CATEGORY)
{
head = "TOPIC_TERM->("; // WN2.1 - TDMS
}
else if (pt.ptp.Ident == CLASS_USAGE)
{
head = "USAGE_TERM->(";
}
else if (pt.ptp.Ident == CLASS_REGIONAL)
{
head = "REGION_TERM->(";
}
head += pt.pos.Key;
head += ") ";
cursyn.Str(head, "\n", 0, 0, 0, 0);
}
}
}
}
/// <summary>
/// Traces pointer hierarchy.
/// </summary>
/// <param name="stp"></param>
/// <param name="fpos"></param>
/// <param name="depth"></param>
internal void TracePtrs(SearchType stp, PartOfSpeech fpos, int depth)
{
int i;
SynonymSet cursyn;
PointerType ptp = stp.ptp;
string prefix;
int realptr; // WN2.1
for (i = 0; i < ptrs.Length; i++)
{
Pointer pt = ptrs[i];
// following if statement is WN2.1 - TDMS
if ((ptp.Ident == HYPERPTR && (pt.ptp.Ident == HYPERPTR ||
pt.ptp.Ident == INSTANCE)) ||
(ptp.Ident == HYPOPTR && (pt.ptp.Ident == HYPOPTR ||
pt.ptp.Ident == INSTANCES)) ||
((pt.ptp == ptp) &&
((pt.sce == 0) ||
(pt.sce == whichword))))
{
realptr = pt.ptp.Ident; /* WN2.1 deal with INSTANCE */
if (!search.prflag) // print sense number and synset
{
Strsns(sense + 1);
}
search.prflag = true;
Spaces("TRACEP", depth + (stp.rec ? 2 : 0));
switch (pt.ptp.Ident) // TDMS 11 JUL 2006 - changed switch to ident
{
case PERTPTR:
if (fpos.Key == "adv") // TDMS "adverb")
{
prefix = "Derived from ";
}
else
{
prefix = "Pertains to ";
}
prefix += pt.pos.Key + " ";
break;
case ANTPTR: // TDMS 26/8/05
if (fpos.Key == "adj") //TODO: which adjective will fall into the below?
{
prefix = "Antonym of ";
}
else
{
prefix = "";
}
break;
case PPLPTR:
prefix = "Participle of verb";
break;
case INSTANCE:
prefix = "INSTANCE OF=> ";
break;
case INSTANCES:
prefix = "HAS INSTANCE=> ";
break;
case HASMEMBERPTR:
prefix = " HAS MEMBER: ";
break;
case HASSTUFFPTR:
prefix = " HAS SUBSTANCE: ";
break;
case HASPARTPTR:
prefix = " HAS PART: ";
break;
case ISMEMBERPTR:
prefix = " MEMBER OF: ";
break;
case ISSTUFFPTR: // TDMS 26/8/05
prefix = " SUBSTANCE OF: ";
break;
case ISPARTPTR: // TDMS 26/8/05
prefix = " PART OF: ";
break;
default:
prefix = "=> ";
break;
}
/* Read synset pointed to */
cursyn = new SynonymSet(pt.off, pt.pos, this, netData);
search.WordsFrom(cursyn);
// TDMS 6 Oct 2005 - build hierarchical results
if (senses == null)
{
senses = new List <SynonymSet>();
}
cursyn.thisptr = pt; // TDMS 17 Nov 2005 - add this pointer type
senses.Add(cursyn);
/* For Pertainyms and Participles pointing to a specific
* sense, indicate the sense then retrieve the synset
* pointed to and other info as determined by type.
* Otherwise, just print the synset pointed to. */
if ((ptp.Ident == PERTPTR || ptp.Ident == PPLPTR) &&
pt.dst != 0)
{
string tbuf = " (Sense " + cursyn.Getsearchsense(pt.dst) + ")";
cursyn.Str(prefix, tbuf, 0, pt.dst, 0, 1);
if (ptp.Ident == PPLPTR) // adj pointing to verb
{
cursyn.Str(" =>", "\n", 1, 0, 1, 1);
cursyn.TracePtrs(PointerType.Of("HYPERPTR"), cursyn.pos, 0);
}
else if (fpos.Key == "adv") // adverb pointing to adjective
{
cursyn.Str(" =>", "\n", 0, 0, (pos.Clss == "SATELLITE") ? 0 : 1, 1);
}
else // adjective pointing to noun
{
cursyn.Str(" =>", "\n", 1, 0, 1, 1);
cursyn.TracePtrs(PointerType.Of("HYPERPTR"), pos, 0);
}
}
else
{
cursyn.Str(prefix, "\n", 1, 0, 1, 1);
}
/* For HOLONYMS and MERONYMS, keep track of last one printed in buffer so results can be truncated later. */
if (ptp.Ident >= PointerType.Of("ISMEMBERPTR").Ident&&
ptp.Ident <= PointerType.Of("HASPARTPTR").Ident)
{
search.Mark();
}
if (depth > 0)
{
depth = cursyn.Depthcheck(depth);
cursyn.TracePtrs(ptp, cursyn.pos, depth + 1);
}
}
}
}
public SynonymSet(int off, PartOfSpeech p, SynonymSet fr, WordNetData netdata)
: this(off, p, "", fr, netdata)
{
}
public SynonymSet(int off, PartOfSpeech p, string wd, SynonymSet fr, WordNetData netdata)
: this(off, p, wd, fr.search, fr.sense, netdata)
{
}