Forum de mathématiques - Bibm@th.net

Bonjour,
Ton poste est difficile à suivre: je ne vois pas trop ton problème! Est-il questions des équations différentielles ou démonstration d'une intégrale! je n'ai pas bien capté! Je reprends le dernier poste de yoshi concernant la démonstration: [tex]\int^{\infty }_{0}\frac{x\cos u}{{u}^{2}+{x}^{2}}=\frac{\pi }{2{e}^{x}}[/tex]
Pour calculer cette intégrale, je pense qu'il vaut mieux faire un changement de variable, en posant, par exemple: [tex]\frac{u}{x}=\tan \left(\theta \right)[/tex]
Valentin

Salut freddy Groupoid Kid,
Pour la 1) c'est effectivement la définition d'une binomiale : pi est donnée et i varie de 1 à k. Donc, on a:
[tex]P\left({N}_{i}=k\right)=\sum^{k}_{i=1}{C}^{i}_{k}{p}^{k}_{i}{\left(1-{p}_{i}\right)}^{k-i}[/tex]

Salut freddy,
Merci, mais à quoi est égale [tex]{p}_{i}[/tex]?

Salut,
Il te manque une parenthèse dans ta dérivé première de F(x):

et un signe moins au deuxième terme de ta dérivé seconde (tu dérives par rapport à x!)
Valentin

Salut,
En fait,  [tex]x\left(t\right)\times y\left(t\right)[/tex] revient à "convoluer" les deux signaux, on peut donc utiliser la transformée de Fourier directe et inverse!
Valentin

Salut Freddy,
comment tu as fait pour avoir le  [tex]\frac{1}{2}[/tex] dans prob de a et  le facteur [tex]\frac{1}{4!}[/tex] dans "pour le b)"

La loi que tu as généralisé au post 8 me fait penser à la loi d'hypergéométrie! En fait, si on avait affirmé dès le départ que c'est une loi de Bernoulli, est-ce qu'on ne pouvait pas directement (si l'on avait reconnu!) généraliser que c'est une loi d'hypergéométrique?

Salut Freddy,
Pour ta question: "Est ce toi qui adaptes des sujets piochés à droite et à gauche, ou bien vas tu les chercher sur Mars ou sur Vénus ?", non, c'est un sujet d'examen qu'un prof avait donné à l'examen et je l'ai réécrit tel qu'il a été donné.
Concernant la question 1 "b) Quelle est la probabilité d'obtenir au moins deux boules de même couleur?", d'après le calcul que t'as fait en post  [tex]P=\frac{\binom{14}{1}\binom{12}{1}\binom{10}{1}\binom{8}{1}}{\binom{14}{4}4!}=\frac{80}{143}[/tex]

Pour la question 2 "b) Généraliser le résultat aux autres variables   ", je n'ai pas compris ta démarche. Dans un premier temps, tu as posé i=3 puis t'as calculé la probabilité de tirer le troisième poisson rouge. On a l'univers :  [tex]\Omega ={RRR;RRG;RGR;RGG;GRR;GRG;GGR;GGG}[/tex]
On a bien 1 RRR donc 3 parmi 10 ce qui donne bien 10*9*8. Là où je n'ai pas compris : pourquoi t'as 2 cas types RGR (est -ce qu'on ne compte pas aussi GRR et RRG?)?
Valentin

Bonjour Yoshi,
Et voici ma matrice triangulaire supérieure, elle fonctionne à merveille! En fait, il suffisait d'introduire une fonction dans le code. C'était surtout là la grande difficulté!
Merci beaucoup Yoshi pour ton aide et surtout les liens de cours que tu m'as donnés: ils vont, au moins, me permettre de reviser pour mes examens! Enfin, ce fil de discussion m'a été beaucoup plus pratique pour mieux comprendre le cours. Je ne voyais pas trop l'intérêt d'un tableau en langage C, effectivement, il y a bien des ressemblaces et dissemblaces entre maths et informatique, quand l'informatique est bien expliqué logiquement!...C'est surtout cela que je voulais plutôt voir, il y a un melange de deux!

Voici le code de la matrice triangulaire sup:

# include <stdio.h>
# include <stdlib.h>

/* Fonction d'affichage d'une matrice */
void affichage(float ts[4][4]){
    int i=0;
        printf("+----------+----------+----------+----------+\n");
        for (i = 0 ; i<4 ; i++)
            {
                printf("| %8.2f | %8.2f | %8.2f | %8.2f |\n", ts[i][0], ts[i][1], ts[i][2], ts[i][3]);
                printf("+----------+----------+----------+----------+\n");
            }
    }
 
/* Fonction de saisie des valeurs dans une matrice */ 
void saisie (float ts[4][4]){
     int i=0,j=0;
            for (i = 0 ; i<4 ; i++)
            {
                for(j = 0 ; j < 4; j++)
                    {
                        printf("Ligne, %d,colonne, %d : ", i+1, j+1);
                        scanf("%f", &(ts[i][j]));
                    }
            }
    }

/* Fonction de triangularisation d'une matrice */
void triangularisation (float ts[4][4]){
     int db,i,j;
     float coeff,pv;
         /* Traitement de la matrice donnée */
       for (db = 0 ; db<3 ; db++)
       {
           /* On vérifie si le premier nombre sur la diagonale est non nul */
           if(ts[db][db]!=0)
           {
           /* On en fait un pivot, et on normalise le reste de la ligne */
                  pv=ts[db][db];
                  for (j=0 ; j<4; j++)
                  {
                      ts[db][j]=(ts[db][j])/pv;
                  }
           /* On annule le 1er terme non nul de chaque ligne suivante */   
                   for (i=db+1;i<4;i++)
                   {   
                       coeff=(ts[i][db]);
                       for (j=db;j<4;j++)
                       {
                           ts[i][j]=(ts[i][j])-coeff*(ts[db][j]);
                       }
                   }
           /* Affichage en cours de route pour voir l'évolution de la matrice */
      affichage(ts);
           }
      }
}

int main()
{
    float ts[4][4];
    int i,j,db;
    printf("        Triangularisation de matrices 4 x 4\n\n");
    printf("      Elements\n");
   
   saisie(ts);
   system("cls");
   affichage(ts);
   triangularisation(ts);

    printf("\n\n");
   affichage(ts);       
                       
    system("pause");

    return 0;
}

+----------+----------+----------+----------+
|     1.00 |     2.00 |     3.00 |     4.00 |
+----------+----------+----------+----------+
|     2.00 |     3.00 |     4.00 |     1.00 |
+----------+----------+----------+----------+
|     3.00 |     4.00 |     1.00 |     2.00 |
+----------+----------+----------+----------+
|     4.00 |     1.00 |     2.00 |     3.00 |
+----------+----------+----------+----------+
+----------+----------+----------+----------+
|     1.00 |     2.00 |     3.00 |     4.00 |
+----------+----------+----------+----------+
|     0.00 |    -1.00 |    -2.00 |    -7.00 |
+----------+----------+----------+----------+
|     0.00 |    -2.00 |    -8.00 |   -10.00 |
+----------+----------+----------+----------+
|     0.00 |    -7.00 |   -10.00 |   -13.00 |
+----------+----------+----------+----------+
+----------+----------+----------+----------+
|     1.00 |     2.00 |     3.00 |     4.00 |
+----------+----------+----------+----------+
|     0.00 |     1.00 |     2.00 |     7.00 |
+----------+----------+----------+----------+
|     0.00 |     0.00 |    -4.00 |     4.00 |
+----------+----------+----------+----------+
|     0.00 |     0.00 |     4.00 |    36.00 |
+----------+----------+----------+----------+
+----------+----------+----------+----------+
|     1.00 |     2.00 |     3.00 |     4.00 |
+----------+----------+----------+----------+
|     0.00 |     1.00 |     2.00 |     7.00 |
+----------+----------+----------+----------+
|     0.00 |     0.00 |     1.00 |    -1.00 |
+----------+----------+----------+----------+
|     0.00 |     0.00 |     0.00 |    40.00 |
+----------+----------+----------+----------+

+----------+----------+----------+----------+
|     1.00 |     2.00 |     3.00 |     4.00 |
+----------+----------+----------+----------+
|     0.00 |     1.00 |     2.00 |     7.00 |
+----------+----------+----------+----------+
|     0.00 |     0.00 |     1.00 |    -1.00 |
+----------+----------+----------+----------+
|     0.00 |     0.00 |     0.00 |    40.00 |
+----------+----------+----------+----------+
Appuyez sur une touche pour continuer...
Valentin

je ne comprends rien, j'arrive à entrer les valeurs (le programme est compilé et exécuté), mais ça ne m'affiche pas le résultat. J'ai ça comme code:
#include <stdio.h>
#include <stdlib.h>

void lecture (float tab[4][4]){
    int i,j;
    for(i=0;i<4;i++){
        for(j=0;j<4;j++){
            printf("entrez une valeur\n");
            scanf("%f",&tab[i][j]);
         }
     }
     return;
}
        void ecriture (float t[4][4]){
           int i,j;
           for(i=0;i<4;i++){
               for(j=0;j<4;j++){
                   printf("%f",t[i][j]);
               }
               printf("\n");
           }
           return;
        }
        float matrice_triangulaireTS (float tab[4][4]){
              int i,j,k;
              float TS[4][4],coeff,pv;
              for(k=0;k<3;k++){
                  pv=TS[k][k];
                  for(i=k;i<4;i++){
                      TS[k][i]=(TS[k][i])/pv;
                  }
              }
                  for(j=k+1;k<4;k++){
                      coeff=TS[j][k];
                      for(i=k;i<4;i++){
                          TS[j][i]=TS[j][i]-coeff*TS[k][i];
                          }
                      }   
        }
main()
{
        float tt[4][4];
        float TS;
        lecture(tt);
        ecriture(tt);
        printf("la matrice triangulaire est %f",TS);
        getchar();
}