Note pour moi: pas oublier sin log etc Note préalable. Les différentes fonctions se trouvent après $$$ Les liens (url) seront entre && : &&SolveN(&& (y compris pour les fonctions déjà présentes sur le site). Faire attention à la syntaxe Basic Casio, car les liens et fonctions peuvent comporter un espace (comme Sum ). Les liens vers des tutos (et autres) sont déjà en BBCode ([url=LINK][/url]). Ne connaissant que peu de bonnes applications des différentes fonctions (comme Super DrawStat), les liens vers d'autres url du site Planète Casio se feront assez rares. Ce point-ci serait utile d'être retravaillé par quelqu'un s'y connaissant mieux que moi ^^ . Il est (fort) possible que les fiches doivent être revues d'un point de vue "visuel". En effet, je ne suis pas le meilleur concernant la présentation (par exemple, la plupart des exemples de code se trouvent uniquement entre ``. Je ne saurais dire si c'est suffisant). La localisation des fonctions (qui est l'ordre de ce document - afin de donner une sorte de tri par thème) se trouve après @@@ (par exemple @@@ PRGM (SHIFT, VARS), JUMP (F3), Lbl (F1) ). List et Mat peuvent être trouvés avec SHIFT+1 ou 2, mais leur chemin complet a été donné (OPTN+F1+F1 pour List ). Le code (syntaxe de la fonction) se trouve après ``` La fin de chaque fiche est définie par les caractères *** , donc le texte se trouvant entre ``` et *** correspond à la description de la fonction. Toutes les erreurs possibles ont été mises en gras. Les erreurs très évidentes n'ont pas été écrite, comme l'erreur math que renverrait Det si une liste était donnée à la place d'une matrice. Du BBCode se trouvera dans ce document. Comme par exemple des tableaux. Des caractères spéciaux s'y trouveront aussi (▷, →, ...). Toutes les fonctions ne se trouvant pas encore sur le site mais bien dans ce document sont compatibles OS Graph 2.05 et supposé compatibles 2.00 (grâce au manuel d'utilisation). Les fonctions se trouvant déjà sur le site sont reprises après la ligne de tirets (-), leur compatibilité sur différentes calculatrices n'ayant pas été prise en compte. Je ne pense pas que des erreurs de français puissent se trouver dans le document, par contre il est possible que dans certains cas l'explication de la fonction pourrait ne pas être super clair. Si c'est arrivé, désolé... (J'y mettrai tout de même des exemples ;) La fonction Dim se trouve aussi bien dans OPTN+F1 que OPTN+F6+F2, seulement le premier cas a été pris en compte. Seulement les cas où la parenthèse fermante de la fonction est obligatoire sont spécifiés (autrement, cela veut dire qu'on peut l'oublier), contrairement aux arguments, pour lesquels seuls ceux pouvant être ommis sont cités. Certaines fiches n'ont pas été écrites : c'est le cas de f1 (→f6 - voir fn ), List1 (→List6 - voir List ), VarList1 (→VarList6 - voir VarList ) et File1 (→File6 - voir File ). Ces dernières ne se trouvent que dans le catalogue de la calto (SHIFT+4). $$$ Percent @@@ OPTN (OPTN), LIST (F1), ▷ (F6), ▷ (F6), % (F4) ``` Percent Pour une liste donnée, renvoie une nouvelle liste contenant le pourcentage entre chaque élément et la somme de la liste. La fonction est donc équivalente à `100×÷Sum ` (voir &&Sum &&). Une [b]Erreur math[/b] est renvoyée si au moins un élément est négatif ou si tous les éléments sont nuls. La peut-être de différentes formes : - `{1,2,3}` - `List 1` (voir &&List &&) - `Seq(X,X,1,3,1)` (voir &&Seq(&&) - `(1+List 1)` , ou toute autre expression renvoyant une liste. *** $$$ ◿List @@@ OPTN (OPTN), LIST (F1), ▷ (F6), ▷ (F6), ◿ (F5) ``` ◿List Pour une liste donnée de [u]n[/u] éléments, renvoie une nouvelle liste de taille [u]n-1[/u] contenant la différence entre chaque élément successif. Exemple : le code `◿List {1,3,4}` renvoie la liste `{2,1}`. Une [b]Erreur syntaxe[/b] est renvoyée si n'est pas un résultat direct, autrement dit si est une expression contenant une fonction (comme &&Seq(&&), ou si contient, par exemple, `(2×{1,3,4})`. Une [b]Erreur dimension[/b] est renvoyée si ne contient qu'un seul élément. peut-être de différentes formes : - `{1,2,3}` - `1` qui correspond au numéro de la liste. Cela peut aussi être une variable, mais pas un nombre stocké dans une liste ou matrice (voir &&List &&). *** $$$ Det @@@ OPTN (OPTN), MAT (F2), Det (F3) ``` Det Renvoie le déterminant d'une matrice carrée. Une [b]Erreur dimension[/b] est renvoyée si n'est pas carrée (ie si le nombre de colonnes est différent du nombre de lignes). peut-être de différentes formes : - `[[1,2][3,4]]` - `Mat A` (voir &&Mat &&) - `(2×Mat A)` , ou toute autre expression renvoyant une matrice, comme &&Identity &&. *** $$$ Identity @@@ OPTN (OPTN), MAT (F2), ▷ (F6), Iden (F1) ``` Indentity Crée une nouvelle matrice de taille ×. Une [b]Erreur argument[/b] est renvoyée si n'est pas un naturel différent de 0. peut-être un nombre, une variable, ou toute expression renvoyant un scalaire. *** $$$ Ref @@@ OPTN (OPTN), MAT (F2), ▷ (F6), Ref (F4) ``` Ref Renvoie la matrice sous forme échelonnée par rapport aux lignes (et est donc par conséquent triangulaire supérieure). Voir &&Rref && pour une forme échelonnée [i]réduite[/i] de la matrice. Par exemple `Ref [[1,2][4,4]]` donnera `[[1,1][0,1]]`. peut-être de différentes formes : - `[[1,2][3,4]]` - `Mat A` (voir &&Mat &&) - `(2×Mat A)` , ou toute autre expression renvoyant une matrice, comme &&Identity &&. *** $$$ Rref @@@ OPTN (OPTN), MAT (F2), ▷ (F6), Rref (F5) ``` Rref Renvoie la matrice sous forme échelonnée réduite par rapport aux lignes (et est donc par conséquent triangulaire supérieure). Voir &&Ref && pour une forme échelonnée [i]non-[/i]réduite de la matrice. Cette fonction permet de résoudre des systèmes d'équation (dont les inconnues sont toutes d'ordre 0 ou 1). Par exemple, pour résoudre le système X+Y=0 et X-Y=6, nous avons une matrice de coeficients `[[1,1,0][1,-1,6]]`. Après avoir avoir utilisé Rref , nous obtenons la matrice `[[1,0,3][0,1,-3]]`. On peut voir cette dernière comme la représentation du système 1X+0Y=3 et 0X+1Y=-3. Dès lors, X=3 et Y=-3. peut-être de différentes formes : - `[[1,2][3,4]]` - `Mat A` (voir &&Mat &&) - `(2×Mat A)` , ou toute autre expression renvoyant une matrice, comme &&Identity &&. *** ---------------------------------------------------------------------------------------------------------------------------------------------------------------- $$$ List @@@ OPTN (OPTN), LIST (F1), List (F1) ``` List Les différentes listes se trouvent dans l'application STAT ([MENU] + [2]). On peut aussi obtenir la commande `List ` en appuyant sur [SHIFT] + [1]. L'argument d'une liste peut être de différentes formes : - une chaîne de caractères, étant le nom de la liste (seuls les [i]8 premiers octets[/i] de la String seront pris en compte - une chaîne vide est valide). 2 listes ne peuvent pas avoir le même nom, ou une erreur est renvoyée : "[b]Existe déjà[/b]". - un nombre n, étant le numéro de la liste (qui peut aussi être une variable dont la valeur est le numéro de la liste, ou `Ans` qui est utilisé pour `List Ans` : une liste que l'on n'a pas stockée; la valeur de Ans ne sera jamais lue). Selon votre modèle de calculatrice, il y a maximum 6, 20 ou 26 listes. Les commandes `List1` (jusque `List6`) sont trouvables dans le catalogue de la calculatrice ([SHIFT] + [4]), permettant ainsi d'alléger le code (en effet, ces commandes pèsent 1 octet chacune). On peut mettre au maximum 255 ou 999 éléments dans une liste. N'hésitez pas à aller voir le [url=https://www.planet-casio.com/Fr/programmation/listes.php]fonctionnement des listes dans le tutoriel de programmation Basic Casio[/url]. Toute opération mathématique est supportée par les listes : on peut dès lors utiliser les fonctions &&log && ou &&cos && sur une liste, la multiplier, l'additioner ou l'élever à une puissance avec un scalaire, et même avec une autre liste ! Un calcul entre plusieurs listes se fait élément par élément, il faut donc que ces différentes listes soient de même taille (ou une [b]Erreur dimension[/b] sera renvoyée). Par exemple, `{1,2,3}^{2,3,4}` donne `{1,8,81}`. Un liste peut être initialisée de différentes façons : - `{1,2,3}→List 1` - `2×Seq(X,X,1,3,1)→List 1` , ou toute autre expression/fonction renvoyant une liste (voir &&Seq(&&). - `3→Dim List 1` où 3 (ou toute autre expression/fonction renvoyant un naturel différent de 0) devient la dimension (voir &&Dim &&) de la liste 1. La liste contient donc maintenant uniquement 3 éléments égaux à 0. On peut aussi initialiser une liste grâce à un nom unique : `3→Dim List "BLABLA"`. Si la liste "BLABLA" existe déjà, elle sera écrasée. Au contraire, si elle n'existe pas encore, une liste vide jusqu'ici sera utilisée (il n'est pas aisé de savoir à quel numéro de liste elle correspond...). Ceci renvoie une [b]Erreur mémoire[/b] si toutes les listes sont déjà initialisées. On ne peut pas initialiser la `List Ans` de la même manière (`{1,2,3}→List Ans` produit une [b]Erreur argument[/b]). En effet, toute expression/fonction renvoyant une liste qui n'est pas stockée se retrouve dans `List Ans`. Pour modifier un élément ou le lire, il faut spécifier l'indice de celui-ci entre crochet après la liste (par exemple `2→List 1[5]`). On ne peut accéder un élément que dans une `List ` - et non si la liste est une expression/fonction (`Seq(X,X,1,3,1)[2]` renvoie une [b]Erreur syntaxe[/b] - voir &&Seq(&&). Aussi, un élément en particulier ne peut être modifié s'il se trouve dans `List Ans`. Les listes supportent l'auto-incrémentation, c'est-à-dire que si vous écrivez une donnée à d'indice `1+Dim List 1` , celle-ci sera ajoutée à votre liste, comportant maintenant un élément de plus. Chaque liste peut porter un nom (unique, et de 8 octets maximum - une chaîne vide est valide), stocké à l'indice `[0]` de la liste. Il faut donc procéder comme suit : `"BLABLA"→List 1[0]` , et l'indice `[0]` peut être ommis. Si la liste était vide, elle contient maintenant la valeur `0` à l'indice `[1]`. Ce nom peut être afficher grâce à &&Locate &&, mais ne peut [u]pas[/u] être récupéré dans une String (&&Str &&) avec la fonction &&Exp▶Str(&&. Pour supprimer complètement une liste, voir &&ClrList &&. Pour avoir accès à encore plus de listes, voir &&File &&. Pour trier une liste dans l'ordre croissant, voir &&SortA(&&; dans l'ordre décroissant, voir &&SortD(&&. Pour fusionner 2 listes, voir &&Augment(&&. *** $$$ List→Mat( @@@ OPTN (OPTN), LIST (F1), L→M (F2) $$$ Dim @@@ OPTN (OPTN), LIST (F1), Dim (F3) $$$ Fill( @@@ OPTN (OPTN), LIST (F1), Fill (F4) $$$ Seq( @@@ OPTN (OPTN), LIST (F1), Seq (F5) $$$ Min( @@@ OPTN (OPTN), LIST (F1), ▷ (F6), Min (F1) $$$ Max( @@@ OPTN (OPTN), LIST (F1), ▷ (F6), Max (F2) $$$ Mean( @@@ OPTN (OPTN), LIST (F1), ▷ (F6), Mean (F3) $$$ Median( @@@ OPTN (OPTN), LIST (F1), ▷ (F6), Med (F4) $$$ Augment( @@@ OPTN (OPTN), LIST (F1), ▷ (F6), Aug (F5) $$$ Sum @@@ OPTN (OPTN), LIST (F1), ▷ (F6), ▷ (F6), Sum (F1) $$$ Prod @@@ OPTN (OPTN), LIST (F1), ▷ (F6), ▷ (F6), Prod (F2) $$$ Cuml @@@ OPTN (OPTN), LIST (F1), ▷ (F6), ▷ (F6), Cuml (F3) $$$ Mat @@@ OPTN (OPTN), MAT (F2), Mat (F1) $$$ Mat→List( @@@ OPTN (OPTN), MAT (F2), M→L (F2) $$$ Trn @@@ OPTN (OPTN), MAT (F2), Trn (F4) $$$ Augment( @@@ OPTN (OPTN), MAT (F2), Aug (F5) $$$ Fill( @@@ OPTN (OPTN), MAT (F2), ▷ (F6), Fill (F3) ``` Fill(,) Remplit une liste ou une matrice [u]pré-initialisée[/u] avec la valeur . Une [b]Erreur syntaxe[/b] est renvoyée si n'est pas un résultat direct (ou n'est pas un numéro de liste existant), autrement dit si est une expression contenant une fonction, ou toute autre calcul (comme `2+A`). Une [b]Erreur dimension[/b] est renvoyée si n'est pas encore initialisée. peut-être un nombre, une variable, ou toute expression renvoyant un scalaire. peut-être de différentes formes : - Si c'est une liste : ~ `List 1` (voir &&List &&) ~ `1` , qui est le numéro de la liste. Cela peut aussi être une variable, mais pas un nombre stocké dans une liste ou matrice. - Si c'est une matrice : ~ `Mat A` (voir &&Mat &&) *** $$$ Vct @@@ OPTN (OPTN), MAT (F2), ▷ (F6), ▷ (F6), Vct (F1) ``` Vct La liste des vecteurs se trouve dans l'application RUN-MAT, ▶MAT (F3), M↔V (F6). peut être soit une lettre de l'alphabet (A~Z), ou bien Ans. Pour transformer un vecteur ligne en un vecteur colonne (ou inversement), voir &&Trn &&. L'addition entre un scalaire et un vecteur n'est pas tolérée, mais bien la multiplication entre ceux-ci. Pour mutliplier des vecteurs de même nombre d'éléments entre-eux directement, il faut impérativement que l'un soit un vecteur colonne et l'autre matrice (et le résultat sera une matrice 1×1). On peut éviter ce souci avec la fonction &&DotP(&&, qui renverra un scalaire peu importe l'orientation des vecteurs (colonne ou ligne). Il n'est de nouveau pas possible d'élever un vecteur à une puissance (à part le cas particulier d'un vecteur d'un seul élément), car il faut pour ça avoir une matrice carrée. Aucune fonction mathématique ne peut être appliquée à un vecteur, comme &&sin && ou &&ln &&. Un vecteur peut être initialisé de différentes façons : - `[[1,2,3]]→Vct A` qui est un vecteur ligne. - `[[1][2][3]]→Vct A` qui est un vecteur colonne - `Mat A→Vct A` , ou toute autre expression/fonction renvoyant une matrice ligne ou une matrice colonne (voir &&Mat &&). - `{1,3}→Dim Vct A` qui est un vecteur ligne dont tous les éléments sont initialisés à 0, ou toute autre expression/fonction renvoyant une liste de 2 éléments dont un vaut 1 (voir &&List && et &&Dim &&). On ne peut pas initialiser le `Vct Ans` de cette manière (`[[1,2,3]]→Vct Ans` produit une [b]Erreur syntaxe[/b]). En effet, toute expression/fonction renvoyant un-e matrice/vecteur unidimensionnel-le qui n'est pas stockée se retrouve dans `Vct Ans`. Pour supprimer complètement un vecteur, voir &&ClrVct &&. *** $$$ DotP( @@@ OPTN (OPTN), MAT (F2), ▷ (F6), ▷ (F6), DotP (F2) ``` DotP(,) Effectue le produit scalaire des 2 vecteurs. Des matrices peuvent aussi être utilisées, à condition qu'elles soient des matrices colonnes ou lignes. Une [b]Erreur dimension[/b] est renvoyée si les arguments n'ont pas le même nombre d'éléments (ou si un des 2 n'est pas unidimensionnel). En effet, on peut multiplier un vecteur colonne par un vecteur ligne sans souci ! Pour effectuer le produit vectoriel, voir &&CrossP(&&. peut être de différentes formes : - `[[1,2,3]]` - `Vct A` (voir &&Vct &&) - `Mat A` , à condition que ce soit une matrice unidimensionnelle (voir &&Mat &&). - `2×Vct A` , ou toute autre expression/fonction renvoyant une matrice unidimensionnelle. *** $$$ CrossP( @@@ OPTN (OPTN), MAT (F2), ▷ (F6), ▷ (F6), CrsP (F3) ``` DotP(,) Effectue le produit vectoriel des 2 vecteurs ([u]à 2 et 3 composantes seulement[/u]), et renvoie toujours un vecteur à 3 composantes. Les vecteurs 2D (`[[X,Y]]`) auront une composante Z nulle (ils sont interprétés comme `[[X,Y,0]]`). Par exemple, `CrossP([[1,2]],[[3,4]])` donnera `[0,0,-2]`. Des matrices peuvent donc aussi être utilisées, à condition qu'elles soient des matrices colonnes ou lignes. Une [b]Erreur dimension[/b] est renvoyée si les arguments n'ont pas le même nombre d'éléments, si un des 2 n'est pas unidimensionnel, ou si leur nombre d'éléments n'est pas de 2 ou 3. En effet, on peut multiplier un vecteur colonne par un vecteur ligne sans souci ! Pour effectuer le produit scalaire, voir &&DotP(&&. peut être de différentes formes : - `[[1,2,3]]` - `Vct A` (voir &&Vct &&) - `Mat A` , à condition que ce soit une matrice unidimensionnelle (voir &&Mat &&). - `2×Vct A` , ou toute autre expression/fonction renvoyant une matrice unidimensionnelle. *** $$$ Angle( @@@ OPTN (OPTN), MAT (F2), ▷ (F6), ▷ (F6), Angle (F4) ``` Angle(,) Calcule l'angle orienté entre 2 vecteurs, et renvoie toujours un angle positif. Des matrices peuvent aussi être utilisées, à condition qu'elles soient des matrices colonnes ou lignes. L'angle retourné dépend de l'unité d'angle que vous utilisez (voir &&Deg&&, &&Rad&&, &&Gra&& pour changer d'unité). Une [b]Erreur dimension[/b] est renvoyée si les arguments n'ont pas le même nombre d'éléments (ou si un des 2 n'est pas unidimensionnel). En effet, on peut donner un vecteur colonne et un vecteur ligne sans souci ! Pour effectuer le produit scalaire, voir &&DotP(&&. Pour effectuer le produit vectoriel, voir &&CrossP(&&. peut être de différentes formes : - `[[1,2,3]]` - `Vct A` (voir &&Vct &&) - `Mat A` , à condition que ce soit une matrice unidimensionnelle (voir &&Mat &&). - `2×Vct A` , ou toute autre expression/fonction renvoyant une matrice unidimensionnelle. *** $$$ UnitV( @@@ OPTN (OPTN), MAT (F2), ▷ (F6), ▷ (F6), UntV (F5) ``` UnitV() Renvoie le vecteur unitaire. Une matrice peut aussi être utilisée, à condition qu'elle soit une matrice colonne ou ligne. Une [b]Erreur dimension[/b] est renvoyée si l'argument n'est pas unidimensionnel. Cette fonction revient à diviser le vecteur par sa norme (`÷Norm()` , voir &&Norm(&&). peut être de différentes formes : - `[[1,2,3]]` - `Vct A` (voir &&Vct &&) - `Mat A` , à condition que ce soit une matrice unidimensionnelle (voir &&Mat &&). - `2×Vct A` , ou toute autre expression/fonction renvoyant une matrice unidimensionnelle. *** $$$ Norm( @@@ OPTN (OPTN), MAT (F2), ▷ (F6), ▷ (F6), ▷ (F6), Norm (F1) ``` Norm() Renvoie la norme du vecteur donné. Une matrice peut aussi être utilisée, à condition qu'elle soit une matrice colonne ou ligne. Une [b]Erreur dimension[/b] est renvoyée si l'argument n'est pas unidimensionnel. Pour obtenir un vecteur unitaire, voir &&UnitV(&&. peut être de différentes formes : - `[[1,2,3]]` - `Vct A` (voir &&Vct &&) - `Mat A` , à condition que ce soit une matrice unidimensionnelle (voir &&Mat &&). - `2×Vct A` , ou toute autre expression/fonction renvoyant une matrice unidimensionnelle. ***