private void QuickSort_Recursive(CircleArray circles, int left, int right)
{
if (left < right)
{
StartCoroutine(Coroutine(circles, left, right));
}
}
private int Partition(CircleArray circles, int left, int right)
{
GameObject pivotGameObject = Extension.GetObjectByActualPosition(circles, left);
for (;;)
{
while (Extension.Compare(pivotGameObject, Extension.GetObjectByActualPosition(circles, left)))
{
left++;
}
while (Extension.Compare(Extension.GetObjectByActualPosition(circles, right), pivotGameObject))
{
right--;
}
if (left < right)
{
Extension.Swap(Extension.GetObjectByActualPosition(circles, right), Extension.GetObjectByActualPosition(circles, left));
}
else
{
return(right);
}
}
}
public void Sort(CircleArray objects, Enums.Shuffle selectedSorting)
{
this.Sort(objects);
switch (selectedSorting)
{
case Enums.Shuffle.Almost_Sorted:
this._almostSort.Shuffle(objects);
break;
case Enums.Shuffle.Random:
this._randomSort.Shuffle(objects);
break;
case Enums.Shuffle.Sorted:
break;
case Enums.Shuffle.Reversed:
this._reversedSort.Shuffle(objects);
break;
default:
break;
}
}
public override IEnumerator Sort(CircleArray objects)
{
IsFinished = false;
int tmpIdx = objects.Length - 1;
for (int p = 0; p < objects.Length - 2; p++)
{
for (int i = 0; i < objects.Length - 1; i++)
{
GameObject prev = Extension.GetObjectByActualPosition(objects, i);
GameObject next = Extension.GetObjectByActualPosition(objects, i + 1);
if (Extension.Compare(prev, next))
{
Extension.Swap(prev, next);
}
yield return(new WaitForSeconds(Time));
}
tmpIdx--;
}
IsFinished = true;
}
public void MovingTest()
{
var cl = new CircleArray<int>(new int[] { 0, 1, 2, 3, 4, 5, 6 });
Assert.AreEqual(7, cl.Length);
for (var i = 0; i <= 19; ++i) // here we has stopped on 19 in order to test reset
{
Assert.AreEqual(i % 7, cl.Current);
cl.MoveForward();
}
cl.Reset();
for (var i = 21; i >= 0; --i)
{
Assert.AreEqual(i % 7, cl.Current);
cl.MoveBack();
}
cl.Reset();
Assert.AreEqual(0, cl.Current);
Assert.AreEqual(1, cl.Next);
Assert.AreEqual(6, cl.Prev);
Assert.AreEqual(3, cl[3]);
}
public override IEnumerator Sort(CircleArray objects)
{
double gap = objects.Length;
bool swaps = true;
while (gap > 1 || swaps)
{
gap /= 1.247330950103979;
if (gap < 1)
{
gap = 1;
}
int i = 0;
swaps = false;
while (i + gap < objects.Length)
{
int igap = i + (int)gap;
GameObject iGO = Extension.GetObjectByActualPosition(objects, i);
GameObject igapGO = Extension.GetObjectByActualPosition(objects, igap);
if (Extension.Compare(iGO, igapGO))
{
Extension.Swap(iGO, igapGO);
swaps = true;
}
++i;
yield return(new WaitForSeconds(Time));
}
}
}
public DetectorControlPanel(IEnumerable <Detector> dets)
{
try
{
InitializeComponent();
_dets = new CircleArray <Detector>(dets);
foreach (var d in dets)
{
d.StatusChanged += DetStatusChangedHandler;
}
DesktopLocation = new Point(Screen.PrimaryScreen.Bounds.Left + 10, Screen.PrimaryScreen.Bounds.Bottom - Size.Height - 50);
Disposed += DetectorControlPanel_Disposed;
Load += DetectorControlPanel_Load;
}
catch (Exception ex)
{
Report.Notify(new RCM.Message(Codes.ERR_UI_WF_DCP_CTOR_UNREG)
{
DetailedText = ex.ToString()
});
}
}
public static void AddFade(CircleArray objects)
{
for (int i = 0; i < objects.Length; i++)
{
Color c = objects[i].GetComponent <Circle>().Color;
objects[i].GetComponent <Circle>().Color = new Color(c.r, c.g, c.b, .65f);
}
}
public override IEnumerator Sort(CircleArray circles)
{
IsFinished = false;
QuickSort_Recursive(circles, 0, circles.Length - 1);
yield return(new WaitForSeconds(0));
IsFinished = true;
}
public virtual void Shuffle(CircleArray circles)
{
int r0, r1;
for (int i = 0; i < LoopCount; i++)
{
r0 = Random.Range(0, circles.Length);
r1 = Random.Range(0, circles.Length);
Extension.Swap(circles[r0], circles[r1]);
}
}
public virtual void Shuffle(CircleArray circles)
{
int r0, r1;
for (int i = 0; i < circles.Length / 2; i++)
{
r0 = i;
r1 = circles.Length - 1 - i;
Extension.Swap(circles[r0], circles[r1]);
}
}
public static GameObject GetObjectByActualPosition(CircleArray objects, int idx)
{
for (int i = 0; i < objects.Length; i++)
{
if (objects[i].GetComponent <Circle>().ActualIndex == idx)
{
return(objects[i]);
}
}
return(null);
}
private IEnumerator Coroutine(CircleArray circles, int left, int right)
{
yield return(new WaitForSeconds(Time));
int pivot = Partition(circles, left, right);
if (pivot > 1)
{
QuickSort_Recursive(circles, left, pivot - 1);
}
if (pivot + 1 < right)
{
QuickSort_Recursive(circles, pivot + 1, right);
}
}
private void Sort(CircleArray objects)
{
int smallest;
for (int i = 0; i < objects.Length - 1; i++)
{
smallest = i;
for (int j = i + 1; j < objects.Length; j++)
{
if (Extension.Compare(Extension.GetObjectByActualPosition(objects, smallest), Extension.GetObjectByActualPosition(objects, j)))
{
smallest = j;
}
}
Extension.Swap(Extension.GetObjectByActualPosition(objects, smallest), Extension.GetObjectByActualPosition(objects, i));
}
}
private async void MainForm_Load(object sender, EventArgs e)
{
Labels.SetControlsLabels(mainForm);
mainForm.MainRDGV.HideColumns();
//mainForm.MainRDGV.SetUpReadOnlyColumns();
mainForm.MainRDGV.SetUpWritableColumns();
mainForm.MainRDGV.Sorted += MainRDGV_Sorted;
mainForm.MainRDGV.Columns["DateTimeStart"].DefaultCellStyle.Format = "dd.MM.yyyy HH:mm:ss";
mainForm.MainRDGV.Columns["DateTimeFinish"].DefaultCellStyle.Format = "dd.MM.yyyy HH:mm:ss";
var w = mainForm.MainRDGV.Width;
var typW = 0.05;
mainForm.MainRDGV.Columns["CountryCode"].Width = (int)(w * typW);
mainForm.MainRDGV.Columns["ClientNumber"].Width = (int)(w * typW);
mainForm.MainRDGV.Columns["Year"].Width = (int)(w * typW);
mainForm.MainRDGV.Columns["SetNumber"].Width = (int)(w * typW);
mainForm.MainRDGV.Columns["SetIndex"].Width = (int)(w * typW);
mainForm.MainRDGV.Columns["SampleNumber"].Width = (int)(w * typW);
mainForm.MainRDGV.Columns["DiskPosition"].Width = (int)(w * typW);
mainForm.MainRDGV.Columns["DateTimeStart"].Width = (int)(w * 0.1);
mainForm.MainRDGV.Columns["Duration"].Width = (int)(w * 0.1);
mainForm.MainRDGV.Columns["FileSpectra"].Width = (int)(w * typW);
mainForm.MainRDGV.Columns["Height"].Width = (int)(w * typW);
mainForm.MainRDGV.Columns["Detector"].Width = (int)(w * typW);
mainForm.MainRDGV.Columns["DeadTime"].Width = (int)(w * typW);
var tmpArr = new List <string>(8);
await foreach (var d in Detector.GetAvailableDetectorsAsyncStream())
{
if (!string.IsNullOrEmpty(d))
{
CheckedAvailableDetectorArrayControl.Add(d);
tmpArr.Add(d);
}
}
_circleDetArray = new CircleArray <string>(tmpArr.OrderBy(d => d).ToArray());
mainForm.buttonClearRegister.Enabled = true;
buttonShowAcqQueue.Enabled = true;
}
public IEnumerator Sort(CircleArray objects, Enums.Algorithm selectedSorting)
{
switch (selectedSorting)
{
case Enums.Algorithm.Selection:
return(this._selectionSort.Sort(objects));
case Enums.Algorithm.Bubble:
return(this._bubbleSort.Sort(objects));
case Enums.Algorithm.Comb:
return(this._combSort.Sort(objects));
case Enums.Algorithm.Merge:
return(this._mergeSort.Sort(objects));
}
return(null);
}
public override IEnumerator Sort(CircleArray objects)
{
IsFinished = false;
int smallest;
for (int i = 0; i < objects.Length - 1; i++)
{
smallest = i;
for (int j = i + 1; j < objects.Length; j++)
{
if (Extension.Compare(Extension.GetObjectByActualPosition(objects, smallest), Extension.GetObjectByActualPosition(objects, j)))
{
smallest = j;
}
yield return(new WaitForSeconds(Time));
}
Extension.Swap(Extension.GetObjectByActualPosition(objects, smallest), Extension.GetObjectByActualPosition(objects, i));
}
IsFinished = true;
}
public abstract IEnumerator Sort(CircleArray objects);
public override void Shuffle(CircleArray circles)
{
base.LoopCount = 1000;
base.Shuffle(circles);
}
