Pour les matheux, définition de l'exponentielle, sinus, cosinus

Soyez le premier à donner votre avis sur cette source.

Vue 21 591 fois - Téléchargée 292 fois

Description

Ben voila une petite source.
Je pense qu'elle va surtout intéresser les matheux.
Elle montre d'où vient la fonction exponentielle, sinus, cosinus, PI,..., grâce à une "résolution" de séries.
C'est peut-être utile pour le calcul,... Je vous fais confiance, je pense que vous y trouverez une utilité (c'est déjà "didactique"). Toujours est-il, ce sont les définitions officielles de l'expo, cosinus, etc.
Pour certaines fonctions, il est possible qu'il y ait des problèmes de précision. Il faudra alors régler le nombre de sommes pour la série.
@++

Source / Exemple :


/* DEFINITION DE L'EXPONENTIELLE AINSI QUE DU COSINUS ET DU SINUS */

/*EXPONENTIELLE*/

/*On définit l'exponentielle comme une série tel que
  la somme de n=0 jusqu'à l'infini du nombre à la puissance n
  sur la factorielle de n.

/**********Fonction factorielle**********/

function factor(h) {
    return (h == 0)?1:(h * factor(h - 1));	//exemple : 5! = 5*4*3*2*1 = 120
}

/****************************************/

/*********Fonction exponentielle*********/

/* J'ai eu quelques soucis avec la fonction puissance
   à cause des infinis. J'ai donc utiliser la fonction 
   prédéfinie Math.pow(). La fonction a été testée jusqu'à 100,
   ensuite les nombres sont trop énormes pour cette fonction.*/

function expo(z){		//la base est e = 2.718281828...
    var som = 0;
    for(n=0;n<155;n++)
    {
        val = (Math.pow(z,n))/(factor(n));
        som = som + val;
    }
    return som;
}

/****************************************/

/******************PI********************/

function pi(){
    var som = 0;
    for(n=0;n<25;n++)    //25 est amplement suffisant car elle converge vite.
    {
        var N = 2*n;
        var N2 = 4*n+1;
        val = (factor(N))/(Math.pow(2,N2)*factor(n)*factor(n)*(2*n+1));
        som = som + val;
    }
    som = som * 6;
    return som;
}
/****************************************/

/*****************SINUS******************/

function sinus(nb){       
    var som = 0;
    for(n=0;n<20;n++)     //à choisir suivant la précision que l'on veut donner, plus le nombre est grand et plus n doit être grand 
    {
        val = (Math.pow(-1,n)*Math.pow(nb,2*n+1))/(factor(2*n+1));
        som = som + val;
    }
    return som;
}

/****************************************/

/****************COSINUS*****************/

function cosinus(nb){
    var som = 0;
    for(n=0;n<20;n++)     //à choisir suivant la précision que l'on veut donner, plus le nombre est grand et plus n doit être grand 
    {
        val = (Math.pow(-1,n)*Math.pow(nb,2*n))/(factor(2*n));
        som = som + val;
    }
    return som;
}

/****************************************/

/***************TANGEANTES***************/

function tang(nb){
    val = sinus(nb)/cosinus(nb);
    return val;
}

/****************************************/

/***************ARC SINUS****************/

function arcsin(nb){
    var som = 0;
    for(n=0;n<30;n++)     //à choisir suivant la précision que l'on veut donner, plus le nombre est grand et plus n doit être grand 
    {
        val = (factor(2*n)*Math.pow(nb,2*n+1))/(Math.pow(2,2*n)*factor(n)*factor(n)*(2*n+1));
        som = som + val;
    }
    return som;
}

/****************************************/

/**************ARC COSINUS***************/
/*On définit l'ARC COSINUS par :

arccos x = pi/2 - arcsin x

  • /
function arccos(nb){ return pi()/2 - arcsin(nb); } /****************************************/ /**************ARC TANGEANTE*************/ function arctg(nb){ var som = 0; for(n=0;n<40;n++) //à choisir suivant la précision que l'on veut donner, plus le nombre est grand et plus n doit être grand { val = (Math.pow(-1,n)*Math.pow(nb,2*n+1))/(2*n+1) som = som + val; } return som; } /****************************************/ /***********SINUS HYPERBOLIQUE***********/ function sinh(nb){ return (expo(nb)-expo(-nb))/2; } /****************************************/ /**********COSINUS HYPERBOLIQUE**********/ function cosh(nb){ return (expo(nb) + expo(-nb))/2; } /****************************************/ /*********TANGEANTE HYPERBOLIQUE*********/ function tanh(nb){ return (1-expo(-2*nb))/(1+expo(-2*nb)); } /****************************************/ /**********SECANTE HYPERBOLIQUE**********/ function sech(nb){ return 1/cosh(nb); } /****************************************/ /*********COSECANTE HYPERBOLIQUE*********/ function cosech(nb){ return 1/sinh(nb); } /****************************************/ /********COTANGEANTE HYPERBOLIQUE********/ function cotanh(nb){ return cosh(nb)/sinh(nb); } /****************************************/ document.write("Exponentielle de 1 : " + expo(1) + "<br>"+ "Fonction prédéfinie Math.exp(1) : " + Math.exp(1) + "<br><br>"+ "Nombre PI : " + pi() + "<br>"+ "Nombre prédéfini : " + Math.PI + "<br><br>"+ "Sinus de PI/2 : " + sinus(pi()/2) + "<br>"+ "Sinus prédéfini : " + Math.sin(Math.PI/2) + "<br><br>"+ "Cosinus de PI/4 : " + cosinus(pi()/4) + "<br>"+ "Cosinus prédéfini : " + Math.cos(Math.PI/4) + "<br><br>"+ "Tangeante de PI/4 : " + tang(pi()/4) + "<br>"+ "Tangeante prédéfinie : " + Math.tan(Math.PI/4) + "<br><br>"+ "Arc sinus de PI/4 : " + arcsin(pi()/4) + "<br>"+ "Arc sinus prédéfini : " + Math.asin(Math.PI/4) + "<br><br>"+ "Arc cosinus de PI/4 : " + arccos(pi()/4) + "<br>"+ "Arc cosinus prédéfini : " + Math.acos(Math.PI/4) + "<br><br>"+ "Arc tangeante de 1 : " + arctg(1) + "<br>"+ "Arc tangeante prédéfini : " + Math.atan(1) + "<br><br>"+ "Sinus hyperbolique de PI : " + sinh(pi()) + "<br>"+ "Cosinus hyperbolique de PI : " + cosh(pi()) + "<br>"+ "Tangeante hyperbolique de PI : " + tanh(pi()) + "<br>"+ "Sécante hyperbolique de PI : " + sech(pi()) + "<br>"+ "Cosécante hyperbolique de PI : " + cosech(pi()) + "<br>"+ "Cotangeante hyperbolique de PI : " + cotanh(pi()));

Conclusion :


voila...

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
868
Date d'inscription
dimanche 26 décembre 2004
Statut
Membre
Dernière intervention
26 février 2008
1
Localstone >> Bonne idée.
Je ferai ça un peu plus tard car je suis pas mal débordé ces temps-ci.
@++
Messages postés
1804
Date d'inscription
mardi 15 juillet 2003
Statut
Membre
Dernière intervention
22 septembre 2009
5
Aucune idée pour les cos/sin/exp honnêtement, ca converge vite pour cos et sin vu qu'il y'a seulement un terme sur deux, pour l'exp idem du au factoriel.
Au passage, j'reviens sur les séries entières : c'est quand même aussi super utile pour les résolutions d'équations différentielles ou fonctionnelles, c'est une des méthodes classiques...
J'attends de voir tout ca en C !! :)
Messages postés
514
Date d'inscription
mercredi 19 mars 2003
Statut
Membre
Dernière intervention
1 mars 2009

Algori > Je pense même que tu devrais (enfin si tu as envie, moi je dis ça comme ça, hein ;) ) essayer de coder ta propre gestion des nombres en C pour ensuite pouvoir calculer la fonction exponentielle ou cosinus avec autant de précision que tu veux. C'est un truc que j'ai toujours voulu faire, en codant l'addition, la multiplication, etc ... Mais j'ai jamais pris le temps.
Enfin voilà voilà ...
++ !
L.S.
Messages postés
868
Date d'inscription
dimanche 26 décembre 2004
Statut
Membre
Dernière intervention
26 février 2008
1
Salut PADA,
merci pour ces précisions.
Cette source est un petit amusement. Je suppose qu'il doit y avoir des méthodes plus rapides pour calculer le cos, sin, etc (?)...
Je l'ai fait en javascript mais j'aurai du le posté en C car pour javascript, la précision mathématique est à revoir.
@++
Messages postés
1804
Date d'inscription
mardi 15 juillet 2003
Statut
Membre
Dernière intervention
22 septembre 2009
5
Je fais très peu de javascript, mais si je peux préciser deux trois trucs mathématiques :
On peut pas raisonnablement dire que les séries entières sont des définitions officielles des sin,cos,exp, etc.. c'est un angle d'attaque, et on peut montrer facilement qu'il coincide avec tous les autres.
D'autre part, les séries entières c'est quelque chose de magnifique sur le papier, et c'est extrêmement utile pour des exercices théoriques. Mais niveau calcul numérique, c'est complètement obsolète, en général on a des fonctions d'état efficace qui convergent avec une précision de 8-10 digits en quelques itérations seulement
(exple: la racine carrée qui dans les caltos est programmée comme point fixe de u(x)=1/2*(x+a/x), ce qui est bien plus efficace que l'horrible série entière sur les (1+x)^alpha)
Afficher les 11 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.