C 存储多个for循环的结果_C_Arrays_List_Loops_Multidimensional Array

C 存储多个for循环的结果

c arrays list loops

C 存储多个for循环的结果,c,arrays,list,loops,multidimensional-array,C,Arrays,List,Loops,Multidimensional Array,我有一个python代码，现在我正努力用c编写它（以优化速度），因为我从未使用过c 以前我常常将结果数据存储在字典或数组列表中，但我不知道什么是合适的结构以及如何在c中存储它我从一个名为（尝试）的文件中读取数据，然后使用代码中编写的函数对其进行处理。三个for循环用于生成所需的数据，但我不知道如何存储它包含循环的代码 for (i=0; i<m; i++){ igraph_edge(&graph, i, &from, &to); igraph_nei

我有一个python代码，现在我正努力用c编写它（以优化速度），因为我从未使用过c

以前我常常将结果数据存储在字典或数组列表中，但我不知道什么是合适的结构以及如何在c中存储它

我从一个名为（尝试）的文件中读取数据，然后使用代码中编写的函数对其进行处理。三个

for循环

用于生成所需的数据，但我不知道如何存储它

包含循环的代码

for (i=0; i<m; i++){
   igraph_edge(&graph, i, &from, &to);
   igraph_neighbors(&graph, &v1, from, IGRAPH_ALL);
   igraph_neighbors(&graph, &v2, to, IGRAPH_ALL);
   for (j=0; j < igraph_vector_size(&v2); j++) {
     for (k=0; k < igraph_vector_size(&v1); k++) {
       printf("%li %d %f %d %f\n", i, from, VECTOR(v1)[k] ,to, VECTOR(v2)[j]);     
     } 
   }
}     

 //EDIT: concerning the different data types, at the end all elements inside the loops could have have the same type so


int n1, n2;
for (i=0; i<m; i++){
    igraph_edge(&graph, i, &from, &to);
    igraph_neighbors(&graph, &v1, from, IGRAPH_ALL);
    igraph_neighbors(&graph, &v2, to, IGRAPH_ALL);
    for (j=0; j < igraph_vector_size(&v2); j++) {
      for (k=0; k < igraph_vector_size(&v1); k++) {
        n1 =  floor(VECTOR(v1)[k]);
        n2 =  floor(VECTOR(v2)[j]);
        printf("%li %d %d %d %d\n", i, from, n1 ,to, n2);                        
      }
    }
 }

我不想打印这些数据，而是将其存储为

data = [ [ [1, 2.000000, 2 ,1.000000], [1, 2.000000, 2, 3.000000], [1, 2.000000, 2, 4.000000] ], [  [2, 1.000000, 3, 2.000000], [2, 3.000000, 3, 2.000000], ...  ], ... ]

然后如果我需要访问数据

对于索引0，

data[0]=[1,2.000000,21.000000]，[1,2.000000,2,3.000000]，[1,2.000000,2,4.000000]

和

数据[0][2]=[1 2.000000 2 4.000000]

和

数据[0][2][3]=[4.000000]

数据[0][2][3]=4.000000

就我而言，这可能吗？我将非常感谢任何帮助

附言：我很乐意解释任何不清楚的事情

添加

以下是完整的代码（如果需要）

我想储存它

每个元素都需要一个结构，比如

typedef Struct Data {
  int from;
  float vfrom;
  int to;
  float vto;
} Data;

然后是一个

数据**

注意这样做不允许有

数据[0][2][3]=[4.000000]

否则需要有

浮点***

，这是不实际的，它是

数据[0][2]。vto==4.000000

例如，替换

 for (i=0; i<m; i++){
    igraph_edge(&graph, i, &from, &to);
    igraph_neighbors(&graph, &v1, from, IGRAPH_ALL);
    igraph_neighbors(&graph, &v2, to, IGRAPH_ALL);
    for (j=0; j < igraph_vector_size(&v2); j++) {
      for (k=0; k < igraph_vector_size(&v1); k++) {
        printf("%li %d %f %d %f\n", i, from, VECTOR(v1)[k] ,to, VECTOR(v2)[j]);                        
      }
    }
 }

允许做：

 Datas * all = malloc(m * sizeof(Datas));

 for (i=0; i<m; i++){
    igraph_edge(&graph, i, &from, &to);
    igraph_neighbors(&graph, &v1, from, IGRAPH_ALL);
    igraph_neighbors(&graph, &v2, to, IGRAPH_ALL);

    int jsup = igraph_vector_size(&v2);
    int ksup = igraph_vector_size(&v1);
    Data * a = malloc(jsup * ksup * sizeof(Data));

    all[i].n = jsup * ksup;
    all[i].datas = a;

    for (j=0; j < jsup; j++) {
      for (k=0; k < ksup; k++) {
        a->from = from;
        a->vfrom = VECTOR(v1)[k];
        a->to = to;
        a->vto = VECTOR(v2)[j];
        a += 1;
      }
    }
 }

执行：

pi@raspberrypi:/tmp $ ./a.out
1 2.000000 2 1.000000
1 2.000000 2 3.000000
1 2.000000 2 4.000000
2 1.000000 3 2.000000
2 3.000000 3 2.000000
2 4.000000 3 2.000000
2 1.000000 3 4.000000
2 3.000000 3 4.000000
2 4.000000 3 4.000000
2 1.000000 4 2.000000
2 3.000000 4 2.000000
2 4.000000 4 2.000000
2 1.000000 4 3.000000
2 3.000000 4 3.000000
2 4.000000 4 3.000000
2 1.000000 4 5.000000
2 3.000000 4 5.000000
2 4.000000 4 5.000000
3 2.000000 4 2.000000
3 4.000000 4 2.000000
3 2.000000 4 3.000000
3 4.000000 4 3.000000
3 2.000000 4 5.000000
3 4.000000 4 5.000000
4 2.000000 5 4.000000
4 3.000000 5 4.000000
4 5.000000 5 4.000000
data : [ [ [1 2.000000 2 1.000000] [1 2.000000 2 3.000000] [1 2.000000 2 4.000000] ] [ [2 1.000000 3 2.000000] [2 3.000000 3 2.000000] [2 4.000000 3 2.000000] [2 1.000000 3 4.000000] [2 3.000000 3 4.000000] [2 4.000000 3 4.000000] ] [ [2 1.000000 4 2.000000] [2 3.000000 4 2.000000] [2 4.000000 4 2.000000] [2 1.000000 4 3.000000] [2 3.000000 4 3.000000] [2 4.000000 4 3.000000] [2 1.000000 4 5.000000] [2 3.000000 4 5.000000] [2 4.000000 4 5.000000] ] [ [3 2.000000 4 2.000000] [3 4.000000 4 2.000000] [3 2.000000 4 3.000000] [3 4.000000 4 3.000000] [3 2.000000 4 5.000000] [3 4.000000 4 5.000000] ] [ [4 2.000000 5 4.000000] [4 3.000000 5 4.000000] [4 5.000000 5 4.000000] ] ]

半相关的，如果你只关心提高速度（而不是学习C），你可能会考虑NuMPY或Cython。first@UnholySheep谢谢，但我已经用c写了它的代码，只是我现在需要存储结果！根据您的预期结果，您应该创建一个

struct

来保存您要存储的值，然后将该

struct

创建一个数组，并填入loop@Noah16我给出了一个答案，允许保存数据，然后在不假设

igraph\u vector\u size（）的情况下打印它们

总是返回比

数据更具描述性的相同的值名，而数据
（作为一个已经复数的术语的复数形式，这是非常奇怪的）会有所帮助。那么Edge
和Edges
呢？另外，最好解释一下需要结构的原因是，在C中，数组只能存储一种类型的值——不能有同时包含int和float的数组。@Caleb我使用数据和数据的原因很简单，因为我不知道这些信息的语义，所以无法给出更好的名称，OP可以重命名它们，这只是一个细节。数据是数据的向量，具有大小和值。关于你的评论的第二部分，我也很惊讶，因为我说过最好使用struct，而不仅仅是浮动***
；-）@布鲁诺感谢您的合作。我需要以这种方式调用元素data[0][2][3]=[4.000000]，因为在一次之后，我将访问数组列表以与每个元素进行比较，如：if（data[I][x][y]==j）{…}@Noah16我编写了所有这些数据，没有任何编译或执行，我没有igraph，也没有您的输入文件。关于data[0][2][3]=[4.000000]
你可能指的是4.0而不是数组，要做到这一点，假设你只有一个三维浮点数组，而不是一个二维结构数组，你真的想要吗？@Noah16你可以
 for (i=0; i<m; i++){
    igraph_edge(&graph, i, &from, &to);
    igraph_neighbors(&graph, &v1, from, IGRAPH_ALL);
    igraph_neighbors(&graph, &v2, to, IGRAPH_ALL);
    for (j=0; j < igraph_vector_size(&v2); j++) {
      for (k=0; k < igraph_vector_size(&v1); k++) {
        printf("%li %d %f %d %f\n", i, from, VECTOR(v1)[k] ,to, VECTOR(v2)[j]);                        
      }
    }
 }

 Data ** all = malloc(m * sizeof(Data*));

 for (i=0; i<m; i++){
    igraph_edge(&graph, i, &from, &to);
    igraph_neighbors(&graph, &v1, from, IGRAPH_ALL);
    igraph_neighbors(&graph, &v2, to, IGRAPH_ALL);
    all[i] = malloc(igraph_vector_size(&v2)*graph_vector_size(&v1)*sizeof(Data));

    int idx = 0;

    for (j=0; j < igraph_vector_size(&v2); j++) {
      for (k=0; k < igraph_vector_size(&v1); k++) {
        all[i][idx].from = from;
        all[i][idx].vfrom = VECTOR(v1)[k];
        all[i][idx].to = to;
        all[i][idx].vto = VECTOR(v2)[j];
        idx += 1;
      }
    }
 }

typedef Struct Data {
  int from;
  float vfrom;
  int to;
  float vto;
} Data;

typedef Datas {
   int n;
   Data * datas;
} Datas;

 Datas * all = malloc(m * sizeof(Datas));

 for (i=0; i<m; i++){
    igraph_edge(&graph, i, &from, &to);
    igraph_neighbors(&graph, &v1, from, IGRAPH_ALL);
    igraph_neighbors(&graph, &v2, to, IGRAPH_ALL);

    int jsup = igraph_vector_size(&v2);
    int ksup = igraph_vector_size(&v1);
    Data * a = malloc(jsup * ksup * sizeof(Data));

    all[i].n = jsup * ksup;
    all[i].datas = a;

    for (j=0; j < jsup; j++) {
      for (k=0; k < ksup; k++) {
        a->from = from;
        a->vfrom = VECTOR(v1)[k];
        a->to = to;
        a->vto = VECTOR(v2)[j];
        a += 1;
      }
    }
 }

printf("data : [");

for (i=0; i<m; i++) {
  Data * a = all[i].datas;

  printf(" [");

  for (int j = 0; j != all[i].n; ++j)
    printf(" [%d %f %d %f]", a[j].from, a[j].vfrom, a[j].to, a[j].vto);

  printf(" ]");
}

puts(" ]");

#include <igraph/igraph.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>

#define sigma 1

void print_vector(igraph_vector_t *v, FILE *file) {
     long int i;
     for (i=0; i < igraph_vector_size(v); i++) {
        fprintf(file, "%li \n", (long int) VECTOR(*v)[i]);
     }
     fprintf(file,"\n");
 }


float rbf(int a, int b);

float rbf(int a, int b) {
  double inverse;
  double exp(double x;);
  double x;
  double result;

  inverse = ( 1/(sigma*sigma) );
  x = (- inverse * ( (a - b)*(a - b) ) );
  result = exp(x);
  return (result); 
} 

typedef struct Data {
  int from;
  float vfrom;
  int to;
  float vto;
} Data;

typedef struct Datas {
   int n;
   Data * datas;
} Datas;


int main(void)
{

     igraph_t graph; 
     igraph_bool_t false;
     igraph_bool_t connected1, connected2, connected3, connected4, connected5, connected6;
     int ret;
     float rhs1;
     float rhs2;
     igraph_vector_t v1, v2;
     long int i, j, k, n, m ;
     igraph_integer_t from, to;
     igraph_adjlist_t adjlist;
     FILE *file;
     file = fopen("attempt", "r");
     if(!file){
        return 1;
     }

     igraph_read_graph_edgelist(&graph, file, 
                                0, false);

     fclose(file);

     igraph_vector_init(&v1, (igraph_vcount(&graph)) );
     igraph_vector_init(&v2, (igraph_vcount(&graph)) );
     igraph_adjlist_init(&graph, &adjlist, IGRAPH_ALL);

     n = igraph_vcount(&graph);
     m = igraph_ecount(&graph);
     Datas * all = malloc(m * sizeof(Datas));

     for (i=0; i<m; i++){
       igraph_edge(&graph, i, &from, &to);
       igraph_neighbors(&graph, &v1, from, IGRAPH_ALL);
       igraph_neighbors(&graph, &v2, to, IGRAPH_ALL);

       int jsup = igraph_vector_size(&v2);
       int ksup = igraph_vector_size(&v1);
       Data * a = malloc(jsup * ksup * sizeof(Data));

       all[i].n = jsup * ksup;
       all[i].datas = a;

       for (j=0; j < jsup; j++) {
         for (k=0; k < ksup; k++) {
           a->from = from;
           a->vfrom = VECTOR(v1)[k];
           a->to = to;
           a->vto = VECTOR(v2)[j];
           printf("%d %f %d %f\n", a->from, a->vfrom, a->to, a->vto);
           a += 1;
         }
       }
     }

     printf("data : [");

     for (i=0; i<m; i++) {
       Data * a = all[i].datas;

       printf(" [");

       for (int j = 0; j != all[i].n; ++j)
         printf(" [%d %f %d %f]", a[j].from, a[j].vfrom, a[j].to, a[j].vto);

       printf(" ]");
     }

     puts(" ]");

     /* free resources */
     igraph_destroy(&graph);
     igraph_vector_destroy(&v1);
     igraph_vector_destroy(&v2);
     igraph_adjlist_destroy(&adjlist);

     for (i=0; i<m; i++)
       free(all[i].datas);
     free(all);         

     return 0;
}

1 2
2 3
2 4
3 4
4 5

pi@raspberrypi:/tmp $ ./a.out
1 2.000000 2 1.000000
1 2.000000 2 3.000000
1 2.000000 2 4.000000
2 1.000000 3 2.000000
2 3.000000 3 2.000000
2 4.000000 3 2.000000
2 1.000000 3 4.000000
2 3.000000 3 4.000000
2 4.000000 3 4.000000
2 1.000000 4 2.000000
2 3.000000 4 2.000000
2 4.000000 4 2.000000
2 1.000000 4 3.000000
2 3.000000 4 3.000000
2 4.000000 4 3.000000
2 1.000000 4 5.000000
2 3.000000 4 5.000000
2 4.000000 4 5.000000
3 2.000000 4 2.000000
3 4.000000 4 2.000000
3 2.000000 4 3.000000
3 4.000000 4 3.000000
3 2.000000 4 5.000000
3 4.000000 4 5.000000
4 2.000000 5 4.000000
4 3.000000 5 4.000000
4 5.000000 5 4.000000
data : [ [ [1 2.000000 2 1.000000] [1 2.000000 2 3.000000] [1 2.000000 2 4.000000] ] [ [2 1.000000 3 2.000000] [2 3.000000 3 2.000000] [2 4.000000 3 2.000000] [2 1.000000 3 4.000000] [2 3.000000 3 4.000000] [2 4.000000 3 4.000000] ] [ [2 1.000000 4 2.000000] [2 3.000000 4 2.000000] [2 4.000000 4 2.000000] [2 1.000000 4 3.000000] [2 3.000000 4 3.000000] [2 4.000000 4 3.000000] [2 1.000000 4 5.000000] [2 3.000000 4 5.000000] [2 4.000000 4 5.000000] ] [ [3 2.000000 4 2.000000] [3 4.000000 4 2.000000] [3 2.000000 4 3.000000] [3 4.000000 4 3.000000] [3 2.000000 4 5.000000] [3 4.000000 4 5.000000] ] [ [4 2.000000 5 4.000000] [4 3.000000 5 4.000000] [4 5.000000 5 4.000000] ] ]