public ClassResult(string data) { ResultType = ResultType.Class; Time = Convert.ToDateTime(data.Replace("time: ", "~").Split('~')[1].Split(',')[0]); string d1 = data.Replace("data: ", "~").Split('~')[1]; if (d1.Contains("class: Abstract")) { Classification = WordClassification.Abstract; } else if (d1.Contains("class: Physical")) { Classification = WordClassification.Physical; } string d2 = d1.Replace("value: ", "~").Split('~')[1].Split(',')[0]; try { Value = Double.Parse(d2); } catch { } string d3 = d1.Replace("word: ", "~").Split('~')[1].Split(',')[0]; Word = d3; int d4 = Int32.Parse(d1.Replace("line: ", "~").Split('~')[1].Split('}')[0]); Line = d4; }
// ----------------------- SetWord --------------------------------- /// <summary> /// Set the value of the word and its position in the string. /// </summary> /// <param name="InWord"></param> /// <param name="InWordBx"></param> /// <returns></returns> public WordCursor SetWord( string InWord, WordClassification InClass, int InWordBx, char InBraceChar) { mWordValue = new WordValue(InWord, InClass, mTraits, InBraceChar); mWordBx = InWordBx; RelativePosition = AcRelativePosition.At; return(this); }
// ----------------------- SetWord --------------------------------- /// <summary> /// Set the value of the word and its position in the string. /// </summary> /// <param name="InWord"></param> /// <param name="InWordBx"></param> /// <returns></returns> public WordCursor SetWord( string InWordText, WordClassification InWordClass, int InWordBx, char InBraceChar) { mWord = new TextWord(InWordText, InWordClass, mTraits, InBraceChar); mWordBx = InWordBx; this.Position = RelativePosition.At; return(this); }
public TextWord(string Value, WordClassification WordClass, TextTraits Traits) { char?braceChar = null; if (WordClass.IsOpenBraced()) { braceChar = Value[0]; if (Traits.IsOpenBraceChar(braceChar.Value) == false) { throw new ApplicationException("not an open brace char"); } } CommonConstruct(Value, WordClass, Traits, braceChar); }
public static bool IsOpenBraced(this WordClassification WordClass) { if (WordClass == WordClassification.OpenContentBraced) { return(true); } else if (WordClass == WordClassification.OpenNamedBraced) { return(true); } else { return(false); } }
public string ToValuePresentationString() { string s1 = null; if (WordClassification == WordClassification.None) { s1 = WordClassification.ToString(); } else { s1 = " wc: " + WordClassification.ToString() + " wBx: " + WordBx.ToString( ) + " wv: " + Word.ToString(); } return(s1); }
private void CommonConstruct( string InValue, WordClassification InClass, TextTraits InTraits, char InBraceChar) { mValue = InValue; mClass = InClass; mTraits = InTraits; mBraceChar = InBraceChar; // depending on word class, brace char must be specified or be blanks. if ((mClass == WordClassification.Braced) || (mClass == WordClassification.NameBraced)) { if (mBraceChar == ' ') { throw(new ApplicationException("Brace character of braced word is missing")); } } }
// ----------------------- SetValue --------------------------------- /// <summary> /// Set the value of the word and its position in the string. /// </summary> /// <param name="InWord"></param> /// <param name="InWordBx"></param> /// <returns></returns> private void SetValue( string InValue, WordClassification InClass, char InBraceChar) { mValue = InValue; mClass = InClass; mBraceChar = ' '; // brace character. if (mClass == WordClassification.Braced) { mBraceChar = mValue[0]; } else if (InClass == WordClassification.NameBraced) { if (InBraceChar == ' ') { throw(new ApplicationException("brace char of NameBraced word is missing")); } mBraceChar = InBraceChar; } }
public TextWord(string Text, LiteralType LiteralType, TextTraits Traits) { mValue = Text; _LiteralType = LiteralType; if (this.LiteralType.IsNumeric( )) { mClass = WordClassification.Numeric; } else if (this.LiteralType.IsQuoted( )) { mClass = WordClassification.Quoted; } else { throw new ApplicationException( "LiteralType is not supported. " + LiteralType.ToString()); } mTraits = Traits; _BraceChar = null; }
// ----------------------- SetValue --------------------------------- /// <summary> /// Set the value of the word and its position in the string. /// </summary> /// <param name="InWord"></param> /// <param name="InWordBx"></param> /// <returns></returns> private void SetValue( string InValue, WordClassification InClass, char?BraceChar) { mValue = InValue; mClass = InClass; _BraceChar = null; // brace character. if ((mClass == WordClassification.ContentBraced) || (mClass == WordClassification.OpenContentBraced)) { _BraceChar = mValue[0]; } else if ((InClass == WordClassification.NamedBraced) || (mClass == WordClassification.OpenNamedBraced)) { if (BraceChar == null) { throw (new ApplicationException("brace char of NameBraced word is missing")); } _BraceChar = BraceChar; } }
private static void RunCommand(string cmd) { cmd = cmd.ToLower(); if (cmd.StartsWith("run! ")) { cmd = cmd.Replace("run! ", ""); if (TrainedNetwork != null) { Console.WriteLine("\t" + TrainedNetwork.Compute(RootBreaker.BreakWord(cmd).SignificantRoots(2).GetVals())[0]); Console.WriteLine(""); } } else if (cmd.StartsWith("graph ")) { cmd = cmd.Replace("graph ", ""); var lineCount = File.ReadAllLines(cmd).Length; StreamReader file = new StreamReader(cmd); string line = ""; List <LogResult> results = new List <LogResult>(); int maxLine = 0; Dictionary <int, double[]> initial = new Dictionary <int, double[]>(); while ((line = file.ReadLine()) != null) { if (line.Contains("type: new-word")) { NewWordResult res = new NewWordResult(line); results.Add(res); } else if (line.Contains("type: abstraction")) { ClassResult res = new ClassResult(line); if (initial.ContainsKey(res.Line)) { initial[res.Line] = new double[] { initial[res.Line][0] + res.Value, initial[res.Line][1] + 1 }; } else { initial.Add(res.Line, new double[] { res.Value, 1 }); } results.Add(res); } } double[] classResults = new double[20000]; foreach (KeyValuePair <int, double[]> e in initial) { classResults[e.Key] = (e.Value[0] / e.Value[1]); } for (int i = 0; i < classResults.Length; i++) { Console.WriteLine(classResults[i]); } } else if (cmd.StartsWith("read ")) { cmd = cmd.Replace("read ", ""); StreamReader file = new StreamReader(cmd); string line = ""; Queue <string> readQueue = new Queue <string>(); Queue <Sentence> sentences = new Queue <Sentence>(); int lineNum = 0; while ((line = file.ReadLine()) != null) { // remove not needed words line = line.Replace(" the ", " ").Replace(" an ", " ").Replace(" a ", " "); string[] words = line.Split(' '); int i = 0; for (i = 0; i < words.Length; i++) { Word w = new Word(words[i]); // check abstraction only for nouns if (w.WordType == WordType.Noun) { double d = GlobalNetworks.GetRootsNetwork().Compute(RootBreaker.BreakWord(w.Isolation).SignificantRoots(2).GetVals())[0]; WordClassification cl = d > 0.5 ? WordClassification.Abstract : WordClassification.Physical; GlobalCache.LogAction("abstraction", $"class: {cl}, value: {d}, word: {w.Isolation}, line: {lineNum}"); } } i = 0; while (i < words.Length) { string word = words[i]; readQueue.Enqueue(word); if (word.Contains(".") || word.Contains("?") || word.Contains("!")) { // empty queue into sentance string all = ""; while (readQueue.Count > 0) { all += " " + readQueue.Dequeue(); } all = all.Trim(); Sentence s = new Sentence(all); Console.WriteLine("\n\t > " + s.Raw); sentences.Enqueue(s); if (sentences.Count > 50) { Sentence sen = sentences.Dequeue(); List <Sentence> sens = SentenceBreaker.BreakSentence(sen); // pass sentances into context analyzer } } i++; } lineNum++; } file.Close(); } else if (cmd.StartsWith("train ")) { cmd = cmd.Replace("train ", ""); if (cmd.StartsWith("root from ")) { cmd = cmd.Replace("root from ", ""); string[] args = cmd.Split(' '); if (args.Length > 1) { string input = args[0]; string output = args[1]; Console.WriteLine(">> training roots\n"); ActivationNetwork an = Analyzer.RunRoots(input, output); Console.WriteLine(">> finished training roots\n"); TrainedNetwork = an; } } } else if (cmd.StartsWith("test ")) { cmd = cmd.Replace("test ", ""); if (cmd.StartsWith("sen ")) { cmd = cmd.Replace("sen ", ""); List <List <Sentence> > s = SentenceBreaker.BreakString(cmd); foreach (List <Sentence> list in s) { Console.WriteLine("\n\t> " + list); foreach (Sentence sen in list) { Console.WriteLine($"\t - {sen.Raw}"); } } } else if (cmd.StartsWith("syn ")) { cmd = cmd.Replace("syn ", ""); Word w = new Word(cmd); w.LoadSynonyms(); } else if (cmd == "backpropogation" || cmd == "bp") { double[][] input = new double[4][] { new double[] { 0, 0 }, new double[] { 0, 1 }, new double[] { 1, 0 }, new double[] { 1, 1 } }; double[][] output = new double[4][] { new double[] { 0 }, new double[] { 1 }, new double[] { 1 }, new double[] { 0 } }; Console.WriteLine(">> testing back-propogation\n"); ActivationNetwork net = Neural.RunBackPropogation(input, output, 6); Console.WriteLine($"\n>> test results:\n" + $"\n[0,0]\t{net.Compute(new double[] { 0, 0 })[0]}" + $"\n[0,1]\t{net.Compute(new double[] { 0, 1 })[0]}" + $"\n[1,0]\t{net.Compute(new double[] { 1, 0 })[0]}" + $"\n[1,1]\t{net.Compute(new double[] { 1, 1 })[0]}"); } } }
// -------------------- IsolateWord --------------------------- // We have a word starting at InBx. Scan to the end of the word. // Returns the word in the InOutResults parm. // Returns the word delim in the return argument. private static ScanPatternResults IsolateWord( string Text, int Bx, ref WordCursor Results, TextTraits Traits) { int bx; ScanPatternResults spr = null; bx = Bx; char ch1 = Text[bx]; // is start of either verbatim string literal or quoted literal. if ( ((Traits.VerbatimLiteralPattern != null) && (Traits.VerbatimLiteralPattern.Match(Text, bx))) || (Traits.IsQuoteChar(ch1) == true) ) { var rv = ScanWord.IsolateQuotedWord(Text, bx, Traits); bx = rv.Item1; int? ex = rv.Item2; string wordText = rv.Item3; WordClassification wc = WordClassification.Quoted; var litType = rv.Item4; spr = rv.Item5; Results.SetWord(wordText, wc, bx); Results.Word.LiteralType = litType; } else { // Scan the string for any of the non word patterns spcfd in Traits. DelimClassification sprdc = DelimClassification.None; int remLx = Text.Length - bx; spr = Scanner.ScanEqualAny(Text, bx, remLx, Traits.NonWordPatterns); if (spr.IsNotFound == false) { sprdc = spr.FoundPat.DelimClassification; } // a quote character within the name. this is an error. if (sprdc == DelimClassification.Quote) { throw new ApplicationException( "quote character immed follows name character at position " + spr.FoundPos.ToString() + " in " + Text); } // no delim found. all word to the end of the string. else if (spr.IsNotFound) { string wordText = Text.Substring(Bx); Results.SetWord(wordText, WordClassification.Identifier, Bx); } // found an open named brace char // Open named braced words are words that combine the word and the braced contents. // debateable that this feature is needed and should be retained. else if (sprdc == DelimClassification.OpenNamedBraced) { Scanner.ScanWord_IsolateWord_Braced( Text, bx, spr, ref Results, Traits); } // delim is same position as the word. so either the word is the delim ( an // expression symbol ) or the word is empty ( the delim is a comma, semicolon, // ... a content divider ) else if (spr.FoundPos == Bx) { if ((Traits.NonDividerIsWord == true) && (Traits.IsDividerDelim(spr.FoundPat.DelimClassification) == false)) { Results.SetWord( spr.FoundPat.PatternValue, spr.FoundPat.DelimClassification.ToWordClassification( ).Value, Bx, spr.FoundPat.LeadChar); } // start of CommentToEnd comment. This is a word, not a delim. Find the // end of the comment and set the delim to that end position. else if (sprdc == DelimClassification.CommentToEnd) { spr = Scanner.ScanWord_IsolateWord_CommentToEnd( Text, spr.FoundPos, ref Results, Traits); } else { Results.SetNullWord(); } } // we have a word that ends with a delim. else { int lx = spr.FoundPos - Bx; string wordText = Text.Substring(Bx, lx); Results.SetWord(wordText, WordClassification.Identifier, Bx); } } // return ScanPatternResults of the delim that ends the word. return(spr); }
// ----------------------- SetWord --------------------------------- /// <summary> /// Set the value of the word and its position in the string. /// </summary> /// <param name="InWord"></param> /// <param name="InWordBx"></param> /// <returns></returns> public WordCursor SetWord(string InWord, WordClassification InClass, int InWordBx) { return(SetWord(InWord, InClass, InWordBx, ' ')); }
public WordValue( string InValue, WordClassification InClass, TextTraits InTraits, char InBraceChar) { CommonConstruct(InValue, InClass, InTraits, InBraceChar); }
public WordValue(string InValue, WordClassification InClass, TextTraits InTraits) { CommonConstruct(InValue, InClass, InTraits, ' '); }
public TextWord( string InValue, WordClassification InWordClass, TextTraits InTraits, char?BraceChar) { CommonConstruct(InValue, InWordClass, InTraits, BraceChar); }
/// <summary> /// Examine the string for its WordClassification content. /// </summary> /// <param name="InWord"></param> /// <param name="InTraits"></param> /// <returns></returns> public static CharObjectPair CalcWordClassification( string InWord, TextTraits InTraits) { int Fx = 0, Ix = 0; WordClassification wc = WordClassification.None; char braceChar = ' '; char ch1 = AcCommon.PullChar(InWord, 0); int Ex = InWord.Length - 1; // is quoted. the word runs to the closing quote. if (Scanner.IsOpenQuoteChar(ch1) == true) { Ix = Scanner.ScanCloseQuote(InWord, 0, InTraits.QuoteEncapsulation); if (Ix == Ex) { wc = WordClassification.Quoted; } else { wc = WordClassification.MixedText; } } // check if the string is a Braced or NameBraced word. if (wc == WordClassification.None) { char[] combo = AcCommon.Concat(InTraits.DelimChars, InTraits.BraceChars); Scanner.ScanCharResults results = Scanner.ScanEqual(InWord, 0, combo); Fx = results.ResultPos; ch1 = results.ResultChar; // found a brace char if ((InTraits.IsOpenBraceChar(ch1) == true) && (InTraits.IsDelimChar(ch1) == false)) { Ix = Scanner.ScanCloseBrace(InWord, Fx); if (Ix == Ex) { braceChar = ch1; if (Fx == 0) { wc = WordClassification.Braced; } else { wc = WordClassification.NameBraced; } } } } // word is all delimeter. if (wc == WordClassification.None) { Fx = Scanner.ScanNotEqual(InWord, 0, InTraits.DelimChars).a; if (Fx >= 0) { wc = WordClassification.Delimeter; } } // check if a numeric string. if (wc == WordClassification.None) { char[] digitChars = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', '+', '-' }; Fx = Scanner.ScanNotEqual(InWord, 0, digitChars).a; if (Fx == -1) { wc = WordClassification.Numeric; try { double vx = double.Parse(InWord); } catch (Exception) { wc = WordClassification.None; } } } // any delim chars in the string. if not, the string is a name. otherwise, it is // mixed. if (wc == WordClassification.None) { Fx = Scanner.ScanEqual(InWord, 0, InTraits.DelimChars).a; if (Fx == -1) { wc = WordClassification.Name; } else { wc = WordClassification.MixedText; } } return(new CharObjectPair(braceChar, wc)); }
public Word(string word) { WordClassification = WordClassification.None; Literal = word; word = word.Replace(":", "").Replace("?", "").Replace("_", "").Replace("!", "").Replace(".", "").ToLower().Replace("\"", "").Replace("\\", "").Replace("/", "").Replace(",", ""); Isolation = word; if (GlobalCache.WordCache.ContainsKey(Isolation)) { Word w = GlobalCache.WordCache[Isolation]; WordType = w.WordType; } else { try { string w = WebInteractive.GetPageContents(@"https://www.dictionary.com/browse/" + word); string[] bk = w.Split(new string[] { "<span class=\"luna-pos\">" }, StringSplitOptions.None); if (bk.Length < 2) { WordType = WordType.None; return; } string type = bk[1].Split(new string[] { "</span>" }, StringSplitOptions.None)[0].Replace(",", "").Replace(";", "").ToLower(); switch (type) { case "definite article": WordType = WordType.DefiniteArticle; break; case "noun adjective": case "noun": WordType = WordType.Noun; break; case "verb (used without object)": case "verb (used with object)": case "auxiliary verb": case "verb": WordType = WordType.Verb; break; case "interjection": WordType = WordType.Interjection; break; case "adjective": WordType = WordType.Adjective; break; case "adverb": WordType = WordType.Adverb; break; case "pronoun": WordType = WordType.Pronoun; break; case "preposition": WordType = WordType.Preposition; break; case "conjunction": case "connective": WordType = WordType.Adjective; break; default: WordType = WordType.None; break; } if (WordType == WordType.None) { Console.WriteLine(Isolation + " - " + type); } GlobalCache.WordCache.Add(Isolation, this); GlobalCache.LogAction("new-word", $"word: {Isolation}, type: {WordType}"); //Console.WriteLine($"\tcached: [{Isolation}, {WordType}]"); } catch { } } }