web-dev-qa-db-fra.com

nième implémentation racine

Je travaille sur un moyen de calculer le nth racine d'un nombre. Cependant, j'ai des problèmes avec le nth racine des nombres négatifs.

La plupart des gens disent d'utiliser Math.pow(num, 1 / root), mais cela ne fonctionne pas pour les nombres négatifs.

J'ai essayé ceci:

public static double root(double num, double root) {
    if (num < 0) {
        return -Math.pow(Math.abs(num), (1 / root));
    }
    return Math.pow(num, 1.0 / root);
}

mais, cela ne fonctionne pas pour tous les nombres, car la racine peut être un nombre décimal. Par exemple, root(-26, 0.8) renvoie -58.71, mais il s'agit d'une entrée non valide. Cela donnera aussi la mauvaise réponse, même pour les racines. Par exemple, root(-2, 2) renvoie -1.41421, mais -2 n'a pas de racine carrée.

javamathnth-root
20
Will

Qu'essayez-vous de faire? Sauf si vous envisagez de gérer complètement et correctement les nombres complexes, vous ne pouvez pas prendre la nième racine d’un nombre négatif.

Par exemple, alors que (-8)^(1/3) a une branche principale de -2, les seules branches de (-4)^(1/2) sont 2i et -2i.

Pour gérer cela correctement, vous devez transformer le nombre en sa forme polaire, puis prendre la racine requise sous cette forme.

Donc, -8 est le nombre complexe 8*exp(i*pi). Les racines de 1/3 qui sont 2*exp(i*pi/3), 2*exp(i*pi) et 2*exp[i*(-pi)/3]. Ensuite, vous pouvez utiliser la formule de Moivre ' pour calculer les racines sous la forme a + bi.

9
QuantumMechanic

(num) ^ (1/root) est similaire à exp( (1/root) * log(num) ), vous pouvez donc le faire comme suit:

public static double root(double num, double root)
{
    return Math.pow(Math.E, Math.log(num)/root);
}
14
Eng.Fouad

Soit utilisez l’un des nombreux ensembles de nombres complexes disponibles sur Internet, soit convertissez votre numéro en une position rectangulaire sur le plan Argand, faites-le pivoter de l’angle approprié, comme indiqué par la racine, puis lisez-le en tant que paire (réelle, imaginaire). .

2
Ignacio Vazquez-Abrams

J'utilise la méthode ci-dessous. Peut-être que ce n'est pas le plus précis, mais cela fonctionne bien dans mon cas.

public double root(double num, double root) {
    double d = Math.pow(num, 1.0 / root);
    long rounded = Math.round(d);
    return Math.abs(rounded - d) < 0.00000000000001 ? rounded : d;
}
1
Pavel Kataykin

Je ne suis pas trop sûr du code exact, mais j'ajoute une instruction if supplémentaire pour préciser les racines paires. quelque chose le long des lignes de 

public static double root(double num, double root) {
    if (num < 0) {
        if(root%2==1) {
            return -Math.pow(Math.abs(num), (1 / root));
        }
    }
    return Math.pow(num, 1.0 / root);
}

Pas tout à fait sûr que cela fonctionnera avec votre autre code, mais j'espère que cela pourra vous aider

0
RandomHighShooler

Vous pourriez faire si (num <0) { retourne Math.abs (Math.pow (num, 1/racine)) } Ensuite, utilisez simplement '+ "i"' pour indiquer la valeur. Ou utilisez la valeur absolue pour les équations et, plus tard, le facteur positif/négatif et i si nécessaire. C'est ce qui a fonctionné pour moi.

0
user3312489
    public double root(double num, double root) {
        double y=1;
        double x;
        while(Math.pow(x, root) != num) {
            if(Math.pow(x, root) > num) {
                x=x-y;
                y=y/10;
            } else {
                x=x+y;
            }
        }
        return x;
    }

Cela devrait fonctionner correctement pour vous, même s'il n'est pas compact, il utilise aussi peu de fonctions mathématiques que possible. 

0
Alexis Labat