Bonjour, quelqu'un connaitrait il un librairie sur les matrices mais que les matrices soient toujours modulo un nombre. J'ai trouver plusieur librairie mais toutes donne des nombres à virgule lors de certain calcul. Merci de votre réponse

??????
t'as qu'à changer le paramètre template en int si c'est ça que tu veux
sinon y a plus que tout chez boost

une matrice modulo un nombre ?

oui, que tout les nombres dans la matrice soit modulo un nombre.

ben tu fais une classe qui planque un entier et fais de l'arithmétique comme il faut. en template le plus possible et tout bien inliné pour que ça soit le moins pénalisnat possible.

par definition qu'un nombre soit modulo un nombre ca ve rien dire, tu veux dire qu'il soit divisible sans doute ? travail sur des entiers alors

ben avec ton joli x86, tu utilises l'algèbre modulo 2**32

mais moi je voit pas ou est le probleme, ca doit ressembler a quoi sa matrice a part un simple matrice d'entier?

nan il veut definir des matrices dans des corps quotients je pense, donc autant travailler avec des entiers tout betes encapsules dans une classe et redefinir les relations d'egalite et de comparaison

ben il veut juste que chaque a(i,j) € [0:n[

ok

Oui c'est sa que je voudrais.
vu qu'apparement, personne ne connait de librairie qui prend sa en compte, j'essaye de faire ma propre classe mais j'ai un petit problème.
 
La parti privée de ma classe est :

 
Après, je remplis toutes les cases de mon tableau 3x3 avec la valeur 15 (par exemple). Le problème c'est que si j'essaye d'afficher la case 5x5 de mon tableau, cela m'affiche 15 alors que je n'ai rempli cette case avec aucune valeur et cette case ne devrait meme pas existé. Je me demande si c'est pas "int mat[][];" de la partie privée qui pose problème. Et si c'est sa, comment puis je faire pour declarer un tableau dans la parti privée sans connaitre sa taille.
 
   Merci de votre réponse

c'est nul comme ça
 
utilise une bibliothèque de matrice déjà tout prête genre celle de boost
 
et après
 
boost::matrix< MonEntierModule<15> > m
 
et c'est parti

edit : ok j'ai rien dit
 
c'est standard ca boost ?

ok mais j'aimerais au moins comprendre pourquoi sa bug si possible. C'est possible de mettre un tableau en privée sans indiquer le nombre de ligne et de colonne ?

non. un tableau a par définition un taille fixe connue à la compilation

a ce moment la c'est pas un tableau

pourtant ma classe passait sans probleme à la compil. Si c'est pas un tableau c'est quoi alors "int mat[][];" ?

rien, ça n'existe pas

 
C'est l'équivalent de int** mat;
 
Si tu as "rempli ton tableau", comme tu dis, tu as en fait juste réalisé un bel écrasement d'une zone mémoire que tu n'as pas allouée préalablement avec un new.
Du coup, quand tu fait mat[5][5], pour le compilo, ça ne veut strictement rien dire.

 
si ça ne veut strictement rien dire, il fait comment pour le compiler ? je suppose que ça veut dire d'aller lire à l'adresse mat[5]+5*sizeof(int) et que mat[5] est l'adresse contenue à l'emplacement mat+5, nan ? au final, vu que rien n'a été initialisé, c vrai que ça veut pas dire grand chose, mais ce que je comprend pas, c'est qu'il dit que ça lui renvoie 15 comme valeur, bizar, non ?

non, c'est juste indéfini.
et je vois pas ou est le problème : le compilateur connait toutes les dimensions et le type, quand tu lui dit mat[5][5], c'est bon. mais faut que ça soit un tableau évidemment. donc si mat un int**, le compilateur n'a pas les dimensions, il ne sait pas quoi faire. là tu as du bol parce que sizeof(int) == sizeof(int*) et tu pars pas trop loin dans le décors
 
mais je crois que t'as oublié qu'int** ça veut dire un pointeur de pointeur. tu a donc N pointeurs vers des int. au total, si t'as matrice fais N*M, tu as N*M int + N int* alors qu'avec un tableau, tout est contigu, tu as alors N*M int et c'est tout

ben c'est ce que je dis : quand il fais mat[5][5], ça va voir le 5eme élément du tableau pointé par le 5eme élément de mat... sauf que le 5eme élément de mat (qui est un pointeur sur un tableau d'entiers) n'est pas initialisé, donc logiquement, ça devrait envoyer loin dans le décor... et sûrement pas vers un tableau dont le 5eme élément est en entier dont la valeur est 15...

 
Pas tout-à-fait. L'adresse de mat[5][5] est plutôt :
&mat[0] + 5*"premiere dimension du tableau"*sizeof(int) + 5*sizeof(int)
Je suppose que le compilo considère que cette dimension vaut 0, et donc il ressortirait l'équivalent de mat[0][5].
A vérifier, je dis peut-être une grosse connerie.

Je pense qu'au lieu de faire toute une théorie, il serait pas mal de lui donner une réponse pour l'aider.
 
Il peut le faire sa matrice en utilisant int** tab
puis quand il la crée, il fait les new adéquats.
 
Ou sinon autre possibilité créer un nouveau type : int_mod
qui prends en private
int nbre;
int modulo;
 
puis il faut redefinr les operateurs et enfin il peut travailler simplement avec son nouveau type et faire un simple tableau int_mod** tab
 

...

Merci pour le nul, je ne cherchais qu'a donner une autre solution.

si t'es pas capable de coder MonEntierModule<15>, je vois mal comment tu vas coder une matrice

Tu ne sais pas ce que je suis ou non capable de programmer alors ne te permets pas de juger.
 
Tu sors un truc comme ca boost::matrix< MonEntierModule<15> > m  
sans plus d'explications.
 
La méthode que je donnais peut donner de bons résultats sans avoir à utiliser une librairie que l'on n'a jamais utilisé.

ta méthode est loin d'être souple ...
et ma solution n'a pas donné lieu à des questions.
 
tu débarques sans rien avoir lu et nous explique qu'il faut 2 membres, un pointeur de pointeur en nous détaillant même le private. c'est trivial. ton intervention est louche
 
 
et le nul, parlons en : lui apprendre à coder MonEntierModule<N> sera très facile, mais réaliser une bonne classe de matrice sera très dur. je sais pas ce que vous avez avec le C++ putain : c'est le seul langage ou tout le monde fait chier à vouloir utiliser aucune bibliothèque. n'importe ou ailleurs, vous feriez carrément frapper à ne pas utiliser la bibliothèque. ou peut être que vous auriez une attitude plus positive du genre "ouah, cette bibli est très bien faite et documentée, merci du conseil". STL est standard et boost est de la même qualité et présente beaucoup de fonctionnalités qu'on retrouvera dans la future version de STL. mais non, vous voulez pas, et après j'ai droit à des "nous prends pas pour des cons"
 
bien savoir programmer, c'est savoir utiliser et réutiliser. Passer son temps sur des structures de données définies et codées depuis des années est vain.
 
l'intéressant du problème ici, c'est une classe d'arithmétique modulaire, pas la matrice

 
C'est bien mon idée de faire une classe d'entiers modulo.
Avec surcharge des operateurs. pour la somme, on retourne le reste de la division euclidienne de la somme des 2 nombres par le modulo, on fait ensuite pareil pour les autres operateurs.
 
Je ne trouve pas ca lourd que de faire son propre type, ensuite il peut le modifier et ajouter des fonctionnalités facilement.
 
Utiliser une lib ok c'est bien mais a la compil et en taille ca alourdie pour n'utiliser que peu de choses dans la lib.
 
Utiliser une commande donnée sans plus d'explication va prendre pas mal de temps a voir tout ce qui s'y rattache.
 
Si le gars veut faire une matrice de nombres avec modulo, il doit bien savoir faire une classe.
 
La richesse des débats est que différentes solutions peuvent être proposées.

en quoi les templates ça alourdie ? en quoi c'est mal de prendre les devant en faisant du template ?
 
le fait est que c'est la même solution. et je doute que le gars sache faire une classe justement. Quand bien même il saurait la faire, il vaudrait mieux utiliser boost

OK tant pis je laisse tombé, tes explications sont tellement éloquentes que j'avais même pas vu que tu utilisais des Templates.

boost::matrix< MonEntierModule<15> >
 
ça ressemble à quoi d'autres ?

Bon je vais essayer une dernière fois de t'expliquer.
C'est pas parce que tu connais bien un peu toutes les libs et pleins d'autre choses en prog et que t'es un bon habitué de ce forum que nous devons comprendre tout à fait ce que tu cherches à nous dire avec seulement une ligne sans rien en plus.
 
Non seulement, tu pourrais expliquer ou plcer cette ligne, mais aussi à quoi elle se rapporte, qu'est ce qu'elle retourne et comment elle marche.
Deux trois phrases d'explications valent mieux que dix messages qui répètent la même chose.
 
C'est tout.|

peut être que tu pourrais le demander si tu comprends pas ? une page plus tard, je comprends que t'avais même pas compris ce que j'avais proposé. je suis pas devin. suffit de demander
 
1) pas besoin de recoder la classe matrix : celle de boost est très bien faite. Elle est template
2) comme elle est template, on va pouvoir l'utiliser avec le type qu'on souhaite (et pas comme l'autre qui se retrouve avec des chiffres après la virgule, il a tout coder en dur, il devra tout recoder. Donc une classe MonEnterModulo
3) et soyons un peu fou, faisont de l'opérande droite du modulo un argument template, MonEntierModulo<n>
 
et voilà

Moi je pense que les gens qui viennent sur ce forum ne font pas forcément des programmes dont le but est d'être finis le plus rapidement et le plus proprement proprement possible. Je pense que la plupart d'entre eux programmes des choses pour apprendre à les programmer, pour comprendre comment ça marche au niveaux les plus primitifs. Et dans ce cas, utiliser des librairies dans tous les sens ou repomper du code n'est pas du tout la bonne solution. Donc en particulier, plutot que de dire fait "boost::matrix<MonEntierModule<15>>", il faudrait expliquer, donner des pistes, mettre sur la voie, mais sans donner forcément une solution à copier/coller sans comprendre d'où elle vient... surtout quand on voir que le niveau de mifinoufou en prog C++ n'a pas l'air géant.

moi je pense que si quelqu'un est capable de poser une question, il peut en poser deux. ce que je retiens de ce topic, c'est que mifinoufou s'en fout

Taz un peu de politesse et de courtoisies ne serraient pas du superflu.
Tu te permets trop facilement de juger.
 
La personne peut avoir différentes raisons de ne pas avoir répondu, elle a oublié d'activer la notification par email, elle n'a plus d'ordi ou le net ou je ne sais quoi encore.
 
Ta manière sèche de répondre ne donne pas envie de poser une autre question.

je juge rien. C'est toi qui pinaille parce que t'as pas compris ce que j'ai proposé, mais tu l'as réalisé trop tard. Si t'as des questions, je suis là. Si tu veux pas t'améliorer ou apprendre, t'as plus rien à dire