public override IOperation Apply()
{
var swarmBest = SwarmBestQualityParameter.ActualValue;
if (swarmBest == null)
{
return(base.Apply());
}
var previousBest = PreviousBestQualityParameter.ActualValue;
if (previousBest == null)
{
PreviousBestQualityParameter.ActualValue = new DoubleValue(swarmBest.Value);
return(base.Apply());
}
;
var successor = new OperationCollection(new[] { base.Apply() });
var max = MaximizationParameter.ActualValue.Value;
if (max && swarmBest.Value <= previousBest.Value ||
!max && swarmBest.Value >= previousBest.Value)
{
successor.Insert(0, ExecutionContext.CreateOperation(TopologyInitializerParameter.ActualValue));
}
previousBest.Value = swarmBest.Value;
return(successor);
}
private void ApplyInnerSelector()
{
// necessary for inner GenderSpecificSelector to execute all operations in OperationCollection
Stack <IOperation> executionStack = new Stack <IOperation>();
executionStack.Push(ExecutionContext.CreateChildOperation(Selector));
while (executionStack.Count > 0)
{
CancellationToken.ThrowIfCancellationRequested();
IOperation next = executionStack.Pop();
if (next is OperationCollection)
{
OperationCollection coll = (OperationCollection)next;
for (int i = coll.Count - 1; i >= 0; i--)
{
if (coll[i] != null)
{
executionStack.Push(coll[i]);
}
}
}
else if (next is IAtomicOperation)
{
IAtomicOperation operation = (IAtomicOperation)next;
next = operation.Operator.Execute((IExecutionContext)operation, CancellationToken);
if (next != null)
{
executionStack.Push(next);
}
}
}
}
public void Commit()
{
OperationCollection oprs = new OperationCollection(StorageEngineClient.XIndexMIN, 1);
oprs.Add(new StorageEngineCommitOperation());
Execute(oprs);
}
public override IOperation Apply() {
OperationCollection next = new OperationCollection(base.Apply());
IOperator op = OperatorParameter.ActualValue;
if (op != null)
next.Insert(0, ExecutionContext.CreateOperation(op));
return next;
}
public override IOperation Apply()
{
var max = MaximizationParameter.ActualValue.Value;
// Update of the personal bests
var points = RealVectorParameter.ActualValue;
var qualities = QualityParameter.ActualValue;
var particles = points.Select((p, i) => new { Particle = p, Index = i })
.Zip(qualities, (p, q) => Tuple.Create(p.Index, p.Particle, q.Value)).ToList();
UpdatePersonalBest(max, particles);
// SPSO: update of the neighbor bests from the personal bests
var personalBestPoints = PersonalBestParameter.ActualValue;
var personalBestQualities = PersonalBestQualityParameter.ActualValue;
particles = personalBestPoints.Select((p, i) => new { Particle = p, Index = i })
.Zip(personalBestQualities, (p, q) => Tuple.Create(p.Index, p.Particle, q.Value)).ToList();
UpdateNeighborBest(max, particles);
var next = new OperationCollection()
{
base.Apply()
};
next.Insert(0, ExecutionContext.CreateChildOperation(ResultsCollector));
if (MaxVelocityScalingOperatorParameter.Value != null)
{
next.Insert(0, ExecutionContext.CreateChildOperation(MaxVelocityScalingOperatorParameter.Value));
}
else
{
CurrentMaxVelocityParameter.ActualValue = new DoubleValue(MaxVelocityParameter.ActualValue.Value);
}
return(next);
}
public virtual IOperation InstrumentedApply()
{
if (!AfterExecutionOperators.Any())
{
if (Successor != null)
{
return(ExecutionContext.CreateOperation(Successor));
}
return(null);
}
var opCol = new OperationCollection();
foreach (var afterAction in AfterExecutionOperators)
{
var afterActionOperation = ExecutionContext.CreateChildOperation(afterAction);
opCol.Add(afterActionOperation);
}
if (Successor != null)
{
opCol.Add(ExecutionContext.CreateOperation(Successor));
}
return(opCol);
}
public override IOperation Apply()
{
var scopes = ExecutionContext.Scope.SubScopes;
if (scopes.Count < 1)
{
throw new ArgumentException("At least one layer must exist.");
}
var newScope = (IScope)scopes.Last().Clone();
int scopeNumber;
if (int.TryParse(newScope.Name, out scopeNumber))
{
newScope.Name = (scopeNumber + 1).ToString();
}
scopes.Add(newScope);
var next = new OperationCollection(base.Apply());
if (NewLayerOperator != null)
{
next.Insert(0, ExecutionContext.CreateOperation(NewLayerOperator, newScope));
}
return(next);
}
private static void RepairStack(Stack <IOperation> executionStack, Stack <IOperation>[] parallelExecutionStacks)
{
OperationCollection remaining = new OperationCollection()
{
Parallel = true
};
for (int i = 0; i < parallelExecutionStacks.Length; i++)
{
if (parallelExecutionStacks[i].Count == 1)
{
remaining.Add(parallelExecutionStacks[i].Pop());
}
if (parallelExecutionStacks[i].Count > 1)
{
OperationCollection ops = new OperationCollection();
while (parallelExecutionStacks[i].Count > 0)
{
ops.Add(parallelExecutionStacks[i].Pop());
}
remaining.Add(ops);
}
}
if (remaining.Count > 0)
{
executionStack.Push(remaining);
}
}
public static void Main()
{
// Read the 'StockQuote.wsdl' file as input.
ServiceDescription myServiceDescription = ServiceDescription.Read("StockQuote.wsdl");
// Get the operation fault collection and remove the operation fault with the name 'ErrorString'.
PortTypeCollection myPortTypeCollection = myServiceDescription.PortTypes;
PortType myPortType = myPortTypeCollection[0];
OperationCollection myOperationCollection = myPortType.Operations;
Operation myOperation = myOperationCollection[0];
OperationFaultCollection myOperationFaultCollection = myOperation.Faults;
if (myOperationFaultCollection.Contains(myOperationFaultCollection["ErrorString"]))
{
myOperationFaultCollection.Remove(myOperationFaultCollection["ErrorString"]);
}
// Get the fault binding collection and remove the fault binding with the name 'ErrorString'.
// <Snippet1>
BindingCollection myBindingCollection = myServiceDescription.Bindings;
Binding myBinding = myBindingCollection[0];
OperationBindingCollection myOperationBindingCollection = myBinding.Operations;
OperationBinding myOperationBinding = myOperationBindingCollection[0];
FaultBindingCollection myFaultBindingCollection = myOperationBinding.Faults;
if (myFaultBindingCollection.Contains(myFaultBindingCollection["ErrorString"]))
{
myFaultBindingCollection.Remove(myFaultBindingCollection["ErrorString"]);
}
// </Snippet1>
myServiceDescription.Write(Console.Out);
}
/// <summary>
/// 获得数据列表
/// </summary>
/// <returns></returns>
public static List <OperationInfo> GetList()
{
string cacheKey = GetCacheKey();
//本实体已经注册成缓存实体，并且缓存存在的时候，直接从缓存取
if (CachedEntityCommander.IsTypeRegistered(typeof(OperationInfo)) && CachedEntityCommander.GetCache(cacheKey) != null)
{
return(CachedEntityCommander.GetCache(cacheKey) as List <OperationInfo>);
}
else
{
List <OperationInfo> list = new List <OperationInfo>();
OperationCollection collection = new OperationCollection();
Query qry = new Query(Operation.Schema);
collection.LoadAndCloseReader(qry.ExecuteReader());
foreach (Operation operation in collection)
{
OperationInfo operationInfo = new OperationInfo();
LoadFromDAL(operationInfo, operation);
list.Add(operationInfo);
}
//生成缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(OperationInfo)))
{
CachedEntityCommander.SetCache(cacheKey, list);
}
return(list);
}
}
private void LoadOperations(string resourceTypeCode)
{
try
{
OperationCategoryManager opCatMan = new OperationCategoryManager();
OperationCategoryCollection opCats = opCatMan.GetAllOperationCategories();
OperationManager opMan = new OperationManager();
OperationCollection ops = opMan.FindOperationsByResourceType(resourceTypeCode);
cbxListOperations.Items.Clear();
foreach (OperationCategory opCat in opCats)
{
ListItem cbxOperation = new ListItem(opCat.Name, opCat.OperationCode.ToString());
foreach (Operation op in ops)
{
if (op.OperationCode == opCat.OperationCode)
{
cbxOperation.Selected = true;
}
}
cbxListOperations.Items.Add(cbxOperation);
}
}
catch (Exception ex)
{
ucErrorBox.Message = ex.Message;
CurrentFormState = FormState.ErrorState;
this.SaveErrorLog(ex);
}
}
/// <summary>
/// Deals with the next operation, if it is an <see cref="AtomicOperation"/> it is executed,
/// if it is a <see cref="CompositeOperation"/> its single operations are pushed on the execution stack.
/// </summary>
/// <remarks>If an error occurs during the execution the operation is aborted and the operation
/// is pushed on the stack again.<br/>
/// If the execution was successful <see cref="EngineBase.OnOperationExecuted"/> is called.</remarks>
protected virtual void ProcessNextOperation(bool logOperations, CancellationToken cancellationToken)
{
IAtomicOperation atomicOperation = CurrentOperation as IAtomicOperation;
OperationCollection operations = CurrentOperation as OperationCollection;
if (atomicOperation != null && operations != null)
throw new InvalidOperationException("Current operation is both atomic and an operation collection");
if (atomicOperation != null) {
if (logOperations)
Log.LogMessage(string.Format("Performing atomic operation {0}", Utils.Name(atomicOperation)));
PerformAtomicOperation(atomicOperation, cancellationToken);
} else if (operations != null) {
if (logOperations)
Log.LogMessage("Expanding operation collection");
ExecutionStack.AddRange(operations.Reverse());
CurrentOperation = null;
} else if (ExecutionStack.Count > 0) {
if (logOperations)
Log.LogMessage("Popping execution stack");
CurrentOperation = ExecutionStack.Last();
ExecutionStack.RemoveAt(ExecutionStack.Count - 1);
} else {
if (logOperations)
Log.LogMessage("Nothing to do");
}
OperatorTrace.Regenerate(CurrentAtomicOperation);
}
private void GetOperations()
{
try
{
if (Request["id"] != null)
{
int resourceID = int.Parse(Request["id"]);
OperationManager opMan = new OperationManager();
OperationCollection ops = opMan.FindOperationsByResources(resourceID);
cbxListOperation.Items.Clear();
foreach (Operation op in ops)
{
OperationCategoryManager opCatMan = new OperationCategoryManager();
OperationCategory opCat = opCatMan.GetOperationCategory(op.OperationCode);
ListItem cbxOperation = new ListItem(opCat.Name, op.OperationCode.ToString());
ListItem cbxDenyOperation = new ListItem(opCat.Name, op.OperationCode.ToString());
cbxListOperation.Items.Add(cbxOperation);
cbxListDenyOperation.Items.Add(cbxDenyOperation);
}
}
}
catch (Exception ex)
{
ucErrorBox.Message = ex.Message;
CurrentFormState = FormState.ErrorState;
}
}
/// <summary>
/// 获得分页列表,无论是否是缓存实体都从数据库直接拿取数据
/// </summary>
/// <param name="pPageIndex">页数</param>
/// <param name="pPageSize">每页列表</param>
/// <param name="pOrderBy">排序</param>
/// <param name="pSortExpression">排序字段</param>
/// <param name="pRecordCount">列表行数</param>
/// <returns>数据分页</returns>
public static List <OperationInfo> GetPagedList(int pPageIndex, int pPageSize, SortDirection pOrderBy, string pSortExpression, out int pRecordCount)
{
if (pPageIndex <= 1)
{
pPageIndex = 1;
}
List <OperationInfo> list = new List <OperationInfo>();
Query q = Operation.CreateQuery();
q.PageIndex = pPageIndex;
q.PageSize = pPageSize;
q.ORDER_BY(pSortExpression, pOrderBy.ToString());
OperationCollection collection = new OperationCollection();
collection.LoadAndCloseReader(q.ExecuteReader());
foreach (Operation operation in collection)
{
OperationInfo operationInfo = new OperationInfo();
LoadFromDAL(operationInfo, operation);
list.Add(operationInfo);
}
pRecordCount = q.GetRecordCount();
return(list);
}
public void InitializeOperations()
{
// workaround for internal constructor
PortType portType = new PortType();
operations = portType.Operations;
}
/// <summary>
///
/// </summary>
/// <param name="category"></param>
/// <returns></returns>
public OperationCollection FindOperationsByCategory(int operationCode)
{
try
{
OperationCollection collection = new OperationCollection();
// create sql param
SqlParameter prmOperationCode = new SqlParameter("@OperationCode", SqlDbType.Int, 4);
prmOperationCode.Direction = ParameterDirection.Input;
prmOperationCode.Value = operationCode;
// execute stored
using (IDataReader dr = Database.ExecuteReader("UspFindOperationsByResource", CommandType.StoredProcedure, prmOperationCode))
{
while (dr.Read())
{
Operation operation = Populate(dr);
collection.Add(operation);
}
}
return(collection);
}
catch (Exception ex)
{
throw ex;
}
}
public override IOperation Apply() {
OperationCollection next = new OperationCollection();
next.Add(ExecutionContext.CreateOperation(StrategyVectorCrossover));
if (Crossover != null)
next.Add(ExecutionContext.CreateOperation(Crossover));
next.Add(base.Apply());
return next;
}
protected override void RestoreFromSnapshot(AccountSnapshot snapshot)
{
Number = snapshot.Number;
Amount = snapshot.Amount;
Active = snapshot.Active;
ClientId = snapshot.ClientId;
_operations = new OperationCollection(snapshot.Operations);
}
public override IOperation Apply() {
OperationCollection next = new OperationCollection(base.Apply());
if (ConditionParameter.ActualValue != null && ConditionParameter.ActualValue.Value) {
if (TrueBranch != null) next.Insert(0, ExecutionContext.CreateOperation(TrueBranch));
} else {
if (FalseBranch != null) next.Insert(0, ExecutionContext.CreateOperation(FalseBranch));
}
return next;
}
public override IOperation InstrumentedApply() {
var next = new OperationCollection(base.InstrumentedApply());
if (TerminateParameter.ActualValue.Value) {
if (TerminateBranch != null) next.Insert(0, ExecutionContext.CreateOperation(TerminateBranch));
} else {
if (ContinueBranch != null) next.Insert(0, ExecutionContext.CreateOperation(ContinueBranch));
}
return next;
}
/// <summary>
/// 批量装载
/// </summary>
internal static void LoadFromDALPatch(List <OperationInfo> pList, OperationCollection pCollection)
{
foreach (Operation operation in pCollection)
{
OperationInfo operationInfo = new OperationInfo();
LoadFromDAL(operationInfo, operation);
pList.Add(operationInfo);
}
}
public override IOperation Apply() {
OperationCollection next = new OperationCollection(base.Apply());
if (RandomParameter.ActualValue.NextDouble() < ProbabilityParameter.ActualValue.Value) {
if (FirstBranch != null) next.Insert(0, ExecutionContext.CreateOperation(FirstBranch));
} else {
if (SecondBranch != null) next.Insert(0, ExecutionContext.CreateOperation(SecondBranch));
}
return next;
}
public static void Main()
{
try
{
// Read the 'MathService_Input_cs.wsdl' file.
ServiceDescription myDescription =
ServiceDescription.Read("MathService_Input_cs.wsdl");
PortTypeCollection myPortTypeCollection = myDescription.PortTypes;
// Get the 'OperationCollection' for 'SOAP' protocol.
OperationCollection myOperationCollection =
myPortTypeCollection[0].Operations;
Operation myOperation = new Operation();
myOperation.Name = "Add";
OperationMessage myOperationMessageInput =
(OperationMessage) new OperationInput();
myOperationMessageInput.Message = new XmlQualifiedName
("AddSoapIn", myDescription.TargetNamespace);
OperationMessage myOperationMessageOutput =
(OperationMessage) new OperationOutput();
myOperationMessageOutput.Message = new XmlQualifiedName(
"AddSoapOut", myDescription.TargetNamespace);
myOperation.Messages.Add(myOperationMessageInput);
myOperation.Messages.Add(myOperationMessageOutput);
myOperationCollection.Add(myOperation);
if (myOperationCollection.Contains(myOperation) == true)
{
Console.WriteLine("The index of the added 'myOperation' " +
"operation is : " +
myOperationCollection.IndexOf(myOperation));
}
myOperationCollection.Remove(myOperation);
// Insert the 'myOpearation' operation at the index '0'.
myOperationCollection.Insert(0, myOperation);
Console.WriteLine("The operation at index '0' is : " +
myOperationCollection[0].Name);
Operation[] myOperationArray = new Operation[
myOperationCollection.Count];
myOperationCollection.CopyTo(myOperationArray, 0);
Console.WriteLine("The operation(s) in the collection are :");
for (int i = 0; i < myOperationCollection.Count; i++)
{
Console.WriteLine(" " + myOperationArray[i].Name);
}
myDescription.Write("MathService_New_cs.wsdl");
}
catch (Exception e)
{
Console.WriteLine("Exception caught!!!");
Console.WriteLine("Source : " + e.Source);
Console.WriteLine("Message : " + e.Message);
}
}
private DispatchRuntime(SharedRuntimeState shared)
{
_shared = shared;
_operations = new OperationCollection(this);
_synchronizationContext = ThreadBehavior.GetCurrentSynchronizationContext();
_automaticInputSessionShutdown = true;
_unhandled = new DispatchOperation(this, "*", MessageHeaders.WildcardAction, MessageHeaders.WildcardAction);
}
public override IOperation Apply()
{
OperationCollection next = new OperationCollection(base.Apply());
if (operatorGraph.InitialOperator != null)
{
next.Insert(0, ExecutionContext.CreateChildOperation(operatorGraph.InitialOperator));
}
return(next);
}
public override IOperation InstrumentedApply()
{
OperationCollection result = new OperationCollection();
foreach (IOperator op in Operators.CheckedItems.OrderBy(x => x.Index).Select(x => x.Value))
{
result.Add(ExecutionContext.CreateOperation(op));
}
result.Add(base.InstrumentedApply());
return(result);
}
public override IOperation InstrumentedApply() {
IVRPMove move = VRPMoveParameter.ActualValue as IVRPMove;
VRPMoveEvaluator moveEvaluator = move.GetMoveEvaluator();
moveEvaluator.VRPMoveParameter.ActualName = VRPMoveParameter.Name;
OperationCollection next = new OperationCollection(base.InstrumentedApply());
next.Insert(0, ExecutionContext.CreateOperation(moveEvaluator));
return next;
}
public override IOperation Apply()
{
OperationCollection next = new OperationCollection(base.Apply());
IOperator op = OperatorParameter.ActualValue;
if (op != null)
{
next.Insert(0, ExecutionContext.CreateOperation(op));
}
return(next);
}
public override IOperation InstrumentedApply() {
var decoder = ScheduleDecoderParameter.ActualValue;
var evaluator = ScheduleEvaluatorParameter.ActualValue;
if (evaluator == null) throw new InvalidOperationException("A ScheduleEvaluator could not be found.");
var operations = new OperationCollection(base.InstrumentedApply());
operations.Insert(0, ExecutionContext.CreateChildOperation(evaluator));
if (decoder != null) // decode before evaluating
operations.Insert(0, ExecutionContext.CreateChildOperation(decoder));
return operations;
}
public override IOperation Apply() {
int generations = GenerationsParameter.ActualValue.Value;
int ageGap = AgeGapParameter.ActualValue.Value;
var next = new OperationCollection(base.Apply());
if (generations % ageGap == 0) {
var layerZeroScope = ExecutionContext.Scope.SubScopes[0];
if (FirstLayerOperator != null)
next.Insert(0, ExecutionContext.CreateChildOperation(FirstLayerOperator, layerZeroScope));
}
return next;
}
public static void Main()
{
try
{
// Read the 'StockQuote.wsdl' file as input.
ServiceDescription myServiceDescription = ServiceDescription.
Read("StockQuote_cs.wsdl");
// Remove the operation fault with the name 'ErrorString'.
PortTypeCollection myPortTypeCollection = myServiceDescription.
PortTypes;
PortType myPortType = myPortTypeCollection[0];
OperationCollection myOperationCollection = myPortType.Operations;
Operation myOperation = myOperationCollection[0];
// <Snippet1>
OperationFaultCollection myOperationFaultCollection =
myOperation.Faults;
OperationFault myOperationFault =
myOperationFaultCollection["ErrorString"];
if (myOperationFault != null)
{
myOperationFaultCollection.Remove(myOperationFault);
}
// </Snippet1>
// Remove the fault binding with the name 'ErrorString'.
BindingCollection myBindingCollection = myServiceDescription.
Bindings;
Binding myBinding = myBindingCollection[0];
OperationBindingCollection myOperationBindingCollection =
myBinding.Operations;
OperationBinding myOperationBinding =
myOperationBindingCollection[0];
FaultBindingCollection myFaultBindingCollection =
myOperationBinding.Faults;
if (myFaultBindingCollection.Contains(
myFaultBindingCollection["ErrorString"]))
{
myFaultBindingCollection.Remove(
myFaultBindingCollection["ErrorString"]);
}
myServiceDescription.Write("OperationFaultCollection_out.wsdl");
Console.WriteLine("WSDL file with name 'OperationFaultCollection_out.wsdl'" +
" created Successfully");
}
catch (Exception e)
{
Console.WriteLine("Exception caught!!!");
Console.WriteLine("Source : " + e.Source);
Console.WriteLine("Message : " + e.Message);
}
}
public override IOperation Apply()
{
OperationCollection next = new OperationCollection();
next.Add(ExecutionContext.CreateOperation(StrategyVectorCrossover));
if (Crossover != null)
{
next.Add(ExecutionContext.CreateOperation(Crossover));
}
next.Add(base.Apply());
return(next);
}
public override IOperation InstrumentedApply() {
List<IScope> scopes = GetScopesOnLevel(ExecutionContext.Scope, Depth.Value).ToList();
OperationCollection next = new OperationCollection(base.InstrumentedApply());
if (scopes.Count != Operators.Count)
throw new ArgumentException("The number of operators doesn't match the number of sub-scopes at depth " + Depth.Value);
OperationCollection inner = new OperationCollection();
inner.Parallel = Parallel == null ? false : Parallel.Value;
for (int i = 0; i < scopes.Count(); i++) {
inner.Add(ExecutionContext.CreateOperation(Operators[i], scopes[i]));
}
next.Insert(0, inner);
return next;
}
public override IOperation Apply() {
OperationCollection next = new OperationCollection(base.Apply());
if (Operator != null) {
List<IScope> scopes = GetScopesOnLevel(ExecutionContext.Scope, Depth.Value).ToList();
OperationCollection inner = new OperationCollection();
inner.Parallel = Parallel == null ? false : Parallel.Value;
for (int i = 0; i < scopes.Count; i++) {
inner.Add(ExecutionContext.CreateOperation(Operator, scopes[i]));
}
next.Insert(0, inner);
}
return next;
}
private DispatchRuntime(SharedRuntimeState shared)
{
_shared = shared;
_operations = new OperationCollection(this);
_messageInspectors = NewBehaviorCollection <IDispatchMessageInspector>();
_synchronizationContext = ThreadBehavior.GetCurrentSynchronizationContext();
_automaticInputSessionShutdown = true;
_unhandled = new DispatchOperation(this, "*", MessageHeaders.WildcardAction, MessageHeaders.WildcardAction);
_unhandled.InternalFormatter = MessageOperationFormatter.Instance;
_unhandled.InternalInvoker = new UnhandledActionInvoker(this);
}
public override IOperation Apply()
{
IVRPMove move = VRPMoveParameter.ActualValue as IVRPMove;
ITabuMaker moveTabuMaker = move.GetTabuMaker();
(moveTabuMaker as IVRPMoveOperator).VRPMoveParameter.ActualName = VRPMoveParameter.Name;
OperationCollection next = new OperationCollection(base.Apply());
next.Insert(0, ExecutionContext.CreateOperation(moveTabuMaker));
return(next);
}
public NXSessionInfo(Session session, UFSession ufsession)
{
theSession = session;
theUFSession = ufsession;
workPart = theSession.Parts.Work;
displayPart = theSession.Parts.Display;
part_tag = theUFSession.Part.AskDisplayPart();
theUFSession.Part.AskPartName(part_tag, out part_name);
OperationCollection opers = displayPart.CAMSetup.CAMOperationCollection;
NCGroupCollection ncgrc = displayPart.CAMSetup.CAMGroupCollection;
MCSManager.Instance().McsListClear();
foreach (CAMObject camobj in ncgrc.ToArray())
{
if (camobj is OrientGeometry)
{
mcsobj = camobj;
mcs_name = camobj.Name;
mcs_geometry.Add(mcs_name);
workpice_geometry.Add(mcs_name);
MillOrientGeomBuilder millOrientGeom = displayPart.CAMSetup.CAMGroupCollection.CreateMillOrientGeomBuilder(mcsobj);
CartesianCoordinateSystem cartesianCoordinateSystem;
cartesianCoordinateSystem = millOrientGeom.Mcs;
nmx = cartesianCoordinateSystem.Orientation;
origin = cartesianCoordinateSystem.Origin;
MCSManager.Instance().AddValue(nmx, mcs_name, origin);
}
if (camobj is FeatureGeometry)
{
workpice_geometry.Add(camobj.Name);
}
if (camobj is NXOpen.CAM.Operation)
{
opName.Add(camobj.Name);
// NXSessionManager.Instance.OperationList.Add(camobj) ;
// MessageBox.Show(camobj.Name);
}
}
RaisePropertyChanged("GetMcsGeometry");
RaisePropertyChanged("GetWorkPiceGeometry");
RaisePropertyChanged("TheSession");
}
public override IOperation InstrumentedApply() {
IVRPEncoding solution = VRPToursParameter.ActualValue;
if (!(solution is PotvinEncoding)) {
VRPToursParameter.ActualValue = PotvinEncoding.ConvertFrom(solution, ProblemInstance);
}
OperationCollection next = new OperationCollection(base.InstrumentedApply());
VehicleAssignmentParameter.ActualValue = (VRPToursParameter.ActualValue as PotvinEncoding).VehicleAssignment;
VehicleAssignmentManipuator.Value.PermutationParameter.ActualName = VehicleAssignmentParameter.ActualName;
next.Insert(0, ExecutionContext.CreateOperation(VehicleAssignmentManipuator.Value));
return next;
}
public override IOperation InstrumentedApply()
{
IVRPMove move = VRPMoveParameter.ActualValue as IVRPMove;
VRPMoveEvaluator moveEvaluator = move.GetMoveEvaluator();
moveEvaluator.VRPMoveParameter.ActualName = VRPMoveParameter.Name;
OperationCollection next = new OperationCollection(base.InstrumentedApply());
next.Insert(0, ExecutionContext.CreateOperation(moveEvaluator));
return(next);
}
public override IOperation InstrumentedApply()
{
if (!Operators.CheckedItems.Any())
{
throw new InvalidOperationException(Name + ": Please add at least one termination criterion.");
}
var next = new OperationCollection(base.InstrumentedApply());
foreach (var item in Operators.CheckedItems)
{
next.Add(ExecutionContext.CreateOperation(item.Value));
}
return(next);
}
public override IOperation Apply() {
var scopes = ExecutionContext.Scope.SubScopes;
if (scopes.Count < 1)
throw new ArgumentException("At least one layer must exist.");
var newScope = (IScope)scopes.Last().Clone();
int scopeNumber;
if (int.TryParse(newScope.Name, out scopeNumber))
newScope.Name = (scopeNumber + 1).ToString();
scopes.Add(newScope);
var next = new OperationCollection(base.Apply());
if (NewLayerOperator != null)
next.Insert(0, ExecutionContext.CreateOperation(NewLayerOperator, newScope));
return next;
}
private IOperation CreatePruningOperation() {
var operations = new OperationCollection { Parallel = true };
var range = GetSliceBounds();
var qualities = Quality.Select(x => x.Value).ToArray();
var indices = Enumerable.Range(0, qualities.Length).ToArray();
indices.StableSort((a, b) => qualities[a].CompareTo(qualities[b]));
if (!Maximization.Value) Array.Reverse(indices);
var subscopes = ExecutionContext.Scope.SubScopes;
var random = RandomParameter.ActualValue;
var empty = new EmptyOperator();
for (int i = 0; i < indices.Length; ++i) {
IOperator @operator;
if (range.Start <= i && i < range.End && random.NextDouble() <= PruningProbability)
@operator = PruningOperator;
else @operator = empty;
var index = indices[i];
var subscope = subscopes[index];
operations.Add(ExecutionContext.CreateChildOperation(@operator, subscope));
}
return operations;
}
/// <summary>
/// 获得数据列表
/// </summary>
/// <returns></returns>
public static List<OperationInfo> GetList()
{
string cacheKey = GetCacheKey();
//本实体已经注册成缓存实体，并且缓存存在的时候，直接从缓存取
if (CachedEntityCommander.IsTypeRegistered(typeof(OperationInfo)) && CachedEntityCommander.GetCache(cacheKey) != null)
{
return CachedEntityCommander.GetCache(cacheKey) as List< OperationInfo>;
}
else
{
List< OperationInfo> list =new List< OperationInfo>();
OperationCollection collection=new OperationCollection();
Query qry = new Query(Operation.Schema);
collection.LoadAndCloseReader(qry.ExecuteReader());
foreach(Operation operation in collection)
{
OperationInfo operationInfo= new OperationInfo();
LoadFromDAL(operationInfo,operation);
list.Add(operationInfo);
}
//生成缓存
if (CachedEntityCommander.IsTypeRegistered(typeof(OperationInfo)))
{
CachedEntityCommander.SetCache(cacheKey, list);
}
return list;
}
}
/// <summary>
/// 获得分页列表,无论是否是缓存实体都从数据库直接拿取数据
/// </summary>
/// <param name="pPageIndex">页数</param>
/// <param name="pPageSize">每页列表</param>
/// <param name="pOrderBy">排序</param>
/// <param name="pSortExpression">排序字段</param>
/// <param name="pRecordCount">列表行数</param>
/// <returns>数据分页</returns>
public static List<OperationInfo> GetPagedList(int pPageIndex,int pPageSize,SortDirection pOrderBy,string pSortExpression,out int pRecordCount)
{
if(pPageIndex<=1)
pPageIndex=1;
List< OperationInfo> list = new List< OperationInfo>();
Query q = Operation .CreateQuery();
q.PageIndex = pPageIndex;
q.PageSize = pPageSize;
q.ORDER_BY(pSortExpression,pOrderBy.ToString());
OperationCollection collection=new OperationCollection();
collection.LoadAndCloseReader(q.ExecuteReader());
foreach (Operation operation in collection)
{
OperationInfo operationInfo = new OperationInfo();
LoadFromDAL(operationInfo, operation);
list.Add(operationInfo);
}
pRecordCount=q.GetRecordCount();
return list;
}
public override IOperation Apply() {
//code executed in the first call of analyzer
if (qualitiesBeforeCoOp == null) {
double[] trainingQuality;
// sort is ascending and we take the first n% => order so that best solutions are smallest
// sort order is determined by maximization parameter
if (Maximization.Value) {
// largest values must be sorted first
trainingQuality = Quality.Select(x => -x.Value).ToArray();
} else {
// smallest values must be sorted first
trainingQuality = Quality.Select(x => x.Value).ToArray();
}
// sort trees by training qualities
int topN = (int)Math.Max(trainingQuality.Length * PercentageOfBestSolutions, 1);
scopeIndexes = Enumerable.Range(0, trainingQuality.Length).ToArray();
Array.Sort(trainingQuality, scopeIndexes);
scopeIndexes = scopeIndexes.Take(topN).ToArray();
qualitiesBeforeCoOp = scopeIndexes.Select(x => Quality[x].Value).ToArray();
OperationCollection operationCollection = new OperationCollection();
operationCollection.Parallel = true;
foreach (var scopeIndex in scopeIndexes) {
var childOperation = ExecutionContext.CreateChildOperation(ConstantOptimizationEvaluator, ExecutionContext.Scope.SubScopes[scopeIndex]);
operationCollection.Add(childOperation);
}
return new OperationCollection { operationCollection, ExecutionContext.CreateOperation(this) };
}
//code executed to analyze results of constant optimization
double[] qualitiesAfterCoOp = scopeIndexes.Select(x => Quality[x].Value).ToArray();
var qualityImprovement = qualitiesBeforeCoOp.Zip(qualitiesAfterCoOp, (b, a) => a - b).ToArray();
if (!ResultCollection.ContainsKey(DataTableNameConstantOptimizationImprovement)) {
var dataTable = new DataTable(DataTableNameConstantOptimizationImprovement);
ResultCollection.Add(new Result(DataTableNameConstantOptimizationImprovement, dataTable));
dataTable.VisualProperties.YAxisTitle = "R²";
dataTable.Rows.Add(new DataRow(DataRowNameMinimumImprovement));
MinimumImprovement.VisualProperties.StartIndexZero = true;
dataTable.Rows.Add(new DataRow(DataRowNameMedianImprovement));
MedianImprovement.VisualProperties.StartIndexZero = true;
dataTable.Rows.Add(new DataRow(DataRowNameAverageImprovement));
AverageImprovement.VisualProperties.StartIndexZero = true;
dataTable.Rows.Add(new DataRow(DataRowNameMaximumImprovement));
MaximumImprovement.VisualProperties.StartIndexZero = true;
}
MinimumImprovement.Values.Add(qualityImprovement.Min());
MedianImprovement.Values.Add(qualityImprovement.Median());
AverageImprovement.Values.Add(qualityImprovement.Average());
MaximumImprovement.Values.Add(qualityImprovement.Max());
qualitiesBeforeCoOp = null;
scopeIndexes = null;
return base.Apply();
}
public override IOperation Apply() {
IVRPMove move = VRPMoveParameter.ActualValue as IVRPMove;
ITabuChecker tabuChecker;
if (UseAspirationCriterion.Value)
tabuChecker = move.GetSoftTabuChecker();
else
tabuChecker = move.GetTabuChecker();
(tabuChecker as IVRPMoveOperator).VRPMoveParameter.ActualName = VRPMoveParameter.Name;
OperationCollection next = new OperationCollection(base.Apply());
next.Insert(0, ExecutionContext.CreateOperation(tabuChecker));
return next;
}
public virtual IOperation InstrumentedApply() {
if (!AfterExecutionOperators.Any()) {
if (Successor != null) return ExecutionContext.CreateOperation(Successor);
return null;
}
var opCol = new OperationCollection();
foreach (var afterAction in AfterExecutionOperators) {
var afterActionOperation = ExecutionContext.CreateChildOperation(afterAction);
opCol.Add(afterActionOperation);
}
if (Successor != null)
opCol.Add(ExecutionContext.CreateOperation(Successor));
return opCol;
}
public override IOperation Apply() {
int count = NumberOfSolutionsParameter.ActualValue.Value;
IOperator creator = SolutionCreatorParameter.ActualValue;
IOperator evaluator = EvaluatorParameter.ActualValue;
bool parallel = ParallelParameter.ActualValue.Value;
int current = CurrentScope.SubScopes.Count;
for (int i = 0; i < count; i++)
CurrentScope.SubScopes.Add(new Scope((current + i).ToString()));
OperationCollection creation = new OperationCollection();
OperationCollection evaluation = new OperationCollection() { Parallel = parallel };
for (int i = 0; i < count; i++) {
if (creator != null) creation.Add(ExecutionContext.CreateOperation(creator, CurrentScope.SubScopes[current + i]));
if (evaluator != null) evaluation.Add(ExecutionContext.CreateOperation(evaluator, CurrentScope.SubScopes[current + i]));
}
OperationCollection next = new OperationCollection();
next.Add(creation);
next.Add(evaluation);
next.Add(base.Apply());
return next;
}
public override IOperation InstrumentedApply() {
IOperator successor = null;
if (ActualProbabilitiesParameter.ActualValue == null) {
ActualProbabilitiesParameter.Value = ProbabilitiesParameter.ActualValue.Clone() as DoubleArray;
} else {
String key = "SuccessfulOffspringAnalyzer Results";
ResultCollection results = null;
IScope scope = ExecutionContext.Parent.Scope;
int depth = 1;
while (scope != null && depth < DepthParameter.Value.Value) {
scope = scope.Parent;
depth++;
}
if (scope != null)
results = scope.Variables["Results"].Value as ResultCollection;
if (results != null && results.ContainsKey(key)) {
ResultCollection successProgressAnalysisResult = results[key].Value as ResultCollection;
key = SuccessProgressAnalyisis.Value.Value;
if (successProgressAnalysisResult.ContainsKey(key)) {
DataTable successProgressAnalysis = successProgressAnalysisResult[key].Value as DataTable;
for (int i = 0; i < Operators.Count; i++) {
IOperator current = Operators[i];
if (successProgressAnalysis.Rows.ContainsKey(current.Name)) {
DataRow row = successProgressAnalysis.Rows[current.Name];
double sum = 0.0;
ObservableList<double> usages = row.Values;
sum += usages.Last();
ActualProbabilitiesParameter.ActualValue[i] += (sum / ActualProbabilitiesParameter.ActualValue[i]) * Factor.Value.Value;
}
}
}
}
//normalize
double max = ActualProbabilitiesParameter.ActualValue.Max();
for (int i = 0; i < ActualProbabilitiesParameter.ActualValue.Length; i++) {
ActualProbabilitiesParameter.ActualValue[i] /= max;
ActualProbabilitiesParameter.ActualValue[i] =
Math.Max(LowerBoundParameter.Value.Value,
ActualProbabilitiesParameter.ActualValue[i]);
}
}
//////////////// code has to be duplicated since ActualProbabilitiesParameter.ActualValue are updated and used for operator selection
IRandom random = RandomParameter.ActualValue;
DoubleArray probabilities = ActualProbabilitiesParameter.ActualValue;
if (probabilities.Length != Operators.Count) {
throw new InvalidOperationException(Name + ": The list of probabilities has to match the number of operators");
}
var checkedOperators = Operators.CheckedItems;
if (checkedOperators.Count() > 0) {
// select a random operator from the checked operators
successor =
checkedOperators.SampleProportional(random, 1, checkedOperators.Select(x => probabilities[x.Index]), false, false).First().Value;
}
IOperation successorOp = null;
if (Successor != null)
successorOp = ExecutionContext.CreateOperation(Successor);
OperationCollection next = new OperationCollection(successorOp);
if (successor != null) {
SelectedOperatorParameter.ActualValue = new StringValue(successor.Name);
if (CreateChildOperation)
next.Insert(0, ExecutionContext.CreateChildOperation(successor));
else next.Insert(0, ExecutionContext.CreateOperation(successor));
} else {
SelectedOperatorParameter.ActualValue = new StringValue("");
}
return next;
}
public override IOperation Apply() {
if (SimilarityParameter.ActualValue == null || SimilarityParameter.ActualValue.Value.IsAlmost(-1.0)) {
UpdateCounter.Value++;
if (UpdateCounter.Value != UpdateInterval.Value) return base.Apply();
UpdateCounter.Value = 0;
var trees = SymbolicExpressionTreeParameter.ActualValue.ToList();
SimilarityParameter.ActualValue = new DoubleValue();
var operations = new OperationCollection { Parallel = true };
foreach (var tree in trees) {
var op = new SymbolicDataAnalysisExpressionTreeSimilarityCalculator(DistanceCalculatorParameter.Value) {
CurrentSymbolicExpressionTree = tree,
MaximumTreeDepth = MaximumSymbolicExpressionTreeDepth.Value
};
var operation = ExecutionContext.CreateChildOperation(op, ExecutionContext.Scope);
operations.Add(operation);
}
return new OperationCollection { operations, ExecutionContext.CreateOperation(this) };
}
var results = ResultsParameter.ActualValue;
// population diversity
DataTable populationDiversityTable;
if (!results.ContainsKey("PopulationDiversity")) {
populationDiversityTable = new DataTable("PopulationDiversity") { VisualProperties = { YAxisTitle = "Diversity" } };
results.Add(new Result("PopulationDiversity", populationDiversityTable));
}
populationDiversityTable = (DataTable)results["PopulationDiversity"].Value;
if (!populationDiversityTable.Rows.ContainsKey("Diversity"))
populationDiversityTable.Rows.Add(new DataRow("Diversity") { VisualProperties = { StartIndexZero = true } });
int length = SymbolicExpressionTreeParameter.ActualValue.Length;
var similarity = SimilarityParameter.ActualValue.Value / (length * (length - 1) / 2.0);
var diversity = 1 - similarity;
SimilarityParameter.ActualValue.Value = -1.0;
populationDiversityTable.Rows["Diversity"].Values.Add(diversity);
return base.Apply();
}
public override IOperation Apply() {
OperationCollection next = new OperationCollection(base.Apply());
if (operatorGraph.InitialOperator != null)
next.Insert(0, ExecutionContext.CreateChildOperation(operatorGraph.InitialOperator));
return next;
}
public override IOperation Apply() {
IScope currentScope = ExecutionContext.Scope;
Scope localScope = new Scope();
Scope individual = new Scope();
foreach (IVariable var in currentScope.Variables)
individual.Variables.Add(var); // add reference to variable otherwise the analyzer fails (it's looking down the tree)
localScope.SubScopes.Add(individual);
currentScope.SubScopes.Add(localScope);
int index = currentScope.SubScopes.Count - 1;
SubScopesProcessor processor = new SubScopesProcessor();
SubScopesRemover remover = new SubScopesRemover();
remover.RemoveAllSubScopes = false;
remover.SubScopeIndexParameter.Value = new IntValue(index);
if (index > 0) {
EmptyOperator eo = new EmptyOperator();
for (int i = 0; i < index - 1; i++) {
processor.Operators.Add(eo);
}
}
VariableCreator variableCreator = new VariableCreator();
variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(loop.IterationsParameter.ActualName, new IntValue(0)));
variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>(loop.BestLocalQualityParameter.ActualName, new DoubleValue(0)));
variableCreator.Successor = loop;
processor.Operators.Add(variableCreator);
processor.Successor = remover;
OperationCollection next = new OperationCollection(base.Apply());
next.Insert(0, ExecutionContext.CreateChildOperation(processor));
return next;
}
/// <summary>
/// 批量装载
/// </summary>
internal static void LoadFromDALPatch(List< OperationInfo> pList, OperationCollection pCollection)
{
foreach (Operation operation in pCollection)
{
OperationInfo operationInfo = new OperationInfo();
LoadFromDAL(operationInfo, operation );
pList.Add(operationInfo);
}
}
public static void SetOperations(DependencyObject obj, OperationCollection value)
{
obj.SetValue(OperationsProperty, value);
}
public override IOperation Apply() {
IVRPMove move = VRPMoveParameter.ActualValue as IVRPMove;
ITabuMaker moveTabuMaker = move.GetTabuMaker();
(moveTabuMaker as IVRPMoveOperator).VRPMoveParameter.ActualName = VRPMoveParameter.Name;
OperationCollection next = new OperationCollection(base.Apply());
next.Insert(0, ExecutionContext.CreateOperation(moveTabuMaker));
return next;
}
private void Run(object state) {
Stack<IOperation> executionStack = (Stack<IOperation>)state;
IOperation next;
OperationCollection coll;
IAtomicOperation operation;
while (executionStack.Count > 0) {
cancellationToken.ThrowIfCancellationRequested();
next = executionStack.Pop();
if (next is OperationCollection) {
coll = (OperationCollection)next;
if (coll.Parallel) {
Stack<IOperation>[] stacks = new Stack<IOperation>[coll.Count];
for (int i = 0; i < coll.Count; i++) {
stacks[i] = new Stack<IOperation>();
stacks[i].Push(coll[i]);
}
try {
Parallel.ForEach(stacks, parallelOptions, Run);
}
catch (OperationCanceledException ex) {
OperationCollection remaining = new OperationCollection() { Parallel = true };
for (int i = 0; i < stacks.Length; i++) {
if (stacks[i].Count == 1)
remaining.Add(stacks[i].Pop());
if (stacks[i].Count > 1) {
OperationCollection ops = new OperationCollection();
while (stacks[i].Count > 0)
ops.Add(stacks[i].Pop());
remaining.Add(ops);
}
}
if (remaining.Count > 0) executionStack.Push(remaining);
throw ex;
}
} else {
for (int i = coll.Count - 1; i >= 0; i--)
if (coll[i] != null) executionStack.Push(coll[i]);
}
} else if (next is IAtomicOperation) {
operation = (IAtomicOperation)next;
try {
next = operation.Operator.Execute((IExecutionContext)operation, cancellationToken);
}
catch (Exception ex) {
executionStack.Push(operation);
if (ex is OperationCanceledException) throw ex;
else throw new OperatorExecutionException(operation.Operator, ex);
}
if (next != null) executionStack.Push(next);
if (operation.Operator.Breakpoint) {
string message = string.Format("Breakpoint: {0}", operation.Operator.Name != string.Empty ? operation.Operator.Name : operation.Operator.ItemName);
Log.LogMessage(message);
throw new OperationCanceledException(message);
}
}
}
}
public sealed override IOperation Apply() {
//to speed up the execution call instrumented apply directly if no before operators exists
if (!BeforeExecutionOperators.Any())
return InstrumentedApply();
//build before operations
var opCol = new OperationCollection();
foreach (var beforeAction in BeforeExecutionOperators) {
var beforeActionOperation = ExecutionContext.CreateChildOperation(beforeAction);
opCol.Add(beforeActionOperation);
}
//build operation for the instrumented apply
opCol.Add(CreateInstrumentedOperation(this));
return opCol;
}
