Pour rappel, la méthode de cardan est une procédure qui permet de calculer de manière formelle les racines d'un polynôme de degré 3.
Je l'ai implémentée en java, j'ai fait quelques test et visiblement ça fonctionne correctement. Je le poste ici, sans explications particulière (la documentation est disponible sur le net) mais ça peut servir à certains.

Code:


public static double cardanRestricted(double p,double q)
   {
      double root = 0.0;
      double delta = sqr(q) + (4.0*cube(p))/(27.0);
      if(delta < 0.0)
      {
         double rho = Math.sqrt(sqr(q)-delta)/2.0;
         double teta = Math.acos(-q/(2.0*rho));
         root = 2.0*root3(rho)*Math.cos(teta/3.0);
      }
      else if(delta == 0.0)
         root = root3(-4.0*q);
      else
         root = root3((-q+Math.sqrt(delta))/2.0) + root3((-q-Math.sqrt(delta))/2.0);
      
      return root;
   }
   
   public static double cardan(double a,double b,double c,double d)
   {
      double p = c/a - sqr(b)/(3.0*sqr(a));
      double q = (2.0*cube(b))/(27.0*cube(a)) - (b*c)/(3.0*sqr(a)) + d/a;
      
      return cardanRestricted(p,q) - b/(3.0*a);
   }


Pour rappel: cube(d) = d*d*d ; sqr(d) = d*d ; sqrt(d) = d

Je n'ai pas encore fait de JAVA, mais ça n'a pas l'air d'être trop compliqué après avoir fait du C !

Merci le_duche

Le java n'est carrément pas plus compliqué que le C++ il est simplement mieux adapté à l'objet, et plus lent... à vous de voir ce que vous privilégiez

Personnellement je suis pas trop fan du java. Il y a plein de petits trucs qu'on ne peut pas faire et qui seraient pourtant bien pratiques, comme surdéfinir les opérateurs, avoir une commande swap pour les objets,...

Par contre, Eclipse c'est de la balle !

le_duche a écrit:Par contre, Eclipse c'est de la balle !

Ben je l'utilise en C même si à l'origine si pour JAVA et j'avoue que c'est super bien fait et pratique, notamment avec le serveur CVS !

le_duche a écrit:Personnellement je suis pas trop fan du java. Il y a plein de petits trucs qu'on ne peut pas faire et qui seraient pourtant bien pratiques, comme surdéfinir les opérateurs, avoir une commande swap pour les objets,...

On ne dit pas qu'on n'aime pas, quand on n'a pas gouté. De même, on ne dit pas qu'on ne peut pas quand on ne sait pas. Je suppose que tu veux parler de redéfinir des opérateurs (puisque surdéfinir n'existe pas en C++ non plus) et bien on peut. Il suffit d'extends la classe contenant ta méthode et tu la redéfinies. Quand au swap, il est fait automatiquement, par ce qu'on apelle le garbage collector. Dès que tu ne te sers plus d'un objet il est garbage collecté

le_duche a écrit:
Par contre, Eclipse c'est de la balle !

Totalement d'accord , vraiment trop puissant...

julien a écrit:Ben je l'utilise en C même si à l'origine si pour JAVA et j'avoue que
c'est super bien fait et pratique, notamment avec le serveur CVS !

CVS est un peu dépassé maintenant, et même s'il s'utilise encore dans des applications en localou sur serveur local (ce qui revient au même au final), il est vraiment beaucoup moins puissant que le SVN. Ce dernier fournie plus de retour avec de la doc et tout. Il est également plus accessible, et gère mieux les conflits

Voilà pour les quelques précisions sur le Java

A plus

Oui il parait que SVN est encore mieux que le CVS mais je n'ai jamais essayé encore... mais si tu le dis !

morice.net a écrit:On ne dit pas qu'on n'aime pas, quand on n'a pas gouté. De même, on ne dit pas qu'on ne peut pas quand on ne sait pas. Je suppose que tu veux parler de redéfinir des opérateurs (puisque surdéfinir n'existe pas en C++ non plus) et bien on peut. Il suffit d'extends la classe contenant ta méthode et tu la redéfinies. Quand au swap, il est fait automatiquement, par ce qu'on apelle le garbage collector. Dès que tu ne te sers plus d'un objet il est garbage collecté

J'ai un projet de 20.000 lignes de code derrière moi, simulant un réseau de trafic aérien. En gros j'ai touché à peu près à tous les aspects de java, et on est 6 programmeurs du même avis, java c'est super chiant tu fais pas ce que tu veux. Et non on ne peut pas directement surdéfinir les opérateurs puisqu'ils sont hardcodés dans le compilateur java. Ou alors, tu as un compilateur qui te le permet, mais dans le java pur, ça n'est pas permis.
Et on parle bien de surdéfinir les opérateurs lorsque le type des paramètres change (par exemple définir une somme entre deux objet de type matrice). La redéfinition c'est lorsque les types ne changent pas et qu'on écrase l'ancienne méthode pour en faire une nouvelle plus adaptée.

Et puisque visiblement tu as oublié ce qu'est un swap, en voici un sur les doubles en c++:

Code:

void swap(double& a,double& b)
{
   double c = a;
   a = b;
   b = c;
}

Et je sais très bien ce qu'est un garbage collector, j'ai un deux cours de compilation, et j'y ai utilisé plus de 10 langages différents...

En effet, j'ai complètement confondu le swap avec autres choses : la suppression(delete en C++). J'en suis désolé.
Néanmoins je ne vois pas en quoi le swap n'est pas faisable en java ...

Essaye, les objets ont beau être passés par adresse, quand tu sors de ta fonction ils n'ont pas changé. (je parle bien des objets, pas de types de base)

Code:


public class Test {
    private String text;

    public Test(String text) {
        super();
        this.text = text;
    }

    public String toString() {
        return text;
    }
}
public class Main {
    public static void main(String[] args) {
       
        Test t1 = new Test("t1");
        Test t2 = new Test("t2");
       
        System.out.println(t1);
        System.out.println(t2);

        Test c = new Test("");
        c = t1;
        t1 = t2;
        t2 = c;

        System.out.println(t1);
        System.out.println(t2);
    }
}


Chez moi ça marche très, et je ne pense pas avoir de compilateur spécial.

Au fait, pour les opérateurs, je suis d'accord avec toi en fin de compte. Néanmoins, il suffit de créer la méthode add dans ta définition de matrices, et ce sera parait :

Code:


mat = mat1.add(mat2);
// au lieu de
mat = mat1 + mat2;


Je trouve que ce n'est pas très génant...

Comme ça oui évidemment !
Mais si tu mets tes trois lignes de swap dans une méthode, ça n'est plus possible.
Il n'est pas possible de faire une procédure swap.

D'accord je vois ce dont tu veux parler... java étant un langage par passge de valeurs, c'est impossible de manière directe. voici une (petite) ruse qui te permet de le faire...

Code:


public class TestSwap {
    private String str;

    public TestSwap(String str) {
        this.str = str;
    }

    public void print() {
        System.out.println("This is " + str);
    }

    public static void swap(Object[] objA, Object[] objB) {
        Object temp = objA[0];
        objA[0] = objB[0];
        objB[0] = temp;
    }

    public static void main(String[] args) {
        TestSwap[] tsA = { new TestSwap("A") };
        TestSwap[] tsB = { new TestSwap("B") };
        swap(tsA, tsB);
        tsA[0].print();
        tsB[0].print();
    }
}


Donc, on peut tout faire, mais faut s'adapter au langage et pas essayer de copié le C++, parce qu'ils sont tout de même différent

A plus

C'est assez laid

Disons que je n'essaye pas de copier le c++, mais quand t'as une centaine de swap à faire dans ton code, ce serait plus pratique d'avoir une procédure, plutot que se taper les 3 lignes à chaque fois.