protected OperatorGraph(OperatorGraph original, Cloner cloner)
: base(original, cloner) {
operators = cloner.Clone(original.operators);
initialOperator = cloner.Clone(original.initialOperator);
visualizationInfo = cloner.Clone(original.visualizationInfo);
Initialize();
}
public ScriptTypeConvertExpr(AstNodeArgs args)
: base(args)
{
if (ChildNodes.Count == 2)
{
if (args.ChildNodes[0] is ScriptExpr &&
!(args.ChildNodes[1] is ScriptExpr))
{
// ( Expr )
_expr = args.ChildNodes[0] as ScriptExpr;
_typeExpr = null;
}
else
{
//(Type) Expr
_typeExpr = args.ChildNodes[0] as ScriptExpr;
_expr = args.ChildNodes[1] as ScriptExpr;
}
}
else
{
throw new ScriptSyntaxErrorException(Strings.GrammarErrorExceptionMessage);
}
_operator = RuntimeHost.GetBinaryOperator("+");
if (_operator == null)
throw new ScriptRuntimeException(string.Format(Strings.MissingOperatorError, "+"));
}
public ScriptTypeConvertExpr(AstNodeArgs args)
: base(args)
{
if (ChildNodes.Count == 2)
{
if (args.ChildNodes[0] is ScriptExpr &&
!(args.ChildNodes[1] is ScriptExpr))
{
// ( Expr )
expr = args.ChildNodes[0] as ScriptExpr;
}
else
{
//(Type) Expr
typeExpr = args.ChildNodes[0] as ScriptExpr;
expr = args.ChildNodes[1] as ScriptExpr;
}
}
else
{
throw new ScriptException("Grammar error!");
}
@operator = RuntimeHost.GetBinaryOperator("+");
if (@operator == null)
throw new ScriptException("RuntimeHost did not initialize property. Can't find binary operators.");
}
public virtual IList<Tour> Create(IPttRequest request, IOperator op, out TourFactoryStatus status)
{
if (op.ExtensiveLoggingNeeded)
{
Logger.LogProcess("TourFactory.Create trying to get html for " + request.Url + " with postdata:"+request.PostValue);
}
var htmlSource = op.RequestResponseBehavior.GetHtmlMaster(request, false, op.ExtensiveLoggingNeeded, op.Name);
if(op.ExtensiveLoggingNeeded)
{
Logger.LogProcess("TourFactory.Create Html coming from htmlmaster");
Logger.LogProcess(htmlSource ?? "");
}
if (string.IsNullOrEmpty(htmlSource))
{
status = new TourFactoryStatus { Success = false };
return null;
}
var htmlSourceRefined = op.Refine(request, htmlSource);
if (op.ExtensiveLoggingNeeded)
{
Logger.LogProcess("TourFactory.Create Html refined");
Logger.LogProcess(htmlSourceRefined ?? "");
}
var html = new HtmlDocument();
html.LoadHtml(htmlSourceRefined);
var list = GetToursFromHtml(request, op, html, out status);
return list;
}
public Expression(IOperator linkingOperator, object leftOperand, IOperator comparisonOperator, object rightOperand)
{
this.linkingOperator = linkingOperator;
this.leftOperand = leftOperand;
this.comparisonOperator = comparisonOperator;
this.rightOperand = rightOperand;
}
public BasicFilter(string name, ITag tag, IOperator filterOperator, string criteria)
: base(name)
{
_tag = tag;
_operator = filterOperator;
_tag.attachObserver(this);
this._criteria = criteria;
}
internal EditBasicFilter(BasicFilter target, string newName, ITag newTag, IOperator newOperator, string newCriteria)
{
_newName = newName;
_newTag = newTag;
_newCriteria = newCriteria;
_target = target;
_newOperator = newOperator;
}
public ObjectRule(ISecurityObject iobject,
IOperator ioperator,
OperatorMethod method)
{
this.securityObject = iobject;
this.ioperator = ioperator;
this.method = method;
this.ruleId = Guid.NewGuid();
}
public string Calculate(string operandA, string operandB, IOperator operatorForAAndB)
{
var A = ConvertFromRomanToArabNumber(operandA);
var B = ConvertFromRomanToArabNumber(operandB);
var answerForExpression = operatorForAAndB.CalculateIt(A, B);
return ConvertFromArabToRomanNumber(answerForExpression);
}
public ScriptIsExpr(AstNodeArgs args)
: base(args)
{
Debug.Assert(Oper == "is");
_operator = RuntimeHost.GetBinaryOperator(Oper);
if (_operator == null)
throw new ScriptRuntimeException(string.Format(Strings.MissingOperatorError, "is"));
}
public override IList<Tour> Create(IPttRequest request, IOperator op, out TourFactoryStatus status)
{
if(!Biblo.TourDates.Contains(op.QueryObject.StartDate))
{
status = new TourFactoryStatus { Success = true, MoveToNextHotel = true};
return null;
}
return base.Create(request, op, out status);
}
public OperatorViewModel(IOperator currentOperator, IConnection connection)
{
if (currentOperator == null)
throw new ArgumentNullException("currentOperator");
if (connection == null)
throw new ArgumentNullException("connection");
this.connection = connection;
this.currentOperator = currentOperator;
this.ChatHistoryRecords = new ObservableCollection<IOperatorChatHistoryRecord>();
}
public ScriptBinExpr(AstNodeArgs args)
: base(args)
{
left = (ScriptExpr)ChildNodes[0];
oper = ((Token)ChildNodes[1]).Text;
right = (ScriptExpr)ChildNodes[2];
operatorFunction = RuntimeHost.GetBinaryOperator(oper);
if (operatorFunction == null)
throw new ScriptException("RuntimeHost did not initialize property. Can't find binary operators.");
}
public void edit(string newName, ITag newTag, IOperator newFilterOperator, string newCriteria)
{
Data.ActionHandler.beginMacro();
Data.ActionHandler.storeAction(new EditBasicFilter(this, _name, _tag, _operator, _criteria));
_name = newName;
_operator = newFilterOperator;
_criteria = newCriteria;
_tag.detachObserver(this);
_tag = newTag;
_tag.attachObserver(this);
Data.ActionHandler.endMacro();
}
internal NodeFuzzyRelation( FuzzyRelation subrelation1, FuzzyRelation subrelation2, IOperator oper)
{
if (
subrelation1 == null ||
//subrelation2 == null ||
oper == null)
throw new ArgumentNullException();
_subrelation1 = subrelation1;
_subrelation2 = subrelation2;
_operator = oper;
subrelation1.Parent = this;
if (subrelation2 !=null)
subrelation2.Parent = this;
}
public static IOperatorShapeInfo CreateOperatorShapeInfo(IOperator op) {
IEnumerable<string> operatorParameterNames = op.Parameters.Where(p => p is IValueParameter && typeof(IOperator).IsAssignableFrom(p.DataType)).Select(p => p.Name);
IEnumerable<string> paramaterNameValues = op.Parameters.Where(p => !(p is IValueParameter && typeof(IOperator).IsAssignableFrom(p.DataType))).Select(p => p.ToString());
OperatorShapeInfo operatorShapeInfo = new OperatorShapeInfo(operatorParameterNames, paramaterNameValues);
operatorShapeInfo.AddConnector(PredecessorConnector);
operatorShapeInfo.Collapsed = true;
operatorShapeInfo.Title = op.Name;
operatorShapeInfo.TypeName = op.GetType().GetPrettyName();
operatorShapeInfo.Color = Color.LightBlue;
operatorShapeInfo.LineWidth = 1;
operatorShapeInfo.LineColor = Color.Black;
operatorShapeInfo.Icon = new Bitmap(op.ItemImage);
return operatorShapeInfo;
}
public ScriptBinExpr(AstNodeArgs args)
: base(args)
{
left = (ScriptExpr)ChildNodes[0];
Oper = ((TokenAst)ChildNodes[1]).Text;
right = (ScriptExpr)ChildNodes[2];
Value = RuntimeHost.NullValue;
if (IsConst)
Evaluation = ConstFirstEvaluate;
else
Evaluation = CompleteEvaluate;
OperatorFunction = RuntimeHost.GetBinaryOperator(Oper);
if (OperatorFunction == null)
throw new ScriptRuntimeException(string.Format(Strings.MissingOperatorError, Oper));
}
public void Parse()
{
try
{
bracketLevel = 0;
CharEnumerator experIter = Exper.GetEnumerator();
if (experIter.MoveNext())
Parse(experIter, OperatorOrder.NONE, ref op);
else
op = new ValOp(0.0);
}
catch (System.Exception ex)
{
System.Console.WriteLine("Exper = " + Exper);
throw;
}
}
public ScriptAssignExpr(AstNodeArgs args)
: base(args)
{
nameExpr = (ScriptQualifiedName)args.ChildNodes[0];
oper = ((Token)args.ChildNodes[1]).Text;
if (args.ChildNodes.Count == 3)
rightExpr = (ScriptExpr)args.ChildNodes[2];
Debug.Assert(oper == "=" || oper == ":=" || oper == "+=" || oper == "-=" || oper == "++" || oper == "--" || oper == ":=");
switch (oper)
{
case "=":
assignOperation = Assign;
break;
case ":=":
assignOperation = AssignEx;
break;
case "++":
assignOperation = PlusPlus;
break;
case "--":
assignOperation = MinusMinus;
break;
case "+=":
assignOperation = PlusEqual;
break;
case "-=":
assignOperation = MinusEqual;
break;
default:
throw new ScriptException("Assignment operator:" + oper + " is not supported");
}
minus = RuntimeHost.GetBinaryOperator("-");
plus = RuntimeHost.GetBinaryOperator("+");
if (plus == null || minus == null)
throw new ScriptException("RuntimeHost did not initialize property. Can't find binary operators.");
}
/// <summary>
/// 获取拥有的function
/// </summary>
/// <param name="operId"></param>
/// <param name="method"></param>
/// <returns></returns>
public static DataTable GetOwnFunction(IOperator oper, OperatorMethod method)
{
// SecurityObjectType objType = SecurityObjectType.Function;
// string sql = @"select f.functionId,f.FunctionName from accessControlList a,FunctionList f where
// a.operatorId=@operId and a.OperatorMethod=@operMethod and a.ObjectType=@objType and a.ObjectId=f.FunctionId";
// SqlParameter[] Parameters = new SqlParameter[3];
// Parameters[0] = new SqlParameter("@operId", SqlDbType.UniqueIdentifier);
// Parameters[1] = new SqlParameter("@operMethod", SqlDbType.TinyInt);
// Parameters[2] = new SqlParameter("@objType", SqlDbType.TinyInt);
// Parameters[0].Value = oper.OperatorId;
// Parameters[1].Value = (int)method;
// Parameters[2].Value = (int)objType;
// return SqlHelper.ExecuteDataset(SqlHelper.SqlCon_QJVRMS, CommandType.Text, sql, Parameters).Tables[0];
FunctionService fs = new FunctionService();
return fs.GetOwnFunction(oper.OperatorId, (int)method);
}
private bool Parse(CharEnumerator experIter, IOperator prevOp, out IOperator op)
{
if (!SkipSpace(experIter))
{
op = null;
return true;
}
bool isEof = false;
char curCh = experIter.Current;
switch (curCh)
{
case '-':
isEof = ParseSub(experIter, prevOp, out op);
break;
case '+':
break;
default:
op = null;
break;
}
op = null;
return isEof;
}
public IAtomicOperation CreateChildOperation(IOperator op)
{
return(new ExecutionContext(this, op, scope));
}
public IAtomicOperation CreateOperation(IOperator op, IScope scope)
{
return(new ExecutionContext(parent, op, scope));
}
/*! This method modifies an operator \f$ L \f$ before the linear
* system \f$ Lu' = u \f$ is solved so that \f$ u' \f$ will
* satisfy the given condition. */
public virtual void applyBeforeSolving(IOperator o, Vector v)
{
throw new NotSupportedException();
}
/// <summary>
/// Gets the heuristic value for the given state.
/// </summary>
/// <param name="state">State to be evaluated.</param>
/// <param name="predecessor">Preceding state.</param>
/// <param name="appliedOperator">Applied operator from the preceding state.</param>
/// <returns>Heuristic value for the specified state.</returns>
protected virtual double GetValueImpl(IState state, IState predecessor, IOperator appliedOperator)
{
return(GetValueImpl(state));
}
public override void applyBeforeApplying(IOperator o)
{
return;
}
public UnaryExpression(IOperator operation, IExpression value)
{
Value = value;
Operation = operation;
}
private SimulatedAnnealingMainLoop FindMainLoop(IOperator start) {
IOperator mainLoop = start;
while (mainLoop != null && !(mainLoop is SimulatedAnnealingMainLoop))
mainLoop = ((SingleSuccessorOperator)mainLoop).Successor;
if (mainLoop == null) return null;
else return (SimulatedAnnealingMainLoop)mainLoop;
}
public bool OnMessageRecieved <T>(T msg) where T : class, IActorMessage
{
if (msg is ControlMessages.HangUp)
{
Broadcast(msg);
UnRegisterAll();
msg.Status?.TrySetResult(msg);
return(true);
}
if (IsUsingSingleOperator())
{
return(MainOperator.OnMessageRecieved <T>(msg));
}
IOperator op = null;
switch (this.MessageDispatchProcedure)
{
case MessageDispatchProcedureType.RandomSelection:
{
var handlesType = LocalSwitchboard.HandleValueTypeMessage(typeof(T));
if (!msgTypeToOperator.ContainsKey(handlesType))
{
throw new NoOperatorRegisteredToSupportTypeException(handlesType.ToString());
}
int nextIndex = rand.Next(0, msgTypeToOperator[handlesType].Count - 1);
op = msgTypeToOperator[handlesType].ElementAt(nextIndex);
}
break;
case MessageDispatchProcedureType.BroadcastToAll:
return(Broadcast <T>(msg));
case MessageDispatchProcedureType.RoundRobin:
{
var handlesType = msg.GetType();
if (!msgTypeToOperator.ContainsKey(handlesType))
{
throw new NoOperatorRegisteredToSupportTypeException(handlesType.ToString());
}
if (((ConcurrentQueue <IOperator>)msgTypeToOperator[handlesType]).Count == 1)
{
if (!((ConcurrentQueue <IOperator>)msgTypeToOperator[handlesType]).TryPeek(out op))
{
throw new CouldNotRetrieveNextOperatorFromQueueException();
}
}
else
{
if (!((ConcurrentQueue <IOperator>)msgTypeToOperator[handlesType]).TryDequeue(out op))
{
throw new CouldNotRetrieveNextOperatorFromQueueException();
}
//Re-Add the operator to the bottom of the queue.
((ConcurrentQueue <IOperator>)msgTypeToOperator[handlesType]).Enqueue(op);
}
}
break;
case MessageDispatchProcedureType.LeastBusy:
{
var handlesType = LocalSwitchboard.HandleValueTypeMessage(typeof(T));
if (!msgTypeToOperator.ContainsKey(handlesType))
{
throw new NoOperatorRegisteredToSupportTypeException(handlesType.ToString());
}
ulong leastCount = ulong.MaxValue;
for (int i = msgTypeToOperator[handlesType].Count - 1; i >= 0 && i < msgTypeToOperator[handlesType].Count; --i)
{
IOperator tempOp = msgTypeToOperator[handlesType].ElementAt(i);
if (leastCount > tempOp.Count)
{
leastCount = tempOp.Count;
op = tempOp;
}
if (0 == tempOp.Count)
{
break;
}
}
}
break;
default:
throw new UnsupportedDispatchImplementationException();
}
return(op.OnMessageRecieved <T>(msg));
}
private OffspringSelectionEvolutionStrategyMainLoop FindMainLoop(IOperator start) {
IOperator mainLoop = start;
while (mainLoop != null && !(mainLoop is OffspringSelectionEvolutionStrategyMainLoop))
mainLoop = ((SingleSuccessorOperator)mainLoop).Successor;
return (OffspringSelectionEvolutionStrategyMainLoop) mainLoop;
}
private ParseErrorType HandleFunctionOrIndexer(IOperator operatorNode) {
// Indexing or function call is performed on the topmost operand which
// generally should be a variable or a node that evaluates to it.
// However, we leave syntax check to separate code.
IRValueNode operand = this.SafeGetOperand();
if (operand == null) {
// Oddly, no operand
return ParseErrorType.IndentifierExpected;
}
operatorNode.LeftOperand = operand;
operatorNode.AppendChild(operand);
_operands.Push(operatorNode);
return ParseErrorType.None;
}
private void BuildUp(Token[] tokens, Expression parent)
{
while (_tokenIndex < tokens.Length)
{
var token = tokens[_tokenIndex];
IOperator op = null;
if (token.TokenType == TokenType.Operator && OperatorsDict.Instance.TryGetValue(token.Value, out op))
{
SetOperatorOnExpression(parent, op);
}
else if (token.TokenType == TokenType.Function)
{
BuildFunctionExpression(tokens, parent, token.Value);
}
else if (token.TokenType == TokenType.OpeningEnumerable)
{
_tokenIndex++;
BuildEnumerableExpression(tokens, parent);
}
else if (token.TokenType == TokenType.OpeningParenthesis)
{
_tokenIndex++;
BuildGroupExpression(tokens, parent);
//if (parent is FunctionExpression)
//{
// return;
//}
}
else if (token.TokenType == TokenType.ClosingParenthesis || token.TokenType == TokenType.ClosingEnumerable)
{
break;
}
else if (token.TokenType == TokenType.WorksheetQuote)
{
var sb = new StringBuilder();
sb.Append(tokens[_tokenIndex++].Value);
sb.Append(tokens[_tokenIndex++].Value);
sb.Append(tokens[_tokenIndex++].Value);
sb.Append(tokens[_tokenIndex].Value);
var t = new Token(sb.ToString(), TokenType.ExcelAddress);
CreateAndAppendExpression(ref parent, t);
}
else if (token.TokenType == TokenType.Negator)
{
_negateNextExpression = true;
}
else if (token.TokenType == TokenType.Percent)
{
SetOperatorOnExpression(parent, Operator.Percent);
if (parent == null)
{
_graph.Add(ConstantExpressions.Percent);
}
else
{
parent.AddChild(ConstantExpressions.Percent);
}
}
else
{
CreateAndAppendExpression(ref parent, token);
}
_tokenIndex++;
}
}
public static BasicExpression Apply(IOperator op, BasicExpression x, BasicExpression y)
{
return(op.Apply(x, y));
}
public long Register <T>(IOperator op)
{
return(Register <T>(op, true));
}
public override IOperation Apply()
{
double maxSelPress = MaximumSelectionPressureParameter.ActualValue.Value;
double successRatio = SuccessRatioParameter.ActualValue.Value;
IScope scope = ExecutionContext.Scope;
IScope parents = scope.SubScopes[0];
IScope offspring = scope.SubScopes[1];
int populationSize = parents.SubScopes.Count;
// retrieve actual selection pressure and success ratio
DoubleValue selectionPressure = SelectionPressureParameter.ActualValue;
if (selectionPressure == null)
{
selectionPressure = new DoubleValue(0);
SelectionPressureParameter.ActualValue = selectionPressure;
}
DoubleValue currentSuccessRatio = CurrentSuccessRatioParameter.ActualValue;
if (currentSuccessRatio == null)
{
currentSuccessRatio = new DoubleValue(0);
CurrentSuccessRatioParameter.ActualValue = currentSuccessRatio;
}
// retrieve next population
ItemList <IScope> population = OffspringPopulationParameter.ActualValue;
ItemList <IScope> virtual_population = OffspringVirtualPopulationParameter.ActualValue;
IntValue successfulOffspring;
if (population == null)
{
population = new ItemList <IScope>();
OffspringPopulationParameter.ActualValue = population;
selectionPressure.Value = 0; // initialize selection pressure for this round
currentSuccessRatio.Value = 0; // initialize current success ratio for this round
successfulOffspring = new IntValue(0);
OffspringPopulationWinnersParameter.ActualValue = successfulOffspring;
virtual_population = new ItemList <IScope>();
OffspringVirtualPopulationParameter.ActualValue = virtual_population;
}
else
{
successfulOffspring = OffspringPopulationWinnersParameter.ActualValue;
}
int successfulOffspringAdded = 0;
// implement the ActualValue fetch here - otherwise the parent scope would also be included, given that there may be 1000 or more parents, this is quite unnecessary
string tname = SuccessfulOffspringParameter.TranslatedName;
double tmpSelPress = selectionPressure.Value;
double tmpSelPressInc = 1.0 / populationSize;
for (int i = 0; i < offspring.SubScopes.Count; i++)
{
// fetch value
IVariable tmpVar;
if (!offspring.SubScopes[i].Variables.TryGetValue(tname, out tmpVar))
{
throw new InvalidOperationException(Name + ": Could not determine if an offspring was successful or not.");
}
BoolValue tmp = (tmpVar.Value as BoolValue);
if (tmp == null)
{
throw new InvalidOperationException(Name + ": The variable that indicates whether an offspring is successful or not must contain a BoolValue.");
}
// add to population
if (tmp.Value)
{
IScope currentOffspring = offspring.SubScopes[i];
offspring.SubScopes.RemoveAt(i);
i--; // next loop should continue with the subscope at index i which replaced currentOffspring
population.Add(currentOffspring);
successfulOffspringAdded++;
}
else
{
IScope currentOffspring = offspring.SubScopes[i];
offspring.SubScopes.RemoveAt(i);
i--;
virtual_population.Add(currentOffspring); // add to losers pool
}
tmpSelPress += tmpSelPressInc;
double tmpSuccessRatio = (successfulOffspring.Value + successfulOffspringAdded) / ((double)populationSize);
if (tmpSuccessRatio >= successRatio && (population.Count + virtual_population.Count) >= populationSize)
{
break;
}
}
successfulOffspring.Value += successfulOffspringAdded;
// calculate actual selection pressure and success ratio
selectionPressure.Value = tmpSelPress;
currentSuccessRatio.Value = successfulOffspring.Value / ((double)populationSize);
// check if enough children have been generated (or limit of selection pressure or evaluted solutions is reached)
if (((EvaluatedSolutionsParameter.ActualValue.Value < MaximumEvaluatedSolutionsParameter.ActualValue.Value) &&
(selectionPressure.Value < maxSelPress) &&
(currentSuccessRatio.Value < successRatio)) ||
((population.Count + virtual_population.Count) < populationSize))
{
// more children required -> reduce left and start children generation again
scope.SubScopes.Remove(parents);
scope.SubScopes.Remove(offspring);
while (parents.SubScopes.Count > 0)
{
IScope parent = parents.SubScopes[0];
parents.SubScopes.RemoveAt(0); // TODO: repeated call of RemoveAt(0) is inefficient?
scope.SubScopes.Add(parent); // order of subscopes is reversed
}
IOperator offspringCreator = OffspringCreatorParameter.ActualValue as IOperator;
if (offspringCreator == null)
{
throw new InvalidOperationException(Name + ": More offspring are required, but no operator specified for creating them.");
}
return(ExecutionContext.CreateOperation(offspringCreator)); // this assumes that this operator will be called again indirectly or directly
}
else
{
// enough children generated
var fitnessComparer = new FitnessComparer(QualityParameter.TranslatedName, MaximizationParameter.ActualValue.Value);
population.Sort(fitnessComparer); // sort individuals by descending fitness
// keeps only the best successRatio * populationSize solutions in the population (the remaining ones are added to the virtual population)
int removed = 0;
for (int i = 0; i < population.Count; i++)
{
double tmpSuccessRatio = i / (double)populationSize;
if (tmpSuccessRatio > successRatio)
{
virtual_population.Add(population[i]);
removed++;
}
}
population.RemoveRange(population.Count - removed, removed);
//fill up population with best remaining children (successful or unsuccessful)
virtual_population.Sort(fitnessComparer);
int offspringNeeded = populationSize - population.Count;
for (int i = 0; i < offspringNeeded && i < virtual_population.Count; i++)
{
population.Add(virtual_population[i]); // children are sorted by descending fitness
}
offspring.SubScopes.Clear();
offspring.SubScopes.AddRange(population);
scope.Variables.Remove(OffspringPopulationParameter.TranslatedName);
scope.Variables.Remove(OffspringVirtualPopulationParameter.TranslatedName);
scope.Variables.Remove(OffspringPopulationWinnersParameter.TranslatedName);
return(base.Apply());
}
}
private TabuSearchMainLoop FindMainLoop(IOperator start) {
IOperator mainLoop = start;
while (mainLoop != null && !(mainLoop is TabuSearchMainLoop))
mainLoop = ((SingleSuccessorOperator)mainLoop).Successor;
if (mainLoop == null) return null;
else return (TabuSearchMainLoop)mainLoop;
}
/// <summary>
/// Core implementation of the visitor functionality.
/// </summary>
/// <param name="node">Node to apply the visitor to.</param>
protected virtual void VisitCore(IOperator node)
{
}
public TD_InStorageController(ITD_InStorageBusiness tD_InStorageBus, IOperator op, IServiceProvider svcProvider)
{
_tD_InStorageBus = tD_InStorageBus;
_Op = op;
this.serviceProvider = svcProvider;
}
public HomeBusiness(IOperator theOperator)
{
_theOperator = theOperator;
}
public Context(IOperator _operator)
{
this._operator = _operator;
}
public override void applyBeforeSolving(IOperator o, Vector v)
{
return;
}
internal PrefixTerm(IOperator source, string prefix)
: base(SearchConditionNodeType.Prefix, source)
{
ArgumentValidator.EnsureArgumentNotNullOrEmptyOrWhiteSpace(prefix, "prefix");
Prefix = prefix;
}
static async Task <int> Main(string[] args)
{
IOperator dynamicOperator = null;
// Setup logging
using var loggerFactory = SetupLogging(args);
var logger = loggerFactory.CreateLogger <Program>();
try
{
logger.LogDebug($"Environment variables: {JsonConvert.SerializeObject(Environment.GetEnvironmentVariables())}");
// Setup termination handlers
SetupSignalHandlers();
// Setup the Kubernetes client
using var client = SetupClient(args);
// Setup the operator
var configuration = GetOperatorConfiguration();
dynamicOperator = new Operator(configuration, client, loggerFactory);
dynamicOperator.AddControllerOfType <MyDynamicResourceController>();
// Start the operator
return(await dynamicOperator.StartAsync());
}
catch (Exception exception)
{
logger.LogError(exception, "Operator error");
return(1);
}
IKubernetes SetupClient(string[] args)
{
// Load the Kubernetes configuration
KubernetesClientConfiguration config = null;
if (KubernetesClientConfiguration.IsInCluster())
{
logger.LogDebug("Loading cluster configuration");
config = KubernetesClientConfiguration.InClusterConfig();
}
else
{
logger.LogDebug("Loading local configuration");
config = KubernetesClientConfiguration.BuildConfigFromConfigFile();
}
if (logger.IsEnabled(LogLevel.Debug))
{
logger.LogDebug($"Client configuration: {JsonConvert.SerializeObject(config)}");
}
return(new Kubernetes(config));
}
ILoggerFactory SetupLogging(string[] args)
{
if (!System.Enum.TryParse <LogLevel>(Environment.GetEnvironmentVariable("LOG_LEVEL"), true, out LogLevel logLevel))
{
logLevel = LogLevel.Debug;
}
var loggerFactory = LoggerFactory.Create(builder => builder
.AddConsole(options => options.Format = ConsoleLoggerFormat.Systemd)
.SetMinimumLevel(logLevel)
);
// Enable Kubernetes client logging if level = DEBUG
ServiceClientTracing.IsEnabled = logLevel <= LogLevel.Debug;
ServiceClientTracing.AddTracingInterceptor(new ConsoleTracingInterceptor());
return(loggerFactory);
}
void SetupSignalHandlers()
{
// SIGTERM: signal the operator to shut down gracefully
AppDomain.CurrentDomain.ProcessExit += (s, e) =>
{
logger.LogDebug("Received SIGTERM");
dynamicOperator?.Stop();
};
// SIGINT: try to shut down gracefully on the first attempt
Console.CancelKeyPress += (s, e) =>
{
bool isFirstSignal = !dynamicOperator.IsDisposing;
logger.LogDebug($"Received SIGINT, first signal: {isFirstSignal}");
if (isFirstSignal)
{
e.Cancel = true;
Environment.Exit(0);
}
};
}
}
/// <summary>
/// Gets the heuristic value for the given node.
/// </summary>
/// <param name="node">Node to be evaluated.</param>
/// <param name="predecessor">Preceding node.</param>
/// <param name="appliedOperator">Applied operator from the preceding node.</param>
/// <returns>Heuristic value for the specified node.</returns>
public double GetValue(ISearchNode node, ISearchNode predecessor, IOperator appliedOperator)
{
// at the moment, specific for states only!
System.Diagnostics.Debug.Assert(node is IState && predecessor is IState);
return(GetValue((IState)node, (IState)predecessor, appliedOperator));
}
public void AcceptOperator(IOperator op) => op.Operate(this);
public F_ShopInfoBusiness(IRepository repository, IOperator op)
: base(repository)
{
operate = op;
}
public SystemMenuManage(IOperator @operator, IPermissionManage permissionManage)
{
_operator = @operator;
_permissionManage = permissionManage;
}
/// <summary>
/// Starts the search procedure.
/// </summary>
/// <param name="type">Type of search.</param>
/// <returns>Result of the search.</returns>
public override ResultStatus Start(SearchType type = SearchType.Forward)
{
InitSearch(type);
List <IOperator> transitionCandidates = new List <IOperator>();
ISearchNode currentNode = GetInitialNode();
while (!Problem.IsGoalNode(currentNode))
{
if (IsTimeLimitExceeded())
{
return(FinishSearch(ResultStatus.TimeLimitExceeded));
}
if (IsMemoryLimitExceeded())
{
return(FinishSearch(ResultStatus.MemoryLimitExceeded));
}
LogSearchStatistics();
transitionCandidates.Clear();
double bestCost = double.MaxValue;
IOperator bestCostOperator;
foreach (var transition in Problem.GetTransitions(currentNode))
{
IOperator appliedOperator = transition.GetAppliedOperator();
ISearchNode node = transition.GetTransitionResult();
double transitionCost = appliedOperator.GetCost() + Heuristic.GetValue(node);
if (transitionCost < bestCost)
{
bestCost = transitionCost;
transitionCandidates.Clear();
transitionCandidates.Add(appliedOperator);
}
else if (transitionCost.Equals(bestCost))
{
transitionCandidates.Add(appliedOperator);
}
}
if (transitionCandidates.Count == 0)
{
return(FinishSearch(ResultStatus.NoSolutionFound)); // dead-end reached
}
else if (transitionCandidates.Count == 1)
{
bestCostOperator = transitionCandidates[0];
}
else
{
bestCostOperator = transitionCandidates[RandomNumberGenerator.Next(transitionCandidates.Count)];
}
SolutionPlan.Add(bestCostOperator);
SolutionCost += bestCostOperator.GetCost();
currentNode = Apply(currentNode, bestCostOperator);
++ProcessedStatesCount;
}
if (SearchType != SearchType.Forward)
{
SolutionPlan.Reverse();
}
return(FinishSearch(ResultStatus.SolutionFound, currentNode));
}
public TimelineDecomposition(string name, List <ITerm> terms, IOperator init, IOperator dummy, List <IPredicate> Preconditions, List <IPredicate> Effects, int ID)
: base(name, terms, init, dummy, Preconditions, Effects, ID)
{
}
// interface
/*! This method modifies an operator \f$ L \f$ before it is
* applied to an array \f$ u \f$ so that \f$ v = Lu \f$ will
* satisfy the given condition. */
public virtual void applyBeforeApplying(IOperator o)
{
throw new NotSupportedException();
}
private ITextRange GetIndexerOrFunctionErrorRange(ParseContext context, IOperator operatorNode) {
ITextRange range = null;
if (operatorNode is Indexer) {
range = ((Indexer)operatorNode).LeftBrackets;
} else if (operatorNode is FunctionCall) {
range = ((FunctionCall)operatorNode).OpenBrace;
}
if (range == null) {
range = context.Tokens.FirstOrDefault((x) => x.Start >= operatorNode.End);
}
if (range == null) {
range = operatorNode;
}
return range;
}
public TimelineDecomposition(IOperator core, List <IPredicate> literals, List <IPlanStep> substeps, List <Tuple <IPlanStep, IPlanStep> > suborderings, List <CausalLink <IPlanStep> > sublinks)
: base(core, literals, substeps, suborderings, sublinks)
{
}
private ParseErrorType ProcessHigherPrecendenceOperators(ParseContext context, IOperator currentOperator) {
Debug.Assert(_operators.Count > 1);
ParseErrorType errorType = ParseErrorType.None;
Association association = currentOperator.Association;
// At least one operator above sentinel is on the stack.
do {
errorType = MakeNode(context);
if (errorType == ParseErrorType.None) {
IOperator nextOperatorNode = _operators.Peek();
if (association == Association.Left && nextOperatorNode.Precedence <= currentOperator.Precedence) {
break;
}
if (association == Association.Right && nextOperatorNode.Precedence < currentOperator.Precedence) {
break;
}
}
} while (_operators.Count > 1 && errorType == ParseErrorType.None);
return errorType;
}
internal bool TryGetOperator(string operatorName, out IOperator value)
{
return(this.registeredOperators.TryGetValue(operatorName, out value));
}
public Expression(double arg1, double arg2, IOperator o)
{
_arg1 = arg1;
_arg2 = arg2;
_o = o;
}
private void graphTreeView_AfterSelect(object sender, TreeViewEventArgs e)
{
SelectedOperator = graphTreeView.SelectedNode == null ? null : GetOperatorTag(graphTreeView.SelectedNode);
}
private void ParameterizeStochasticOperator(IOperator op) {
if (op is IStochasticOperator) {
IStochasticOperator stOp = (IStochasticOperator)op;
stOp.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
stOp.RandomParameter.Hidden = true;
}
}
private void breakpointToolStripMenuItem_Click(object sender, EventArgs e)
{
IOperator op = (IOperator)breakpointToolStripMenuItem.Tag;
op.Breakpoint = breakpointToolStripMenuItem.Checked;
}
/// <summary>
/// Obtains a reflection wrapper for an operator.
/// </summary>
/// <param name="target">The method, or null if none.</param>
/// <returns>The reflection wrapper, or null if none.</returns>
public StaticMethodWrapper Wrap(IOperator target)
{
if (target == null)
return null;
StaticDeclaredTypeWrapper declaringType = MakeDeclaredTypeWithoutSubstitution(target.GetContainingType());
return new StaticMethodWrapper(this, target, declaringType, declaringType, declaringType.Substitution);
}
public override IOperation Apply()
{
double maxSelPress = MaximumSelectionPressureParameter.ActualValue.Value;
double successRatio = SuccessRatioParameter.ActualValue.Value;
bool fillPopulationWithParents = false;
if (FillPopulationWithParentsParameter.ActualValue != null)
{
fillPopulationWithParents = FillPopulationWithParentsParameter.ActualValue.Value;
}
IScope scope = ExecutionContext.Scope;
IScope parents = scope.SubScopes[0];
IScope offspring = scope.SubScopes[1];
int populationSize = parents.SubScopes.Count;
// retrieve actual selection pressure and success ratio
DoubleValue selectionPressure = SelectionPressureParameter.ActualValue;
if (selectionPressure == null)
{
selectionPressure = new DoubleValue(0);
SelectionPressureParameter.ActualValue = selectionPressure;
}
DoubleValue currentSuccessRatio = CurrentSuccessRatioParameter.ActualValue;
if (currentSuccessRatio == null)
{
currentSuccessRatio = new DoubleValue(0);
CurrentSuccessRatioParameter.ActualValue = currentSuccessRatio;
}
// retrieve next population
ItemList <IScope> population = OffspringPopulationParameter.ActualValue;
IntValue successfulOffspring;
if (population == null)
{
population = new ItemList <IScope>();
OffspringPopulationParameter.ActualValue = population;
selectionPressure.Value = 0; // initialize selection pressure for this round
currentSuccessRatio.Value = 0; // initialize current success ratio for this round
successfulOffspring = new IntValue(0);
OffspringPopulationWinnersParameter.ActualValue = successfulOffspring;
}
else
{
successfulOffspring = OffspringPopulationWinnersParameter.ActualValue;
}
int worseOffspringNeeded = (int)((1 - successRatio) * populationSize) - (population.Count - successfulOffspring.Value);
int successfulOffspringAdded = 0;
// implement the ActualValue fetch here - otherwise the parent scope would also be included, given that there may be 1000 or more parents, this is quite unnecessary
string tname = SuccessfulOffspringParameter.TranslatedName;
double tmpSelPress = selectionPressure.Value, tmpSelPressInc = 1.0 / populationSize;
for (int i = 0; i < offspring.SubScopes.Count; i++)
{
// fetch value
IVariable tmpVar;
if (!offspring.SubScopes[i].Variables.TryGetValue(tname, out tmpVar))
{
throw new InvalidOperationException(Name + ": Could not determine if an offspring was successful or not.");
}
BoolValue tmp = (tmpVar.Value as BoolValue);
if (tmp == null)
{
throw new InvalidOperationException(Name + ": The variable that indicates whether an offspring is successful or not must contain a BoolValue.");
}
// add to population
if (tmp.Value)
{
IScope currentOffspring = offspring.SubScopes[i];
offspring.SubScopes.Remove(currentOffspring);
i--;
population.Add(currentOffspring);
successfulOffspringAdded++;
}
else if (worseOffspringNeeded > 0 || tmpSelPress >= maxSelPress)
{
IScope currentOffspring;
if (!fillPopulationWithParents || worseOffspringNeeded > 0)
{
currentOffspring = offspring.SubScopes[i];
offspring.SubScopes.Remove(currentOffspring);
i--;
worseOffspringNeeded--;
}
else
{
currentOffspring = parents.SubScopes[i];
}
population.Add(currentOffspring);
}
tmpSelPress += tmpSelPressInc;
if (population.Count == populationSize)
{
break;
}
}
successfulOffspring.Value += successfulOffspringAdded;
// calculate actual selection pressure and success ratio
selectionPressure.Value = tmpSelPress;
currentSuccessRatio.Value = successfulOffspring.Value / ((double)populationSize);
// check if enough children have been generated
if (((selectionPressure.Value < maxSelPress) && (currentSuccessRatio.Value < successRatio)) ||
(population.Count < populationSize))
{
// more children required -> reduce left and start children generation again
scope.SubScopes.Remove(parents);
scope.SubScopes.Remove(offspring);
while (parents.SubScopes.Count > 0)
{
IScope parent = parents.SubScopes[0];
parents.SubScopes.RemoveAt(0);
scope.SubScopes.Add(parent);
}
IOperator moreOffspring = OffspringCreatorParameter.ActualValue as IOperator;
if (moreOffspring == null)
{
throw new InvalidOperationException(Name + ": More offspring are required, but no operator specified for creating them.");
}
return(ExecutionContext.CreateOperation(moreOffspring));
}
else
{
// enough children generated
offspring.SubScopes.Clear();
offspring.SubScopes.AddRange(population);
scope.Variables.Remove(OffspringPopulationParameter.TranslatedName);
scope.Variables.Remove(OffspringPopulationWinnersParameter.TranslatedName);
return(base.Apply());
}
}
