/* NAME = indexa.h */
/*****************************************/
/*           indexa.h                    */
/*                                       */
/*    Index general de l'interpreteur    */
/*                                       */
/*****************************************/

/*********************************/
/*              A                */
/*********************************/

abandon
aba: abandonne le traitement en cours

absolu
abs(expr): retourne la valeur absolue de expr

ajouter
ajou: ajoute des structures de donnees

aleatoire
alea: retourne un aleatoire precalcule
rand, rand2, randf, rand2f: retourne un aleatoire

alias
alias: definit des alias

arc
arc: definit une ligne polygonale 3d circulaire

arc cosinus
acos(expr): retourne l'arc cosinus de expr

arc cosinus hyperbolique
acosh(expr): retourne l'arc cosinus hyperbolique de expr

arc sinus
asin(expr): retourne l'arc sinus de expr

arc cosinus hyperbolique
acosh(expr): retourne l'arc cosinus hyperbolique de expr

arc tangente
atan(expr): retourne l'arc tangente de expr

arc cosinus hyperbolique
acosh(expr): retourne l'arc cosinus hyperbolique de expr

ascii
ascii(expr): retourne le code ascii de expr

atoi
atoi("expr"): retourne l'evaluation entiere de la chaine expr

attente
wait(t): attend t secondes

atof
atof("expr"): retourne l'evaluation flottante de la chaine expr

automatique
auto x: definit la variable x comme automatique

/*********************************/
/*              B                */
/*********************************/

boucle
voir for et while

branchement
voir goto et switch

break
break: sort d'une imbrication (syntaxe du langage c)

bye
bye: clot une cession

/*********************************/
/*              C                */
/*********************************/

case
case(expr): etiquette d'un switch

cercle
voir arc

centre de gravite
voir CG

CG
CG: retourne le centre de gravite d'une entite

chaine
chaine(ent): convertit ent en chaine de caracteres

chainef
chainef(flo): convertir flo en chaine de caracteres

clean
clean: detruit tous les objets vides

compiler
compiler: compile les fonctions presentes en memoire

cosinus
cos(expr): retourne le cosinus de expr

cosinus hyperbolique
cosh(epxr): retourne le cosinus hyperbolique de expr

/*********************************/
/*              D                */
/*********************************/

debugger
debug: debugger

default
default: etiquette default d'un switch

demonstration
demo commande: lance la demonstration d'une commande

dimension
dim: retourne la dimension d'une emtite

directory
directory: redefinit le directory courant

distance
dist(p1,p2): retourne la distance de deux entites

duppliquer
dup: dupplique une entite

/*********************************/
/*              E                */
/*********************************/

editer
editer: edite des structures de donnees

edition de lien
linker: linke les fonctions presentes en memoire

entier
ent(expr): retourne la valeur entiere la plus proche de expr

entree
voir input et lire

erreur
erreur: positionne le flag d'erreur

executer
exec: execute une commande

exponentielle
exp(expr): retourne l'exponentielle de expr

extern
extern var: definit une variable externe

/*********************************/
/*              F                */
/*********************************/

fin
fin: clot un traitement

fonction
fonc: definit une fonction utilisateur

for
boucle for (syntaxe du langage c)

format
format: permet de lire et de garer des fichiers formates

/*********************************/
/*              G                */
/*********************************/

gare
gare: gare des entites sur le disque

generer
generer: genere une entite

globale
voir extern

GO
GO: relance l'execution en mode debugging

goto
goto etiquette

/*********************************/
/*              H                */
/*********************************/

/*********************************/
/*              I                */
/*********************************/

imprimer
voir print et $

inclusion
inclu(x,w): inclusion de x dans w

initialisation
ini commande: initialise une commande

entree sortie
x=input: entree au clavier

inversion
inv: inverse une entite

/*********************************/
/*              J                */
/*********************************/

/*********************************/
/*              K                */
/*********************************/

/*********************************/
/*              L                */
/*********************************/

lecture
voir lire

lister
------
LIST: liste les instructions en mode debugging

fonction locale
---------------
locale: definit une fonction locale a un objet (au sens des langages objet)

logarithme
log(expr): retourne le logarithme neperien de expr

longueur
module(v): retourne le module du vecteur v
dist(p1,p2): rtourne la distance des points p1 et p2
dist(p1,p2,...): retourne la longueur de la ligne polygonale p1,p2,...

/*********************************/
/*              M                */
/*********************************/

maximum
max(expr): retourne le maximum des elements de expr

minimum
min(expr): retourne le minimum des elements de expr

/*********************************/
/*              N                */
/*********************************/

nombre de sommetsNP
NP: retourne le nombre de points d'une entite

/*********************************/
/*              O                */
/*********************************/

/*********************************/
/*              P                */
/*********************************/

pi
PI: definit le nombre "pi"

produit scalaire
voir scalaire

produit vectoriel
voir vectoriel

pulsation
puls: definit une pulsation periodique

/*********************************/
/*              Q                */
/*********************************/

/*********************************/
/*              R                */
/*********************************/

racine carree
voir sqrt

retour
voir return

rtour charriot
RC: provoque un retour a la ligne (carriage return)


/*********************************/
/*              S                */
/*********************************/

sinus
sin(expr): retourne le sinus de expr

sinus hyperbolique
sinsh(epxr): retourne le sinus hyperbolique de expr

sonner
sonne(t): sonne pendant t secondes

sortie
voir gare et print

stop
STOP: definit un point d'arret en mode debugging

suppprimer
sup: supprime des entites

systeme
system("expr"): execute la commande unix expr

/*********************************/
/*              T                */
/*********************************/

tangente
tan(expr): retourne la tangente de expr

tangente hyperbolique
tansh(epxr): retourne la tangente hyperbolique de expr

temps
time: retourne le temps ecoule

/*********************************/
/*              U                */
/*********************************/

/*********************************/
/*              V                */
/*********************************/

valeur absolue
voir abs

variable
var("x"): definit la variable de nom x

vecteur unitaire
unitaire(vect): retourne un vecteur unitaire

vide
NIL: definit un objet vide

/*********************************/
/*              W                */
/*********************************/

/*********************************/
/*              X                */
/*********************************/

/*********************************/
/*              Y                */
/*********************************/

/*********************************/
/*              Z                */
/*********************************/

~
peu different

!
negation

!=
different

@
passage d'un parametre par adresse

#
directive

$
print

%
modulo

^
puissance

&
et logique

&&
et conditionnel

*
multiplication

(
debut d'evaluation

)
fin d'evaluation

-
soustraction

=
egalite

==
comparaison

~=
peu differenr

+
addition

[
debut d'indice

]
fin d'indice

{
debut de bloc

}
fin de bloc

|
ou logique

||
ou conditionnel

:
fin de nom d'etiquette

;
fin d'instruction

"
debut et fin de chaine
-

'
debut et fin de caractere

<
inferieur

<=
inferieur ou egal

>
plus grand

>=
plus grand ou egal

,
concatenation

.
point decimal

/
division

/*
Debut de commentaire

*/
Fin de commantaire

/* END */
