IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

D Discussion :

Suite de Stern-Brocot, erreur de segmentation


Sujet :

D

  1. #1
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Juillet 2012
    Messages
    6
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juillet 2012
    Messages : 6
    Points : 8
    Points
    8
    Par défaut Suite de Stern-Brocot, erreur de segmentation
    Bonjour à tous.

    J'ai écrit le code ci-dessous afin de générer la suite de suites de Stern-Brocot. Je stocke la suite SB(n) dans le fichier texte n.txt.

    Le main est simple : on demande à l'utilisateur un entier n puis on génére SB(0), SB(1) ...SB(n-1), SB(n); soit les n+1 premières suites de Stern-Brocot à l'aide de la fonction SB.
    Le code ci-dessous fonctionne tant que n ne dépasse pas 14. Pour n = 15, j'obtiens l'erreur : "Erreur de Segmentation (core dumped)".
    Pouvez-vous m'aider à comprendre pourquoi ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
     
    import std.stdio;
    import std.math;
    import std.string;
    import std.file;
    import std.regex;
     
     
    struct rationnel{
      int num;
      int den;
    };
    alias rationnel rat;
    int main(){
    int n;
    write("n : ");
    readf(" %s",&n);
    SB(n);
    return 0;
    }
    void SB(int n){
    int cn = 0;
    File file = File("0.txt","w");
    file.write("0/1\n1/0");
    file.close;
    while(cn < n)
            {
            writeln("Generating SB(",cn+1,").");
            File from = File(_cast(cn)~".txt","r");
            File to = File(_cast( cn+1)~".txt","w");
            string A;
            string B;
            A = chomp(from.readln());
            rat a = extract(A);
            rat b;
            to.write(A);
            while(!from.eof())
                    {
                    B = chomp(from.readln());
                    b = extract(B);
                    rat q = oplus(a,b);
                    to.write("\n",q.num,"/",q.den,"\n");
                    to.write(B);
                    a = b;
                    }
            from.close;
            to.close;
            cn++;
            }
     
    }
    string _cast ( int n){
    string s;
    if (n==0) return "0";
    int nb = cast (int) trunc(log(cast (real) n)/log(10));
    int [] num;
    while(nb>=0)
            {
            num ~= n / 10^^(nb);
            n -= num[$-1]*10^^(nb);
            nb--;
            }
    char [] c;
    foreach(i; num)
            {
            switch (i)
                    {
                    case 0 : c ~= '0';
                    break;
                    case 1 : c ~= '1';
                    break;
                    case 2 : c ~= '2';
                    break;
                    case 3 : c ~= '3';
                    break;
                    case 4 : c ~= '4';
                    break;
                    case 5 : c ~= '5';
                    break;
                    case 6 : c ~= '6';
                    break;
                    case 7 : c ~= '7';
                    break;
                    case 8 : c ~= '8';
                    break;
                    case 9 : c ~= '9';
                    break;
                    default : writeln("Bad symbol encountered : ", i,".");
                    break;
                    }
            }
    return cast (string) c;
    }
    int __cast(string s){
    char [] c = cast (char[]) s;
    int [] num;
    foreach(i; c)
            {
            switch (i)
                    {
                    case '0' : num ~= 0;
                    break;
                    case '1' : num ~= 1;
                    break;
                    case '2' : num ~= 2;
                    break;
                    case '3' : num ~= 3;
                    break;
                    case '4' : num ~= 4;
                    break;
                    case '5' : num ~= 5;
                    break;
                    case '6' : num ~= 6;
                    break;
                    case '7' : num ~= 7;
                    break;
                    case '8' : num ~= 8;
                    break;
                    case '9' : num ~= 9;
                    break;
                    default : writeln("Bad symbol encountered : ", i,".");
                    break;
                    }
            }
    num = num.reverse;
    int a = 0;
    for (int i = 0; i<num.length; i++)
            {
            a += num[i] * 10^^i;
            }
    return a;
    }
    rat extract(string s){
    s = chomp(s);
    auto r = regex("([0-9]+)/([0-9]+)$");
    auto m = match(s, r);
    return simple(rat(__cast( m.captures[1]),__cast( m.captures[2])));
    }
    rat oplus(rat q1, rat q2){
    q1 = simple(q1);
    q2 = simple(q2);
    return simple(rat(q1.num + q2.num, q1.den + q2.den));
    }
    int pgcd (int a, int b){
    int r = 1;
    if (a == 0 && b== 0) return 1;
    if (a == 0) return b;
    if (b == 0) return a;
    while(r != 0)
            {
            r = a % b;
            a = b;
            b = r;
            }
    return a;
    }
    rat simple(rat q){
    int g = pgcd(q.num, q.den);
    return rat(q.num/g , q.den / g);
    }

  2. #2
    Invité
    Invité(e)
    Par défaut
    Ben ici ça fonctionne sans bug, on dépasse 15 même si vers 21 on devient limité vite par le disque.

  3. #3
    Membre confirmé

    Profil pro
    Inscrit en
    Mars 2009
    Messages
    349
    Détails du profil
    Informations personnelles :
    Localisation : France, Gironde (Aquitaine)

    Informations forums :
    Inscription : Mars 2009
    Messages : 349
    Points : 590
    Points
    590
    Par défaut
    J'ai juste regardé en diagonale et je remarque que tu n'implémente pas les fonctionnalitées du D, comme:
    Pureté, par ex pgcd doit etre pure
    L'immutabilité (vimmutable ) ou au moins les const scope ( in )
    Le foreach en lecture seul: foreach( const ref i; arr )

    Ca va améliorer pas mal les perf

  4. #4
    Futur Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Juillet 2012
    Messages
    6
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juillet 2012
    Messages : 6
    Points : 8
    Points
    8
    Par défaut
    Bonjour et merci pour vos réponses.

    Il semble qu'aucune erreur de segmentation n'apparaisse si l'on compile le code avec DMD. Cependant avec LDC (sous F19) on obtient une erreur de segmentation.

    Pour les performances, je suis allé jusqu'à n=28 (DMD sous Win7) même s'il faut patienter un peu. Les changements suggérés par @bioinformatics ne sont pas négligeables dès que l'on dépasse n = 24.

    En utilisant GDB on obtient (après compilation avec LDC sous F19) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
     
    Program received signal SIGSEGV, Segmentation fault.
    0x00007ffff7a89742 in _aaInX (aa=<incomplete type>, 
        keyti=0x482e80 <TypeInfo_S3std8typecons18__T5TupleTAyaTAxaZ5Tuple.__init()>, pkey=0x7fffffffd610) at aaA.d:371
    371	            auto e = aa.a.b[i];
    (gdb) bt
    #0  0x00007ffff7a89742 in _aaInX (aa=<incomplete type>, 
        keyti=0x482e80 <TypeInfo_S3std8typecons18__T5TupleTAyaTAxaZ5Tuple.__init()>, pkey=0x7fffffffd610) at aaA.d:371
    #1  0x000000000044e44a in std.functional.__T7memoizeS83_D3std5regex18__T9regexImplTAyaZ9regexImplFNfAyaAxaZS3std5regex12__T5RegexTaZ5RegexVi8Z.memoize() (
        _param_0=..., _param_1=...) at /usr/include/d/std/functional.d:602
    #2  0x000000000042f5aa in std.regex.__T5regexTAyaZ.regex() (pattern=..., 
        flags=...) at /usr/include/d/std/regex.d:6461
    #3  0x000000000042451e in dev.extract() (s=...)
        at /home/jonathan/Documents/Recherche/Fermat/SBs/D/Dev/dev.d:134
    #4  0x00000000004238cb in dev.SB() (n=15)
        at /home/jonathan/Documents/Recherche/Fermat/SBs/D/Dev/dev.d:39
    #5  0x0000000000423547 in D main ()
        at /home/jonathan/Documents/Recherche/Fermat/SBs/D/Dev/dev.d:17
    #6  0x00007ffff7a82ab1 in rt.dmain2._d_run_main() (mainFunc=0x423500 <D main>)
        at dmain2.d:607
    #7  0x00007ffff7a82a3a in rt.dmain2._d_run_main() () at dmain2.d:582
    #8  0x00007ffff7a82b09 in rt.dmain2._d_run_main() () at dmain2.d:618
    #9  0x00007ffff7a82a3a in rt.dmain2._d_run_main() () at dmain2.d:582
    #10 0x00007ffff7a829ed in _d_run_main (argc=1, argv=0x7fffffffe148, 
        mainFunc=0x423500 <D main>) at dmain2.d:628
    #11 0x00007ffff7a825a2 in main (argc=1, argv=0x7fffffffe148) at dmain2.d:383
    #12 0x00007ffff6a64b45 in __libc_start_main (main=0x422cc0 <main@plt>, argc=1, 
    ---Type <return> to continue, or q <return> to quit---
        ubp_av=0x7fffffffe148, init=<optimized out>, fini=<optimized out>, 
        rtld_fini=<optimized out>, stack_end=0x7fffffffe138) at libc-start.c:274
    #13 0x0000000000423439 in _start ()

Discussions similaires

  1. Erreur de segmentation suite à un sprintf
    Par suyeon dans le forum Bibliothèque standard
    Réponses: 2
    Dernier message: 12/09/2009, 18h38
  2. Erreur de segmentation
    Par Trunks dans le forum C
    Réponses: 3
    Dernier message: 06/10/2005, 18h28
  3. Erreur de segmentation (Inconnue)
    Par Dark-Meteor dans le forum C
    Réponses: 5
    Dernier message: 08/09/2005, 13h42
  4. [Dev-C++] Erreur de segmentation...
    Par sas dans le forum Dev-C++
    Réponses: 11
    Dernier message: 26/03/2005, 14h25
  5. erreur de segmentation
    Par transistor49 dans le forum C++
    Réponses: 10
    Dernier message: 15/03/2005, 11h18

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo