Calcul symbolique : Leçon 6
Patterns

Compléments sur les fonctions

Comment enregistrer les valeurs d’une fonction

F1[n_]:=If[n<2,1,F1[n-1]+F1[n-2]]
Table[F1[n],{n,0,10}]

F2[0]=1
F2[1]=1
F2[n_]:=F2[n-1]+F2[n-2]
Table[F2[n],{n,0,10}]

Trace[F1[3]]
Trace[F2[3]]

Trace[F[1]]

F[2]
f[2]

??f

??F

somme=Function[{x,y},x+y];
somme2[x_,y_]:=x+y

somme[2,3]
somme[a,b]

Fonctions anonymes

(#^2 & ) [3]

On a donc plusieurs façons de calculer la liste des carres des premiers entiers

Map[(#^2 & ),Range[10]]
Map[f,Range[10]]
Map[F,Range[10]]
Range[10]^2 (* La fonction ^est Listable*)

(#1^2 + #2^2 & )[3, 5]

Exercice : Ecrire une fonction qui retourne la somme des carrés d’une liste (en 1 ligne)

Exercice : Ecrire une fonction qui retourne la longueur d’une ligne brisée, définie par une liste de points (en dimension 2). Par exemple, LongueurLigne[{0,0},{0,1},{1,1},{1,0},{0,0}] doit retourner 4 tandis que LongueurLigne[{0,0},{1,1}] retourne (Sqrt[2])

Struture d’une expression

A=1+(x-1)/(x^2+1)

FullForm[A]
TreeForm[A]

FullForm[Range[4]]
TreeForm[Range[4]]
TreeForm[Partition[Range[6],2]]

TreeForm[F]

Head[F]
Head[A]
Head[Range[4]]
Head[4]
Head[Pi]

A
A[[2,1]]

Apply[List,A]

Selection

Select[Range[100],PrimeQ]

Exercice : Ecrire un prédicat qui teste si un nombre entier est somme de deux carrés non nuls. Trouver tous les nombres inférieurs à 100 qui sont somme de deux carrés.  Trouver ceux qui sont en plus premiers.

Même fonction PrimeSumOfSquare2Q  sachant que :
Théorème. Soit p un nombre premier. Alors p est somme de deux carrés si et seulement si p = 2 ou p ≡ 1 (mod 4). Comparez les temps d’exécution des deux méthodes.

ListPlot[{Table[Timing[Select[Range[10n],PrimeSumOfSquareQ]][[1]],{n,1,200}],Table[Timing[Select[Range[10n],PrimeSumOfSquare2Q]][[1]],{n,1,200}]}]

Remplacement

ReplaceAll[Expand[(1+x)^4],x->a]

Expand[(1+x)^4]/.x^2->a

Exercice: Crible d’Erathostnène

Cherchez cet algorithme sur le web et programmez le

Exercice: Nombres parfaits

Cherchez la définition  sur le web et programmez la fonction correspondants

Exercice: Nombres amicaux

Cherchez la définition  sur le web et programmez la fonction correspondants

Thread, Nest, NestList, Fold ...

Clear[f]

Thread[f[{a,b,c},{1,2,3}]]
Thread[f[a,{1,2,3}]]
Thread[f[{a,b,c},1]]

On peut utiliser Thread pour programmer un peu différemment la fonction LongueurLigne

LongueurSegment[A_,B_]:=Sqrt[Total[(B-A)^2]]
LongueurLigne3[listepoints_]:=Thread[LongueurSegment,Drop[listepoints,1],Drop[listepoints,-1]]

LongueurLigne[{{0,0},{1,1}}]
LongueurLigne[{{0,0},{1,0},{1,1},{1,0},{0,0}}]

Nest[f,a,5]
NestList[f,a,5]

Fold[f,x,{1,2,3}]
Fold[Times,1,{a,b,c,d}]
FoldList[f,x,{1,2,3}]
FoldList[Times,1,{a,b,c,d}]

Inner et Outer

Clear[f]

Inner[f,{a,b},{x,y},g]

Outer[f,{a,b},{x,y,z}]

On peut  aussi reprogrammer LongueurLigne à l’aide de Inner, mais la gestion de listes imbriquées n’est pas simple ... Essayez, je suis curieux de voir une solution simple.