короткий короткий int в c?

Тип _Bool является стандартным в самой последней версии C, но это все еще не то, что вам нужно, потому что _Bool по-прежнему занимает как минимум один байт (как и char по определению).

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

Вам нужно растровое изображение (или массив битов, как его называет Википедия).

И нет такой вещи, как short short int, это просто char, который является наименьшим классом хранения целых чисел в C.

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

Небольшой пример может помочь проиллюстрировать:

Используя обычную целочисленную матрицу:

int mat[8*8]; // assuming row major order
int is_element_set(int x, int y) { 
  return mat[y*8 + x];
}

С растровым изображением:

unsigned char mat[8]; // assuming CHAR_BIT == 8
int is_element_set(int x, int y) { 
  return mat[y] & (1 << x);
}

У вас есть около 50 терабит данных. Вы хотите разместить их все в оперативной памяти сразу? Было бы полным безумием использовать более одного бита оперативной памяти для хранения одного бита информации, и даже в этом случае ваш компьютер должен был бы быть размером с самый большой суперкомпьютер на этой планете. Забудьте о производительности битовой упаковки. Вам придется беспокоиться о совершенно других вещах.

5e13, это около 5,6 терабайт памяти, которые вам понадобятся только для представления вашего битового поля. Вероятно, есть лучший способ справиться с вашей проблемой.

Возможно, вы могли бы использовать какую-нибудь разумную реализацию структур битовых полей, доступных в ANSI C.

Что-то вроде этого:

typedef struct node_t_
{
    char bit0 : 1;
    char bit1 : 1;
    char bit2 : 1;
    char bit3 : 1;
    char bit4 : 1;
    char bit5 : 1;
    char bit6 : 1;
    char bit7 : 1;
} node_t;

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

C99 stdbool.h позволяет использовать bool. Однако здесь ваша проблема заключается в том, что 4.9999995e13/8 даст более или менее 6.2500e+12 ($10^9$ — Гбайт, $10^12$ — Тбайт), поэтому вам нужно более 6 Тбайт реальной + виртуальной памяти (чтобы быть счастливый). Это говорит о том, что вы делаете что-то еще неправильно. Вам нужно «масштабировать» вашу проблему на подзадачи, с которыми вы можете справиться, используя меньше памяти.

Как предлагали другие люди, вам, вероятно, следует использовать битовое поле.

Кроме того, если вы просто используете значения true/false, и одно из значений гораздо менее распространено, чем другое, рассмотрите возможность использования неявного кодирования. Вы можете легко сделать это с помощью структуры данных карты. Когда вы работаете с графами, это сэкономит вам огромное количество памяти, если ваш граф совсем разреженный. Если вы объедините это с методами упаковки битов, описанными выше, вы можете даже поместить все это в ОЗУ. Однако нужно быть довольно умным с индексацией.

Еще одна вещь, которую вы могли бы сделать, если вас не волнует снижение производительности во время обработки (т. е. если вы больше беспокоитесь о сохранении данных, чем об их обработке), — запустить структуру через сжатие алгоритм в блоках. Есть библиотека C для bzip2, которая может сэкономить вам 90% или больше на чем-то подобном. Недостатки в том, что это займет (очень!) много времени. Вы можете получить сравнимую производительность с побитовым компрессором, таким как Dynamic Markov Compression (DMC), и они намного быстрее.

Я пытаюсь выжать из своей памяти как можно больше.

Если бы это было правдой, то вы бы не тратили 8 бит на хранение 1 бита данных. Вы бы использовали битовое поле.

Если вы знаете что-нибудь о содержимом матрицы, вы можете использовать другие оптимизации. Например, если вы знаете, что большая часть матрицы обычно равна нулю, вы можете сохранить только пары x,y элементов, равных единице.

Если нет, то 4.9999995e13 займет около 6 ТБ ОЗУ!