\documentclass[12pt,a4paper]{article}
\usepackage{multicol}
\usepackage[french]{babel}
\newfont{\mini}{cmssi10 scaled 480}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\def\euro{\mbox{\textsf{C}\kern -2.33em{\raise0.24ex\vbox{\small\it =}}}}
%%%%%%%%%%%%%%%%%%%%%%%%%%
\def\fin{\nolinebreak \raise-0.1em\hbox{$\Box$}}
\def\stackunder#1#2{\mathrel{\mathop{#2}\limits_{#1}}}
\def\dual{ ^{\rm v}}
\def\bidual{ ^{\rm vv}}
\def\primedual{ ^{\prime \rm v}}
\def\ideal{{\cal J}}
\def\LL{{\cal L}}
\def\max{{\cal M}}
\def\quot#1#2{\mbox{\raise 0.1cm\hbox{$#1$}{\big /}\raise -0.1cm\hbox{$#2$}}}
\def\danger{{\Large \bf
    $\bigtriangleup$}\kern-0.32cm\raise0.05cm\hbox{\small
    !}\kern0.32cm\lower0.05cm\hbox{}}
%%%%%%%
\newlength{\largeurtmp}
\def\rela{\settoheight{\largeurtmp}{Z}{\rm Z} \kern -0.6\largeurtmp
  \raise 0.05cm\hbox{\tiny{\it /}}\kern 0.6\largeurtmp}
\def\petitrela{\settoheight{\largeurtmp}{Z}{\rm Z} \kern -0.4\largeurtmp
  \raise 0.05cm\hbox{\tiny{\it /}}\kern 0.4\largeurtmp}
\def\petitcomplex{{
    \settoheight{\largeurtmp}{$_C$}{\rm C}\kern -\largeurtmp
    \rule{0.25pt}{1.3\largeurtmp}\kern \largeurtmp}}
\def\complex{{
    \settoheight{\largeurtmp}{Q}{\rm C}\kern -0.66\largeurtmp
    \rule{0.25pt}{0.9\largeurtmp}\kern 0.66\largeurtmp}}
\def\ratio{{
    \settoheight{\largeurtmp}{C}{\rm Q}\kern -0.75\largeurtmp
    \rule{0.25pt}{0.9\largeurtmp}\kern 0.75\largeurtmp}}
\def\petitratio{{
    \settoheight{\largeurtmp}{C}{\rm Q}\kern -0.6\largeurtmp
    \rule{0.25pt}{0.6\largeurtmp}\kern 0.6\largeurtmp}}
\newcommand{\proj}{{\rm I} \! {\rm P}}
\newcommand{\reel}{{\rm I} \! {\rm R}}
\newcommand{\Fp}{{\rm I} \! {\rm F}_p}
\newcommand{\nat}{{\rm I} \! {\rm N}}
%%%%%%%%%%%%%%%Debut de macros de fiches d'exos
%%les macros sont \exo, \qu, \quskip \squ \qusqu \qusquskip
\newcounter{exo}
\newcounter{question}
\newlength{\lng}
\newcounter{sousquestion}
\setcounter{exo}{1}
\def\exo{

  \bigskip
  \noindent{\bf Exercice
    \Roman{exo}:}\addtocounter{exo}{1}\setcounter{question}{0}\nopagebreak 

  }
\def\exotitre#1{

  \bigskip
  \noindent{\bf Exercice
    \Roman{exo}: #1}\addtocounter{exo}{1}\setcounter{question}{0}\nopagebreak 

  }
\def\qu{

  \addtocounter{question}{1}\arabic{question})
  \setcounter{sousquestion}{1} }
\def\quskip{

  \bigskip
  \qu}
\def\squ{

  \settowidth{\lng}{\arabic{question})
  }\hspace{\the\lng}\alph{sousquestion}) \addtocounter{sousquestion}{1}} 
\def\qusqu{\qu\nopagebreak \vskip -1\baselineskip \squ}
\def\qusquskip{\quskip\nopagebreak \vskip -1\baselineskip \squ}

%%reference pour exos,squ \`a placer avant la question, qu est a placer apres
\def\labelexo#1{\expandafter\edef\csname refexo#1\endcsname {\Roman{exo}}}
\def\refexo#1{\csname refexo#1\endcsname}
\def\labelqu#1{\expandafter\edef\csname refqu#1\endcsname {\arabic{question})}}
\def\refqu#1{\csname refqu#1\endcsname}
\def\labelsqu#1{\expandafter\edef\csname refsqu#1\endcsname
  {\arabic{question}\alph{sousquestion})}} 
\def\refsqu#1{\csname refsqu#1\endcsname}  

%%%%%%%%%%fin de macros fiche d'exos
%%macros taille page
\newlength{\elargir}
\setlength{\elargir}{2.5cm}
\addtolength{\leftmargin}{-\elargir}
%%\addtolength{\hoffset}{-\elargir}
\addtolength{\oddsidemargin}{-\elargir}
\addtolength{\evensidemargin}{-\elargir}
\addtolength{\elargir}{\elargir}
\addtolength{\textwidth}{\elargir}
\addtolength{\textheight}{13\baselineskip}
\topmargin=-5\baselineskip
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%        
\everymath={\displaystyle}
\begin{document}
\noindent{\bf Universit\'e de Paris 7 \hfill \framebox{\Large \bf
    \hspace{ 1cm} Aide m\'emoire\hspace{1cm}}\hfill   agreg 2011 (F.Han\footnote{http://www.math.jussieu.fr/$\sim$han/agreg})}\\
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\def\code#1{{\tt #1}}
%% 
\columnsep 0.7cm
\begin{multicols}{2}
\qu {\bf  Choisir sa configuration}

\danger Le jour de l'\'epreuve les valeurs par d\'efaut ne co\"\i ncidenront
pas forc\'ement avec vos pr\'ef\'erences. Au premier lancement on r\'epond \`a
quelques questions, on peut ensuite modifier/affiner ses choix dans le
menu \code{Cfg}. Puis Sauvez les gr\^ace au  menu. Il faut donc choisir
le mode xcas ou maple, et \'etudier la configuration du "cas" pour ne
pas mal interpr\'eter les r\'eponses.

NB: Sur une version 32 bits, il y a 2 modes pour la pr\'ecision o\`u les algorithmes
utilis\'es sont diff\'erents: moins de 14 chiffres, et plus de 15 chiffres. (Ex avec
10 chiffres, on travaille tout de m\^eme avec 14 m\^eme s'il n'y en a que 10 d'affich\'es).  
\qu {\bf Les  modes xcas et maple}

$i$ et $I$ d\'esignent le nombre complexe de carr\'e $-1$ selon le mode\footnote{en
  mode xcas si disable test i est d\'ecoch\'e, un $i$ dans une instruction de boucle
sera transform\'e en une variable avec un warning.}. Les
tableaux commencent \`a $0$ contre $1$, et le symbole \% 
est r\'eserv\'e aux objets modulaires pour xcas, alors qu'il repr\'esente le dernier
r\'esultat pour maple. Les symboles \verb/{ }/ servent en mode xcas pour regrouper
des intructions (par exemple boucle, fonction), alors qu'en mode maple ils sont
r\'eserv\'es pour d\'efinir un ensemble. Les commentaires sont \verb|//| resp
\verb|#|. L'instruction \code{subs} prend ses arguments dans des ordres
invers\'es. La lettre $e$ est reserv\'ee en mode xcas pour \code{exp(1)}, en mode
maple elle est libre. Pour evaluer une expression sans afficher en mode xcas on
termine par \code{:;} et en mode maple par \code{;}

Ensuite pour les boucles, procedures, ... les 2 syntaxes  fonctionnent souvent en mode
xcas, et celles qui n'utilisent pas de \verb/{}/ fonctionnent aussi en mode
maple.  

Pour faire des calculs modulaires de mani\`ere naturelle, et pour la documentation
je conseille vivement le mode xcas.

Pour la configuration du "cas", je conseille de:

\noindent{\sc cocher} \code{radians}, et de

\noindent{\sc d\'ecocher:} \code{approx}, \code{complex},
  \verb/Cmpx_var/, \code{Sqrt}. On travaillera ainsi en mode exact
  dans le corps engendr\'e par les coefficients de l'expression, alors
  que si l'on coche complex ou Sqrt, on rajoute $i$ et des racines
  carr\'ees ce qui ne permet pas par exemple une factorisation de
  polyn\^ome sur un corps prescrit.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 
\qu {\bf La langue}
  
\danger Certaines\footnote{non anglaises} instructions d\'ependent de la
langue. Par exemple en fran\c cais \code{afficher} sera synonyme de la fonction
\code{print} alors qu'en anglais 
cette commande ne sera pas d\'efinie. La langue peut \^etre r\'egl\'ee par d\'efaut avant
de lancer xcas selon votre environnement, sinon on peut aussi la modifier dans
le menu \verb/Cfg>index language/  
\qu {\bf  Racourcis claviers}
\begin{verbatim}
copier CTRL c 
coller: CTRL v et aussi CRTL y ou SHIFT ins
couper la selection: CTRL x
undo: CTRL z
couper ce qui suit: CTRL k (kill)
effacer toute la ligne: ECHAP
remonter/descendre dans l'historique:
CTRL fleche haut/bas
\end{verbatim}
Et pour ins\'erer une nouvelle entr\'ee, une partie graphique2D, une partie graphique3D, un
programme, un tableur:
\begin{center}
\code{ALT n}, \code{ALT g}, \code{ALT h}, \code{ALT p}, \code{ALT t}.  
  \end{center}%%
\qu {\bf Supprimer/copier/deplacer des lignes}

  Noircir les petis carr\'es portant le num\'ero
de la ligne en les selectionnant. On peut ensuite deplacer/coller en
positionnant la souris sur un autre carr\'e de ce type.
  %%%%%%%%%%%%%%%%%%%%%%%%%%% 

\qu {\bf Suites:} Pour cr\'eer  une suite d'objets s\'epar\'es par des virgules, on peut
utiliser:

\null\hfill\code{seq(trucdej,j=liste)}\hfill\null\\
Exemples:\\
\verb/seq(j^2,j=1..5);/\\
\verb/L:=[1,4,5,5,6,2];seq(j^2,j=L);/\\
\verb/A:=[seq(j^2,j=1..5)];A[3];/\\
pour aller de 2 en 2 avec une version r\'ecente on peut faire:
\verb/seq(j^2,j=1..5,2);/\\
\danger \code{seq} a de nombreuses syntaxes qui sont toutes valables que l'on
soit en mode xcas ou maple. Par exemple \verb/seq(j^2,j,1,4)/ est la syntaxe
dite TI et retournera \verb/[1,2,3,4]/ et non \verb/(1,2,3,4)/ comme les
prec\'edentes instructions. 
\qu {\bf Boucles:}
Pour for les deux styles (genre maple ou xcas) fonctionnent en mode xcas la
syntaxe est donc indiff\'erente tant que l'on respecte les caract\`eres r\'eserv\'es de
chaque mode.
\squ (comme dans maple)
\begin{center}
\verb/for j from 1 to 5 do tutu;toto; od/
\end{center}
(On peut remplacer \code{od}
par \code{end do} ou \code{end} ou \verb/end_for/ mais PAS
\verb/end_do/. On peut pr\'eciser le pas avec un \code{by} apr\`es le \code{to 5})
\squ (style xcas\footnote{Ne fonctionne pas en mode maple \`a cause des \{ })
\begin{center}
\verb/for(j:=1;j<=5;j++){toto;tutu}/
\end{center}
\squ (La syntaxe algorithmique est aussi support\'ee)
\begin{center}
\verb/pour j de 1 jusque 10 faire print(j) fpour/
\end{center}

\qu {\bf Tant que:}
\squ (uniquement en mode maple)
\begin{center}
  \verb/while j<5 do print(j);j:=j+3 end do/
\end{center}
\squ (style xcas)
\begin{center}
  \verb/while(j<5){print(j);j:=j+1}/
\end{center}
\squ (La syntaxe algorithmique est aussi support\'ee)
\begin{center}
\verb/j:=0;tantque j<10 faire j:=j+1; ftantque/
\end{center}
\qu {\bf Conditions:}
\squ (style maple)
\begin{center}
  \verb/if a=1 then print("a vaut 1\n"); fi/
\end{center}
On peut aussi faire:
\verb/if..then..else..fi/ et remplacer le \code{fi} par \verb/end if/,
ou bien \verb/end_if/ ou \code{end}
\squ (style xcas)
\begin{center}
  \verb/if (a=1){print("1")} else {print("non")}/
\end{center}
\squ (style algorithmique)
\begin{center}
  \verb/si a=1 alors print("1") sinon print("2") fsi/
\end{center}

\qu {\bf Tests:}
\squ (\`a la maple:)\\
\'egal, diff\'erent, inf\'erieur, inf\'erieur ou \'egal:
\begin{center}
\phantom{.}\hfill \code{=} \hfill  \verb/<>/ \hfill \code{<} \hfill
\code{<=} \hfill\null 
\end{center}
\squ (autre possibilit\'e:)\\
le test d\'egalit\'e est aussi \code{==}, celui de diff\'erence est aussi \code{!=}
xd\qu {\bf Op\'erateurs logiques:}\\
ou, et, n\'egation:
\squ (\`a la maple:) \code{or}, \code{and}, \code{not}
\squ Autre possibilit\'e:\hfill\verb/||/\hfill \verb/&&/ \hfill \verb/!/\hfill\null
\qu {\bf D\'efinition d'une fonction:}
\begin{center}
 \verb/f:=x->x^2+1;g:=(i0,j0)->i0*j0;/  
\end{center}
 on peut ensuite faire \code{f(y)}, ou
 \code{f(3)}.
 \qu {\bf Programme/proc\'edure:}
 \squ version maple:
  \verb/P:=proc(a,b)/\\
  \phantom{proc(a,b)}\vdots\\
  liste de ce que l'on veut retourner;\\
  \verb/end proc;/ \\
  \squ version xcas:\verb/P(a,b):={.......}/
\qu {\bf Tableaux, matrices, vecteur:}
\begin{center}
  \verb/matrix([[1,2],[3,4]]);/ \\ \verb/A:=[[1,2],[3,4]];/\\
    \verb/matrix(2,2,(i0,j0)->i0*j0);/
\end{center}
\danger Les coefficients commencent \`a 1 en mode maple, et \`a
0 en mode xcas. (\code{Matrix} n'existe pas utilisez \code{matrix}).
\squ op\'erations \'el\'ementaires:\\
\verb/A*A;A^2;/  \verb/A^(-1);inverse(A);/ 
\code{det(A);} \code{transpose(A);} \danger mais PAS: \verb/A.A/.

La  prem\`ere ligne de $A$ est obtenue avec: \code{A[1];} 
Les vecteurs sont en lignes: \verb/v:=[5,6];/ avec une certaine
souplesse pour le produit. Par exemple {\it produit
  scalaire} est juste \code{v*v}, $A(v)$ est \code{A*v;} et $^tv.A$
est \code{v*A }
\squ \danger\verb/A:=matrix(3,3)+1;/ ne fait pas comme sous maple. (1
n'est pas l'identit\'e mais la matrice de m\^eme taille avec des 1
partout. 
\qu {\bf Astuces:}
\squ Le resultat pr\'ec\'edent est obtenu par \code{ans()} ou \code{ans(-1)}. En
mode maple, le dernier resultat \'evalu\'e: \verb/ % / mais il doit souvent \^etre 
isol\'e par des espaces. Ex \verb/evalf( % );/
\squ \danger lorsque l'on ouvre une feuille contenant de la g\'eom\'etrie,
il vaut mieux faire un \code{Edit>Executer>Session} ou bien \code{F9} pour que tout
soit \'evalu\'e, sinon il y a un risque de plantage. 
\qu {\bf Calcul modulaire.}
En mode xcas, vous travaillez avec les fonctions usuelles car il y a des objets
modulaires. Ex \verb/P:=x^2+1%2;factor(P);/ ou bien \verb/A:=[[5,-2],[4,5]]%11/
ou bien \verb/A:=[[5%11,-2%11],[4%11,5%11]]/ alors on obtient son noyau par
\code{ker(A)} ou \code{nullspace(A)}.

Astuce: Si l'on a besoin de remonter un modulaire en un entier, alors on le passe modulo
z\'ero: Par exemple en mode xcas:\verb/a:=3%7;a%0;/


En mode {\sc Maple} on reste toujours dans $\rela$, il faut donc utiliser des
instruction particulieres que l'on devine souvent ainsi: Le nom de l'instruction
usuelle mais avec une majuscule. Ex:
\begin{center}
\verb/factor(P);Factor(P) mod 2;/   
\end{center}
(mais pour un noyau \code{Ker} n'existe pas, il faut savoir que sous maple c'est
aussi \code{Nullspace}.
On peut cependant  obtenir un objet modulaire bienque l'on soit en mode maple:
Le plus naturel est de passer temporairement\footnote{Soit par menu d\'eroulant,
  soit avec l'intruction maple\_mode} en mode xcas, de cr\'eer le 1 de
$\rela/N\rela$ puis de revenir en mode maple.

NB  pour relever un modulaire  en entier, on passe modulo $0$. 
\begin{verbatim}
  maple_mode(0); a:=1%2; b:=x^2+3%7;
  c:=b%0;maple_mode(1);
\end{verbatim}
on peut utiliser la fonction\footnote{qui n'a pas l'air document\'ee}
\code{makemod}:
\begin{center}
  \verb/a:=makemod(1,2); factor(x^2+a);/
\end{center}
o\`u bien via pari: On charge pari une fois pour toute avec \verb/pari();/, puis
on peut faire \verb/a:=Mod(1,2);/ et utiliser \code{a} dans xcas m\^eme si l'on
est en mode maple.

Exemples d'instructions tr\`es utiles en mode maple et inutiles sinon:
\begin{center}
  \code{Gcd}, \code{Gcdex}, \code{Rem(P,Q,x) mod 2;}, \code{Powmod(P,Q,x) mod 2;}
  \code{Nullspace(A) mod 2;} 
\end{center}
NB: xcas fait automatiquement  les puissances rapides si elles sont assez grandes. (\`a
partir de $2^{31}$? Attention autour de $2^{30}$ il ne le fait pas et ca peut
\^etre long ou poser probl\`eme, dans ce cas mieux vaut utiliser \code{powmod})  
\begin{center}
  \verb/7^(12^50) mod 101;/
\end{center}
(NB: sous le logiciel\footnote{et non sous xcas en mode maple} maple il faut
faire la subtilit\'e suivante: \verb/7&^(12^50) mod 101;/): 
\qu {\bf Cr\'eer une fonction \`a partir d'un symbole}
\begin{center}
  \verb/P:=x^2+1;/ \verb/f:=unapply(P,x);/ \code{f(3);}
\end{center}
On peut aussi {\bf substituer} une variable par quelque chose: utiliser \code{subs}
(\danger: l'ordre des arguments est different entre les modes xcas et maple) ou
\code{subst} qui lui se comporte toujours de la m\^eme mani\`ere en mode xcas et maple. 
\qu {\bf Obtenir une \'ecriture binaire;}
Par exemple, pour obtenir l'\'ecriture de 7 en base 2, on peut utiliser convert et
renverser l'ordre.
\begin{center}
  \verb/l:=convert(7,base,2);/ \code{v:=revlist(l);}
\end{center}
On veut parfois {\bf compl\'eter par des z\'eros} pour avoir une taille constante,
il suffit d'ajouter un vecteur nul de la taille totale voulue, par exemple:
\begin{center}
  \verb/v:=[1,2];v:=v+[0$5];/
\end{center}
donnera \code{[1,2,0,0,0]}. (\verb/0$5/ voulant dire $0$ r\'ep\'et\'e 5 fois.)
\qu {\bf Suites, listes, et ensembles}
Dans xcas les objets avec parenth\`eses sont \`a plat:
essayer: \code{eval((1,(2,3),3);} Ceux entre crochets n'y sont pas et
donnent la possibilit\'e de faire des listes de listes, c'est par
exemple le cas d'une matrice. Ex: \code{eval([1,[2,3],3]);}

Pour les ensembles, en mode maple les \verb/{}/ suffisent:
\verb/{1,2,3,3}/ . En mode xcas il faut un \%. Exemple: \verb/%{1,2,3,3%}/  

Astuce: On peut trier, selectionner des \'el\'ements avec une fonction de tri
arbitraire que l'on donne en argument. (cf \code{sort} et code{select}).
Par exemple pour trier la liste de vecteurs suivante selon leur premiere
coordonn\'ee: \code{l:=[[1,3],[2,5],[0,6]]} 
\code{sort(l,(x,y)->x[1]>=y[1]);} (En mode maple)
\qu Cr\'eer une fonction \`a partir d'un symb\^ole: la m\'ethode la plus fiable est
d'utiliser \code{unapply}. par exemple: \verb/P:=x^2+a;/
\code{f:=unapply(P,x);} On peut alors \'evaluer \code(f) 
\qu Pour les matrices par blocs, juxtaposition (\`a cot\'e ou en dessous) \'etudier:
matrices par blocs, blockmatrix, diag, augment, concat. On peut aussi faire des
matrices de permutation, (Cf \code{permutation}).
\qu {\bf G\'eom\'etrie}
On peut affecter \`a une variable un objet g\'eom\'etrique. Les points peuvent \^etre
donn\'es en coordonn\'ees, ou bien par leur affixe complexe.  (rappel: en mode
maple \code{I} est le nombre complexe, en mode xcas c'est \code{i}):
\begin{center}
  \code{d1:=droite(0,1-I);} \code{d2:=droite(x+y=0);} \code{P1:=point(1+I);}\\
   \verb/plotparam(cos(t)+I*sin(t),t=-2..2,tstep=0.01)/
\end{center}
Pour afficher le tout simultan\'ement: \code{d1,d2,P1;}

Pour afficher l'objet: objetgeo en changeant ses attributs:
\begin{center}
\verb/couleur(objetgeo,red+point_width_2+hidden_name);/
\end{center}
mais aussi de maniere globale on peut faire: \verb/couleur(hidden_name);/

Tout ceci peut maintenant \^etre obtenu par des exemples dans le menu "Graphic".\\
{\sc Astuces:} Le menu "Graphic" 

-La fonction "Attribut" du menu "Graphic" ins\`ere dans votre ligne de commande
les options d'affichages de votre obtjet g\'eom\'etrique que vous avez choisies \`a la
souris.

-On peut cliquer sur la petite ic\^one de couleur (souvent magenta) qui apparait
dans de nombreuses fonctions du menu "Graphic". (Ex:
Graphic\verb/>/Courbes\verb/>/plotparam)
\qu {\bf Stats}
Pour faire des stats sur la suite:  \verb/l:=[seq(rand(1001),n=1..100)];/ on
doit d'abord regrouper ses \'el\'ements en classes. Pour des classes de largeur
constante, on donne le debut de la premi\`ere classe (ici 0) et la largeur des
intervalles (ici 1001/5):
\begin{center}
  \verb| classes(l,0,1001/5)|, \verb|histogram(classes(l,0,1001/5));|
\end{center}
pour avoir juste les cardinaux des classes il vaut mieux \verb/diagramme_batons/


\vfill
\newpage

\end{multicols}



\end{document}


Dessins et r\'esultants: TP15 2009

geometrie: Attributs d'un objet:
Pour l'objet: objetgeo:


on peut faire des droites par 2 points (on donne leur coordonn\'ees, ou les
affixes)  ou en cartesien:

Ex




ln et log sont neperiens
exp(1) en mode maple il n'y a que ca?
e marche en mode xcas

histogram il faut creer des classes

pour initialiser rand executer srand

corps fini, factoriser: GF. pari factorff, ffinit, lift

pari()
P:=lift(ffinit(2,20,b))
GF(2,P,['b','G'])
pour recuperer les polymod:
redefinir le Mod de pari:
Ex:
Mod:=(u,v)->u ou??? (a adapter)
eval(factorff(Q,2,P))
rem Rem... en une autre variable





pour factoriser en flottants sur R (si case complexe decochee, meme si case
float decochee) 
factor(eqx,1.1);


input("texte court",a)
input(output("texte un peu plus long"),a)


NB: les matrices modulaires sont acceptees directement.