Problème de définition d'une variable de type float

Bonjour,
J'essaie de réaliser une petite application 3D utilisant OpenGL, mais je pense que mon problème ne vient pas de là.
Je pense que le plus simple est que je vous donne mes sources. J'utilise Dev C++.
Dans "void Solid::init()", si je définis mon vecteur w par: "w.def(0.0,0.0,0.0)", mon cube s'affiche correctement. Par contre, dès que je met "w.def(0.1,0.1,0.1)", cela ne fonctionne plus!
J'ai déjà eu des problèmes précédemment en utilisant les floats dans mes calculs: j'avais des expression du type: 1/2*a (a étant une variable de type float), et j'ai trouvé qu'il fallait les remplacer par 0.5*a (par exemple), pour que les problèmes de définition du type float.
Dans mon problème donc, j'essaie de faire un debug, et je constate que w n'est pas définit correctement: x=-1#INF, y=-1#INF, z=-nan(0xc00000).
J'ai beau chercher, je ne comprends pas d'où vient mon erreur. J'ai pourtant fait attention à déclarer toutes mes variables de type long double, et à remplacer les 1, 0, 1/2 etc par des 1.0, 0.0, 0.5...

Merci d'avance pour votre aide!

Voici le code (j'en ai supprimé une bonne partie comme on me l'a demandé)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
class Vect {
    public:
        long double x,y,z; // Composantes du vecteur
        void def(long double cx,long double cy,long double cz); // Définition des composantes
        long double norm(); // Norme du vecteur (longueur)
};
void Vect::def(long double cx,long double cy,long double cz) {
    x=cx;y=cy;z=cz;
}
long double Vect::norm() {
    return sqrt(carre(x)+carre(y)+ carre(z));
}
class Solid {
    public:
        void init(); // Initialisation de l'objet
        void main(); // Gestion de l'objet à chaque boucle
        void display(); // Affichage de l'objet
        void calc_ext(); // Calcul de la résultante et du moment des forces extérieures
        void move(); // Calcul la nouvelle position
        long double m; // Masse
        Vect j; // Opérateur d'inertie diagonalisé (composantes de la diagonale)
        Vect v; // Vitesse de l'objet
        Vect g; // Centre de gravite
        Vect w; // Vecteur rotation
        Vect4 q; // Quaternion
        Matrix p; // Matrice de passage du ref galileen dans le repere lie au solide
        Force forces[FORCES_MAX]; // Liste des forces appliquées au solide
        Vect forcext; // Résultante des forces extérieures (point d'application=centre de gravite du solide)
        Vect momext; // Moment résultant des forces extérieures par rapport au centre de gravite
}
void Solid::init() {
    m=0.28; // masse
    g.def(0.0,0.0,0.0); // Centre de gravite initial
    w.def(0.1,0.1,0.1); // Vecteur rotation initial
    v.def(0.0,0.0,0.0); // Vitesse initiale
    j.def(2.23,2.23,0.00016); // Opérateur d'inertie
    // Forces initiales
    for (int i=0;i<FORCES_MAX;i++) {
        forces[i].f.def(0.0,0.0,0.0);
        forces[i].p.def(0.0,0.0,0.0);
    }
    // Matrice de passage initiale
    p.def(1.0, 0.0, 0.0,
          0.0, 0.7, -0.7,
          0.0, 0.7, 0.7);
    q.def(q0,q1,q2,q3);
}
 
}
void Solid::move() {
    // Translation
    g=vectplus(multscalvect(carre(dt)*m,forcext),vectplus(g,multscalvect(dt,v)));
    v=vectplus(multscalvect(dt/m,forcext),v);
    // Rotation
        // Recherche du vecteur rotation
    long double a[3][3]={{j.x/dt,0.5*(j.z-j.y),-(momext.x+w.x/dt)},
                   {j.y/dt,0.5*(j.x-j.z),-(momext.y+w.y/dt)},
                   {j.z/dt,0.5*(j.y-j.x),-(momext.z+w.z/dt)}};
    Vect delta;delta.def(5.0,5.0,5.0);
        w=vectplus(w,delta);
    }
}