�criture en C++ d'un algo d'interpolation

Version imprimable

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:

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 :aie:

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
:D

13/02/2012, 12h53
aslo92

Bonjour,

est ce que les temps sont tri�s et croissants dans tes deux matrices ?
13/02/2012, 14h03
membreComplexe12

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

Oui les temps sont bien class�s par ordre croisant ;)
13/02/2012, 14h50
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.

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

Code:

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� ?

ouahou super aslo !!! tu m'as bien aid� l� :)

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

merci beaucoup, �a � l'air vraiment pas mal comme cela :ccool:

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

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;

13/02/2012, 17h36
oodini

Citation:

Envoy� par 21did21

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.

d'accord, merci

pour commencer j'ai essay� de refaire le code ci dessus (un peu pr�s) mais en matlab et �a donne �a :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
for g=1:1:tailleTableau
		tempsResultats=Tableau{g,1};
        tempsDetecte=0; erreur=0; m=1;
		while ( tempsDetecte==0 && erreur==0 && m<length(tempsResultats(:,1)) )
            if ( m<length(tempsResultats(:,1)) ) %comme on a +1 ci dessous
               if ( tempsMinteresse(b,1) >= tempsResultats(m,1) && tempsMinteresse(b,1) < tempsResultats(m+1,1) )
                    if (tempsMinteresse(b,1)==tempsResultats(m,1))
                        fprintf(fidVTK,'%g\n',tempsResultats(m,2));
                    else %interpolation linéaire (dvlpt Taylor) Y=Ya+(X-Xa).(Yb-Ya)/(Xb-Xa)
                        fprintf( fidVTK,'%g\n',tempsResultats(m,2)+(tempsMinteresse(b,1)-tempsResultats(m,1))*((tempsResultats(m+1,2)-tempsResultats(m,2))/(tempsResultats(m+1,1)-tempsResultats(m,1))) );
                    end
                    tempsDetecte=1;
               end
            else %produit en croix pour dernière composante
                fprintf(fidVTK,'%g\n',(tempsMinteresse(b,1)*tempsResultats(m,2))/tempsResultats(m,1));
                tempsDetecte=1;
            end		
            m=m+1;
        end
	end

le soucis est qu'il semblerai que la variable tempsDetecte soit toujours nulle :(

voyez vous pk ?

13/02/2012, 18h09
cob59

Si tu as effectivement besoin de matrices (c'est � dire si les std::vector sont insuffisants), autant ne pas r�inventer la roue : http://eigen.tuxfamily.org/dox/GettingStarted.html.

En plus le code fourni en exemple a de grandes chances de provoquer des fuites m�moire si les donn�es allou�es L19 ne sont pas d�sallou�es.
13/02/2012, 18h21
membreComplexe12

Citation:

Envoy� par cob59

Si tu as effectivement besoin de matrices (c'est � dire si les std::vector sont insuffisants), autant ne pas r�inventer la roue : http://eigen.tuxfamily.org/dox/GettingStarted.html.

� merde alors, je connaissais pas ce truc : "eigen" c'est dans la librairie standard ? j'ai besoin d'installer qqch ou d'inclure un fichier .cpp dans mon projet ? (je suis d�butant et je ne comprends pas tous sur le lien que tu m'as envoy�)

si j'ai bien compris cet objet Eigen � toutes les propri�t�s des matrices d�j� pr�programm�e ?

Citation:

Envoy� par cob59

En plus le code fourni en exemple a de grandes chances de provoquer des fuites m�moire si les donn�es allou�es L19 ne sont pas d�sallou�es.

en fait le code que je viens de fournir est en matlab, du coup il n'y a pas besoin de d�salouer il le fait automatiquement :ccool:

Eigen n'est pas dans la STL, c'est une librairie "tierce" de calculs matriciels.
Quant � l'installation, je ne vois pas ce qu'il y a de compliqu� :

Citation:

How to "install" Eigen?

In order to use Eigen, you just need to download and extract Eigen's source code (see the wiki for download instructions). In fact, the header files in the Eigen subdirectory are the only files required to compile programs using Eigen. The header files are the same for all platforms. It is not necessary to use CMake or install anything.

Donc tu as juste � t�l�charger un zip, l'extraire, inclure certains de ces headers dans ton projet C++ et le tour est jou�. Pas de lib/dll � inclure, et rien � configurer. Tu cr�es un fichier main.cpp et tu colles �a dedans :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <iostream> #include <Eigen/Dense> using Eigen::MatrixXd; int main() { MatrixXd m(2,2); m(0,0) = 3; m(1,0) = 2.5; m(0,1) = -1; m(1,1) = m(1,0) + m(0,1); std::cout << m << std::endl; }
Tu compiles (en pr�cisant bien l'emplacement du r�pertoire parent de Eigen/ � ton compilo) puis tu testes.

Citation:

en fait le code que je viens de fournir est en matlab, du coup il n'y a pas besoin de d�salouer il le fait automatiquement

Je parlais du code de aslo92.

14/02/2012, 10h29
aslo92

J'ai en effet oubli� de lib�rer la m�moire de mes matrices avec un delete avant la fin du programme.

Le code fourni est une impl�mentation possible, mais ce n'est pas la seule. On peut en effet aussi utiliser STL et les vecteurs.

Concernant to code MATLAB

Je ne voit pas l'int�r�t de L5 vu que le m�me test se trouve en L4.
Si ta variable tempsDetecte reste � z�ro, c'est que le test en L6 est toujours faux. L'utilisation du debugger va te permettre de comprendre pourquoi.