Большой массив 2d в C

Question

Я пытаюсь решить задачу линейной оптимизации 4 переменных и ограничений 600000. Мне нужно создать большой вход. Поэтому мне нужно A[600000][4] для коэффициентов ограничения и b[600000] для правой части. Вот код для создания 600000 ограничений.

int i, j; 
int numberOfInequalities = 600000; 
double c[4]; 
double result[4];; 
double A[numberOfInequalities][4], b[numberOfInequalities]; 

printf("\nPreparing test: 4 variables, 600000 inequalities\n"); 
A[0][0] = 1.0; A[0][1] = 2.0; A[0][2] = 1.0; A[0][3] = 0.0; b[0] = 10000.0; 
A[1][0] = 0.0; A[1][1] = 1.0; A[1][2] = 2.0; A[1][3] = 1.0; b[1] = 10000.0; 
A[2][0] = 1.0; A[2][1] = 0.0; A[2][2] = 1.0; A[2][3] = 3.0; b[2] = 10000.0; 
A[3][0] = 4.0; A[3][1] = 0.0; A[3][2] = 1.0; A[3][3] = 1.0; b[3] = 10000.0; 
c[0]=1.0; c[1]=1.0; c[2]=1.0; c[3]=1.0; 
for(i=4; i< 100000; i++) 
{ 
    A[i][0] = (12123*i)%104729; 
    A[i][1] = (47*i)%104729; 
    A[i][2] = (2011*i)%104729; 
    A[i][3] = (7919*i)%104729; 
    b[i] = A[i][0] + 2*A[i][1] + 3*A[i][2] + 4* A[i][3] + 1 + (i%137); 
} 
A[100000][0] = 0.0; A[100000][1] = 6.0; A[100000][2] = 1.0; 
A[100000][3] = 1.0; b[100000] = 19.0; 
for(i=100001; i< 200000; i++) 
{ 
    A[i][0] = (2323*i)%101111; 
    A[i][1] = (74*i)%101111; 
    A[i][2] = (2017*i)%101111; 
    A[i][3] = (7915*i)%101111; 
    b[i] = A[i][0] + 2*A[i][1] + 3*A[i][2] + 4* A[i][3] + 2 + (i%89); 
} 
A[200000][0] = 5.0; A[200000][1] = 2.0; A[200000][2] = 0.0; 
A[200000][3] = 1.0; b[200000] = 13.0; 
for(i=200001; i< 300000; i++) 
{ 
    A[i][0] = (23123*i)%100003; 
    A[i][1] = (47*i)%100003; 
    A[i][2] = (2011*i)%100003; 
    A[i][3] = (7919*i)%100003; 
    b[i] = A[i][0] + 2*A[i][1] + 3*A[i][2] + 4* A[i][3] + 2 + (i%57); 
} 
A[300000][0] = 1.0; A[300000][1] = 2.0; A[300000][2] = 1.0; 
A[300000][3] = 3.0; b[300000] = 20.0; 
A[300001][0] = 1.0; A[300001][1] = 0.0; A[300001][2] = 5.0; 
A[300001][3] = 4.0; b[300001] = 32.0; 
A[300002][0] = 7.0; A[300002][1] = 1.0; A[300002][2] = 1.0; 
A[300002][3] = 7.0; b[300002] = 40.0; 
for(i=300003; i< 400000; i++) 
{ 
    A[i][0] = (13*i)%103087; 
    A[i][1] = (99*i)%103087; 
    A[i][2] = (2012*i)%103087; 
    A[i][3] = (666*i)%103087; 
    b[i] = A[i][0] + 2*A[i][1] + 3*A[i][2] + 4* A[i][3] + 1; 
} 
for(i=400000; i< 500000; i++) 
{ 
    A[i][0] = 1; 
    A[i][1] = (17*i)%999983; 
    A[i][2] = (1967*i)%444443; 
    A[i][3] = 2; 
    b[i] = A[i][0] + 2*A[i][1] + 3*A[i][2] + 4* A[i][3] + (1000000.0/(double)i); 
} 
for(i=500000; i< 600000; i++) 
{ 
    A[i][0] = (3*i)%111121; 
    A[i][1] = (2*i)%999199; 
    A[i][2] = (2*i)%444443; 
    A[i][3] = i; 
    b[i] = A[i][0] + 2*A[i][1] + 3*A[i][2] + 4* A[i][3] + 1.3; 
} 

Проблема в том, что не может создать такой большой массив, он просто заканчивается на время выполнения, но это работает отлично, если я не создавать не более 200000 ограничений. Я пытался увеличить размер стека до неограниченного значения, но это не помогло. Я попытался использовать указатели типа ** A, но я получаю неправильный результат вывода. P.S. Я использую Ubuntu. Любые идеи?

Answer 1

Если numberOfInequalities постоянная времени выполнения, вы могли бы сделать его #define и определить A и b как глобальные переменные или static локальные переменные:

#define numberOfInequalities 600000 
static double A[numberOfInequalities][4], b[numberOfInequalities]; 

Это будет перемещать эти массивы из «стека» к " bss '.

Лучшее решение выделить эти массивы с malloc:

double (*A)[4] = malloc(numberOfInequalities * 4 * sizeof(double)); 
double *b = malloc(numberOfInequalities * sizeof(double)); 

Это заставит эти массивы, которые будут выделены из памяти «кучи». Не забудьте освободить их, прежде чем вернуться к вызывающему.

См http://www.geeksforgeeks.org/memory-layout-of-c-program/ для краткого объяснения, как память расположена в типичной программе C