Tableaux de fonctions

Version imprimable

Bonjour à tous,

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

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,

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

Code:

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); }
                        }

Salut.

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

Code:

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:

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 ;)

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

Code:

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+

16/07/2010, 13h51
kutne10

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