如何使用C中的函数生成随机数数组

Question

我正在尝试将程序从Matlab移植到C，以提高执行时间和内存使用率。 由于C中没有函数会生成0和1的均匀填充数组（或者我找不到它们），因此我创建了一个函数来根据相关的概率填充数组。

例如 ：如果该概率是0.3（30％）予想有100个元素的阵列，具有零和一随机填充，并且阵列中的一些的总和必须接近30。

我使用N =试验次数，而不是100，因此，如果N = 10000，则阵列总和应接近3000，以此类推。

Matlab中的函数只是：

function [y] = rand_gen(N,Prob)

    for i=1:N
        y(i,1) = binornd(1,Prob);
    end
end

该函数将被称为：

array = rand_gen(N, Probability);

现在，这是C语言中的问题：运行程序时，我可以生成一些数组，但是最大尝试次数（N）非常低，我认为这与内存无关。 如果我以N = 100000运行该程序，则一切正常，但在100000（及某些）崩溃之后。 C语言中的程序是：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int * rand_gen(int N, double Prob); // Function declaration
int sum_array(int a[], int num_elements);    // Function declaration

int main()  // Main function
{
int N;  // Declaration: Number of trials
printf("Number of trials: ");
scanf("%d", &N);    // Asks for Number of trials

double Prob_a = 0.5;   // Probability (50%)
int i;  // Declaration: Index
int sum; // Declaration: sum of elements of arrays
int bin_array_0[N]; // Declaration: array populated randomly by 0 and 1
int bin_array_1[N]; // Declaration: array populated randomly by 0 and 1
int bin_array_2[N]; // Declaration: array populated randomly by 0 and 1
int bin_array_3[N]; // Declaration: array populated randomly by 0 and 1
int *ptrnd = NULL; // Declaration: pointer to array
int seed = time(NULL); // Declaration: random number generator seed (based on current time)
srand(seed);


ptrnd = rand_gen(N, Prob_a);    // Populate a temporary array with 0 and 1 using the rand_gen function

for(i=0 ; i<N ; i++)
{
    bin_array_0[i] = *(ptrnd + i);
}
/* Print the sum of ones in the array
 * in order to check the rand_gen probability
 * reliability and compare to the temp array   */
sum = sum_array(bin_array_0, N);
printf("\n The sum of the bin_array_0 is %d\n", sum);



ptrnd = rand_gen(N, Prob_a);    // Populate a temporary array with 0 and 1 using the rand_gen function

for(i=0 ; i<N ; i++)
{
    bin_array_1[i] = *(ptrnd + i);
}
/* Print the sum of ones in the array
 * in order to check the rand_gen probability
 * reliability and compare to the temp array   */
sum = sum_array(bin_array_1, N);
printf("\n The sum of the bin_array_1 is %d\n", sum);


ptrnd = rand_gen(N, Prob_a);    // Populate a temporary array with 0 and 1 using the rand_gen function

for(i=0 ; i<N ; i++)
{
    bin_array_2[i] = *(ptrnd + i);
}
/* Print the sum of ones in the array
 * in order to check the rand_gen probability
 * reliability and compare to the temp array   */
sum = sum_array(bin_array_2, N);
printf("\n The sum of the bin_array_2 is %d\n", sum);


ptrnd = rand_gen(N, Prob_a);    // Populate a temporary array with 0 and 1 using the rand_gen function

for(i=0 ; i<N ; i++)
{
    bin_array_3[i] = *(ptrnd + i);
}
/* Print the sum of ones in the array
 * in order to check the rand_gen probability
 * reliability and compare to the temp array   */
sum = sum_array(bin_array_3, N);
printf("\n The sum of the bin_array_3 is %d\n", sum);

return(0);

}


// Function: generate an array populated by 0 and 1 according to a uniformed distribution
int * rand_gen(int N, double Prob)
{
    int sum; // Declaration: sum of elements of arrays
    int *array;
    array = (int *)malloc(sizeof(int)*N);
    if(array == NULL)
    {
        printf("\nRun out of memory!\n");
        exit(1);
    }

    int j;
    double x;

    for(j=0; j<N; j++)
    {
        x=rand();
        x=x/RAND_MAX;
        if (x < Prob)
        {
            array[j]=1;
        }
        else
        {
            array[j]=0;
        }
    }

/* Print the sum of ones in the array
 * in order to check the rand_gen probability
 * reliability and compare to the bin_array_*   */
    sum = sum_array(array, N);
    printf("\n The sum of the temp array is %d\n", sum);

    return array;
}


// Function: sum elements of array and return the sum.
int sum_array(int a[], int num_elements)
{
    int k, sum=0;
    for (k=0; k<num_elements; k++)
        {
        sum = sum + a[k];
        }
    return(sum);
}

请给我一些解决问题的技巧。 我已经尝试过使用不同类型的值（ long代替int ， double代替float ），但是没有任何结果。 先感谢您！

干杯，

Pullo86

Answer 1

您几乎肯定想做的就是传递rand_gen()指向要填充的数组的指针，并对其进行写入，而不是让它分配大数组，然后复制并泄漏。 （此应用程序可能更适合带有<random>和<vector>的C ++ STL。）

但是，如果要使用此基本结构，请声明：

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

/* Set N. */

bool *binarray[] = {
  rand_gen( N, prob_a ), // binarray[0]
  rand_gen( N, prob_a ), 
  rand_gen( N, prob_a ),
  rand_gen( N, prob_a )  // binarray[3]
};
static const size_t m = sizeof(binarray)/sizeof(binarray[0]);

/* Do stuff with binarray[0] through binarray[m-1]. */

for ( size_t i = 0; i < m; ++i ) {
  free(binarray[i]);
  binarray[i] = NULL;
}

但是，实际上，您可能希望使用随机生成器更新的数组数组，例如：

bool *fill_arrays( size_t m, size_t n, bool to_fill[m][n], double prob )
{
  for ( size_t i = 0; i < m; ++i )
    rand_gen_in_place( to_fill[i], n, prob );

  return to_fill;
}

void do_stuff_with( size_t m, size_t n, bool binarray[m][n] );

int main(void)
{
  /* … */
  bool* arrayp = calloc( M*N, sizeof(bool) );
  fill_arrays( M, N, arrayp, prob_a );
  do_stuff_with( M, N, arrayp );
  free(arrayp);
  /* … */
}