Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 3 sur 3

Discussion: Les vecteurs creux

  1. #1
    Invité de passage
    Femme Profil pro
    Étudiant
    Inscrit en
    juin 2012
    Messages
    6
    Détails du profil
    Informations personnelles :
    Sexe : Femme

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juin 2012
    Messages : 6
    Points : 1
    Points
    1

    Par défaut Les vecteurs creux

    Bonjour,

    Des vecteurs creux sont des vecteurs de grande taille avec beaucoup de coordonnées nulles. Par exemple V = (0, 0, 3.1, 0, 0, 4.2, 0, 0, 0, 0). On ne veut stocker que les infos non nulles, donc ici 3.1 et 4.2 ainsi que leur position.

    Il fallait definir un type vectcreu, j'ai donc fait :
    Code :
    1
    2
    3
    type couple ={place : int; composante:float}
    type vectcreu = {taille :int; position : couple list}
    Maintenant le problème c'est que je dois calculer la norme (sqrt(somme(coordonnées²))).
    J'ai fait :
    Code :
    1
    2
    3
    4
    5
    let rec calc l =
         match l with
         |[] -> 0.0
         |(i, v)::t -> sqrt (v*.v+.calc t);;
    Et ensuite :
    Code :
    1
    2
    3
    let norme v=
         calc v.position;;
    Cela ne fonctionne pas mais je ne vois pas pourquoi (je débute...).

    Merci pour votre aide.

  2. #2
    Membre Expert
    Inscrit en
    avril 2007
    Messages
    831
    Détails du profil
    Informations forums :
    Inscription : avril 2007
    Messages : 831
    Points : 1 009
    Points
    1 009

    Par défaut

    Dans ta fonction récursive, tu utilises les éléments comme des couples `int * float`, ce qui est incompatible avec la définition de type que tu donnes. Il faut que tu choisisses soit d'utiliser des couples ainsi, soit d'utiliser le type `couple` que tu as défini.

    Pour manipuler un type produit comme le type `couple` que tu as défini, tu peux utiliser
    Code :
    | c :: t -> ... c.place ... c.composante ...
    ou bien
    Code :
    | { place = i; composante = v } :: t -> .... i ... v ....
    Par ailleurs l'algorithme utilisé est faux, puisque tu prends la racine récursivement: si tu as une liste [(i1,v1); (i2,v2); (i3,v3)] tu vas calculer sqrt(v1^2 + sqrt(v2^2 + sqrt(v^3 + 0))), ce qui est faux.

  3. #3
    Invité de passage
    Femme Profil pro
    Étudiant
    Inscrit en
    juin 2012
    Messages
    6
    Détails du profil
    Informations personnelles :
    Sexe : Femme

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juin 2012
    Messages : 6
    Points : 1
    Points
    1

    Par défaut

    Ca marche! Merci.

    Finalement j'ai fait :

    Code :
    1
    2
    3
    4
    5
    let rec somme l =
       match l with
       |[] -> 0.0
       |{ place = i; composante = v } :: t -> v*.v+.somme t;;
    puis :

    Code :
    1
    2
    3
    let norme v=
       sqrt (somme v.position);;

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •