/// <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));
}
