/// <summary>
/// Sort elements in an Array object, using the Order
/// delegate to determine how items should be sorted.
/// </summary>
/// <param name="table">Array to be sorted</param>
/// <param name="sortHandler">Delegate to manage
/// sort order.</param>
public void Sort(Array table, Order sortHandler)
{
if(sortHandler == null)
throw new ArgumentNullException();
bool nothingSwapped = false;
int pass = 1;
while(nothingSwapped == false)
{
nothingSwapped = true;
for(int index = 0; index < table.Length - pass; ++index)
{
// Use an Order delegate to determine the sort order.
if(sortHandler(table.GetValue(index),
table.GetValue(index + 1)) == false)
{
nothingSwapped = false;
object temp = table.GetValue(index);
table.SetValue(table.GetValue(index + 1), index);
table.SetValue(temp, index + 1);
}
}
++pass;
}
}
public static void swapTo(float input, Array dest, int pos)
{
byte[] tmpIn = BitConverter.GetBytes(input);
dest.SetValue(tmpIn[3], pos);
dest.SetValue(tmpIn[2], pos + 1);
dest.SetValue(tmpIn[1], pos + 2);
dest.SetValue(tmpIn[0], pos + 3);
}
public static void Shuffle(this Random rng, Array array)
{
int n = array.Length;
while (n > 1) {
int k = rng.Next (n--);
object temp = array.GetValue (n);
array.SetValue (array.GetValue (k), n);
array.SetValue (temp, k);
}
}
protected override void SortGenericArray(Array items, int left, int right)
{
int lo = left;
int hi = right;
if (lo >= hi)
{
return;
}
int mid = (lo + hi) / 2;
// Partition the items into two lists and Sort them recursively
SortGenericArray(items, lo, mid);
SortGenericArray(items, mid + 1, hi);
// Merge the two sorted lists
int end_lo = mid;
int start_hi = mid + 1;
while ((lo <= end_lo) && (start_hi <= hi))
{
if (this.comparer.Compare(items.GetValue(lo), items.GetValue(start_hi)) < 0)
{
lo++;
}
else
{
/*
* items[lo] >= items[start_hi]
* The next element comes from the second items,
* move the items[start_hi] element into the next
* position and shuffle all the other elements up.
*/
object T = items.GetValue(start_hi);
for (int k = start_hi - 1; k >= lo; k--)
{
items.SetValue(items.GetValue(k), k + 1);
}
items.SetValue(T, lo);
lo++;
end_lo++;
start_hi++;
}
}
}
public Palette(int randomSeed, int colorX, int colorY)
{
_random = new Random(randomSeed);
ColorList = new List<PaletteColor>();
Bitmap bmp;
try
{
bmp = Properties.Resources.ColourPalette;
_colorArr = Array.CreateInstance(typeof(Color), bmp.Height / colorX);
var y = colorY;
var ind = 0;
while (y < bmp.Height)
{
var clr = bmp.GetPixel(colorY, y);
y += colorX;
_colorArr.SetValue(clr, ind);
ind++;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public void CopyTo(Array array, int index){
IEnumerator tablecell = this.GetEnumerator();
while(tablecell.MoveNext()){
index = index + 1;
array.SetValue(tablecell.Current, index);
}
}
public void CopyTo(Array array, int index)
{
foreach (object item in this)
{
array.SetValue(item, index++);
}
}
void ICollection.CopyTo(Array array, int index)
{
foreach (DesignSurface surface in this)
{
array.SetValue(surface, index++);
}
}
public void CopyTo(Array array, int index)
{
foreach (MethodData data in this)
{
array.SetValue(data, index++);
}
}
private void fillHeftArray(int spaceDimension, int histogramResolution, Array array, Array heftArray)
{
int cellNO = (int)Math.Pow(histogramResolution, spaceDimension);
int[] outerIndicesArray = new int[spaceDimension];
int[] innerIndicesArray = new int[spaceDimension];
int[] windowIndicesArray = new int[spaceDimension];
for (int outerCellIdx = 0; outerCellIdx < cellNO; outerCellIdx++)
{
transformator.transformCellIdxToIndicesArray(histogramResolution, outerIndicesArray, outerCellIdx);
for (int innerCellIdx = outerCellIdx; innerCellIdx < cellNO; innerCellIdx++)
{
transformator.transformCellIdxToIndicesArray(histogramResolution, innerIndicesArray, innerCellIdx);
int[] heftArrayIndeces;
int cellPoints;
bool validHeftArrayIndeces = transformator.mergeIndicesArrays(spaceDimension, outerIndicesArray,
innerIndicesArray, out heftArrayIndeces, out cellPoints);
if (validHeftArrayIndeces)
{
int cellValue = 0;
for (int windowIdx = outerCellIdx; windowIdx <= innerCellIdx; windowIdx++)
{
transformator.transformCellIdxToIndicesArray(histogramResolution, windowIndicesArray, windowIdx);
bool validSummableArrayIndeces = transformator.validateIndicesArrays(spaceDimension,
outerIndicesArray, innerIndicesArray, windowIndicesArray);
if (validSummableArrayIndeces)
{
cellValue += (int)array.GetValue(windowIndicesArray);
}
}
heftArray.SetValue(cellValue, heftArrayIndeces);
}
}
}
}
public virtual void CopyTo(Array array, int index)
{
foreach (object k in keys)
{
array.SetValue(hash[k], index++);
}
}
/// <summary>
/// Modifies the specified array by applying the specified function to each element.
/// </summary>
/// <param name="a"></param>
/// <param name="func">object delegate(object o){}</param>
/// <returns></returns>
public static void ForEach(Array a, ForEachFunction func)
{
long[] ix = new long[a.Rank];
//Init index
for (int i = 0; i < ix.Length; i++) ix[i] = a.GetLowerBound(i);
//Loop through all items
for (long i = 0; i < a.LongLength; i++)
{
a.SetValue(func(a.GetValue(ix)), ix);
//Increment ix, the index
for (int j = 0; j < ix.Length; j++)
{
if (ix[j] < a.GetUpperBound(j))
{
ix[j]++;
break; //We're done incrementing.
}
else
{
//Ok, reset this one and increment the next.
ix[j] = a.GetLowerBound(j);
//If this is the last dimension, assert
//that we are at the last element
if (j == ix.Length - 1)
{
if (i < a.LongLength - 1) throw new Exception();
}
continue;
}
}
}
return;
}
void ICollection.CopyTo(Array dest, int index)
{
int count = this.Count;
for (int i = 0; i < count; i++)
{
dest.SetValue(this[i], index++);
}
}
void ICollection.CopyTo(Array myArr, int index)
{
foreach (BlockHistoryObject bho in _collectionArray)
{
myArr.SetValue(bho, index);
index++;
}
}
protected override void SortGenericArray(Array items, int left, int right)
{
int j;
int limit = items.Length;
int st = -1;
while (st < limit)
{
bool flipped = false;
st++;
limit--;
for (j = st; j < limit; j++)
{
if (this.comparer.Compare(items.GetValue(j), items.GetValue(j + 1)) > 0)
{
object T = items.GetValue(j);
items.SetValue(items.GetValue(j + 1), j);
items.SetValue(T,j + 1);
flipped = true;
}
} // end for
if (!flipped)
{
return;
}
for (j = limit; --j >= st; )
{
if (this.comparer.Compare(items.GetValue(j), items.GetValue(j + 1)) > 0)
{
object T = items.GetValue(j);
items.SetValue(items.GetValue(j + 1), j);
items.SetValue(T, j + 1);
flipped = true;
}
}
if (!flipped)
{
return;
}
}
}
void ICollection.CopyTo(Array array, int index)
{
IEnumerator enumerator = ((IEnumerable) this).GetEnumerator();
while (enumerator.MoveNext())
{
array.SetValue(enumerator.Current, index++);
}
}
public virtual void CopyTo(Array array, int index)
{
int cElem = this._obj.Length;
for (int i = 0; i < cElem; ++i)
{
array.SetValue(this[i], i + index);
}
}
public void CopyTo(Array array, int index)
{
IEnumerator enumerator = this.GetEnumerator();
while (enumerator.MoveNext())
{
array.SetValue(enumerator.Current, index++);
}
}
public override void CopyTo(Array array, int index)
{
if (array == null) throw new ArgumentNullException("array");
for (var i = 0; i < _parameters.Count; i++)
{
array.SetValue(_parameters[i], index + i);
}
}
internal static void CopyTo(this Dictionary<object, object>.ValueCollection source, Array a, int index)
{
int arrayIndex = index;
foreach (object value in source)
{
a.SetValue(value, arrayIndex++);
}
}
public void CopyTo(Array array, int index)
{
int i = index;
foreach(MethodInfo mi in this)
{
array.SetValue(mi,i++);
}
}
public RawAnalysisReport(NCCReporter.LMLoggers.LognLM ctrllog)
: base(ctrllog)
{
selectedReportSections = Array.CreateInstance(typeof(bool), System.Enum.GetValues(typeof(RawReportSections)).Length);
foreach (ValueType v in System.Enum.GetValues(typeof(RawReportSections)))
{
selectedReportSections.SetValue(true, (int)v);
}
}
public override void CopyTo(Array array, int arrayIndex) {
if (hasNullKey) {
base.CopyTo(array, arrayIndex + 1);
array.SetValue(new DictionaryEntry(null, valueOfNullKey), arrayIndex);
}
else {
base.CopyTo(array, arrayIndex);
}
}
public virtual void CopyTo(Array array, int index)
{
IDictionaryEnumerator enumerator1 = this.ObjectTable.GetEnumerator();
int num1 = index;
while (enumerator1.MoveNext())
{
array.SetValue(enumerator1.Key, num1++);
}
}
protected override void SortGenericArray(Array items, int left, int right)
{
bool flipped = false;
int gap, top;
int i, j;
gap = items.Length;
do
{
gap = (int)((float)gap / SHRINKFACTOR);
switch (gap)
{
case 0: /* the smallest gap is 1 - bubble Sort */
gap = 1;
break;
case 9: /* this is what makes this Combsort11 */
case 10:
gap = 11;
break;
default: break;
}
flipped = false;
top = items.Length - gap;
for (i = 0; i < top; i++)
{
j = i + gap;
if (this.comparer.Compare(items.GetValue(i), items.GetValue(j)) > 0)
{
object T = items.GetValue(i);
items.SetValue(items.GetValue(j), i);
items.SetValue(T, j);
flipped = true;
}
}
} while (flipped || (gap > 1));
/* like the bubble and shell sorts we check for items clean pass */
}
public virtual void CopyTo(Array array, int index)
{
for (int i = 0; i < this._keys.Length; i++)
{
array.SetValue(this.GetMessageValue(i), (int) (index + i));
}
if (this._dict != null)
{
this._dict.CopyTo(array, index + this._keys.Length);
}
}
public void Sirala(Array dizi)
{
for (int i = 0; i < dizi.Length - 1; i++)
{
for (int j = 0; j < dizi.Length - i - 1; j++)
{
object x = dizi.GetValue(j); // dizi[j]
object y = dizi.GetValue(j+1); // dizi[j+1]
if (Karsilastir(x, y))
{
object z = x;
x = y;
y = z;
dizi.SetValue(x, j); // dizi[j] = x;
dizi.SetValue(y, j+1); // dizi[j+1] = y;
}
}
}
}
public void CopyTo(Array array, int index)
{
if (array == null)
{
throw new ArgumentNullException("array");
}
IEnumerator enumerator = this.GetEnumerator();
while (enumerator.MoveNext())
{
array.SetValue(enumerator.Current, index++);
}
}
protected override void SortGenericArray(Array items, int left, int right)
{
int h = 1;
int length = items.Length;
// find the largest h value possible
while ((h * 3 + 1) < length)
{
h = 3 * h + 1;
}
// while h remains larger than 0
while (h > 0)
{
// for each set of elements (there are h sets)
for (int i = h - 1; i < length; i++)
{
// pick the last element in the set
object B = items.GetValue(i);
int j = i;
// compare the element at B to the one before it in the set
// if they are out of order continue this loop, moving
// elements "back" to make room for B to be inserted.
for (j = i; (j >= h) && (this.comparer.Compare(items.GetValue(j - h), B) > 0); j -= h)
{
items.SetValue(items.GetValue(j - h), j);
}
// insert B into the correct place
items.SetValue(B, j);
} // end for
// all sets h-sorted, now decrease set size
h = h / 3;
}
}
public void CopyTo(Array array, int arrayIndex)
{
if (array == null)
{
throw new ArgumentNullException("array");
}
int index = arrayIndex;
for (int i = 0; i < this.Count; i++)
{
array.SetValue(this[i], index);
index++;
}
}
