/// <summary>
/// this method Start Training
/// </summary>
/// <returns></returns>
public async Task <bool> DoTrain(GettingStarted gettingStarted)
{
var firstPopulation = await _randomSelection.HandleSelection(gettingStarted.Items, gettingStarted.KnapsakCapacity, Selection.Random);
var maximumChild = new Individual(gettingStarted.Items);
await Task.Run(() =>
{
for (int i = 0; i < gettingStarted.NumberOfGenerationRepetitions; i++)
{
TryChanged.Invoke(i);
var parent = _rouletteWeelSelection.HandleSelection(firstPopulation, gettingStarted.NumberOfParents, Selection.RouletteWheel).Result;
//فاصله گرفتن از
firstPopulation = _rouletteWeelSelection.HandleSelection(parent, gettingStarted.NumberOfParents, Selection.RouletteWheel).Result;
for (int j = 0; j < gettingStarted.NumberOfParents; j++)
{
ParentChanged.Invoke(j);
if (firstPopulation[j].Fitness > maximumChild.Fitness)
{
maximumChild = firstPopulation[j];
//Send Notification
MaximumChildChanged.Invoke(maximumChild, j, i);
}
if (firstPopulation[j + 1].Fitness > maximumChild.Fitness)
{
maximumChild = firstPopulation[j + 1];
//Send Notification
MaximumChildChanged.Invoke(maximumChild, j, i);
}
//Recombination between two chromosomes together
var childs = _crossOver.HandleRecombination(firstPopulation[j], firstPopulation[j + 1], Recombination.None).Result;
/// میو + لاندا
firstPopulation.Add(childs.first);
if (childs.first.Fitness > maximumChild.Fitness)
{
maximumChild = childs.first;
//Send Notification
MaximumChildChanged.Invoke(maximumChild, j, i);
}
firstPopulation.Add(childs.second);
if (childs.second.Fitness > maximumChild.Fitness)
{
maximumChild = childs.second;
//Send Notification
MaximumChildChanged.Invoke(maximumChild, j, i);
}
}
}
});
ExcetedFitness = maximumChild.Fitness;
return(true);
}
/// <summary>
/// Called when this transform's parent changes.
/// </summary>
/// <param name="newParent">The new parent. May be null.</param>
private void SetParent(Transform newParent)
{
var oldParent = _parent;
if (oldParent != null)
{
oldParent._children.Remove(this);
oldParent.TransformChanged -= OnParentTransformChanged;
oldParent.PositionManuallyChanged -= OnParentPositionChanged;
oldParent.RotationManuallyChanged -= OnParentRotationChanged;
}
_parent = newParent;
if (newParent != null)
{
newParent._children.Add(this);
newParent.TransformChanged += OnParentTransformChanged;
newParent.PositionManuallyChanged += OnParentPositionChanged;
newParent.RotationManuallyChanged += OnParentRotationChanged;
}
ParentChanged?.Invoke(this, oldParent, _parent);
TransformChanged?.Invoke(this);
OnPositionChanged();
}
public void Handle(ParentChanged e)
{
using (var session = _store.OpenSession())
{
var get = session.Load <Responses.Get>(e.AccountId);
if (e.ParentId.HasValue)
{
var parent = session.Load <Responses.Get>(e.ParentId);
get.ParentId = e.ParentId;
get.Parent = parent.Name;
var parentCode = parent.Code;
while (parent.ParentId.HasValue)
{
parent = session.Load <Responses.Get>(parent.ParentId);
parentCode = parent.Code + parentCode;
}
get.ParentCode = parentCode;
}
else
{
get.ParentId = null;
get.ParentCode = "";
get.Parent = "";
}
session.SaveChanges();
_manager.Publish(get);
}
}
public void Handle(ParentChanged e)
{
if (e.ParentId.HasValue)
{
var parent = _elastic.Get <Responses.Index>(e.ParentId.Value).Source;
var parentName = parent.Name;
var parentCode = parent.Code;
while (parent.ParentId.HasValue)
{
parent = _elastic.Get <Responses.Index>(parent.ParentId.Value).Source;
parentCode = parent.Code + parentCode;
}
_elastic.Update <Responses.Index, Object>(x => x
.Id(e.AccountId)
.Doc(new { ParentCode = parentCode, ParentId = e.ParentId, Parent = parentName })
.RetryOnConflict(3)
.Refresh()
);
}
else
{
_elastic.Update <Responses.Index, Object>(x => x
.Id(e.AccountId)
.Doc(new { ParentCode = "", ParentId = (Guid?)null, Parent = "" })
.RetryOnConflict(3)
.Refresh()
);
}
var index = _elastic.Get <Responses.Index>(e.AccountId);
_manager.Publish(index.Source);
}
protected virtual void OnParentChanged()
{
OnLocationChanged();
if (ParentChanged != null)
{
ParentChanged.Invoke(this, EventArgs.Empty);
}
}
private void Update()
{
if (transform.parent != m_Parent)
{
m_Parent = transform.parent;
ParentChanged?.Invoke(this, m_Parent);
}
}
protected override void OnParentSet()
{
base.OnParentSet();
if (LastParent != Parent)
{
ParentChanged?.Invoke(this, new ChangedEventArgs <Layout <View> >(LastParent, Parent));
LastParent = Parent;
}
}
/// <summary />
public Explosion()
{
_emitter = new ParticleEmitter();
_ghostObject = new GhostObject {
UserObject = this, CollisionFlags = CollisionFlags.NoContactResponse
};
BlastPressure = 500000;
BlastRadius = 4;
Craters = true;
OnHit = new Signal <Part, float>(this);
ParentChanged.Connect(OnParentChanged);
RunService.Service.SimulationStarted.Connect(Explode);
}
public void OnEndDrag(PointerEventData eventData)
{
GetComponent <CanvasGroup>().blocksRaycasts = true;
//Parent might be changed by other script when ui element is dropped
if (TransformComponent.parent.gameObject != DragParentTransform.gameObject)
{
ParentTransform = TransformComponent.parent.gameObject.GetComponent <RectTransform>();
TransformComponent.SetParent(ParentTransform);
ParentChanged?.Invoke(this.gameObject, ParentTransform.gameObject);
}
else
{
TransformComponent.SetParent(ParentTransform);
TransformComponent.SetSiblingIndex(SiblingIndex);
}
}
/// <summary>
/// Fires any cached events when events are resumed.
/// </summary>
protected override void OnEventsResumed()
{
lock (SyncRoot)
{
// Fire any cached base class events
base.OnEventsResumed();
// Do nothing more when no events are cached for this class
if (_parentChangeEventCache == null)
{
return;
}
// Clear cache
var args = _parentChangeEventCache;
_parentChangeEventCache = null !;
// Fire event
ParentChanged?.Invoke(this, args);
}
}
public void DroppedOn(GardenDropper laboratorySeeds)
{
ParentChanged.Invoke(this);
}
public async Task <bool> DoTrain(MinFunGettingStarted gettingStarted)
{
var firstPopulation = await _selectionHandler.ProcessSelection(null, gettingStarted.ChoromosemeLenght, Selection.Random);
var maximumChild = new MinFuncIndividual(new double[gettingStarted.ChoromosemeLenght]);
await Task.Run(() =>
{
//var threadId = Thread.CurrentThread.ManagedThreadId;
for (int i = 0; i < gettingStarted.NumberOfGenerationRepetitions; i++)
{
//threadId = Thread.CurrentThread.ManagedThreadId;
TryChanged.Invoke(i);
var parent = _selectionHandler.ProcessSelection(firstPopulation, gettingStarted.NumberOfParents, gettingStarted.SelectionList).Result;
for (int j = 0; j < gettingStarted.NumberOfParents - 1; j++)
{
ParentChanged.Invoke(j);
var random = RandomHelper.CreateRandom(0, 10);
if (random == 5)
{
//create childs by recombination
var childs = _recombinationHandler.ProcessRecombinationHandler(parent[j], parent[j + 1], gettingStarted.Recombinations).Result;
// Compute childs fitness to function
var child1New = _functionHandler.ProcessHandleFitness(childs.first, gettingStarted.ChoromosemeLenght, gettingStarted.FunctionSelected).Result;
var child2New = _functionHandler.ProcessHandleFitness(childs.second, gettingStarted.ChoromosemeLenght, gettingStarted.FunctionSelected).Result;
//Choose Max Child//
var chooseChild = (child1New.Fitness >= child2New.Fitness) ?
child1New : child2New;
if (chooseChild.Fitness > maximumChild.Fitness)
{
maximumChild = chooseChild;
//Invoke
MaximumChildChanged.Invoke(maximumChild, MutationOrRecombination.Recombination, j, i);
}
// میو + لاندا
firstPopulation.Add(child1New);
firstPopulation.Add(child2New);
}
else
{
//create childs by mutation
var mutationChild = _mutationnHandler.ProcessMutationHandler(parent[j], gettingStarted.mutationList).Result;
//update child fitness => by function
var childUpdateFitness = _functionHandler.ProcessHandleFitness(mutationChild, gettingStarted.ChoromosemeLenght, gettingStarted.FunctionSelected).Result;
//Choose Max Child //
if (childUpdateFitness.Fitness > maximumChild.Fitness)
{
maximumChild = childUpdateFitness;
//Invoke
//MaximumChildChanged.Invoke(maximumChild, MutationOrRecombination.Mutation, j, i);
MaximumChildChanged.Invoke(maximumChild, MutationOrRecombination.Mutation, j, i);
}
//update case positive or not
_mutationnHandler.ProcessUpdateCase(mutationChild, childUpdateFitness, gettingStarted.mutationList);
// میو + لاندا
firstPopulation.Add(childUpdateFitness);
}
}
// update sigma
_mutationnHandler.ProcessUpdateStatus(gettingStarted.mutationList);
}
ExcetedFitness = _functionHandler.ProcessHanldeExcutedFitness(maximumChild, gettingStarted.FunctionSelected).Result;
});
return(true);
}
/// <summary>
/// Gets called when the parent element of the current element changes
/// </summary>
/// <param name="newParent">The new parent element</param>
/// <param name="oldParent">The old parent element</param>
protected virtual void OnParentChanged(IModelElement newParent, IModelElement oldParent)
{
ParentChanged?.Invoke(this, new ValueChangedEventArgs(oldParent, newParent));
}
protected virtual void OnParentChanged(Visual3D visual)
{
ParentChanged?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// Raise the ParentChanged event
/// </summary>
/// <param name="newParentBoard"></param>
protected virtual void OnParentChanged(TBoard newParentBoard)
{
Plank = ParentBoard.Plank;
ParentChanged?.Invoke(this, newParentBoard);
}
private void OnTransformParentChanged()
{
ParentChanged?.Invoke();
}
protected override void Loaded(BehaviorLoadedEventArgs args)
{
args.TrackSubscription(ParentChanged.Subscribe(OnParentChanged));
}
protected virtual void onParentChanged(object sender, DataSourceChangeEventArgs e) {
ParentChanged.Raise (this, e);
if (logicalParent == null)
LogicalParentChanged.Raise (this, e);
}
public bool ChangeParent(Drawer newParent, int indexInNewParent)
{
var oldParent = parent;
if (oldParent != null && oldParent.childrenEnumerating)
{
var msg = string.Format(
"Attempt to remove child '{0}' from '{1}' while its children enumerating.",
HierarchicalName, oldParent.HierarchicalName);
throw new InvalidOperationException(msg);
}
if (newParent != null)
{
Ensure.Argument.IsValidIndex(indexInNewParent, "indexInParent", newParent.ChildCount + 1);
if (newParent.childrenEnumerating)
{
var msg = string.Format(
"Attempt to add child '{0}' to '{1}' while its children enumerating.",
HierarchicalName, newParent.HierarchicalName);
throw new InvalidOperationException(msg);
}
}
if (newParent == parent)
{
return(false);
}
// Notifications for public.
ParentChanging.NPInvoke(newParent);
// Notifications for deriveds.
BeforeChangeParent(newParent);
parent = newParent;
// Update children list
if (oldParent != null)
{
oldParent.children.Remove(this);
}
if (newParent != null)
{
var childList = newParent.children;
childList.Insert(indexInNewParent, this);
}
UpdateDepthInHierarchy();
Root = newParent != null ? newParent.Root : this;
if (oldParent != null)
{
oldParent.MarkHierarchicalNameDirty();
}
MarkHierarchicalNameDirty();
// Notifications for deriveds.
AfterChangeParent(oldParent);
if (oldParent != null)
{
oldParent.OnChildRemoved(this);
}
if (newParent != null)
{
newParent.OnChildAdded(this);
}
// Notifications for public.
ParentChanged.NPInvoke(oldParent);
if (oldParent != null)
{
oldParent.NotifyChildRemoved(this);
}
if (newParent != null)
{
newParent.NotifyChildAdded(this);
}
return(true);
}
protected override bool HandleMessage(WidgetMessage message, Widget widget, IntPtr param1, IntPtr param2)
{
bool handled = false;
switch (message)
{
case WidgetMessage.Create:
Created?.Invoke(widget, param1 != default, ref handled);
break;
case WidgetMessage.Destroy:
Destroyed?.Invoke(widget, param1 != default, ref handled);
break;
case WidgetMessage.Paint:
Paint?.Invoke(widget, ref handled);
break;
case WidgetMessage.Draw:
Draw?.Invoke(widget, ref handled);
break;
case WidgetMessage.KeyPress:
KeyPressed?.Invoke(widget, ref AsRef <KeyState>(param1), ref handled);
break;
case WidgetMessage.KeyTakeFocus:
TakingFocus?.Invoke(widget, param1 != default, ref handled);
break;
case WidgetMessage.KeyLoseFocus:
LostFocus?.Invoke(widget, param1 != default, ref handled);
break;
case WidgetMessage.MouseDown:
MouseDown?.Invoke(widget, ref AsRef <MouseState>(param1), ref handled);
break;
case WidgetMessage.MouseDrag:
MouseDrag?.Invoke(widget, ref AsRef <MouseState>(param1), ref handled);
break;
case WidgetMessage.MouseUp:
MouseUp?.Invoke(widget, ref AsRef <MouseState>(param1), ref handled);
break;
case WidgetMessage.Reshape:
Reshape?.Invoke(widget, Widget.GetOrCreate(param1), ref AsRef <WidgetGeometryChange>(param2), ref handled);
break;
case WidgetMessage.ExposedChanged:
ExposedChanged?.Invoke(widget, ref handled);
break;
case WidgetMessage.AcceptChild:
ChildAdded?.Invoke(widget, Widget.GetOrCreate(param1), ref handled);
break;
case WidgetMessage.LoseChild:
ChildRemoved?.Invoke(widget, Widget.GetOrCreate(param1), ref handled);
break;
case WidgetMessage.AcceptParent:
ParentChanged?.Invoke(widget, param1 != default ? Widget.GetOrCreate(param1) : null, ref handled);
break;
case WidgetMessage.Shown:
Shown?.Invoke(widget, Widget.GetOrCreate(param1), ref handled);
break;
case WidgetMessage.Hidden:
Hidden?.Invoke(widget, Widget.GetOrCreate(param1), ref handled);
break;
case WidgetMessage.DescriptorChanged:
DescriptorChanged?.Invoke(widget, ref handled);
break;
case WidgetMessage.PropertyChanged:
PropertyChanged?.Invoke(widget, param1.ToInt32(), param2, ref handled);
break;
case WidgetMessage.MouseWheel:
MouseWheel?.Invoke(widget, ref AsRef <MouseState>(param1), ref handled);
break;
case WidgetMessage.CursorAdjust:
CursorAdjust?.Invoke(widget, ref AsRef <MouseState>(param1), ref AsRef <CursorStatus>(param2), ref handled);
break;
}
return(handled);
}
public void OnParentChanged(INode sender, INode oldParent) => ParentChanged?.Invoke(sender, oldParent);
private void OnParentChanged(int parentID)
{
ElementChanged?.Invoke(parentID);
ParentChanged?.Invoke(parentID);
}
private void OnParentChanged(ObservableSortedTree <T> oldParent)
{
ParentChanged?.Invoke(this, oldParent);
}
protected virtual void OnParentChanged(ControlDiffArgs e)
{
ParentChanged?.Invoke(this, e);
}
public void DroppedOn(LaboratorySeeds laboratorySeeds)
{
this.transform.SetParent(laboratorySeeds.transform);
ParentChanged.Invoke(this);
}
