/// <summary> /// Reads a symbol from a term. /// </summary> /// <param name="term">The term.</param> /// <returns>The symbol.</returns> private ISymbol ReadSymbol(ITerm term) { #region Contract Contract.Requires<ArgumentNullException>(term != null); Contract.Ensures(Contract.Result<ISymbol>() != null); #endregion IConsTerm appl = (IConsTerm)term; switch (appl.Name) { case "sort": return new Sort(appl[0].ToString()); case "char-class": return new CharacterClass(ReadCharacterRanges((IListTerm)appl[0])); case "alt": return new Alt(ReadSymbol(appl[0]), ReadSymbol(appl[1])); case "cf": return new Cf(ReadSymbol(appl[0])); case "lex": return new Lex(ReadSymbol(appl[0])); case "layout": return Layout.Instance; case "lit": return new Lit(appl[0].ToString()); case "opt": return new Opt(ReadSymbol(appl[0])); case "parameterized-sort": throw new NotImplementedException(); case "iter": return new Iter(IterType.None, null, ReadSymbol(appl[0])); case "iter-star": return new Iter(IterType.ZeroOrMore, null, ReadSymbol(appl[0])); case "iter-plus": return new Iter(IterType.OneOrMore, null, ReadSymbol(appl[0])); case "iter-sep": return new Iter(IterType.None, null, ReadSymbol(appl[0])); case "iter-star-sep": return new Iter(IterType.ZeroOrMore, null, ReadSymbol(appl[0])); case "iter-plus-sep": return new Iter(IterType.OneOrMore, null, ReadSymbol(appl[0])); default: throw new NotSupportedException(); } }
public void Parse(Context context) { while (true) { if (context.CurrentToken().Kind == TokenKind.EOF || context.CurrentToken().Kind == TokenKind.EOL) { break; } else if (Action.IsAction(context)) { if (mProvidedAction == null) { mAction = new Action(); } else { mAction = mProvidedAction; } mAction.Parse(context); mList.Add(mAction); //break; } else if(context.CurrentToken().Value==";") { context.SkipToken(";"); } else { mExpression = new Expression(); mExpression.Parse(context); mList.Add(mExpression); } } }
public void Parse(Context context) { string currentTokenValue = context.CurrentToken().Value.ToLower(); context.SkipToken(context.CurrentToken().Value); while (true) { if (context.CurrentToken().Kind == TokenKind.EOF || context.CurrentToken().Kind == TokenKind.EOL) { break; } else if (currentTokenValue == "bt" || currentTokenValue == "adress" || currentTokenValue == "status") { mLiteral = new Literal(); mLiteral.Parse(context); mTerms.Add(mLiteral); //break; } else if(currentTokenValue!=";") { mObjective = new Objective(); mObjective.Parse(context); mTerms.Add(mObjective); } } }
/// <inheritdoc /> public void Write(ITerm term, Stream output) { // CONTRACT: Inherited from ITermWriter using (var writer = new StreamWriter(output, Encoding.Default, 4096, true)) { Write(term, writer); } }
/// <summary> /// Reads a reduction from a term. /// </summary> /// <param name="term">The term.</param> /// <returns>The reduction.</returns> private INonTerminal ReadReduction(ITerm term) { #region Contract Contract.Requires<ArgumentNullException>(term != null); Contract.Ensures(Contract.Result<INonTerminal>() != null); #endregion return (INonTerminal)ReadSymbol(term); }
public ResultTerm(ITerm term, double relevance) { if (term == null) { throw new ArgumentNullException("term"); } Term = term; Relevance = relevance; }
/// <summary> /// Initializes a new instance of the <see cref="PlaceholderTerm"/> class. /// </summary> /// <param name="template">The template.</param> /// <param name="annotations">The annotations of the term.</param> internal PlaceholderTerm(ITerm template, IReadOnlyCollection<ITerm> annotations) : base(annotations) { #region Contract Contract.Requires<ArgumentNullException>(template != null); Contract.Requires<ArgumentNullException>(annotations != null); Contract.Requires<ArgumentException>(Contract.ForAll(annotations, a => a != null)); #endregion this.Template = template; }
/// <summary> /// Writes a term to a string. /// </summary> /// <param name="term">The term to write.</param> /// <returns>The string representation of the term.</returns> public string ToString(ITerm term) { #region Contract Contract.Requires(term != null); Contract.Ensures(Contract.Result<string>() != null); #endregion using (var writer = new StringWriter(this.Culture)) { Write(term, writer); return writer.ToString(); } }
/// <summary> /// Writes the term to a file. /// </summary> /// <param name="writer">The term writer.</param> /// <param name="term">The term to write.</param> /// <param name="path">The path to the file to write to.</param> /// <remarks> /// The file is overwritten by this method. /// </remarks> public static void Write(this ITermWriter writer, ITerm term, string path) { #region Contract Contract.Requires<ArgumentNullException>(writer != null); Contract.Requires<ArgumentNullException>(term != null); Contract.Requires<ArgumentNullException>(path != null); #endregion using (var output = File.Create(path)) { writer.Write(term, output); } }
public void HasExpectedPropertyValues() { // Arrange string consName = "Cons"; var val0 = Factory.Int(0); var val1 = Factory.Int(1); var values = new ITerm[] { val0, val1 }; var sut = CreateSUT(consName, values); // Assert Assert.AreEqual(consName, sut.Name); Assert.AreEqual(values, sut.SubTerms); Assert.IsEmpty(sut.Annotations); }
/// <summary> /// Initializes a new instance of the <see cref="ListTerm"/> class, /// that represents a non-empty list. /// </summary> /// <param name="head">The head of the list.</param> /// <param name="tail">The tail of the list.</param> /// <param name="annotations">The annotations of the term.</param> public ListTerm(ITerm head, IListTerm tail, IReadOnlyCollection<ITerm> annotations) : base(annotations) { #region Contract Contract.Requires<ArgumentNullException>(head != null); Contract.Requires<ArgumentNullException>(tail != null); Contract.Requires<ArgumentNullException>(annotations != null); Contract.Requires<ArgumentException>(Contract.ForAll(annotations, a => a != null)); #endregion this.Head = head; this.Tail = tail; this.Count = tail.Count + 1; }
public void ToStringReturnsAString() { // Arrange string consName = "Cons"; var val0 = Factory.Int(0); var val1 = Factory.Int(1); var values = new ITerm[] { val0, val1 }; var sut = CreateSUT(consName, values); // Act var result = sut.ToString(); // Assert Assert.AreEqual("Cons(0,1)", result); }
public void ToStringReturnsAString() { // Arrange var val0 = Factory.Int(0); var val1 = Factory.Int(1); var val2 = Factory.Int(2); var values = new ITerm[] { val0, val1, val2 }; var sut = CreateSUT(values); // Act var result = sut.ToString(); // Assert Assert.AreEqual("[0,1,2]", result); }
public override IMongoQuery BuildQuery(ITerm term) { string m = (term.Operator ?? string.Empty).ToLower(); switch (m) { case "exact": return Query.EQ(term.Field, term.Value); case "partial": return Query.Matches(term.Field, new BsonRegularExpression("^"+term.Value, "i")); // case "phonetic": return Query.Matches(term.Field+"soundex", "^"+term.Value); default: return Query.Matches(term.Field, new BsonRegularExpression(term.Value, "i")); //full ci } }
public virtual void Create(ITerm newTerm, Action<ITerm, bool> callback) { var source = (Occupation)newTerm; // TODO: reconsider OrderBy clause var success = !_mixed.Retrieve<Occupation>(newTerm.Start, newTerm.End) .OfType<SeatEvent>() .Any(t => t.IsCoverd(source)); if (success) { AddOccupation(source); } callback(newTerm, success); }
public void TwoEqualTermsAreEqual() { // Arrange string consName = "Cons"; var val0 = Factory.Int(0); var val1 = Factory.Int(1); var values = new ITerm[] { val0, val1 }; var sut = CreateSUT(consName, values); var other = CreateSUT(consName, new[] { val0, val1 }); // Act var result = sut.Equals(other); // Assert Assert.IsTrue(result); }
public void TwoDifferentTermsAreDifferent() { // Arrange var val0 = Factory.Int(0); var val1 = Factory.Int(1); var val2 = Factory.Int(2); var values = new ITerm[] { val0, val1, val2 }; var sut = CreateSUT(values); var other = CreateSUT(new[] { val0, val2 }); // Act var result = sut.Equals(other); // Assert Assert.IsFalse(result); }
public IServiceQueueContainer Preparing(object scheduleId, ITerm enquiryRange, System.Func<double[], int, string, object, IVisibleLinerData> convertTo) { _enquiryRange = enquiryRange; var schedule = _forecastRepository.Get<Schedule>(scheduleId); var serviceQueues = schedule.ServiceQueues.Keys.ToArray(); var set = new ServiceQueueContainer(serviceQueues, enquiryRange, convertTo); _forecastRepository.LoadForecastRaw(serviceQueues, enquiryRange.Start, enquiryRange.End, t => { set[t.GroupBy<ServiceQueue>().GetHashCode()].Concat(t); }); set.CalculateForecastStatistics(schedule.Shrinkages.Select(o => o.AsArray()).ToArray(), (int)enquiryRange.Start.DayOfWeek); return set; }
public void HasExpectedPropertyValues() { // Arrange var val0 = Factory.Int(0); var val1 = Factory.Int(1); var val2 = Factory.Int(2); var values = new ITerm[] { val0, val1, val2 }; var sut = CreateSUT(values); // Assert Assert.AreEqual(values, sut.SubTerms); Assert.AreEqual(3, sut.Count); Assert.IsFalse(sut.IsEmpty); Assert.AreEqual(val0, sut.Head); Assert.AreEqual(new ITerm[]{ val1, val2 }, sut.Tail.SubTerms); Assert.IsEmpty(sut.Annotations); }
public void TwoDifferentTermsAreDifferent() { // Arrange string cons0Name = "Cons"; string cons1Name = "Other"; var val0 = Factory.Int(0); var val1 = Factory.Int(1); var values = new ITerm[] { val0, val1 }; var sut = CreateSUT(cons0Name, values); var other = CreateSUT(cons1Name, new[] { val0 }); // Act var result = sut.Equals(other); // Assert Assert.IsFalse(result); }
/// <summary> /// Prints the list of labels. /// </summary> /// <param name="list">The list of labels.</param> /// <returns>A list of terms.</returns> private IListTerm PrintLabels(IReadOnlyList<Label> list) { #region Contract Contract.Requires<ArgumentNullException>(list != null); Contract.Ensures(Contract.Result<IListTerm>() != null); #endregion var result = new ITerm[list.Count]; for (int i = 0; i < list.Count; i++) { var item = list[i]; result[i] = factory.Cons("label", productionFormat.Write(item.Production), factory.Int(i + SpoofaxParseTableFormat.LabelBase) ); } return factory.List(result); }
/// <inheritdoc /> public ProductionRule Read(ITerm representation) { // CONTRACT: Inherited from IProductionFormat<T> IConsTerm prod = representation.ToCons("prod", 3); IListTerm rhs = (IListTerm)prod[0]; ITerm lhs = prod[1]; ITerm attr = prod[2]; var reduction = ReadReduction(lhs); var expression = ReadExpression(rhs); string constructor = ReadConstructor(attr); var type = ReadProductionType(attr); var flags = ReadProductionFlags(attr); // TODO: Error on unknown attributes return new ProductionRule(reduction, expression, constructor, type, flags); }
/// <summary> /// Parses the parse table from the specified AST. /// </summary> /// <param name="ast">The AST.</param> /// <returns>The resulting <see cref="ParseTable"/>.</returns> private ParseTable Parse(ITerm ast) { #region Contract Contract.Requires<ArgumentNullException>(ast != null); Contract.Ensures(Contract.Result<ParseTable>() != null); #endregion var pt = ast.ToCons("parse-table", 5); int version = pt[0].ToInt32(); Assert(version == 4 || version == 6, "Only version 4 or 6 parse tables are supported."); var initialState = new StateRef(pt[1].ToInt32()); var labels = ParseLabels((IListTerm)pt[2]); var states = ParseStates((IListTerm)pt[3].ToCons("states", 1)[0], labels); var priorities = ParsePriorities((IListTerm)pt[4].ToCons("priorities", 1)[0]); // TODO: Injections? return new ParseTable(initialState, states, labels, priorities); }
private Argument DetermineArgument(ITerm term) { Argument argument = null; if (term.Operator == Modifier.MISSING) argument = new MissingArgument(); if (argument == null) argument = definitions.DetermineUniversalArgument(term.Field); if (argument == null) argument = definitions.FindArgument(term.Resource, term.Field); if (argument == null) argument = definitions.GuessArgument(term.Field); return argument; }
/// <summary> /// Prints the list of states. /// </summary> /// <param name="list">The list of states.</param> /// <param name="labels">The list with labels.</param> /// <returns>A list of terms.</returns> private IListTerm PrintStates(IReadOnlyList<State> list, IReadOnlyList<Label> labels) { #region Contract Contract.Requires<ArgumentNullException>(list != null); Contract.Requires<ArgumentNullException>(labels != null); Contract.Ensures(Contract.Result<IListTerm>() != null); #endregion var result = new ITerm[list.Count]; for (int i = 0; i < list.Count; i++) { var item = list[i]; result[i] = factory.Cons("state-rec", factory.Int(i), PrintGotos(item.Gotos), PrintActions(item.Actions, labels) ); } return factory.List(result); }
public ITerm Substitute(string variable, ITerm expression) { if (variable == Variable) { // (λ x . t)[x := r] = λ x . t return this; } else { var free_variables = expression.GetFreeVariables(); if (free_variables.Contains(Variable)) { // Need to do an α-conversion. string t = Utilities.GetFreeVariable(Body.GetFreeVariables().Union(free_variables)); return new AbstractionTerm(t, Body.Substitute(Variable, new VariableTerm(t)).Substitute(variable, expression)); } else { // (λ y . t)[x := r] = λ y . (t[x := r]) return new AbstractionTerm(Variable, Body.Substitute(variable, expression)); } } }
public JasonityException(string msg, ITerm error, Exception cause) : base(msg, cause) { this.error = error; }
public bool Equals(ITerm other) { return(Object.Equals(this, other.Header)); }
public static bool IsInTheRange(this DateTime dateTime, ITerm term) { return(dateTime.IsInTheRange(term.Start, term.End)); }
public bool Equals(ITerm other) { return(Object.Equals(other.Header, ArrayFunction.Instance) && this.Terms.AllDual(other.Terms, (x, y) => x.Equals(y))); }
/// <summary> /// Constructor. Takes the two terms to divide. /// </summary> /// <param name="term1">The first term (left-hand side).</param> /// <param name="term2">The second term (right-hand side).</param> public DivideTerm(ITerm term1, ITerm term2) { Term1 = term1; Term2 = term2; }
public Fix(IInfo info, ITerm term) { Info = info; Term = term; }
/** * returns all unifications for intentions with some goal */ public static IEnumerator <Unifier> AllIntentions(Circumstance C, Literal l, ITerm intAsTerm, Unifier un) { Trigger g = new Trigger(TEOperator.add, TEType.achieve, l); return(new EnumeratorImpl(C, un, g, intAsTerm)); }
/// <summary> /// Class constructor. /// </summary> /// <param name="term">Term instance.</param> public TermMessage(ITerm term, ITermProgressBar termProgressBar) { _term = term; _termProgressBar = termProgressBar; }
public double GetDegree(ITerm term) { return(_values.ContainsKey(term) ? _values[term] : 0); }
/// <summary> /// Application term (xy) /// </summary> /// <param name="left">The first term in the application</param> /// <param name="right">The second term in the application</param> public App(IInfo info, ITerm left, ITerm right) { Info = info; Left = left; Right = right; }
public void Set(ITerm term, double degree) { _values[term] = degree; }
/// <summary> /// Grounds the term. This version does "deep" grounding, in the sense that even object function terms are /// grounded into constant terms (the value of the object function term is gotten from the given reference state). /// </summary> /// <param name="term">Term.</param> /// <param name="substitution">Variables substitution.</param> /// <param name="referenceState">Reference state.</param> /// <returns>Grounded term.</returns> public ITerm GroundTermDeep(ITerm term, ISubstitution substitution, IState referenceState) { Substitution = substitution; ReferenceState = referenceState; return(term.Accept(this)); }
/// <summary> /// Grounds the term. /// </summary> /// <param name="term">Term.</param> /// <param name="substitution">Variables substitution.</param> /// <returns>Grounded term.</returns> public ITerm GroundTerm(ITerm term, ISubstitution substitution) { Substitution = substitution; ReferenceState = null; return(term.Accept(this)); }
/// <inheritdoc /> public override IPlaceholderTerm Placeholder(ITerm template, IReadOnlyCollection<ITerm> annotations) { // CONTRACT: Inherited from TermFactory return new PlaceholderTerm(template, annotations); }
public override IPlaceholderTerm CreateSUT(ITerm template) { return new PlaceholderTermTests().CreateSUT(template); }
public bool Equals(ITerm term) => term is UnaryOperation operation && Equals(operation);
public void UpdateShiftOccupyStatus(ITerm shift) { Session.SaveOrUpdate(shift); }
/// <summary> /// Vyhledávání volné kapacity /// </summary> /// <param name="hotId">Id hotelu</param> /// <param name="term"> /// Vrátí volné kapacity pokojů v daném rozsahu datumů. /// !!! Stačí, že vyhoví alespoň jedno datum To OR From a data jsou vrácena /// vrať data Where From => OR To <= /// </param> /// <returns></returns> public FreeCapacity GetFreeCapacity(int hotId, ITerm term) { return(Repository.GetFreeCapacity(BuildHotIdSnippetXml(hotId) + term.ToSnippetXmlOrNull())); }
private DateTime?ReplaceAssignment(AssignmentType choosedTermStyle, IAgent agent, ITerm term) { bool?dirty = null; if (term.IsNot <UnknowAssignment>()) { if (TryDeleteTerm(agent, (IIndependenceTerm)term) == null) { return(null); // 该天已存在班表无法删除, 也就无需再创建 (break point) } dirty = true; } var dateKey = term.SaftyGetProperty <DateTime, IIndependenceTerm>(t => t.SaftyGetHrDate()); // 未来改用 HRDate var newAssignment = _shiftDispatcherModel.CreateAssignmentWithSenser(dateKey, choosedTermStyle); agent.Schedule.Create(newAssignment, (t, success) => { if (!success) { agent.OperationFail = true; } else { dirty = true; t.SaftyInvoke <IAssignment>(a => { var assignmentStartIndex = (int)(a.Start.Subtract(_enquiryRange.Start).TotalMinutes / CellUnit); //xvar assignmentStartIndex = a.Start.IndexOf(_enquiryRange.Start); var staffingDemanded = _serviceQueueContainer.GetStaffingDemanded( assignmentStartIndex, (int)a.GetLength().TotalMinutes / CellUnit, agent.Profile.Skills); foreach (var rule in choosedTermStyle.SubEventInsertRules) { var ruleStartIndex = rule.TimeRange.StartValue / CellUnit; var eventCellLength = rule.SubEvent.TimeRange.Length / CellUnit; var availableOccurTimes = rule.GetAmountOfAvailableOccurPoints(); var balls = new Dictionary <int, double>(); for (var i = 0; i < availableOccurTimes; i++) { var score = 0.0; for (var j = 0; j < eventCellLength; j++) { score += staffingDemanded[i + ruleStartIndex + j]; } balls[i] = int.MaxValue - score; } var x = MathLib.CreateRatioSelector(balls).Pick(); agent.Schedule.ArrangeSubEvent(a, rule, x); } //agent.Schedule.ArrangeSubEvent(a, choosedTermStyle.GetSubEventInsertRules(), null); Statistic(a.NativeName, a, dateKey, 1); }); } }, true); return(dirty == true ? dateKey : default(DateTime?)); }
public ITerm Subst(IDictionary <Variable, ITerm> theta, ITerm aTerm) { return(substVisitor.Subst(theta, aTerm)); }
public static bool IsInTheRange(this DateRange range, ITerm term) { return(range.Start >= term.Start && range.End <= term.End); }
public Product(ITerm leftArg, ITerm rightArg) => (_leftArg, _rightArg) = (leftArg, rightArg);
public Pred(IInfo info, ITerm of) { Info = info; Of = of; }
/// <summary> /// Constructor. Takes the last term in the dice expression (the root of the expression tree). /// </summary> /// <param name="termToEvaluate"> /// The root of the expression tree -- by evaluating this term, all others will be evaluated recursively. /// </param> public DiceExpression(ITerm termToEvaluate) { this.termToEvaluate = termToEvaluate; }
public static IListTerm CreateBasicErrorAnnots(ITerm id, string msg) { return(AsSyntax.AsSyntax.CreateList( AsSyntax.AsSyntax.CreateStructure("error", id), AsSyntax.AsSyntax.CreateStructure("error_msg", AsSyntax.AsSyntax.CreateString(msg)))); }
protected virtual bool Compare(ITerm a, ITerm t) { return(a.CompareTo(t) > 0); }
/// <summary> /// Application term (xy) /// </summary> /// <param name="left">The first term in the application</param> /// <param name="right">The second term in the application</param> public App(ITerm left, ITerm right) { Left = left; Right = right; }
/// <summary> /// Constructor. Takes the last term in the dice expression (the root of the expression tree). /// </summary> /// <param name="rootTerm"> /// The root of the expression tree -- by evaluating this term, all others will be evaluated recursively. /// </param> public DiceExpression(ITerm rootTerm) => RootTerm = rootTerm;
/// <inheritdoc /> public override IListTerm ListConsNil(ITerm head, IListTerm tail, IReadOnlyCollection<ITerm> annotations) { // CONTRACT: Inherited from TermFactory return new ListTerm(head, tail, annotations); }
/// <summary> /// Constructor. Takes a term representing the number of dice to keep, and the dice term to /// operate on. /// </summary> /// <param name="keep">Term representing the number of dice to keep.</param> /// <param name="diceTerm">The dice term to operate on.</param> public KeepTerm(ITerm keep, DiceTerm diceTerm) { DiceTerm = diceTerm; Keep = keep; }
public TrivialTermFactory.PlaceholderTerm CreateSUT(ITerm template) { return (TrivialTermFactory.PlaceholderTerm)Factory.Placeholder(template); }
bool IEquatable <ITerm> .Equals(ITerm other) => other is Rational rational && Equals(rational);
public Logarithm(ITerm arg, ITerm @base) => (_base, _arg) = (@base, arg);
public static Dictionary <DateTime, int> CreateDateIndexer(this ITerm range) { return(DateTimeExt.CreateDateIndexer(range.Start, range.End)); }