Petit souci de formule - Page 2

Résolu
Précédent
  • 1
  • 2
  1. lefleau02 Messages postés 26 Statut Membre
     
    Non c'est plus en java que je dois rédiger cette fonction
    Par contre je ne connais pas du tout le language MathLab donc je vais te dire ce que je comprend au code et tu n'auras qu'a me dire si je fais une erreur
    // Declaration de la fonction qui prend en paramettre X (valeur) et N (nombre de decimal)
    function[res]=log10app(x,n) 


    // Declaration des variables de la fonction
    clear y; clear M; clear res; 


    // Initialisation de leur valeur
    res=0; M=0; 


    // Connais pas du tout
    format long  


    // Test verifiant la validité des donnees transmise
    if (x<=0 || n<0)  

       res='Erreur';
    else


    // Repete tant que K n'est pas égale a N
       for k=0:n  
            y=0;
            if k==0
                if x<1

    // La je ne vois pas ou est initialisé Y mais je comprend l'algo
                    while x/10^(y-1)<10
                        y=y-1;
                    end
                else
                    while x/10^y>=10
                        y=y+1;
                    end
                end
                M=x/10^y;
                res=y;
            else
                while M^10/10^y>=10
                    y=y+1;
                end
                M=M^10/10^y;
                res=res+y/10^k;
            end
        end
    end


    Je supose qu'en MathLab la variable RES est retourné automatiquement a la fin de la methode
    0
  2. lefleau02 Messages postés 26 Statut Membre
     
    Petit essai de traduction en java

    public static double log10X(int x, int n) throws Exception
    {
         int y;
         double M=0;
         double res=0;
    
         if (x<=0 || n<0)  
              throw new Exception("Valeur fausse !");
         else
         {
              for(int k=0; k<n; k++)
              {
                  y=0;
                  if (k==0)
                  {
                       if (x<1)
                       {
                             while (x/10^(y-1)<10)
                             {
                                  y=y-1;
                              } //fin while
                        } // fin if
    
                        while (x/10^y>=10)
                        {
                             y=y+1;
                         } //fin while
                   } //fin if
                   
                  M=x/10^y;
                  res=y;
                  
                  else
                  {
                        while (M^10/10^y>=10)
                        {
                              y=y+1;
                         }// Fin while
    
                         M=M^10/10^y;
                         res=res+y/10^k;
                   }// Fin else
              }// Fin for
        } //fin else
    } //fin methode
    --
     La franchise ne consiste pas à dire tout ce que l'on pense, mais à penser tout ce que l'on dit.
    0
  3. Sacabouffe Messages postés 9427 Date d'inscription   Statut Membre Dernière intervention   1 863
     
    Il y a pas besoin de déclaration de type ou de dimension avec Matlab, c'est implicite.
    En fait clear c'était pour tout effacer au cas où les variables auraient été utilisés avant.
    C'est au moment où on met ces variables à 0 que Matlab leur donne un type.

    format long c'était pour régler l'affichage des nombres avec plus de décimales que le mode par défaut (qui doit être de 4).

    y est initialisé juste après l'entrée dans la boucle.

    Et une question : tu as mis k<n dans ton code, est-ce normal? Je dirais plutôt k<=n.

    Et sinon, ça marche?
    Moi c'est nickel...
    PS : si tu connais un moyen de compter les chiffres qui composent un nombre en java, ce serait plus simple pour calculer y
    PPS : c'est pas un algorithme qui prend 3 jours de calcul mais peut-être qu'en exploitant le fait que log10(x) = - log10(1/x) ça permet de simplifier un peu le programme et de gagner quelques microsecondes en ne considérant que le cas x>=1 et en ajoutant un moins pour x<1
    0
  4. lefleau02 Messages postés 26 Statut Membre
     
    Voila la methode en java qui marche super bien et en effet c'etait k<=net non k<n

    Par contre il y a une erreur sur un calcul que je ne comprend pas
    quand je fait log(3,3) le resultat est 0.47000000...003
    alors que pour les autres nombre sa marche nikel

    public static double log10X(int x, int n) throws Exception
    	{
    		int y;
        	double M=0;
        	double res=0;
    
        	if (x<=0 || n<0)
        		throw new Exception("Valeur fausse !");
         	else
        	{
         	     for(int k=0; k<=n; k++)
            	 {
                  	y=0;
                  	if (k==0)
                  	{
                       if (x<1)
                       {
                             while ((x/Math.pow(10.0, y-1))<10)
                             {
                                  y=y-1;
                             } //fin while
                        } // fin if
    					else
    					{
    						while ((x/Math.pow(10.0, y))>=10)
                        	{
                        	     y=y+1;
                        	} //fin while
                   		} //fin if
                   
                  		M=x/Math.pow(10.0, y);
                  		res=y;
                  	}
                  	else
                  	{
                  		while ((Math.pow(M, 10.0)/Math.pow(10.0, y))>=10)
                        {
                              y=y+1;
                         }// Fin while
    	
                    	     M=Math.pow(M, 10.0)/Math.pow(10.0, y);
                	         res=res+y/Math.pow(10.0, k);
            	       }// Fin else
            	  }// Fin for
        	} //fin else
        	System.out.println(res+"");
        	return res;
    	} //fin methode
    0
  5. Vous n’avez pas trouvé la réponse que vous recherchez ?

    Posez votre question
  6. Sacabouffe Messages postés 9427 Date d'inscription   Statut Membre Dernière intervention   1 863
     
    Je pense que le résultat que tu obtiens est plutôt 0.47700000...003 et vu où se trouve le 3 ça correspond vaisemblablement à l'erreur machine.
    0
  7. lefleau02 Messages postés 26 Statut Membre
     
    oui dsl jai fait une erreur en tapant le nombre
    donc comme l'erreur est du a la machine donc aucun moyen de corriger cela a par tronquer le nombre au moment de l'affichage ?
    0
  8. Sacabouffe Messages postés 9427 Date d'inscription   Statut Membre Dernière intervention   1 863
     
    Ben je vois que ça...
    0
  9. lefleau02 Messages postés 26 Statut Membre
     
    Bon j'ai changé un petit détail dans le code au lieu de m'arreter a k<=n je m'arrete a k<=n+1 car si on veux un resultat sur N decimal il nous faut calculer n+1 decimal pour que la nieme soit correcte et au moment de l'affichage on n'affiche le resultat que sur n decimal

    je metterrais au propre ma méthode et je la posterais
    En tout cas merci beaucoup pour ton aide
    0
  10. Sacabouffe Messages postés 9427 Date d'inscription   Statut Membre Dernière intervention   1 863
     
    De rien...
    0
  11. lefleau02 Messages postés 26 Statut Membre
     
    Voici un resumer de la solution comme j'avais promis de le faire

    Voici d'abort les deux fichier de demonstration
    Demo par ln
    Demo par log

    Ensuite l'inplémentation en mathLab (merci sacabouffe)
    function[res]=log10app(x,n)
    clear y; clear M; clear res;
    res=0; M=0;
    format long
    if (x<=0 || n<0)
        res='Erreur';
    else
        for k=0:n
            y=0;
            if k==0
                if x<1
                    while x/10^(y-1)<10
                        y=y-1;
                    end
                else
                    while x/10^y>=10
                        y=y+1;
                    end
                end
                M=x/10^y;
                res=y;
            else
                while M^10/10^y>=10
                    y=y+1;
                end
                M=M^10/10^y;
                res=res+y/10^k;
            end
        end
    end


    Et pour finir la traduction en Java
    import javax.swing.*;
    
    public class Log 
    {
         public static double log10X(long x, int n) throws Exception
         {
              // Utilisation du type double pour garder un maximum de precision lors du calcul
               double y;
               double M=0;
               double res=0;
    
               if (x<=0 || n<0)
               {
        	throw new Exception("La valeur de x est fausse !";
               }
              else
              {
                     for(int k=0; k<=n+1; k++) // Pour k decimal on calcul k+1 decimal pour plus de precision sur kieme decimal
                     {
                  	y=0;
                  	if (k==0)
                  	{
                       if (x<1)
                       {
                             while ((x/Math.pow(10.0, y-1))<10) // Math.pow calcul la puissance ici 10^y-1
                             {
                                  y=y-1;
                             } //fin while
                        } 
    	else
    	{
    	while ((x/Math.pow(10.0, y))>=10)
                        	{
                        	     y=y+1;
                        	} //fin while
                   } //fin if
                   
                  M=x/Math.pow(10.0, y);
                  res=y;
                  }
                  else
                  {
                  	while ((Math.pow(M, 10.0)/Math.pow(10.0, y))>=10)
                        {
                              y=y+1;
                         }// Fin while
    	
                        M=Math.pow(M, 10.0)/Math.pow(10.0, y);
                         res=(res+y/Math.pow(10.0, k));
                   }// Fin else
              }// Fin for
        } //fin else
        return res;
    } //fin methode
        
    
    //Petit bonus le calcul de log2X qui n'est autre qu'un reutilisation de log avec un changement de base
    public static double calculerLog2X(long x, int n) throws Exception
    {
        	String resTemp=log10X(x, n+1);
        	String resTemp1= log10X(2,n+1);
        	double res= logX/log2;
        	return res;
    }
        
        
    }
    


    Je tiens tout particulierement a remercier sacabouffe pour son aide et sa patience
    0
Précédent
  • 1
  • 2