Maple

Cette partie présente quelques algorithmes écrits en langage Maple.

Tout d’abord un grand remerciement à  A.L.S. professeur agrégé de Mathématiques en retraite, qui est d’une générosité
qui inspire le respect, qui possède une connaissance phénoménale du logiciel Maple et qui m’a écrit les algorithmes.

Je vous invite vivement, pour toutes questions sur Maple à  visiter son site à  l’adresse suivante :

http://alamanya.free.fr/

 

Commandes élémentaires Maple

Quelques Algorithmes Maple

 Résolution d’un ensemble d’équations.

eq1:=x+y=p:
eq2:=x-y=q:
solve({eq1,eq2},{x,y});

  

Élimine les doublons d’une liste L.

elimine_doublons:=proc(L::list(integer))
local M;
M:=convert(L,set);
sort(convert(M,list)):
end proc:
elimine_doublons([15,2,3,1,7,3,1,5,5,12,7]);


Renvoyer les nombres premiers d’une liste.

  for k in [31,39,47,105] do
if isprime(k) then print(k,`est premier`) end if:
end do;

  
Trouver les nombres se terminant par un chiffre donné, dans une Liste.

  L := [1419, 5541, 745, 47419, 88520, 8819]:
finissant_par:=proc(L::list(posint), n::nonnegint)
local k,F:
F:=NULL:
for k to nops(L) do
if L[k] mod 10 = n then F:=F,L[k] fi:
od:
[F]:
end proc:
finissant_par(L,9);

 

Calculer le quotient et le reste d’une division euclidienne.

divise:=proc(a,b)
local r,q:
r:=a : q:=0 :
while r>=b do r:=r-b : q:=q+1 : od :
print(reste = r);
print(quotient = q);
end:
divise(2537,17);

  
Indicatrice d’Euler.

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);

 

L’inverse de l’écriture décimale d’un nombre.

f := proc(n)
local nombre, inverse :
nombre := n;
inverse := 0;
while nombre > 0 do
inverse := 10*inverse + irem(nombre,10);
nombre:=iquo(nombre,10);
od;
inverse
end:
‘f(1260)’=f(1260);

  
Convertir un ensemble “e” en somme ou produit.

convert(e,`+`);
convert(e,`*`);

Décomposition d’un nombre donné p, en somme de puissance de a.

DECOMPOSITION:=proc(a::nonnegint, b::posint)
local d,q,k;
d := NULL;
q := a;
k :=-1;
while q > 0 do
k:=k+1:
if (q mod b)>0 then d :=  (q mod b)*cat(b,`^`,k), d fi;
q := floor(q / b);
od:
return [d],print(nops([d]))
end proc:
DECOMPOSITION(255,2);

  
Décomposition d’un nombre en différence de puissance de 2.

DECOMP_DIFF := proc (a::nonnegint)
local d, q, k, z:
z := NULL;
q := a;
k := -1;
while 0 < q do k := k+1;
if 0 = `mod`(q, 2) then z := k, z end if;
q := floor((1/2)*q) end do;
d := cat(2, `^`, k+1);
for k in [z] do d := d, -cat(2, `^`, k) end do;
d := d, -cat(2, `^`, 0);
return [d], print(nops([d])) end proc:
DECOMP_DIFF(2537);

Conjecture de Collatz ou Syracuse.

restart;
Collatz := proc (n::posint)
if type(n, even) then (1/2)*n:
else 3*n+1 :
end if :
end proc:
iteratecollatz := proc (n::posint)
local c, s:
c := n:
s := c:
while 1 < c do c := Collatz(c):
s := s, c end do:
[s] end proc:
iteratecollatz(2537);

   
 Factoriser un nombre semi-premier dont les facteurs sont proches ( voire jumeaux ).

  restart;
  Digits := 200;
  p := 2537;
  p1 := length(p);
  N := 2*sqrt(p);
  M := p-2*sqrt(p);
  M1 := evalf(M);
  P := trunc(M1);
  Q := M1-P;
  s := [seq(f+Q, f = 0 .. 10^3)]:
  t := [evalf(seq(N+u, u = s))]:
  T := {seq(round(i), i = t)}:
  for g in T do r := (g+sqrt(g^2-4*p))*(1/2):
  if type(r, integer) then print(" ! PREMIER NOMBRE ENTIER TROUVÉ..! ");
  print("TERMINÉ r =", r);
  break end if end do:
  R := evalf(3*sqrt(p)/sqrt(2)):
  U := frac(R):
  s := [seq(f+U, f = 0 .. 10^3)]:
  t := [evalf(seq(R-u, u = s))]:
  T := {seq(round(i), i = t)}:
  for g in T do r := (g+sqrt(g^2-4*p))*(1/2):
  if type(r, integer) then print(" ! PREMIER NOMBRE ENTIER TROUVÉ...!");
  print("TERMINÉ r =", r);
  break end if end do:
 

Somme des décimales d’un nombre.

 somme_dec := proc (nb::posint, n::posint)
 local k, l, s, t :
 l := evalf(floor(log10(nb)));
 if n > l+1 then error "bad second argument" fi:
 s := [seq(floor(nb/10^(l-d)), d = 0 .. n-1)];
 t := s[1]:
 for k from 2 to nops(s) do t := t, s[k]-10*s[k-1] od:
 convert([t], `+`);
 end proc:
 somme_dec(2537, 3);

Décomposition d'un nombre en somme de 5 carrés.

  decomp := proc (n) 
  local i, j, k, l, m, a, s:
  a := {seq(k, k = 0 .. 12)};
  s := NULL:
  for i to nops(a) do
  for j to nops(a) do
  for k to nops(a) do 
  for l to nops(a) do
  for m to nops(a) do
  if (i-j)*(i-k)*(i-l)*(i-m)*(j-k)*(j-l)*(j-m)*(k-l)*(k-m)*(l-m) ≠ 0 
  and n = a[i]^2+a[j]^2+a[k]^2+a[l]^2+a[m]^2
  then s := s, sort([a[i], a[j], a[k], a[l], a[m]]);
  end if;
  od;od;od;od;od; 
  convert([s], set);
  end proc:
  decomp(247);

Transcrire un nombre dans une base donnée.

 restart;
Digits:=1000;
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);

Liste nombres premiers

restart;
Digits:=1000;
L:=[ ]:
for k from 1 to 100 do if isprime(k)
then L := [op(L),k] fi od ;
L := L;