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.