Discussion :

[membreComplexe12]

Salut tous,

désolé pour le titre pourrit mais je ne savais pas trop comment appeler ceci... :p

Voici le contexte de mon probleme :

j'ai un tableau (vector) dont voici les dimensions : tableau{30000,2}.
Dans ce tableau chaque case contient une matrice vector de dimension Nx2 (avec N compris entre 0 et 2000).

On a la première colonne de chaque matrice qui contient des "temps" et la deuxieme qui contient des résultats.

Voici ce que je veux faire :

j'ai une matrice qui s'appel tempsResultat qui contient dans sa première colonne aussi des temps et je voudrais écrire dans la deuxième colonne les résultats qui correspondent à ces temps (que je choppe dans la variable matrice que j'ai donné plus haut).

Le soucis est que les temps de tempsResultat ne sont pas les même que ceux qui se trouvent dans la variable matrice

du coup, le code que j'avais fait ne fonctionne pas (ici le code n'est pas en C++ car je fais des tests sous matlab avant de me lancer en C++) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
for g=1:1:tailleTableau
    %je stocke ma matrice qui a dans la case {g,1} ds variable
    %nommée tempsResultats
    tempsResultats=Tableau{g,1};
    %je copie les résultats qui correspondent aux temps qui m'intéressent  
    %dans le fichier texte             
    for m=1:1:length(tempsResultats(:,1))
        if (tempsResultats(m,1)==tempsMinteresse(b,1))
            fprintf(fidVTK,'%g\n',tempsResultats(m,2))
        end			
    end
end

Ce qu'il faut faire mais que je n'arrive pas :

1°) pourriez vous me dire comment faire en C++ s'il vous plait pour faire l'équivalent de ceci ?

2°) En fait ce que j'ai fais plus haut c'est chercher le temps qui m'interesse dans la matrice "tempsResultats" et copier le résutats correspondant dans le fichier texte.
Le probleme de ceci est que ça ne marche que si les temps qui m'interessent se trouvent aussi dans la matrice "tempsResultats" or ce n'est pas toujours le cas pour moi

du coup je ne vois pas trop comment faire de façon un peu prêt optimisée avec les outils standard
je dis de façon un peu pret optimisée car je manipule de très gros matrices/tableau et la seul solution que je vois moi c'est réecrire toutes les matrice en y insérant mes temps qui m'intéressent pui faire une interpolation linéaire et je pourrais ensuite utiliser ce code.

Le soucis de ceci c'est que je vais recopier toutes les matrices et à ça va demander un temps très important alors que je suis certain qu'il y a une autre méthode.
=> en fait je pense qu'il faudrait détecter qu'elles sont les valeurs qui encadrent le temps qui m'intéresse et faire direct l'interpolation sans à avoir à recopier toute la matrice...

pourriez vous m'aidez pour faire ceci s'il vous plait ?

merci d'avance

[aslo92]

Bonjour,

est ce que les temps sont triés et croissants dans tes deux matrices ?

[membreComplexe12]

merci aslo de prendre le temps de m'aider !!

Oui les temps sont bien classés par ordre croisant

[cob59]

Les matrices fourre-tout de MATLAB n'ont pas d'équivalent en C++. Il va falloir repenser ton code sur certains aspects : S'agit-il de matrices (avec ce que ça implique mathématiquement) ou seulement de tableaux d'éléments hétérogènes ?

La plupart du temps, l'une des dimensions de ta matrice est fixe, donc il suffit de créer un std::vector<T> où T est un objet composite (temps+résultat dans une struct, par exemple).

Il faudra aussi réfléchir au type de tes éléments scalaires : des "temps" typé en unsigned long int se compareraient entre eux plus facilement que des types double. Les "resultats" sont-ils entiers/réels ? De quelle taille ?

A partir de là, il sera possible d'agir sur les std::vector avec des boucles for (ou par l'utilisation conjointe de foncteurs et des algos de la STL), mais il existe des étapes préalables.

[aslo92]

Dis moi si je me trompe mais je vois les choses comme ça en C++:

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
// Contenu de matrice
typedef struct
{
    double temps;
    double res;        
} t_res_1;
 
// Contenu de tableau
typedef struct
{
    double    temps;
    t_res_1*  pres;
    int       tailleMatrice;
} t_res_2;
 
static int get_matrice(t_res_1** matrice, int* tailleMatrice)
{
    *tailleMatrice = 2000;
    *matrice       = new t_res_1 [*tailleMatrice];
 
    // Pas assez de mémoire si NULL, retourne une erreur
    if (NULL == *matrice)
       return 0;
 
    // Remplissage de la matrice
    for (int i=0; i<*tailleMatrice; i++)
    {
        // Mettre un temps valide ici
        (*matrice)[i].temps = i; 
 
        // Mettre un résultat valide ici
        (*matrice)[i].res = 0; 
    }
 
    // Succès 
    return 1;
}
 
int main(int argc, char *argv[])
{
    double tempsMinteresse = 10;
 
    // Définition du tableau
    int       tailleTableau = 30000;
    t_res_2   tableau[tailleTableau];
 
    // Remplissage du tableau
    for (int i=0; i<tailleTableau; i++)
    {
        // Ici mettre un temps valide
        tableau[i].temps = i;
 
        // Création de la matrice
        int      tailleMatrice = 0;
        t_res_1* matrice = NULL;
 
        if (get_matrice(&matrice, &tailleMatrice) != 0)
        {
            tableau[i].pres = matrice;
            tableau[i].tailleMatrice = tailleMatrice;
        }
    }
 
    // Recherche des temps
    for (int i=0; i<tailleTableau; i++)
    {
        t_res_2* ptableau = &tableau[i];
 
        // Recherche des temps dans matrice
        for (int j=0; j<ptableau->tailleMatrice - 1; j++)
        {
            if ((tempsMinteresse >= ptableau->pres[j].temps) && (tempsMinteresse <= ptableau->pres[j+1].temps))
            {
               if (ptableau->pres[j].temps == tempsMinteresse)
               {
                   // fprintf(fidVTK,'%g\n',ptableau->pres[j].res)
               }
               else
               {
                   // Ici tester le résultat le plus proche
                   // fprintf(fidVTK,'%g\n',ptableau->pres[j].res)
                   // ou   
                   // fprintf(fidVTK,'%g\n',ptableau->pres[j+1].res)
               } 
            } 
        }
    }
 
    system("PAUSE");
    return EXIT_SUCCESS;
}

Je remplace tes cellules MATLAB par des structures.
La structure tableau contient un champ temps, un champ matrice (pointeur sur la matrice) et un champ qui contient la taille de la matrice.

La matrice est aussi une structure avec un champ temps et un champ résultat.

Le code est à adapter selon ton besoin.
Tu peux optimiser la recherche du temps qui t'intéresse en utilisant la dichotomie ce qui aura pour effet de minimiser la boucle j.

Il manque peut-être quelques tests mais le principe est là.
J'espère t'avoir aidé ?

[membreComplexe12]

ouahou super aslo !!! tu m'as bien aidé là

je vois le principe, par contre il faut que je me replonge dans le cpp
(dans le if je pense qu'il faut mettre un <= et un strictement > pour ne pas avoir un probleme )

merci beaucoup, ça à l'air vraiment pas mal comme cela

par contre j'ai un peu de mal avec ce passage (surtout la double etoile et l'histoire de memoire ):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
static int get_matrice(t_res_1** matrice, int* tailleMatrice)
{
    *tailleMatrice = 2000;
    *matrice       = new t_res_1 [*tailleMatrice];
 
    // Pas assez de mémoire si NULL, retourne une erreur
    if (NULL == *matrice)
       return 0;

[oodini]

par contre j'ai un peu de mal avec ce passage (surtout la double etoile et l'histoire de memoire ):

Va falloir te pencher sur les pointeurs (et les pointeurs de pointeurs).
Les arguments de la méthode sont en fait des valeurs de retour, d'où l'utilisation de pointeurs.