public void Build()
{
// формируем массив пар
List <int> keys = new List <int>();
List <long> offsets = new List <long>();
int ind = 0;
bearing.Scan((off, obj) =>
{
foreach (int key in keyFun(obj))
{
offsets.Add(off);
keys.Add(key);
ind++;
}
return(true);
});
int[] keys_arr = keys.ToArray(); keys = null;
long[] offsets_arr = offsets.ToArray(); offsets = null;
// Сортируем по ключу
Array.Sort(keys_arr, offsets_arr);
// Эта часть делается если компаратор объектов comp задан
//if (comp != null)
//{
// // массив объектов
// List<object> objs = new List<object>();
// // проходим по массиву ключей, в группах одинаковых ключей выделяем массив объектов
// int key, start = -1; // начало интервала и количество с одинаковым ключом
// key = Int32.MinValue;
// Action fixgroup = () =>
// {
// int number = objs.Count;
// if (number > 1)
// {
// long[] offs_small = new long[number];
// for (int j = 0; j < number; j++)
// offs_small[j] = offsets[start + j];
// // Сортировка отрезка
// Array.Sort(objs.ToArray(), offs_small, comp);
// // вернуть отсортированные офсеты на место
// for (int j = 0; j < number; j++)
// offsets[start + j] = offs_small[j];
// }
// };
// for (int i = 0; i < ne; i++)
// {
// object ob = bearing.GetElement(offsets[i]);
// int k = keyFun(ob);
// // смена ключа
// if (i == 0 || k != key)
// {
// // фиксируем предыдущий отрезок (key, start, number)
// //FixGroup(offsets, objs, start);
// fixgroup();
// // Начать новый отрезок
// key = k;
// start = i;
// objs.Clear();
// }
// // основное действие
// objs.Add(ob);
// }
// if (objs.Count > 1) fixgroup();
//}
// Записываем
keyoffsets.Clear(); // очищаем
for (int i = 0; i < keys_arr.Length; i++)
{
keyoffsets.AppendElement(new object[] { keys_arr[i], offsets_arr[i] });
}
keyoffsets.Flush();
if (scale != null)
{
scale.Load(keys_arr);
}
}
public void Scan(Func <long, object, bool> handler)
{
sequence.Scan(handler);
}
public void Build()
{
// формируем массив пар
int ne = (int)bearing.Count();
//KeyOffPair[] keyoff_arr = new KeyOffPair[ne];
int[] keys = new int[ne];
long[] offsets = new long[ne];
int ind = 0;
bearing.Scan((off, obj) =>
{
offsets[ind] = off;
keys[ind] = keyFun(obj);
ind++;
return(true);
});
// Сортируем по ключу
Array.Sort(keys, offsets);
// Эта часть делается если компаратор объектов comp задан
if (comp != null)
{
// массив объектов
List <object> objs = new List <object>();
// проходим по массиву ключей, в группах одинаковых ключей выделяем массив объектов
int key, start = -1; // начало интервала и количество с одинаковым ключом
key = Int32.MinValue;
Action fixgroup = () =>
{
int number = objs.Count;
if (number > 1)
{
long[] offs_small = new long[number];
for (int j = 0; j < number; j++)
{
offs_small[j] = offsets[start + j];
}
// Сортировка отрезка
Array.Sort(objs.ToArray(), offs_small, comp);
// вернуть отсортированные офсеты на место
for (int j = 0; j < number; j++)
{
offsets[start + j] = offs_small[j];
}
}
};
for (int i = 0; i < ne; i++)
{
object ob = bearing.GetElement(offsets[i]);
int k = keyFun(ob);
// смена ключа
if (i == 0 || k != key)
{
// фиксируем предыдущий отрезок (key, start, number)
//FixGroup(offsets, objs, start);
fixgroup();
// Начать новый отрезок
key = k;
start = i;
objs.Clear();
}
// основное действие
objs.Add(ob);
}
if (objs.Count > 1)
{
fixgroup();
}
}
// Записываем
keyoffsets.Clear(); // очищаем
for (int i = 0; i < keys.Length; i++)
{
keyoffsets.AppendElement(new object[] { keys[i], offsets[i] });
}
keyoffsets.Flush();
if (scale != null)
{
scale.Load(keys);
}
}
public void Build()
{
// формируем массив пар
List <int> keys_list = new List <int>();
List <long> offsets_list = new List <long>();
bearing.Scan((off, obj) =>
{
keys_list.Add(keyFun(obj));
offsets_list.Add(off);
return(true);
});
int[] keys = keys_list.ToArray();
keys_list = null;
long[] offsets = offsets_list.ToArray();
offsets_list = null;
int ne = keys.Length;
// Сортируем по ключу
Array.Sort(keys, offsets);
// Эта часть делается если компаратор объектов comp задан
// Производится сортировка участков с одинаковыми ключами
if (comp != null)
{
// массив в который будет вкладываться набор объектов с одинаковыми ключами
List <object> objs = new List <object>();
// проходим по массиву ключей, в группах одинаковых ключей выделяем массив объектов
int key, start = -1; // ключ интервала и начало интервала в массивах keys и offsets
key = Int32.MinValue;
// Фиксация накопленного в предыдущих переменных objs, key, start
Action fixgroup = () =>
{
int number = objs.Count;
if (number > 1)
{
long[] offs_small = new long[number];
for (int j = 0; j < number; j++)
{
offs_small[j] = offsets[start + j];
}
// Сортировка отрезка
Array.Sort(objs.ToArray(), offs_small, comp);
// вернуть отсортированные офсеты на место
for (int j = 0; j < number; j++)
{
offsets[start + j] = offs_small[j];
}
}
};
// Сканирование массивов keys, offsets
for (int i = 0; i < ne; i++)
{
int k = keys[i];
// смена ключа
if (i == 0 || k != key)
{
// фиксируем предыдущий отрезок (key, start), начинаем новый
fixgroup();
// Начать новый отрезок
key = k;
start = i;
objs.Clear();
}
// основное действие
object ob = bearing.GetElement(offsets[i]);
objs.Add(ob);
}
if (objs.Count > 1)
{
fixgroup();
}
}
// Записываем
keyoffsets.Clear(); // очищаем
for (int i = 0; i < keys.Length; i++)
{
keyoffsets.AppendElement(new object[] { keys[i], offsets[i] });
}
keyoffsets.Flush();
if (scale != null)
{
scale.Load(keys);
}
keys = null;
offsets = null;
System.GC.Collect();
}