[Débutant] Approximation de la racine carrée d'une fonction

Bonjour,

Je suis débutant en C# et j'essaie de faire ce TP en entier.

Pièce jointe 223790

Là où je sèche totalement, c'est sur l'approximation selon la méthode indiquée dans le TP:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
        public double Approximation(int d)
        {
 
            string resultat;
            double[] y = new double [d];
            resultat = (BigInteger.Pow(10, -d) * numerateur / denominateur).ToString();
            double a = double.Parse((numerateur).ToString());
            double b = double.Parse((denominateur).ToString());
            int i = 1;
            do
            {
                y[0] = Math.Sqrt(a) / Math.Sqrt(b);
                y[i] = y[i - 1] * (3 - (a / b) * Math.Pow(y[i - 1], 2)) / 2;
                i++;
            }while( (Math.Pow(y[i],-2)-(a/b))/Math.Pow(y[i],-1) >= Math.Pow(10,-d) );
        }
    }

Ensuite, j'ai quelques incompréhensions quand j'ai souligé après ce code, je vous le mets en entier pour avoir toute aide possible, comme une autre solution envisageable ...

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
 
 
 
class Fraction
    {
 
        BigInteger num;
        BigInteger den;
 
       public BigInteger numerateur
       {
            get {return num;}
            set {num = value;}
        }
       public BigInteger denominateur
       {
            get {return den;}
            set {if (den != 0)
                    den = value;}
        }
 
        public Fraction(long n, long d)
        {
            num = n;
            den = d;
        }
 
        public Fraction(string n, string d)
        {
            num = BigInteger.Parse(n);
            den = BigInteger.Parse(d);
        }
 
        public string DevFraction(int p)
        {
 
            String resultat;
            resultat = ((BigInteger.Pow(10, p) * numerateur) / denominateur).ToString();
            int len = resultat.Length;
            //int reste = (p + 1) - len;
            //String res = new String ('0', p);
            resultat = new string('0', p) + resultat;
            //return f;
            return resultat.Substring(len - 1, 1) + "," + resultat.Substring(len, p);
        }
 
        public static Fraction operator +(Fraction f1, Fraction f2)
        {
            string n = (f1.num * f2.den + f1.den * f2.num).ToString();
            return new Fraction(long.Parse((f1.num * f2.den + f1.den * f2.num).ToString()), long.Parse((f1.den*f2.den).ToString()));
        }
 
        public static Fraction Facteurs_Premiers(Fraction f)
        {
            BigInteger p;
 
            p= BigInteger.GreatestCommonDivisor(f.num, f.den);
            if (p == 1)
                return f;
            else
                return new Fraction(long.Parse((f.num / p).ToString()), long.Parse((f.den / p).ToString()));
 
        }

Je ne comprends pas notemment pourquoi je dois écrire ça pour l'opérateur + :

Code:

 return new Fraction(long.Parse((f1.num * f2.den + f1.den * f2.num).ToString()), long.Parse((f1.den*f2.den).ToString()));

je me dis que cela vient du fait qu'il y a 2 constructeurs, et je pense aussi que je peux utiliser qu'un seul constructeur, en gros, pourquoi quand je fais ça :

Code:

return new Fraction((f1.num * f2.den + f1.den * f2.num).ToString(), (f1.den*f2.den).ToString());

C# me signale un erreur, de même que quand je les convertis seulement en long.

Merci d'avance pour votre aide

Cordialement