Результаты поиска

Мне нужно уметь манипулировать большим (10^7 узлов) графом в python. Данные, соответствующие каждому узлу / ребру, минимальны, скажем, небольшое количество строк. Каков наиболее эффективный , с точки зрения памяти и скорости , способ сделать это?

Дикт диктов более гибок и прост в реализации, но я интуитивно ожидаю, что список списков будет быстрее. Опция списка также потребует, чтобы я хранил данные отдельно от структуры, в то время как дикты позволят сделать что-то подобное:

graph[I][J]["Property"]="value"

Что бы вы предложили?

Да, мне следовало бы немного прояснить, что я подразумеваю под эффективностью. В данном конкретном случае я имею в виду его в терминах произвольного поиска доступа.

Загрузка данных в память не является огромной проблемой. Это делается раз и навсегда. Трудоемкая часть-это посещение узлов, чтобы я мог извлечь информацию и измерить интересующие меня показатели.

Я не рассматривал возможность сделать каждый узел классом (свойства одинаковы для всех узлов), но похоже, что это добавит дополнительный уровень накладных расходов? Я надеялся, что у кого-то будет какой-то непосредственный опыт с подобным случаем, которым они могли бы поделиться. В конце концов, графики-это одна из самых распространенных абстракций в CS.

Где находятся некоторые хорошие источники информации о структурах макета двоичных файлов?

Если бы я хотел вытащить файл индекса BTrieve , проанализировать заголовки MP3 и т. д. Где можно получить достоверную информацию?

Я смог найти подробности о нескольких самобалансирующихся BST через несколько источников, но я не нашел хороших описаний, детализирующих, какой из них лучше всего использовать в разных ситуациях (или если это действительно не имеет значения).

Я хочу BST , который является оптимальным для хранения более десяти миллионов узлов. Порядок вставки узлов в основном случайный, и мне никогда не нужно будет удалять узлы, поэтому время вставки-это единственное, что нужно будет оптимизировать.

Я намерен использовать его для хранения ранее посещенных игровых состояний в игре-головоломке, чтобы я мог быстро проверить, была ли уже обнаружена предыдущая конфигурация.

Где находятся некоторые хорошие источники информации о структурах макета двоичных файлов?

Если бы я хотел вытащить файл индекса BTrieve , проанализировать заголовки MP3 и т. д. Где можно получить достоверную информацию?

Я смог найти подробности о нескольких самобалансирующихся BST через несколько источников, но я не нашел хороших описаний, детализирующих, какой из них лучше всего использовать в разных ситуациях (или если это действительно не имеет значения).

Я хочу BST , который является оптимальным для хранения более десяти миллионов узлов. Порядок вставки узлов в основном случайный, и мне никогда не нужно будет удалять узлы, поэтому время вставки-это единственное, что нужно будет оптимизировать.

Я намерен использовать его для хранения ранее посещенных игровых состояний в игре-головоломке, чтобы я мог быстро проверить, была ли уже обнаружена предыдущая конфигурация.

Что такое хорошие библиотеки для C с такими структурами данных, как векторы, деки, стеки, хэш-карты, древовидные карты, наборы и т. д.? Простой C, пожалуйста, и независимый от платформы.

Как лучше всего заполнить структуру C# из массива byte[], где данные были получены из структуры C/C++? Структура C будет выглядеть примерно так (мой C очень ржавый):

typedef OldStuff {
    CHAR Name[8];
    UInt32 User;
    CHAR Location[8];
    UInt32 TimeStamp;
    UInt32 Sequence;
    CHAR Tracking[16];
    CHAR Filler[12];
}

И наполнил бы что-то вроде этого:

[StructLayout(LayoutKind.Explicit, Size = 56, Pack = 1)]
public struct NewStuff
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
    [FieldOffset(0)]
    public string Name;

    [MarshalAs(UnmanagedType.U4)]
    [FieldOffset(8)]
    public uint User;

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
    [FieldOffset(12)]
    public string Location;

    [MarshalAs(UnmanagedType.U4)]
    [FieldOffset(20)]
    public uint TimeStamp;

    [MarshalAs(UnmanagedType.U4)]
    [FieldOffset(24)]
    public uint Sequence;

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
    [FieldOffset(28)]
    public string Tracking;
}

Что является лучшим способом, чтобы скопировать OldStuff до NewStuff , OldStuff , если передается массив byte[]?

В настоящее время я делаю что-то вроде следующего, но это кажется немного неуклюжим.

GCHandle handle;
NewStuff MyStuff;

int BufferSize = Marshal.SizeOf(typeof(NewStuff));
byte[] buff = new byte[BufferSize];

Array.Copy(SomeByteArray, 0, buff, 0, BufferSize);

handle = GCHandle.Alloc(buff, GCHandleType.Pinned);

MyStuff = (NewStuff)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(NewStuff));

handle.Free();

Есть ли лучший способ сделать это?

Может ли использование класса BinaryReader обеспечить какой-либо прирост производительности по сравнению с закреплением памяти и использованием Marshal.PtrStructure ?

Как лучше всего сделать связанный список в Java?

Мне нужна структура данных, которая позволит запрашивать, сколько элементов за последние X минут . Элемент может быть просто простым идентификатором или более сложной структурой данных, предпочтительно timestamp элемента будет находиться в элементе, а не храниться снаружи (как hash или аналогичный, не хотелось бы иметь проблемы с несколькими элементами, имеющими одинаковый timestamp).

До сих пор кажется, что с LINQ я мог бы легко фильтровать элементы с timestamp больше, чем заданное время и агрегировать количество. Хотя я не решаюсь попробовать работать .NET 3.5 конкретных вещей в моей производственной среде пока нет. Есть ли другие предложения для подобной структуры данных?

Другая часть, которая меня интересует, - это устаревание старых данных, если я буду запрашивать количество элементов менее 6 часов назад, я бы хотел, чтобы что-то более старое было удалено из моей структуры данных, потому что это может быть длительная программа.

Я пытаюсь полностью понять все концепции Haskell.

В чем алгебраические типы данных похожи на универсальные типы, например, в C# и Java? И чем же они отличаются? И вообще, что в них такого особенного?

Я знаком с универсальной алгеброй и ее кольцами и полями, но у меня есть только смутное представление о том, как работают типы Haskell.

У меня есть дерево, закодированное в базе данных MySQL как ребра:

CREATE TABLE items (
    num INT,
    tot INT,
    PRIMARY KEY (num)
    );
CREATE TABLE tree (
    orig INT,
    term INT
    FOREIGN KEY (orig,term) REFERENCES items (num,num)
    )

Для каждого листа в дереве, items.tot устанавливается кем-то. Для внутренних узлов items.tot должен быть суммой его дочерних элементов. Повторное выполнение следующего запроса приведет к желаемому результату.

UPDATE items SET tot = (
    SELECT SUM(b.tot) FROM
        tree JOIN items AS b
        ON tree.term = b.num 
        WHERE tree.orig=items.num)
    WHERE EXISTS 
        (SELECT * FROM tree WHERE orig=items.num)

(обратите внимание, что это на самом деле не работает, но это к делу не относится)

Предположим, что база данных существует и инвариант уже удовлетворен.

Вопрос в том:

Каков наиболее практичный способ обновления DB при сохранении этого требования? Обновления могут перемещать узлы вокруг или изменять значение tot на конечных узлах. Можно предположить, что листовые узлы останутся листовыми узлами, внутренние узлы останутся внутренними узлами, и все это останется как правильное дерево.

Некоторые мысли у меня были:

• Полное аннулирование, после любого обновления, пересчитать все (ум... Нет)
• Установите триггер в таблице элементы для обновления родительского элемента любой обновляемой строки
  • Это было бы рекурсивно (обновления запускают обновления, запускают обновления,...)
  • Не работает, MySQL не может обновить таблицу, которая запустила триггер
• Установите триггер для планирования обновления родительского элемента любой обновляемой строки
  • Это было бы итеративно (получить элемент из расписания, обработка его планирует больше элементов)
  • Что же это такое? Доверяйте клиентскому коду, чтобы получить его правильно?
  • Преимущество заключается в том, что если обновления упорядочены правильно, то меньше сумм должно быть вычислено. Но этот порядок сам по себе является осложнением.

Идеальное решение было бы обобщить на другие "aggregating invariants"

FWIW я знаю, что это "немного за бортом", но я делаю это для удовольствия (Fun: verb, находя невозможное, делая это. :-)

Я смотрю на руководство PHP, и я не вижу раздела о структурах данных, которые есть в большинстве языков, таких как списки и наборы. Я просто слепой или у PHP нет ничего подобного встроенного?

До сих пор я сталкивался со списком смежности, вложенными наборами и вложенными интервалами в качестве моделей для хранения древовидных структур в базе данных. Я знаю их достаточно хорошо и перекочевал с одного дерева на другое.

Каковы другие популярные модели? Каковы их характеристики? Каковы хорошие ресурсы (книги, интернет и т. д.) По этой теме?

Я не только ищу хранилище БД, но и хотел бы расширить свои знания о деревьях в целом. Например, я понимаю, что вложенные наборы / интервалы особенно благоприятны для хранения реляционных баз данных, и спросил себя, действительно ли они являются плохим выбором в других контекстах?