private void Test()
{
var first = otriples_op.Root.ElementValues().Cast <object[]>().First();
int currentPredicate = (int)first[1];
var currentDiapason = new Diapason();
var currentObjectDiapason = new Diapason();
int currentObj = (int)first[2];
using (StreamWriter wr = new StreamWriter(@"..\..\temp.txt"))
foreach (object[] spo in otriples_op.Root.ElementValues())
{
if (currentPredicate == (int)spo[1] && currentObj == (int)spo[2])
{
currentDiapason.numb++;
}
else
{
currentPredicate = (int)spo[1];
wr.WriteLine("diapasonPredicate " + currentDiapason.numb);
currentDiapason.start += currentDiapason.numb;
currentDiapason.numb = 1;
if (currentObj == (int)spo[2])
{
currentObjectDiapason.numb++;
}
else
{
currentObj = (int)spo[2];
currentObjectDiapason.start += currentObjectDiapason.numb;
// wr.WriteLine("currentObjectDiapason " + currentObjectDiapason.numb);
currentObjectDiapason.numb = 1;
}
}
}
}
public void Load()
{
ewtable.Clear();
ewtable.Fill(new object[0]);
foreach (var scanner in scanners)
{
scanner.Start();
}
while (NotFinished(scanners))
{
string key = Least(scanners);
Diapason[] diaps = Enumerable.Repeat <Diapason>(new Diapason()
{
start = 0L, numb = 0L
}, 3).ToArray();
object[] pval = new object[4];
pval[0] = key;
for (int ind = 0; ind < 3; ind++)
{
if (scanners[ind].HasValue && scanners[ind].KeyCurrent == key)
{
Diapason di = scanners[ind].Scan();
diaps[ind] = di;
}
pval[ind + 1] = new object[] { diaps[ind].start, diaps[ind].numb };
}
ewtable.Root.AppendElement(pval);
}
ewtable.Flush();
}
/// <summary>
/// парсинг диапазона значений dobule
/// </summary>
/// <param name="v"></param>
/// <returns></returns>
private Diapason <double> parseDiapason(string v)
{
string[] arr = v.Split('-');
Diapason <double> res = new Diapason <double>(double.Parse(arr[0].Replace('.', Constants.DecimalSeparator)), double.Parse(arr[1].Replace('.', Constants.DecimalSeparator)));
return(res);
}
public override Dictionary <PointLatLng, ManualLimits> LoadDatabaseFile()
{
Dictionary <PointLatLng, ManualLimits> limits = new Dictionary <PointLatLng, ManualLimits>();
StreamReader sr = new StreamReader(FileName);
sr.ReadLine();//пропускаем первую строку-заголовок
while (!sr.EndOfStream)
{
string line = sr.ReadLine();
string[] arr = line.Split(';'); //название;широта;долгота;минимальная скорость;максимальная скорость
if (arr.Length < 5)
{
continue;
}
Diapason <double> d = new Diapason <double>(double.Parse(arr[3].Replace('.', Constants.DecimalSeparator)), double.Parse(arr[4].Replace('.', Constants.DecimalSeparator)));
PointLatLng p = new PointLatLng(double.Parse(arr[1].Replace('.', Constants.DecimalSeparator)), double.Parse(arr[2].Replace('.', Constants.DecimalSeparator)));
ManualLimits ml = new ManualLimits(new List <Diapason <double> >(), new List <Diapason <double> >()
{
d
})
{
Position = p, Name = arr[0]
};
if (!limits.ContainsKey(p))
{
limits.Add(p, ml);
}
}
sr.Close();
return(limits);
}
public static IEnumerable <OValRowInt> _Spo(this IEnumerable <OValRowInt> rows, short subj, short pred, short obj)
{
// Определены объект и предикат, нужно найти множество субъектов, побочным эффектом будет определение
// и фиксация диапазона. Если диапазон уже есть, то диапазон не вычисляется, а используется
var query = rows.SelectMany(rw =>
{
var row = rw.row;
OVal obj_oval = row[obj];
Diapason diap = new Diapason();
if (obj_oval.spo_number >= 0)
{ // Диапазон определен
diap.start = obj_oval.spo_start;
diap.numb = obj_oval.spo_number;
}
else
{
Diapason di = rw.StoreAbstract.GetDiap_op(obj_oval.entity);
diap.start = obj_oval.spo_start = di.start;
diap.numb = obj_oval.spo_number = di.numb;
}
return(rw.StoreAbstract.GetSubjInDiapason(diap, row[pred].entity)
.Select(su =>
{
row[subj].entity = su; row[subj].op_number = -1; row[subj].spd_number = -1; row[subj].spo_number = -1;
return new OValRowInt(rw.StoreAbstract, row);
}));
});
return(query);
}
public static IEnumerable <OValRowInt> _spo(this IEnumerable <OValRowInt> rows, short subj, short pred, short obj)
{
var query = rows.Where(ovr =>
{
OVal[] row = ovr.row;
// будем "плясать" от субъекта. TODO: наверное можно как-то задействовать и объектную цепочку
OVal subj_oval = row[subj];
OVal pred_oval = row[pred];
OVal obj_oval = row[obj];
// Проверим через шкалу
if (!ovr.StoreAbstract.Scale.ChkInScale(subj_oval.entity, pred_oval.entity, obj_oval.entity))
{
return(false);
}
Diapason diap = new Diapason();
if (subj_oval.spo_number >= 0)
{ // Диапазон определен
diap.start = subj_oval.spo_start;
diap.numb = subj_oval.spo_number;
}
else
{
Diapason di = ovr.StoreAbstract.GetDiap_spo(subj_oval.entity);
diap.start = subj_oval.spo_start = di.start;
diap.numb = subj_oval.spo_number = di.numb;
}
return(ovr.StoreAbstract.CheckPredObjInDiapason(diap, ovr.row[pred].entity, ovr.row[obj].entity));
});
return(query);
}
/// <summary>
/// Получение триплетов из диапазона, соответствующих заданному второму ключу
/// </summary>
/// <param name="dia">Диапазон в индексном массиве. Есть специальные требования к диапазону</param>
/// <param name="key2">Ключ2 по которому фильтруется результарующее множество</param>
/// <returns>Возвращает поток триплетов в объектной форме</returns>
public IEnumerable <object> GetAllInDiap(Diapason dia, Tkey key2)
{
if (dia.IsEmpty())
{
return(Enumerable.Empty <object>());
}
int hkey = Half2Producer(key2);
PaEntry entry = Table.Element(0);
var query1 = index_cell.Root.BinarySearchAll(dia.start, dia.numb, ent =>
{
object[] va = (object[])ent.Get();
int hk = (int)va[2];
int cmp = hk.CompareTo(hkey);
return(cmp);
}).Select(ent => ent.Get())
.Where(va => (int)((object[])va)[2] == hkey);
var query2 = index_cell.Root.ElementValues(dia.start, dia.numb)
.Where(va => (int)((object[])va)[2] == hkey);
IEnumerable <object> query = dia.numb > 30 ? query1 : query2;
return(query
.Select(va =>
{
long off = (long)((object[])va)[0];
entry.offset = off;
return entry.Get();
})
.Where(two => !(bool)((object[])two)[0] && Key2Producer(two).CompareTo(key2) == 0)
.Select(two => ((object[])((object[])two)[1])));
}
public object Get(int search_key)
{
long offset;
if (dic1 != null && dic1.Count > 0 && dic1.TryGetValue(search_key, out offset))
{
//return keyvalue_seq.Root.Element(0).SetOffset(offset).Get();
return(keyvalue_seq.GetElement(offset));
}
if (dic2 != null && dic2.Count > 0 && dic2.TryGetValue(search_key, out offset))
{
//return ((object[])keyvalue_seq.Root.Element(0).SetOffset(offset).Get())[1];
return(((object[])keyvalue_seq.GetElement(offset))[1]);
}
Diapason diap = GetDia(search_key);
//int ifirst = ScaleExt.Get8FirstIndexOf((int)diap.start, (int)diap.numb, keys_arr, search_key);
//if (ifirst == -1)
//{
// return null;
//}
//offset = (long)offsets.Root.Element(ifirst).Get();
//return keyvalue_seq.Root.Element(0).SetOffset(offset).Get();
int ind = Array.BinarySearch <int>(keys_arr, search_key);
if (ind == -1)
{
return(null);
}
return(keyvalue_seq.GetElement((long)offsets.GetElement((long)offsets.ElementOffset(ind))));
}
// Определение всех данных по заданным s-p
public static IEnumerable <OValRowInt> _spD(this IEnumerable <OValRowInt> rows, short subj, short pred, short dat)
{
var query = rows.SelectMany(ovr =>
{
OVal[] row = ovr.row;
OVal subj_oval = row[subj];
OVal pred_oval = row[pred];
OVal dat_oval = row[dat];
Diapason diap = new Diapason();
if (subj_oval.spd_number >= 0)
{ // Диапазон определен
diap.start = subj_oval.spd_start;
diap.numb = subj_oval.spd_number;
}
else
{
Diapason di = ovr.StoreAbstract.GetDiapason_spd(subj_oval.entity);
diap.start = subj_oval.spd_start = di.start;
diap.numb = subj_oval.spd_number = di.numb;
}
return(ovr.StoreAbstract.GetDatInDiapason(diap, row[pred].entity)
.Select(lit =>
{
row[dat].lit = lit;
return new OValRowInt(ovr.StoreAbstract, row);
}));
});
return(query);
}
public void Load()
{
Diapason current = new Diapason()
{
start = 0, numb = 1
};
int hashCurrent = GetHash((int)entites.EWTable.Root.Element(0).Field(0).Get());
foreach (int hashNew in
entites.EWTable.Root.Elements()
.Skip(1)
.Select(entry => entry.Field(0).Get())
.Cast <int>()
.Select(GetHash))
{
if (hashNew == hashCurrent)
{
current.numb++;
}
else
{
Diapasons[hashCurrent] = current;
current = new Diapason()
{
start = current.start + current.numb, numb = 1
};
hashCurrent = hashNew;
}
}
Diapasons[hashCurrent] = current;
}
/// <summary>
/// создает новый экземпляр
/// </summary>
public Options()
{
StaticRegionLimitsSourceFile = Application.StartupPath + "\\Data\\staticRegionLimits.txt";
StaticMeteostationCoordinatesSourceFile = Application.StartupPath + "\\Data\\staticMeteostationCoordinates.txt";
StaticAMSDatabaseSourceFile = Application.StartupPath + "\\Data\\AMS.database.txt";
StaticFlugerDatabaseSourceFile = Application.StartupPath + "\\Data\\Fluger.database.txt";
StaticEquipmentDatabaseSourceFile = Application.StartupPath + "\\Data\\Equipment.database.txt";
StaticMicroclimateTableDatabaseSourceFile = Application.StartupPath + "\\Data\\Microclimate.table.txt";
StaticMesoclimateTableDatabaseSourceFile = Application.StartupPath + "\\Data\\Mesoclimate.table.txt";
StaticRP5DatabaseSourceDirectory = Application.StartupPath + "\\Data\\rp5.Database";
QualifierSectionLength = 20; //20 измерений
QualifierDaysToNewInterval = 30; //1 месяц
QualifierDaysToBeginMissing = 30; //1 месяца
AirDensity = 1.226;
SuitAMSMaximalRelativeSpeedDeviation = 0.8;
UseSuitAMSMaximalRelativeSpeedDeviation = false;
MinimalSpeedDeviation = 0.1d;
MinimalCorrelationCoeff = 0.7;
MinimalCorrelationControlParametres = new List <MeteorologyParameters>()
{
MeteorologyParameters.Speed
};
NearestMSRadius = 50e3;//50 km
NormalLawPirsonCoefficientDiapason = new Diapason <double>(0, 5);
CurrentSpeedGradationType = GradationTypes.Voeykow;
UserSpeedGradation = new UserGradation();
TextImportState = new TextImporterState();
CalculateAirDensity = false;
ETOPO2Folder = Application.StartupPath + "\\Data\\ETOPO";
RP5SearchEngine = RP5SearchEngine.DBSearch;
RP5SourceEngine = RP5SourceType.OnlineAPI;
LoadNasaLastPoint = PointLatLng.Empty;
}
public object Get(int search_key)
{
long offset;
if (dic1 != null && dic1.Count > 0 && dic1.TryGetValue(search_key, out offset))
{
return(((object[])keyvalue_seq.Root.Element(0).SetOffset(offset).Get())[1]);
}
if (dic2 != null && dic2.Count > 0 && dic2.TryGetValue(search_key, out offset))
{
return(((object[])keyvalue_seq.Root.Element(0).SetOffset(offset).Get())[1]);
}
Diapason diap = GetDia(search_key);
//int ifirst = 666888;
int ifirst = Program.Get8FirstIndexOf((int)diap.start, (int)diap.numb, keys_arr, search_key);
//int ifirst = Program.Get8FirstIndexOf(0, keys_arr.Length, keys_arr, search_key);
if (ifirst == -1)
{
return(null);
}
//entry.offset = offsets[ifirst]; // Использование массива
//entry.offset = (long)key_index.Root.Element(ifirst).Field(1).Get(); // Использование всего индекса
offset = (long)offsets.Root.Element(ifirst).Get();
return(((object[])keyvalue_seq.Root.Element(0).SetOffset(offset).Get())[1]);
}
public async Task <IActionResult> Edit(int id, [Bind("DiapasonId,Diapason1")] Diapason diapason)
{
if (id != diapason.DiapasonId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(diapason);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DiapasonExists(diapason.DiapasonId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(diapason));
}
/// <summary>
/// получить ограничения скоростей с заданного региона
/// </summary>
/// <param name="region">информация о регионе</param>
/// <param name="geocoder">геокодер для получения координат</param>
/// <param name="checkStop">функция проверки отмены</param>
/// <param name="act">действие при изменении процента выполнения</param>
/// <param name="current_region">номер текущего региона (передавать в act)</param>
/// <param name="total_regions">всего регионов (передавать в act)</param>
/// <returns></returns>
public List <ManualLimits> GetLimits(RegionInfo region, IGeocoderProvider geocoder, Func <bool> checkStop = null, Action <int, int, string, int, int> act = null, int current_region = -1, int total_regions = -1)
{
List <BaseLimit> bases = getBasesLimits(region);
List <ManualLimits> res = new List <ManualLimits>();
int counter = 0;
foreach (BaseLimit lim in bases)
{
try
{
if (checkStop.Invoke())
{
return(res);
}
if (act != null)
{
act.Invoke(current_region, total_regions, region.Name, counter, bases.Count);
}
Diapason <double> speeds = new Diapason <double>(0, lim.MaxSpeed);
ManualLimits limit = new ManualLimits(null, new List <Diapason <double> >()
{
speeds
});
limit.Name = lim.Name;
limit.Position = geocoder.GetCoordinate(lim.Name);
res.Add(limit);
counter++;
}
catch (Exception ex)
{ continue; }
}
return(res);
}
public int[] GetAllPrimaryByExternal(int exindnom, int exkey)
{
//TODO: нет концепции динамики для внешних индексов, тут должо быть решение
if (exindexes == null || exindexes.Length <= exindnom)
{
throw new Exception("Err: 2983883");
}
var exindx = exindexes[exindnom];
// Будут объединены результаты выборки из словаря и выборки из статического индекса
List <int> frdic;
int[] res;
if (exindx.ekey_idlist.TryGetValue(exkey, out frdic))
{
res = frdic.ToArray();
}
else
{
res = new int[0];
}
if (exindx.GetDia == null)
{
return(res);
}
Diapason d = exindx.GetDia(exkey);
if (d.IsEmpty())
{
return(res);
}
int start = (int)d.start;
int finish = start + (int)d.numb;
for (; start < finish; start++)
{
if (exindx.key_arr[start] == exkey)
{
break;
}
}
if (start == finish)
{
return(res);
}
for (; finish > start; finish--)
{
if (exindx.key_arr[finish - 1] == exkey)
{
break;
}
}
//var query = exindx.prikeys.Root.ElementValues(start, finish - start).Cast<int>();
var query = Enumerable.Range(start, finish - start).Select(i => exindx.exprikeys.ElementOffset(i))
.Select(off => ((object[])exindx.exprikeys.GetElement(off))[1]).Cast <int>();
return(res.Concat(query).ToArray());
}
public void TestScale()
{
int[] arr1 = Enumerable.Range(0, 160).ToArray();
var scale_fun = Scale.GetDiaFunc32(arr1);
int index = 81;
Diapason dia = scale_fun(index);
Assert.IsTrue(dia.start <= index && dia.start + dia.numb > index, "" + index + " in " + dia.start + " " + dia.numb);
}
public async Task DeleteDiapason(int diapasonId)
{
Diapason di = _context.Diapasons.Find(diapasonId);
if (di != null)
{
_context.Diapasons.Remove(di);
await _context.SaveChangesAsync();
}
}
/// <summary>
/// проверяет скорости и направления в заданном ряду на соответствие нормальному закону распределения.
/// Возвращает false если ряд не соответствует
/// </summary>
/// <param name="baseRange">проверяемый ряд</param>
/// <param name="acceptDiapason">допустимый диапазон</param>
/// <returns></returns>
internal static bool CheckNormalLaw(RawRange baseRange, Diapason <double> acceptDiapason)
{
return(true);
double Xi_speed = checkNormalLaw(baseRange, MeteorologyParameters.Speed);
double Xi_dir = checkNormalLaw(baseRange, MeteorologyParameters.Direction);
double f = Math.Max(Xi_dir, Xi_speed); //максимально расхождение
return(acceptDiapason.From < f && acceptDiapason.To > f);
}
/*
* public IEnumerable<int> GetObjInDiap(Diapason di, int pred)
* {
* return otriples.Root.BinarySearchAll(di.start, di.numb, ent => ((int)ent.Field(1).Get()).CompareTo(pred))
* .Select(en => (int)en.Field(2).Get());
* }
*/
public IEnumerable <int> GetSubjInDiapason(Diapason di, int pred)
{
//return otriples_op.Root.BinarySearchAll(di.start, di.numb, ent => ((int)ent.Field(1).Get()).CompareTo(pred))
// .Select(en => (int)en.Field(0).Get());
Diapason internal_diap = otriples_op.Root.BinarySearchDiapason(di.start, di.numb, ent => ((int)ent.Field(0).Get()).CompareTo(pred));
return(otriples_op.Root.Elements(internal_diap.start, internal_diap.numb)
.Select(ent => (object[])ent.Get())
.Select(p_obj => (int)((object[])p_obj)[1]));
}
public async Task <IActionResult> Create([Bind("DiapasonId,Diapason1")] Diapason diapason)
{
if (ModelState.IsValid)
{
_context.Add(diapason);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(diapason));
}
public IEnumerable <Literal> GetDatInDiapason(Diapason di, int pred)
{
Diapason internal_diap = dtriples_sp.Root.BinarySearchDiapason(di.start, di.numb, ent =>
{
return(((int)ent.Field(1).Get()).CompareTo(pred));
});
return(dtriples_sp.Root.ElementValues(internal_diap.start, internal_diap.numb)
.Cast <object[]>()
.Select(en => (long)en[1])
.Select(offset => LiteralStore.Read(offset, PredicatesCoding.LiteralVid[pred])));
}
public void TimeDiapason()
{
Assert.AreEqual(Diapason.CreateTime("23:00-;-01:30").Pieces.JoinToString(", "), Diapason.CreateTime("23:00-01:30").Pieces.JoinToString(", "));
Assert.IsTrue("10:30-11:48,12,13:00:16,18:47-".TimeDiapasonContains(FlexibleParser.ParseTime("11:43")));
Assert.IsTrue("10:30-11:48,12,13:00:16,18:47-".TimeDiapasonContains(FlexibleParser.ParseTime("11:48")));
Assert.IsFalse("10:30-11:48,12,13:00:16,18:47-".TimeDiapasonContains(FlexibleParser.ParseTime("11:49")));
Assert.IsFalse("10:30-11:48,12,13:00:16,18:47-".TimeDiapasonContains(FlexibleParser.ParseTime("9:43")));
Assert.IsTrue("10:30-11:48,12,13:00:16,18:47-".TimeDiapasonContains(FlexibleParser.ParseTime("12:43")));
Assert.IsFalse("10:30-11:48,12,13:00:16,18:47-".TimeDiapasonContains(FlexibleParser.ParseTime("12:43"), false));
Assert.IsFalse("10:30-11:48,12,13:00:16,18:47-".TimeDiapasonContains(FlexibleParser.ParseTime("13:00")));
Assert.IsTrue("10:30-11:48,12,13:00:16,18:47-".TimeDiapasonContains(FlexibleParser.ParseTime("13:00:16")));
Assert.IsTrue("10:30-11:48,12,13:00:16,18:47-".TimeDiapasonContains(FlexibleParser.ParseTime("20:24")));
}
//internal static Func<int, Diapason> GetDiaFunc(int[] keys)
//{
// // Построение шкалы
// int N = keys.Length;
// int V_min = keys[0];
// int V_max = keys[N - 1];
// int M = N / 16;
// int[] scale = new int[M];
// int index = 0;
// int ik = 0;
// scale[index] = ik;
// for (; ik < N; ik++)
// {
// if (keys[ik] < (int)((long)V_min + ((long)index + 1L) * ((long)V_max - (long)V_min) / (long)M)) { continue; }
// index = index + 1;
// if (index == M) { break; }
// scale[index] = ik;
// }
// Func<int, Diapason> GetDia = key =>
// {
// int indx = (int)((long)M * (long)(key - V_min) / (long)(V_max - V_min));
// if (indx == M) return new Diapason() { start = N - 1, numb = 1 };
// if (indx == M - 1) return new Diapason() { start = scale[indx], numb = N - scale[indx] };
// int sta = scale[indx];
// int sto = scale[indx + 1];
// var d = new Diapason() { start = scale[indx], numb = scale[indx + 1] - scale[indx] };
// return d;
// };
// return GetDia;
//}
private static void ComputeEntry(PaCell pers_ind_off_arr, int[] keys, Func <int, Diapason> GetDia, PaEntry entry, int search_key)
{
Diapason diap = GetDia(search_key);
int ifirst = Get8FirstIndexOf((int)diap.start, (int)diap.numb, keys, search_key);
if (ifirst == -1)
{
entry = PaEntry.Empty; return;
}
//entry.offset = offsets[ifirst]; // Использование массива
//entry.offset = (long)key_index.Root.Element(ifirst).Field(1).Get(); // Использование всего индекса
entry.offset = (long)pers_ind_off_arr.Root.Element(ifirst).Get();
}
/// <summary>
/// добавление нового диапазона
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void buttonAdd_Click(object sender, EventArgs e)
{
Diapason <double> nd = new Diapason <double>();
nd.From = (double)numericUpDownFrom.Value;
nd.To = (double)numericUpDownTo.Value;
if (nd.From >= nd.To)
{
_ = MessageBox.Show(this, "Начало диапазона должно быть меньше конца", "Добавление диапазона", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
diapasons.Add(nd);
}
public async Task <IActionResult> OnPost(int id, Diapason newDia)
{
var userId = _httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier);
if (newDia.StartDay != null && newDia.FinishDay != null && newDia.StartTime != null && newDia.FinishTime != null)
{
newDia.MeetingVariantID = id;
newDia.User = userId;
await _diRepo.AddDiapason(newDia);
return(Redirect("/HostMan/MeetingVariantManage/" + id));
}
return(Page());
}
/*
* public IEnumerable<string> GetObjInDiap(Diapason di, string pred)
* {
* return otriples.Root.BinarySearchAll(di.start, di.numb, ent => ((string)ent.Field(1).Get()).CompareTo(pred))
* .Select(en => (string)en.Field(2).Get());
* }
*/
public IEnumerable <string> GetSubjInDiapason(Diapason di, string pred)
{
//return otriples_op.Root.BinarySearchAll(di.start, di.numb, ent => ((string)ent.Field(1).Get()).CompareTo(pred))
// .Select(en => (string)en.Field(0).Get());
Diapason internal_diap = otriples_op.Root.BinarySearchDiapason(di.start, di.numb, ent =>
{
return(((string)ent.Field(1).Get()).CompareTo(pred));
});
return(otriples_op.Root.Elements(internal_diap.start, internal_diap.numb)
.Select <PaEntry, object[]>(ent => (object[])ent.Get())
.Select(p_obj => (string)((object[])p_obj)[0]));
}
public IEnumerable <Literal> GetDatInDiap(Diapason di, int pred)
{
Diapason internal_diap = dtriples_sp.Root.BinarySearchDiapason(di.start, di.numb, ent => ((int)ent.Field(1).Get()).CompareTo(pred));
PaEntry dtriple_entry = dtriples.Root.Element(0);
return(dtriples_sp.Root.Elements(internal_diap.start, internal_diap.numb)
.Select(ent => (object[])ent.Get())
.Select(p_obj =>
{
long off = (long)((object[])p_obj)[2];
dtriple_entry.offset = off;
return PObjToLiteral(dtriple_entry.Field(2).Get());
})
);
}
public IEnumerable <PaEntry> GetAllByKey(Tkey key)
{
if (Scale != null)
{
Diapason dia = Scale.GetDiapason(Convert.ToInt32(key));
if (dia.numb == 0)
{
return(Enumerable.Empty <PaEntry>());
}
else
{
return(GetAllByKey(dia.start, dia.numb, key));
}
}
return(GetAllByKey(0, index_cell.Root.Count(), key));
}
public static void Main8_1()
{
int max = 1000000;
int[] arr = Enumerable.Range(1, max).ToArray();
var Dia = GetDiaFunc2(arr);
foreach (int key in arr)
{
Diapason di = Dia(key);
if (di.IsEmpty())
{
Console.WriteLine($"no dia for {key}");
}
int start = (int)di.start;
int numb = (int)di.numb;
int found = -1;
for (int i = start; i < start + numb || i < arr.Length; i++)
{
if (arr[i] == key)
{
found = i; break;
}
}
if (found == -1)
{
Console.WriteLine($"not found for {key}: start={start} numb={numb}");
}
int ind = Program.Get8FirstIndexOf(start, numb, arr, key);
if (ind == -1)
{
Console.WriteLine($"no ind for key {key}");
int ind2 = Program.Get8FirstIndexOf(start, numb, arr, key);
}
else
{
int keyval = arr[ind];
if (keyval != key)
{
Console.WriteLine($"bad result index {ind} {keyval} for {key}");
}
}
}
Console.WriteLine("ok?");
}
public ViewModel([NotNull] ReplayObject acObject) : base(acObject)
{
UpdateAlreadyShared();
_timeKey = @".ReplayTime:" + acObject.Id;
Time = acObject.AllowToOverrideTime
? CacheStorage.Get(_timeKey, acObject.TimeFrom ?? FlexibleParser.ParseTime(@"09:00"))
: acObject.TimeFrom ?? FlexibleParser.ParseTime(@"09:00");
if (acObject.AllowToOverrideTime)
{
TimeSliderMapper = new DiapasonMapper(WeatherManager.Instance.GetById(acObject.WeatherId)?.GetTimeDiapason()
?? Diapason.CreateTime(@"0:00-23:59"))
{
ActualValue = Time
};
}
}
