Salut à tous !

Alors voilà j'aimerais créer un tableau de vecteurs. Je travaille sur linux. Evidemment quand je compile le terminal m'affiche "double can not convert to vecteur.
Je l'ai déclaré de cette façon dans mon porgramme :
double tab [4];
tab [0] = y01; // y01 est un vecteur à 4 dimensions
etc...

J'ai cherché regardé sur le net mais je n'arrive pas à le programmer ou alors je ne comprends la manière dont cela est expliqué...

Merci d'avance de votre aide ;)

y01 est un vecteur je suppose ? Tu as déjà créé ton type Vecteur ?

Si tu veux faire un vecteur dans un tableau :
double vecteur[4]; vecteur[0] = 0; vecteur[1] = 0; vecteur[2] = 0; vecteur[3] = 0;

Je te conseil plutôt de faire une structure ou une classe Vecteur et ensuite de faire un tableau de vecteurs (si besoin) :
Vecteur tab[4]; // 4 vecteurs tab[0] = new Vecteur (0,1,1,1);

tout simplement :

int n = 10;
std::vector<double> vectors[n]

Le 22 mai 2016 à 16:57:50 VaultDeveloper a écrit :
y01 est un vecteur je suppose ? Tu as déjà créé ton type Vecteur ?

Si tu veux faire un vecteur dans un tableau :
double vecteur[4]; vecteur[0] = 0; vecteur[1] = 0; vecteur[2] = 0; vecteur[3] = 0;

Je te conseil plutôt de faire une structure ou une classe Vecteur et ensuite de faire un tableau de vecteurs (si besoin) :
Vecteur tab[4]; // 4 vecteurs tab[0] = new Vecteur (0,1,1,1);

new c'est seulement pour des pointeurs....

J'ai déjà déclaré le fichier vecteur.h ou ya la classe vecteur qui est définie dedans. Mon problème vient juste du fait que je ne sais pas comment le déclarer dans un programme
Comme je programme avec gedit et que j'ai suivi des cours de c++ comment je pourrais transformer ce que tu m'as dit DontColleMyNem ?

Je te suis pas trop, quand tu parles de vecteur c'est la classe Vector<T> de std ? Ou une classe que tu as faite toi même ?

Dans tous les cas c'est la même logique :

Type nom[longueur];

Dans ton premier post tu mets double à la place de type or c'est le Vecteur qui contient les réels et comme tu souhaites obtenir un tableau de Vecteurs, tu dois mettre le nom de la classe à la place de type.
Si tu veux les déclarer dynamiquement tu mets * entre type et nom.

Si ce n'est pas ce que tu souhaites il faudra que tu reformules ton problème.

Désolé de mettre mal exprimé...
J'utilise une classe vecteur (rien à voir avec celle de Vector<T> je crois). Je veux utiliser dans une boucle for plusieurs vecteurs. Je voudrais les mettre dans un tableau et dans ma boucle faire par exemple :

Vecteur tab [4];
tab [0] = y01; // y01 est un vecteur à 4 dimensions
etc...
for (int i=0; i<=N; i++)
{
a = tab[i] * tab[i];
}
Mais je n'arrive pas à bien déclarer mon tableau de vecteurs...
Je sais pas si j'ai été clair ?

Je veux utiliser dans une boucle for plusieurs vecteurs. Je voudrais les mettre dans un tableau et dans ma boucle faire par exemple :

<code>Vecteur tab [4];

tab[0] = y01; // y01 est un vecteur à 4 dimensions

for (int i=0; i<=N; i++)

{
    a = tab[i] * tab[i];
}</code>

quelle est l'erreur dans cette partie du code ?

car il est différent de ton code départ, dans ton code de départ tu déclarais un double tab[4]
on sait pas comment tu as déclaré "a"
pareil pour y01 etc

l'erreur qui peut survenir ici est qu'il manque la surchage de l'operateur multiplication
car tab[i] ici est un Vecteur

et tu veux faire tab[i] * tab[i] donc, tu veux faire une multiplication de 2 vecteur, pour cela il faut surcharger operator*

si tu as une erreur, le mieux est de poster tout ton code sur pastebin, la définition et la declaration de ta classe vecteur etc, et le code que tu voudrais mais qui ne fonctionne pas

Je poste mon code c'est mon fichier EDO.cpp :

1. include "EDO.h"
2. include <fstream>
3. include <iomanip>
4. include <iostream>

using namespace std;

1. include "TGraph.h"
2. include "TFile.h"
3. include "TString.h"

Vecteur EDO1Systeme::rk2(double x0, Vecteur y0, double xf)
{
Vecteur y;//vecteur
int D=4;
double x; //temps
y = y0; //position initiale

double h = (xf - x0)/N; //h le pas, en temps. t0=0 ; tf=31 558 144 secondes ; N=30 000
Vecteur k1(D), k2(D); //vecteurs
for (int i = 1 ; i < N+1 ; i++)
{
x = x0 + i*h;
k1 = h * evalyp(x, y);
k2 = h * evalyp(x + h/2, y + k1/2);
y = y + k2;//vecteur P
stocke (i, x, y, evalyp(x, y));
cout<<"y= "<<y<<endl;
}
return y;
}

EDO1Systeme::EDO1Systeme(int Di, int Ni) : D(Di),N(Ni)
{
yf.redim(D); // On alloue les tableaux servant a stocker x, y, y', z, z' pour chaque point.
xtab=new double [N+1]; // [0..N] => N+1
ytab=new Vecteur [N+1];
yptab=new Vecteur [N+1];
for (int i=0;i<N+1;i++) {
ytab[i].redim(D);
yptab[i].redim(D);
}
}

EDO1Systeme::~EDO1Systeme()
{
delete[] xtab;
delete[] ytab;
delete[] yptab;
}

void EDO1Systeme::stocke(int i,double x, Vecteur y, Vecteur yp)
{
xtab[i]=x;
ytab[i]=y;
yptab[i]=yp;
}

void EDO1Systeme::ecrirexyz(const char * nom_fichier)
{
ofstream fichier( nom_fichier );
// On ecrit tout en 7colonnes dans un fichier
for (int i= 0 ; i < N+1 ; i++)
{
fichier << setw(10) <<"t= "<< setprecision(12) << xtab[i]

<< setw(10) << "Px = "<< setprecision(12) << ytab[i](1)
<< setw(10) << "Py = "<< setprecision(12) << ytab[i](3)

<< setw(10) << "Vx = "<< setprecision(12) << yptab[i](1)
<< setw(10) << "Vy = "<< setprecision(12) << yptab[i](3)

<< setw(10) << "Ax = "<< setprecision(12) << yptab[i](2)
<< setw(10) << "Ay = "<< setprecision(12) << yptab[i](4)<<endl;
}
fichier << endl;
fichier.close();
}

void EDO1Systeme::ecrirexyzROOT(const char * nom_fichier,int G)
{

TFile fichier( nom_fichier , "RECREATE" );

TGraph* gr=new TGraph [D];
int d=0;
TString s("Ellipse pour un seul corps"); TString name("Planete");
gr[d].Set(N+1); // mets le nombre de points dans les graphes
s+=(d+1);name+=(d+1);
gr[d].SetNameTitle(name,s);
for (int i = 0 ; i < N+1 ; i++)
{
gr[d].SetPoint(i+1,ytab[i](1),ytab[i](3));
}
gr[d].Write();

delete [] gr;
fichier.Close();
}

double EDO2::evalys(double x, Vecteur y)
{
//Terre:
double A[4]={149600000000.0,0.0, 0.0, 29000.0}; // on a xterre (au périhélie), vxterre, yterre, vyterre (donc la vitesse max, car au périhélie). Idem pour toutes les planètes.
Vecteur y0(4, A);
double x0=0.0;
double xf=31558144.0; //période de révolution. Idem pour toutes les planètes

//Mercure:
double B[4]={46001272000.0,0.0, 0.0, 58980.0}; // x, vx, y, vy
Vecteur y10(4, B);
double x10=0.0;
double xf1=7603200.0;

//Venus:
double C[4]={107476259000.0,0.0, 0.0, 35260.0}; // x, vx, y, vy
Vecteur y20(4, C);
double x20=0.0;
double xf2=19440000.0;

//Mars
double D[4]={206644545000.0,0.0, 0.0, 26499.0}; // x, vx, y, vy
Vecteur y30(4, D);
double x30=0.0;
double xf3=59356800.0;

//Jupiter
double E[4]={740520000000.0, 0.0, 0.0,13720.0}; // x, vx, y, vy
Vecteur y40(4, E);
double x40=0.0;
double xf4=374574629.0;

//Saturne
double F[4]={1349467375000.0, 0.0, 0.0,10183.0}; //x, vx, y, vy
Vecteur y50(4, F);
double x50=0.0;
double xf5=9294684337.0;

//Uranus
double GA[4]={2734998229000.0 , 0.0, 0.0, 7128.0 }; // x, vx, y, vy
Vecteur y60(4, GA);
double x60=0.0;
double xf6=2651369760.0;

//Neptune
double H[4]={4452940833000.0,0.0, 0.0,5479.0}; // x, vx, y, vy
Vecteur y70(4, H);
double x70=0.0;
double xf7=5203431671.0;

double G =-6.67*pow(10,-11);
double MS = 1.989*pow(10,30);

double a [8];
a[0]=y0(1);
a[1]=y10(1); // coordonnees x de toutes les planetes
a[2]=y20(1);
a[3]=y30(1);
a[4]=y40(1);
a[5]=y50(1);
a[6]=y60(1);
a[7]=y70(1);

double m[8];
m[0]= 5.972e+24; //masse terre
m[1]= 3.285e+23; //masse mercure
m[2]= 4.86732e+24; //masse venus
m[3]= 6.41693e+23; //masse mars
m[4]= 5.972e+24; //masse terre
m[5]= 3.285e+23; //masse mercure
m[6]= 4.86732e+24; //masse venus
m[7]= 6.41693e+23; //masse mars

double acc;

for (int i=0; i<8;i++)
{
double b;
b=(G*MS*a[i])/(pow(a[i],3));
double norme=0;
for (int j=0; j<8; j++) //2 boucles pour la formule de l'accélération
{
do { norme+=(G*m[j]*(a[i]-a[j])) / pow (sqrt(a[i]*a[i]+a[j]*a[j]), 3);
// do while pour ne pas compter la masse de la planète etudiée
acc=b+norme;
cout<<" acceleration= "<<acc<<endl;
}while (j==i);
}
}
return acc;
}

double EDO2::evalyss(double x, Vecteur y)
{
double a [8];
a[0]=y0(3);
a[1]=y10(3);
a[2]=y20(3);
a[3]=y30(3);
a[4]=y40(3); // coordonnees y pour toutes les planetes
a[5]=y50(3);
a[6]=y60(3);
a[7]=y70(3);

double acc;

for (int i=0; i<8;i++)
{
double b;
b=(G*MS*a[i])/(pow(a[i],3));
double norme=0;
for (int j=0; j<8;j++)
{
do{ norme+=(G*m[j]*(a[i]-a[j])) / pow (sqrt(a[i]*a[i]+a[j]*a[j]), 3);
acc=b+norme;
cout<<" acceleration= "<<acc<<endl;
}while (j==i);
}
}
return acc;
}

Ensuite ya mon fichier EDO.h :

class EDO1Systeme
{
protected:
int D,N;
Vecteur yf; // Valeurs de y(xf) stockees ici par rk4()
double *xtab;
Vecteur *ytab, *yptab;
void stocke(int i,double x, Vecteur y, Vecteur yp);

public:
EDO1Systeme(int Di, int Ni); // <--- Constructeur complet, avec allocation des tableaux, defini dans le .cpp
~EDO1Systeme(); // Destructeur

// La methode evalyp(x, y) qui donne y' (et definit donc le probleme)
// est ici virtuelle pure, on fera deriver une classe de EDO1Systeme
// pour chaque probleme a resoudre

virtual Vecteur evalyp(double x, Vecteur y)=0;
Vecteur rk2(double x0, Vecteur y0, double xf);
double getyf(int i) { return yf(i); }
void ecrirexyz(const char * nom_fichier);
void ecrirexyzROOT(const char * nom_fichier, int G);
};

class EDO2 : public EDO1Systeme {
private:
public:

EDO2(int Ni) : EDO1Systeme(4,Ni) {}
// evalyp est redefinie pour obtenir le systeme d'ordre 1
// equivalent a l'equation d'ordre 2...
Vecteur evalyp(double x, Vecteur y)
{
Vecteur v(4);
v(1)=y(2);
v(2)=evalys(x, y);
v(3)=y(4);
v(4)=evalyss(x, y);
return v;
}
// ...definie par evalys() qui donne y'' = f(x, y').

double evalys(double x, Vecteur y);
double evalyss(double x, Vecteur y);

// On "renomme" aussi la methode "get" qui permet de recuperer
// y'(xf) = z(xf). getyf() est definie dans EDO2
double getypf() { return getyf(2); }
};

Je poste maintenant (c'est le dernier !!) mon main.cpp :

1. include <iostream>
2. include <iomanip>
3. include <cmath>
4. include <vector>

1. include "EDOtest.h"
2. include "Vecteur.h"
3. include "TGraph.h"
4. include "TFile.h"
5. include "TCanvas.h"
6. include "TLegend.h"
7. include "TAxis.h"
8. include "TApplication.h"
9. include <TROOT.h>

using namespace std;

int main ()
{

TFile *fichier_root=TFile::Open("Système.root","RECREATE");

//Terre:
double A[4]={149600000000.0,0.0, 0.0, 29000.0};// on a xterre (au périhélie), vxterre, yterre, vyterre (donc la vitesse max, car au périhélie). Idem pour toutes les planètes.
Vecteur y0(4, A);
double x0=0.0;
double xf=31558144.0;//période de révolution. Idem pour toutes les planètes

//Mercure:
double B[4]={46001272000.0,0.0, 0.0, 58980.0};// x, vx, y, vy
Vecteur y10(4, B);
double x10=0.0;
double xf1=7603200.0;

//Venus:
double C[4]={107476259000.0,0.0, 0.0, 35260.0};// x, vx, y, vy
Vecteur y20(4, C);
double x20=0.0;
double xf2=19440000.0;

//Mars
double D[4]={206644545000.0,0.0, 0.0, 26499.0};// x, vx, y, vy
Vecteur y30(4, D);
double x30=0.0;
double xf3=59356800.0;

//Jupiter
double E[4]={740520000000.0, 0.0, 0.0,13720.0};// x, vx, y, vy
Vecteur y40(4, E);
double x40=0.0;
double xf4=374574629.0;

//Saturne
double F[4]={1349467375000.0, 0.0, 0.0,10183.0};// x, vx, y, vy
Vecteur y50(4, F);
double x50=0.0;
double xf5=9294684337.0;

//Uranus
double GA[4]={2734998229000.0 , 0.0, 0.0, 7128.0 };// x, vx, y, vy
Vecteur y60(4, GA);
double x60=0.0;
double xf6=2651369760.0;

//Neptune
double H[4]={4452940833000.0,0.0, 0.0,5479.0};// x, vx, y, vy
Vecteur y70(4, H);
double x70=0.0;
double xf7=5203431671.0;

int m = 1;//noir

EDO2 Terre(1000);//nombre de points //calcul position avec rk2 pour Terre
Terre.rk2(x0, y0 , xf);
Terre.ecrirexyz("Terre.dat");
Terre.ecrirexyzROOT("Terre.root",m);

m++;//rouge

EDO2 Mercure(1000); //calcul position avec rk2 pour Mercure
Mercure.rk2(x10, y10 , xf1);
Mercure.ecrirexyz("Mercure.dat");
Mercure.ecrirexyzROOT("Mercure.root",m);

m++;//vert

EDO2 Venus(1000); //calcul position avec rk2 pour Venus
Venus.rk2(x20, y20 , xf2);
Venus.ecrirexyz("Venus.dat");
Venus.ecrirexyzROOT("Venus.root",m);

m++;//bleu

EDO2 Mars(1000); //calcul position avec rk2 pour Mars
Mars.rk2(x30, y30 , xf3);
Mars.ecrirexyz("Mars.dat");
Mars.ecrirexyzROOT("Mars.root",m);

m++;//jaune

EDO2 Jupiter(1000); //calcul position avec rk2 pour Jupiter
Jupiter.rk2(x40, y40, xf4);
Jupiter.ecrirexyz("Jupiter.dat");
Jupiter.ecrirexyzROOT("Jupiter.root",m);

m++;//violet

EDO2 Saturne(1000); //calcul position avec rk2 pour Saturne
Saturne.rk2(x50, y50 , xf5);
Saturne.ecrirexyz("Saturne.dat");
Saturne.ecrirexyzROOT("Saturne.root",m);

m++;//bleu clair

EDO2 Uranus(1000); //calcul position avec rk2 pour Uranus
Uranus.rk2(x60, y60 , xf6);
Uranus.ecrirexyz("Uranus.dat");
Uranus.ecrirexyzROOT("Uranus.root", m);

m=36;//gris

EDO2 Neptune(1000); //calcul position avec rk2 pour Neptune
Neptune.rk2(x70, y70 , xf7);
Neptune.ecrirexyz("Neptune.dat");
Neptune.ecrirexyzROOT("Neptune.root",m);

fichier_root->Close();

return 0;
}

Merci d'avance à ceux qui prendront le temps de le lire, ce serait cool