/// <summary>Creates/replaces the override entry for the given color layer property with the given evaluatable numbers.</summary>
/// <param name="layerPropertyName">The name of an color layer property (e.g. "_PrimaryColor").</param>
/// <param name="a">The evaluatable number that will be used as the alpha property for this color.</param>
/// <param name="r">The evaluatable number that will be used as the red property for this color.</param>
/// <param name="g">The evaluatable number that will be used as the green property for this color.</param>
/// <param name="b">The evaluatable number that will be used as the blue property for this color.</param>
public OverrideLogicBuilder SetDynamicColor(string layerPropertyName, IEvaluatable <double> a, IEvaluatable <double> r, IEvaluatable <double> g, IEvaluatable <double> b)
{
overrideProperties[layerPropertyName] = new OverrideDynamicValue(typeof(System.Drawing.Color), new Dictionary <string, IEvaluatable> {
{ "Alpha", a }, { "Red", r }, { "Green", g }, { "Blue", b }
});
return(this);
}
public bool IsTrueInAtLeastTwo <WorldType>(IEvaluatable rule, IEnumerable <WorldType> worlds)
{
_metricService.IncrementMetric("IsTrueInAtLeastTwo");
var positiveCount = worlds.Count(world => _ruleEvaluator.IsTrueIn(rule, world));
return(positiveCount >= 2);
}
public bool RelationallyEquivalentTo(IEvaluatable evaluatable)
{
if (evaluatable.GetType() != typeof(Disjunction))
{
return(false);
}
var scenario = evaluatable as Disjunction;
foreach (var arg in Arguments)
{
if (!ScenarioContainsArgumentRelation(scenario.Arguments, arg))
{
return(false);
}
}
foreach (var arg in scenario.Arguments)
{
if (!ScenarioContainsArgumentRelation(Arguments, arg))
{
return(false);
}
}
return(true);
}
public NumericChangeDetector(IEvaluatable <double> eval, bool detectRising = true, bool detectFalling = true, double threshold = 0)
{
Evaluatable = eval;
DetectRising = detectRising;
DetectFalling = detectFalling;
DetectionThreshold = threshold;
}
public double Evaluate(IEvaluatable node, int a, int b)
{
_Parameters["a"] = a;
_Parameters["b"] = b;
return node.Evaluate(_Parameters);
}
/// <summary>
/// Interal helper function to simplify/shorten the public API methods.
/// </summary>
private OverrideLogicBuilder SetDynamic(Type type, string layerPropertyName, IEvaluatable evaluatable)
{
overrideProperties[layerPropertyName] = new OverrideDynamicValue(type, new Dictionary <string, IEvaluatable> {
{ "Value", evaluatable }
});
return(this);
}
public VariableDefinition(Node node)
{
Node VariableIdNode = node.Attributes.GetNamedItem("VariableId");
if (VariableIdNode != null)
{
this._variableId = VariableIdNode.NodeValue;
}
else
{
throw new Indeterminate(Indeterminate.IndeterminateSyntaxError);
}
this._evaluatable = null;
NodeList children = node.ChildNodes;
for (int i = 0; i < children.Length; i++)
{
Node child = children.Item(i);
if (child.NodeType == Node.ELEMENT_NODE)
{
IElement e = PolicyElementFactory.GetInstance(children.Item(i));
if (e is IEvaluatable)
{
this._evaluatable = (IEvaluatable)e;
break;
}
}
}
if (this._evaluatable == null)
{
throw new Indeterminate(Indeterminate.IndeterminateSyntaxError);
}
}
public static Any Of(IEvaluatable argument)
{
var newJunction = new Disjunction();
JunctionHelper.AddArgumentToJunction <Disjunction>(newJunction, argument);
return(new Any(newJunction));
}
private string FactToEasyRuleFormat(IEvaluatable construct)
{
var fact = construct as Proposition;
var friendlyOperator = _operatorSynonyms.First(m => m.Value == fact.Operator).Key;
return($"{_attOpen}{fact.AttributeName}{_attClose} {friendlyOperator} {(fact.BinaryArgument? _binaryArgOpen:"")}{_valOpen}{fact.AttributeValue}{_valClose}{(fact.BinaryArgument ? _binaryArgClose : "")}");
}
public static All Of(IEvaluatable argument)
{
var newJunction = new Conjunction();
JunctionHelper.AddArgumentToJunction <Conjunction>(newJunction, argument);
return(new All(newJunction));
}
public bool IsTrueInOnlyFew <WorldType>(IEvaluatable rule, IEnumerable <WorldType> worlds)
{
_metricService.IncrementMetric("IsTrueInOnlyFew");
var positiveCount = worlds.Count(world => _ruleEvaluator.IsTrueIn(rule, world));
return(positiveCount / worlds.Count() <= 0.34);
}
public void Context()
{
AGenome = "rx";
Converter = new GenomeConverter();
Ast = Converter.Convert(AGenome);
Because();
}
private string DisjunctionToEasyRuleFormat(IEvaluatable construct)
{
var scenario = construct as Disjunction;
return(scenario.Arguments
.Select(x => Parenthesize(x, x.ToFormattedString(DymeConstructToFormattedString)))
.Aggregate((a, b) => $"{a} OR {b}"));
}
private string Parenthesize(IEvaluatable construct, string argument)
{
if (construct.GetType() != typeof(Proposition))
{
return($"{_openEncapsulation}{argument}{_closeEncapsulation}");
}
return(argument);
}
public static If When(IEvaluatable antecedant)
{
var implication = Implication.Create();
implication.Antecedent = antecedant;
var imply = new If(implication);
return(imply);
}
public bool RelationallyEquivalentTo(IEvaluatable evaluatable)
{
if (evaluatable.GetType() == typeof(Implication))
{
var implication = evaluatable as Implication;
return(Antecedent.RelationallyEquivalentTo(implication.Antecedent) && Consequent.RelationallyEquivalentTo(implication.Consequent));
}
return(false);
}
/// <summary>
/// Obtains an array that describes what sets of criteria a data set has "cleared", and which they haven't.
/// </summary>
public static bool[] GetCriteriaResults(SportSettings settings, IEvaluatable toEvaluate)
{
return(new bool[]
{
(settings.MinAge <= toEvaluate.Edad && toEvaluate.Edad <= settings.MaxAge),
(settings.MinHeight <= toEvaluate.Estatura && toEvaluate.Estatura <= settings.MaxHeight),
(settings.MinIMC <= toEvaluate.IMC && toEvaluate.IMC <= settings.MaxIMC)
});
}
public TrainingSession(INeuralNetwork nn, IEvaluatable evaluatable, int sessionNumber, bool isIdempotent = true)
{
NeuralNet = nn;
_evaluatable = evaluatable;
_sessionNumber = sessionNumber;
_hasStoredSessionEval = false;
_sessionEval = 0;
_isIdempotent = isIdempotent;
}
public TrainingSession(INeuralNetwork nn, IEvaluatable evaluatable, int sessionNumber, bool isIdempotent = true)
{
NeuralNet = nn;
_evaluatable = evaluatable;
_sessionNumber = sessionNumber;
_hasStoredSessionEval = false;
_sessionEval = 0;
_isIdempotent = isIdempotent;
}
public bool RelationallyEquivalentTo(IEvaluatable evaluatable)
{
if (evaluatable.GetType() != typeof(Proposition))
{
return(false);
}
var fact = evaluatable as Proposition;
return(fact.AttributeName == AttributeName);
}
public static void AddArgumentToJunction <T>(IJunction junction, IEvaluatable argument)
{
if (IsJunctionOfType <T>(argument))
{
junction.Arguments = MergeArgumentsReturnNewSet(junction, argument as IJunction);
}
else
{
junction.Arguments = AddArgumentReturnNewSet(junction, argument);
}
}
public static OverrideLogicBuilder InGameAnd(IEvaluatable <bool> eval)
{
return(new OverrideLogicBuilder().SetDynamicBoolean("_Enabled",
new BooleanAnd(
new IEvaluatable <bool>[] {
new BooleanGSIBoolean("Match/InGame"),
eval
}
)
));
}
/// <summary>Attempts to get an evaluatable from the suppliied data object. Will return true/false indicating if data is of correct format
/// (an <see cref="IEvaluatable{T}"/> where T matches the given type. If the eval type is null, no type check is performed, the returned
/// evaluatable may be of any sub-type.</summary>
internal static bool TryGetData(IDataObject @do, out IEvaluatable evaluatable, out Control_EvaluatablePresenter source, Type evalType)
{
if (@do.GetData(@do.GetFormats().FirstOrDefault(x => x != "SourcePresenter")) is IEvaluatable data && (evalType == null || Utils.TypeUtils.ImplementsGenericInterface(data.GetType(), typeof(IEvaluatable <>), evalType)))
{
evaluatable = data;
source = @do.GetData("SourcePresenter") as Control_EvaluatablePresenter;
return(true);
}
evaluatable = null;
source = null;
return(false);
}
/// <summary>
/// Инициализирует функцию на основе вычисляемого значения
/// </summary>
/// <param name="item">Вычисляемое значение</param>
/// <exception cref="ParserException">Возникает при несоответствии переданных параметров требованиям</exception>
public void Initialize(IEvaluatable <T> item)
{
// ReSharper disable once JoinNullCheckWithUsage
if (item == null)
{
throw new ParserException($"Недостаточно параметров для функции \"{this}\"");
}
_item = item;
Initialized = true;
}
/// <summary>
/// Инициализирует функцию на основании двух вычисляемых значений
/// </summary>
/// <param name="first">Первое вычисляемое значение</param>
/// <param name="second">Второе вычисляемое значение</param>
/// <exception cref="ParserException">Возникает при несоответствии переданных параметров требованиям</exception>
public void Initialize(IEvaluatable <T> first, IEvaluatable <T> second)
{
if (first == null || second == null)
{
throw new ParserException($"Недостаточно параметров для функции \"{this}\"");
}
_first = first;
_second = second;
Initialized = true;
}
public bool RemoveExpression(IEvaluatable expression)
{
int index = expressions.IndexOf(expression);
if (index == -1)
{
return(false);
}
expressions.RemoveAt(index);
expColors.RemoveAt(index);
expVisible.RemoveAt(index);
return(true);
}
public IEnumerable <int> IsTrueInWorldsReturnWorldIndexes <WorldType>(IEvaluatable rule, IEnumerable <WorldType> worlds)
{
_metricService.IncrementMetric("IsTrueInWorldsReturnWorldIndexes");
var indexedWorlds = worlds.ToArray();
var indexes = new List <int>();
for (var i = 0; i < indexedWorlds.Length; i++)
{
var world = indexedWorlds[i];
if (_ruleEvaluator.IsTrueIn(rule, world))
{
indexes.Add(i);
}
}
return(indexes);
}
double _GetScoreByEvaluatingClosenessToRealDeal(IEvaluatable node)
{
var aggregateResult = 0.0;
for(var a=100; a < 105; a++)
{
for(var b=100; b<105; b++)
{
var geneResult = Evaluate(node, a, b);
var actualResult = Math.Sqrt(a.Squared() + b.Squared());
aggregateResult += - Math.Abs(geneResult - actualResult);
}
}
return aggregateResult / 100;
}
/// <summary>
/// Analysiert ein gegebenes Szenario. Dabei werden verschiedene Leistungsmetriken
/// quantifiziert. Die Rate der erfolgreichen Buchungen, überflüssige Auslastung,
/// zusätzlicher Bedarf an Resourcen, Verteilung der Stecker akzeptierter Buchungen
/// und Verteilung der Stecker abgelehnter Buchungen.
/// </summary>
/// <param name="_scenario">Das zu untersuchende Szenario.</param>
/// <returns></returns>
public static Evaluation analyze(IEvaluatable _scenario)
{
scenario = _scenario;
List <List <double> > plugTypeDistribution = calcPlugTypeDistribution();
evaluation = new Evaluation()
{
suggestions = createSuggestion(),
bookingSuccessRate = calcBookingSuccessRate(),
unneccessaryWorkload = calcUnnecessaryWorkload(),
neccessaryWorkload = calcNecessaryWorkload(),
plugDistributionAccepted = plugTypeDistribution[0],
plugDistributionDeclined = plugTypeDistribution[1],
scenario = (ExecutedScenario)_scenario
};
// Berechnungen.
List <Booking> declined = new List <Booking>();
int declinedBookingsInGeneratedBookings = 0;
int acceptedBookingsInGeneratedBookings = 0;
ExecutedScenario s = (ExecutedScenario)scenario;
foreach (Booking b in s.bookings)
{
if (!s.location.schedule.bookings.Contains(b))
{
declined.Add(b);
}
}
foreach (Booking b in s.location.schedule.bookings)
{
if (s.bookings.Contains(b))
{
acceptedBookingsInGeneratedBookings++;
}
}
foreach (Booking b in declined)
{
if (s.bookings.Contains(b))
{
declinedBookingsInGeneratedBookings++;
}
}
return(evaluation);
}
private bool EvaluateAgainst <World>(IEvaluatable evaluatable, World world)
{
switch (evaluatable.GetType().Name)
{
case nameof(Conjunction):
return(EvaluateConjunction(evaluatable as Conjunction, world));
case nameof(Implication):
return(EvaluateImplication(evaluatable as Implication, world));
case nameof(Disjunction):
return(EvaluateDisjunction(evaluatable as Disjunction, world));
case nameof(Proposition):
return(EvaluateProposition(evaluatable as Proposition, world));
}
throw new Exception("Unknown construct");
}
public string DymeConstructToFormattedString(IEvaluatable construct)
{
var constructType = construct.GetType().Name.ToString();
switch (constructType)
{
case nameof(Proposition):
return(FactToEasyRuleFormat(construct));
case nameof(Conjunction):
return(ConjunctionToEasyRuleFormat(construct));
case nameof(Disjunction):
return(DisjunctionToEasyRuleFormat(construct));
case nameof(Implication):
return(ImplyToEasyRuleFormat(construct));
}
throw new ArgumentOutOfRangeException();
}
public AttributeAssignmentExpression(Node node)
{
this._attributeId = this.GetNodeAttribute(node, "AttributeId", true);
this._category = this.GetNodeAttribute(node, "Category", false);
this._issuer = this.GetNodeAttribute(node, "Issuer", false);
NodeList children = node.ChildNodes;
for (int i = 0; i < children.Length; i++)
{
Node child = children.Item(i);
if (child.NodeType == Node.ELEMENT_NODE)
{
this._evaluatable = (IEvaluatable)PolicyElementFactory.GetInstance(child);
}
}
if (this._evaluatable == null)
{
throw new Indeterminate(Indeterminate.IndeterminateSyntaxError);
}
}
public Match(Node node)
{
Node matchidnode = node.Attributes.GetNamedItem("MatchId");
if (matchidnode != null)
{
this._matchId = new AnyURIDataType(matchidnode.NodeValue);
}
else
{
throw new Indeterminate(Indeterminate.IndeterminateSyntaxError);
}
this._evaluatable = null;
this._attributeValue = null;
NodeList children = node.ChildNodes;
for (int i = 0; i < children.Length; i++)
{
Node child = children.Item(i);
if (child.NodeName.Trim().Equals(AttributeValue.stringIdentifer))
{
this._attributeValue = new AttributeValue(child);
}
else if (this._evaluatable == null && child.NodeName.Trim().Equals(AttributeDesignator.stringIdentifer))
{
this._evaluatable = new AttributeDesignator(child);
}
else if (this._evaluatable == null && child.NodeName.Trim().Equals(AttributeSelector.stringIdentifer))
{
this._evaluatable = new AttributeSelector(child);
}
}
if (this._evaluatable == null || this._attributeValue == null)
{
throw new Indeterminate(Indeterminate.IndeterminateSyntaxError);
}
}
public Condition(Node node)
{
this._evaluatable = null;
NodeList children = node.ChildNodes;
for (int i = 0; i < children.Length; i++)
{
Node child = children.Item(i);
if (child.NodeType == Node.ELEMENT_NODE)
{
IElement e = PolicyElementFactory.GetInstance(children.Item(i));
if (e != null && e is IEvaluatable)
{
this._evaluatable = (IEvaluatable)e;
break;
}
}
}
if (this._evaluatable == null)
{
throw new Indeterminate(Indeterminate.IndeterminateSyntaxError);
}
}
public void AddKeybind(String contextName, IEnumerable<Keys> keys, IEvaluatable function, IDictionary<String, String> parameters)
{
this.Keybinds.Add(
Tuple.Create(contextName, keys.ToArray()),
Tuple.Create(function, parameters)
);
}
public TwoInputGenomeEvaluator(string genome)
{
_GenomeAst = new GenomeConverter().Convert(genome);
}
double _GetScoreByInferenceOfRules(IEvaluatable genomeEvaluator)
{
var score = 0.0;
{
score += (.08)*(1 - genomeEvaluator.GetOperableGeneLength()/_MaxGeneLength);
}
// Hypoteneuse must be longer than leg a
{
var a = 6;
var b = 9;
var c = Evaluate(genomeEvaluator, a, b);
score += c > a ? .16 : 0;
}
// Hypoteneuse must be longer than leg b
{
var a = 1;
var b = 20;
var c = Evaluate(genomeEvaluator, a, b);
score += c > b ? .16 : 0;
}
// Hypoteneuse must be shorter than leg a + leg b
{
var a = 3;
var b = 4;
var c = Evaluate(genomeEvaluator, a, b);
score += c < a + b ? .16 : 0;
}
// Hypoteneuse is a if b == 0
{
var a = 3;
var b = 0;
var c = Evaluate(genomeEvaluator, a, b);
score += c == a ? .16 : 0;
}
// Hypoteneuse is b if a == 0
{
var a = 0;
var b = 4;
var c = Evaluate(genomeEvaluator, a, b);
score += c == b ? .16 : 0;
}
// Hypoteneuse is 0 if a == 0 && b == 0
{
var a = 0;
var b = 0;
var c = Evaluate(genomeEvaluator, a, b);
score += c == b ? .16 : 0;
}
// Hypoteneuse is a*sqrt(2) if a == b
{
var a = 1;
var b = a;
var c = Evaluate(genomeEvaluator, a, b);
score += -Math.Abs(2*a.Squared() - c.Squared());
}
if (double.IsInfinity(score))
score = double.MinValue;
return score;
}
