Discussion :

[hinaneee]

En fait, je cherche un faire un programme en C++ pour calculer

pour allant de 0 à M, et allant de 0 à N.
En sachant que pour tout i, et pour tout n.
( est une constante), et f est définie dans mon premier post.
Là je suis perdue, est-ce que je construit un vecteur ? ou bien je déclare une fonction f et je change à chaque fois l'attribut? Proposez moi une bonne idée s'il vous plaît.
Je vous remercie par avance.

[Ehonn]

Bonjour
Fais voir un peu le code que tu as pour l'instant ? En mettant l'énoncé dans le code source au fur et à mesure.

[ternel]

D'après toi, quels seraient les avantages de créer une fonction? Et de construire un vecteur?

En répondant à ces questions, nous pourrons t'aider à comprendre comment choisir

[hinaneee]

En fait, si je choisi un vecteur au lieu d'une fonction, je n'aurai pas à faire de boucle for sur le i, après pour calculer; j'airais uniquement une boucle sur n.
Je une syntaxe qui permette de construire un vecteur à partir de cette fonction.
Je vous remercie par avance pour votre aide.

[ternel]

Quel est ton code?

[hinaneee]

Voici ce que j'ai écris pour le moment
fichier.h

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
 
#include<iostream>
using namespace std;
class vecteur
{
 private:
  int N;//taille
  double *v;//pointer les composantes
 public:
 vecteur():v(NULL),N(0){};//Déclaration et définition du constructeur par défaut
  vecteur(int Nb=0, double val=0);//déclaration d'un constructeur avec argument
  vecteur(vecteur const& v);//déclaration d'un constructeur de copie
  ~vecteur();//déstructeur
  double& operator[](int rang);//Déclaration de l'opérateur[]
  vecteur& operator=(const vecteur&);//Déclaration de l'opérateur =
  vecteur operator * (double scalar); //Déclaration de l'opérateur *
  vecteur operator + (const vecteur&);//Déclaration de l'opérateur +
  void affiche();
  double krw(double s);
  double kro(double s);
  double f(double s); 
  vecteur decg(const vecteur&);   
};

fichier.cpp

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
#include <iostream>
#include "exemple6.h"
#include <cmath>
#include <fstream>
using namespace std;
//Définition du constructeur de copie
vecteur::vecteur(const vecteur& ref): N(ref.N)
{
  v = new double[N];
  for(unsigned int i=0; i<N;i++)
    v[i]=ref.v[i];
}
 
//Définition du constructeur avec argument
vecteur::vecteur(int Nb, double val)
{
   N = Nb;
   if (Nb == 0)
      v = NULL; 
   else
   {
      v = new double[N];
      for (unsigned i=0; i<N; i++)
         v[i] = val;
   }
}
 
//Définition du destructeur
vecteur::~vecteur()
{}
 
//Définition de []
double& vecteur::operator[](int rang)
{
  return v[rang]; 
}
 
//Définition de =
 
vecteur &vecteur::operator=(const vecteur &a)
{
  for(int i=0;i<N;i++)
    {
      v[i]=a.v[i];
    }
return *this;
}
 
 
//Définition de +
vecteur vecteur:: operator + (const vecteur &a)
{
vecteur d(N);
for (int i=0;i<N;i++)
d.v[i]=v[i]+a.v[i];
return d;
}
 
//Définition de *
vecteur vecteur:: operator*(double  d)
{
for(int i=0;i<N;i++)
v[i]=d*v[i];
return *this;
}
 
//Déclaration de la fonction affiche
void vecteur::affiche()
{
//cout<<"les coordonnées du vecteurs v sont"<<endl;
for(int i=0;i<N;i++)
{
cout<<v[i]<<endl;
}
cout<< "---fin---"<<endl;
}
 
 
//Définition de la fonction décalée à gauche
vecteur vecteur:: decg(const vecteur &C)
{
v[0]=C.v[N-1];
for(int i=1;i<N;i++)
v[i]=C.v[i-1];
return *this;
}
 
 
//Définition de la fonction krw
double krw(double s)
{
return pow(s,2);
}
 
//Définition de la fonction kro
double kro(double s)
{
return pow((1-s),2);
}
 
//Définition de la fonction fw
 
double f (double s, double u, double v)
{
return (krw(s)/u)/((krw(s)/u)+ (kro(s)/v));
}
 
 
main()
{
int N=2;
int M=2;
vecteur S(N);
S[0]=1;
vecteur San(N);
San[0]=1;
double uw=1;
double uo=1;
 
for (int n=0; n < M; n++)
{
for (int i=1; i<N; i++)
S[i]= San[i] - (f(San[i],1,1) - f(San[i-1],1,1));
San=S;
}

mais en fait ca ne marche pas parce qu'il faut écrire S[n][i] pour que ca fonctionne, mais S estr un vecteur donc cette écriture n'est pas correcte. Le mieux est de se débarasser de l'itération sur i, et ca peut se faire si on construit un vecteur à partir de la fonction f, mais je ne vois pas comment l'implémenter.
Je vous remercie par avance.

[ternel]

Supprime immédiatement ce "using namespace" de ton en-tête.
C'est une grosse erreur, qui peut empecher le code l'utilisant de compiler.

Et si tu essayais, pour commencer, avec

Code :

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

1
2
3
4
5
6
7
8
namespace math {
class vector {
private:
std::vector<double> data;
 
...
};
}//math::

Si tu n'y arrives pas, c'est que S n'est pas la bonne chose, il est mal défini.
Fais attention que certaines fonctions doivent pouvoir s'appliquer sur des objets constants, et donc être marquées const.

Par exemple, tes fonctions +, * etc.
L'écriture canonique, en restant dans ta manière de faire le vecteur serait:

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
#include <algorithm>
 
template <size_t N, typename Value>
class vecteur {
public:
   typedef Value value_type;
   typedef size_t size_type;
 
   size_type size() const {return N;}
 
private:
   value_type *v;//pointer les composantes
public:
   vecteur(): v(new value_type(N)) {if(!v) throw std::runtime_exception("bad alloc");}
   ~vecteur() {delete v;}
 
   vecteur(vecteur const& other) : v(new value_type(N)) {
      if(!v) throw std::runtime_exception("bad alloc");
      for (size_type i = 0; i<N; ++i) {
         v[i]=other.v[i];
      }
   }
 
   vecteur& operator=(vecteur other) { // passed by value
      copy.swap(*this); // nothrow swap
      return *this; // old resources now in copy, released in its dtor
   }
 
   void swap(vecteur& other) throw() {
      using std::swap; // enable ADL, defaulting to std::swap
      swap(v, other.v);
   }
 
   vecteur& operator <<=(size_type shift) {
      std::rotate(v, v+(shift%N), v+N);
      return *this;
   }
 
   vecteur& operator >>=(size_type shift) {return operator<<=(N-shift);}
 
    std::rotate(v.rbegin(), v.rbegin() + 1, v.rend());
   double& operator[] (int rang)       {return v[rang];}
   double  operator[] (int rang) const {return v[rang];}
 
   vecteur& operator *= (double scalar) {
      for (size_type i = 0; i<N; ++i) v[i]*=scalar;
      return *this;
   }
 
   vecteur& operator /= (double scalar) {
      for (size_type i = 0; i<N; ++i) v[i]/=scalar;
      return *this;
   }
 
   vecteur& operator += (vecteur const& other) {
      for (size_type i = 0; i<N; ++i) v[i]+=other.v[i];
      return *this;
   }
   vecteur& operator -= (vecteur const& other){
      for (size_type i = 0; i<N; ++i) v[i]-=other.v[i];
      return *this;
   }
 
   vecteur operator-() const {return vecteur(*this)*=-1;}
 
   friend inline std::ostream& operator<<(std::ostream& stream, vecteur const& v) {
      for(size_type i=0; i<N; ++i) stream<<v[i]<<' ';
      return stream;
   }
};
template <size_t N, typename Value>
inline vecteur<N, Value> operator * (vecteur<N, Value> const& v, double scalar) {return vecteur<N, Value>(v)*=scalar;}
 
template <size_t N, typename Value>
inline vecteur<N, Value> operator * (double scalar, vecteur<N, Value> const& v) {return vecteur<N, Value>(v)*=scalar;}
 
template <size_t N, typename Value>
inline vecteur<N, Value> operator / (vecteur<N, Value> const& v, double scalar) {return vecteur<N, Value>(v)/=scalar;}
 
template <size_t N, typename Value>
inline vecteur<N, Value> operator + (vecteur<N, Value> const& a, vecteur<N, Value> const& b) {return vecteur<N, Value>(a)+=b;}
 
template <size_t N, typename Value>
inline vecteur<N, Value> operator - (vecteur<N, Value> const& a, vecteur<N, Value> const& b) {return vecteur<N, Value>(a)-=b;}
 
template <size_t N, typename Value>
inline vecteur<N, Value> operator <<(vecteur<N, Value> const& v, size_t n) {return vecteur<N, Value>(v)<<=n;}
 
template <size_t N, typename Value>
inline vecteur<N, Value> operator >>(vecteur<N, Value> const& v, size_t n) {return vecteur<N, Value>(v)>>=n;}

tu remarqueras que j'ai introduit des paramêtres template.
ainsi, un vecteur<3> n'est pas un vecteur<4>;
Comme conteneur de données, il y a en C++ std::array<Type, taille> qui te conviendrait parfaitement (à la place du pointeur), ou à défaut, std::vector<Type>.

Tu remarqueras:

• L'usage des références constantes
• L'utilisation des opérateurs externes: les opérateurs non affectants sont définis par les opérateurs affectants.
• Le fait qu'on peut ainsi écrire 2*vecteur
• Le delete dans le constructeur (pour éviter les fuites mémoires)
• Le throw dans les constructeurs (pour éviter les corruptions mémoires)
• L'utilisation du Copy&Swap
• L'absence (grave?) de protection dans l'opérateur [].

Quant à la partie calcul, tu veux probablement écrire ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
double krw(double s) {return s*s;}
double kro(double s) {return (1-s)*(1-s);}
 
double f (double s, double u, double v) {
   return ( krw(s)/u ) / ( (krw(s)/u) + (kro(s)/v) );
}
 
double f (double (*krw)(double), double (*kro)(double), double s, double u, double v) {
   return ( (*krw)(s)/u ) / ( ((*krw)(s)/u) + ((*kro)(s)/v) );
}

la seconde version de f utilise des pointeurs sur les fonctions krw et kro pour pouvoir les changer.

[hinaneee]

Mais s'il te plaît, après ca comment tu appelle la fonction f pour calculer S^{n+1}_i pour n allant de 0 à M-1 et i allant de 0 à N-1? Expliques moi ce point s'il te plaît.
Merci par avance pour ton aide.

[ternel]

Aucune idée.
Et toi, comment le ferais tu sans ordinateur, mais juste du papier et un crayon?

Quelle est la situation initiale.
Vois-tu la récurrence mathématique?

Une telle définition du résultat par récurrence, peut se coder comme une boucle sur "l'axe de récurrence".
Du moins, quand on n'a pas besoin de conserver les valeurs intérmédiaires quand on les valeurs finales.

[hinaneee]

En fait, voici le code que je viens de faire: j'ai défini une fonction fw de type double, pus j'ai créer un vecteur F de type vecteur (la classe vecteur), en utilisant la fonction fw. Mais en testant ca ne me donne que des zéros, je ne comprend pas pourquoi.
Voici mon code:
fichier.h

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
 
#include<iostream>
class vecteur
{
 private:
  int N;//taille
  double *v;//pointer les composantes
 public:
 vecteur():v(NULL),N(0){};//Déclaration et définition du constructeur par défaut
  vecteur(int Nb=0, double val=0);//déclaration d'un constructeur avec argument
  vecteur(vecteur const& v);//déclaration d'un constructeur de copie
  ~vecteur();//déstructeur
  double& operator[](int rang);//Déclaration de l'opérateur[]
  vecteur& operator=(const vecteur&);//Déclaration de l'opérateur =
  vecteur operator * (double scalar); //Déclaration de l'opérateur *
  vecteur operator + (const vecteur&);//Déclaration de l'opérateur +
  void affiche();
  double krw(double s);
  double kro(double s);
  double f(double s); 
  vecteur F(const vecteur&, double , double);  
};

fichier.cpp

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
#include <iostream>
#include "exemple6.h"
#include <cmath>
#include <fstream>
using namespace std;
//Définition du constructeur de copie
vecteur::vecteur(const vecteur& ref): N(ref.N)
{
  v = new double[N];
  for(unsigned int i=0; i<N;i++)
    v[i]=ref.v[i];
}
 
//Définition du constructeur avec argument
vecteur::vecteur(int Nb, double val)
{
   N = Nb;
   if (Nb == 0)
      v = NULL; 
   else
   {
      v = new double[N];
      for (unsigned i=0; i<N; i++)
         v[i] = val;
   }
}
 
//Définition du destructeur
vecteur::~vecteur()
{}
 
//Définition de []
double& vecteur::operator[](int rang)
{
  return v[rang]; 
}
 
//Définition de =
 
vecteur &vecteur::operator=(const vecteur &a)
{
  for(int i=0;i<N;i++)
    {
      v[i]=a.v[i];
    }
return *this;
}
 
 
//Définition de +
vecteur vecteur:: operator + (const vecteur &a)
{
vecteur d(N);
for (int i=0;i<N;i++)
d.v[i]=v[i]+a.v[i];
return d;
}
 
//Définition de *
vecteur vecteur:: operator*(double  d)
{
for(int i=0;i<N;i++)
v[i]=d*v[i];
return *this;
}
 
//Déclaration de la fonction affiche
void vecteur::affiche()
{
//cout<<"les coordonnées du vecteurs v sont"<<endl;
for(int i=0;i<N;i++)
{
cout<<v[i]<<endl;
}
cout<< "---fin---"<<endl;
}
 
 
//Définition de la fonction krw
double krw(double s)
{
return pow(s,2);
}
 
//Définition de la fonction kro
double kro(double s)
{
return pow((1-s),2);
}
 
//Définition de la fonction fw
 
double fw (double s, double u, double w)
{
return s+u+w;
}
 
 
// Définition d'un vecteur F à partir de fw
vecteur vecteur:: F (const vecteur &S,double u,double w)
{
for (int i=0; i<N; i++)
v[i] = fw(S.v[i],u, w);
return *this;
}
 
 
 
main()
{
int N=2;
double u=1;
double v=1;
vecteur S(2);
S[0]=1;
S[1]=2;
S[2]=10;
vecteur F(2);
 
for (int i=0;i<2;i++)
cout <<F[i]<<endl;
 
 
 
}

Pourtant ca compile et ca s'execute correctement. Avez vous une idée sur pourquoi ca ne le donne que des zéros?

[ternel]

Probablement parce que tu n'a pas copié.

Dans le code suivant, pourquoi veux-tu que F soit différent de 0?

Code :

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

1
2
3
4
5
6
7
8
vecteur S(2);
S[0]=1;
S[1]=2;
S[2]=10;
vecteur F(2);
 
for (int i=0;i<2;i++)
    cout <<F[i]<<endl;

Pire encore, prend un crayon, et dessine des cases mémoires.
Où se trouve S[2]?

PS: fait attention à l'indentation, le bloc de code d'une boucle doit être indenté par rapport au for/while

[hinaneee]

Ok, En fait, comme je l'ai écrit, il faut mettre S(3) et non S(2).
S'il te plaît, en arrangeant ce souci j'ai ce bout de code

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
 
 
main()
{
int N=2;
double u=1;
double v=1;
vecteur S(3);
S[0]=1;
S[1]=2;
S[2]=10;
vecteur F(3);
 
for (int i=0;i<3;i++)
cout <<F[i]<<endl;
 
}

par contre je ne comprend pas comment copier, et obtenir le bon résultat sur F. Quelle est la bonne syntaxe? S'il te plaît.
Merci par avance.

[ternel]

relis ton propre code, c'est marqué dans les commentaires.
Indice, pour copier, il faut copier.

Indice 2: quelles sont exactement toutes les opérations faites par :

Code :

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

vecteur F(3);

[hinaneee]

Je commence par le 2:
vecteur F(2) créer une place dans la mémoire pour un objet F de dimension 2 et de la classe vecteur, donc on peut appliquer à F toutes les opérations de la classe vcteur.
Pour copier, bien sur on appelle le constructeur de copie, mais mon problème est la syntaxe exacte.
J'ai essayé F(S) mais ca ne marche pas (et je pense que ca n'a pas de sens). Ce que j'essaye de faire, c'est créer un vecteur F à partir du vecteur S, telle que chaque composante i du vecteur F est fw appliqué à la composante i de S, puis de l'appeler en faisant un test pour être sûre que ca marche, s'il n'y a pas d'erreurs dans les définitions de fw et de F, je bloque à la dérnière étape. Comment l'écrire correctement? S'il te plaît.
Merci par avance.

[ternel]

La traduction réelle de vecteur F(3); est:
Un vecteur est placé sur la pile.
Il est initialisé avec le constructeur appelé avec l'entier 3 pour argument.
En interne, ce constructeur alloue effectivement un tableau de 3 doubles.


Le constructeur de copie copie, c'est bien ca, mais ca n'est pas ce que tu veux.
Effectivement, vecteur F(S); crée F en appelant son constructeur de copie avec S comme argument.

ce que tu veux, toi, c'est très proche de:

Code :

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

1
2
3
4
5
6
7
8
9
vecteur S(3);
S[0]=1;
S[1]=10;
S[2]=12;
 
vecteur F(s.size());//ou tout autre nom que tu as choisis pour avoir la taille de s.
F[0]=f(S(0));
F[1]=f(S(1));
F[2]=f(S(0));

ou bien

Code :

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

1
2
3
4
5
6
7
vecteur S(3);
S[0]=1;
S[1]=10;
S[2]=12;
 
vecteur F(s.size());//ou tout autre nom que tu as choisis pour avoir la taille de s.
for(int i = 0; i <s.size(); ++i) F[i]=f(S[i]);

Comme tu le vois, c'est laborieux, parce que tu ne disposes pas d'un constructeur simple de ton vecteur.
si tu activais C++11, tu pourrais utiliser std::initializer_list, et écrire ta classe vecteur de façon à ce que ton code soit:

Code :

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

1
2
3
typedef math::vecteur<3> vecteur;
vecteur S {1, 10, 12};
vecteur F {f(S[0]), f(S[0]), f(S[0])};

Maintenant, soyons astucieux.
Il existe des pointeurs de fonctions.
On peut imaginer composer une fonction et un vecteur pour obtenir un vecteur.

Code :

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

1
2
3
4
5
6
7
8
vecteur operator * (double (*f)(double), vecteur const& v) {
    vecteur w(v.size());
    for (int i = 0; i <v.size(); ++i) w[i] = (*f) (v[i]);
    return w;
}
 
//et sa symétrique
inline vecteur operator * (vecteur const& v, double (*f)(double)) {return f*v;}

[hinaneee]

J'ai mis les deux écriture, et les deux donnes des erreurs du genre

error: ‘s’ was not declared in this scope
 vecteur F(s.size());//ou tout autre nom que tu as choisis pour avoir la taille de s.
           ^
exemple6.cpp:122:44: error: no match for call to ‘(vecteur) (int&)’
 for(int i = 0; i <s.size(); ++i) F[i]=f(S(i));
                                            ^
exemple6.cpp:122:45: error: ‘f’ was not declared in this scope
 for(int i = 0; i <s.size(); ++i) F[i]=f(S(i));

où ben il faut mettre un std:: quelque part et je n'ai pas compris où? Merci de m'expliquer ce point s'il te plaît.

[ternel]

Je code dans un forum, cherche un peu quels sont les noms exacts dans ton code.
En l'occurence, je t'ai donné une classe de vecteur beaucoup plus propre.
(notamment parce que kro, krw et f ne sont pas dedans).

Ton autre soucis, c'est que j'ai l'impression que ta relation est définie pour deux niveaux de récurrence:
S au temps N+1 est fonction de S au temps N et S au temps N-1.

[hinaneee]

Allons-y étape par étapes s'il te plaît, d'abord je souhaite régler le progralème du vecteur F défini à partir de la fonction fw pour voir si mon algorithme peut marcher. Alors pour voir si F marche bien, j'ai écris le code que tu proposes en utilisant mes notation, mais ca ne marche pas. Voici mon code .cpp et ci-dessous l'erreur

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
 
#include <iostream>
#include "exemple6.h"
#include <cmath>
#include <fstream>
using namespace std;
//Définition du constructeur de copie
vecteur::vecteur(const vecteur& ref): N(ref.N)
{
  v = new double[N];
  for(unsigned int i=0; i<N;i++)
    v[i]=ref.v[i];
}
 
//Définition du constructeur avec argument
vecteur::vecteur(int Nb, double val)
{
   N = Nb;
   if (Nb == 0)
      v = NULL; 
   else
   {
      v = new double[N];
      for (unsigned i=0; i<N; i++)
         v[i] = val;
   }
}
 
//Définition du destructeur
vecteur::~vecteur()
{}
 
//Définition de []
double& vecteur::operator[](int rang)
{
  return v[rang]; 
}
 
//Définition de =
 
vecteur &vecteur::operator=(const vecteur &a)
{
  for(int i=0;i<N;i++)
    {
      v[i]=a.v[i];
    }
return *this;
}
 
 
//Définition de +
vecteur vecteur:: operator + (const vecteur &a)
{
vecteur d(N);
for (int i=0;i<N;i++)
d.v[i]=v[i]+a.v[i];
return d;
}
 
//Définition de *
vecteur vecteur:: operator*(double  d)
{
for(int i=0;i<N;i++)
v[i]=d*v[i];
return *this;
}
 
//Déclaration de la fonction affiche
void vecteur::affiche()
{
//cout<<"les coordonnées du vecteurs v sont"<<endl;
for(int i=0;i<N;i++)
{
cout<<v[i]<<endl;
}
cout<< "---fin---"<<endl;
}
 
 
//Définition de la fonction krw
double krw(double s)
{
return pow(s,2);
}
 
//Définition de la fonction kro
double kro(double s)
{
return pow((1-s),2);
}
 
//Définition de la fonction fw
 
double fw (double s, double u, double w)
{
return s+u+w;
}
 
 
// Définition d'un vecteur F à partir de fw
vecteur vecteur:: F (const vecteur &S,double u,double w)
{
S.v[0]=1;
for (int i=1; i<N; i++)
v[i] = fw(S.v[i],u, w);
return *this;
}
 
 
 
main()
{
int N=2;
double u=1;
double v=1;
 
vecteur S(3);
S[0]=1;
S[1]=10;
S[2]=12;
 
vecteur F(S.3(),u,v);//ou tout autre nom que tu as choisis pour avoir la taille de s.
F[0]=fw(S[0]);
F[1]=fw(S[1]);
F[2]=fw(S[0]);
 
}

et l'erreur qu'il m'affiche, est:

In function ‘int main()’:
exemple6.cpp:121:12: error: expected ‘)’ before numeric constant
 vecteur F(S.3(),u,v);//ou tout autre nom que tu as choisis pour avoir la taille de s.
            ^
exemple6.cpp:121:20: error: no matching function for call to ‘vecteur::vecteur(vecteur&, double&, double&)’
 vecteur F(S.3(),u,v);//ou tout autre nom que tu as choisis pour avoir la taille de s.
                    ^
exemple6.cpp:121:20: note: candidates are:
exemple6.cpp:7:1: note: vecteur::vecteur(const vecteur&)
 vecteur::vecteur(const vecteur& ref): N(ref.N)
 ^
exemple6.cpp:7:1: note:   candidate expects 1 argument, 3 provided
exemple6.cpp:15:1: note: vecteur::vecteur(int, double)
 vecteur::vecteur(int Nb, double val)
 ^
exemple6.cpp:15:1: note:   candidate expects 2 arguments, 3 provided
In file included from exemple6.cpp:2:0:
exemple6.h:8:2: note: vecteur::vecteur()
  vecteur():v(NULL),N(0){};//Déclaration et définition du constructeur par défaut
  ^
exemple6.h:8:2: note:   candidate expects 0 arguments, 3 provided
exemple6.cpp:122:13: error: too few arguments to function ‘double fw(double, double, double)’
 F[0]=fw(S[0]);
             ^
exemple6.cpp:93:8: note: declared here
 double fw (double s, double u, double w)
        ^
exemple6.cpp:123:13: error: too few arguments to function ‘double fw(double, double, double)’
 F[1]=fw(S[1]);
             ^
exemple6.cpp:93:8: note: declared here
 double fw (double s, double u, double w)
        ^
exemple6.cpp:124:13: error: too few arguments to function ‘double fw(double, double, double)’
 F[2]=fw(S[0]);
             ^
exemple6.cpp:93:8: note: declared here
 double fw (double s, double u, double w)

Comment l'aranger? S'il vous plaît.

[ternel]

Comment lis-tu ces messages d'erreur?
qu'en déduis-tu?

Où est ta fonction f?
Vois-tu pourquoi je te disais que c'est une mauvaise idée?

Au passage, il faudrait que tu actives les warnings, parce que ce n'est pas main() mais int main().
Cela fait depuis au moins 26 ans (1989) qu'en C, les fonctions sans type de retour sont deprecated, c'est à dire à ne pas utiliser.

[hinaneee]

En fait je n'ai pas tout compris, je comprend juste que le problème vient de la définition de F. Alors voici comment j'ai arangé mon code

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
#include <iostream>
#include "exemple6.h"
#include <cmath>
#include <fstream>
using namespace std;
//Définition du constructeur de copie
vecteur::vecteur(const vecteur& ref): N(ref.N)
{
  v = new double[N];
  for(unsigned int i=0; i<N;i++)
    v[i]=ref.v[i];
}
 
//Définition du constructeur avec argument
vecteur::vecteur(int Nb, double val)
{
   N = Nb;
   if (Nb == 0)
      v = NULL; 
   else
   {
      v = new double[N];
      for (unsigned i=0; i<N; i++)
         v[i] = val;
   }
}
 
//Définition du destructeur
vecteur::~vecteur()
{}
 
//Définition de []
double& vecteur::operator[](int rang)
{
  return v[rang]; 
}
 
//Définition de =
 
vecteur &vecteur::operator=(const vecteur &a)
{
  for(int i=0;i<N;i++)
    {
      v[i]=a.v[i];
    }
return *this;
}
 
 
//Définition de +
vecteur vecteur:: operator + (const vecteur &a)
{
vecteur d(N);
for (int i=0;i<N;i++)
d.v[i]=v[i]+a.v[i];
return d;
}
 
//Définition de *
vecteur vecteur:: operator*(double  d)
{
for(int i=0;i<N;i++)
v[i]=d*v[i];
return *this;
}
 
//Déclaration de la fonction affiche
void vecteur::affiche()
{
//cout<<"les coordonnées du vecteurs v sont"<<endl;
for(int i=0;i<N;i++)
{
cout<<v[i]<<endl;
}
cout<< "---fin---"<<endl;
}
 
 
//Définition de la fonction krw
double krw(double s)
{
return pow(s,2);
}
 
//Définition de la fonction kro
double kro(double s)
{
return pow((1-s),2);
}
 
//Définition de la fonction fw
 
double fw (double s, double u, double w)
{
return (krw(s)/u)/ ((krw/w)+(kro/u));
}
 
 
// Définition d'un vecteur F à partir de fw
vecteur vecteur ::F (const vecteur &S, double u, double w)
{
   v[0]= fw(S.v[0],u,w);
   for(int i=1; i< N; i++)
  v[i]= fw(S.v[i], u, w);
return *this;
}
 
 
 
int main()
{
int N=2;
double u=1;
double v=1;
 
 
 
vecteur S(3);
S[0]=1;
S[1]=10;
S[2]=12;
 
vecteur G(3);
 
 
}

mon problème reste dans la syntaxe utiliser pour appeller la fonction F utilisée pour construire le vecteur qui a pour composantes f(S_i). Comment la faire logiquement? S'il vous plaît. En plus, il m'affiche l'erreur suivante

In function ‘double fw(double, double, double)’:
exemple6.cpp:95:26: error: invalid operands of types ‘double(double)’ and ‘double’ to binary ‘operator/’
return (krw(s)/u)/ ((krw/w)+(kro/u));
^
exemple6.cpp:95:34: error: invalid operands of types ‘double(double)’ and ‘double’ to binary ‘operator/’
return (krw(s)/u)/ ((krw/w)+(kro/u));

ca concerne la division d'un double par un double. Comment l'aranger? S'il vous plaît.
Je vous remercie par avance.