Point sur un objet géométrique : element

### 10.8.14 Point sur un objet géométrique : `element`

`element` peut avoir différents types d’arguments :

- un intervalle a..b et deux réels la valeur et le pas (par défaut la valeur vaut (a+b)/2 et le pas (b−a)/100), par exemple, `t:=element(0..pi)` ou `t:=element(0..pi,pi/2)` ou `t:=element(0..pi,pi/2,pi/100.0)` signifie que `t` peut prendre une valeur quelconque de l’intervalle [0;π] et le deuxième argument π/2 donne la valeur qui définit `t` : cela a pour effet d’avoir en haut et à droite un curseur noté `t` que l’on peut faire bouger à la souris de 0 à π, avec à gauche de ce curseur un nombre égal à la valeur de `t` du curseur.
- un objet géométrique et un réel (par défaut ce réel vaut 1/2), par exemple, `A:=element(cercle(0,2),1)` signifie que `A` se trouve sur le cercle de centre 0 et de rayon 2 et a comme affixe 2*exp(i) (car 2*exp(i*t) est l’équation paramétrique du cercle(0,2) et le deuxième argument 1 donne la valeur du paramètre t pour définir `A`). Par exemple, `A:=element(cercle(0,1))` signifie que `A` se trouve sur le cercle de centre 0 et de rayon 1, le point `A` sera tracé en prenant t=1/2 comme valeur du paramètre de l’équation paramétrique de l’objet géométrique (ici `affixe(A)`= 2*exp(i/2)). Lorsque ensuite on déplacera `A` avec la souris, `A` se déplacera sur l’objet géométrique.
- un objet géométrique et un nom de variable (par exemple `t`) défini auparavant par la commande `element` : par exemple `t:=element(0..pi)`. Si on tape `A:=element(cercle(0,2),t)`, alors t est la variable de paramétrage de l’obget géométrique défini par le premier argument, c’est à dire que `A` se trouve sur le cercle de centre 0 et de rayon 2 et que `A` a comme affixe 2*exp(i*t), car 2*exp(i*t) est l’équation paramétrique du cercle(0,2). Il est donc obligatoire dans ce cas de définir auparavant le deuxième argument (ici `t`) comme étant l’élément d’un intervalle.
  On tape par exemple:
  `t:=element(0..pi)`
  puis
  `A:=element(cercle(0,2),t)`
  cela a pour effet d’avoir en haut et à droite un curseur noté `t` que l’on peut faire bouger à la souris de 0 à π, avec à gauche de ce curseur un nombre égal à la valeur de `t` du curseur. Ce curseur permet de faire bouger le point `A` sur le demi-cercle supérieur du cercle de centre 0 et de rayon 1 (car 0≤ t ≤ π) et cela sans tracer ce demi-cercle. On tape par exemple:
  `A:=point(1);B:=point(2+i)`
  `t:=element(0..2)`
  puis
  `M:=element(droite(A,B),t)`
  `M` est un point de la droite `AB` et on a `M=A+t*(B-A)` c’est à dire `M=(1-t)*A+t*B` pout parcourir le segment `AB` , il faut mettre `t:=element(0..1)` ou encore `M:=element(segment(A,B),t)` qui aura pour effet de laisser `M` en `A` si `t<0` et de laisser `M` en `B` si `t>1`.
- une ligne polygonale `LP` et `[floor(t),frac(t)]` avec `t` défini auparavant par la commande `element` : par exemple `t:=element(0..5)` si `LP` a 5 côtés.
  Les côtés de la ligne polygonale `LP` ont comme numèro : 0,1....
  Si par exemple `LP` a 5 côtés et a pour sommets `A(0),...A(4),A(5)=A(0)`, on tapera :
  `t:=element(0..5)`
  `M:=element(LP,[floor(t),frac(t)])`
  Ainsi selon les valeurs de `t`, `M` va parcourir les 5 côtés de `LP` : `M` sera situé sur le côté de numéro `n=floor(t)` et on aura `M=frac(t)*A(n)+(1-frac(t))*A(n+1)`.
  Par exemple :

      A:=point(0);
      B:=point(4);
      C:=point(4*i);
      t:=element(0..3);
      T:=triangle(A,B,C);
      M:=element(T,[floor(t),frac(t)]);

Attention Si à un point M d’affixe m, défini comme élément d’une courbe C, on ajoute un complexe a, cela définit un point N de la courbe C qui est le projeté du point d’affixe m+a sur C.
Par contre si un point M d’affixe m, défini comme élément d’une courbe C, on ajoute un point A d’affixe a, cela définit un point P d’affixe m+a Par exemple, étant donné 3 points M,A,B, si on veut définir le point `N` vérifiant par exemple : MN=AB, on peut taper : `N:=M+(B-A)` à condition que M ne soit pas défini comme élément d’une courbe C. En effet si on a tapé `M:=element(C)` il faut définir N en tapant : `N:=affixe(M)+B-A` ou `N:=M+B-A` (sans parenthèses) car `N:=M+B-A` est interprété en `N:=(M+B)-A` car il n’y a pas de règle de priorité entre `+` et `-` alors que
`M+(B-A)` renvoie un élément de la courbe C qui est le projeté de N sur C.
On a donc, si on tape :
`A:=point(-2,2);B:=point(1,3);C:=cercle(0,1);`
`M:=element(C);N:=affixe(M)+B-A`;(ou `N:=M+B-A`;) `N` n’est pas sur la courbe `C`
si on tape :
`P:=M+(B-A)` (ou P:=projection(C,N);) `P` est sur la courbe `C`