Bonsoir,

Je ne sais pas trop quel est le language utilisé sous Maple, mais en gros le principe c'est de diviser successivement par tous les nombres premiers.

En gros tu commences par diviser ton nombre par 2. Si le résultat de la division est un nombre entier, ça signifie que ton nombre est divisible par 2. Tu affiches donc 2.
Tu continue à diviser par 2 et afficher 2 tant que ton nombre est divisible par 2.
Lorsqu'il n'est plus divisible par 2, tu passes à 3 puis 5 etc ...

Certes mais encore faut-il faire un prog pour obtenir la liste des nombres premiers dans ce cas...


Maple ne fait pas ça tout seul ??

Non, pas forcement, déjà à partir de 3 on peut aller de 2 en 2, et ensuite, on affichera par exemple jamais 10 comme diviseur car on aura divisé auparavant par 2 et par 5.

Maintenant c'est sur que c'est pas le programme le plus rapide du marché mais bon, ça n'est pas le but je pense ..

bonsoir
non en effet, pour un programme comme ca je ne recherche pas la rapidité..
que pensez vous de cet algo : (en fait je cherche a obtenir les p_i et les n_i pour pouvoir les réutiliser après)
a est donné
p:=2
while a 1 do
   if a modulo p =0
   then (n:=n+1 & a:=a/p)
   else p:=p+1
  end if
end while

cepandant il me manque les commandes qui sortent les p_i et les n_i...

Je viens de regarder le language Maple, et les end if et end while n'existe pas, il faut mettre fi et od .

Le problème là, c'est que par exemple si ton nombre est divisible 3 fois par 2 ( exemple 8), tu tu va faire afficher 2 et 4 comme nombre premier.

Pour les pi et les ni tout dépend ce que tu compte fait, les ni ce sont els exposant et les pi les nombres premiers ?

Je pense que faut les stocker dans un tableau, je vais voir ça comme ça march esous Maple

Bonsoir,

au pire tu fais juste un petit prog avant estpremier et tu rajoutes un test.

Je capte pas le rapport avec ce qu'il veut faire, Cauchy ?

le test isprime existe sous maple mais dans le cas présent vu que je ne recherche pas la rapidité (c'est le résultat qui m'intéresse et je n'ai pas tro le temp de me pencher sur l'efficaité du prog) ca ne ferai qu'alourdir le programme.

et sinon, comment fait-on pour rappeler ce programe dans un autre? y a t-il une commande? les pi sont les premier et les ni sont les puissance.

pour cauchy : mon but est de retrouver le programme qui a permis de trouver les listes en page 7.

Les listes en page 7 ?

http://www.emis.de/journals/JIS/VOL6/Ufnarovski/ufnarovski.pdf
voir ce doc.

Rouliane c'etait pour ne regarder que les diviseurs premiers en fait je sais pas si j'ai bien compris c'est quand tu as dis ca:

non, en effet. en page 7 ce sont tout les nombres"a" pour qui l'équation n'=a n'a pas de solution. puis il donne la liste du nombres de primitives d'un nombre donné.

c bon pour la fonction qui me permet de rapeller le programme, il faut utiliser des procédure.. et j'ai compri comment on fait.

Pour ton programme sinon, voici une idée même si la synthaxe n'est peut-etre par correcte car je ne connais pas trop maple :

dfp:=proc(a)
k:=-1;
P=array(1..a);
N=array(1..a);

for i from 2 to a do
P[i]:=0;
N[i]:=0;
od;

for i from 2 to sqrt(b) do
if (a mod i)=0 then
   k:=k+1;
   while ( a mod i) =0 do
         p[k]=i;
         N[k]=N[k]+1;
         a:=a/i;
   od;
od;
od;
k:=k+1;
P[k]=a;
N[k]=1;
end;



voilà, avec ça tu devrais pouvoir stocker tes valeurs de n et p

Une petite explication :

ok je comprend tout ca mais je vois cependant pas l'utilité d'initialiser k à -1.

dans un tableau P, le premier élément est P[0], le deuxième P[1] etc ...
J'initialise k à -1 parce que des que je rentre dans la boucle if, j'incrémente de 1  ( afin d'enregistrer le premier nombre premier dans P[0], le deuxième dans P[1] etc ... )

ok d'accord merci des explications.

de rien

teste le pour voir si ça marche, parce que y'aura de toute façon des erreur

> dfp2:=proc(a)
> k:=-1;a1:=a;
> P:=array(1..a);N:=array(1..a);
> for i from 2 to a do
> P[i]:=0;
> N[i]:=0;
> od;
> for i from 2 to sqrt(a1) do
> if (a1 mod i)=0 then
>    k:=k+1;
>    while a1 mod i=0 do
>       P[k]=i:
>       N[k]=N[k]+1:
>       a1:=a1/i:
>    od:
> fi:
> do:
> k:=k+1;
> P[k]=a;
> N[k]=1;
> end:


Warning, premature end of input

voic ce que j'ai tapé ce qui est en gras c'est ce que maple me dit...

il fallait mettre a en variable local, sinon maple nous insulte dès qu'on veut toucher à a..

c'est un point virgule à la fin de end , non ?

le ; veut dire en maple "affiche" et : signifie "enregitre mais n'affiche pas"  mais j'ai qd meme testé a tout hasard mais ca ne marche quand meme pas.

j'ai trouvé, t'as mis un do au lieu d'un od à la fin

ok c'étai ca!

mais maintenat il di ca:
> dfp2(78);
>
>
Error, (in dfp2) final value in for loop must be numeric or character

essaye de remplacer sqrt(a1) par a1 au début de la boucle for

j'ai trouvé, tu dois remplacer sqrt(a1) par evalf(sqrt(a1))

evalf((sqrt(a1))

> dfp2(78);
>
>
Error, (in dfp2) 1st index, 0, smaller than lower array bound 1

on a ca maintenant...

ok, initialise k à 0 au début et pas -1, car apparemment sous maple les indices des tableaux commencent à 1

ok donc ya un pb : je renvoi tout :

> dfp2:=proc(a)
> k:=0;a1:=a;
> P:=array(1..a);N:=array(1..a);
> for i from 2 to a do
> P[i]:=0;
> N[i]:=0;
> od;
> for i from 2 to evalf(sqrt(a1)) do
> if (a1 mod i)=0 then
>    k:=k+1;
>    while a1 mod i=0 do
>       P[k]=i:
>       N[k]=N[k]+1:
>       a1:=a1/i:
>    od:
> fi:
> od:
> k:=k+1;
> P[k]=a;
> N[k]=1;
> end:

>
>
>
>
Warning, `k` is implicitly declared local to procedure `dfp2`

Warning, `a1` is implicitly declared local to procedure `dfp2`

Warning, `P` is implicitly declared local to procedure `dfp2`

Warning, `N` is implicitly declared local to procedure `dfp2`

Warning, `i` is implicitly declared local to procedure `dfp2`

> dfp2(78);
>
>

                                0 = 1

je ne compren pas le résultat...

déjà met des ; au lieu des :

ensuite, c'est bizarre parce qu'il ne devrai rien afficher.

lance le programme pour une valeur petite (genre 10 )
et afficher ensuite [N1] et P[1]

> dfp2:=proc(a)
> k:=0;a1:=a;
> P:=array(1..a);N:=array(1..a);
> for i from 2 to a do
> P[i]:=0;
> N[i]:=0;
> od;
> for i from 2 to evalf(sqrt(a1)) do
> if (a1 mod i)=0 then
>    k:=k+1;
>    while a1 mod i=0 do
>       P[k]:=i;
>       N[k]:=N[k]+1;
>       a1:=a1/i;
>    od;
> fi;
> od;
> k:=k+1;
> P[k]=a;
> N[k]=1;
> end:

>
>
>
>
Warning, `k` is implicitly declared local to procedure `dfp2`

Warning, `a1` is implicitly declared local to procedure `dfp2`

Warning, `P` is implicitly declared local to procedure `dfp2`

Warning, `N` is implicitly declared local to procedure `dfp2`

Warning, `i` is implicitly declared local to procedure `dfp2`

> dfp2(10);
> P[1];
> N[1];

                                0 = 1


                                 P[1]


                                 N[1]

voici ce que ca donne. je n'y comprend plus rien!!

je crois avoir trouvé :

remplace " if (a1 mod i)=0 then " par " if evalb((a1 mod i)=0)=true then "

pareil dans le while

non ca donne la meme chose... dsl

tu peux recopier ton code ici stp

> dfp2:=proc(a)
> k:=0;a1:=a;
> P:=array(1..a);N:=array(1..a);
> for i from 2 to a do
> P[i]:=0;
> N[i]:=0;
> od;
> for i from 2 to evalf(sqrt(a1)) do
> if evalb((a1 mod i)=0)=true then
>    k:=k+1;
>    while evalb(a1 mod i=0)=true do
>       P[k]:=i;
>       N[k]:=N[k]+1;
>       a1:=a1/i;
>    od;
> fi;
> od;
> k:=k+1;
> P[k]=a;
> N[k]=1;
> end:

>
>
>
>
`Warning, \`k\` is implicitly declared local to procedure \`dfp2\`\n`
`Warning, \`a1\` is implicitly declared local to procedure \`dfp2\`\n`
`Warning, \`P\` is implicitly declared local to procedure \`dfp2\`\n`
`Warning, \`N\` is implicitly declared local to procedure \`dfp2\`\n`
`Warning, \`i\` is implicitly declared local to procedure \`dfp2\`\n`
> dfp2(10);
> P[1];
> N[1];

                                0 = 1


                                 P[1]


                                 N[1]

Copie que cette partie là ( en rajoutant le end à la fin )

> dfp2:=proc(a)
> k:=0;a1:=a;
> P:=array(1..a);N:=array(1..a);
> for i from 2 to a do
> P[i]:=0;
> N[i]:=0;
> od;

puis tappe P[1] pour savoir ce que ça donne

dfp3:=proc(a)
>  k:=0;a1:=a;
>  P:=array(1..a);N:=array(1..a);
>  for i from 2 to a do
>  P[i]:=0;
>  N[i]:=0;
>  od;
> end:Warning, `k` is implicitly declared local to procedure `dfp3`

Warning, `a1` is implicitly declared local to procedure `dfp3`

Warning, `P` is implicitly declared local to procedure `dfp3`

Warning, `N` is implicitly declared local to procedure `dfp3`

Warning, `i` is implicitly declared local to procedure `dfp3`

> dfp3(10);

                                  0

> P[1];
>
>

                                 P[1]

je n'arrive vraiment pas a saisir pourquoi il renvoi "P[1]" comme ca!!

ca a peut etre aucun rapport mais
si N entier ^^

ifactor(N);

donne ce que tu cherches

Apres peut etre que tu dois faire un projet...

bonsoir suistrop euh plutot bonjour,
ici N et P sont des tableaux de valeurs....

y'a un truc qui m'intrigues dans ton programme, c'est que tu ne devrais pas avoir de < devant chaque ligne, mais uniquement devant la 1ere ligne il me semble

oui je sais c'est le copié collé de maple a firefox qui les rajoute. ca n'y est pas dans maple....

si tu as un < devant chaque ligne, chaque ligne est pour lui un nouveau programme, donc quand t'écris P[1] pour l'ordi t'a pas défini P[1] enfin je pense

ah ok désolé...

vincprof
salut
je vais peut etre te faire repété mais j ai pas compris ce que tu cherchais a faire :$
j ai lu le truc en anglais du charabia...

remplace a par a1 dans les 'array' et à la fin, juste avant le end, mets un RETURN ( P[1]);