Bonjour,
Une personne saurait-elle m'aider s'il vous plaît, à faire une séquence qui pour un nombre donné n, renvoie sa décomposition décroissante en puissance de 2 selon les techniques de multiplication égyptienne..? ( Sous MAPLE )
Exemple :
n= 17
Décomposition:= 2^4+2^0
Autre exemple :
n = 43
Décomposition:= 2^5+2^3+2^1+2^0
t'est mignon. Mais indication:
si k est tel que
2^k <= n < 2^(k+1)
en prenant ln des membres, puis qu exprimer k en fonction de la partie entiere de quelque chose?
Bonjour,Envoyé par untruc
Merci pour cette remarque ; je vous retourne votre compliment, vous êtes fort mignon, mais j'ai du mal à saisir votre syntaxe, si vous pouviez parler une façon moins Nostradamusienne...?
Bonsoir,
Soient n le nombre en question et k le naturel (que tu cherches) tel que
Tu appliques le logarithme en base 2, ça donne
D'où
oùdésigne la fonction partie entière
http://fr.m.wikipedia.org/wiki/Partie_entière
Cordialement
Dernière modification par Gandhi33 ; 27/10/2014 à 19h56.
Bonsoir,Bonsoir,
Soient n le nombre en question et k le naturel (que tu cherches) tel que
Tu appliques le logarithme en base 2, ça donne
D'où
où
http://fr.m.wikipedia.org/wiki/Partie_entière
Cordialement
Merci Gandhi, mais la question de départ est comment faire une séquence sous MAPLE, qui puisse donner la décomposition de n en somme de puissance de 2, façon multiplication égyptienne.
ecoute, soit tu es en train de chercher la commande pour te donner le résultat , dans ce cas c'est http://www.maplesoft.com/support/hel...convert/binary
soit tu cherches à construire une boucle pour te sortir le résultat, mon idée est si je cherchais
alors
et du coup, j'ai le premier coeff, maintenant je mets n-2^k et je trouve le k' suivant etc...
à la fin j'ai n= 2^k + ...
mais probablement d'un point de vu informatique ce n'est pas acceptable. Probablement il y a des boucles plus astucieuses, qui donnent le résultat.
Dernière modification par untruc ; 27/10/2014 à 20h07.
ecoute, soit tu es en train de chercher la commande pour te donner le résultat , dans ce cas c'est http://www.maplesoft.com/support/hel...convert/binary
soit tu cherches à construire une boucle pour te sortir le résultat, mon idée est si je cherchais
alors
et du coup, j'ai le premier coeff, maintenant je mets n-2^k et je trouve le k' suivant etc...
à la fin j'ai n= 2^k + ...
mais probablement d'un point de vu informatique ce n'est pas acceptable. Probablement il y a des boucles plus astucieuses, qui donnent le résultat.
Je reprends le post :
(...) faire une séquence qui pour un nombre donné n, renvoie sa décomposition décroissante en puissance de 2 selon(..) ( Sous MAPLE )
Exemple :
n= 17
Décomposition:= 2^4+2^0
Autre exemple :
n = 43
Décomposition:= 2^5+2^3+2^1+2^0
Une SÉQUENCE, et non pas des commentaires sur ladite séquence...
Exemple de SEQUENCE MAPLE : ( Indicatrice d'euler )
============================== ========
>restart;
Euler := proc(n::nonnegint)
local i, p, phi;
phi := n;
p := 2;
for i from 2 while p<=n do
if n mod p = 0 then phi := phi*(1-1/p); end if;
p := ithprime(i);
end do;
phi;
end proc;
Euler(13);
============================== ========
On cherche donc une séquence, pas des commentaires qui tournent autour de la séquence, même si ces commentaires sont justes...
Pour info voici par exemple une autre SEQUENCE MAPLE qui donne la composition d'un nommbre n donné dans une base b :
============================== ====
restart;
decomp := proc (n, b) :
local q, r;
q, r := iquo(n, b), irem(n, b);
if q = 0 then [r] else [op(decomp(q, b)), r] end if end proc;
decomp(17, 2)
============================== ====
tout ce qui te restes à faire c'est d'ecrir une classe qui prend "n", et retourne "convert(n, base, 2)"
genre un truc du genre. Vu ce que tu mets, et n'ayant jamais utilisé maple de ma vie, je présume que c'est un truc du genre:
restart;
machin := proc (n) :
local truc;
truc := convert(n, base, 2);
end proc;
machin (17);
devrait de donner [1, 0 , 0, 1].
????????
" n'ayant jamais utilisé maple de ma vie"...
Je ne suis pas sûr de comprendre pourquoi alors, tous tes commentaires...???
Enfin bref, je cherche l'aide d'une personne qui se débrouille en MAPLE, non pas quelqu'un qui ne connaît même pas le logiciel et qui se permet de dire telle ou telle chose dessus...
J'ai commencé à faire comme ça mais il doit manquer plein de lignes, si qqn peut m'aider s'il vous plaît...
restart;
Decomposition:=proc(n)
local a,b,c:
a:=ln(n);
b:=round(a);
while (n- 2**a) > 0 do c:=(n- 2**a): od :
end proc:
Decomposition(17);
Même dans le peu de lignes que tu as écrit, il y a des problèmes. Déjà tu utilises a au lieu de b, ensuite tu ne réutilises pas c, tu ne décrémentes pas a (qui devrait être un b). Et une fois ces erreurs corrigées, il ne faut pas toujours faire c:=(c- 2**b), il faut donc faire un test
Dans l'idéal, avant de faire une implémentation, on écrit l'algorithme en pseudo code, ça permet de séparer les difficultés algorithmiques des difficultés techniques du langage (et accessoirement, ça permet à ceux qui ne peuvent/veulent pas se payer maple de participer)
laisse tomber, à supposer que l’écriture 11001 ne lui plait pas, il n'a qu'à trouver une fonction qui lui retourne les indices des termes non nuls d'un vecteur
alors si convert( machin ,base , 2)
lui retourne une liste. Il doit la transformer en vecteur grâce à http://www.maplesoft.com/support/hel...nvert%2Fvector
bidulevecteur = convert (trucliste, vector)
avant de sortir l'equivalent du find dans matlab:http://www.maplesoft.com/support/hel...ls/SearchArray soit
SearchArray (bidulevecteur)
à moins que dans ce langage inutile de maple, un vecteur n'est pas une array.
Si la question ne veut pas qu'il utilise des fonctions prédéfinies, alors, en y réflechissant, j'ai l'impression que la boucle est encore plus élémentaire:
--------------------------
int n;
j=0;
int m=n;
int k;
tant que(m !=0){
_____k= m Modulo 2;
_____si (k != 0){
__________ print j;}
_____ m:= (int) (m-k)/2;
_____ j:=j+1;
}
-----------------------
normalement, je pense que ca doit imprimer les puissances j, de la décomposition n= somme 2^j.
mais peut etre j'ai pas fait attention à quelque chose.
Sinon, basiquement, il suffit d'utiliser cette méthode :
27:2=13reste1
13:2=6 reste1
6 :2=3 reste0
3 :2=1 reste1
1 :2=0 reste1
Le nombre 27 est donc
En fait il faut lire les restes, le seul problème mais qui n'en est pas un est que c'est dans l'ordre croissant
il lui faut la SEQUENCE maple. KappaHD
Bonjour,
J'arrive vraiment pas à cerner votre démarche...
Alors on vous demande un chat, et vous donnez une litière...
@untruc, tes commentaires sont redondants et nébuleux : " laisse tomber, à supposer que l’écriture 11001 ne lui plait pas "
À la base il faut une SÉQUENCE MAPLE, pas seulement des discours, justes ou non, de x et y autour de la séquence ou une écriture "11001"...
D'autant plus que tu dis ne rien connaître de MAPLE, alors pourquoi s'acharner...??
Pourtant l'intitulé du post est précis ; voici encore un exemple de séquence MAPLE, en rapport avec le post, bien que bourré d'erreurs...
Alors ceux qui voient les erreurs sans pouvoir proposer une séquence opérationnelle, à quoi bon...?? :
============================
restart;
Decomposition:=proc(n)
local a,b,c:
a:=ln(n);
b:=round(a);
while (n- 2**a) > 0 do c:=(n- 2**a): od :
end proc:
Decomposition(17);
============================
Merci de proposer des choses CONCRÉTES...
Guimzo,
si je comprends bien, tu demandes aux intervenants de faire ton travail ! Ce qui contrevient aux règles de ce forum.
Plusieurs intervenants ont essayé de t'aider en te proposant des façons de faire ton travail. Mais comme tu passes ton temps à écrire des textes Maple sans avoir réfléchi à ce que tu veux faire faire au programme, tu n'avances pas. Et tu peux continuer longtemps ...
Il n'y a évidemment aucun intérêt à parler de ce que tu viens de proposer, qu' n'a pas de vrai rapport au sujet (Tu l'as mis pour faire beau ?).
Il te suffit de faire le travail à la main sur des nombres pas trop grands, genre 117, 83, 204, pour voir ce que tu peux faire faire à Maple (il y a plusieurs méthodes).
Cordialement.
Sauf qu'on n'est pas là pour te faire tes devoir, mais pour t'aider à les faire... La nuance est sensible. et te donner la réponse entre dans la première catégorie
Je t'ai donné des indications sur certaines choses qui n'allaient pas, et tu n'as même pas pris la peine de corriger ces problèmes
edit : grillé
elles sont CONCRETES! tu as un code quasi clair sur une boucle qui ressemble à 2 gouttes d'eau à ce que Gandhi te dis. Tout ce que t'as à faire est de la traduire en langage maple.
pour cette boucle, les langages Matlab, Maple, c++, java, algol, sont similaires.
soit l'autre solution CONCRETE, que je t'ai donné aussi, est d'utiliser des fonctions prédéfinies par MAPLE.
Une simple recherche dans l'aide de MAPLE, m'a permis d'identifier que l'equivalent de "de2bi" et "find" sous Matlab, sont "convert" et "SearchArray".
toi, tu veux une solution toute faite, que tu recopies. Mais quel intérêt?
Bonjour,
Je demande à personne de faire le "devoir" sans rien faire ; ce que je demande aux participants, c'est d'éviter les commentaires redondants qui n'apportent rien de concret...
Bien sûr que je sais que pour trouver la décomposition d'un nombre selon les termes du post il faudrait faire ainsi :
Soit n le nombre de départ :
1.On calcule log2(n)
2.On arrondit log2(n) à sa partie entière.
3. On fait la soustraction, de (n - log2(n) )
4. Si (n - log2(n) ) = 0 alors c'est fini.
5. Si (n - log2(n) ) > 0 alors on recommence 1.
5.On a donc décomposer notre nombre n en somme de puissance de 2.
6. Ordonner ces résultats, avec sortie MAPLE de la forme : "Decomposition(n) : = 2^n+2^a+2^b.....
Donc oui, je comprends bien ce qu'il faut faire théoriquement, mais je ne demande pas comme le fait par exemple @untruc, de me répéter mille fois, qu'i faudrait faire ci ou ça sans rien proposer de CONCRET. ( D'autant plus qu'il dit qu'il ne connaît même pas MAPLE... alors à quoi bon ..??? Si vous n'êtes pas mécanicien, et en plus que vous ne connaissez même pas une voiture, vous n'allez quand même pas dire à votre voisin qui a sa voiture en panne, qu'il faudrait faire ci ou ça ! )
Cordialement
J'ai refait de cette façon, mais toujours plein de choses à rectifier, les commentaires concrets sont les bienvenus :
============================== =
restart;
Decomposition := proc (n):
local a,b,c:
a:=evalf(log[2](n)):
b:=floor(a):
c:=n-2^(b):
if c:=0 then print(c) else do a:
end if: end do:
end proc:
Decomposition(7);
============================== =
Dernière modification par Guimzo ; 28/10/2014 à 12h50.
Bonjour,
J'ai beaucoup de mal à cerner ta pédagogie...
Presque pareil que @untruc, faire ci ou faire ça, mais concrètement..?
Je reprends l'exemple du voisin qui a sa voiture en panne ; si t'es mécanicien automobile, et que ton voisin te demande de l'aider à réparer son kit de distribution, tu ne vas quand même pas lui dire, qu'en fait il faut retirer l'ancien et acheter un autre !
Non, mais aider c'est parfois montrer comment faire une chose étape par étape et expliquer le cas échéant ce que l'on fait précisément.
J'ai refait comme ça, mais le probléme c'est que ça ne fonctionne qu'avec des multiples des nombres 2^n :
=========================
restart;
Decomposition := proc (n)
local a, b, c;
a := evalf(log[2](n));
b := floor(a);
c := n-2^b;
if c = 0 then print(Decomposition = 2 puissance(b))
end if:
end proc:
Decomposition(16);
=========================
Bonjour Guimzo,
Si vous ne modifiez pas rapidement votre façon peu aimable de répondre à des gens qui passent du temps, voire le perdent, à vous répondre, ce fil sera fermé sans autre préavis.
Médiat, pour la modération
Je suis Charlie.
J'affirme péremptoirement que toute affirmation péremptoire est fausse
Bonjour Media,
Est-ce que j'ai écrit des propos vulgaires qui mériteraient de supprimer cette discussion...?
Expliquez-moi s'il vous plaît Monsieur
Cordialement,
Je n'ai pas écrit "vulgaire", j'ai écrit "peu aimable" !
Je suis Charlie.
J'affirme péremptoirement que toute affirmation péremptoire est fausse
Bonjour Media,
Effectivement, vous avez parlé de "peu aimable" et non pas de "vulgaire". C.Q.F.D.
De même si vous relisez les messages dans la discussion, vous verrez que c'est exactement la même chose que je ne comprends pas chez certains, on leur parle d'une chose, et eux vous parlent d'une autre chose, en particulier @untruc ; j'ai parlé de "MAPLE" et lui il avoue qu'il ne connaît absolument pas Maple mais il me parle de "MATLAB" etc...
D'autre part, j'ai trouvé sa façon de répondre peu respectueuse ; ce que vous pouvez vérifier par vous-même :
post N°2, @Untruc pour répondre me dit d'emblée "t'es mignon..." etc etc
post N°4 @Gandhi33 qui me renvoie à un article de wikipédia qui n'a rien à voir avec Maple...
post N°9 @untruc, qui répond de façon très légère, pour qui la séquence se résume à : " machin truc proc.... etc decomposition truc machin..."
Donc peut-être qu'il serait également utile de demander aux intervenants, de faire preuve d'amabilité, vis à vis de ceux qui postent des discussions, et de ne pas "agresser" les autres s'ils ne veulent pas eux-mêmes se voir "agresser"
Cordialement
Pour faire bonne figure, je m'excuse si j'ai pu blesser quiconque, et pourquoi ne pas repartir sur de meilleures bases...
Alors la discussion il s'agit de construire une séquence MAPLE qui permet de décomposer un nombre n donné en somme décroissante unique de puissance de 2.
Exemple :
17 = 2^4+2^0
Autre exemple :
592 = 2^9+2^6+2^4
Je précise que je manipule Maple avec beaucoup de lacunes, j'ai encore plein de choses à apprendre vis à vis des séquences, donc si une personne qui s'y connaît, peut m'aider, en m'expliquant étape par étape, une séquence possible qui répondrait au probléme, avec des exemples concrets, ce serait une vraie pédagogie ; car parfois aider, c'est montrer comment faire une chose, en expliquant ce que l'on fait...
Voici ce que j'ai déjà fait, mais le probléme c'est que je ne vois pas comment inclure l'instruction "ELSE" afin que la séquence soit opérationnelle :
============================== =========
restart;
Decomposition := proc (n)
local a, b, c;
a := evalf(log[2](n));
b := floor(a);
c := n-2^b;
if c = 0 then print(Decomposition = 2 puissance(b))
end if:
end proc:
Decomposition(16);
============================== =========
Cordialement
Essaye plutôt de commencer par écrire l'algorithme en pseudo-code précisément avant de chercher à faire l'implémentation sous maple. En effet, tu semble avoir des difficultés et en maple et en algorithmique : découper le problème en deux me semble une bonne idée.
Ici, si on reprends ton ébauche que tu as donnée plus haut :
On remarque qu'il y a une boucle, on peut donc commencer par là. Réecrit proprement avec une boucle, et en corrigeant le test (n- log2(n) n'est pas ce que tu veux faire) ça donne :Code:1.On calcule log2(n) 2.On arrondit log2(n) à sa partie entière. 3. On fait la soustraction, de (n - log2(n) ) 4. Si (n - log2(n) ) = 0 alors c'est fini. 5. Si (n - log2(n) ) > 0 alors on recommence 1.
Est ce que tu as compris jusqu'ici?Code:c=n Tant que c > 0 faire a = log2(c) b = floor(a) afficher( "2^" b " " ) c = c-2^b fin tant que
Si oui, essaye d'implémenter cet algorithme en maple, ça devrait être relativement transparent
Bonjour @Tryss
Voilà ce que j'ai fait avec ton exemple de code :
=====================
restart;
Dec := proc (n)
local a, b, c;
c := n;
while 0 < c do a := log[2](c):
b := floor(a):
print("2^"*b*" ");
c := c-2^b :
end do:
end proc:
Dec(16);
=========================
Cela ne fonctionne pas, donc si tu peux expliquer s'il te plaît le pourquoi du comment, montrer et expliquer la bonne formulation, ce serait aussi bien
Merci
