/// <summary> /// Parse the given line. /// </summary> /// <param name="line">The line to parse.</param> /// <returns>The parsed probability.</returns> public ParsedProbability Parse(String line) { ParsedProbability result = new ParsedProbability(); SimpleParser parser = new SimpleParser(line); parser.EatWhiteSpace(); if (!parser.LookAhead("P(", true)) { throw new EncogError("Bayes table lines must start with P("); } parser.Advance(2); // handle base AddEvents(parser, result.BaseEvents, "|,)=[]"); // handle conditions if (parser.Peek() == '|') { parser.Advance(); AddEvents(parser, result.GivenEvents, ",)=[]"); } if (parser.Peek() != ')') { throw new BayesianError("Probability not properly terminated."); } return result; }
/// <summary> /// Add events, as they are pased. /// </summary> /// <param name="parser">The parser.</param> /// <param name="results">The events found.</param> /// <param name="delim">The delimiter to use.</param> private void AddEvents(SimpleParser parser, IList<ParsedEvent> results, String delim) { bool done = false; StringBuilder l = new StringBuilder(); while (!done && !parser.EOL()) { char ch = parser.Peek(); if (delim.IndexOf(ch) != -1) { if (ch == ')' || ch == '|') done = true; ParsedEvent parsedEvent; // deal with a value specified by + or - if (l.Length > 0 && l[0] == '+') { String l2 = l.ToString().Substring(1); parsedEvent = new ParsedEvent(l2.Trim()); parsedEvent.Value = "true"; } else if (l.Length > 0 && l[0] == '-') { String l2 = l.ToString().Substring(1); parsedEvent = new ParsedEvent(l2.Trim()); parsedEvent.Value = "false"; } else { String l2 = l.ToString(); parsedEvent = new ParsedEvent(l2.Trim()); } // parse choices if (ch == '[') { parser.Advance(); int index = 0; while (ch != ']' && !parser.EOL()) { String labelName = parser.ReadToChars(":,]"); if (parser.Peek() == ':') { parser.Advance(); parser.EatWhiteSpace(); double min = double.Parse(parser.ReadToWhiteSpace()); parser.EatWhiteSpace(); if (!parser.LookAhead("to", true)) { throw new BayesianError("Expected \"to\" in probability choice range."); } parser.Advance(2); double max = CSVFormat.EgFormat.Parse(parser.ReadToChars(",]")); parsedEvent.ChoiceList.Add(new ParsedChoice(labelName, min, max)); } else { parsedEvent.ChoiceList.Add(new ParsedChoice(labelName, index++)); } parser.EatWhiteSpace(); ch = parser.Peek(); if (ch == ',') { parser.Advance(); } } } // deal with a value specified by = if (parser.Peek() == '=') { parser.ReadChar(); String value = parser.ReadToChars(delim); // BayesianEvent evt = this.network.getEvent(parsedEvent.getLabel()); parsedEvent.Value = value; } if (ch == ',') { parser.Advance(); } if (ch == ']') { parser.Advance(); } if (parsedEvent.Label.Length > 0) { results.Add(parsedEvent); } l.Length = 0; } else { parser.Advance(); l.Append(ch); } } }
/// <summary> /// Read the specified parameter. /// </summary> /// <param name="parser">The parser to use.</param> /// <returns>The parsed parameter.</returns> private ParamTemplate ReadParam(SimpleParser parser) { var result = new ParamTemplate(); if (!parser.LookAhead("{", true)) { throw new EACompileError("Expected {"); } parser.Advance(); bool done = false; var buffer = new StringBuilder(); while (!done) { if (parser.Peek() == '}') { done = true; parser.Advance(); } else if (parser.Peek() == '{') { throw new EACompileError("Unexpected {"); } else if (parser.Peek() == '{') { done = true; parser.Advance(); } else if (parser.Peek() == ',') { result.AddType(buffer.ToString().Trim().ToLower()); parser.Advance(); buffer.Length = 0; } else { buffer.Append(parser.ReadChar()); } } String s = buffer.ToString().Trim(); if (s.Length > 0) { result.AddType(s); } return result; }
public ProgramNode Parse(String expression) { this.parser = new SimpleParser(expression); while (!this.parser.EOL()) { this.parser.EatWhiteSpace(); // read in the command if (this.parser.ReadChar() != '[') { throw new EACompileError("Expected ["); } this.parser.EatWhiteSpace(); StringBuilder cmd = new StringBuilder(); while (this.parser.Peek() != ']' && !this.parser.EOL()) { cmd.Append(this.parser.ReadChar()); } if (this.parser.Peek() != ']') { throw new EACompileError("Expected ]"); } this.parser.Advance(); // parse out the command string[] tok = cmd.ToString().Split(':'); int idx = 0; String name = tok[idx++]; int childCount = int.Parse(tok[idx++]); IProgramExtensionTemplate temp = EncogOpcodeRegistry.Instance.FindOpcode(name, childCount); if (temp == null) { throw new EACompileError("Invalid instruction: " + name); } // build the arguments ProgramNode[] args = new ProgramNode[childCount]; for (int i = args.Length - 1; i >= 0; i--) { args[i] = this.nodeStack.Pop(); } // factor the node ProgramNode node = this.holder.Functions.FactorProgramNode(name, this.holder, args); this.nodeStack.Push(node); // add any needed data to the node for (int i = 0; i < temp.DataSize; i++) { String str = tok[idx++].Trim(); int strIdx = str.IndexOf('#'); if (strIdx != -1) { int enumType = int.Parse(str.Substring(0, strIdx)); int enumVal = int.Parse(str.Substring(strIdx + 1)); node.Data[0] = new ExpressionValue(enumType, enumVal); } // is it boolean? else if (str.Length == 1 && "tf".IndexOf(char.ToLower(str[0])) != -1) { node.Data[i] = new ExpressionValue(string.Compare(str, "t", true)); } // is it a string? else if (str[0] == '\"') { node.Data[i] = new ExpressionValue(str.Substring(1, str.Length - 1)); } // is it an integer else if (str.IndexOf('.') == -1 && str.ToLower().IndexOf('e') == -1) { long l; try { l = long.Parse(str); } catch (FormatException ex) { // sometimes C# will output a long value that is larger than can be parsed // this is very likely not a useful genome and we just set it to zero so that // the population load does not fail. l = 0; } node.Data[i] = new ExpressionValue(l); } // At this point, must be a float else { node.Data[i] = new ExpressionValue(CSVFormat.EgFormat.Parse(str)); } } } return this.nodeStack.Pop(); }
private static List<string> x5dc02619c7b497cb(string x311e7a92306d7199) { List<string> list = new List<string>(); SimpleParser parser = new SimpleParser(x311e7a92306d7199); if (0 == 0) { goto Label_0036; } Label_0012: list.Add((parser.Peek() == '"') ? parser.ReadQuotedString() : parser.ReadToWhiteSpace()); parser.EatWhiteSpace(); Label_0036: if (!parser.EOL()) { goto Label_0012; } return list; }
/// <summary> /// Construct a basic template object. /// </summary> /// <param name="thePrecedence">The precedence.</param> /// <param name="theSignature">The opcode signature.</param> /// <param name="theType">The opcode type.</param> /// <param name="isVariable">True, if this opcode is a variable.</param> /// <param name="theDataSize">The data size kept for this opcode.</param> /// <param name="theEvaluate">The evaluator delegate.</param> /// <param name="theIsPossibleReturnType">The return type delegate.</param> /// <param name="theRandomize">The randomizer delegate.</param> public BasicTemplate(int thePrecedence, String theSignature, NodeType theType, bool isVariable, int theDataSize, DelEvaluate theEvaluate, DelIsPossibleReturnType theIsPossibleReturnType, DelRandomize theRandomize) { _precedence = thePrecedence; _signature = theSignature; _varValue = isVariable; _dataSize = theDataSize; _nodeType = theType; _delEvaluate = theEvaluate; _delIsPossibleReturnType = theIsPossibleReturnType; _delRandomize = theRandomize; if (theSignature.Trim().Equals("(")) { // special case, we add a left-paren for the shunting yard alg. _name = theSignature; _returnValue = null; } else { // non-special case, find the name of the function/operator var parser = new SimpleParser(theSignature); bool pass = false; parser.EatWhiteSpace(); _name = parser.ReadToChars("(").Trim(); parser.Advance(); bool done = false; while (!done) { if (parser.Peek() == ')') { parser.Advance(); done = true; } else if (parser.Peek() == ':') { parser.Advance(); pass = true; } else if (parser.Peek() == '{') { ParamTemplate temp = ReadParam(parser); temp.PassThrough = pass; pass = false; _param.Add(temp); } else { parser.Advance(); if (parser.EOL()) { throw new EncogError("Invalid opcode template."); } } } // get the return type parser.EatWhiteSpace(); if (!parser.LookAhead(":", true)) { throw new EACompileError("Return type not specified."); } parser.Advance(); parser.EatWhiteSpace(); _returnValue = ReadParam(parser); } }
/// <summary> /// Parse a name. /// </summary> /// /// <param name="parser">The parser to use.</param> /// <returns>The name.</returns> private static String ParseName(SimpleParser parser) { var result = new StringBuilder(); parser.EatWhiteSpace(); while (parser.IsIdentifier()) { result.Append(parser.ReadChar()); } return result.ToString(); }
/// <summary> /// Parse a value. /// </summary> /// /// <param name="parser">The parser to use.</param> /// <returns>The newly parsed value.</returns> private static String ParseValue(SimpleParser parser) { bool quoted = false; var str = new StringBuilder(); parser.EatWhiteSpace(); if (parser.Peek() == '\"') { quoted = true; parser.Advance(); } while (!parser.EOL()) { if (parser.Peek() == '\"') { if (quoted) { parser.Advance(); if (parser.Peek() == '\"') { str.Append(parser.ReadChar()); } else { break; } } else { str.Append(parser.ReadChar()); } } else if (!quoted && (parser.IsWhiteSpace() || (parser.Peek() == ','))) { break; } else { str.Append(parser.ReadChar()); } } return str.ToString(); }
/// <summary> /// Parse parameters. /// </summary> /// /// <param name="line">The line to parse.</param> /// <returns>The parsed values.</returns> public static IDictionary<String, String> ParseParams(String line) { IDictionary<String, String> result = new Dictionary<String, String>(); var parser = new SimpleParser(line); while (!parser.EOL()) { String name = ParseName(parser) .ToUpper(); parser.EatWhiteSpace(); if (!parser.LookAhead("=", false)) { throw new EncogError("Missing equals(=) operator."); } parser.Advance(); String v = ParseValue(parser); result[name.ToUpper()] = v; if (!parser.ParseThroughComma()) { break; } } return result; }
public ProgramNode Parse(String expression) { this.parser = new SimpleParser(expression); this.unary = true; while (!parser.EOL()) { parser.EatWhiteSpace(); char ch = parser.Peek(); if (ch == '.' || char.IsDigit(ch)) { HandleNumeric(); this.unary = false; } else if (char.IsLetter(ch)) { handleAlpha(false); this.unary = false; } else if (ch == '(') { this.parser.Advance(); this.functionStack.Push(LEFT_PAREN); this.unary = true; } else if (ch == ')') { handleRightParen(); this.unary = false; } else if ("<>^*/+-=&|".IndexOf(ch) != -1) { handleSymbol(); this.unary = true; } else if (ch == '\"') { handleString(); this.unary = false; } else if (ch == ',') { HandleFunctionSeparator(); this.unary = true; } else { throw new EACompileError("Unparsable character: " + ch); } } // pop off any functions still on the stack while (this.functionStack.Count > 0) { IProgramExtensionTemplate f = this.functionStack.Pop(); OutputQueue(f); } // were there no operators? if (this.rootNode == null) { this.rootNode = this.outputStack.Pop(); } return this.rootNode; }
private static string xe1cd55dd1e3e1253(SimpleParser xbce90b56ab411c23) { StringBuilder builder = new StringBuilder(); xbce90b56ab411c23.EatWhiteSpace(); while (xbce90b56ab411c23.IsIdentifier()) { builder.Append(xbce90b56ab411c23.ReadChar()); } return builder.ToString(); }
private static string x0738845e2abbf3d2(SimpleParser xbce90b56ab411c23) { bool flag = false; StringBuilder builder = new StringBuilder(); xbce90b56ab411c23.EatWhiteSpace(); if (0 == 0) { goto Label_001E; } goto Label_0160; Label_000F: builder.Append(xbce90b56ab411c23.ReadChar()); goto Label_002B; Label_001E: if (xbce90b56ab411c23.Peek() == '"') { goto Label_0160; } Label_002B: if (!xbce90b56ab411c23.EOL()) { goto Label_00AE; } goto Label_01A9; Label_0061: if (((uint) flag) >= 0) { goto Label_000F; } Label_008C: if (!flag) { if (xbce90b56ab411c23.IsWhiteSpace()) { goto Label_01A9; } if (xbce90b56ab411c23.Peek() != ',') { goto Label_0061; } if (0 != 0) { goto Label_008C; } if ((((uint) flag) - ((uint) flag)) <= uint.MaxValue) { goto Label_01A9; } goto Label_000F; } if (-2 != 0) { goto Label_000F; } Label_00AE: if (xbce90b56ab411c23.Peek() == '"') { goto Label_0109; } if ((((uint) flag) - ((uint) flag)) <= uint.MaxValue) { goto Label_008C; } goto Label_000F; Label_00D2: if ((((uint) flag) + ((uint) flag)) < 0) { goto Label_001E; } goto Label_002B; Label_0109: if (!flag) { builder.Append(xbce90b56ab411c23.ReadChar()); goto Label_002B; } xbce90b56ab411c23.Advance(); if (xbce90b56ab411c23.Peek() != '"') { goto Label_01A9; } builder.Append(xbce90b56ab411c23.ReadChar()); goto Label_00D2; Label_0160: flag = true; if ((((uint) flag) + ((uint) flag)) <= uint.MaxValue) { if ((((uint) flag) | 15) == 0) { if (((uint) flag) >= 0) { goto Label_0061; } goto Label_008C; } xbce90b56ab411c23.Advance(); goto Label_002B; } if ((((uint) flag) - ((uint) flag)) >= 0) { goto Label_0109; } goto Label_00D2; Label_01A9: return builder.ToString(); }
public static IDictionary<string, string> ParseParams(string line) { SimpleParser parser; string str; string str2; IDictionary<string, string> dictionary = new Dictionary<string, string>(); if (-1 != 0) { parser = new SimpleParser(line); } else { goto Label_002F; } Label_0012: if (!parser.EOL()) { str = xe1cd55dd1e3e1253(parser).ToUpper(); goto Label_007A; } if (0 == 0) { return dictionary; } Label_0022: if (parser.ParseThroughComma()) { goto Label_0012; } if (0 != 0) { goto Label_007A; } return dictionary; Label_002F: str2 = x0738845e2abbf3d2(parser); dictionary[str.ToUpper()] = str2; goto Label_0022; Label_007A: parser.EatWhiteSpace(); if (!parser.LookAhead("=", false)) { throw new EncogError("Missing equals(=) operator."); } parser.Advance(); goto Label_002F; }