[Q&A] セグメの原因がわからない。

セグメの原因がわからない。

Q&AClosed

解決したいこと

セグメの原因がわからない。
以下のコードは物理現象を再現することを目的として、電子の生成消滅演算子を再現するものです。
また、その演算子を用いて固有ベクトルに変更を加えています。
以下のコードではN=10でコアダンプするが、Nがそれ以下の偶数の場合うまく起動するようになります。

発生している問題・エラー

Segmentation fault

gdbでは以下のようになります。

Program received signal SIGSEGV, Segmentation fault.
0x00000000004050ed in main ()
(gdb) bt
#0  0x00000000004050ed in main ()
(gdb)

コード上では
creation_vector_up(), annihilatioin_vector_up(),
creation_vector_down(), annihilatioin_vector_down()
を二つ以上実行するとセグメします。内容では

void annihilation_up_eigenvector(int binary_up[N], int binary_down[N], int search_2D[size], int search_gyakubiki[size_gyaku], 
     double eigenvector[size], double eigenvector_annihilation_up[size_annihilation_up], int index, int i_e_position){
    int binary_annihilation[L] = {0}, binary_up_copy[N] = {0}; copy_int(N, binary_up, binary_up_copy);
    annihilation_operator(binary_up, binary_up_copy, i_e_position); spin_connect(binary_annihilation, binary_up_copy, binary_down);
    int decimal = binaryToDecimal(binary_annihilation, L), index_annihilaton_up = (search_gyakubiki[binaryToDecimal(binary_up_copy, N)] - 1) * NUM_KET_down
                                                                                    + search_gyakubiki[binaryToDecimal(binary_down, N)];
⇒  (search_2D[index] != decimal) ? eigenvector_annihilation_up[index_annihilaton_up - 1] += eigenvector[index]
                                                                                             * countCrossing_new(binary_up, binary_up_copy, i_e_position): 0;
}

⇒の箇所をコメントアウトすると動くようになります。
配列の逸脱が考えられたためindex, index_annihilation_up が負、または配列よりも大きくなっていることが考えられセーフティーを設けたが、解決には至らなかった。

該当するソースコード

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

#define Lanczos_stop 5
#define N 10
#define L 2*N
#define Cn 100

int NUM_KET_up = 0, NUM_KET_down = 0, NUM_KET_creation_up = 0, NUM_KET_creation_down = 0, NUM_KET_annihilation_up = 0, NUM_KET_annihilation_down = 0;
int size = 0, size_creation_up = 0, size_creation_down = 0, size_annihilation_up = 0, size_annihilation_down = 0, size_gyaku = 0;
int M = 0, limit = 0; double t_opt = 1.0;

void shokika_double(int length, double hairetu[length]){
    for(int i = 0; i < length; i++){
        hairetu[i] = 0.0;
    }
}
void shokika_int(int length, int hairetu[length]){
    for(int i = 0; i < length; i++){
        hairetu[i] = 0.0;
    }
}
void shokika_matrix(int length, double hairetu[length][length]){
    for(int i = 0; i < length; i++){
        for(int j = 0; j < length; j++){
            hairetu[i][j] = 0.0;
        }
    }
}
void shokika_vector_convert(int length, double eigenvector_spin[N][length]){
    for(int i = 0; i < N; i++){
        for(int j = 0; j < length; j++){
            eigenvector_spin[i][j] = 0.0;
        }
    }    
}

void copy_double(int length, double hairetu_before[length], double hairetu_after[length]){
    for(int i = 0; i < length; i++){
        hairetu_after[i] = hairetu_before[i];
    }
}
void copy_double_complex(int length, double complex hairetu_before[length], double complex hairetu_after[length]){
    for(int i = 0; i < length; i++){
        hairetu_after[i] = hairetu_before[i];
    }
}
void copy_int(int length, int hairetu_before[length], int hairetu_after[length]){
    for(int i = 0; i < length; i++){
        hairetu_after[i] = hairetu_before[i];
    }
}

int combination(int n, int r) {
    int result = 1;
    for (int i = 1; i <= r; i++) {
        result *= (n - i + 1);
        result /= i;
    }
    return result;
}
double dot_product(int length, double vector_1[length], double vector_2[length]){ //内積
    double dot = 0.0;
    for(int i = 0; i < length; i++){
        dot += vector_1[i] * vector_2[i];
    }
    return dot;
}
double norm(int length, double vector[length]){ //ノルム
    double norm = 0.0;
    norm = dot_product(length, vector, vector);
    norm = pow(norm, 0.5);
    return norm;
}
void normalization(int length, double vector[length]){ //ヴェクトルの正規化
    double n = 0.0; 
    n = norm(length, vector); 
    for(int i = 0; i < length; i++){
        vector[i] = vector[i] / n;
    }
}

//random vector creation
void r_v_c(int size_length, double vector_q_0[size_length]){
    // 乱数の初期化
    srand(time(NULL));

    // ランダムな成分からなるベクトルを生成
    for (int i = 0; i < size_length; i++) {
        vector_q_0[i] = ((double)rand() / RAND_MAX) * 2.0 - 1.0;
    }

    double norm = 0.0;
    for (int i = 0; i < size_length; i++) {
        norm += vector_q_0[i] * vector_q_0[i];
    }
    norm = sqrt(norm);

    for (int i = 0; i < size_length; i++) {
        vector_q_0[i] /= norm;
    }
}

int countCrossing_new(int binary_1[N], int binary_2[N], int index_left) {   //operator
    int andresult[N] = {0};
    int count = 0, sign = 1;
    for(int i = 0; i < index_left; i++){
        andresult[i] = binary_1[i] & binary_2[i];
    }
    for(int i = 0; i < N; i++){
        count += andresult[i];
    } 
    sign = pow(-1, count);
    return sign;
}

// 二進数から10進数への変換関数
int binaryToDecimal(int *binary, int length) {
    int decimal = 0;
    for (int i = 0; i < length; i++) {
        decimal = (decimal << 1) | binary[i];
    }
    return decimal;
}
void decimalToBinary(int decimal, int *binary, int length) {
    for (int i = length - 1; i >= 0; i--) {
        binary[i] = decimal & 1;
        decimal >>= 1;
    }
}

void spin_separate(int binary[L], int binary_up[N], int binary_down[N]){
    for(int i = 0; i < N; i++){
        binary_up[i] = binary[i]; 
        binary_down[i] = binary[i + N]; 
    }
}
void spin_connect(int binary[L], int binary_up[N], int binary_down[N]){
    for(int i = 0; i < N; i++){
        binary[i] = binary_up[i];
        binary[i + N] = binary_down[i];
    }
}

int get(int decimal, int SPIN_up, int SPIN_down){
    int i_up = 0, i_down = 0, binary[L] = {0}; decimalToBinary(decimal, binary, L);
    for(int i = 0; i < N; i++){
        i_up += binary[i]; i_down += binary[i + N];
    }
    int check_spin = - 1; (i_up == SPIN_up && i_down == SPIN_down) ? check_spin = 0: (check_spin = - 1);
    return check_spin;
}
int get_2(int decimal, int i_spin){
    int binary[N] = {0};
    for(int i = 0; i < N; i++){
        binary[N - i - 1] = (decimal % 2);
        decimal /= 2;
    }
    int num_e = 0;
    for(int i = 0; i < N; i++){
        num_e += binary[i];
    }
    int check_spin = - 1;
    (num_e == i_spin) ? check_spin = 0: (check_spin = - 1);
    return check_spin;
}
void make_search(int size_length, int search_junbiki[size_length], int SPIN_up, int SPIN_down){
    int i_cnt = 0;
    for(int i = 0; i < pow(2, L) && i_cnt < size_length; i++){
        int check_spin = get(i, SPIN_up, SPIN_down);
        (check_spin == 0) ? (search_junbiki[i_cnt] = i, i_cnt++): 0;
    }
}
void make_gyakubiki(int search_gyakubiki[size_gyaku]){
    for(int i_spin = 0; i_spin < N + 1; i_spin++){
        int i_cnt = 0; int size_cnt = combination(N, i_spin); size_gyaku = (int)(pow(2, N));
        for(int i = 0; i < size_gyaku && i_cnt < size_cnt; i++){
            int check_spin = get_2(i, i_spin); (check_spin == 0) ? (search_gyakubiki[i] = i_cnt + 1, i_cnt++): 0;
        }   
    }
}
void search(int search_2D[size], 
    int search_creation_up[size_creation_up], int search_creation_down[size_creation_down], 
    int search_annihilation_up[size_annihilation_up], int search_annihilation_down[size_annihilation_down], int SPIN_up, int SPIN_down){
    shokika_int(size, search_2D);
    shokika_int(size_creation_up, search_creation_up);         shokika_int(size_creation_down, search_creation_down);
    shokika_int(size_annihilation_up, search_annihilation_up); shokika_int(size_annihilation_down, search_annihilation_down);

    make_search(size, search_2D, SPIN_up, SPIN_down);
    make_search(size_creation_up, search_creation_up, SPIN_up + 1, SPIN_down); 
    make_search(size_annihilation_up, search_annihilation_up, SPIN_up - 1, SPIN_down);
    make_search(size_creation_down, search_creation_down, SPIN_up, SPIN_down + 1);
    make_search(size_annihilation_down, search_annihilation_down, SPIN_up, SPIN_down - 1);
}

//生成・消滅演算子
void creation_operator(int binary_bf[N], int binary_af[N], int i_e_position){
    (binary_bf[i_e_position] == 0) ? binary_af[i_e_position] = 1 : 0;
}
void annihilation_operator(int binary_bf[N], int binary_af[N], int i_e_position){
    (binary_bf[i_e_position] == 1) ? binary_af[i_e_position] = 0 : 0;
}

void creation_up_eigenvector(int binary_up[N], int binary_down[N], int search_2D[size], int search_gyakubiki[size_gyaku],
     double eigenvector[size], double eigenvector_creation_up[size_creation_up], int index, int i_e_position){
    int binary_creation[L] = {0}, binary_up_copy[N] = {0}; copy_int(N, binary_up, binary_up_copy);
    creation_operator(binary_up, binary_up_copy, i_e_position); spin_connect(binary_creation, binary_up_copy, binary_down);
    int decimal = binaryToDecimal(binary_creation, L), index_creation_up = (search_gyakubiki[binaryToDecimal(binary_up_copy, N)] - 1) * NUM_KET_down
                                                                                    + search_gyakubiki[binaryToDecimal(binary_down, N)];
    (search_2D[index] != decimal && index_creation_up - 1 >= 0 && index_creation_up - 1 < size_creation_up) ? 
                    eigenvector_creation_up[index_creation_up - 1] += eigenvector[index] * countCrossing_new(binary_up, binary_up_copy, i_e_position): 0;

    // (search_2D[index] != decimal) ? printf("%d %d %d\n", index, index_creation_up, binaryToDecimal(binary_creation, L)): 0;
}
void annihilation_up_eigenvector(int binary_up[N], int binary_down[N], int search_2D[size], int search_gyakubiki[size_gyaku], 
     double eigenvector[size], double eigenvector_annihilation_up[size_annihilation_up], int index, int i_e_position){
    int binary_annihilation[L] = {0}, binary_up_copy[N] = {0}; copy_int(N, binary_up, binary_up_copy);
    annihilation_operator(binary_up, binary_up_copy, i_e_position); spin_connect(binary_annihilation, binary_up_copy, binary_down);
    int decimal = binaryToDecimal(binary_annihilation, L), index_annihilaton_up = (search_gyakubiki[binaryToDecimal(binary_up_copy, N)] - 1) * NUM_KET_down
                                                                                    + search_gyakubiki[binaryToDecimal(binary_down, N)];
    (search_2D[index] != decimal && index_annihilaton_up - 1 >= 0 && index_annihilaton_up - 1 < size_annihilation_up) ? 
                    eigenvector_annihilation_up[index_annihilaton_up - 1] += eigenvector[index] * countCrossing_new(binary_up, binary_up_copy, i_e_position): 0;
    // (search_2D[index] != decimal) ? printf("%d %d %d %d\n", index, search_2D[index], index_annihilaton_up - 1, binaryToDecimal(binary_annihilation, L)): 0;
}
void creation_down_eigenvector(int binary_up[N], int binary_down[N], int search_2D[size], int search_gyakubiki[size_gyaku],
     double eigenvector[size], double eigenvector_creation_down[size_creation_down], int index, int i_e_position){
    int binary_creation[L] = {0}, binary_down_copy[N] = {0}; copy_int(N, binary_down, binary_down_copy);
    creation_operator(binary_down, binary_down_copy, i_e_position); spin_connect(binary_creation, binary_up, binary_down_copy);
    int decimal = binaryToDecimal(binary_creation, L), index_creation_down = (search_gyakubiki[binaryToDecimal(binary_up, N)] - 1) * NUM_KET_creation_down
                                                                                    + search_gyakubiki[binaryToDecimal(binary_down_copy, N)];
    (search_2D[index] != decimal && index_creation_down - 1 >= 0 && index_creation_down - 1 < size_creation_down) ? 
                eigenvector_creation_down[index_creation_down - 1] += eigenvector[index] * countCrossing_new(binary_down, binary_down_copy, i_e_position): 0;
        // printf("%d %d %d\n", index, index_creation_down, decimal);
}
void annihilation_down_eigenvector(int binary_up[N], int binary_down[N], int search_2D[size],  int search_gyakubiki[size_gyaku],
     double eigenvector[size], double eigenvector_annihilation_down[size_annihilation_down], int index, int i_e_position){
    int binary_annihilation[L] = {0}, binary_down_copy[N] = {0}; copy_int(N, binary_down, binary_down_copy);
    annihilation_operator(binary_down, binary_down_copy, i_e_position); spin_connect(binary_annihilation, binary_up, binary_down_copy);
    int decimal = binaryToDecimal(binary_annihilation, L), index_annihilaton_down = (search_gyakubiki[binaryToDecimal(binary_up, N)] - 1) * NUM_KET_annihilation_down
                                                                                    + search_gyakubiki[binaryToDecimal(binary_down_copy, N)];
    (search_2D[index] != decimal && index_annihilaton_down - 1 >= 0 && index_annihilaton_down - 1 < size_annihilation_down) ?
                eigenvector_annihilation_down[index_annihilaton_down - 1] += eigenvector[index] * countCrossing_new(binary_down, binary_down_copy, i_e_position): 0;
        // printf("%d %d %d\n", index, index_annihilaton_down, binaryToDecimal(binary_annihilation, L));
}

void creation_up(int search_2D[size], int search_gyakubiki[size_gyaku], 
     double eigenvector[size], double eigenvector_creation_up[size_creation_up], int i_e_position){
    int binary[L] = {0}, binary_up[N] = {0}, binary_down[N] = {0};
    for(int index = 0; index < size; index++){
        decimalToBinary(search_2D[index], binary, L); spin_separate(binary, binary_up, binary_down);
        creation_up_eigenvector(binary_up, binary_down, search_2D, search_gyakubiki, eigenvector, 
                                 eigenvector_creation_up, index, i_e_position);
        // printf("%lf\n",eigenvector[index]);
    }
}
void annihilation_up(int search_2D[size], int search_gyakubiki[size_gyaku], 
     double eigenvector[size], double eigenvector_annihilation_up[size_annihilation_up], int i_e_position){
    int binary[L] = {0}, binary_up[N] = {0}, binary_down[N] = {0};
    for(int index = 0; index < size; index++){
        decimalToBinary(search_2D[index], binary, L); spin_separate(binary, binary_up, binary_down);
        annihilation_up_eigenvector(binary_up, binary_down, search_2D, search_gyakubiki, eigenvector,
                                     eigenvector_annihilation_up, index, i_e_position);
        // printf("%d %d\n", search_2D[index], index);
    }
}
void creation_down(int search_2D[size], int search_gyakubiki[size_gyaku],
     double eigenvector[size], double eigenvector_creation_down[size_creation_down], int i_e_position){
    int binary[L] = {0}, binary_up[N] = {0}, binary_down[N] = {0};
    for(int index = 0; index < size; index++){
        decimalToBinary(search_2D[index], binary, L); spin_separate(binary, binary_up, binary_down);
        creation_down_eigenvector(binary_up, binary_down, search_2D, search_gyakubiki, eigenvector,
                                     eigenvector_creation_down, index, i_e_position);
        // printf("%lf\n",eigenvector[index]);
    }
}
void annihilation_down(int search_2D[size], int search_gyakubiki[size_gyaku],
     double eigenvector[size], double eigenvector_annihilation_down[size_annihilation_down], int i_e_position){
    int binary[L] = {0}, binary_up[N] = {0}, binary_down[N] = {0};
    for(int index = 0; index < size; index++){
        decimalToBinary(search_2D[index], binary, L); spin_separate(binary, binary_up, binary_down);
        annihilation_down_eigenvector(binary_up, binary_down, search_2D, search_gyakubiki, eigenvector,
                                         eigenvector_annihilation_down, index, i_e_position);
        // printf("%d %d\n", search_2D[index], index);
    }
}

void creation_vector_up(int search_2D[size], int search_gyakubiki[size_gyaku],
     double eigenvector[size], double eigenvector_creation_up[N][size_creation_up]){
    for(int i_e_position = 0; i_e_position < N; i_e_position++){
        creation_up(search_2D, search_gyakubiki, eigenvector, eigenvector_creation_up[i_e_position], i_e_position);
    }
}
void creation_vector_down(int search_2D[size], int search_gyakubiki[size_gyaku],
     double eigenvector[size], double eigenvector_creation_down[N][size_creation_down]){
    for(int i_e_position = 0; i_e_position < N; i_e_position++){
        creation_down(search_2D, search_gyakubiki, eigenvector, eigenvector_creation_down[i_e_position], i_e_position);
    }
}
void annihilatioin_vector_up(int search_2D[size], int search_gyakubiki[size_gyaku], 
     double eigenvector[size], double eigenvector_annihilation_up[N][size_annihilation_up]){
    for(int i_e_position = 0; i_e_position < N; i_e_position++){
        annihilation_up(search_2D, search_gyakubiki, eigenvector, eigenvector_annihilation_up[i_e_position], i_e_position);
    }
}
void annihilatioin_vector_down(int search_2D[size], int search_gyakubiki[size_gyaku],
     double eigenvector[size], double eigenvector_annihilation_down[N][size_annihilation_down]){
    for(int i_e_position = 0; i_e_position < N; i_e_position++){
        annihilation_down(search_2D, search_gyakubiki, eigenvector, eigenvector_annihilation_down[i_e_position], i_e_position);
    }
}

int main(){
    double U_t = 1.0; int size_gyaku = (int)(pow(2, N));
    int search_gyakubiki[size_gyaku]; shokika_int(size_gyaku, search_gyakubiki); make_gyakubiki(search_gyakubiki);
    int SPIN_up = 5, SPIN_down = 5, filling = SPIN_up + SPIN_down; 
    NUM_KET_up = combination(N, SPIN_up);                  NUM_KET_down = combination(N, SPIN_down);
    NUM_KET_creation_up = combination(N, SPIN_up + 1);     NUM_KET_creation_down = combination(N, SPIN_down + 1);
    NUM_KET_annihilation_up = combination(N, SPIN_up - 1); NUM_KET_annihilation_down = combination(N, SPIN_down - 1);

    size = NUM_KET_up * NUM_KET_down;
    size_creation_up = NUM_KET_creation_up * NUM_KET_down;         size_creation_down =  NUM_KET_up * NUM_KET_creation_down;
    size_annihilation_up = NUM_KET_annihilation_up * NUM_KET_down; size_annihilation_down = NUM_KET_up * NUM_KET_annihilation_down;

    //辞書　normal creation annihilatioin
    int search_2D[size];
    int search_creation_up[size_creation_up], search_creation_down[size_creation_down];
    int search_annihilation_up[size_annihilation_up], search_annihilation_down[size_annihilation_down];
    search(search_2D, search_creation_up, search_creation_down, search_annihilation_up, search_annihilation_down, SPIN_up, SPIN_down);
    double vector[size]; r_v_c(size, vector);

    double eigenvector_creation_up[N][size_creation_up],     eigenvector_annihilation_up[N][size_annihilation_up];
    double eigenvector_creation_down[N][size_creation_down], eigenvector_annihilation_down[N][size_annihilation_down];
    shokika_vector_convert(size_creation_up, eigenvector_creation_up);     shokika_vector_convert(size_annihilation_up, eigenvector_annihilation_up);
    shokika_vector_convert(size_creation_down, eigenvector_creation_down); shokika_vector_convert(size_annihilation_up, eigenvector_annihilation_down);
    creation_vector_up(search_2D, search_gyakubiki, vector, eigenvector_creation_up);
    annihilatioin_vector_up(search_2D, search_gyakubiki, vector, eigenvector_annihilation_up);
    // creation_vector_down(search_2D, search_gyakubiki, vector, eigenvector_creation_down);
    // annihilatioin_vector_down(search_2D, search_gyakubiki, vector, eigenvector_annihilation_down);
        
    return 0;
}

自分で試したこと

正直、いろいろ確認しましたがよくわからなくなってしまったため、岡目八目的にアドバイスをいただきたく質問しました。

環境はメモリ８GB、windouws11,WSL上でoneAPIを用いて計算しております。
申し訳ございませんが、よろしければご助言いただけますと幸いです。

(20240508での問題は解決できました。)

2Answer

@YearCentury posted at 2024-05-10

環境が異なりますので、質問者殿と同じ動きにはならなかったのですが、Segmentation fault　は発生しています。
確認したところ、こちらではmain()内で問題が発生してます。
前回(20240508)と同じローカル変数領域がなくなって、領域外アクセスになってるようですね。

    double eigenvector_creation_up[N][size_creation_up],     eigenvector_annihilation_up[N][size_annihilation_up];
    double eigenvector_creation_down[N][size_creation_down], eigenvector_annihilation_down[N][size_annihilation_down];

この子達がローカル変数領域を確保でできなくて発生してました。。
発生場所は違えど同じ問題でローカル変数領域がなくなったのでしょう。
力ずくですが、とりあえずその子らを修正すれば、Segmentation fault　は解決すると思います。

-    double eigenvector_creation_up[N][size_creation_up],     eigenvector_annihilation_up[N][size_annihilation_up];
+    double *eigenvector_creation_up = malloc( sizeof(double) * N * size_creation_up);
+    if( !eigenvector_creation_up ){
+        printf("動的メモリ確保できなかった。");
+        exit(1);
+    }
+    double *eigenvector_annihilation_up = malloc( sizeof(double) * N * size_annihilation_up);
+    if( !eigenvector_annihilation_up ){
+        printf("動的メモリ確保できなかった。");
+        exit(1);
+    }
-    double eigenvector_creation_down[N][size_creation_down], eigenvector_annihilation_down[N][size_annihilation_down];
+    double *eigenvector_creation_down = malloc( sizeof(double) * N * size_creation_down );
+    if( !eigenvector_creation_down ){
+        printf("動的メモリ確保できなかった。");
+        exit(1);
+    }
+    double *eigenvector_annihilation_down = malloc( sizeof(double) * N * size_annihilation_down);
+   if( !eigenvector_annihilation_down ){
+        printf("動的メモリ確保できなかった。");
+        exit(1);
+    }

この修正で動くと思いますが、ワーニングが嫌であればキャストの追加が必要です。


-    shokika_vector_convert(size_creation_up, eigenvector_creation_up);     shokika_vector_convert(size_annihilation_up, eigenvector_annihilation_up);
+    shokika_vector_convert(size_creation_up, (double(*)[])eigenvector_creation_up);     shokika_vector_convert(size_annihilation_up, (double(*)[])eigenvector_annihilation_up);
-    shokika_vector_convert(size_creation_down, eigenvector_creation_down); shokika_vector_convert(size_annihilation_up, eigenvector_annihilation_down);
+    shokika_vector_convert(size_creation_down, (double(*)[])eigenvector_creation_down); shokika_vector_convert(size_annihilation_up, (double(*)[])eigenvector_annihilation_down);
-    creation_vector_up(search_2D, search_gyakubiki, vector, eigenvector_creation_up);
+    creation_vector_up(search_2D, search_gyakubiki, vector, (double(*)[])eigenvector_creation_up);
-    annihilatioin_vector_up(search_2D, search_gyakubiki, vector, eigenvector_annihilation_up);
+    annihilatioin_vector_up(search_2D, search_gyakubiki, vector, (double(*)[])eigenvector_annihilation_up);

Comments

@kisara11235
Questioner
コメントありがとうございます。
こちらの環境でも上記の変更によりコアダンプせずに動くようになりました。

今までローカル領域にのみメモリを確保していたため、前回と同様の問題が生じているのだと思います。次回よりは動的メモリを活用し、メモリ管理にも意識を向けていこうと考えております。
前回に引き続きアドバイスいただきありがとうございます。

@iiokazuya posted at 2024-05-10

エラーメッセージを見る限り、main()のどこかで問題が発生しているようです。

ステップ実行して、どこの行でエラーになっているかを特定してみてはどうでしょう？

Comments

@kisara11235
Questioner
コメントありがとうございます。
それについてはおそらく同じサイトを参考にやってみましたが、やはり「発生する問題」のところにあるようなことがわかるだけで、何ともならなかったです。
@iiokazuya
各変数をダンプした結果はどうでしょう？
配列インデックスがオーバーしているならその変数がおかしい事になっているはずですし、そもそも配列(行列)が巨大になりすぎている可能性もあります。
@kisara11235
Questioner
たびたびありがとうございます。
問題としては@YearCentury 様もご指摘の通り、配列が巨大になっていることにありました。
前回の質問の際にも同様の問題があり、コアダンプしていたのだと思います。

前回、今回と質問に助言を下さり、誠に感謝しております。
ステップを実行することも次回からのデバッグで行うようにいたします。
@iiokazuya
頑張ってください。

ちなみに、配列の初期化とコピーですが、memset()とmemcpy()という関数があります。
もしかたらこちらの方が早くなるかもしれません、ご参考までに。
使用例

#inclucde <string.h> memset(array, 0, array_size); memcpy(array_dest, array_src, array_size);

セグメの原因がわからない。

解決したいこと

発生している問題・エラー

該当するソースコード

自分で試したこと

2Answer

Comments

Comments

Your answer might help someone💌

Popular Questions