public void GetShortestRoute_should_consider_routes_in_order_from_small_distance() { using (new IndirectionsContext()) { // Arrange var slot = 0; var numAndDistances = new[] { 4, 2, 4, 3, 1, 6, 7 }; PRandom.NextInt32().Body = (@this, maxValue) => numAndDistances[slot++]; var vil = new Village(); var considerations = new List<RicePaddy>(); PList<RicePaddy>.AddT().Body = (@this, item) => { IndirectionsContext.ExecuteOriginal(() => { considerations.Add(item); @this.Add(item); }); }; // Act var result = vil.GetShortestRoute(vil.RicePaddies.ElementAt(2), vil.RicePaddies.ElementAt(0)); // Assert Assert.AreEqual(3, result.TotalDistance); Assert.AreEqual(4, considerations.Count); Assert.AreEqual(2, considerations[0].Identifier); Assert.AreEqual(1, considerations[1].Identifier); Assert.AreEqual(0, considerations[2].Identifier); Assert.AreEqual(3, considerations[3].Identifier); } }
/// <summary>Main method of mention detection.</summary> /// <remarks> /// Main method of mention detection. /// Extract all NP, PRP or NE, and filter out by manually written patterns. /// </remarks> public override IList <IList <Mention> > FindMentions(Annotation doc, Dictionaries dict, Properties props) { IList <IList <Mention> > predictedMentions = new List <IList <Mention> >(); ICollection <string> neStrings = Generics.NewHashSet(); IList <ICollection <IntPair> > mentionSpanSetList = Generics.NewArrayList(); IList <ICoreMap> sentences = doc.Get(typeof(CoreAnnotations.SentencesAnnotation)); // extract premarked mentions, NP/PRP, named entity, enumerations foreach (ICoreMap s in sentences) { IList <Mention> mentions = new List <Mention>(); predictedMentions.Add(mentions); ICollection <IntPair> mentionSpanSet = Generics.NewHashSet(); ICollection <IntPair> namedEntitySpanSet = Generics.NewHashSet(); ExtractPremarkedEntityMentions(s, mentions, mentionSpanSet, namedEntitySpanSet); ExtractNamedEntityMentions(s, mentions, mentionSpanSet, namedEntitySpanSet); ExtractNPorPRP(s, mentions, mentionSpanSet, namedEntitySpanSet); ExtractEnumerations(s, mentions, mentionSpanSet, namedEntitySpanSet); AddNamedEntityStrings(s, neStrings, namedEntitySpanSet); mentionSpanSetList.Add(mentionSpanSet); } if (CorefProperties.LiberalMD(props)) { ExtractNamedEntityModifiers(sentences, mentionSpanSetList, predictedMentions, neStrings); } // find head for (int i = 0; i < sz; i++) { FindHead(sentences[i], predictedMentions[i]); SetBarePlural(predictedMentions[i]); } // mention selection based on document-wise info if (lang == Locale.English && !CorefProperties.LiberalMD(props)) { RemoveSpuriousMentionsEn(doc, predictedMentions, dict); } else { if (lang == Locale.Chinese) { if (CorefProperties.LiberalMD(props)) { RemoveSpuriousMentionsZhSimple(doc, predictedMentions, dict); } else { RemoveSpuriousMentionsZh(doc, predictedMentions, dict, CorefProperties.RemoveNestedMentions(props)); } } } return(predictedMentions); }
/// <summary>Reads an annotation from the given filename using the requested input.</summary> public static IList <Annotation> GetAnnotations(StanfordCoreNLP tokenizer, SentimentPipeline.Input inputFormat, string filename, bool filterUnknown) { switch (inputFormat) { case SentimentPipeline.Input.Text: { string text = IOUtils.SlurpFileNoExceptions(filename); Annotation annotation = new Annotation(text); tokenizer.Annotate(annotation); IList <Annotation> annotations = Generics.NewArrayList(); foreach (ICoreMap sentence in annotation.Get(typeof(CoreAnnotations.SentencesAnnotation))) { Annotation nextAnnotation = new Annotation(sentence.Get(typeof(CoreAnnotations.TextAnnotation))); nextAnnotation.Set(typeof(CoreAnnotations.SentencesAnnotation), Java.Util.Collections.SingletonList(sentence)); annotations.Add(nextAnnotation); } return(annotations); } case SentimentPipeline.Input.Trees: { IList <Tree> trees; if (filterUnknown) { trees = SentimentUtils.ReadTreesWithGoldLabels(filename); trees = SentimentUtils.FilterUnknownRoots(trees); } else { MemoryTreebank treebank = new MemoryTreebank("utf-8"); treebank.LoadPath(filename, null); trees = new List <Tree>(treebank); } IList <Annotation> annotations = Generics.NewArrayList(); foreach (Tree tree in trees) { ICoreMap sentence = new Annotation(SentenceUtils.ListToString(tree.Yield())); sentence.Set(typeof(TreeCoreAnnotations.TreeAnnotation), tree); IList <ICoreMap> sentences = Java.Util.Collections.SingletonList(sentence); Annotation annotation = new Annotation(string.Empty); annotation.Set(typeof(CoreAnnotations.SentencesAnnotation), sentences); annotations.Add(annotation); } return(annotations); } default: { throw new ArgumentException("Unknown format " + inputFormat); } } }
private static IDictionary <string, int> ArgOptionDefs() { IDictionary <string, int> argOptionDefs = Generics.NewHashMap(); argOptionDefs["help"] = 0; argOptionDefs["ftb"] = 0; argOptionDefs["ancora"] = 0; argOptionDefs["lowerCase"] = 0; argOptionDefs["encoding"] = 1; argOptionDefs["options"] = 1; argOptionDefs["tokens"] = 0; return(argOptionDefs); }
/// <summary> /// Rotates the given Vector around the zero point. /// </summary> /// <param name="vector">The vector to rotate.</param> /// <returns>The rotated vector.</returns> public Vector RotateVector(Vector vector) { double tolerance = Generics.GetTolerance(this, vector); if (Radians.IsZeroSign(tolerance)) { return(vector); } Angle completeAngle = CreateFromVector(vector) + Radians; return(completeAngle.GetDirectionVector() * vector.Magnitude()); }
private static IDictionary <string, TokenizerAnnotator.TokenizerType> InitializeClassMap() { IDictionary <string, TokenizerAnnotator.TokenizerType> map = Generics.NewHashMap(); foreach (TokenizerAnnotator.TokenizerType type in TokenizerAnnotator.TokenizerType.Values()) { if (type.className != null) { map[type.className.ToUpper()] = type; } } return(Java.Util.Collections.UnmodifiableMap(map)); }
static IOBUtils() { // Training token types. // Label inventory // Patterns for tokens that should not be segmented. // Sets of known clitics for tagging when reconstructing the segmented sequences. string arabicPrefixString = "ل ف و م ما ح حا ه ها ك ب س"; arPrefixSet = Java.Util.Collections.UnmodifiableSet(Generics.NewHashSet(Arrays.AsList(arabicPrefixString.Split("\\s+")))); string arabicSuffixString = "ل و ما ه ها هم هن نا كم تن تم ى ي هما ك ب ش"; arSuffixSet = Java.Util.Collections.UnmodifiableSet(Generics.NewHashSet(Arrays.AsList(arabicSuffixString.Split("\\s+")))); }
public static ICollection <string> GetUnaryMatrixNames(IList <IDictionary <string, SimpleMatrix> > maps) { ICollection <string> matrixNames = Generics.NewHashSet(); foreach (IDictionary <string, SimpleMatrix> map in maps) { foreach (KeyValuePair <string, SimpleMatrix> entry in map) { matrixNames.Add(entry.Key); } } return(matrixNames); }
public void ToString(StringBuilder sb) { ReturnType.ToString(sb); sb.Append(" "); if (ExplicitInterface != null) { sb.Append(ExplicitInterface); sb.Append('.'); } sb.Append(Name); Generics.ToString(sb); Parameters.ToString(sb); }
/// <summary>Get all of the states which *only* occur at the root.</summary> /// <remarks> /// Get all of the states which *only* occur at the root. Useful for /// knowing which transitions can't be done internal to the tree /// </remarks> private static ICollection <string> FindRootOnlyStates(IList <Tree> trees, ICollection <string> rootStates) { ICollection <string> rootOnlyStates = Generics.NewHashSet(rootStates); foreach (Tree tree in trees) { foreach (Tree child in tree.Children()) { FindRootOnlyStatesHelper(child, rootStates, rootOnlyStates); } } return(Java.Util.Collections.UnmodifiableSet(rootOnlyStates)); }
/// <summary>Returns the set of keys that have exactly the given count.</summary> /// <remarks> /// Returns the set of keys that have exactly the given count. /// This set may have 0 elements but will not be null. /// </remarks> public virtual ICollection <E> KeysAt(int count) { ICollection <E> keys = Generics.NewHashSet(); foreach (E key in map.Keys) { if (GetIntCount(key) == count) { keys.Add(key); } } return(keys); }
private Type GetSubTypeAsModelType(ParseContext context) { Type returnType = GetReturnType(context); try { return(Generics.GetParameterType(returnType)); } catch (ArgumentException) { return(returnType); } }
public virtual ICollection <K2> SecondKeySet() { ICollection <K2> result = Generics.NewHashSet(); foreach (K1 k1 in FirstKeySet()) { foreach (K2 k2 in GetCounter(k1).KeySet()) { result.Add(k2); } } return(result); }
private static IDictionary <string, int> OptionArgDefs() { IDictionary <string, int> optionArgDefs = Generics.NewHashMap(); optionArgDefs["v"] = 0; optionArgDefs["l"] = 1; optionArgDefs["y"] = 1; optionArgDefs["s"] = 1; optionArgDefs["c"] = 0; optionArgDefs["e"] = 0; optionArgDefs["f"] = 1; return(optionArgDefs); }
public CorefCluster(int Id) { clusterID = Id; corefMentions = Generics.NewHashSet(); numbers = EnumSet.NoneOf <Dictionaries.Number>(); genders = EnumSet.NoneOf <Dictionaries.Gender>(); animacies = EnumSet.NoneOf <Dictionaries.Animacy>(); nerStrings = Generics.NewHashSet(); heads = Generics.NewHashSet(); words = Generics.NewHashSet(); firstMention = null; representative = null; }
/// <summary>Constructor.</summary> /// <param name="r"/> /// <param name="tf"/> /// <param name="lexerProperties"/> /// <param name="splitCompounds"/> public FrenchTokenizer(Reader r, ILexedTokenFactory <T> tf, Properties lexerProperties, bool splitCompounds, bool splitContractions) { // The underlying JFlex lexer // Internal fields compound splitting // Produces the tokenization for parsing used by Green, de Marneffe, and Manning (2011) lexer = new FrenchLexer(r, tf, lexerProperties); this.splitCompounds = splitCompounds; this.splitContractions = splitContractions; if (splitCompounds || splitContractions) { compoundBuffer = Generics.NewLinkedList(); } }
/// <summary>Given a file name, reads in those trees and returns them as a List</summary> public static IList <Tree> ReadTreesWithLabels(string path, Type annotationClass) { IList <Tree> trees = Generics.NewArrayList(); MemoryTreebank treebank = new MemoryTreebank("utf-8"); treebank.LoadPath(path, null); foreach (Tree tree in treebank) { AttachLabels(tree, annotationClass); trees.Add(tree); } return(trees); }
protected internal static ICollection <TransducerGraph.Arc> Difference(ICollection <TransducerGraph.Arc> block, ICollection <TransducerGraph.Arc> members) { ICollection <TransducerGraph.Arc> difference = Generics.NewHashSet(); foreach (TransducerGraph.Arc member in block) { if (!members.Contains(member)) { difference.Add(member); } } return(difference); }
public AbishekFrenchHeadFinder(FrenchTreebankLanguagePack tlp) : base(tlp) { //French POS: // A (adjective), ADV (adverb), C (conjunction and subordinating conjunction), CL (clitics), // CS (subordinating conjunction) but occurs only once!, // D (determiner), ET (foreign word), I (interjection), N (noun), // P (preposition), PREF (prefix), PRO (strong pronoun -- very confusing), V (verb), PUNC (punctuation) nonTerminalInfo = Generics.NewHashMap(); // "sentence" nonTerminalInfo[tlp.StartSymbol()] = new string[][] { new string[] { "left", "VN", "V", "NP", "Srel", "Ssub", "Sint" } }; nonTerminalInfo["SENT"] = new string[][] { new string[] { "left", "VN", "V", "NP", "Srel", "Ssub", "Sint" } }; // adjectival phrases nonTerminalInfo["AP"] = new string[][] { new string[] { "right", "A", "N", "V" } }; // adverbial phrases nonTerminalInfo["AdP"] = new string[][] { new string[] { "right", "ADV" }, new string[] { "left", "P", "D", "C" } }; // coordinated phrases nonTerminalInfo["COORD"] = new string[][] { new string[] { "left", "C" }, new string[] { "right" } }; // noun phrases nonTerminalInfo["NP"] = new string[][] { new string[] { "right", "N", "PRO", "A", "ADV" }, new string[] { "left", "NP" }, new string[] { "right" } }; // prepositional phrases nonTerminalInfo["PP"] = new string[][] { new string[] { "right", "P", "CL", "A", "ADV", "V", "N" } }; // verbal nucleus nonTerminalInfo["VN"] = new string[][] { new string[] { "right", "V" } }; // infinitive clauses nonTerminalInfo["VPinf"] = new string[][] { new string[] { "left", "VN", "V" }, new string[] { "right" } }; // nonfinite clauses nonTerminalInfo["VPpart"] = new string[][] { new string[] { "left", "VN", "V" }, new string[] { "right" } }; // relative clauses nonTerminalInfo["Srel"] = new string[][] { new string[] { "left", "VN", "V" } }; // subordinate clauses nonTerminalInfo["Ssub"] = new string[][] { new string[] { "left", "VN", "V" }, new string[] { "right" } }; // parenthetical clauses nonTerminalInfo["Sint"] = new string[][] { new string[] { "left", "VN", "V" }, new string[] { "right" } }; // adverbes //nonTerminalInfo.put("ADV", new String[][] {{"left", "ADV", "PP", "P"}}); // compound categories: start with MW: D, A, C, N, ADV, V, P, PRO, CL nonTerminalInfo["MWD"] = new string[][] { new string[] { "left", "D" }, new string[] { "left" } }; nonTerminalInfo["MWA"] = new string[][] { new string[] { "left", "P" }, new string[] { "left", "N" }, new string[] { "right", "A" }, new string[] { "right" } }; nonTerminalInfo["MWC"] = new string[][] { new string[] { "left", "C", "CS" }, new string[] { "left" } }; nonTerminalInfo["MWN"] = new string[][] { new string[] { "right", "N", "ET" }, new string[] { "right" } }; nonTerminalInfo["MWV"] = new string[][] { new string[] { "left", "V" }, new string[] { "left" } }; nonTerminalInfo["MWP"] = new string[][] { new string[] { "left", "P", "ADV", "PRO" }, new string[] { "left" } }; nonTerminalInfo["MWPRO"] = new string[][] { new string[] { "left", "PRO", "CL", "N", "A" }, new string[] { "left" } }; nonTerminalInfo["MWCL"] = new string[][] { new string[] { "left", "CL" }, new string[] { "right" } }; nonTerminalInfo["MWADV"] = new string[][] { new string[] { "left", "P", "ADV" }, new string[] { "left" } }; nonTerminalInfo["MWI"] = new string[][] { new string[] { "left", "N", "ADV", "P" }, new string[] { "left" } }; nonTerminalInfo["MWET"] = new string[][] { new string[] { "left", "ET", "N" }, new string[] { "left" } }; //TODO: wsg2011: For phrasal nodes that lacked a label. nonTerminalInfo[FrenchXMLTreeReader.MissingPhrasal] = new string[][] { new string[] { "left" } }; }
private void ComputeEmpiricalStatistics(IList <F> geFeatures) { //allocate memory to the containers and initialize them geFeature2EmpiricalDist = new double[][] { }; geFeature2DatumList = new List <IList <int> >(geFeatures.Count); IDictionary <F, int> geFeatureMap = Generics.NewHashMap(); ICollection <int> activeUnlabeledExamples = Generics.NewHashSet(); for (int n = 0; n < geFeatures.Count; n++) { F geFeature = geFeatures[n]; geFeature2DatumList.Add(new List <int>()); Arrays.Fill(geFeature2EmpiricalDist[n], 0); geFeatureMap[geFeature] = n; } //compute the empirical label distribution for each GE feature for (int i = 0; i < labeledDataset.Size(); i++) { IDatum <L, F> datum = labeledDataset.GetDatum(i); int labelID = labeledDataset.labelIndex.IndexOf(datum.Label()); foreach (F feature in datum.AsFeatures()) { if (geFeatureMap.Contains(feature)) { int geFnum = geFeatureMap[feature]; geFeature2EmpiricalDist[geFnum][labelID]++; } } } //now normalize and smooth the label distribution for each feature. for (int n_1 = 0; n_1 < geFeatures.Count; n_1++) { ArrayMath.Normalize(geFeature2EmpiricalDist[n_1]); SmoothDistribution(geFeature2EmpiricalDist[n_1]); } //now build the inverted index from each GE feature to unlabeled datums that contain it. for (int i_1 = 0; i_1 < unlabeledDataList.Count; i_1++) { IDatum <L, F> datum = unlabeledDataList[i_1]; foreach (F feature in datum.AsFeatures()) { if (geFeatureMap.Contains(feature)) { int geFnum = geFeatureMap[feature]; geFeature2DatumList[geFnum].Add(i_1); activeUnlabeledExamples.Add(i_1); } } } System.Console.Out.WriteLine("Number of active unlabeled examples:" + activeUnlabeledExamples.Count); }
public virtual void Run(bool pathsAreFiles, bool displayWords, bool displayOOV) { if (useSplit) { IList <TreebankStats.ObservedCorpusStats> allSplitStats = new List <TreebankStats.ObservedCorpusStats>(); makeVocab = true; foreach (KeyValuePair <TreebankStats.Split, ICollection <string> > split in splitFileLists) { DiskTreebank tb = tlpp.DiskTreebank(); IFileFilter splitFilter = new TreebankStats.SplitFilter(split.Value); foreach (string path in pathNames) { tb.LoadPath(path, splitFilter); } TreebankStats.ObservedCorpusStats splitStats = GatherStats(tb, languageName.ToString() + "." + split.Key.ToString()); allSplitStats.Add(splitStats); makeVocab = false; } Display(AggregateStats(allSplitStats), displayWords, displayOOV); foreach (TreebankStats.ObservedCorpusStats ocs in allSplitStats) { Display(ocs, displayWords, displayOOV); } } else { if (pathsAreFiles) { makeVocab = true; foreach (string path in pathNames) { DiskTreebank tb = tlpp.DiskTreebank(); tb.LoadPath(path, null); TreebankStats.ObservedCorpusStats stats = GatherStats(tb, languageName.ToString() + " " + path); Display(stats, displayWords, displayOOV); makeVocab = false; } } else { trainVocab = Generics.NewHashSet(); DiskTreebank tb = tlpp.DiskTreebank(); foreach (string path in pathNames) { tb.LoadPath(path, null); } TreebankStats.ObservedCorpusStats allStats = GatherStats(tb, languageName.ToString()); Display(allStats, displayWords, displayOOV); } } }
internal bool RegisterGeneric(TypeSig t) { Debug.Assert(t != null, $"{nameof(t)} != null"); // This is a temporary fix. // Type visibility should be handled in a much better way which would involved some analysis. var typeDef = t.ToTypeDefOrRef().ResolveTypeDef(); if (typeDef != null && !typeDef.IsVisibleOutside()) { return(false); } // Get proper type. t = SignatureUtils.GetLeaf(t); if (!Generics.ContainsKey(t)) { GenericParam newGenericParam; if (t.IsGenericMethodParameter) { var mVar = t.ToGenericMVar(); Debug.Assert(mVar != null, $"{nameof(mVar)} != null"); newGenericParam = new GenericParamUser(GenericCount, mVar.GenericParam.Flags, $"T{GenericCount}") { Rid = mVar.Rid }; } else if (t.IsGenericTypeParameter) { var tVar = t.ToGenericVar(); Debug.Assert(tVar != null, $"{nameof(tVar)} != null"); newGenericParam = new GenericParamUser(GenericCount, tVar.GenericParam.Flags, $"T{GenericCount}") { Rid = tVar.Rid }; } else { newGenericParam = new GenericParamUser(GenericCount, GenericParamAttributes.NoSpecialConstraint, $"T{GenericCount}"); } Generics.Add(t, newGenericParam); GenericCount++; _trueTypes.Add(t); return(true); } else { return(false); } }
protected void btnUpdateItem_Click(object sender, CommandEventArgs e) { try { byte quantity = 1; quantity = byte.Parse(Generics.IfNullString(((DropDownList)((LinkButton)sender).NamingContainer.FindControl("ddlQuantity")).SelectedValue)); Mediator.doUpdateCartItemQuantity(int.Parse(Generics.IfNullString(e.CommandArgument)), quantity); Response.Redirect(Request.RawUrl); } catch { ; } }
public SpanishHeadFinder(ITreebankLanguagePack tlp) : base(tlp) { nonTerminalInfo = Generics.NewHashMap(); // "sentence" string[][] rootRules = new string[][] { new string[] { "right", "grup.verb", "s.a", "sn" }, new string[] { "left", "S" }, new string[] { "right", "sadv", "grup.adv", "neg", "interjeccio", "i", "sp", "grup.prep" }, InsertVerbs(new string[] { "rightdis" }, new string[] { "nc0s000", "nc0p000", "nc00000", "np00000", "rg", "rn" }) }; nonTerminalInfo[tlp.StartSymbol()] = rootRules; nonTerminalInfo["S"] = rootRules; nonTerminalInfo["sentence"] = rootRules; nonTerminalInfo["inc"] = rootRules; // adjectival phrases string[][] adjectivePhraseRules = new string[][] { new string[] { "leftdis", "grup.a", "s.a", "spec" } }; nonTerminalInfo["s.a"] = adjectivePhraseRules; nonTerminalInfo["sa"] = adjectivePhraseRules; nonTerminalInfo["grup.a"] = new string[][] { new string[] { "rightdis", "aq0000", "ao0000" }, InsertVerbs(new string[] { "right" }, new string[] { }), new string[] { "right", "rg", "rn" } }; // adverbial phrases nonTerminalInfo["sadv"] = new string[][] { new string[] { "left", "grup.adv", "sadv" } }; nonTerminalInfo["grup.adv"] = new string[][] { new string[] { "left", "conj" }, new string[] { "rightdis", "rg", "rn", "neg", "grup.adv" }, new string[] { "rightdis", "pr000000", "pi000000", "nc0s000", "nc0p000", "nc00000", "np00000" } }; nonTerminalInfo["neg"] = new string[][] { new string[] { "leftdis", "rg", "rn" } }; // noun phrases nonTerminalInfo["sn"] = new string[][] { new string[] { "leftdis", "nc0s000", "nc0p000", "nc00000" }, new string[] { "left", "grup.nom", "grup.w", "grup.z", "sn" }, new string[] { "leftdis", "spec" } }; nonTerminalInfo["grup.nom"] = new string[][] { new string[] { "leftdis", "nc0s000", "nc0p000", "nc00000", "np00000", "w", "grup.w" }, new string[] { "leftdis", "pi000000", "pd000000" }, new string[] { "left", "grup.nom", "sp" }, new string[] { "leftdis", "pn000000", "aq0000", "ao0000" }, new string[] { "left", "grup.a", "i", "grup.verb" }, new string[] { "leftdis", "grup.adv" } }; // verb phrases nonTerminalInfo["grup.verb"] = new string[][] { InsertVerbs(new string[] { "left" }, new string[] { }) }; nonTerminalInfo["infinitiu"] = new string[][] { InsertVerbs(new string[] { "left" }, new string[] { "infinitiu" }) }; nonTerminalInfo["gerundi"] = new string[][] { new string[] { "left", "vmg0000", "vag0000", "vsg0000", "gerundi" } }; nonTerminalInfo["participi"] = new string[][] { new string[] { "left", "aq", "vmp0000", "vap0000", "vsp0000", "grup.a" } }; // specifiers nonTerminalInfo["spec"] = new string[][] { new string[] { "left", "conj", "spec" }, new string[] { "leftdis", "da0000", "de0000", "di0000", "dd0000", "dp0000", "dn0000", "dt0000" }, new string[] { "leftdis", "z0", "grup.z" }, new string[] { "left", "rg", "rn" }, new string[] { "leftdis", "pt000000", "pe000000", "pd000000", "pp000000", "pi000000", "pn000000", "pr000000" }, new string[] { "left", "grup.adv", "w" } }; // entre A y B // etc. nonTerminalInfo["conj"] = new string[][] { new string[] { "leftdis", "cs", "cc" }, new string[] { "leftdis", "grup.cc", "grup.cs" }, new string[] { "left", "sp" } }; nonTerminalInfo["interjeccio"] = new string[][] { new string[] { "leftdis", "i", "nc0s000", "nc0p000", "nc00000", "np00000", "pi000000" }, new string[] { "left", "interjeccio" } }; nonTerminalInfo["relatiu"] = new string[][] { new string[] { "left", "pr000000" } }; // prepositional phrases nonTerminalInfo["sp"] = new string[][] { new string[] { "left", "prep", "sp" } }; nonTerminalInfo["prep"] = new string[][] { new string[] { "leftdis", "sp000", "prep", "grup.prep" } }; // custom categories nonTerminalInfo["grup.cc"] = new string[][] { new string[] { "left", "cs" } }; nonTerminalInfo["grup.cs"] = new string[][] { new string[] { "left", "cs" } }; nonTerminalInfo["grup.prep"] = new string[][] { new string[] { "left", "prep", "grup.prep", "s" } }; nonTerminalInfo["grup.pron"] = new string[][] { new string[] { "rightdis", "px000000" } }; nonTerminalInfo["grup.w"] = new string[][] { new string[] { "right", "w" }, new string[] { "leftdis", "z0" }, new string[] { "left" } }; nonTerminalInfo["grup.z"] = new string[][] { new string[] { "leftdis", "z0", "zu", "zp", "zd", "zm" }, new string[] { "right", "nc0s000", "nc0p000", "nc00000", "np00000" } }; }
public override void Display(bool verbose, PrintWriter pw) { base.Display(verbose, pw); if (doCatLevelEval) { NumberFormat nf = new DecimalFormat("0.00"); ICollection <string> cats = Generics.NewHashSet(); Random rand = new Random(); Sharpen.Collections.AddAll(cats, precisions.KeySet()); Sharpen.Collections.AddAll(cats, recalls.KeySet()); IDictionary <double, string> f1Map = new SortedDictionary <double, string>(); foreach (string cat in cats) { double pnum2 = pnums2.GetCount(cat); double rnum2 = rnums2.GetCount(cat); double prec = precisions2.GetCount(cat) / pnum2; double rec = recalls2.GetCount(cat) / rnum2; double f1 = 2.0 / (1.0 / prec + 1.0 / rec); if (f1.Equals(double.NaN)) { f1 = -1.0; } if (f1Map.Contains(f1)) { f1Map[f1 + (rand.NextDouble() / 1000.0)] = cat; } else { f1Map[f1] = cat; } } pw.Println("============================================================"); pw.Println("Tagging Performance by Category -- final statistics"); pw.Println("============================================================"); foreach (string cat_1 in f1Map.Values) { double pnum2 = pnums2.GetCount(cat_1); double rnum2 = rnums2.GetCount(cat_1); double prec = precisions2.GetCount(cat_1) / pnum2; prec *= 100.0; double rec = recalls2.GetCount(cat_1) / rnum2; rec *= 100.0; double f1 = 2.0 / (1.0 / prec + 1.0 / rec); double oovRate = (lex == null) ? -1.0 : percentOOV.GetCount(cat_1) / percentOOV2.GetCount(cat_1); pw.Println(cat_1 + "\tLP: " + ((pnum2 == 0.0) ? " N/A" : nf.Format(prec)) + "\tguessed: " + (int)pnum2 + "\tLR: " + ((rnum2 == 0.0) ? " N/A" : nf.Format(rec)) + "\tgold: " + (int)rnum2 + "\tF1: " + ((pnum2 == 0.0 || rnum2 == 0.0) ? " N/A" : nf.Format(f1)) + "\tOOV: " + ((lex == null) ? " N/A" : nf.Format(oovRate))); } pw.Println("============================================================"); } }
/// <summary> /// Imports script results /// </summary> /// <param name="result">RScriptResults object</param> /// <returns>Script results</returns> public override object ImportResults(RScriptResult result) { IEnumerable <double> authorities = Generics.ImportDoubles(_authorityFile, false); IEnumerable <double> hubs = Generics.ImportDoubles(_hubFile, false); IEnumerable <string> map = Generics.ImportStrings(_mappingFile); HITSResult results = new HITSResult(); for (int i = 0; i < map.Count(); i++) { results.Hubs.AddLink(_traceID, map.ElementAt(i), hubs.ElementAt(i)); results.Authorities.AddLink(_traceID, map.ElementAt(i), authorities.ElementAt(i)); } return(results); }
public GaleP4LexMapper() { //Buckwalter patterns //U+0627 //TODO Extend coverage to entire Arabic code chart //Obviously Buckwalter is a lossful conversion, but no assumptions should be made about //UTF-8 input from "the wild" //Patterns to fix segmentation issues observed in the ATB //Tags for the canChangeEncoding() method parentTagsToEscape = Generics.NewHashSet(); parentTagsToEscape.Add("PUNC"); parentTagsToEscape.Add("LATIN"); parentTagsToEscape.Add("-NONE-"); }
/// <summary> /// Construct a new /// <c>CollocationFinder</c> /// over the /// <c>Tree</c> /// t. /// </summary> /// <param name="t">parse tree</param> /// <param name="w">wordnet connection</param> /// <param name="hf"> /// /// <see cref="IHeadFinder"/> /// to use /// </param> public CollocationFinder(Tree t, IWordNetConnection w, IHeadFinder hf) { CoordinationTransformer transformer = new CoordinationTransformer(hf); this.wnConnect = w; this.qTree = transformer.TransformTree(t); this.collocationCollector = Generics.NewArrayList(); this.hf = hf; this.GetCollocationsList(); if (Debug) { log.Info("Collected collocations: " + collocationCollector); } }
// static method only public static IList <V> GetShortestPath <V, E>(IGraph <V, E> graph, V node1, V node2, bool directionSensitive) { if (node1.Equals(node2)) { return(Java.Util.Collections.SingletonList(node2)); } ICollection <V> visited = Generics.NewHashSet(); IDictionary <V, V> previous = Generics.NewHashMap(); BinaryHeapPriorityQueue <V> unsettledNodes = new BinaryHeapPriorityQueue <V>(); unsettledNodes.Add(node1, 0); while (unsettledNodes.Count > 0) { double distance = unsettledNodes.GetPriority(); V u = unsettledNodes.RemoveFirst(); visited.Add(u); if (u.Equals(node2)) { break; } unsettledNodes.Remove(u); ICollection <V> candidates = ((directionSensitive) ? graph.GetChildren(u) : graph.GetNeighbors(u)); foreach (V candidate in candidates) { double alt = distance - 1; // nodes not already present will have a priority of -inf if (alt > unsettledNodes.GetPriority(candidate) && !visited.Contains(candidate)) { unsettledNodes.RelaxPriority(candidate, alt); previous[candidate] = u; } } } if (!previous.Contains(node2)) { return(null); } List <V> path = new List <V>(); path.Add(node2); V n = node2; while (previous.Contains(n)) { path.Add(previous[n]); n = previous[n]; } Java.Util.Collections.Reverse(path); return(path); }
protected internal virtual void MakeInitialBlocks() { // sink block (for if the automaton isn't complete MakeBlock(Java.Util.Collections.Singleton(SinkNode)); // accepting block ICollection <TransducerGraph.Arc> endNodes = GetUnminimizedFA().GetEndNodes(); MakeBlock(endNodes); // main block ICollection <TransducerGraph.Arc> nonFinalNodes = Generics.NewHashSet(GetUnminimizedFA().GetNodes()); nonFinalNodes.RemoveAll(endNodes); MakeBlock(nonFinalNodes); }
/// <summary>Copies the Auxiliary tree.</summary> /// <remarks> /// Copies the Auxiliary tree. Also, puts the new names->nodes map in the TsurgeonMatcher that called copy. /// <br /> /// The trees and labels to use when making the copy are specified /// with treeFactory and labelFactory. This lets the tsurgeon script /// produce trees which are of the same type as the input trees. /// Each of the tsurgeon relations which copies a tree should include /// pass in the correct factories. /// </remarks> public virtual Edu.Stanford.Nlp.Trees.Tregex.Tsurgeon.AuxiliaryTree Copy(TsurgeonMatcher matcher, ITreeFactory treeFactory, ILabelFactory labelFactory) { if (labelFactory == null) { labelFactory = CoreLabel.Factory(); } IDictionary <string, Tree> newNamesToNodes = Generics.NewHashMap(); Pair <Tree, Tree> result = CopyHelper(tree, newNamesToNodes, treeFactory, labelFactory); //if(! result.first().dominates(result.second())) //log.info("Error -- aux tree copy doesn't dominate foot copy."); matcher.newNodeNames.PutAll(newNamesToNodes); return(new Edu.Stanford.Nlp.Trees.Tregex.Tsurgeon.AuxiliaryTree(result.First(), result.Second(), newNamesToNodes, originalTreeString)); }
protected void Page_Load(object sender, EventArgs e) { intSite = Convert.ToInt32(HttpContext.Current.Session["siteId"].ToString()); if (HttpContext.Current.Session["contId"] != null) { intCont = Convert.ToInt32(HttpContext.Current.Session["contId"].ToString()); } else { intCont = 1; } System.Text.StringBuilder sbUser = new System.Text.StringBuilder(); if (Convert.ToInt32(Session["userType"]) == 1) { sbUser.AppendLine("<div class=\"LoginName\">"); sbUser.AppendLine("<a href=mnt_administrator.aspx style=\"border:0px\"><img src=\"imagesCss/user-icon.gif\" style=\"border:0px\" alt=\"user\" align=\"absmiddle\" /></a> Administrator "); sbUser.AppendLine("</div>"); } else { sbUser.AppendLine("<div class=\"LoginName\">"); sbUser.AppendLine("<img src=\"imagesCss/user-icon.gif\" style=\"border:0\" alt=\"user\" align=\"absmiddle\" /> " + Convert.ToString(Session["userfullname"]) + ""); sbUser.AppendLine("</div>"); } sbUser.AppendLine("<div class=\"LoginName\" id=\"cms_documentation\"><a class=\"linkHeader\" href=\"documents/ER-CMSUserManual.doc\" target=\"_blank\"><img align=\"absmiddle\" alt=\"user\" style=\"border: 0px none;\" src=\"imagesCss/Word.gif\"> CMS Documentation</a></div>"); admin_name.InnerHtml = sbUser.ToString(); #region Aut ifs if (Convert.ToBoolean(Session["authenticated"]) != true) { Response.Redirect("CMS_Login.aspx"); } if (Request["Generic"] != null) { Session["CurrentPage"] = "mnt_Generics.aspx?Generic=" + Convert.ToInt32(Request["Generic"]); } if (Request["ContentGroupId"] != null) { Session["contId"] = Convert.ToInt32(Request["ContentGroupId"]); Session["CurrentPage"] = "mnt_Generics.aspx?Generic=" + Convert.ToInt32(Request["Generic"]); Response.Redirect("mnt_Generics.aspx?Generic=" + Convert.ToInt32(Request["Generic"])); } #endregion #region Ifs if (Convert.ToBoolean(Session["TemplateChose"]) == false) { Session["GeneType"] = 0; if ((Request["Generic"]) != null) { if (Convert.ToInt32(Request["Generic"]) == 2) { Session["About"] = true; } else { Session["About"] = false; } } if ((Request["Generic"]) != null) { Session["GeneType"] = Convert.ToInt32(Request["Generic"]); } } else { loadDDL(); } if (Convert.ToString(Session["PageTitle"]) != "") { tamplates = true; txt_NewPageTitle.Value = Convert.ToString(Session["PageTitle"]); } #endregion #region Content group if (Convert.ToBoolean(Session["authenticated"]) != true) { Response.Redirect("CMS_Login.aspx"); } System.Text.StringBuilder sbcont = new System.Text.StringBuilder(); //if (Session["contId"] != null) //{ ContentNavigation content = new ContentNavigation(); DataSet data = new DataSet(); string[] Vector = new string[6 + 1]; data = content.getAllContent(intSite); foreach (DataTable table in data.Tables) { foreach (DataRow row in table.Rows) { string link = "<a class=\"SelectAudience2\" href=" + Convert.ToString(Session["CurrentPage"]) + "&ContentGroupId=" + Convert.ToInt32(row["ContId"]) + ">" + Convert.ToString(row["ContTitle"]) + "</a> "; Vector[Convert.ToInt32(row["ContOrdPos"])] = link; } } for (int i = 1; i < Vector.Length; i++) { sbcont.AppendLine(Convert.ToString(Vector[i])); } sbcont.AppendLine("<br/>"); div_TopNavigation.InnerHtml = sbcont.ToString(); //} #endregion #region FirstLoad if (((Request["Generic"]) != null) || (Convert.ToInt32(Session["GeneType"]) != 0) || (Convert.ToBoolean(Session["NewPageTemplate"]) == true)) { bool fila = true; Generics gen = new Generics(); //DataSet data = new DataSet(); System.Text.StringBuilder sb = new System.Text.StringBuilder(); if (Session["GeneType"] != null) { if (Convert.ToInt32(Session["GeneType"]) == 1) { RCAbout = "Resource Center"; data = gen.Get_All_GenericByType(intSite, intCont, Convert.ToInt32(Session["GeneType"])); } else { if (Convert.ToInt32(Session["GeneType"]) == 2) { RCAbout = "About Us"; data = gen.Get_All_GenericByType(intSite, 0, Convert.ToInt32(Session["GeneType"])); } } sb.AppendLine("<TABLE border=\"0\" cellspacing=\"0\" cellpadding=\"2\">"); sb.AppendLine("<tr>"); sb.AppendLine("<td width=\"9\" height=\"10\"> </td> "); sb.AppendLine("<td width=\"44\"> </td>"); sb.AppendLine("<td width=\"150\" class=\"class_LineaVTabla\"> </td>"); sb.AppendLine("<td width=\"80\" align=\"center\"> </td> "); sb.AppendLine("<td width=\"100\" align=\"center\"> </td> "); sb.AppendLine("<td width=\"58\"> </td>"); sb.AppendLine("</tr>"); sb.AppendLine("<tr>"); sb.AppendLine("<td> </td> "); sb.AppendLine("<td>Id</td>"); sb.AppendLine("<td class=\"class_LineaVTabla\">Name</td> "); sb.AppendLine("<td align=\"center\"> </td><td align=\"center\"> </td> "); sb.AppendLine("<td> </td>"); sb.AppendLine("</tr>"); foreach (DataTable table in data.Tables) { foreach (DataRow row in table.Rows) { if(fila == true) {sb.AppendLine("<tr class=\"fila\"> ");}else{sb.AppendLine("<tr> ");} sb.AppendLine("<td> </td>"); sb.AppendLine("<TD align=\"center\">"); sb.AppendLine("" + row["GeneId"].ToString() + ""); sb.AppendLine("</TD>"); sb.AppendLine("<TD align=\"left\" class=\"class_LineaVTabla\">"); sb.AppendLine("" + row["GeneTitle"].ToString() + ""); sb.AppendLine("</TD>"); sb.AppendLine("<td align=\"center\"><a class=\"enlace\" href= mnt_Generics.aspx?RenameId=" + row["GeneId"] + "&Type=" + Session["GeneType"] + "><img src=\"images/edit.jpg\" border=\"0\"> Rename</A></td>"); sb.AppendLine("<TD align=\"center\"><a href=" + row["tempmntpage"].ToString() + "?GenericId=" + row["GeneId"] + " class=\"enlace\"><img src=\"images/btn_Edit.png\" border=\"0\" /> Edit Content</a></TD>"); sb.AppendLine("<td align=\"center\"><a class=\"enlace\" href= mnt_Generics.aspx?DeleteId=" + row["GeneId"] + "&Type=" + Session["GeneType"] + "><img src=\"images/btn_delete.png\" border=\"0\" onclick=\"return confirm('Do you want to continue? ');\"> Delete</A></td>"); sb.AppendLine(" <td align=\"left\"> </td></tr>"); if (fila == true) { fila = false; } else { fila = true; } } } if (Convert.ToBoolean(Session["About"]) == false) { if (fila == true) { sb.AppendLine("<tr class=\"fila\"> "); } else { sb.AppendLine("<tr> "); } sb.AppendLine("<td> </td>"); sb.AppendLine("<TD align=\"center\">"); sb.AppendLine("</TD>"); sb.AppendLine("<TD align=\"left\" class=\"class_LineaVTabla\">Free Tools</TD>"); sb.AppendLine("<td align=\"center\"></td>"); sb.AppendLine("<TD align=\"center\"><a href=\"mnt_FreeTools.aspx\" class=\"enlace\"><img src=\"images/btn_Edit.png\" border=\"0\" /> Edit Content</a></TD>"); sb.AppendLine("<td align=\"center\"></td>"); sb.AppendLine(" <td align=\"left\"> </td></tr>"); } sb.AppendLine("<tr><td> </td><td align=\"center\"> </td>"); sb.AppendLine("<td align=\"left\"class=\"class_LineaVTabla\"> </td>"); sb.AppendLine("<td align=\"center\"> </td>"); sb.AppendLine("<td align=\"center\"> </td>"); sb.AppendLine("<td align=\"left\"> </td></tr>"); sb.AppendLine("</TABLE>"); div_Generic.InnerHtml = sb.ToString(); btn_New.Visible = true; } else { Session["NewPageTemplate"] = true; div_templates.Visible = true; } if ((Request["GenericId"] != null) || (Request["ContentGroupId"] != null)) { div_templates.Visible = false; } if (Convert.ToBoolean(Session["NewPageTemplate"]) == true) { div_templates.Visible = true; } } #endregion if (Request["Rename"] != null) { nameGene = Request["Rename"].ToString(); Rename = true; } }
public DataSet Get_LeftMenu_All_AboutUs(int SiteId) { Generics generics = new Generics(); return generics.Get_Site_All_GenericByType(SiteId, 0, 2);//Loading About Us only in Site Level generics.Dispose(); }
public DataSet Get_LeftMenu_All_AboutUs() { Generics generics = new Generics(); return generics.Get_Site_All_GenericByType(SiteId, 0, 2); // generics.Dispose(); }
//Extrae tipo de menú public DataSet getGeneTypeId(string _gentype) { Generics generics = new Generics(); return generics.Get_GeneDefault_By_Id(_gentype); }
//Get Id Generic by Default Id public DataSet Get_Id_Generic(int genDefaId) { Generics generics = new Generics(); return generics.Get_Id_Generic(SiteId, ContId, genDefaId); }
protected void loadDDL() { DataSet datanew = new DataSet(); Generics genew = new Generics(); SelectGeneric.Items.Add(new ListItem("None", "0")); datanew = genew.Get_GeneDefault_By_Type(Convert.ToInt32(Session["GeneType"])); foreach (DataTable table in datanew.Tables) { foreach (DataRow row in table.Rows) { SelectGeneric.Items.Add(new ListItem(Convert.ToString(row["GeneDefaDescription"]), Convert.ToString(row["GeneDefaId"]))); } } }
//----------------------------------------------------- public DataSet Get_LeftMenu_All_ResourceCenter(int siteid,int contid) { Generics generics = new Generics(); return generics.Get_Site_All_GenericByType(siteid, contid, 1); }
public DataSet Get_LeftMenu_All_ResourceCenter(int SiteId, int ContId) { Generics generics = new Generics(); return generics.Get_Site_All_GenericByType(SiteId, ContId, 1); generics.Dispose(); }