Discussion :

[kutne10]

Bonjour à tous,

voila j'ai créés 4 fonctions sous la forme f(x,y,z,t) f1,f2,f3,f4

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
  public static Double f1(double V, double gamma, double h, double r, double t)
        { return -CD / 2 * rho * V * V * S / mass - g * Math.Sin(gamma); }
 
        public static Double f2(double V, double gamma, double h, double r, double t)
        { return 1 / V * (1 / (2 * mass) * rho * V * V * S * CL - g * Math.Cos(gamma)); }
 
        public static Double f3(double V, double gamma, double h, double r, double t)
        { return V * Math.Sin(gamma); }
 
        public static Double f4(double V, double gamma, double h, double r, double t)
        { return V * Math.Cos(gamma);

et j'aurais besoin enfait de les appeler dans une boucle, genre f_i avec i de 1 à 4. Pour cela j'ai pensé à les réunir dans une matrice F pour pouvoir appeler F(i).

Mais question, est il possible de définir cette matrice, et de l'utiliser comme par exemple F(i)(V,gamma,h,r) avec i de 0 à 3 ? Toujours dans le but d'utiliser mes différentes fonctions dans une boucle for

En vous remerciant,

Cordialement,

[kutne10]

Bon on va dire que avec ca ca passe, c'est pas super générique mais bon...

Code :

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

1
2
3
4
5
6
7
8
 
        public static Double F(int i,double x1, double x2, double x3, double x4,double t)
            {
                if (i == 1) { return f1(x1, x2, x3, x4, t); }
                if (i == 2) { return f2(x1, x2, x3, x4, t); }
                if (i ==3) { return f3(x1, x2, x3, x4, t); }
                if (i == 4) { return f4(x1, x2, x3, x4, t); }
                        }

[Max]

Salut.

C'est mon jour de bonté Imagine que ta classe dans laquelle sont définies tes fonctions s'appelle MyClass :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MyClass {
    public static Double f1(double V, double gamma, double h, double r, double t)
    { return -CD / 2 * rho * V * V * S / mass - g * Math.Sin(gamma); }
 
    public static Double f2(double V, double gamma, double h, double r, double t)
    { return 1 / V * (1 / (2 * mass) * rho * V * V * S * CL - g * Math.Cos(gamma)); }
 
    public static Double f3(double V, double gamma, double h, double r, double t)
    { return V * Math.Sin(gamma); }
 
    public static Double f4(double V, double gamma, double h, double r, double t)
    { return V * Math.Cos(gamma); }
}

Imaginons ensuite que tu veuilles faire l'appel dynamique dans une classe qui s'appelle OtherClass :

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
public class OtherClass {
    // ...
 
    public void DummyMethod() {
        // Tu crées une instance de l'objet sur lequel tu veux appeler dynamiquement des méthodes
        MyClass myClass = new MyClass();
        MethodInfo currentMethodInfo = null;
        double currentDouble = 0.0;
        // Ta boucle qui simule un "f(i)"
        for (int i = 1; i < 5; i++) {
            // Tu récupères la méthode via son nom
            currentMethodInfo = typeof(MyClass).GetMethod("f" + i);
            // Tu l'éxécutes avec les bons paramètres et récupères le résultat
            currentDouble = (double)methodInfo.Invoke(myClass, new object[] { 1, 1, 1, 1, 1 });            
        }        
    }
}

Je te laisse fouiller dans la doc pour voir comment ça fonctionne réellement

[hotsizzle]

Dans ton cas je ferais plutôt une seul fonction , je passerais i en parametres et je ferais un switch comme ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
public static Double f(double V, double gamma, double h, double r, double t, int i)
{
Double result = 0;
switch (i)
            {
                case 1 : result = -CD / 2 * rho * V * V * S / mass - g * Math.Sin(gamma);
                break;
                case 2 : result = 1 / V * (1 / (2 * mass) * rho * V * V * S * CL - g * Math.Cos(gamma)); }
                 break;
///ect......
            }
return result
}

L'autre solution est d'utiliser la reflection, mais ce procédé est un peu plus complexe.

bonne continuation a+

[kutne10]

Merci à tous pour toutes ces réponses, que je vais tester sans trainer !