Erreur de segmentation lors du tri du vecteur basé sur l'ordre induit par une matrice

Question

J'ai écrit du code qui ressemble à ce qui suit. Je reçois une erreur de segmentation. Le débogueur montre que l'erreur vient de 'some_order'. J'ai vérifié les valeurs de la variable pour un exemple particulier. Prenez n = 26 : alors, Var = {0,...,25} ce qui signifie que u et v passés à 'some_order' doivent être dans la plage (0-25) mais j'obtiens une valeur élevée pour l'un d'eux comme 7785654 ou -1549259 (quelque chose comme ça). Je ne comprends pas pourquoi. L'erreur de segmentation est alors inévitable.

//TNT: template numeric toolkit
#include "tnt.h"  
//contient les inclusions à tous les fichiers dans http://math.nist.gov/tnt/tnt_doxygen/files.html
//toutes les autres inclusions nécessaires à la STL et à la bibliothèque standard de C++ sont là     

class global_data{
public:
  static TNT::Matrix* Value_matrix;

};
TNT::Matrix* global_data::Value_matrix = NULL;

bool some_order(const int& u ,const int& v) {
      return (*global_Data::Value_matrix)[v][u] == 0.0;
}

void some_function(int n){
    std::vector Var(n);
    for(int i=0; i(n,n,0.0) ;
    //global_data::Value_matrix est ensuite rempli de valeurs
    some_function(n); 
    delete[] global_data::Value_matrix
}

Answer 1

Ce type d'erreur est presque toujours dû à la fonction de tri ne répondant pas aux exigences d'un ordre strictement faible, tel que requis par la norme. Êtes-vous sûr que 1) some_order(a, b) && some_order(b, c) implique some_order(a, c), et que 2) some_order( a, b ) implique !some_order(b, a)? (À première vue, cela ne me semble pas correct, mais je ne comprends pas vraiment ce que cela fait.)

Answer 2

std::sort suppose que la fonction de comparaison modélise un Ordre Strict Faible

• irréflexif: some_order(u, u) renvoie false
• anti-symétrique: some_order(u, v) implique !some_order(v, u) (les deux pourraient être faux, auquel cas u et v sont équivalents)
• transitif: some_order(u, v) == true et some_order(v, w) == true implique some_order(u, w) == true

Cela dépendrait du contenu de votre matrice global_Data si votre some_order() peut être utilisé avec std::sort

- irréflexif: la diagonale ne peut pas avoir 0.0 dessus
- anti-symétrique: si une entrée a 0.0 alors l'élément de transposition n'a pas de 0.0
- transitif: si `global_Data[u, v]` et `global_Data[v, w]` ont 0.0 alors `global_Data[u, w]` a aussi cela.

A priori, cela semble être une restriction très forte, vous voudrez peut-être vérifier.