Serialized Form


Package edu.stanford.nlp.graph

Class edu.stanford.nlp.graph.DirectedMultiGraph extends Object implements Serializable

serialVersionUID: 609823567298345145L

Serialized Fields

outgoingEdges

Map<K,V> outgoingEdges

incomingEdges

Map<K,V> incomingEdges

Package edu.stanford.nlp.international.arabic

Class edu.stanford.nlp.international.arabic.ArabicMorphoFeatureSpecification extends MorphoFeatureSpecification implements Serializable

serialVersionUID: 4448045447200922076L

Class edu.stanford.nlp.international.arabic.ArabicMorphoFeatureSpecification.ArabicMorphoFeatures extends MorphoFeatures implements Serializable

serialVersionUID: -4611776415583633186L


Package edu.stanford.nlp.international.french

Class edu.stanford.nlp.international.french.FrenchMorphoFeatureSpecification extends MorphoFeatureSpecification implements Serializable

serialVersionUID: -58379347760106784L


Package edu.stanford.nlp.international.morph

Class edu.stanford.nlp.international.morph.MorphoFeatures extends Object implements Serializable

serialVersionUID: -3893316324305154940L

Serialized Fields

fSpec

Map<K,V> fSpec

altTag

String altTag

Class edu.stanford.nlp.international.morph.MorphoFeatureSpecification extends Object implements Serializable

serialVersionUID: -5720683653931585664L

Serialized Fields

activeFeatures

Set<E> activeFeatures

Package edu.stanford.nlp.io

Class edu.stanford.nlp.io.RuntimeIOException extends RuntimeException implements Serializable

serialVersionUID: -8572218999165094626L


Package edu.stanford.nlp.ling

Class edu.stanford.nlp.ling.CategoryWordTag extends StringLabel implements Serializable

serialVersionUID: -745085381666943254L

Serialized Fields

word

String word

tag

String tag

Class edu.stanford.nlp.ling.CoreLabel extends ArrayCoreMap implements Serializable

serialVersionUID: 2L

Class edu.stanford.nlp.ling.CyclicCoreLabel extends CoreLabel implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.ling.IndexedWord extends CoreLabel implements Serializable

serialVersionUID: 3739633991145239829L

Class edu.stanford.nlp.ling.LabeledWord extends Word implements Serializable

serialVersionUID: -7252006452127051085L

Serialized Fields

tag

Label tag

Class edu.stanford.nlp.ling.StringLabel extends ValueLabel implements Serializable

serialVersionUID: -4153619273767524247L

Serialized Fields

str

String str

beginPosition

int beginPosition
Start position of the word in the original input string


endPosition

int endPosition
End position of the word in the original input string

Class edu.stanford.nlp.ling.TaggedWord extends Word implements Serializable

serialVersionUID: -7252006452127051085L

Serialized Fields

tag

String tag

Class edu.stanford.nlp.ling.ValueLabel extends Object implements Serializable

serialVersionUID: -1413303679077285530L

Class edu.stanford.nlp.ling.Word extends StringLabel implements Serializable

serialVersionUID: -4817252915997034058L

Class edu.stanford.nlp.ling.WordLemmaTag extends Object implements Serializable

serialVersionUID: -5993410244163988138L

Serialized Fields

word

String word

lemma

String lemma

tag

String tag

Class edu.stanford.nlp.ling.WordTag extends Object implements Serializable

serialVersionUID: -1859527239216813742L

Serialized Fields

word

String word

tag

String tag

Package edu.stanford.nlp.objectbank

Class edu.stanford.nlp.objectbank.LineIterator.LineIteratorFactory extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

oper

Function<T1,T2> oper

Class edu.stanford.nlp.objectbank.ObjectBank extends Object implements Serializable

serialVersionUID: -4030295596701541770L

Serialized Fields

rif

ReaderIteratorFactory rif

ifrf

IteratorFromReaderFactory<T> ifrf

contents

List<E> contents

keepInMemory

boolean keepInMemory

Package edu.stanford.nlp.parser.lexparser

Class edu.stanford.nlp.parser.lexparser.AbstractDependencyGrammar extends Object implements Serializable

serialVersionUID: 3L

Serialization Methods

readObject

private void readObject(ObjectInputStream ois)
                 throws IOException,
                        ClassNotFoundException
Throws:
IOException
ClassNotFoundException
Serialized Fields

tagProjection

TagProjection tagProjection

tagIndex

Index<E> tagIndex

wordIndex

Index<E> wordIndex

numTagBins

int numTagBins

tagBin

int[] tagBin

tlp

TreebankLanguagePack tlp

directional

boolean directional

useDistance

boolean useDistance

useCoarseDistance

boolean useCoarseDistance

lex

Lexicon lex

stopTW

IntTaggedWord stopTW

wildTW

IntTaggedWord wildTW

coarseDistanceBins

int[] coarseDistanceBins

regDistanceBins

int[] regDistanceBins

op

Options op

Class edu.stanford.nlp.parser.lexparser.AbstractTreebankParserParams extends Object implements Serializable

serialVersionUID: 4299501909017975915L

Serialized Fields

evalGF

boolean evalGF
If true, then evaluation is over grammatical functions as well as the labels If false, then grammatical functions are stripped for evaluation. This really only makes sense if you've trained with grammatical functions but want to evaluate without them.


inputEncoding

String inputEncoding

outputEncoding

String outputEncoding

tlp

TreebankLanguagePack tlp

Class edu.stanford.nlp.parser.lexparser.AbstractTreebankParserParams.AnnotatePunctuationFunction extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

key

String key

annotationMark

String annotationMark

Class edu.stanford.nlp.parser.lexparser.ArabicTreebankParserParams extends AbstractTreebankParserParams implements Serializable

serialVersionUID: 8853426784197984653L

Serialized Fields

optionsString

StringBuilder optionsString

retainNPTmp

boolean retainNPTmp

retainNPSbj

boolean retainNPSbj

retainPRD

boolean retainPRD

retainPPClr

boolean retainPPClr

changeNoLabels

boolean changeNoLabels

collinizerRetainsPunctuation

boolean collinizerRetainsPunctuation

discardX

boolean discardX

headFinder

HeadFinder headFinder

annotationPatterns

Map<K,V> annotationPatterns

activeAnnotations

Map<K,V> activeAnnotations

morphoSpec

MorphoFeatureSpecification morphoSpec

baselineFeatures

List<E> baselineFeatures
These are the annotations included when the user selects the -arabicFactored option.


additionalFeatures

List<E> additionalFeatures

Class edu.stanford.nlp.parser.lexparser.BaseLexicon extends Object implements Serializable

serialVersionUID: 40L

Serialization Methods

readObject

private void readObject(ObjectInputStream ois)
                 throws IOException,
                        ClassNotFoundException
Throws:
IOException
ClassNotFoundException
Serialized Fields

uwModel

UnknownWordModel uwModel

trainOptions

TrainOptions trainOptions

testOptions

TestOptions testOptions

smoothInUnknownsThreshold

int smoothInUnknownsThreshold
If a word has been seen more than this many times, then relative frequencies of tags are used for POS assignment; if not, they are smoothed with tag priors.


smartMutation

boolean smartMutation
Have tags changeable based on statistics on word types having various taggings.


wordIndex

Index<E> wordIndex

tagIndex

Index<E> tagIndex

seenCounter

ClassicCounter<E> seenCounter
Records the number of times word/tag pair was seen in training data. Includes word/tag pairs where one is a wildcard not a real word/tag.


smooth

double[] smooth

flexiTag

boolean flexiTag

useSignatureForKnownSmoothing

boolean useSignatureForKnownSmoothing

tagsToBaseTags

int[] tagsToBaseTags

Class edu.stanford.nlp.parser.lexparser.BinaryGrammar extends Object implements Serializable

serialVersionUID: 1L

Serialization Methods

readObject

private void readObject(ObjectInputStream stream)
                 throws IOException,
                        ClassNotFoundException
Throws:
IOException
ClassNotFoundException
Serialized Fields

index

Index<E> index

allRules

List<E> allRules

Class edu.stanford.nlp.parser.lexparser.BinaryRule extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

parent

int parent

score

float score

leftChild

int leftChild

rightChild

int rightChild

hashCode

int hashCode

Class edu.stanford.nlp.parser.lexparser.ChineseCharacterBasedLexicon extends Object implements Serializable

serialVersionUID: -5357655683145854069L

Serialized Fields

lengthPenalty

double lengthPenalty

penaltyType

int penaltyType

charDistributions

Map<K,V> charDistributions

knownChars

Set<E> knownChars

POSDistribution

Distribution<E> POSDistribution

useUnknownCharacterModel

boolean useUnknownCharacterModel

wordIndex

Index<E> wordIndex

tagIndex

Index<E> tagIndex

Class edu.stanford.nlp.parser.lexparser.ChineseLexicon extends BaseLexicon implements Serializable

serialVersionUID: -7836464391021114960L

Serialized Fields

useCharBasedUnknownWordModel

boolean useCharBasedUnknownWordModel

useGoodTuringUnknownWordModel

boolean useGoodTuringUnknownWordModel

probRandomWalk

edu.stanford.nlp.parser.lexparser.RandomWalk probRandomWalk

Class edu.stanford.nlp.parser.lexparser.ChineseLexiconAndWordSegmenter extends Object implements Serializable

serialVersionUID: -6554995189795187918L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException
Throws:
IOException
ClassNotFoundException
Serialized Fields

chineseLexicon

ChineseLexicon chineseLexicon

wordSegmenter

WordSegmenter wordSegmenter

op

Options op

Class edu.stanford.nlp.parser.lexparser.ChineseSimWordAvgDepGrammar extends MLEDependencyGrammar implements Serializable

serialVersionUID: -1845503582705055342L

Serialized Fields

simSmooth

double simSmooth

simArgMap

Map<K,V> simArgMap

simHeadMap

Map<K,V> simHeadMap

debug

boolean debug

verbose

boolean verbose

statsCounter

ClassicCounter<E> statsCounter

Class edu.stanford.nlp.parser.lexparser.ChineseTreebankParserParams extends AbstractTreebankParserParams implements Serializable

serialVersionUID: 2L

Serialized Fields

ctlp

ChineseTreebankLanguagePack ctlp
The variable ctlp stores the same thing as the tlp variable in AbstractTreebankParserParams, but pre-cast to be a ChineseTreebankLanguagePack.


charTags

boolean charTags

useCharacterBasedLexicon

boolean useCharacterBasedLexicon

useMaxentLexicon

boolean useMaxentLexicon

useMaxentDepGrammar

boolean useMaxentDepGrammar

segment

boolean segment

segmentMarkov

boolean segmentMarkov

sunJurafskyHeadFinder

boolean sunJurafskyHeadFinder

bikelHeadFinder

boolean bikelHeadFinder

discardFrags

boolean discardFrags

useSimilarWordMap

boolean useSimilarWordMap

segmenterClass

String segmenterClass

lex

Lexicon lex

segmenter

WordSegmenter segmenter

headFinder

HeadFinder headFinder

chineseSplitDouHao

boolean chineseSplitDouHao
Chinese: Split the dou hao (a punctuation mark separating members of a list) from other punctuation. Good but included below.


chineseSplitPunct

boolean chineseSplitPunct
Chinese: split Chinese punctuation several ways, along the lines of English punctuation plus another category for the dou hao. Good.


chineseSplitPunctLR

boolean chineseSplitPunctLR
Chinese: split left right/paren quote (if chineseSplitPunct is also true. Only very marginal gains, but seems positive.


markVVsisterIP

boolean markVVsisterIP
Chinese: mark VVs that are sister of IP (communication & small-clause-taking verbs). Good: give 0.5%


markPsisterIP

boolean markPsisterIP
Chinese: mark P's that are sister of IP. Negative effect


markIPsisterVVorP

boolean markIPsisterVVorP
Chinese: mark IP's that are sister of VV or P. These rarely have punctuation. Small positive effect.


markADgrandchildOfIP

boolean markADgrandchildOfIP
Chinese: mark ADs that are grandchild of IP.


gpaAD

boolean gpaAD
Grandparent annotate all AD. Seems slightly negative.


chineseVerySelectiveTagPA

boolean chineseVerySelectiveTagPA

chineseSelectiveTagPA

boolean chineseSelectiveTagPA

markIPsisterBA

boolean markIPsisterBA
Chinese: mark IPs that are sister of BA. These always have overt NP. Very slightly positive.


markVPadjunct

boolean markVPadjunct
Chinese: mark phrases that are adjuncts of VP (these tend to be locatives/temporals, and have a specific distribution). Necessary even with chineseSplitVP==3 and parent annotation because parent annotation happens with unsplit parent categories. Slightly positive.


markNPmodNP

boolean markNPmodNP
Chinese: mark NP modifiers of NPs. Quite positive (0.5%)


markModifiedNP

boolean markModifiedNP
Chinese: mark left-modified NPs (rightmost NPs with a left-side mod). Slightly positive.


markNPconj

boolean markNPconj
Chinese: mark NPs that are conjuncts. Negative on small set.


markMultiNtag

boolean markMultiNtag
Chinese: mark nominal tags that are part of multi-nominal rewrites. Doesn't seem any good.


markIPsisDEC

boolean markIPsisDEC
Chinese: mark IPs that are part of prenominal modifiers. Negative.


markIPconj

boolean markIPconj
Chinese: mark IPs that are conjuncts. Or those that have (adjuncts or subjects)


markIPadjsubj

boolean markIPadjsubj

chineseSplitVP

int chineseSplitVP
Chinese VP splitting. 0 = none; 1 = mark with -BA a VP that directly dominates a BA; 2 = mark with -BA a VP that directly dominates a BA or a VP that directly dominates a BA 3 = split VPs into VP-COMP, VP-CRD, VP-ADJ. (Negative value.)


mergeNNVV

boolean mergeNNVV
Chinese: merge NN and VV. A lark.


unaryIP

boolean unaryIP
Chinese: unary category marking


unaryCP

boolean unaryCP

paRootDtr

boolean paRootDtr
Chinese: parent annotate daughter of root. Meant only for selectivesplit=false.


markPostverbalP

boolean markPostverbalP
Chinese: mark P with a left aunt VV, and PP with a left sister VV. Note that it's necessary to mark both to thread the context-marking. Used to identify post-verbal P's, which are rare.


markPostverbalPP

boolean markPostverbalPP

splitBaseNP

boolean splitBaseNP
Mark base NPs. Good.


tagWordSize

boolean tagWordSize
Annotate tags for number of characters contained.


markCC

boolean markCC
Mark phrases which are conjunctions. Appears negative, even with 200K words training data.


splitNPTMP

boolean splitNPTMP
Whether to retain the -TMP functional tag on various phrasal categories. On 80K words training, minutely helpful; on 200K words, best option gives 0.6%. Doing splitNPTMP and splitPPTMP (but not splitXPTMP) is best.


splitPPTMP

boolean splitPPTMP

splitXPTMP

boolean splitXPTMP

dominatesV

boolean dominatesV
Verbal distance -- mark whether symbol dominates a verb (V*). Seems bad for Chinese.


useGoodTuringUnknownWordModel

boolean useGoodTuringUnknownWordModel

useCharBasedUnknownWordModel

boolean useCharBasedUnknownWordModel

lengthPenalty

double lengthPenalty
Parameters for a ChineseCharacterBasedLexicon


useUnknownCharacterModel

boolean useUnknownCharacterModel

penaltyType

int penaltyType
penaltyType should be set as follows: 0: no length penalty 1: quadratic length penalty 2: penalty for continuation chars only TODO: make this an enum


depGramFeatureLevel

int depGramFeatureLevel

Class edu.stanford.nlp.parser.lexparser.EnglishTreebankParserParams extends AbstractTreebankParserParams implements Serializable

serialVersionUID: 4153878351331522581L

Serialized Fields

headFinder

HeadFinder headFinder

englishTrain

EnglishTreebankParserParams.EnglishTrain englishTrain

englishTest

EnglishTreebankParserParams.EnglishTest englishTest

Class edu.stanford.nlp.parser.lexparser.EnglishTreebankParserParams.EnglishTest extends Object implements Serializable

serialVersionUID: 183157656745674521L

Serialized Fields

retainNPTMPSubcategories

boolean retainNPTMPSubcategories

retainTMPSubcategories

boolean retainTMPSubcategories

retainADVSubcategories

boolean retainADVSubcategories

makeCopulaHead

boolean makeCopulaHead

Class edu.stanford.nlp.parser.lexparser.EnglishTreebankParserParams.EnglishTrain extends Object implements Serializable

serialVersionUID: 1831576434872643L

Serialized Fields

leaveItAll

int leaveItAll
if true, leave all PTB (functional tag) annotations (bad)


splitIN

int splitIN
Annotate prepositions into subcategories. Values: 0 = no annotation 1 = IN with a ^S.* parent (putative subordinating conjunctions) marked differently from others (real prepositions). OK. 2 = Annotate IN prepositions 3 ways: ^S.* parent, ^N.* parent or rest (generally predicative ADJP, VP). Better than sIN=1. Good. 3 = Annotate prepositions 6 ways: real feature engineering. Great. 4 = Refinement of 3: allows -SC under SINV, WHADVP for -T and no -SCC if the parent is an NP. 5 = Like 4 but maps TO to IN in a "nominal" (N*, P*, A*) context. 6 = 4, but mark V/A complement and leave noun ones unmarked instead.


splitQuotes

boolean splitQuotes
Mark quote marks for single vs. double so don't get mismatched ones.


splitSFP

boolean splitSFP
Separate out sentence final punct. (. ! ?). Doesn't help.


splitPercent

boolean splitPercent
Mark the nouns that are percent signs. Slightly good.


splitNPpercent

int splitNPpercent
Mark phrases that are headed by %. A value of 0 = do nothing, 1 = only NP, 2 = NP and ADJP, 3 = NP, ADJP and QP, 4 = any phrase.


tagRBGPA

boolean tagRBGPA
Grand parent annotate RB to try to distinguish sentential ones and ones in places like NP post modifier (things like 'very' are already distinguished as their parent is ADJP).


splitNNP

int splitNNP
Mark NNP words as to position in phrase (single, left, right, inside) or subcategorizes NNP(S) as initials or initial/final in NP.


joinPound

boolean joinPound
Join pound with dollar.


joinJJ

boolean joinJJ
Joint comparative and superlative adjective with positive.


joinNounTags

boolean joinNounTags
Join proper nouns with common nouns. This isn't to improve performance, but because Genia doesn't use proper noun tags in general.


splitPPJJ

boolean splitPPJJ
A special test for "such" mainly ("such as Fred"). A wash, so omit


splitTRJJ

boolean splitTRJJ
Put a special tag on 'transitive adjectives' with NP complement, like 'due May 15' -- it also catches 'such' in 'such as NP', which may be a good. Matches 658 times in 2-21 training corpus. Wash.


splitJJCOMP

boolean splitJJCOMP
Put a special tag on 'adjectives with complements'. This acts as a general subcat feature for adjectives.


splitMoreLess

boolean splitMoreLess
Specially mark the comparative/superlative words: less, least, more, most


unaryDT

boolean unaryDT
Mark "Intransitive" DT. Good.


unaryRB

boolean unaryRB
Mark "Intransitive" RB. Good.


unaryPRP

boolean unaryPRP
"Intransitive" PRP. Wash -- basically a no-op really.


markReflexivePRP

boolean markReflexivePRP
Mark reflexivie PRP words.


unaryIN

boolean unaryIN
Mark "Intransitive" IN. Minutely negative.


splitCC

int splitCC
Provide annotation of conjunctions. Gives modest gains (numbers shown F1 increase with respect to goodPCFG in June 2005). A value of 1 annotates both "and" and "or" as "CC-C" (+0.29%), 2 annotates "but" and "&" separately (+0.17%), 3 annotates just "and" (equalsIgnoreCase) (+0.11%), 0 annotates nothing (+0.00%).


splitNOT

boolean splitNOT
Annotates forms of "not" specially as tag "NOT". BAD


splitRB

boolean splitRB
Split modifier (NP, AdjP) adverbs from others. This does nothing if you're already doing tagPA.


splitAux

int splitAux
Make special tags for forms of BE and HAVE (and maybe DO/HELP, etc.). A value of 0 is do nothing. A value of 1 is the basic form. Positive PCFG effect, but neutral to negative in Factored, and impossible if you use gPA. A value of 2 adds in "s" = "'s" and delves further to disambiguate "'s" as BE or HAVE. Theoretically good, but no practical gains. A value of 3 adds DO. A value of 4 adds HELP (which also takes VB form complement) as DO. A value of 5 adds LET (which also takes VB form complement) as DO. A value of 6 adds MAKE (which also takes VB form complement) as DO. A value of 7 adds WATCH, SEE (which also take VB form complement) as DO. A value of 8 adds come, go, but not inflections (which colloquially can take a VB form complement) as DO. A value of 9 adds GET as BE. Differences are small. You get about 0.3 F1 by doing something; the best appear to be 2 or 3 for sentence exact and 7 or 8 for LP/LR F1.


vpSubCat

boolean vpSubCat
Pitiful attempt at marking V* preterms with their surface subcat frames. Bad so far.


markDitransV

int markDitransV
Attempt to record ditransitive verbs. The value 0 means do nothing; 1 records two or more NP or S* arguments, and 2 means to only record two or more NP arguments (that aren't NP-TMP). 1 gave neutral to bad results.


splitVP

int splitVP
Add (head) tags to VPs. An argument of 0 = no head-subcategorization of VPs, 1 = add head tags (anything, as given by HeadFinder), 2 = add head tags, but collapse finite verb tags (VBP, VBD, VBZ, MD) together, 3 = only annotate verbal tags, and collapse finite verb tags (annotation is VBF, TO, VBG, VBN, VB, or zero), 4 = only split on categories of VBF, TO, VBG, VBN, VB, and map cases that are not headed by a verbal category to an appropriate category based on word suffix (ing, d, t, s, to) or to VB otherwise. We usually use a value of 3; 2 or 3 is much better than 0. See also splitVPNPAgr. If it is true, its effects override any value set for this parameter.


splitVPNPAgr

boolean splitVPNPAgr
Put enough marking on VP and NP to permit "agreement".


splitSTag

int splitSTag
Mark S/SINV/SQ nodes according to verbal tag. Meanings are: 0 = no subcategorization. 1 = mark with head tag 2 = mark only -VBF if VBZ/VBD/VBP/MD tag 3 = as 2 and mark -VBNF if TO/VBG/VBN/VB 4 = as 2 but only mark S not SINV/SQ 5 = as 3 but only mark S not SINV/SQ Previously seen as bad. Option 4 might be promising now.


markContainedVP

boolean markContainedVP

splitNPPRP

boolean splitNPPRP

dominatesV

int dominatesV
Verbal distance -- mark whether symbol dominates a verb (V*, MD). Very good.


dominatesI

boolean dominatesI
Verbal distance -- mark whether symbol dominates a preposition (IN)


dominatesC

boolean dominatesC
Verbal distance -- mark whether symbol dominates a conjunction (CC)


markCC

int markCC
Mark phrases which are conjunctions. 0 = No marking 1 = Any phrase with a CC daughter that isn't first or last. Possibly marginally positive. 2 = As 0 but also a non-marginal CONJP daughter. In principle good, but no gains. 3 = More like Charniak. Not yet implemented. Need to annotate _before_ annotate children! np or vp with two or more np/vp children, a comma, cc or conjp, and nothing else.


splitSGapped

int splitSGapped
Mark specially S nodes with "gapped" subject (control, raising). 1 is basic version. 2 is better mark S nodes with "gapped" subject. 3 seems best on small training set, but all of these are too similar; 4 can't be differentiated. 5 is done on tree before empty splitting. (Bad!?)


splitNumNP

boolean splitNumNP
Mark "numeric NPs". Probably bad?


splitPoss

int splitPoss
Give a special tag to NPs which are possessive NPs (end in 's). A value of 0 means do nothing, 1 means tagging possessive NPs with "-P", 2 means restructure possessive NPs so that they introduce a POSSP node that takes as children the POS and a regularly structured NP. I.e., recover standard good linguistic practice circa 1985. This seems a good idea, but is almost a no-op (modulo fine points of markovization), since the previous NP-P phrase already uniquely captured what is now a POSSP.


splitBaseNP

int splitBaseNP
Mark base NPs. A value of 0 = no marking, 1 = marking baseNP (ones which rewrite just as preterminals), and 2 = doing Collins-style marking, where an extra NP node is inserted above a baseNP, if it isn't already in an NP over NP construction, as in Collins 1999. This option shouldn't really be in EnglishTrain since it's needed at parsing time. But we don't currently use it.... A value of 1 is good.


splitTMP

int splitTMP
Retain NP-TMP (or maybe PP-TMP) annotation. Good. The values for this parameter are defined in NPTmpRetainingTreeNormalizer.


splitSbar

int splitSbar
Split SBAR nodes. 1 = mark 'in order to' purpose clauses; this is actually a small and inconsistent part of what is marked SBAR-PRP in the treebank, which is mainly 'because' reason clauses. 2 = mark all infinitive SBAR. 3 = do 1 and 2. A value of 1 seems minutely positive; 2 and 3 seem negative. Also get 'in case Sfin', 'In order to', and on one occasion 'in order that'


splitNPADV

int splitNPADV
Retain NP-ADV annotation. 0 means strip "-ADV" annotation. 1 means to retain it, and to percolate it down to a head tag providing it can do it through a path of only NP nodes.


splitNPNNP

int splitNPNNP
Mark NP-NNP. 0 is nothing; 1 is only NNP head, 2 is NNP and NNPS head; 3 is NNP or NNPS anywhere in local NP. All bad!


correctTags

boolean correctTags
'Correct' tags to produce verbs in VPs, etc. where possible


rightPhrasal

boolean rightPhrasal
Right edge has a phrasal node. Bad?


sisterSplitLevel

int sisterSplitLevel
Set the support * KL cutoff level (1-4) for sister splitting -- don't use it, as far as we can tell so far


gpaRootVP

boolean gpaRootVP
Grand-parent annotate (root mark) VP below ROOT. Seems negative.


makePPTOintoIN

int makePPTOintoIN
Change TO inside PP to IN.

Class edu.stanford.nlp.parser.lexparser.FactoredLexicon extends BaseLexicon implements Serializable

serialVersionUID: 8496467161563992530L

Serialized Fields

morphoSpec

MorphoFeatureSpecification morphoSpec

Class edu.stanford.nlp.parser.lexparser.FrenchTreebankParserParams extends AbstractTreebankParserParams implements Serializable

serialVersionUID: -6976724734594763986L

Serialized Fields

optionsString

StringBuilder optionsString

headFinder

HeadFinder headFinder

annotationPatterns

Map<K,V> annotationPatterns

activeAnnotations

Map<K,V> activeAnnotations

readPennFormat

boolean readPennFormat

collinizerRetainsPunctuation

boolean collinizerRetainsPunctuation

mwCounter

TwoDimensionalCounter<K1,K2> mwCounter

morphoSpec

MorphoFeatureSpecification morphoSpec

baselineFeatures

List<E> baselineFeatures

additionalFeatures

List<E> additionalFeatures

Class edu.stanford.nlp.parser.lexparser.HebrewTreebankParserParams extends AbstractTreebankParserParams implements Serializable

serialVersionUID: -3466519995341208619L

Serialized Fields

optionsString

StringBuilder optionsString

Class edu.stanford.nlp.parser.lexparser.IntDependency extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

head

IntTaggedWord head

arg

IntTaggedWord arg

leftHeaded

boolean leftHeaded

distance

short distance

Class edu.stanford.nlp.parser.lexparser.IntTaggedWord extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

word

int word

tag

short tag

Class edu.stanford.nlp.parser.lexparser.Lattice extends Object implements Serializable

serialVersionUID: 5135076134500512556L

Serialized Fields

constraints

List<E> constraints

edges

List<E> edges

nodes

Set<E> nodes

edgeStartsAt

Map<K,V> edgeStartsAt

maxNode

int maxNode

Class edu.stanford.nlp.parser.lexparser.LatticeEdge extends Object implements Serializable

serialVersionUID: 4416189959485854286L

Serialized Fields

word

String word

label

String label

weight

double weight

start

int start

end

int end

attrs

Map<K,V> attrs

Class edu.stanford.nlp.parser.lexparser.MLEDependencyGrammar extends AbstractDependencyGrammar implements Serializable

serialVersionUID: 1L

Serialization Methods

readObject

private void readObject(ObjectInputStream stream)
                 throws IOException,
                        ClassNotFoundException
Throws:
IOException
ClassNotFoundException

writeObject

private void writeObject(ObjectOutputStream stream)
                  throws IOException
Throws:
IOException
Serialized Fields

useSmoothTagProjection

boolean useSmoothTagProjection

useUnigramWordSmoothing

boolean useUnigramWordSmoothing

numWordTokens

int numWordTokens

argCounter

ClassicCounter<E> argCounter
Stores all the counts for dependencies (with and without the word being a wildcard) in the reduced tag space.


stopCounter

ClassicCounter<E> stopCounter

smooth_aT_hTWd

double smooth_aT_hTWd
Bayesian m-estimate prior for aT given hTWd against base distribution of aT given hTd. TODO: Note that these values are overwritten in the constructor. Find what is best and then maybe remove these defaults!


smooth_aTW_hTWd

double smooth_aTW_hTWd
Bayesian m-estimate prior for aTW given hTWd against base distribution of aTW given hTd.


smooth_stop

double smooth_stop

interp

double interp
Interpolation between model that directly predicts aTW and model that predicts aT and then aW given aT. This percent of the mass is on the model directly predicting aTW.


smooth_aTW_aT

double smooth_aTW_aT

smooth_aTW_hTd

double smooth_aTW_hTd

smooth_aT_hTd

double smooth_aT_hTd

smooth_aPTW_aPT

double smooth_aPTW_aPT

smoothTP

TagProjection smoothTP

smoothTPIndex

Index<E> smoothTPIndex

Class edu.stanford.nlp.parser.lexparser.NegraPennTreebankParserParams extends AbstractTreebankParserParams implements Serializable

serialVersionUID: 757812264219400466L

Serialized Fields

markRC

boolean markRC

markZuVP

boolean markZuVP

markLP

boolean markLP

markColon

boolean markColon

markKonjParent

boolean markKonjParent

markHDParent

boolean markHDParent

markContainsV

boolean markContainsV

nodeCleanup

int nodeCleanup
Node cleanup is how node names are normalized. The known values are: 0 = do nothing; 1 = keep category and function; 2 = keep only category


headFinder

HeadFinder headFinder

treeNormalizerInsertNPinPP

boolean treeNormalizerInsertNPinPP

treeNormalizerLeaveGF

boolean treeNormalizerLeaveGF

treeReaderFactory

NegraPennTreeReaderFactory treeReaderFactory

Class edu.stanford.nlp.parser.lexparser.Options extends Object implements Serializable

serialVersionUID: 4L

Serialization Methods

readObject

private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException
Making the TestOptions transient means it won't even be constructed when you deserialize an Options, so we need to construct it on our own when deserializing

Throws:
IOException
ClassNotFoundException
Serialized Fields

lexOptions

Options.LexOptions lexOptions

tlpParams

TreebankLangParserParams tlpParams
The treebank-specific parser parameters to use.


forceCNF

boolean forceCNF
Forces parsing with strictly CNF grammar -- unary chains are converted to XP&YP symbols and back


doPCFG

boolean doPCFG
Do a PCFG parse of the sentence. If both variables are on, also do a combined parse of the sentence.


doDep

boolean doDep
Do a dependency parse of the sentence.


freeDependencies

boolean freeDependencies
if true, any child can be the head (seems rather bad!)


directional

boolean directional
Whether dependency grammar considers left/right direction. Good.


genStop

boolean genStop

useSmoothTagProjection

boolean useSmoothTagProjection

useUnigramWordSmoothing

boolean useUnigramWordSmoothing

distance

boolean distance
Use distance bins in the dependency calculations


coarseDistance

boolean coarseDistance
Use coarser distance (4 bins) in dependency calculations


dcTags

boolean dcTags
"double count" tags rewrites as word in PCFG and Dep parser. Good for combined parsing only (it used to not kick in for PCFG parsing). This option is only used at Test time, but it is now in Options, so the correct choice for a grammar is recorded by a serialized parser. You should turn this off for a vanilla PCFG parser.


nodePrune

boolean nodePrune
If true, inside the factored parser, remove any node from the final chosen tree which improves the PCFG score. This was added as the dependency factor tends to encourage 'deep' trees.


trainOptions

TrainOptions trainOptions

Class edu.stanford.nlp.parser.lexparser.Options.LexOptions extends Object implements Serializable

serialVersionUID: 2805351374506855632L

Serialized Fields

useUnknownWordSignatures

int useUnknownWordSignatures
Whether to use suffix and capitalization information for unknowns. Within the BaseLexicon model options have the following meaning: 0 means a single unknown token. 1 uses suffix, and capitalization. 2 uses a variant (richer) form of signature. Good. Use this one. Using the richer signatures in versions 3 or 4 seems to have very marginal or no positive value. 3 uses a richer form of signature that mimics the NER word type patterns. 4 is a variant of 2. 5 is another with more English specific morphology (good for English unknowns!). 6-9 are options for Arabic. 9 codes some patterns for numbers and derivational morphology, but also supports unknownPrefixSize and unknownSuffixSize. For German, 0 means a single unknown token, and non-zero means to use capitalization of first letter and a suffix of length unknownSuffixSize.


smoothInUnknownsThreshold

int smoothInUnknownsThreshold
Words more common than this are tagged with MLE P(t|w). Default 100. The smoothing is sufficiently slight that changing this has little effect. But set this to 0 to be able to use the parser as a vanilla PCFG with no smoothing (not as a practical parser but for exposition or debugging).


smartMutation

boolean smartMutation
Smarter smoothing for rare words.


useUnicodeType

boolean useUnicodeType
Make use of unicode code point types in smoothing.


unknownSuffixSize

int unknownSuffixSize
For certain Lexicons, a certain number of word-final letters are used to subclassify the unknown token. This gives the number of letters.


unknownPrefixSize

int unknownPrefixSize
For certain Lexicons, a certain number of word-initial letters are used to subclassify the unknown token. This gives the number of letters.


uwModel

String uwModel
Model for unknown words that the lexicon should use


flexiTag

boolean flexiTag

useSignatureForKnownSmoothing

boolean useSignatureForKnownSmoothing
Whether to use signature rather than just being unknown as prior in known word smoothing. Currently only works if turned on for English.

Class edu.stanford.nlp.parser.lexparser.ParserConstraint extends Object implements Serializable

serialVersionUID: 4955237758572202093L

Serialized Fields

start

int start

end

int end

state

Pattern state

Class edu.stanford.nlp.parser.lexparser.ParserData extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

lex

Lexicon lex

bg

BinaryGrammar bg

ug

UnaryGrammar ug

dg

DependencyGrammar dg

stateIndex

Index<E> stateIndex

wordIndex

Index<E> wordIndex

tagIndex

Index<E> tagIndex

pt

Options pt

Class edu.stanford.nlp.parser.lexparser.TestOptions extends Object implements Serializable

serialVersionUID: 7256526346598L

Serialized Fields

noRecoveryTagging

boolean noRecoveryTagging
If false, then failure of the PCFG parser to parse a sentence will trigger allowing all tags for words in parse recovery mode, with a log probability of -1000. If true, these extra taggings are not added. It is false by default. Use option -noRecoveryTagging to set to true.


doRecovery

boolean doRecovery
If true, then failure of the PCFG factor to parse a sentence will trigger parse recovery mode.


useN5

boolean useN5
If true, the n^4 "speed-up" is not used with the Factored Parser.


useFastFactored

boolean useFastFactored
If true, use approximate factored algorithm, which just rescores PCFG k best, rather than exact factored algorithm. This algorithm requires the dependency grammar to exist for rescoring, but not for the dependency grammar to be run. Hence the correct usage for guarding code only required for exact A* factored parsing is now if (op.doPCFG && op.doDep && ! Test.useFastFactored).


iterativeCKY

boolean iterativeCKY
If true, use faster iterative deepening CKY algorithm.


maxLength

int maxLength
The maximum sentence length (including punctuation, etc.) to parse.


MAX_ITEMS

int MAX_ITEMS
The maximum number of edges and hooks combined that the factored parser will build before giving up. This number should probably be relative to the sentence length parsed. In general, though, if the parser cannot parse a sentence after this much work then there is no good parse consistent between the PCFG and Dependency parsers. (Normally, depending on other flags), the parser will then just return the best PCFG parse.)


unseenSmooth

double unseenSmooth
The amount of smoothing put in (as an m-estimate) for unknown words. If negative, set by the code in the lexicon class.


increasingLength

boolean increasingLength
Parse trees in test treebank in order of increasing length.


preTag

boolean preTag
Tag the sentences first, then parse given those (coarse) tags.


forceTags

boolean forceTags
Parse using only tags given from correct answer or the POS tagger


forceTagBeginnings

boolean forceTagBeginnings

taggerSerializedFile

String taggerSerializedFile
POS tagger model used when preTag is enabled.


noFunctionalForcing

boolean noFunctionalForcing
Only valid with force tags - strips away functionals when forcing the tags, meaning tags have to start appropriately but the parser will assign the functional part.


evalb

boolean evalb
Write EvalB-readable output files.


verbose

boolean verbose
Print a lot of extra output as you parse.


exhaustiveTest

boolean exhaustiveTest

pcfgThreshold

boolean pcfgThreshold
If this variable is true, and the sum of the inside and outside score for a constituent is worse than the best known score for a sentence by more than pcfgThresholdValue, then -Inf is returned as the outside Score by oScore() (while otherwise the true outside score is returned).


pcfgThresholdValue

double pcfgThresholdValue

printAllBestParses

boolean printAllBestParses
Print out all best PCFG parses.


depWeight

double depWeight
Weighting on dependency log probs. The dependency grammar negative log probability scores are simply multiplied by this number.


prunePunc

boolean prunePunc

addMissingFinalPunctuation

boolean addMissingFinalPunctuation
If a token list does not have sentence final punctuation near the end, then automatically add the default one. This might help parsing if the treebank is all punctuated. Not done if reading a treebank.


outputFormat

String outputFormat
Determines format of output trees: choose among penn, oneline


outputFormatOptions

String outputFormatOptions

writeOutputFiles

boolean writeOutputFiles
If true, write files parsed to a new file with the same name except for an added ".stp" extension.


outputFilesDirectory

String outputFilesDirectory
If the writeOutputFiles option is true, then output files appear in this directory. An unset value (null) means to use the directory of the source files. Use "" or . for the current directory.


outputFilesExtension

String outputFilesExtension
If the writeOutputFiles option is true, then output files appear with this extension. Use "" for no extension.


outputFilesPrefix

String outputFilesPrefix
If the writeOutputFiles option is true, then output files appear with this prefix.


outputkBestEquivocation

String outputkBestEquivocation
If this option is not null, output the k-best equivocation. Must be specified with printPCFGkBest.


maxSpanForTags

int maxSpanForTags
The largest span to consider for word-hood. Used for parsing unsegmented Chinese text and parsing lattices. Keep it at 1 unless you know what you're doing.


lengthNormalization

boolean lengthNormalization
Turns on normalizing scores for sentence length. Makes no difference (except decreased efficiency) unless maxSpanForTags is greater than one. Works only for PCFG (so far).


sample

boolean sample
Used when you want to generate sample parses instead of finding the best parse. (NOT YET USED.)


printPCFGkBest

int printPCFGkBest
Printing k-best parses from PCFG, when k > 0.


printFactoredKGood

int printFactoredKGood
Printing k-best parses from PCFG, when k > 0.


evals

Properties evals
What evaluations to report and how to report them (using LexicalizedParser). Known evaluations are: pcfgLB, pcfgCB, pcfgDA, pcfgTA, pcfgLL, pcfgRUO, pcfgCUO, pcfgCatE, depDA, depTA, depLL, factLB, factCB, factDA, factTA, factLL. The default is pcfgLB,depDA,factLB,factTA. You need to negate those ones out (e.g., -evals "depDA=false") if you don't want them. LB = ParseEval labeled bracketing, CB = crossing brackets and zero crossing bracket rate, DA = dependency accuracy, TA = tagging accuracy, LL = log likelihood score, RUO/CUO = rules/categories under and over proposed, CatE = evaluation by phrasal category. Known styles are: runningAverages, summary, tsv. The default style is summary. You need to negate it out if you don't want it. Invalid names in the argument to this option are not reported!


fastFactoredCandidateMultiplier

int fastFactoredCandidateMultiplier
This variable says to find k good fast factored parses, how many times k of the best PCFG parses should be examined.


fastFactoredCandidateAddend

int fastFactoredCandidateAddend
This variable says to find k good factored parses, how many added on best PCFG parses should be examined.


useLexiconToScoreDependencyPwGt

boolean useLexiconToScoreDependencyPwGt
If this is true, the Lexicon is used to score P(w|t) in the backoff inside the dependency grammar. (Otherwise, a MLE is used is w is seen, and a constant if w is unseen.


useNonProjectiveDependencyParser

boolean useNonProjectiveDependencyParser
If this is true, perform non-projective dependency parsing.

Class edu.stanford.nlp.parser.lexparser.TrainOptions extends Object implements Serializable

serialVersionUID: 72571349843538L

Serialized Fields

trainTreeFile

String trainTreeFile

trainLengthLimit

int trainLengthLimit

cheatPCFG

boolean cheatPCFG
Add all test set trees to training data for PCFG. (Currently only supported in FactoredParser main.)


markovFactor

boolean markovFactor

markovOrder

int markovOrder

hSelSplit

boolean hSelSplit

HSEL_CUT

int HSEL_CUT

markFinalStates

boolean markFinalStates
Whether or not to mark final states in binarized grammar. This must be off to get most value out of grammar compaction.


openClassTypesThreshold

int openClassTypesThreshold
A POS tag has to have been attributed to more than this number of word types before it is regarded as an open-class tag. Unknown words will only possibly be tagged as open-class tags (unless flexiTag is on). If flexiTag is on, unknown words will be able to be tagged any POS for which the unseenMap has nonzero count (that is, the tag was seen for a new word after unseen signature counting was started).


fractionBeforeUnseenCounting

double fractionBeforeUnseenCounting
Start to aggregate signature-tag pairs only for words unseen in the first this fraction of the data.


PA

boolean PA
This variable controls doing parent annotation of phrasal nodes. Good.


gPA

boolean gPA
This variable controls doing 2 levels of parent annotation. Bad.


postPA

boolean postPA

postGPA

boolean postGPA

selectiveSplit

boolean selectiveSplit
Only split the "common high KL divergence" parent categories.... Good.


selectiveSplitCutOff

double selectiveSplitCutOff

selectivePostSplit

boolean selectivePostSplit

selectivePostSplitCutOff

double selectivePostSplitCutOff

postSplitWithBaseCategory

boolean postSplitWithBaseCategory
Whether, in post-splitting of categories, nodes are annotated with the (grand)parent's base category or with its complete subcategorized category.


sisterAnnotate

boolean sisterAnnotate
Selective Sister annotation.


sisterSplitters

Set<E> sisterSplitters

markUnary

int markUnary
Mark all unary nodes specially. Good for just PCFG. Bad for factored. markUnary affects phrasal nodes. A value of 0 means to do nothing; a value of 1 means to mark the parent (higher) node of a unary rewrite. A value of 2 means to mark the child (lower) node of a unary rewrie. Values of 1 and 2 only apply if the child (lower) node is phrasal. (A value of 1 is better than 2 in combos.) A value of 1 corresponds to the old boolean -unary flag.


markUnaryTags

boolean markUnaryTags
Mark POS tags which are the sole member of their phrasal constituent. This is like markUnary=2, applied to POS tags.


splitPrePreT

boolean splitPrePreT
Mark all pre-preterminals (also does splitBaseNP: don't need both)


tagPA

boolean tagPA
Parent annotation on tags. Good (for PCFG?)


tagSelectiveSplit

boolean tagSelectiveSplit
Do parent annotation on tags selectively. Neutral, but less splits.


tagSelectiveSplitCutOff

double tagSelectiveSplitCutOff

tagSelectivePostSplit

boolean tagSelectivePostSplit

tagSelectivePostSplitCutOff

double tagSelectivePostSplitCutOff

rightRec

boolean rightRec
Right edge is right-recursive (X << X) Bad. (NP only is good)


leftRec

boolean leftRec
Left edge is right-recursive (X << X) Bad.


collinsPunc

boolean collinsPunc
Promote/delete punctuation like Collins. Bad (!)


splitters

Set<E> splitters
Set the splitter strings. These are a set of parent and/or grandparent annotated categories which should be split off.


postSplitters

Set<E> postSplitters

deleteSplitters

Set<E> deleteSplitters

printTreeTransformations

int printTreeTransformations
Just for debugging: check that your tree transforms work correctly. This will print the transformations of the first printTreeTransformations trees.


printAnnotatedPW

PrintWriter printAnnotatedPW

printBinarizedPW

PrintWriter printBinarizedPW

printStates

boolean printStates

compactGrammar

int compactGrammar
How to compact grammars as FSMs. 0 = no compaction [uses makeSyntheticLabel1], 1 = no compaction but use label names that wrap from right to left in binarization [uses makeSyntheticLabel2], 2 = wrapping labels and materialize unary at top rewriting passive to active, 3 = ExactGrammarCompactor, 4 = LossyGrammarCompactor, 5 = CategoryMergingGrammarCompactor. (May 2007 CDM note: options 4 and 5 don't seem to be functioning sensibly. 0, 1, and 3 seem to be the 'good' options. 2 is only useful as input to 3. There seems to be no reason not to use 0, despite the default.)


leftToRight

boolean leftToRight

noTagSplit

boolean noTagSplit

ruleSmoothing

boolean ruleSmoothing
Enables linear rule smoothing during grammar extraction but before grammar compaction. The alpha term is the same as that described in Petrov et al. (2006), and has range [0,1].


ruleSmoothingAlpha

double ruleSmoothingAlpha

smoothing

boolean smoothing
TODO wsg2011: This is the old grammar smoothing parameter that no longer does anything in the parser. It should be removed.


ruleDiscount

double ruleDiscount
Discounts the count of BinaryRule's (only, apparently) in training data.


printAnnotatedRuleCounts

boolean printAnnotatedRuleCounts

printAnnotatedStateCounts

boolean printAnnotatedStateCounts

basicCategoryTagsInDependencyGrammar

boolean basicCategoryTagsInDependencyGrammar
Where to use the basic or split tags in the dependency grammar

Class edu.stanford.nlp.parser.lexparser.UnaryGrammar extends Object implements Serializable

serialVersionUID: 1L

Serialization Methods

readObject

private void readObject(ObjectInputStream stream)
                 throws IOException,
                        ClassNotFoundException
Throws:
IOException
ClassNotFoundException
Serialized Fields

index

Index<E> index

coreRules

Map<K,V> coreRules
The basic list of UnaryRules. Really this is treated as a set

Class edu.stanford.nlp.parser.lexparser.UnaryRule extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

parent

int parent

score

float score

child

int child

Package edu.stanford.nlp.parser.ui

Class edu.stanford.nlp.parser.ui.TreeJPanel extends JPanel implements Serializable

Serialized Fields

VERTICAL_ALIGN

int VERTICAL_ALIGN

HORIZONTAL_ALIGN

int HORIZONTAL_ALIGN

maxFontSize

int maxFontSize

minFontSize

int minFontSize

tree

Tree tree

Package edu.stanford.nlp.process

Package edu.stanford.nlp.semgrex

Class edu.stanford.nlp.semgrex.CoordinationPattern extends SemgrexPattern implements Serializable

serialVersionUID: -3122330899634961002L

Serialized Fields

isConj

boolean isConj

isNodeCoord

boolean isNodeCoord

children

List<E> children

Class edu.stanford.nlp.semgrex.NodePattern extends SemgrexPattern implements Serializable

serialVersionUID: -5981133879119233896L

Serialized Fields

reln

edu.stanford.nlp.semgrex.GraphRelation reln

negDesc

boolean negDesc

attributes

Map<K,V> attributes

isRoot

boolean isRoot

isLink

boolean isLink

isEmpty

boolean isEmpty

name

String name

descString

String descString

child

SemgrexPattern child

variableGroups

List<E> variableGroups

Class edu.stanford.nlp.semgrex.ParseException extends Exception implements Serializable

serialVersionUID: 1L

Serialized Fields

currentToken

edu.stanford.nlp.semgrex.Token currentToken
This is the last token that has been consumed successfully. If this object has been created due to a parse error, the token followng this token will (therefore) be the first error token.


expectedTokenSequences

int[][] expectedTokenSequences
Each entry in this array is an array of integers. Each array of integers represents a sequence of tokens (by their ordinal values) that is expected at this point of the parse.


tokenImage

String[] tokenImage
This is a reference to the "tokenImage" array of the generated parser within which the parse error occurred. This array is defined in the generated ...Constants interface.


eol

String eol
The end of line string for this machine.

Class edu.stanford.nlp.semgrex.SemgrexParseException extends RuntimeException implements Serializable

Class edu.stanford.nlp.semgrex.SemgrexPattern extends Object implements Serializable

serialVersionUID: 1722052832350596732L

Serialized Fields

neg

boolean neg

opt

boolean opt

patternString

String patternString

Package edu.stanford.nlp.stats

Class edu.stanford.nlp.stats.ClassicCounter extends Object implements Serializable

serialVersionUID: 4L

Serialized Fields

map

Map<K,V> map

mapFactory

MapFactory<K,V> mapFactory

totalCount

double totalCount

defaultValue

double defaultValue

Class edu.stanford.nlp.stats.Distribution extends Object implements Serializable

serialVersionUID: 6707148234288637809L

Serialized Fields

numberOfKeys

int numberOfKeys

reservedMass

double reservedMass

counter

Counter<E> counter

Class edu.stanford.nlp.stats.GeneralizedCounter extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

map

Map<K,V> map

depth

int depth

total

double total

Class edu.stanford.nlp.stats.IntCounter extends AbstractCounter<E> implements Serializable

serialVersionUID: 4L

Serialized Fields

map

Map<K,V> map

mapFactory

MapFactory<K,V> mapFactory

totalCount

int totalCount

defaultValue

int defaultValue

Class edu.stanford.nlp.stats.TwoDimensionalCounter extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

map

Map<K,V> map

total

double total

outerMF

MapFactory<K,V> outerMF

innerMF

MapFactory<K,V> innerMF

defaultValue

double defaultValue

Package edu.stanford.nlp.swing

Class edu.stanford.nlp.swing.TooltipJList extends JList implements Serializable


Package edu.stanford.nlp.trees

Class edu.stanford.nlp.trees.AbstractCollinsHeadFinder extends Object implements Serializable

serialVersionUID: -6540278059442931087L

Serialized Fields

tlp

TreebankLanguagePack tlp

nonTerminalInfo

Map<K,V> nonTerminalInfo

defaultRule

String[] defaultRule
Default direction if no rule is found for category. Subclasses can turn it on if they like. If they don't it is an error if no rule is defined for a category (null is returned).


defaultLeftRule

String[] defaultLeftRule
These are built automatically from categoriesToAvoid and used in a fairly different fashion from defaultRule (above). These are used for categories that do have defined rules but where none of them have matched. Rather than picking the rightmost or leftmost child, we will use these to pick the the rightmost or leftmost child which isn't in categoriesToAvoid.


defaultRightRule

String[] defaultRightRule

Class edu.stanford.nlp.trees.AbstractTreebankLanguagePack extends Object implements Serializable

serialVersionUID: -6506749780512708352L

Serialized Fields

gfCharacter

char gfCharacter
Default character for indicating that something is a grammatical fn; probably should be overridden by lang specific ones


punctTagStringAcceptFilter

Filter<T> punctTagStringAcceptFilter

punctWordStringAcceptFilter

Filter<T> punctWordStringAcceptFilter

sFPunctTagStringAcceptFilter

Filter<T> sFPunctTagStringAcceptFilter

eIPunctTagStringAcceptFilter

Filter<T> eIPunctTagStringAcceptFilter

startSymbolAcceptFilter

Filter<T> startSymbolAcceptFilter

Class edu.stanford.nlp.trees.BobChrisTreeNormalizer extends TreeNormalizer implements Serializable

serialVersionUID: -1005188028979810143L

Serialized Fields

tlp

TreebankLanguagePack tlp

emptyFilter

Filter<T> emptyFilter

aOverAFilter

Filter<T> aOverAFilter

Class edu.stanford.nlp.trees.BobChrisTreeNormalizer.AOverAFilter extends Object implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.trees.BobChrisTreeNormalizer.EmptyFilter extends Object implements Serializable

serialVersionUID: 8914098359495987617L

Class edu.stanford.nlp.trees.CollinsHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: -8747319554557223437L

Class edu.stanford.nlp.trees.Dependencies.DependentPuncTagRejectFilter extends Object implements Serializable

serialVersionUID: -7732189363171164852L

Serialized Fields

tagRejectFilter

Filter<T> tagRejectFilter

Class edu.stanford.nlp.trees.Dependencies.DependentPuncWordRejectFilter extends Object implements Serializable

serialVersionUID: 1166489968248785287L

Serialized Fields

wordRejectFilter

Filter<T> wordRejectFilter

Class edu.stanford.nlp.trees.EnglishGrammaticalStructure extends GrammaticalStructure implements Serializable

serialVersionUID: -1866362375001969402L

Class edu.stanford.nlp.trees.GrammaticalFunctionTreeNormalizer extends TreeNormalizer implements Serializable

serialVersionUID: -2270472762938163327L

Serialized Fields

nodeCleanup

int nodeCleanup
How to clean up node labels: 0 = do nothing, 1 = keep category and function, 2 = just category.


root

String root

tlp

TreebankLanguagePack tlp

Class edu.stanford.nlp.trees.GrammaticalRelation extends Object implements Serializable

serialVersionUID: 892618003417550128L

Serialized Fields

language

GrammaticalRelation.Language language

shortName

String shortName

longName

String longName

parent

GrammaticalRelation parent

children

List<E> children

sourcePattern

Pattern sourcePattern

targetPatterns

List<E> targetPatterns

specific

String specific

Class edu.stanford.nlp.trees.GrammaticalStructure extends TreeGraph implements Serializable

serialVersionUID: 2286294455343892678L

Serialized Fields

dependencies

Set<E> dependencies

typedDependencies

List<E> typedDependencies

allTypedDependencies

List<E> allTypedDependencies

Class edu.stanford.nlp.trees.LabeledScoredTreeNode extends Tree implements Serializable

serialVersionUID: -8992385140984593817L

Serialized Fields

label

Label label
Label of the parse tree.


score

double score
Score of TreeNode


daughterTrees

Tree[] daughterTrees
Daughters of the parse tree.

Class edu.stanford.nlp.trees.LeftHeadFinder extends Object implements Serializable

serialVersionUID: 8453889846239508208L

Class edu.stanford.nlp.trees.ModCollinsHeadFinder extends CollinsHeadFinder implements Serializable

serialVersionUID: -5870387458902637256L

Class edu.stanford.nlp.trees.NamedDependency extends UnnamedDependency implements Serializable

serialVersionUID: -1635646451505721133L

Serialized Fields

name

Object name

Class edu.stanford.nlp.trees.NPTmpRetainingTreeNormalizer extends BobChrisTreeNormalizer implements Serializable

serialVersionUID: 7548777133196579107L

Serialized Fields

temporalAnnotation

int temporalAnnotation

doSGappedStuff

boolean doSGappedStuff

leaveItAll

int leaveItAll

doAdverbialNP

boolean doAdverbialNP

headFinder

HeadFinder headFinder

Class edu.stanford.nlp.trees.OrderedCombinationTreeNormalizer extends TreeNormalizer implements Serializable

serialVersionUID: 326L

Serialized Fields

tns

List<E> tns

Class edu.stanford.nlp.trees.PennTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable

serialVersionUID: 9081305982861675328L

Class edu.stanford.nlp.trees.SemanticHeadFinder extends ModCollinsHeadFinder implements Serializable

serialVersionUID: 5721799188009249808L

Serialized Fields

verbalAuxiliaries

HashSet<E> verbalAuxiliaries

copulars

HashSet<E> copulars

passiveAuxiliaries

HashSet<E> passiveAuxiliaries

verbalTags

HashSet<E> verbalTags

Class edu.stanford.nlp.trees.SimpleTree extends Tree implements Serializable

serialVersionUID: -8075763706877132926L

Serialized Fields

daughterTrees

Tree[] daughterTrees
Daughters of the parse tree.

Class edu.stanford.nlp.trees.Tree extends AbstractCollection<Tree> implements Serializable

serialVersionUID: 5441849457648722744L

Serialized Fields

score

double score

Class edu.stanford.nlp.trees.TreeGraph extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

root

TreeGraphNode root
The root node of this treegraph.


indexMap

Map<K,V> indexMap
A map from arbitrary integer indices to nodes.

Class edu.stanford.nlp.trees.TreeGraphNode extends Tree implements Serializable

serialVersionUID: 5080098143617475328L

Serialized Fields

label

CyclicCoreLabel label
Label for this node.


parent

TreeGraphNode parent
Parent of this node.


children

TreeGraphNode[] children
Children of this node.


tg

TreeGraph tg
The TreeGraph of which this node is part.

Class edu.stanford.nlp.trees.TreeNormalizer extends Object implements Serializable

serialVersionUID: 1540681875853883387L

Class edu.stanford.nlp.trees.TypedDependency extends Object implements Serializable

serialVersionUID: -7690294213151279779L

Serialized Fields

reln

GrammaticalRelation reln

gov

TreeGraphNode gov

dep

TreeGraphNode dep

extra

boolean extra

Class edu.stanford.nlp.trees.UnnamedConcreteDependency extends UnnamedDependency implements Serializable

serialVersionUID: -8836949694741145222L

Serialized Fields

headIndex

int headIndex

depIndex

int depIndex

Class edu.stanford.nlp.trees.UnnamedDependency extends Object implements Serializable

serialVersionUID: -3768440215342256085L

Serialized Fields

regentText

String regentText

dependentText

String dependentText

regent

Label regent

dependent

Label dependent

Package edu.stanford.nlp.trees.international.arabic

Class edu.stanford.nlp.trees.international.arabic.ArabicHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: 6203368998430280740L

Serialized Fields

tagSet

ArabicHeadFinder.TagSet tagSet

predPattern

Pattern predPattern

Class edu.stanford.nlp.trees.international.arabic.ArabicTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable

serialVersionUID: 9081305982861675328L

Class edu.stanford.nlp.trees.international.arabic.ArabicTreeNormalizer extends BobChrisTreeNormalizer implements Serializable

serialVersionUID: -1592231121068698494L

Serialized Fields

retainNPTmp

boolean retainNPTmp

retainNPSbj

boolean retainNPSbj

markPRDverb

boolean markPRDverb

changeNoLabels

boolean changeNoLabels

retainPPClr

boolean retainPPClr

prdPattern

Pattern prdPattern

prdVerbPattern

TregexPattern prdVerbPattern

npSbjPattern

TregexPattern npSbjPattern

rootLabel

String rootLabel

Class edu.stanford.nlp.trees.international.arabic.ArabicTreeNormalizer.ArabicEmptyFilter extends Object implements Serializable

serialVersionUID: 7417844982953945964L

Class edu.stanford.nlp.trees.international.arabic.ArabicTreeReaderFactory extends Object implements Serializable

serialVersionUID: 1973767605277873017L

Serialized Fields

retainNPTmp

boolean retainNPTmp

retainNPSbj

boolean retainNPSbj

retainPRD

boolean retainPRD

retainPPClr

boolean retainPPClr

changeNoLabels

boolean changeNoLabels

filterX

boolean filterX

noNormalization

boolean noNormalization

Class edu.stanford.nlp.trees.international.arabic.ArabicTreeReaderFactory.ArabicRawTreeReaderFactory extends ArabicTreeReaderFactory implements Serializable

serialVersionUID: -5693371540982097793L


Package edu.stanford.nlp.trees.international.french

Class edu.stanford.nlp.trees.international.french.DybroFrenchHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: 8798606577201646967L

Class edu.stanford.nlp.trees.international.french.FrenchHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: 8747319554557223422L

Class edu.stanford.nlp.trees.international.french.FrenchTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable

serialVersionUID: -7338244949063822519L

Class edu.stanford.nlp.trees.international.french.FrenchTreeNormalizer extends BobChrisTreeNormalizer implements Serializable

serialVersionUID: 7868735300308066991L

Serialized Fields

rootLabel

String rootLabel

Class edu.stanford.nlp.trees.international.french.FrenchTreeNormalizer.FrenchAOverAFilter extends Object implements Serializable

serialVersionUID: 793800623099852951L

Class edu.stanford.nlp.trees.international.french.FrenchTreeReaderFactory extends Object implements Serializable

serialVersionUID: 6928967570430642163L

Serialized Fields

readPennFormat

boolean readPennFormat

Package edu.stanford.nlp.trees.international.hebrew

Class edu.stanford.nlp.trees.international.hebrew.HebrewTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable

serialVersionUID: 4787589385598144401L

Class edu.stanford.nlp.trees.international.hebrew.HebrewTreeNormalizer extends BobChrisTreeNormalizer implements Serializable

serialVersionUID: -3129547164200725933L

Serialized Fields

hebrewEmptyFilter

Filter<T> hebrewEmptyFilter

Class edu.stanford.nlp.trees.international.hebrew.HebrewTreeNormalizer.HebrewEmptyFilter extends Object implements Serializable

serialVersionUID: -7256461296718287280L

Class edu.stanford.nlp.trees.international.hebrew.HebrewTreeReaderFactory extends Object implements Serializable

serialVersionUID: 818065349424602548L


Package edu.stanford.nlp.trees.international.negra

Class edu.stanford.nlp.trees.international.negra.NegraHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: -7253035927065152766L

Serialized Fields

coordSwitch

boolean coordSwitch

left

String left

right

String right

Class edu.stanford.nlp.trees.international.negra.NegraLabel extends StringLabel implements Serializable

serialVersionUID: 2847331882765391095L

Serialized Fields

edge

String edge

features

Map<K,V> features

Class edu.stanford.nlp.trees.international.negra.NegraPennLanguagePack extends AbstractTreebankLanguagePack implements Serializable

serialVersionUID: 9081305982861675328L

Serialized Fields

leaveGF

boolean leaveGF

Class edu.stanford.nlp.trees.international.negra.NegraPennTreeNormalizer extends TreeNormalizer implements Serializable

serialVersionUID: 8529514903815041064L

Serialized Fields

nodeCleanup

int nodeCleanup
How to clean up node labels: 0 = do nothing, 1 = keep category and function, 2 = just category


tlp

TreebankLanguagePack tlp

insertNPinPP

boolean insertNPinPP

emptyFilter

Filter<T> emptyFilter

aOverAFilter

Filter<T> aOverAFilter

prepositionTags

Set<E> prepositionTags

postpositionTags

Set<E> postpositionTags

Class edu.stanford.nlp.trees.international.negra.NegraPennTreeReaderFactory extends Object implements Serializable

serialVersionUID: 5731352106152470304L

Serialized Fields

nodeCleanup

int nodeCleanup

tlp

TreebankLanguagePack tlp

treeNormalizerInsertNPinPP

boolean treeNormalizerInsertNPinPP

Class edu.stanford.nlp.trees.international.negra.TigerHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: 4307594629124896496L

Serialized Fields

coordSwitch

boolean coordSwitch

left

String left

right

String right

Package edu.stanford.nlp.trees.international.pennchinese

Class edu.stanford.nlp.trees.international.pennchinese.BikelChineseHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: -5445795668059315082L

Class edu.stanford.nlp.trees.international.pennchinese.CharacterLevelTagExtender extends BobChrisTreeNormalizer implements Serializable

serialVersionUID: 7893996593626523700L

Class edu.stanford.nlp.trees.international.pennchinese.ChineseEnglishWordMap extends Object implements Serializable

serialVersionUID: 7655332268578049993L

Serialized Fields

map

Map<K,V> map

normalized

boolean normalized

Class edu.stanford.nlp.trees.international.pennchinese.ChineseHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: 6143632784691159283L

Class edu.stanford.nlp.trees.international.pennchinese.ChineseSemanticHeadFinder extends ChineseHeadFinder implements Serializable

serialVersionUID: 2L

Class edu.stanford.nlp.trees.international.pennchinese.ChineseTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable

serialVersionUID: 5757403475523638802L

Class edu.stanford.nlp.trees.international.pennchinese.CTBErrorCorrectingTreeNormalizer extends BobChrisTreeNormalizer implements Serializable

serialVersionUID: -8203853817025401845L

Serialized Fields

tagExtender

TreeTransformer tagExtender

splitNPTMP

boolean splitNPTMP

splitPPTMP

boolean splitPPTMP

splitXPTMP

boolean splitXPTMP

chineseEmptyFilter

Filter<T> chineseEmptyFilter

Class edu.stanford.nlp.trees.international.pennchinese.SunJurafskyChineseHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: -7942375587642755210L


Package edu.stanford.nlp.trees.international.tuebadz

Class edu.stanford.nlp.trees.international.tuebadz.TueBaDZHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: 1L

Serialized Fields

left

String left

right

String right

coordSwitch

boolean coordSwitch

headMarkedPattern

Pattern headMarkedPattern

headMarkedPattern2

Pattern headMarkedPattern2

Class edu.stanford.nlp.trees.international.tuebadz.TueBaDZLanguagePack extends AbstractTreebankLanguagePack implements Serializable

serialVersionUID: 2697418320262700673L

Serialized Fields

limitedGF

boolean limitedGF

leaveGF

boolean leaveGF

Class edu.stanford.nlp.trees.international.tuebadz.TueBaDZPennTreeNormalizer extends TreeNormalizer implements Serializable

serialVersionUID: 8009544230321390490L

Serialized Fields

nodeCleanup

int nodeCleanup
How to clean up node labels: 0 = do nothing, 1 = keep category and function, 2 = just category.


root

String root

tlp

TreebankLanguagePack tlp

tns

List<E> tns

Class edu.stanford.nlp.trees.international.tuebadz.TueBaDZTreeReaderFactory extends Object implements Serializable

serialVersionUID: 1614799885744961795L

Serialized Fields

tlp

TreebankLanguagePack tlp

nodeCleanup

int nodeCleanup

Package edu.stanford.nlp.trees.semgraph

Class edu.stanford.nlp.trees.semgraph.SemanticGraph extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

roots

Collection<E> roots
The distinguished root vertices, if known.


graph

DirectedMultiGraph<V,E> graph

Class edu.stanford.nlp.trees.semgraph.SemanticGraphEdge extends Object implements Serializable

serialVersionUID: 2L

Serialized Fields

relation

GrammaticalRelation relation

weight

double weight

source

IndexedWord source

target

IndexedWord target

Package edu.stanford.nlp.trees.tregex

Class edu.stanford.nlp.trees.tregex.ParseException extends Exception implements Serializable

serialVersionUID: 1L

Serialized Fields

currentToken

edu.stanford.nlp.trees.tregex.Token currentToken
This is the last token that has been consumed successfully. If this object has been created due to a parse error, the token followng this token will (therefore) be the first error token.


expectedTokenSequences

int[][] expectedTokenSequences
Each entry in this array is an array of integers. Each array of integers represents a sequence of tokens (by their ordinal values) that is expected at this point of the parse.


tokenImage

String[] tokenImage
This is a reference to the "tokenImage" array of the generated parser within which the parse error occurred. This array is defined in the generated ...Constants interface.


eol

String eol
The end of line string for this machine.

Class edu.stanford.nlp.trees.tregex.TregexParseException extends RuntimeException implements Serializable

Class edu.stanford.nlp.trees.tregex.TregexPattern extends Object implements Serializable

serialVersionUID: 5060298043763944913L

Serialized Fields

neg

boolean neg

opt

boolean opt

patternString

String patternString

Package edu.stanford.nlp.trees.tregex.gui

Class edu.stanford.nlp.trees.tregex.gui.DisplayMatchesPanel extends JPanel implements Serializable

Serialized Fields

scroller

JScrollPane scroller

firstMouseEvent

MouseEvent firstMouseEvent

fontName

String fontName

fontSize

int fontSize

defaultColor

Color defaultColor

matchedColor

Color matchedColor

tjp

ScrollableTreeJPanel tjp

Class edu.stanford.nlp.trees.tregex.gui.FilePanel extends JPanel implements Serializable

serialVersionUID: -2229250395240163264L

Serialized Fields

tree

JTree tree

treeModel

FileTreeModel treeModel

Class edu.stanford.nlp.trees.tregex.gui.FileTreeModel extends DefaultTreeModel implements Serializable

Serialized Fields

listeners

List<E> listeners

root

FileTreeNode root

treeStructure

HashMap<K,V> treeStructure

Class edu.stanford.nlp.trees.tregex.gui.FileTreeNode extends DefaultMutableTreeNode implements Serializable

Serialized Fields

file

File file

check

JCheckBox check

label

JLabel label

t

Treebank t

listeners

ArrayList<E> listeners

Class edu.stanford.nlp.trees.tregex.gui.InputPanel extends JPanel implements Serializable

serialVersionUID: -8219840036914495876L

Serialized Fields

foundStats

JLabel foundStats

findMatches

JButton findMatches

cancel

JButton cancel

help

JButton help

tregexPattern

JTextArea tregexPattern

recentTregexPatterns

JComboBox recentTregexPatterns

numRecentPatterns

int numRecentPatterns

tsurgeonScript

JTextArea tsurgeonScript

compiler

TregexPatternCompiler compiler

historyList

List<E> historyList

historyFrame

JFrame historyFrame

scriptLabel

JLabel scriptLabel

tsurgeonEnabled

boolean tsurgeonEnabled

tsurgeonHelp

JButton tsurgeonHelp

cancelTsurgeon

JButton cancelTsurgeon

searchThread

Thread searchThread

historyButton

JButton historyButton

progressBar

JProgressBar progressBar

browseButton

JButton browseButton

helpFrame

JFrame helpFrame

tsurgeonHelpFrame

JFrame tsurgeonHelpFrame

runScript

JButton runScript

Class edu.stanford.nlp.trees.tregex.gui.MatchesPanel extends JPanel implements Serializable

Serialized Fields

list

JList list

matchedParts

HashMap<K,V> matchedParts

listeners

List<E> listeners

highlightColor

Color highlightColor

showOnlyMatchedPortion

boolean showOnlyMatchedPortion

lastSelected

JTextField lastSelected

firstMouseEvent

MouseEvent firstMouseEvent

maxMatches

int maxMatches

Class edu.stanford.nlp.trees.tregex.gui.PreferencesPanel extends JDialog implements Serializable

Serialized Fields

highlightButton

JButton highlightButton

setEncoding

JTextField setEncoding

Class edu.stanford.nlp.trees.tregex.gui.ScrollableTreeJPanel extends TreeJPanel implements Serializable

Serialized Fields

fontSize

int fontSize

defaultColor

Color defaultColor

matchedColor

Color matchedColor

tdiffColor

Color tdiffColor

fontName

String fontName

style

int style

preferredSize

Dimension preferredSize

matchedParts

List<E> matchedParts

leafCtr

int leafCtr

yieldHeight

double yieldHeight

yieldOffsets

float[] yieldOffsets

diffConstituents

Set<E> diffConstituents

Class edu.stanford.nlp.trees.tregex.gui.TregexGUI extends JFrame implements Serializable

Serialized Fields

preferences

JMenuItem preferences

loadFiles

JMenuItem loadFiles

saveMatches

JMenuItem saveMatches

saveSentences

JMenuItem saveSentences

saveHistory

JMenuItem saveHistory

loadTsurgeon

JMenuItem loadTsurgeon

tDiff

JMenuItem tDiff

quit

JMenuItem quit

copy

JMenuItem copy

clearFileList

JMenuItem clearFileList

chooser

JFileChooser chooser

preferenceDialog

JDialog preferenceDialog

aboutBox

JDialog aboutBox

doTdiff

boolean doTdiff

Package edu.stanford.nlp.trees.tregex.tsurgeon

Class edu.stanford.nlp.trees.tregex.tsurgeon.ParseException extends Exception implements Serializable

serialVersionUID: 1L

Serialized Fields

currentToken

edu.stanford.nlp.trees.tregex.tsurgeon.Token currentToken
This is the last token that has been consumed successfully. If this object has been created due to a parse error, the token followng this token will (therefore) be the first error token.


expectedTokenSequences

int[][] expectedTokenSequences
Each entry in this array is an array of integers. Each array of integers represents a sequence of tokens (by their ordinal values) that is expected at this point of the parse.


tokenImage

String[] tokenImage
This is a reference to the "tokenImage" array of the generated parser within which the parse error occurred. This array is defined in the generated ...Constants interface.


eol

String eol
The end of line string for this machine.

Class edu.stanford.nlp.trees.tregex.tsurgeon.TsurgeonParseException extends RuntimeException implements Serializable


Package edu.stanford.nlp.util

Class edu.stanford.nlp.util.ArrayCoreMap extends Object implements Serializable

serialVersionUID: 1L

Serialization Methods

writeObject

private void writeObject(ObjectOutputStream out)
                  throws IOException
Overridden serialization method: compacts our map before writing.

Throws:
IOException - If IO error
Serialized Fields

keys

Class<T>[] keys
Array of keys


values

Object[] values
Array of values


size

int size
Total number of elements actually in keys,values

Class edu.stanford.nlp.util.ArrayMap extends AbstractMap<K,V> implements Serializable

serialVersionUID: 1L

Serialized Fields

entryArray

edu.stanford.nlp.util.ArrayMap.Entry<K,V>[] entryArray

capacity

int capacity

size

int size

hashCodeCache

int hashCodeCache

Class edu.stanford.nlp.util.CollectionFactory extends Object implements Serializable

serialVersionUID: 3711321773145894069L

Class edu.stanford.nlp.util.CollectionFactory.ArrayListFactory extends CollectionFactory<T> implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.util.CollectionFactory.HashSetFactory extends CollectionFactory<T> implements Serializable

serialVersionUID: -6268401669449458602L

Class edu.stanford.nlp.util.CollectionFactory.LinkedListFactory extends CollectionFactory<T> implements Serializable

serialVersionUID: -4236184979948498000L

Class edu.stanford.nlp.util.CollectionFactory.SizedArrayListFactory extends CollectionFactory<T> implements Serializable

serialVersionUID: 1L

Serialized Fields

defaultSize

int defaultSize

Class edu.stanford.nlp.util.CollectionFactory.TreeSetFactory extends CollectionFactory<T> implements Serializable

serialVersionUID: -3451920268219478134L

Class edu.stanford.nlp.util.CollectionValuedMap extends Object implements Serializable

serialVersionUID: -9064664153962599076L

Serialized Fields

map

Map<K,V> map

cf

CollectionFactory<T> cf

treatCollectionsAsImmutable

boolean treatCollectionsAsImmutable

mf

MapFactory<K,V> mf

emptyValue

Collection<E> emptyValue
The empty collection to be returned when a get doesn't find the key. The collection returned should be empty, such as Collections.emptySet, for example.

Class edu.stanford.nlp.util.DeltaCollectionValuedMap extends CollectionValuedMap<K,V> implements Serializable

serialVersionUID: 1L

Serialized Fields

originalMap

CollectionValuedMap<K,V> originalMap

deltaMap

Map<K,V> deltaMap

Class edu.stanford.nlp.util.DeltaIndex extends AbstractCollection<E> implements Serializable

serialVersionUID: -1459230891686013411L

Serialized Fields

backingIndex

Index<E> backingIndex

spilloverIndex

Index<E> spilloverIndex

backingIndexSize

int backingIndexSize

locked

boolean locked

Class edu.stanford.nlp.util.FixedPrioritiesPriorityQueue extends AbstractSet<E> implements Serializable

serialVersionUID: 1L

Serialized Fields

size

int size

capacity

int capacity

elements

List<E> elements

priorities

double[] priorities

Class edu.stanford.nlp.util.HashableCoreMap extends ArrayCoreMap implements Serializable

serialVersionUID: 1L

Serialized Fields

immutableKeys

Set<E> immutableKeys
Set of immutable keys


hashcode

int hashcode
Pre-computed hashcode

Class edu.stanford.nlp.util.HashableCoreMap.HashableCoreMapException extends RuntimeException implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.util.HashIndex extends AbstractCollection<E> implements Serializable

serialVersionUID: 5398562825928375260L

Serialized Fields

objects

ArrayList<E> objects

indexes

HashMap<K,V> indexes

locked

boolean locked

semaphore

Semaphore semaphore

Class edu.stanford.nlp.util.IdentityHashSet extends AbstractSet<E> implements Serializable

serialVersionUID: -5024744406713321676L

Serialization Methods

readObject

private void readObject(ObjectInputStream s)
                 throws IOException,
                        ClassNotFoundException
Deserialize this Object in a manner which is binary-compatible with the JDK.

Throws:
IOException
ClassNotFoundException

writeObject

private void writeObject(ObjectOutputStream s)
                  throws IOException
Serialize this Object in a manner which is binary-compatible with the JDK.

Throws:
IOException

Class edu.stanford.nlp.util.Interval extends Pair<E extends Comparable<E>,E extends Comparable<E>> implements Serializable

Serialized Fields

flags

int flags

Class edu.stanford.nlp.util.IntPair extends IntTuple implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.util.IntQuadruple extends IntTuple implements Serializable

serialVersionUID: 7154973101012473479L

Class edu.stanford.nlp.util.IntTriple extends IntTuple implements Serializable

serialVersionUID: -3744404627253652799L

Class edu.stanford.nlp.util.IntTuple extends Object implements Serializable

serialVersionUID: 7266305463893511982L

Serialized Fields

elements

int[] elements

Class edu.stanford.nlp.util.IntUni extends IntTuple implements Serializable

serialVersionUID: -7182556672628741200L

Class edu.stanford.nlp.util.MapFactory extends Object implements Serializable

serialVersionUID: 4529666940763477360L

Class edu.stanford.nlp.util.MetaClass.ClassCreationException extends RuntimeException implements Serializable

serialVersionUID: -5980065992461870357L

Class edu.stanford.nlp.util.MetaClass.ConstructorNotFoundException extends MetaClass.ClassCreationException implements Serializable

serialVersionUID: -5980065992461870357L

Class edu.stanford.nlp.util.MutableDouble extends Number implements Serializable

serialVersionUID: 624465615824626762L

Serialized Fields

d

double d

Class edu.stanford.nlp.util.MutableInteger extends Number implements Serializable

serialVersionUID: 624465615824626762L

Serialized Fields

i

int i

Class edu.stanford.nlp.util.Pair extends Object implements Serializable

serialVersionUID: 1360822168806852921L

Serialized Fields

first

Object first
Direct access is deprecated. Use first().

 

second

Object second
Direct access is deprecated. Use second().

 

Class edu.stanford.nlp.util.ReflectionLoading.ReflectionLoadingException extends RuntimeException implements Serializable

Class edu.stanford.nlp.util.ScoredComparator extends Object implements Serializable

serialVersionUID: 1L

Serialized Fields

ascending

boolean ascending

Class edu.stanford.nlp.util.StringParsingTask.ParserException extends RuntimeException implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.util.Triple extends Object implements Serializable

serialVersionUID: -4182871682751645440L

Serialized Fields

first

Object first

second

Object second

third

Object third



Stanford NLP Group