Casio Universal Wiki - Nouvelles pages [fr]

Casioplot

2020-05-05T10:11:07Z

Lephenixnoir : Corrections rapportées par Ptitjoz

Casioplot est une bibliothèque de dessin bas niveau fournie par Casio pour supporter ses modules <code>matplotlib</code> et <code>turtle</code>, annoncé dans une [https://www.planet-casio.com/Fr/forums/topic16154-1-modules-graphiques-python-en-avril-matplotlib-et-turtle.html newsletter de Février 2020] et [https://www.planet-casio.com/Fr/forums/topic16243-1-rendu-graphique-en-python-partie-1-decouverte-de-matplotlib-et-turtle.html publié en Avril]. Le module est disponible à la fois pour Graph 35+E II et Graph 90+E avec une interface commune.

Le module peut être importé en ajoutant simplement <code>import casioplot</code> ou <code>from casioplot import *</code> au début du programme, selon les usages.

== Zone de dessin et couleurs ==

La taille de la zone de dessin est de :
* 384×192 sur les Graph 90+E (écran limité par les bandes habituelles et la barre de statut)
* 128×64 sur les Graph 35+E II (plein écran)

Sur les deux modèles, les couleurs sont représentées par des tuples <code>(R,G,B)</code> où chaque composante a une valeur entre 0 et 255. Aucune de ces deux machines ne sait représenter des couleurs avec une telle précision, mais cette convention a été choisie par compatibilité avec les plateformes PC.

Sur écran monochrome, les couleurs sont approximées au noir ou blanc selon la luminosité. Sur écran couleur, elles sont approximées sur l'échelle RGB565, probablement seuillées à la couleur représentable la plus proche.0

== Description de l'interface ==

De manière générale, toutes les fonctions effectuent leurs opérations dans l'écran virtuel (VRAM). Pour appliquer les modifications de la VRAM vers l'écran physique, il faut nécessairement appeler <code>show_screen()</code> ''(ce qui est fait automatiquement à la fin de l'exécution d'un programme)''. Les performances du double buffering en font une alternative bien plus puissante que le dessin avec PxlOn en Basic Casio.

=== <code>show_screen()</code> ===

Affiche l'écran virtuel (VRAM) sur l'écran physique.

=== <code>clear_screen()</code> ===

Remplit la VRAM de pixels blancs.

=== <code>set_pixel(x, y, color)</code> ===

Affecte la couleur `color` au pixel aux coordonnées (x,y).

=== <code>get_pixel(x, y)</code> ===

Retourne la couleur du pixel aux coordonnées (x,y) dans la VRAM. Comme la VRAM est intrinsèquement moins précise que le format d'entrée de <code>set_pixel()</code> (1-bit sur les machines mono, 16-bit sur les machines couleur), typiquement <code>set_pixel(x, y, color)</code> suivi de <code>get_pixel(x, y)</code> ne renverra pas <code>color</code> mais son approximation au format de la VRAM.

=== <code>draw_string(x, y, text, color, size)</code> ===

Écrit du texte à l'écran aux coordonnées (x,y) de couleur <code>color</code>. Le pixel (x,y) est le coin haut gauche du texte affiché de couleur. Le paramètre <code>size</code> peut prendre les valeurs <code>'small'</code>, <code>'medium'</code> ou <code>'large'</code>. Sur Graph 35+E II, les deux petites polices sont identiques (<code>PrintMini</code>) ; sur Graph 90+E, les trois polices sont distinctes. La plupart des caractères non-ASCII ne sont pas supportés(nécessite une vérification).

Python

2020-05-05T09:35:45Z

Lephenixnoir : Ajouté quelques colonnes et des liens vers les infos des modules.

Le langage de programmation [https://fr.wikipedia.org/wiki/Python_(langage) Python] est disponible nativement sur les Graph 90+E et Graph 35+II. Un interpréteur communautaire, [[Casiopython]] est disponible pour les Graph monochromes supportant les addins.

''Pour le moment, cette page ne parle que des spécificités de l'interpréteur officiel.''

== Bibliothèques ==

{| class="wikitable sortable"
|-
! Nom !! Description !! Source !! Plateforme || Intégrée à l'OS1 !! Officielle2 !! Niveau de support par rapport à l'original
|-
| <code>[[random]]</code> || Génération de données aléatoires || [https://docs.python.org/3/library/random.html Standard Python 3] || Tous modèles || Oui || Oui || Complet
|-
| <code>[[math]]</code> || Fonctions mathématiques || [https://docs.python.org/3/library/math.html Standard Python 3] || Tous modèles || Oui || Oui || ?
|-
| <code>[[matplotlib]]</code> || Visualisation de statistiques || [https://matplotlib.org/ Projet multi-plateforme très utilisé] || Tous modèles || Non || Oui || Partiel, uniquement les fonctionnalités de base
|-
| <code>[[turtle]]</code> || Dessin pas à pas || [https://docs.python.org/3/library/turtle.html Standard Python 3] || Tous modèles || Non || Oui || Partiel, orienté vers l'algorithmique plus que le dessin
|-
| <code>[[casioplot]]</code> || Dessin bas niveau || Module original de Casio || Tous modèles || Oui || Oui || -
|-
| <code>[[sprito]]</code> || Framework graphique || [https://www.planet-casio.com/Fr/forums/topic16248-1-python-sprito-framework-de-dessin-pour-le-python-de-la-90e-wip.html Communauté de Planète Casio] || Graph 90+E || Non || Non || -
|-
| <code>[[geolib]]</code> || Framework graphique || [https://www.planet-casio.com/Fr/forums/topic16255-1-geolib-une-lib-de-geometrie-pour-le-python-de-la-graph-90e.html Communauté de Planète Casio] || Graph 90+E || Non || Non || -
|}
''(1) Les modules intégrés à l'OS ne requièrent pas l'ajout de fichier <code>.py</code> pour fonctionner. Ce sont les seuls utilisables en mode examen.

''(2) L'implémentation pour calculatrices du module est fournie par Casio''.

LuaZM

2014-09-21T17:35:42Z

Nemhardy : Création de la page LuaZM

{{InfoBox Software
| nom=LuaZM
| logoLégende=Logo de Lua
| logo=Lua.gif
| screenshot=LuaZM_screenshot.jpeg
| légende=Screenshot de LuaZM sur Prizm
| Auteur=Luiz Henrique de Figueiredo, Roberto Ierusalimschy et Waldemar Celes
| développeur= KermMartian (né Christopher Michell)
| SouventMàJ=Non
| genre=Interpréteur de langage alternatif
| langage=Anglais
| langage de programmation=[[C (langage)|C]], [[C++]]
| site web=[http://www.cemetech.net/forum/viewtopic.php?t=8168 Topic du projet]
}}

Le Lua est un langage de script libre. Du fait de sa programmation en C ANSI il est portable sur une grande variété de périphériques. LuaZM est le portage réalisé par KermMartian disponible sur les calculatrices fx-CG10 et fx-CG20 (plus généralement appelées Prizm).

L'add-in permettant d'interpréter les fichiers en texte-plein ou compressés (respectivement .lua et .lc) est téléchargeable [http://www.cemetech.net/programs/index.php?mode=file&id=770 ici]

== Librairie Standard, ou basique ==

La librairie standard du Lua est normalement supportée par l'add-in. Deux fonctions que l'on pourrait considérer comme standard sont ajoutées.

=== run() ===

<code>> run()
> run("file.lua")
> run("compressed.lc")</code>

La fonction 'run' permet de lancer un script Lua (compressé ou non). La fonction appelée sans argument ouvrira un explorateur de fichier sur la calculatrice permettant à l'utilisateur de sélectionner le fichier à lancer, sinon le script désigné par l'argument sera exécuté.

A noter qu'il est possible d'appeler un script contenu dans un sous-dossier de la mémoire de stockage, en utilisant l'antislash ('\'). Dans ce cas, il faudra entourer l'argument de doubles crochets ("[[" et "]]"), cela afin de ne pas considérer l'antislash comme introducteur d'un caractère d'échappement.

<code>> run("folder\file.lua") '''Ne fonctionnera pas'''
> run([[[[folder\file.lua]]]]) '''Fonctionnera'''</code>

=== about() ===

<code>> about()</code>

L'appel de 'about' ouvre une fenêtre de type Pop-up affichant les crédits de ce portage, ainsi que la version utilisée.

== ZMG Lib (Ou bibliothèque graphique spécifique aux Prizm)==

Toutes les fonctions de la bibliothèque ZMG (qui vient de "priZM Graphics") sont appelées de la même façon :
<code>zmg.function(arguments,...)</code>

=== zmg.clear() ===

zmg.clear()

La fonctione 'zmg.clear', qui ne prend pas d'argument, vide la VRAM, ou mémoire vidéo, c'est à dire la zone où sont effectués les différents tracés avant d'être copiés à l'écran.

=== zmg.copySprite() ===

zmg.copysprite(x,y,width,height,data)

Cette fonction copie un sprite dans la VRAM, en effaçant tout contenu précédent à l'endroit de la copie. La fonction supporte le clipping (c'est à dire le fait que le sprite soit dessiné dans un espace limité et tronqué en partie si besoin), par défaut les bords de l'écran sont utilisés comme limite, mais si la fonction 'zmg.clipRect()' a été appelée, c'est le rectangle définit qui servira de limite.

La fonction prend 5 arguments en entrée :
- x : (nombre) : coordonnée en x du coin en haut à gauche du sprite
- y : (nombre) : coordonnée en y du coin en haut à gauche du sprite
- width : (nombre) : largeur du sprite en pixels
- height : (nombre) : hauteur du sprite en pixels
- data : (string) : chaîne en hexadécimal où chaque pixel du sprite est codé sur 16bits (en RGB 5-6-5)

=== zmg.fastCopy() ===

zmg.fastCopy()

La fonction 'zmg.fastCopy()', qui ne prend pas d'arguments en entrée et ne retourne rien, permet d'afficher le contenu de la VRAM (ou mémoire vidéo) à l'écran.

Page en cours d'écriture; documentation disponible en anglais sur [http://prizm.cemetech.net/index.php/LuaZM_Reference cette page].

[[Catégorie:Pages en cours d'écriture]]

PV-Lib

2014-05-21T14:14:53Z

Lephenixnoir :

{{MsgBox|title=Page En construction|text=Cette page est encore en construction. Tout apport d'information est le bienvenu.|theme=orange}}

La libraire PV-Lib est un ensemble de fonctions permettant d'utiliser des syscalls du Casio Pocket Viewer.
En effet, le Classpad étant basé sur cet ancien modèle d'agenda électronique, toutes les fonctions (ou presque) disponibles pour le SDK du PV le sont également pour le CPSDK.

Ceci implique qu'il est facile de ré-écrire un programme PV pour CP. C'est grâce à cela que Vanhoa a pu porter autant de programmes vers le Classpad (IEdit, OWBasic, ...)

Plus d'informations viendront par la suite.

[[Catégorie:Pages en cours d'écriture]]

CPSDK

2014-05-19T15:50:21Z

Cartix : /* L'Assembleur (Asm) */

{{MsgBox|title=Important|text=Le ClassPad SDK n'est officiellement pas supporté par Casio qui ne répondra donc pas aux questions posées à ce sujet.|theme=rouge}}
 
{{InfoBox Software
| nom=CPSDK
| logo=devcpp.png
| Auteur=Saltire
| language=Anglais
| langage de programmation=[[C (langage)|C]], [[C++]]
}}
Ce logiciel (Software Development Kit) est un module de Dev-C++ vous permettant de programmer des add-ins pour votre Classpad.
Saltire, qui a développé le cœur mathématique de la Graph100, a aussi développé le système d'exploitation de la Classpad 300 basé sur une API graphique propriétaire.

Ils ont donc fourni avec l'accord de Casio un Environnement de Développement Intégré basé sur Dev-C++, le compilateur SH et des outils propriétaires.

Ainsi, il est possible de développer des applications utilisant l'API de la calculatrice pour faire des jeux, dessiner, utiliser le cœur mathématique, gérer les fichiers...

Actuellement, le SDK n'est fonctionnel que pour les CP300(+) et CP330. En effet, le format d'add-in des CP330+ étant différent, les add-ins actuels sont incompatibles. De plus, il semblerait que Casio n'est pas décidé à combler ce manque.

== Interface de développement ==

Le CPSDK se présente comme un plug-in à ajouter à Dev-C++. Ceci permet d'utiliser l'interface de ce logiciel pour programmer.

== Langages de programmation disponibles ==

Les Add-Ins (ou Applications Ajoutées) sont des programmes qui apparaissent dans le menu principal. Ces programmes sont bien plus rapides que ceux écrits en Basic. Ils sont programmables en deux langages :

=== Le C++ ===

Il permet de mettre en place des fenêtres, une interface, des menus, exactement comme dans les applications intégrées.
Le C++ est plus complexe que le CPBasic, et donc plus difficile à apprendre. Cependant, étant un langage de haut-niveau, il reste compréhensible par un programmeur habitué

Le C++ étant un langage compilé, l'add-in doit être programmé à partir d'un ordinateur, compilé, puis envoyé vers la ClassPad.

Vous trouverez plus bas divers liens utiles pour vous entraîner. Vous pouvez également consulter les nombreuses sources disponibles sur CasioFan.

=== L'Assembleur (Asm) ===

Le langage Assembleur utilisé par le ClassPad est l'assembleur SH-3, de par le type de processeur dont elle est équipée. L'assembleur est le langage le plus proche du "langage machine" ; c'est son principal avantage (il est alors plus rapide que le C++) mais c'est aussi son principal inconvénient car cela le rend (très) peu lisible et peu maniable : réaliser un programme complet avec demande énormément d'efforts et d'expérience. On utilise plus souvent l'assembleur pour faire des fonctions qu'on exporte ensuite dans un programme C++, notamment lorsque certains traitements nécessitent une grande vitesse d'exécution (opération de rafraichissement d'écran, etc).

Programmer en Assembleur est réservé aux développeurs chevronnés. Ce langage ne permet de faire que ce que le processeur sait faire : lire/écrire dans la mémoire, et effectuer des opérations très simples sur ses registres. Ainsi, si on souhaite simplement afficher un pixel à l'écran, il faut connaître l'adresse de l'écran et sa structure dans la mémoire, puis "écrire" à cette adresse au bon endroit (sans altérer l'état des pixels voisins). C'est pourquoi ce langage peut s'avérer dangereux : on a la possibilité de faire tout et n'importe quoi avec la mémoire, une mauvaise manipulation peut avoir de graves conséquences comme "bloquer" la machine et ce de manière irréversible. Au cas où vous voudriez tenter votre chance, consultez la documentation Hitachi, et effectuez vos tests sur le ClassPad Manager.

== Alternative à Dev-C++ ==

* Il semblerait qu'il existe un plug-in Casio pour MS Visual Studio. Malheureusement, celui-ci reste, à l'heure actuelle, introuvable. Il a probablement disparu avec la chute de cpsdk.com
* Le 01/04/2013, MicroPro, un programmeur de l'UCF, a annoncé avoir commencé à développer un IDE Visuel, dans le style de Visual Studio. Malheureusement, nous n'avons plus de nouvelles de ce projet depuis longtemps. La date de l'annonce laisse également supposer qu'il s'agissait d'une blague. Pour plus d'informations, voir [[http://community.casiocalc.org/topic/7122-program-in-a-visual-basic-ide-for-classpad/ ici]]

== Liens utiles ==

* [http://calc-casio.e-monsite.com/medias/files/programming-guide.pdf CPSDK Programming Guide]
* [http://calc-casio.e-monsite.com/medias/files/programming-tutorial.pdf CPSDK Programming Tutorial]
* [http://casiocalto.free.fr/Forum/viewtopic.php?t=474 Tuto sur CasioCalto]
* [http://www.siteduzero.com/tutoriel-3-11406-programmez-avec-le-langage-c.html Tuto C++ sur le Site Du Zéro]
* [http://documentation.renesas.com/eng/products/mpumcu/rej09b0317_sh_3sm.pdf Documentation SH3]

[[Catégorie:C/C++/Asm]]

Eigenmath

2014-05-17T20:58:08Z

Lephenixnoir : Passage brutal de la page sous KaTeX.

{{InfoBox Software
| nom=Eigenmath
| logo=Eigenmath_logo.png‎
| logoLégende=Logo de Eigenmath
| screenshot=Eigenmath_screenshot.png‎
| légende=Screenshot du portage sur Prizm
| Auteur=Gbl08ma
| développeur=
| Première version=23 Août 2013
| Dernière version=19 Mars 2014
| SouventMàJ=En développement à cadence réduite
| langage=Anglais
| langage de programmation=C / C++
| genre=Calcul Formel / CAS
| plateforme=Casio Prizm et Graph 75/85/95
| licence=GNU GPL v2
| site web=[http://gbl08ma.com/casio-prizm-software/ Version Prizm] et [http://www.planet-casio.com/Fr/programmes/voir_un_programme_casio.php?showid=3035&page=last Version Graph]
}}

Eigenmath est un logiciel libre de calcul formel (ou symbolique) développé à partir de 2002 pour PC. Codé en C++ et léger, il a fait l'objet de nombreux portages sur diverses plateformes.
Il est notamment disponible pour les calculatrices [[:Prizm|Prizm]], suite au travail de Gbl08ma et constitue le premier (et actuellement le seul) add-in de calcul formel pour cette calculatrice, ainsi que sur [[:Catégorie:Graph_75/85/95|Graph 75/85/95]] suite au travail de la communauté CnCalc et Planète-Casio.

== Interface et fonctionnement ==

=== Prizm ===

Une description exhaustive et à jour des particularités du portage sur Prizm est disponible à [https://github.com/gbl08ma/eigenmath/wiki/Usage-instructions cette adresse], en anglais cependant.

=== Graph 75/85/95 ===

À l'heure de l'écriture de l'article, le programme s'organise d'une manière similaire à l'application Run-Mat de Casio, c'est à dire organisé autour d'une zone centrale de saisie, et d'affichage des résultats.
La saisie se fait de manière «linéaire». Le clavier de la machine se comporte au maximum comme dans les applications natives de Casio, les fonctions usuelles (opérateurs, fonctions trigonométriques, etc) et caractères alpha-numériques étant disponibles avec les mêmes combinaisons de touches.
Par défaut, les résultats complexes sont affichés en utilisant un moteur de rendu en écriture, mais leur affichage n'est pas encore intégré dans la console. Il faudra alors se positionner sur la ligne correspondant au résultat souhaité, où apparaîtra alors : «Pretty print», et presser [EXE] pour qu'un fenêtre s'ouvre permettant de visualiser le résultat. Si celui ci est trop grand pour être affiché dans l'écran, il sera possible de se déplacer grâce aux flèches. Il est possible de désactiver ce mode de visualisation, pour retrouver des résultats sous forme «linéaire» intégrés à la console en décochant l'option «pretty print» dans le menu ([Shift] + [Menu], puis [EXE] sur l'option), réglage qui sera sauvegardé.
L'historique de la console conserve les 50 dernières lignes. Il est possible de réutiliser une ligne déjà tapée en se rendant sur celle-ci, puis en saisissant [Shift] + [8], ce qui collera la ligne souhaitée dans la ligne courante d'entrée.

Pour une utilisation plus facile des fonctionnalités offertes par Eigenmath, six menus associés aux touches [F1] à [F6] sont disponibles par défaut et affichés en bas de l'écran. Pour accéder aux fonctions de chacun des menus, il suffit de presser la touche [F⋅] correspondante, de se déplacer sur la fonction souhaitée et de presser [EXE] ce qui l'ajoutera dans la ligne courante (on peut aussi directement presser le nombre correspondant à cette fonction lorsque le menu est affiché). Ces menus ne sont pas exhaustifs, et ne regroupent pas l'intégralité des fonctions disponibles dans Eigenmath. Il est cependant possible de les personnaliser pour qu'ils soient plus adapatés à une utilisation précise. En effet, au premier lancement d'Eigenmath, est crée un fichier ''FMENU.cfg'' à la racine de la mémoire de stockage contenant le menu affiché. Il suffit d'éditer ce fichier (soit directement sur la machine à l'aide d'un éditeur comme [http://www.planet-casio.com/Fr/programmes/programme2186-1-edit-Neptune45-programme.html Edit] par exemple, soit sur un ordinateur et en [[Transferts|transférant]] le fichier sur la machine une fois celui-ci modifié) dont la syntaxe est assez explicite (prendre pour modèle celui par défaut). Au plus 7 entrées par catégorie sont utilisables.

Il est aussi possible de créer ses propres fonctions qui seront chargées au démarrage du programme en créant un fichier ''USER.eig'' à la racine de la mémoire de stockage. Ce fichier devra contenir, sur chaque ligne, le définition d'une fonction ou une affectation telle qu'elle serait effectuée en direct dans la zone de saisie. D'éventuelles erreurs (de syntaxe ou mathématiques par exemple) seront signalée au démarrage. Le fichier suivant permet, par exemple, d'affecteur au démarrage une valeur à $ n $ et de définir la fonction sinus cardinal :
n = pi/2
sinc(x) = sin(x)/x

Le fonction sera par la suite disponible dans le programme ; on aura par exemple :

<syntaxhighlight>
> sinc(n)
2/pi
</syntaxhighlight>

== Variables spéciales ==
Par défaut, deux variables sont initialisées par Eigenmath, et il est souvent intéressant de ne pas les redéfinir pendant l'éxécution.

=== last ===
La variable ''last'', accessible via la combinaison [Shift]+[(-)] pointe résultat de la dernière opération réussie, et permet donc d'utiliser ce résultat dans la prochaine opération.
=== i ===
La variable ''i'', qui correspond, comme habituellement, à l'unité imaginaire, est défini au lancement du programme par :
<syntaxhighlight> > i = sqrt(-1)</syntaxhighlight>

== Description des fonctions ==

Sont décrites ici les fonctions disponibles dans Eigenmath. Si il est possible de taper le nom des fonctions caractère par caractère, souvent, elles sont accessibles plus simplement dans le programme via une combinaison de touche ou un menu. Lorsque c'est le cas, cela est précisé ici.

=== Nombres complexes ===

==== Opérations élémentaires ====

{{Commande|Argument|<syntaxhighlight> > arg(z)</syntaxhighlight>|Calcule l'argument du nombre complexe $ z $.|menu ''Complex number'' du catalogue|menu ''Cplx'' ([F3])}}

{{Commande|Conjugaison|<syntaxhighlight> > conj(z)</syntaxhighlight>|Calcule le conjugué du nombre complexe $ z $.|menu ''Complex number'' du catalogue|menu ''Cplx'' ([F3])}}

{{Commande|Partie imaginaire|<syntaxhighlight> > imag(z)</syntaxhighlight>|Calcule la partie imaginaire du nombre complexe $ z $.|menu ''Complex number'' du catalogue|menu ''Cplx'' ([F3])}}

{{Commande|Partie réelle|<syntaxhighlight> > real(z)</syntaxhighlight>|Calcule la partie réelle du nombre complexe $ z $.|menu ''Complex number'' du catalogue|menu ''Cplx'' ([F3])}}

{{Commande|Module|<syntaxhighlight> > mag(z)</syntaxhighlight>|Calcule le module du nombre complexe $ z $.|menu ''Complex number'' du catalogue|menu ''Cplx'' ([F3])}}

==== Changement de forme ====

{{Commande|Forme polaire|<syntaxhighlight> > polar(z)</syntaxhighlight>|Donne la forme polaire du nombre complexe $ z $.|menu ''Complex number'' du catalogue|menu ''Cplx'' ([F3])}}

{{Commande|Forme cartésienne|<syntaxhighlight> > rect(z)</syntaxhighlight>|Donne le forme polaire du nombre complexe $ z $.|menu ''Complex number'' du catalogue|menu ''Cplx'' ([F3])}}

{{Commande|Forme étrange|<syntaxhighlight> > clock(z)</syntaxhighlight>|Donne la «clock form» du nombre complexe $ z $, c'est une sorte de forme polaire, mais basée sur -1 et non sur l'exponentielle ; je ne l'ai jamais vue ailleurs, et ne sais pas vraiment comment ça se nomme en français…|menu ''Complex number'' du catalogue|}}

=== Algèbre linéaire ===

==== Définir une matrice ====

{{Commande|Matrice identité|<syntaxhighlight> > unit(n)</syntaxhighlight>|Renvoie la matrice identité de taille $ n $.|menu ''Linear algebra'' du catalogue|}}

{{Commande|Matrice nulle|<syntaxhighlight> > zero(i,j,…)</syntaxhighlight>|Renvoie la matrice nulle de taille $ i \times j $. Lorsque utilisée avec plus d'arguments, la fonction renvoie le tenseur nul de la dimension précisée.|menu ''Linear algebra'' du catalogue|}}

{{Commande|Matrice de Hilbert|<syntaxhighlight> > hilbert(n)</syntaxhighlight>|Renvoie la matrice de Hilbert d'ordre $ n $.|menu ''Linear algebra'' du catalogue|menu ''alge'' ([F4])}}

De manière général, on utilise la syntaxe suivante pour définir une matrice :
<syntaxhighlight> > M = ((1,2,3),(4,5,6))</syntaxhighlight>
On a ainsi défini la matrice $ M = \begin{pmatrix}
1 & 2 & 3\\
4 & 5 & 6\\
\end{pmatrix} $

==== Définir un vecteur ====

On définit un vecteur avec la syntaxe suivante :

<syntaxhighlight> > x = (a,b,c,…)</syntaxhighlight>

==== Opérations sur les matrices ====

{{Commande|Comatrice|<syntaxhighlight> > adj(M)</syntaxhighlight>|Renvoie la comatrice de la matrice carrée $ M $.|menu ''Linear algebra'' du catalogue|menu ''alge'' ([F4])}}

{{Commande|Cofacteur|<syntaxhighlight> > cofactor(a,i,j)</syntaxhighlight>|Retourne le cofacteur $ A_{i,j} $ de la matrice carrée $ a $.|menu ''Linear algebra'' du catalogue|}}

{{Commande|Trace|<syntaxhighlight> > contract(M)</syntaxhighlight>|Retourne la trace de la matrice carrée $ M $. Plus généralement, si $ M $ est un tenseur, il est possible de préciser, en arguments supplémentaires, les composantes sur lesquelles sommer (sur les matrices, les arguments supplémentaires sont donc, par défaut, égaux à 1 et 2)|menu ''Linear algebra'' du catalogue|menu ''alge'' ([F4])}}

{{Commande|Déterminant|<syntaxhighlight> > det(M)</syntaxhighlight>|Calcule le déterminant de la matrice carrée $ M $.|menu ''Linear algebra'' du catalogue|menu ''alge'' ([F4])}}

{{Commande|Dimension|<syntaxhighlight> > dim(M,n)</syntaxhighlight>|Retourne la dimension de $ M $ selon la n-ème composante (1 pour le nombre de ligne, 2 pour les colonnes ; se généralise aux tenseurs).|menu ''Linear algebra'' du catalogue|}}

{{Commande|Valeurs propres|<syntaxhighlight> > eigenval(M)</syntaxhighlight>|Retourne les valeurs propres de $ M $.|menu ''Linear algebra'' du catalogue|}}

{{Commande|Vecteurs propres|<syntaxhighlight> > eigenvec(M)</syntaxhighlight>|Retourne les vecteurs propres de $ M $.|menu ''Linear algebra'' du catalogue|}}

{{Commande|Valeurs et vecteurs propres|<syntaxhighlight> > eigen(M)</syntaxhighlight>|Stocke les valeurs propres de $ M $ sur la diagonale de la matrice $ D $ et les vecteurs propres de $ M $ dans les colonnes de la matrice $ Q $ (où $ D $ et $ Q $ sont les matrices désignées par les symboles ''D'' et ''Q'' dans Eigenmath)|menu ''Linear algebra'' du catalogue|}}

{{Commande|Inverse|<syntaxhighlight> > inv(M)</syntaxhighlight>|Retourne la matrice inverse de $ M $.|menu ''Linear algebra'' du catalogue|menu ''alge'' ([F4])}}

{{Commande|Rang|<syntaxhighlight> > rank(M)</syntaxhighlight>|Calcule le rang de la matrice $ M $. (Plus généralement, s'adapte aux tenseurs)|menu ''Linear algebra'' du catalogue|}}

{{Commande|Produit dyadique|<syntaxhighlight> > outer(A,B)</syntaxhighlight>|Calcule le produit dyadique de $ A $ et de $ B $.|menu ''Linear algebra'' du catalogue|}}

{{Commande|Transposition|<syntaxhighlight> > transpose(M)</syntaxhighlight>|Renvoie la matrice transposée de $ M $. S'adapte aux tenseurs si sont précisées en plus les composantes sur lesquelles transposer.|menu ''Linear algebra'' du catalogue|}}

==== Opérations sur les vecteurs ====

{{Commande|Produit scalaire|<syntaxhighlight> > dot(x,y)</syntaxhighlight>|Calcule le produit scalaire de $ x $ par $ y $. S'adapte plus généralements aux tenseurs et donc aux matrices.|menu ''Linear algebra'' du catalogue|}}

{{Commande|Produit vectoriel|<syntaxhighlight> > cross(x,y)</syntaxhighlight>|Calcule le produit vectoriel de $ x $ par $ y $, vecteurs de dimension 3.|menu ''Linear algebra'' du catalogue|}}

{{Commande|Rotationnel|<syntaxhighlight> > curl(x)</syntaxhighlight>|Calcule le rotationnel du vecteur $ x $ de dimension 3.|menu ''Linear algebra'' du catalogue|menu 'alge' ([F4])}}

=== Polynômes, fractions ===

On confond polynômes et fonctions polynomiales, dans la mesure où les opérations relatives aux polynômes s'appliquent à des fonctions définies dans Eigenmath sous la forme :
<syntaxhighlight> > P(x) = a * x^n + b * x^(n-1) + … + c</syntaxhighlight>

==== Opérations élémentaires ====

{{Commande|Degré|<syntaxhighlight> > deg(P,x)</syntaxhighlight>|Retourne le degré du polynôme $ P $ en la variable $ x $. Si la variable étudiée est $ x $, le second paramètre peut être omis.|menu ''Polynomial'' du catalogue|menu ''poly'' ([F5])}}

{{Commande|Coefficient dominant|<syntaxhighlight> > leading(P,x)</syntaxhighlight>|Retourne le coefficient dominant du polynôme $ P $ en $ x $.|menu ''Polynomial'' du catalogue|}}

{{Commande|Coefficient|<syntaxhighlight> > coeff(P,x,n)</syntaxhighlight>|Retourne le coefficient de $ x^n $ dans le polynôme $ P $.|menu ''Linear algebra'' du catalogue|menu ''poly'' ([F5])}}

==== Autres opérations ====

{{Commande|Décomposition en éléments simples|<syntaxhighlight> > expand(R,x)</syntaxhighlight>|Retourne la décomposition en éléments simples de la fraction rationnelle $ Q $ en $ x $. Pour des fractions en $ x $, le second argument peut être omis.|menu ''Polynomial'' du catalogue|menu ''calc'' ([F1])}}

{{Commande|Factorisation|<syntaxhighlight> > factor(P,x,…)</syntaxhighlight>|Factorise le polynôme $ P $ en $ x $. Pour des polynômes à plusieurs variables, il est possible de préciser plusieurs variables selon lesquelles le polynôme sera successivment factorisé. Pour un polynôme en $ x $, le second argument peut être omis.|menu ''Polynomial'' du catalogue|menu ''calc'' ([F1])}}

{{Commande|Division euclidienne|<syntaxhighlight> > quotient(P,Q,x)</syntaxhighlight>|Retourne le quotient de la division euclidienne du polynôme $ P $ par $ Q $ (polynômes en $ x $, ce dernier argument peut être omis si les polynômes sont tous deux en $ x $).|menu ''Polynomial'' du catalogue|menu ''poly'' ([F5])}}

{{Commande|Racines|<syntaxhighlight> > roots(P,x)
> nroots(P,x)</syntaxhighlight>|La première fonction retourne les racines du polynôme P sous forme exacte lorsque le programme parvient à les déterminer. La seconde calcule des valeurs approchées des racines de P. Le dernier argument peut être omis si le polynôme est en $ x $.|menu ''Polynomial'' du catalogue|menu ''poly'' ([F5])}}

=== Arithmétique ===

==== Nombre premiers ====

{{Commande|N-ième nombre premier|<syntaxhighlight> > prime(n)</syntaxhighlight>|Retourne le n-ième nombre premier. $ n $ doit être compris entre 1 et 10000|menu ''Calculus'' du catalogue|menu ''arit'' ([F6])}}

{{Commande|Test de primalité|<syntaxhighlight> > isprime(n)</syntaxhighlight>|Retourne 1 si le nombre $ n $ est premier, 0 sinon|menu ''Calculus'' du catalogue|menu ''arit'' ([F6])}}

{{Commande|Factorisation|<syntaxhighlight> > factor(n)</syntaxhighlight>|Retourne la décomposition en produit de facteurs premiers de $ n $|menu ''Polynomial'' du catalogue|menu ''arit'' ([F6])}}

==== Opérations sur les entiers ====

{{Commande|PGCD|<syntaxhighlight> > gcd(a,b)</syntaxhighlight>|Retourne le PGCD de $ a $ et de $ b $|menu ''Calculus'' du catalogue|menu ''arit'' ([F6])}}

{{Commande|PPCM|<syntaxhighlight> > lcm(a,b)</syntaxhighlight>|Retourne le PPCM de $ a $ et de $ b $|menu ''Calculus'' du catalogue|menu ''arit'' ([F6])}}

{{Commande|Division euclidienne|<syntaxhighlight> > mod(a,b)</syntaxhighlight>|Retourne le reste dans le division euclidienne de $ a $ par $ b $|menu ''Calculus'' du catalogue|menu ''arit'' ([F6])}}

{{Commande|PPCM|<syntaxhighlight> > lcm(a,b)</syntaxhighlight>|Retourne le PPCM de $ a $ et de $ b $|menu ''Calculus'' du catalogue|menu ''arit'' ([F6])}}

{{Commande|Diviseurs|<syntaxhighlight> > divisor(n)</syntaxhighlight>|Retourne les diviseurs de $ n $. Plus généralement, si l'argument est une expression, seront retournées les diviseurs de l'expression.|menu ''Calculus'' du catalogue|}}

=== Analyse ===

==== Trigonométrie ====

Les fonctions suivantes sont implémentées :
{|
|-
| <syntaxhighlight> > cos(x) </syntaxhighlight> || <syntaxhighlight> > arccos(x) </syntaxhighlight>
|-
| <syntaxhighlight> > sin(x) </syntaxhighlight> || <syntaxhighlight> > arcsin(x) </syntaxhighlight>
|-
| <syntaxhighlight> > tan(x) </syntaxhighlight> || <syntaxhighlight> > arctan(x) </syntaxhighlight>
|-
| <syntaxhighlight> > cosh(x) </syntaxhighlight> || <syntaxhighlight> > arccosh(x) </syntaxhighlight>
|-
| <syntaxhighlight> > sinh(x) </syntaxhighlight> || <syntaxhighlight> > arcsinh(x) </syntaxhighlight>
|-
| <syntaxhighlight> > tanh(x) </syntaxhighlight> || <syntaxhighlight> > arctanh(x) </syntaxhighlight>
|-
| <syntaxhighlight> > expcos(x) </syntaxhighlight> || <syntaxhighlight> > expsin(x) </syntaxhighlight>
|}

==== Opérations ====

{{Commande|Dérivation|<syntaxhighlight> > d(f,x)</syntaxhighlight>|Calcule la dérivé de l'expression $ f $ selon la variable $ x $|menu ''Calculus'' du catalogue|menu ''calc'' ([F6]) (entrée ''derive'' )}}

{{Commande|Primitivation|<syntaxhighlight> > integral(f,x)</syntaxhighlight>|Calcule une primitive de $ f $ par rapport à la variable $ x $|menu ''Calculus'' du catalogue|menu ''calc'' ([F6])}}

{{Commande|Calcul d'intégrale (simple)|<syntaxhighlight> > defint(f,x,a,b,…)</syntaxhighlight>|Calcule l'intégrale de $ f $ par rapport à la variable $ x $ entre $ a $ et $ b $.|menu ''Calculus'' du catalogue|}}

{{Commande|Calcul d'intégrale (multiple)|<syntaxhighlight> > defint(f,x,a,b,y,c,d,…)</syntaxhighlight>|Calcule l'intégrale double de $ f $ par rapport à la variable $ x $ entre $ a $ et $ b $, et par rapport à $ y $ entre $ c $ et $ d $. Il est possible de calculer des intégrales d'ordre supérieur en rajoutant des arguments à la fonction.|menu ''Calculus'' du catalogue|}}

{{Commande|Développement en série de Taylor|<syntaxhighlight> > taylor(f,x,n,a)</syntaxhighlight>|Retourne la série de Taylor d'ordre $ n $ de $ f $ par rapport à la variable $ x $ au voisinnage de $ a $|menu ''Calculus'' du catalogue|menu ''calc'' ([F6])}}

==== Simplification, changement de forme ====

{{Commande|Forme exponentielle|<syntaxhighlight> > circexp(f)</syntaxhighlight>|Retourne une expression de $ f $, où les fonctions circulaires sont sous forme exponentielle. Permet parfois de simplifier certaines expressions.<|menu ''Calculus'' du catalogue|menu ''calc'' ([F6]) (entrée ''derive('')}}

{{Commande|Simplification|<syntaxhighlight> > simplify(f)</syntaxhighlight>|Essaie d'aboutir à une forme plus simple de $ f $.|menu ''Other'' du catalogue|menu ''calc'' ([F6])}}

{{Commande|Facteurs communs|<syntaxhighlight> > condense(f)</syntaxhighlight>|Repère et met en facteurs d'éventuels facteurs communs dans l'expression de $ f $.|menu ''Other'' du catalogue|}}

{{Commande|Mise au même dénominateur|<syntaxhighlight> > rationalize(f)</syntaxhighlight>|Met les termes de $ f $ au même dénominateur.|menu ''Other'' du catalogue|}}

Lua Fx

2014-05-11T11:51:45Z

-florian66- : /* Les variables */

{{InfoBox Software
| nom=Lua FX
|logo=Lua.gif
| Auteur=
Luiz Henrique de Figueiredo, Roberto Ierusalimschy et Waldemar Celes

| développeur=Vebveb, Louloux
| SouventMàJ=non

| langage=Anglais
| langage de programmation=[[BASIC]], [[C (langage)|C]], [[C++]]

}}
Le LuaFX est un langage de programmation à mi-chemin entre le Basic et le C et offre de bonnes performances, supérieures au Basic et au MLC ! Les programmes se présentent sous forme d'add-ins à transférer sur la calculatrice Casio.

Le LuaFX est compatible avec les Graph 75/85/95 (SD) et 100(+) grâce à un formidable travail de Vebveb et de la communauté Casio.

On précompile les .lua sur pc en .lc et on les transfère sur g100 pour les executer.
Sur g85 (et autres calculatrices de la même famille), le basic et le C sont bien plus performants que sur g100, mais le lua reste un langage attractif par ses possibilités, sa simplicité et sa rapidité.
La taille maximale d'un .lc est plus faible que sur g100 pour la g85. En revanche, on peut exécuter des .lua on-calc (mais la taille maximale est plus faible et il peut y avoir des problèmes de compilations: préférez compiler sur pc).
La vitesse du lua sur g85 a été harmonisée partiellement avec celle du lua pour g100 afin que les programmes soient compatibles.
Ce document vise à vous donner les bases de la programmation du lua sur g100.
La partie langage lua en lui même peut être complété par les nombreuses documentations anglaises. (par exemple on peut aussi déclarer une variable 2::=x au lieu de x=2)
Le lua est un des langages interprétés les plus rapides. Il fonctionne en deux étapes: d'abord le programme .lua est lu et est précompilé en .lc, puis il est exécuté via le programme précompilé.

==Le lua ==

===Les variables===

Il y a différents types de variable.
Une variable peut contenir des majuscules, des minuscules ou des chiffres (à condition que le nom ne commence pas par un chiffre)
exemples: B R55 nom Nom Rnom2 sont des variables différentes.

Les différents type sont nil, nombre, table, string, userdata et fonction
– nil: la variable est vide. Si on ne lui donne aucune valeur, elle reste à nil. Une variable ayant pour valeur nil est supprimée de la mémoire par le 'garbagecollector' du lua.
– Nombre: la variable contient un nombre de définition 'float' (c'est à dire que le nombre correspond aux nombres float en C) : le nombre peut aller de -3.4*e-38 à 3.4*e38
Exemple: nb= 4.7e9 ou nb = 534
– table: la variable est une table (= équivalent liste ou matrice)
exemple: C= {} --on initialise la table
C[40]=5 –on met 5 dans la 40e case.
Une table peut contenir des nombre, des strings, voir des fonctions.
– String: la variable contient un mot ou une phrase. (='chaine de caractères')
Un string prend très peu de place.
un sprite est contenu dans un string pour prendre moins de place.
– Booléen: la variable contient true ou false.
A= (1==2) --A contient false
A= ((y+x)<w) --A contient true ou false
A noter que nil et false ont la même table de vérité, (if nil then ... sera équivalent à if false then ..)
alors que les autres types et true ont même table de vérité (if nombre then .. pareil que if true)
– Userdata: Réservé aux fichiers (voir librairie file)
– Fonction: la variable réfère à une fonction de la librairie ou une fonction lua
exemple: (ce qui suit '--' est un commentaire et ne fait pas partie du code)

line=nbdraw.line -- la fonction ligne réfère à la fonction nbdraw.line
function rectangle(x1,y1,x2,y2) --rectangle est une fonction lua de 4 paramètres
line(x1,y1,x1,y2) --dessine le rectangle
line(x2,y1,x2,y2)
line(x1,y1,x2,y1)
line(x1,y2,x2,y2)
end -- on signale la fin de la fonction

rectangle(10,10,20,20) --on l'appelle dans la boucle principale

Remarque: placer local devant un variable permet d’accélérer son appel et donc la vitesse du programme. Si la variable locale est déclarée dans une fonction, elle lui est spécifique. Une variable non locale est une variable globale. Exemple:

local resultat -- la variable est équivalente à une globale mais en plus rapide
y=2 -- y est une globale
function calcul(entree) --entree est automatiquement locale à la fonction
local x --x est locale à la fonction
x=(2/entree)
return y+x
end

resultat=calcul(y)
x=resultat+2 -- x est different de x dans la fonction calcul. Ici x est globale.

Pour apprendre plus en profondeur le lua, je vous conseille ce site:
http://lua.gts-stolberg.de/fr/index.php

Les différentes opérations possibles sur les nombres sont:
a = a + b
a= a – b
a= -a -- on prend l'opposé de a
a= a%b (modulo; c'est à dire que a contient le reste de la division euclidienne de a par b)
a = a * b (multiplication)
a = a / b
a = a^b (puissance. Ne marche qu'avec b entier. Si vous utilisez un b à virgule, utilisez pow(a,b) de math.lua)
On peut utiliser les parenthèses.

Pour connaître le nombres de caractères dans une string ou dans une table ainsi:

phrase = "coucou," -- le nom de la variable import peu
suite = "je m'appelle veb"
longueur = #phrase -- contient le nombre de lettres. Ici 7.
phase = phrase .. suite -- on ajoute suite à phrase
-- phrase contient "coucou,je m'appelle veb"
longueur = #phrase -- contient la nouvelle longeur de la string

Si on veut que cela contienne "coucou, je m'appelle veb" (on rajoute un espace après , ),
on fait:

phrase = phrase .. " " .. suite

on peut aussi connaitre la longueur d'une table:

table = {} --on initialise la table

table [1] = {1,2,3} -- on crée une 2 e dimension (matrice) dans cette case
-- #table contient 1 mais #table[1] contient 3

Le paragraphe suivant n'est pas obligatoire, mais il peut permettre de mieux comprendre quelques imprécisions, ou légères erreurs.

===les nombres plus en détail===

Les float:
Le Lua utilise le système des nombres flottants de précision simple tenant sur 4 octets (float).
La précision est assez élévé et les calculs rapides, mais on est moins précis que pour le système utilisé par casio par exemple.
Tout les entiers de 0 à 16777215 (et leurs négatifes associés) sont précis à 100%
Au delà les nombres seront arrondis à l'entier pair, puis tout les 4, ....
Pour les nombres non entiers, la précision est en fait une sorte d'arrondi:

Par exemple le codage précis de 3,3 est impossible : si vous rentrez x = 3.3, en réalité x contiendra 3.2999999523162841796875 mais x == 3.3 renverra vrai.
Lors de l'affichage de x, nbdraw.print affichera 3,3 car la précision d'affichage est de 6 par défaut (c'est à dire que l'arrondi se fait pour que le nombre tienne dans 6 chiffres et l'on enlève les 0)
Si vous augmentez la précision d'affichage vous pourrez voir l'imprécision.

Si vous voulez par exemple mettre 2*pi dans une variable, pour ne pas cumuler les erreurs il vaut donc mieux rentrer manuellement 2pi plutôt que de le calculer.

==Les librairies lua sur g100/85 (les fonctions intégrées)==

===Les fonctions générales===

====Les fonctions non-graphiques existant dans l’édition standard du lua====

Il se peut que vous n'utilisiez jamais ces fonctions, Néanmoins sachez qu'elles existent.

--base.collectgarbage(option [,argument])
Option peut prendre un de ces mots:
-"stop": arrête la collecte des valeurs inutilisées.
-"restart": recommence la collecte.
-"collect": Fait une collecte complète (à utiliser pour libérer de la mémoire)
Cette fonction libère de la place pour l’exécution du programme. Attention, la place libérée n'est que pour de nouvelles valeurs lua (exemple: tableau).
-"count": retourne en octets la place approximative utilisé par lua.
-"step": il faut mettre la taille de la place que vous voulez tenter de libérer dans argument, et le programme va essayer de le libérer.(en kilo-octets)
-"setpause": la valeur de argument se met dans la valeur pause du 'garbagecollector'. Retourne l'ancienne valeur de pause. Si pause=100, alors le garbage collector collecte tout le temps (de même pour des valeurs inférieurs). Par défaut, pause=200, c'est à dire que la garbage collector se lance lorsque l'utilisation de la mémoire double.
-"setstepmul": le step multiplieur prend la valeur de argument. Retourne l'ancienne valeur.
Si c'est 200 (valeur par défaut), le garbage collector a une vitesse normale. 100 signifie un contrôle plus poussé, et, par conséquent, plus lent...

--base.error(message[,niveau])
arrête le programme en renvoyant un message d'erreur donné par message.
Si niveau=1(défaut) l'erreur est complétée de la fonction dans lequelle l'erreur a été déclaré.
Si niveau=0 il n'y a pas d'informations supplémentaires.
Si niveau=2 on indique où on a appelé la fonction qui a rapporté l'erreur.
Si la fonction rapportant l'erreur a été appelé avec base.pcall, l'erreur est capturé par base.pcall et le programme ne s'arrète pas

--base.next(table [,index])
Cette fonction renvoi la prochaine case non vide du tableau. Si base.next(table) renvoi nil, la table est vide.

--base.pcall(fonction, argument1delafonction, argument2,...)
Lance fonction dans un mode protégé. Si une erreur arrive, elle est capturée et le programme ne s'arrète pas. Retourne true et les résultats si il n'y a pas eu d'erreur et false et l'éventuel message d'erreur sinon.

--base.tonumber( e [,base])
si e n'est pas un nombre ou un string convertible en un nombre, la fonction retourne nil. Sinon elle renvoi le nombre converti dans la base demandé (défaut = base 10)
en base 10 on peut avoir des nombres à exposants ou virgules, ce qui n'est pas le cas des autres bases. La base 10 est celle où sont écrit les nombres courants.
La base est comprise entre 2 et 36. Si la base n'est pas 10, le nombre doit être un entier.

--base.tostring(e)
Convertit n'importe quel e donné en string.

--base.type( v)
retourne dans un string le type de l'argument:
peut retourner: "nil", "number", "string", "boolean", "table", "function", "thread", ou "userdata"

--base.unpack(list [,i [,j]])
retourne tout les éléments d'une table à une dimension entre i(1par défaut) et j(par défaut la longueur de la liste)
C'est pareil que en lua: return list[i], list[i+1], •••, list[j]

--base.getfenv(fonction)
retourne la tableau contenant l'environnement global de la fonction (le tableau où les variables globales sont lues et enregistrées pour cette fonction. Le tableau par défaut est la variable globale _G . (rq: _G._G=_G )

--base.setfenv(fonction,tableau)
change l'environnement global de la fonction

--base.setmetatable(table, metatable)
Attribue metatable comme metatable de la table. On ne peut que changer la métatable d'une table en lua. Si metatable vaut nil, alors enlève la métatable de la table, et si la métatable originale avait un index “__metatable” (métatable protégée) alors provoque une erreur.
La fonction retourne table.
--base.getmetatable(object)
Si object n'a pas de métatable, retourne nil.
Sinon si sa métatable a un index “__metatable”, retourne le contenu de cet index.
Sinon retourne la métatable de l'objet.

--table.insert(table [,pos],valeur)
insère valeur à la position donnée (si pos n'est pas donné, alors pose à la toute fin)dans la table.

--table.remove(table [,pos])
retire la valeur à la position donnée et décale le tableau. Retire la dernière valeur si pos n'est pas donné.

--string.byte (s [, i [, j]])
Retourne le contenu numérique des char s[i], s[i+1], •••, s[j].
La valeur défaut de i est 1 et de j est i.

--string.char(...)
reçoit des nombres entre 0 et 255 et en fait un string. (en correspondance avec les valeurs ascii)

--string.sub(s, i [, j])
retourne la sous-string commençant au caractère i et finissant par j ème caractère.

Les fonctions de gestion des strings peuvent vous être très utile car:
-dans une string chaque caractère ne prend qu'un octet (au lieu de plus de 15 pour la case d'un tableau)
vous pouvez donc créer par exemple un map d'un niveau avec uniquement des nombres entre 0 et 255 et lire la map avec string.byte . Cela peut vous permettre de compresser des données.
ASTUCE: Stockez vos map dans des strings puis écrivez la string dans un fichier (librairie file). Réouvrez le fichier en mode "char". Hop: vous pouvez lire dans le fichier toutes les valeurs de votre niveau (nombres entre 0 et 127).
-dans un sprite 5 couleurs(contenu dans un string), les 2 premières valeurs correspondes aux coordonnées à l'origine (x et y), c'est à dire que si x= 4 et y = 4, le sprite sera affiché ) x+4 et y+4
Cela peut-être pratique pour éviter de recalculer des x et des y pour chaques sprites. Ces fonctions de manipulement des strings peut vous permettre à tout moment de changer les 2 premières valeurs du string du sprite.

====Les fonctions non-graphiques spécifiques à nos graph====

--key (numero de touche) '''attention : fonction usuelle'''
retourne false si la touche n'est pas pressée, sinon retourne true si elle est pressée.
Voici le tableau de correspondance des touches.
Si le numero est 0, renvoi si au moins une touche est pressée. ( pas 100% fonctionnel sur g100, car renvoi des fois false même si quelque chose est pressé)

--misc.numcalc ()
retourne 100 sur g100 et 85 sinon

--misc.exit ()
le programme quitte brutalement et retourne au menu.

--misc.tostring2 (nombre)
retourne le nombre en chaine de caractère (uniquement nombres entiers entre -2147483647 et 2147483647). plus rapide que base.tostring . De plus le nombre n'est jamais affiché sous forme exponentielle.

--misc.contrast(nb)
Le nombre doit être 1 ou -1. diminue(-1) ou augmente le contraste(1) (attention: pas de limite est fixée et la calc peut ne pas supporter tout les contrastes )

--misc.math ([parametre] ,nombre)
Fait quelque chose de différent en fonction de paramètre:
-"ln" retourne ln(nombre) ln est le logarithme népérien (log(x) = ln(x)/ln(10)
-"exp" retourne exp(nombre)
-"sqrt" ou "racine" retourne la racine carrée du nombre
On peut aussi calculer la racine avec exp((ln(x))*0.5) ), mais sqrt est plus rapide (et plus précis dans certains cas, comme les racines des grands nombres)

Si le calcul est impossible pour sqrt ou ln (nombre négatif par exemple) la fonction retourne nil

--misc.wait(nb de fois 2centisecondes)
met le processeur (et donc le programme) en pause pendant le temps indiqué.
Utilisez cette fonctions pour ralentir les menus,...
Elle permet d'économiser les piles (elle consomme 10 fois moins qu'une instruction normale sur g100 par exemple)
exemples:
local wait=misc.wait
wait(10) -- attends 0,2 secondes
wait(20) -- 0,4secondes
wait(50) -- 1seconde
wait(100) -- 2 secondes
wait(3000) – 1minute

Par contre à faible nombre, la fonction n'est pas exacte, alors utilisez wait(1) et wait(2) dans un boucle attendant une pression de touche afin de garder un bonne réactivité et diminuant drastiquement la consommation, mais ne l'utilisez pas dans une boucle de jeux, car en fonction de certains paramètres, l'attente est différente. (De plus le résultat est différent sur g100 et g85)

--misc.random(max)
renvoi un nombre aléatoire entre 0 et max-1. Le nombre renvoyé est un entier.
max doit être inférieur à 32767
Exemple: misc.random(1000) retourne un nombre entre 0 et 999

--int(nombre) attention : fonction usuelle
renvoi la partie entière d'un nombre.

--misc.chrono_set([numero_du_chrono])
permet de démarrage d'un chronomètre (deux emplacements : 1 (par défaut) et 2).
Si le chronomètre était déjà démarré, permet de le réinitialiser.
--misc.chrono_read([numero_du_chrono],[mode])
lit le temps chronométré par un chronomètre (le 1 si vous ne spécifiez pas le numéro)
deux formats sont possibles:
.si vous ne rentrez pas de second argument, alors il sera retourné un entier correspondant au temps passé en 1/50 de secondes sur g100 et en 1/64 de secondes sur g85.
.si vous rentrez un second argument, alors il sera retourné dans cet ordre le temps passé : centiseconde, seconde, minute

Le chronomètre est précis au 1/50e de secondes sur g100 et 1/64e de secondes sur g85.
La premier mode d'affichage permet de gérer des évènements arrivant à fréquence élevée ( déplacement ennemi, ...), alors que le second mode permet plutôt d'avoir une idée du temps qui passe sur un durée plus longue.

--misc.modlist()
--misc.modload(nom)
Le lua est assez limité en place sur nos graph.

-> La solution est de charger un .lua principal et de charger ensuite, quand on a besoin, d'autres .lua (qui peuvent contenir des données sur un niveau, des fonctions, une librairie en lua, ...).
Sur g100 il faut que tout soit précompilé en .lc . C'est conseillé sur g85 car la lecture de .lua consomme beaucoup de mémoire.

Utiliser un module lua consomme un peu plus de mémoire que si on avait tout mis dans un seul fichier, mais cela apporte des avantages:
-On ne peut supprimer des fonctions de la mémoire que si c'est dans un module.
-Si on a beaucoup de données, on peut utiliser plusieurs modules pour les stocker. En chargeant un module à la fois on consomme moins de mémoire que si tout était dans un seul fichier.
-Cela permet aussi de faire des librairies.

A noter: seules les variables (et fonctions) globales dans le module sont visibles.

Un fichier .lua chargeable avec modload s'appelle un module.
Le .lua doit contenir une string finissant par "module nom_du_module" (le nom doit avoir une taille inférieure ou égale à 8)
modlist renvoi les noms de tout les modules trouvés.
modload tente de charger le module avec le nom indiqué.

Exemple 1: Je veux charger une librairie et je ne souhaite pas la décharger.

f,err = misc.modload ( nom)
if f == nil -- si il y a erreur, f = nil
then
print(err) -- err contient le message d'erreur
end -- affiche l'erreur lors du chargement du fichier
f() -- execute le fichier (et donc défini les fonctions et les variables globales qui deviennent accessibles)

Remarque: f correspond en fait à une fonction qui contient tout le code du module. L’exécuter revient à lancer le programme contenu dans le module.

Exemple 2: Je veux charger un module, mais je n'ai pas confiance dans le contenu: j'aimerais qu'il ne puisse pas voir les variables globales que j'ai défini et qu'il ne puisse pas les modifier.
OU : Je veux charger le module et pouvoir le supprimer de la mémoire entièrement ensuite.

f,err = misc.modload ( nom )
if f == nil -- si il y a erreur, f = nil
then
print(err) -- err contient le message d'erreur
end -- affiche l'erreur lors du chargement du fichier
tab = {base = base ; misc = misc ; nbdraw = nbdraw ; graydraw = graydraw}
base.setfenv(f, tab) – tab est maintenant l'environnement de f (contient toutes les variables globales)
f()

Toutes les variables globales de f seront définies dans tab. ( on y accède avec ' tab. ' )
Pour supprimer le module de la mémoire:
f = nil
tab = nil – il faut mettre nil aux 2 pour que ça marche
base.collectgarbage("collect") – on supprime tout le module d'un coup.

====la librairie file:====
cette librairie permet de stocker et de lire facilement dans un fichier stocké dans la ram de votre casio. Le nom du fichier doit commencer par LF et ne pas faire plus de 8 caractères. Il sera protégé d'un mot de passe pour prévenir la modification des données par l'utilisateur.
Le système permet de stocker juste ce que vous avez besoin dans un minimum de place.
Par exemple un nombre normal lua prend 4 octet dans un fichier, alors que sinon il en prend bien plus (environ 20 dans une variable locale sur g100 et plus sur g85)
Les fichiers sont ouverts sous différent mode selon le contenu des données:
"string" est le mode pour stocker des string (1 octet par caractère)
"char" est pour les entiers de -128 à 127 (1 octet)
"int" est pour les entiers de -32 768 à 32 767 (2 octets)
"float" est pour les nombres normaux utilisés par le lua (4 octets)
les données du fichier ouvert sont contenu dans une variable du type userdata.

Un fichier ne peut pas être ouvert si la taille ne correspond pas à un multiple de le taille du type demandé.
La taille totale du fichier est limitée à 32750.

A chaque création de fichier/changement de taille/suppression , il faut rechercher de nouveau tout les fichiers pour pouvoir lire/ecrire dedans/les supprimer (sauf celui que l'on vient de manipuler).

--file.new(nom,nombre_de_cases,[mode])
crée un fichier et renvoi l'userdata associé. Il y a une erreur si le fichier existe.
La taille réelle du fichier est un multiple du nombre de cases.

--file.search(nom,[mode])
renvoi un userdata contenant les données sur le fichier recherché et nil s'il n'existe pas.

--file.mode(fichier)
renvoi le mode d'ouverture du fichier

--file.resize(fichier,nombre_de_cases)
change la taille du fichier
(indisponible sur g85)

--file.delete(fichier)
supprime le fichier (et l'userdata associé est inutilisable)

--file.length(fichier)
renvoi le nombre de positions disponibles dans le fichier (pareil que #fichier)

--file.ramsize()
renvoi la place restante dans la ram.
( non disponible pour g85 )

--file.read(fichier,position,[fin])
renvoit le nombre contenu à position.
Si on attends une string, il faut indiquer la position finale. (1 caractère = 1case)
La première case est numérotée 1.

--file.write(fichier,position,nombre)
écrit le nombre (ou la string) à position.

Dans tout les cas, dès que vous utilisez une fonction à tort (en dehors du fichier, fichier non réactualisé, ...), une erreur est envoyée et le programme s'arrète, sauf si l'erreur est capturée par un pcall.

Exemple: pour rechercher un fichier et le créer s'il n'existe pas ou n'est pas de la bonne taille:

local delete = file.delete
local new = file.new
local search = file.search

-- mode est un argument facultatif
local function search_or_create ( name , taille,mode )
local result = search (name , mode)
if result then
if #result == taille then result
else delete(result) ; return new(name,taille , mode)
end
else
return new(name,taille mode)
end
end

====le noir et blanc====

Le mode noir est blanc a un repère partant du coin en haut à gauche de l'écran (le point 1,1) finissant en bas à droite (64, 128)
On a accès à une ligne et une colonne de plus qu'en basic.

L'écran est aussi divisé en colonnes et lignes pour savoir où l'on va écrire avec nbdraw.print . Cela correspond à la fonction locate en basic, sauf que l'on a droit à une ligne de plus ( colonne de 1 à 21 et ligne de 1 à 8)

En lua, on a accès à des pictures virtuelles qui correspondes à des 'pages' d'écran. (En gros si vous voulez vous avez accès à 5 buffers.)
La page 0 est la page principale où tout est affiché. On peut copier la page 0 sur la page 2 ou 3,... et inversement. On peut écrire sur une autre page et copier sur la page 0, ainsi on évite que l'utilisateur voit le dessin se dessiner (et cela évite le clignotement)
la page maximale est 5.

Si vous ne comprenez pas le système de buffer, contentez vous de savoir que ce qui s'affiche est sur la page 0 qui est l'endroit où les fonctions écrivent par défaut.

--nbdraw.print(nombre ou/et booléen(true ou false) ou/et string,[autant de paramètres que l'on veut (max 200)])
affiche tout ce que vous demandez en noir et blanc à l'endroit ou se situe le curseur virtuel (invisible) (voir nbdraw.getcursor pour savoir ou est le curseur)
Le curseur se place après le dernier caractère que nbdraw.print a écrit.
Un nbdraw.print ne doit pas afficher plus de 190 caractères (plus grand que l'écran, heureusement)
Les caractères spéciaux sont:
– '%' doit être écrit %% pour être affiché (Ne pas mettre % tout seul!)
– '\n' fait un saut de ligne sans retour à la ligne
– '\r' revient au début de la ligne (donc la passage à la ligne suivante est '\n\r'. bizzarement, '\r\n' provoquera un erreur lors du chargement "bad constant" )
– $ ne doit jamais être écrit
– on peut accèder à des caractères secondaires (voir tableau p34 du manuel du programmeur http://gprog.tk/) . On peut accèder à la seconde collone de tableau en plaçant \246 juste avant un caractère. (pas encore dispo sur g85)
Par exemple je peut afficher la flèche simple vers la droite avec : "\246\157", car \abc converti abc en caractère selon le code ascii (ex: \044 )
– on peut afficher ' et " avec \' et \"

---nbdraw.getcursor ()
retourne la collone et la ligne du curseur où va écrire nbdraw.print

--nbdraw.setcursor (ligne,colonne)
place le curseur où nbdraw.print va écrire
Cela correspond à placer où l'on va écrire comme la fonction locate en basic sauf que l'on écrit rien.
On a droit à la 8e ligne innaccessible avec locate en basic.

--nbdraw.precision(nb)
Attribue nb à la précision de la conversion par défaut des nombres (base.tostring et nbdraw.print) et chaine de caractère. Par défaut elle est de 6 chiffres significatifs (le reste est arrondi)
Si vous avez des imprecisions dans vos calculs, exemple: vous devez afficher 2.349999, la précision de 6 chiffres affichera 2.35 ou le nombre précédent si elle était de 7.

--clear( page ) attention : fonction usuelle
efface la page que vous avez indiquée (celle affichée : 0)

--nbdraw.pixeltest (x,y,[page])
renvoi 1 si la pixel est allumé, 0 sinon

Remarque: le repère est de haut en bas et de droite à gauche.
Le pixel en haut à gauche (innaccessible en basic) a pour coordonnées x=1 et y=1
et celui en bas à droite x=128 et y =64.
C'est à dire que le basic Pixtest(30,20) devient nbdraw.pixeltest(31,21) (le repère est décalé d'une ligne et une collone, puisque une ligne et une collone de plus sont disponibles.)

--nbdraw.pixel(x,y,[couleur],[page])
affiche un pixel blanc (couleur = 0) ou noir (couleur=1, par défaut) sur la page principale ou celle que vous indiquez. Si vous écrivez en dehors de l'écran, le pixel ne sera pas affiché.

--nbdraw.line(x1,y1,x2,y2,[page])
affiche une ligne noire du point (x1,y1) au point (x2,y2) sur la page principale ou celle que vous indiquez.

--nbdraw.copypage(page source, page destinataire)
Vous avez dans doute remarqué que de nombreuses fonctions peuvent prendre une 'page' comme argument.
En effet la page 0 est la page affichée et les pages de 1 à 5 sont des pages disponibles pour des dessins (vous pouvez dessinez qqch pendant que vous affichez autre chose)
Cette fonction permet par exemple de copier la page 5 sur la 0 pour afficher le contenu de la page 5.

====les 5 couleurs (blanc – gris clair – gris moyen – gris foncé – noir )====

Le repère utilisé (position des pixel avec x et y) est le même qu'en noir et blanc.
Le mode 5 couleurs s'active avec graydraw.setcolor(true) et s'éteint avec graydraw.setcolor(false)
Il s'éteind automatiquement lorsque l'on quitte.

Ce que l'on dessine est toujours d'abord dessiné dans un écran invible (buffer), puis une fois que l'on a tout dessiné, on demande à afficher l'écran invisible à l'écran (pendant que l'on redessine sur l'écran invisible, l'écran visible continu d'afficher l'ancienne image)

L'atout du mode 5 couleurs est que l'on peut utiliser des sprites: c'est à dire que l'on peut afficher un morceau d'image que l'on a prédessiné à n'importe quel x ou y (l'image peut même dépasser de l'écran sans bug)

Rq: sur g85 le gris foncé est en fait remplacé par: 1pix sur 2 du gris moyen et 1 pix sur 2 du noir.

Dessiner un sprite:
Pour dessiner un sprite, utilisez le logiciel sprite maker en mode C/C++ gxlib10 sur pc.
Une fois le sprite dessiné, enregistré et généré, copiez collez le contenu entre les guillemets entre les guillements de la table foo du fichier lua sprites.lua
Lancez dans windows sprites.lua (avec le lua pour windows)
un ficher Prog.lua est apparu avec le sprite sous forme de string et prète à être mise dans le .lua de votre projet.
Tout les sprites sont compressés dans des strings!
Remarque: si Prog.lua existe déjà il est écrasé.
Le string contenant un sprite peut apparaitre bizzare, ne vous en inquiétez pas.

Code du fichier sprites.lua ( à executer avec lua windows et non pas le lua g100/g85 ):

foo = { /le code du sprite/ }
out = io.open("Prog.lua", "w") – l'ancien fichier Prog.lua sera effacé
foo2=string.char(unpack (foo));
out:write(("sprite = %q"):format(foo2));
--Prog.lua contient la string associé au sprite.
out:close()

Pour afficher un sprite:

--spritexy x,y, sprite_sous_forme_de_string attention : fonction usuelle
afficher le sprite aux coordonnées indiquées.

Exemple:

graydraw.setcolor(true) –on active le mode 5 couleurs

ballon ="bapzefbpazefpqkdù$"éù'*é"'" --pas vraiment un sprite ici, mais ce sera quelque chose du genre
... --code
clear nil –efface l'écran invisible
spritexy 20, 30 , ballon -- dessine le sprite ballon dans l'écran invisible

refresh --dessine l'écran invisible à l'écran

--graydraw.setcolor(true ou false)
active(true) ou désactive (false) le mode d'affichage 5couleur (au démarrage du programme, le mode d'affichage est Noir et blanc)

--graydraw.text(x,y,caractères ou nombre)
affiche aux coordonnées entrées une chaine de caractère ou un nombre.
Si on entre un nombre, il est converti en un entier entre -2147483647 et 2147483647 car l'algorithme utilisé est beaucoup plus rapide que l'algorithme normal (tostring) qui est très lent.(il s'agit de l'algorithme rapide de misc.tostring2
Si vous voulez vraiment afficher un nombre à virgule ou plus grand, utilisez:
graydraw.text(x,y,base.tostring(nombre))

Tout caractère ne peut pas être affiché: seul peut être affiché ces caractères (les minuscules sont converties en majuscules):
' ( ) * + , - / 0 1 2 3 4 5 6 7 8 9 : ; < > = ? @
ABCDEFGHIJKLMNOPQRSTUVWXYZ
Les caractères sont affichés en noir avec 5 pixels de hauteur, 4 de largeur + 1 pixel d'espace entre chaque caractère.

--clear nil attention : fonction usuelle
efface l'écran invisible

--refresh attention : fonction usuelle
dessine l'écran invisible à l'écran.

--graydraw.pixel(x,y,[couleur])
dessine un pixel d'une couleur de 0(blanc) à 4 (noir) (1:gris clais 2: gris moyen 3: gris foncé) dans l'ecran invisible, et 5 inverse le pixel.
La couleur par défaut est le noir.

--graydraw.line(x1,y1,x2,y2,couleur)
Dessine une ligne de la couleur désirée (entre 0: blanc et 4: noir (5: inverser les couleurs)) dans l'écran invisible.
Les points en dehors de l'écran ne sont pas dessinés

--graydraw.rect(x1,y1,x2,y2,couleur1,couleur2)
Dessine un rectangle de contour couleur1 et de intérieur couleur2 .

--graydraw.pixeltest(x,y)
renvoie la couleur du pixel dans l'écran invisible

--graydraw.fill(couleur)
rempli l'écran invisible de la couleur donnée. 5 inverse l'écran.

--state(false ou true) attention : fonction usuelle
C'est la fonction qui permet d'égaler un programme C!
state 'sauve' (false) le décor de manière très rapide pour le ressortir quand on le souhaite (true).
Ainsi vous pouvez dessiner un décor très fournit et le recharger en un rien de temps dans l'écran invisible.
false: sauve l'écran invisible
true: remet l'écran invisible à l'état où il était quand il était sauvegardé.
Remarque: une sauvegarde de l'écran suffit pour le recharger autant qu'on le désire.

--graydraw.map(image en string)
Ceci affiche une map dessinée avec sprite maker (il s'agit d'un mode spécial en dehors des sprites: "convertir et coder une image 128*64")

--scrollx ou scrolly (x ,couleur) attention : fonction usuelle
Vous avez affichez une map , et vous voulez la faire défiler sans tout redessiner, alors cette fonction est pour vous!

Un scroll signifie décaler tout les pixels de l'écran d'un coup. Les pixels qui disparaissent d'un coté réapparaissent de l'autre (vous pouvez les effacer et completer la map)

x est entre -8 et 8 (0 ne fait rien)

scrollx décale les pixels au niveau des x: si x est négatif, les pixels se décalent vers la gauche (leurs x diminue) si x = -1, ils se déplacent d'un pixel, si x = -3, de 3 pixels ,...
Si x est positif, les pixels se déplacent de la même manière vers la droite.

scrolly fait la même chose que la fonction précedente, mais sur l'axe des y.
Si x est négatif, les pixels vont vers le haut et inversement.

scrollx a la même vitesse peu importe la valeur de x. scrolly 1 100 est 8 fois plus rapide que scrollx maisla vitesse de scrolly y 100 dépend de y.

Si couleur est entre 0 et 5, alors ce sera remplacé par une ligne de la couleur indiquée.(0:blanc 4:noir 5: inverser) (sur g85, la couleur 3 ne donne pas un très bon rendu)
sinon (exemple: couleur = 100) ce qui sort d'un coté de l'écran réapparait de l'autre

L'interet de décaler tout les 2 ou 3 pixels au lieu de 1 est dans le cas où le programme fait un nombre important de calcul, et que le programme serait plus fluide si le scrolling est de plus de 1 pixel.
Un scrolling de seulement 1 pixel peut aussi dans certains cas faire apparaitre aux yeux l'image floue (l'oeuil distingue mieux un décalage rapide de 2 pixels).

===les fonctions usuelles===

Vous avez sans doute remarqué les 'attention : fonction usuelle'.
Certaines fontions sont appelées de nombreuses fois dans des programmes avec un affichage graphique dévellopé, et ce genre de programme néccessite le plus de fluidité possible, donc j'ai regroupé certains fonctions en les codant d'une certaines manière que leur appel est plus rapide.

Ce que l'on ne peut plus faire avec les fonctions usuelles:

local math=misc.math -- fonctionne
local touche= key -- ne fonctionne pas

En effet, pour utiliser ces fonctions, il faut être plus stricte, et vous ne pourrez pas précompiler si vous ne respectez pas la syntaxe requise.
Mais vous pouvez faire par exemple:
clear 0
clear (0)
clear x -- avec x= 0
clear (x)
clear nil
local touche= key(5) -- contient true si exe était pressé, sinon false
if key(5) then ... end -- execute si exe était pressé.
scrolly 1,4 -- ne pas faire (1,4)
scrollx x,(-y)
spritexy x, y, sprite
spritexy (60), y, sprite
state true
state (false)
refresh
....
remarque:
--clear (num)
en Noir et Blanc, num doit contenir le numero de la page à effacer (page principale= ce que l'on voit à l'écran = page 0)
en 5 couleurs, num n'est pas important, mais vous devez le mettre. Conseil: mettez nil qui prend moins de place.

En fait une fonction usuelle est codée comme une opération de base du lua (+, ...) ce qui fait que son appel est quasi instantané et que contrairement à tout les appels de fonctions (lua ou C) il n'y a pas de gestion de la mémoire ( aucune allocation 'au cas où' et pas de perte de temps)

== Optimisations==

A quoi sert t'il d'avoir le code le plus rapide possible?

-> c'est plus agréable pour l'utilisateur
-> dans le cadre d'un programme graphique; il faut savoir que plus l'affichage se 'raffraichis' (c'est à dire que l'image à afficher se met à jour) rapidement, plus on a l'impression que le mouvement est fluide (le jeux est agréable à regarder)
pas contre si le mouvement est trop rapide, on a l'impression de flou, d'où par exemple dans le jeux "ballon", les ballons ne montent pas d'un pixel par pixel, mais de 45% d'un pixel ou plus en fonction du niveau. (lorsqu'ils sont affichés avec une coordonnée à virgule, en réalité la fonction de sprite ne voit que la partie entière des coordonnées (comme toutes les fonctions graphiques qui le font intantanément) )

Quelques optimisations à effets importants:
-Evitez au maximum d'appeler des fonctions (lua ou C) dans la boucle principale de votre programme. (sauf dans le cas des fonctions usuelles dont l'appel est instantané)
-Diminuez au maximum les calculs
-Utilisez les particularités du lua:
par exemple:
if key(5) == true then x=1 else x=y end
-> 1ère optimisation :
if key(5) then x=1 else x=y end
-> 2e optimisation :
x = (key(5) and 1) or y
en effet or renvoi le premier résultat vrai et and le dernier (sauf si c'est faux)
et un nombre est toujours considéré vrai
par exemple si exe (key(5) ) est pressé:
vrai and 1 renvoie 1

-Utilisez la fonction state pour charger un décor permet de faire un bonne interface graphique tout en accélérant le code .
-Passez en local toutes les fonctions que vous pouvez
-while not condition do ... end est plus lent que son équivalent repeat ... until condition.

Remarque:

Un mouvement est saccadé à partir tu moment où la fréquence de rafraichissement est inférieur à celle de l'écran.
Sur g100 l'écran se raffraichit toutes les 0,1 secondes.
Si on raffraichit l'image toutes les 0,2 secondes, l'image sera un peu saccadée.
Si l'image se raffraichi toute les 0,04 secondes environ, le mouvement est fluide.

==Remarques==
-seclua (sur g100) est un programme basic qui est là pour empècher qu'un bug insoluble du lua qui à son lancement écrit quelque part au début de seclua, d'où le fait qu'il doit être en première position.
Seculua est aussi utilisé pour stocker les données de state (donc au rédémarrage d'un programme, les données de state contenues de la fois précédente peuvent avoir été très légèrement modifiés)
Il contient aussi (dans l'endroit plus sécurisé) les sprites de caractères.

-sur g85 , il reste quelques bugs. Si vous avez un plantage juste après avoir lancé le gris, mettez une petite attente avant d'activer le gris.

-un local est plus rapide et plus petite qu'une variable globale. Une fonction peut être local est donc son appel est plus rapide
-les goto n'existent pas en lua, il est donc difficile de retranscrire en lua un programme avec des goto. Cependant on peut couper un programme avec des goto en fonctions, à condition que l'on s'arrange pour quitter chaque fonction avant dans lancer une autre (voir programme bourse pour comprendre)

-chaque appel d'une fonction (lua ou C) alloue de la mémoire pour un éventuel retour de la fonction. Cet espace n'est libérable pas le garbagecollector qui si l'on a quitté la fonction (donc si A appelle B, la mémoire de A n'est pas libérable). Il est donc préférable dans une boucle d'éviter au maximum d'appeller une fonction chaque tour (pour la fluidité et le fait que l'on devrait souvent liberer la mémoire)
Si des fonctions s'entre-appellent à l'infini (A appelle B qui appelle A,...) vous aurez à un moment une pénurie de mémoire.

-le ramasseur d'ordure ne se déclenche que lorsque l'utilisation de la mémoire augmente beaucoup. On peut l'arrèter ou le déclencher avec la fonction base.collectgarbage.
Si il n'y a plus assez de mémoire il se déclenche de force pour en liberer, mais il peut échouer. Pour aider à gérer la mémoire, mettez à nil les objets que vous n'utilisez plus (c'est fait par défaut pour les variables locales d'une fonction que l'on quitte ). De plus si vous mettez beaucoup de variables à nil d'un coup, forcez une collection.

Voici différents exemples de code qui peuvent vous aider:

-si vous avez une erreur du genre "invalid comparison, x is nil":
x=map[i] --par exemple
..... --code
if (x>100) --l'erreur est signalée ici

Dans ce code on remarque que cela vient probablement de la case i de map qui doit être nil. Pour connaitre i et comprendre l'erreur on peut faire:
..... --code
if (x) then base.error("\n\rerreur x est nil.\n\r la valeur de i était:\n\r i="...tostring(i))
if(x>100)

Ainsi quand x sera égal à nil, au lieu d'avoir le message d'erreur précédent, vous aurez le message d'erreur:
x est nil.
La valeur de i était:
i=433
(le valeur de i est donnée en exemple.)
Une fois l'erreur trouvée, vous pouvez supprimer la ligne avec le test pour ne pas ralentir votre code.
-Vous pouvez vous aussi capturer l'erreur d'une fonction sans arrèter le programme.
function mafonction (i)
.... --code
end

....
arg= 5 --par exemple
a,b=base.pcall(mafonction,arg)
if (not a) -- il y a eu une erreur (equivalent à if (a == false) )
then affichererreur(b) end --b est un string contenant le message d'erreur
.... --dans tout les cas le programme continu. (sauf erreur memoire)

-Vous pouvez vous même creer votre propre message d'erreur
function mafonction (i)
type=base.type(i)
if(type ~= "number") then -- ~= signifie différent de
base.error("erreur d'argument, il faut rentrer un nombre, non pas un"...type,0)
end
.... --code
end
- Si vous voulez défiler les cases d'un tableau, deux cas se présentent à vous:
. Si le tableau ne contient que des cases numérotées par des entiers positifs supérieurs à 1, le plus rapide est d'utiliser une boucle for et d'accéder directement aux cases du tableau.
. Si le tableau contient aussi des cases que l'on n'accède pas avec un entier positif supérieur à 1 ( par exemple la case 0, la case "feuille", ...), alors le plus rapide est d'utiliser le code suivant:

local next = base.next
for k,v in next, mytable do
.... -- k contient l'indice tel que mytable[k] = v
-- la boucle défile toutes les valeurs de k possibles
end

- Pour stocker des données (comme des maps), vous pouvez utiliser les string ou les fichiers. Le lecture d'une case d'un fichier (file.read) et la lecture de l'entier codé par une lettre de la string (string.byte) se fait quasiment à la même vitesse. Vous pouvez donc utiliser les deux systèmes.
Il faut cependant admettre que l'accès d'un tableau est plus rapide (deux fois plus rapide), mais les tableaux prennent énormément plus de mémoire qu'une string

Remerciements:

De grands remerciements à tout ceux qui m'ont aidé dans ce projet. La liste est longue (Orwell, PierrotLL, Eiyeron, Louloux, Purobaz, light_spirit, kristaba,... et j'en oublie)

[[Catégorie:Langages de programmation]]

Fichiers lus par les calculatrices

2014-05-11T06:40:30Z

Lephenixnoir :

Voici un article recensant les types de fichiers lus par les divers modèles de calculatrices CASIO, par extension.

== BMP ==

Les images bitmap très répandues pour leur simplicité de lecture peuvent être affichées sur certains modèles par des add-ins, et exportés par la Classpad (qui elle, ne sait pas les lire).

== CAT ==

Les archives cat sont des programmes. Ils peuvent être convertis en fxi, et ont donc le rôle équivalent.
Voir FXI.

== CFX ==

Les fichiers cfx sont des add-ins Graph 100(+).
Voir EXE et LEC.

== CPA ==

Les fichiers cpa sont les applications add-ins des ClassPad. 
Voir G1A et G3A.

== EXE ==

Les fichiers exe (à ne pas confondre avecles exécutables Windows sont des add-ins pour Graph 100(+).
Voir LEX et CFX.

== FLS ==

Les fichiers binaires fls sont issus de flashs d'OS, notamment de Graph 75/85/95(SD). L'outil fxRemote qui permet de les récupérer permet entre autres la [[Transformer sa graph 35+ USB en graph 75|transformation]] des Graph 35+ USB.

Les fichiers fls lisibles sur les ClassPad sont des e-activities.

== FXI ==

Les fichiers fxi contiennent en brut le code de programmes [[Basic Casio|Basic]]. Ils sont utilisés par [[FA-123]] pour le transfert vers les Graph non USB. [[FA-124]], utilisé pour les Graph USB, y préfère les g*r qui peuvent contenir n'importe quel type de données de la mémoire principale.

== G1A, G3A ==

Les fichiers g1a et g3a sont des applications add-ins à destinations respectives des Graph 75/85/95(SD) et des [[Fx-CG 20|Prizm]].

Elles sont codées en language C/C++ ou en Assembleur dans le [[Fx-9860G SDK|fx-9860G SDK]] et transférées à l'aide de [[FA-124]] ou par une carte SD. Néanmoins, le fichier ne contenant que du code exécutable, il est impossible d'en recréer la source.

Certains programmes savent exploiter ces fichiers, notamment [http://www.planet-casio.com/Fr/programmes/programme1073-1-icone-pierrotll-add-in.html Icône]. Ce dernier en lit l'en-tête et en tire des informations telles que la date et l'heure de compilation ou les icônes de l'application.

== G1E, G2E, G3E ==

Les fichiers dont l'extension est g1e ou g2e sont des e-activities lisibles par les Graph 75/85/95(SD). Les g3e sont lisibles par la [[Fx-CG 20|Prizm]].

Les e-activities sont des documents mis ne forme dans lesquels on peut entre autres insérer des calculs ou des appels à des applications externes, qu'elle soient du système ou des applications ajoutées (g1a).

Contrairement aux autres applications du système, E-Act lit les fichiers directement dans la mémoire de stockage.

== G1M, G2M, G3M ==

Le format g1m est le format utilisé par Casio sur les Graph 25+PRO, Graph 35/35+/35+USB, Graph 65/80, Graph 75/85/95(SD) et Graph 100/100+ pour coder des données dans la mémoire principale.

Il peut contenir entre autres des programmes [[Basic Casio|Basic]], des listes, des matrices, des pictures ou des captures, des chaînes de caractères, des réglages de la calculatrice, et toutes les données enregistrées par des applications de la calculatrice dans la mémoire principale.
À partir du moment où il contient des données de mémoire Alpha (les valeurs de variables) ou de configuration, on obtient un fichier g2m.
Les fichiers g3m sont conçus pour la [[Fx-CG 20|Prizm]].

Ces fichiers sont destinés à être placés dans la mémoire de stockage.

== G1R, G2R ==

Les formats g*r sont très semblables ou g*m puisqu'ils contiennent aussi des données de mémoire principale. La différence est qu'ils sont
faits pour être lus par [[FA-124]] dans sa section "mémoire principale" et non par la calculatrice.

Ces fichiers sont destinés à être envoyés directement dans la mémoire principale depuis l'ordinateur.

== LEC ==

Les fichiers lec sont des add-ins Graph 100(+).
Voir EXE et CFX.

== MCS ==

Les fichiers mcs sont des programmes [[Basic Casio|Basic]] à destination des ClassPad.

== TXT ==

Les fichiers texte classiques peuvent être lu par la [[Fx-CG 20|Prizm]].
[[Catégorie:Pages en cours d'écriture]]

Processeurs SH3 et SH4

2014-05-10T15:10:20Z

Lephenixnoir : Rectifié un "SH3" à la place de "SH4"

Cet article présente les problèmes liés au changement de processeur des calculatrices et les différents moyens de les contourner.

== Qu'est-ce que SH3 et SH4 ? ==

SH3 et SH4 -- pour SuperH-3 et SuperH-4 -- sont les processeurs dont sont équipées les calculatrices de CASIO. En 2012, les processeurs SH-4A ont remplacé les anciens SH-3, ce qui a posé de nombreux problèmes de compatibilité. En outre, le fonctionnement du système est différent bien que cela n'apparaisse aucunement tant que vous utilisez votre calculatrice de manière "classique".
Tous les nouveaux modèles sont aujourd'hui équipés de processeurs SH4.

== Origine des problèmes ==

Les problèmes viennent principalement du changement de [http://www.casiopeia.net/forum/viewtopic.php?f=20&t=1421 quelques fonctions du SDK] et de [http://www.casiopeia.net/forum/viewtopic.php?p=12607#p12607 plusieurs adresses système].

== Incompatibilité des add-ins ==

Le [[Fx-9860G SDK|fx-9860G SDK]] n'est fait que pour les modèles SH3. Beaucoup d'add-ins sont par conséquent devenus incompatibles, ne serait-ce que parce qu'ils utilisaient la fonction IsKeyDown(). [[Utilisateur:Ziqumu|Ziqumu]] a donc travaillé sur le nouveau système et a réussi à remplacer les fonctions manquantes. Il a alors développé le [http://wiki.planet-casio.com/tools/SH4compatibility SH4 Compatibility Tool] qui permet de résoudre les problèmes d'incompatibilités pour les Graph 35+USB/75/85/95(SD). Cet outil prend simplement en entrée votre exécutable (le fichier [[Fichiers lus par les calculatrices|g1a]]) et vous propose d'en télécharger une version compatible avec les nouveaux, mais également les anciens modèles.

Il est également prossible de rendre le SDK "nativement" compatible SH4, grâce à [http://www.planet-casio.com/Fr/forums/topic12285-1-Tutoriel-Configurer-le-SDK-pour-le-rendre-compatible-SH4.html cette astuce].

Néanmoins, il nous est encore impossible de faire fonctionner les add-ins utilisant les niveaux de gris avec les processeurs SH4. De plus, l'arrivée de l'OS 2.04 a encore ajouté des problèmes de compatibilité avec ces add-ins.

FA-124

2014-04-24T20:06:45Z

Lephenixnoir : Réécrit la page dans un style plus encyclopédique, ajouté quelques informations.

FA-124 est un logiciel édité par Casio pour gérer les transferts entre certains modèles de calculatrices et des ordinateurs sous Windows ''via'' les ports série ou USB. Parmi les modèles supportés se trouvent les Graph 35 à 100 ainsi que les modèles de la série ALGEBRA-FX. Bien qu'originellement conçu pour Windows XP, FA-124 est utilisable sur des machines tournant sous 7, 8 ou 10.

== Fonctionnalités élémentaires ==

[[Fichier:FA1241.png]]

Lorsque FA-124 est configuré pour les calculatrices la série Graph, son interface présente côte-à-côte l'arborescence des fichiers de la calculatrice et celle de l'ordinateur. Les fichiers sont soit importés depuis l'ordinateur puis transférés vers la machine (transfert), soit transférés depuis la machine puis exportés vers l'ordinateur (récupération).

=== Configuration du logiciel ===

FA-124 a besoin de plusieurs informations pour fonctionner. Cela comprend le modèle de calculatrice utilisé et le port sur lequel la communication doit avoir lieu :

* Le modèle de machine est configuré dans le menu ''Tool » Model Type'' (usuellement ''fx-9860G'' ou ''GRAPH'' est utilisé) ;
* Le port de communication est sélectionné au choix entre ''USB'' et ''COM 1'' jusqu'à ''COM20'' dans le menu ''Link » Communications''.

=== Connexion à la calculatrice ===

Lorsque le câble USB est branché sur la calculatrice, il devient possible de se connecter à FA-124. En général, une popup sur l'écran de la calculatrice offre différents modes de communication, parmi lesquels ''Data Transfer'' (F1) est le plus utilisé. À défaut, l'utilisation de l'application LINK permet de passer manuellement la machine en mode réception (F2).

Une fois la calculatrice en mode réception, si les pilotes inclus avec FA-124 sont correctement installés sur l'ordinateur, Windows détecte et signale la connexion. À ce moment, le bouton ''Connect'' situé dans la barre d'outils initie un échange de données entre la calculatrice et l'ordinateur pour démarrer les transferts.

=== Transfert de fichiers ===

Les deux boutons à droite de chaque barre d'outils permettent de sélectionner la mémoire avec laquelle on interagit. Chacune de ces mémoires a un rôle et une taille différente :

* Mémoire principale (64 kio) : utilisée pour stocker les programmes, les résultats des calculs, les images, les graphes, la configuration de la machine et par extension toutes les données utilisées par les applications de la Graph 35+ ainsi que l'application S-SHT.
* Mémoire de stockage (~1.5 Mo) : système de fichiers simpliste servant à stocker les e-acts, les add-ins, et n'importe quel fichier en général (pourvu qu'il y ait suffisamment de place). Généralement utilisée pour stocker des fichiers de données ou de sauvegarde pour les add-ins, ou des copies de la mémoire principale. La mémoire de stockage est présente sur les Graph 75 à 95 ; elle existe aussi sur les Graph 35+ USB mais est rendue inaccessible par un bridage logiciel.

==== Cas de la mémoire principale ====

Sous ''FA-124'' se trouve une liste d'images mémoire au format ''g1r'' qui reproduisent la structure de la mémoire principale. Plusieurs moyens existent pour importer des fichiers dans cette zone :

* Créer une nouvelle image mémoire au format ''g1r/g2r'' en cliquant droit sur ''FA-124'' ;
* Importer une image mémoire téléchargée au format ''g1r/g2r'' en cliquant droit sur ''FA-124'' ;
* Importer dans une image existante des données au format ''g1m/g2m'' en cliquant droit sur le nom de l'image.

Pour transférer des fichiers vers ou depuis la calculatrice, il suffit (une fois la machine connectée) de cliquer-glisser les fichiers de leur source vers leur destination. Lors d'un import depuis la calculatrice, les fichiers sont ajoutés à l'image mémoire choisie. La plupart du temps, les programmes sont fournis en téléchargement avec des données de différentes catégories (comme ''Capture'', ''Picture'' ou ''Program'' sur l'image), au format ''g1r/g2r'' ou ''g1m/g2m'' et requièrent que le fichier entier soit transféré pour fonctionner.

==== Cas de la mémoire de stockage ====

La mémoire de stockage peut contenir n'importe quel fichier tant qu'il y reste de la place. De nouveau, on dispose d'images mémoires (reproduisant cette fois la mémoire de stockage, donc de nature différente) et de données, gérées de manière analogue :

* Créer une image mémoire au format ''g1s'' se fait en cliquant droit sur ''FA-124'' ;
* Importer une image mémoire au format ''g1s'' se fait également en cliquant droit sur ''FA-124'' ;
* Importer des données dans n'importe quel format se fait en cliquant droit sur une image mémoire ou un de ses sous-dossiers et en sélectionnant le type approprié dans la liste déroulante dans la boîte de dialogue de sélection de fichiers.

De nouveau, le transfert est aussi simple que de cliquer-glisser les fichiers d'une fenêtre à l'autre. Il y a cependant une subtilité : les données apparaissent toujours dans le même dossier ou sous-dossier de la mémoire cible que celui dans lequel ils se trouvaient dans la mémoire source. En d'autres termes, pour transférer (par exemple) un fichier de l'ordinateur dans un sous-dossier ''EACT'' de la mémoire de stockage, il faut au préalable créer un dossier ''EACT'' à l'intérieur de l'image mémoire, y importer les fichiers choisis en cliquant droit ''sur le sous-dossier'', et ensuite seulement effectuer le transfert.

== Fonctionnalités avancées ==

=== Captures d'écran ===

FA-124 permet également de prendre des captures d'écran de la calculatrice connectée à l'ordinateur. Pour utiliser cette fonctionnalité, il faut choisir ''ScreenCapt'' (F2) dans la popup de connexion, ou le mode ''ScreenCapture'' (F2) dans la configuration (F6) de l'application LINK. Au moment de passer en mode réception, la machine enclenche la communication puis affichage un message et rend à la main à l'utilisateur.

Il devient alors possible de prendre à tout moment (ou presque) une capture d'écran en appuyant sur [SHIFT][7]. D'ordinaire, cette fonction enregistre un fichier dans la mémoire principale, mais ici, elle prépare l'envoi des données à FA-124. Cliquer sur le bouton approprié dans la barre d'outils de la fenêtre ''Calculator'' de FA-124 déclenche le transfert de la capture, qui peut alors être exportée au format bitmap dans un fichier de l'ordinateur.

=== Création et édition de programmes ===

Il est possible de créer des programmes dans FA-124 (configuré en mémoire principale) en sélectionnant une image mémoire au format ''g1r'' et en choisissant ''Item » New'' dans le menu.

Un programme existant dans une image mémoire de l'ordinateur peut être ouvert par double-clic et édité sommairement. Une manipulation canonique est de modifier la première ligne du fichier pour insérer des lettres minuscules dans le nom du programme, ce que le système autorise mais ne permet pas de faire directement sur la calculatrice.

=== Le réveil ===

Le réveil est un paramètre de la calculatrice. Sa localisation est dans l'application LINK, section ''Wake'' (F5). Il permet de démarrer automatiquement la calculatrice, si jamais elle était éteinte, lorsqu'un câble est branché pour la relier à un ordinateur.

== Alternatives ==

FA-124 n'est compatible qu'avec Windows. Sous Linux et MacOS, la solution a longtemps été d'utiliser une machine virtuelle (WINE ne supportant pas la communication USB, ce n'est pas une solution valide). L'étude du protocole 7 (celui qui est utilisé par les machines récentes pour communiquer avec d'autres calculatrices ou ordinateurs) a permis le développement d'outils alternatifs, parmi lesquels on peut citer (pour GNU/Linux) :

* [http://www.planet-casio.com/Fr/forums/topic14276-1--CasioUsb-(Outil-multifonction-USB-pour-calculatrice-CASIO).html CasioUsb], développé par Nessotrin
* [http://www.planet-casio.com/Fr/forums/topic14487-1-GNU-Linux-P7,-pour-des-transferts-a-repasser.html P7], développé par Cakeisalie5

== Liens connexes ==

* [http://www.planet-casio.com/Fr/logiciels/voir_un_logiciel_casio.php?showid=16 Téléchargement de FA-124] (accompagné d'un tutoriel d'utilisation) sur Planète Casio

[[Catégorie: Logiciels]]

Link

2014-04-12T13:56:01Z

Lephenixnoir : Lephenixnoir a déplacé la page Link vers Menu LINK sans laisser de redirection : Nom un peu trop "généraliste" pour un article précis. Uniformisation des noms.

Le menu LINK propose de nombreuses fonctionnalités axées sur le transfert et la communication entre deux calculatrices et entre une calculatrice et un PC.

== TRANS ==

Le menu TRANS permet de choisir le(ou les) fichier(s) à envoyer à l'autre calculatrice. !!! Seule la calculatrice qui envoie les données va dans ce menu!!!

=== Mémoire Principale F1 ===

Permet de choisir des fichiers à envoyer dans la mémoire principale. Il y a des Pictures, des Captures, des programmes... Pour choisir le fichier à envoyer, mettez le rectangle surligné devant le nom puis F1(Select). Vous pouvez aussi tout sélectionner avec F2(All).
Pour envoyer les données sélectionnées, faites F6(Transfert), Puis F1(Oui).

=== Mémoire de Stockage F2 ===

Permet de choisir des fichiers à envoyer dans la mémoire de stockage. Il y a des addins([[Fichiers lus par les calculatrices|.g1a]]), des e-activity et des fichiers divers(.cdf,.csv,.dat,...). Pour choisir le fichier à envoyer, mettez le rectangle surligné devant le nom puis F1(Select). Vous pouvez aussi tout sélectionner avec F2(All).
Pour envoyer les données sélectionnées, faites F6(Transfert), Puis F1(Oui).

== RECV ==

La fonction RECV(Receive) permet de recevoir les données. Il suffit de faire F2 puis d'attendre que la calculatrice qui envoie les données (ou l'ordinateur) ait terminé d'envoyer les fichiers.

== CABL ==

Le menu CABL(Câble) permet de choisir par quel câble vont se transmettre les données.

=== Câble USB F1 ===

C'est le câble pour recevoir les données d'un ordinateur via FA-124.

=== Câble 3 Broches F2 ===

C'est le câble pour recevoir et transmettre les données entre calculatrices. C'est un câble jack.

== WAKE ==

Ce menu permet d'activer (On F1) et désactiver (Off F2) la fonction réveil de la calculatrice. Cette fonction permet d'allumer la calculatrice automatiquement lorsqu'elle est branchée à une autre calculatrice.

== CAPT ==

A suivre...

[[Catégorie:Pages en cours d'écriture]]

Fonctions du menu OPTN

2014-04-07T13:58:25Z

Lephenixnoir : /* ANGL */

Le menu d'options, accessible depuis la plupart des applications, propose un accès aux fonctionnalités "générales" de la calclulatrice.

''Cet article n'est pas encore terminé, aussi je vous invite à y participer, en y ajoutant une des [[Fonctions_du_menu_OPTN#Liste_des_fonctions_manquantes|fonctions manquantes]].''

=== Légende des onglets ===

- Un onglet rectangulaire plein indique souvent une commande qui s'affiche à l'écran.

- Un onglet auquel il manque un coin (en bas à droite) ouvre un sous-menu ou une fenêtre popup si vous le validez.

- Les onglets vides, dont n'apparaissent que les bords haut et gauche représentent d'autres fonctions, qui peuvent agir sur la fenêtre d'affichage par exemple.

== LIST ==

<syntaxhighlight>List L</syntaxhighlight>
Permet d'accéder à la liste L. S'obtient aussi avec [SHIFT]+[1].

<syntaxhighlight>List->Mat({...})</syntaxhighlight>
Génère une matrice à partir des listes passées en argument. Celle-ci peut être assignée ensuite. Une même liste peut apparaître plusieurs fois.

<syntaxhighlight>Dim </syntaxhighlight>
S'utilise avec "List" ou "Mat" et permet de connaître la taille de l'objet. On peut également s'en servir pour assigner ladite taille, mais l'objet sera réinitialisé.

<syntaxhighlight>Fill(X,List L)</syntaxhighlight>
Remplit la liste L de la valeur X.

<syntaxhighlight>Seq(Expression,Variable,Debut,Fin,Pas)</syntaxhighlight>
Génère une liste à partir de l'expression en faisant varier la variable indiquée.
Les paramètres suivants correspondent aux valeurs de début et de fin, et au pas de variation de la variable (même paramètres que pour For).

<syntaxhighlight>Min(List L)</syntaxhighlight>
Renvoie la plus petite valeur contenue dans la liste.

<syntaxhighlight>Max(List L)</syntaxhighlight>
Renvoie la plus grande valeur contenue dans la liste.

<syntaxhighlight>Mean(List L)</syntaxhighlight>
Calcule la moyenne des valeurs contenues dans la liste.

<syntaxhighlight>Med(List L)</syntaxhighlight>
Calcule la médiane de la liste.

<syntaxhighlight>Med(List L, List M)</syntaxhighlight>
Génère la concatènation des deux listes passées en paramètres en une. Le résultat peut être assigné à une nouvelle liste.

<syntaxhighlight>Sum List L</syntaxhighlight>
Renvoie la somme de tous les éléments de la liste passée en paramètre.

<syntaxhighlight>Prod List L</syntaxhighlight>
Renvoie le produit de tous les éléments de la liste passée en paramètre.

<syntaxhighlight>Cuml List L</syntaxhighlight>
Génère une liste d'Effectifs Cumulée Croissants de la liste passée en paramètre.

<syntaxhighlight>Percent List L</syntaxhighlight>
Génère une liste pondérée des valeurs de la liste L, en pourcentages. En pratique, multiplie ou divise l'ensemble de la liste L de sorte que la somme des éléments soit 100.

<syntaxhighlight>DeltaList L</syntaxhighlight>
Génère une liste de Dim List L-1 éléments. Chaque n-ième élémént de la liste générée est égal à la différence entre le nième et le n+1ième élément de la liste L.

== MAT ==

<syntaxhighlight>Mat </syntaxhighlight>
Permet d'accéder à une matrice. S'obtient aussi avec [SHIFT]+[2].

<syntaxhighlight>Mat->List(A,X)</syntaxhighlight>
Génère une liste contenant la colonne X de la matrice A. Elle peut ensuite être assignée.

<syntaxhighlight>Det Mat A</syntaxhighlight>
Calcule le déterminant de la matrice passée en paramètre.

<syntaxhighlight>Trn Mat A</syntaxhighlight>
Génère une nouvelle matrice à partir de celle passée en paramètre. Les lignes et les colonnes sont inversées (double miroir).

<syntaxhighlight>Augment(Mat A,Mat B)</syntaxhighlight>
Génère matrice dans laquelle les colonnes de la matrice B sont placées à la suite des colonnes de la matrice A.

<syntaxhighlight>Indentity X</syntaxhighlight>
Génère une matrice identité (carrée, donc) de taille X.

<syntaxhighlight>Dim </syntaxhighlight>
S'utilise avec "List" ou "Mat" et permet de connaître la taille de l'objet. On peut également s'en servir pour assigner ladite taille, mais l'objet sera réinitialisé.

<syntaxhighlight>Fill(X,Mat M)</syntaxhighlight>
Remplit la matrice indiquée de la valeur X passée en paramètre.

<syntaxhighlight>Ref Mat A</syntaxhighlight>
Aucune information sur la transformation effectuée.

<syntaxhighlight>Rref Mat A</syntaxhighlight>
Génère une matrice transformée semblable à celle obtenue avec Ref.

== CPLX ==

<syntaxhighlight>i</syntaxhighlight>
La base imaginaire peut aussi s'obtenir avec [SHIFT]+[0].

<syntaxhighlight>Abs </syntaxhighlight>
Donne la valeur absolue d'un nombre imaginaire.

<syntaxhighlight>Arg </syntaxhighlight>
Donne la valeur en radians de l'angle entre l'axe des abscisses et le nombre dans le plan complexe.

<syntaxhighlight>Conjg </syntaxhighlight>
Donne la conjugué du paramètre.

<syntaxhighlight>ReP </syntaxhighlight>
Donne la partie réelle (Real Part) du paramètre.

<syntaxhighlight>ImP </syntaxhighlight>
Donne la partie imaginaire (Imaginary Part) du paramètre.

<syntaxhighlight>X->r<teta</syntaxhighlight>
Transforme le nombre sous une forme polaire (norme et angle)

<syntaxhighlight>X->a+bi</syntaxhighlight>
Transforme le nombre sous une forme cartésienne (parties réelle et imaginaire).

== CALC ==

<syntaxhighlight>Solve(Expression,V)</syntaxhighlight>
Pour V=0, donne la première solution de l'équation Expression(X)=0.

<syntaxhighlight>d/dx(f,x)</syntaxhighlight>
Donne la valeur de la dérivée en x de f.

<syntaxhighlight>d²/dx²(f,x)</syntaxhighlight>
Donne la valeur de la dérivée seconde en x de f.

<syntaxhighlight>Integral(f,a,b)</syntaxhighlight>
Donne la valeur de l'intégrale de f de a à b.

<syntaxhighlight>SolveN(Expression)</syntaxhighlight>
Génère la liste des solutions réelles de l'équation Expression=0.

<syntaxhighlight>FMin()</syntaxhighlight>
<syntaxhighlight>FMax()</syntaxhighlight>
Aucune information sur ces commandes.

<syntaxhighlight>Sum(Expression,Variable,Debut,Fin)</syntaxhighlight>
Calcule la somme de toutes les Expression de la Variable définie, celle-ci allant de Debut à Fin (même paramètres que la boucle For).

<syntaxhighlight>logab(A,B)</syntaxhighlight>
Calcule le A-ième logarithme de B.

<syntaxhighlight>A Int/ B</syntaxhighlight>
Donne le quotient de la division entière de A par B.

<syntaxhighlight>A Rmdr B</syntaxhighlight>
Donne le reste de la division entière de A par B (équivalent à MOD(A,B)).

<syntaxhighlight>F->Simp</syntaxhighlight>
Simplifie la fraction F.

== STAT ==

Aucune information sur les fonctions du menu STAT.

== CONV ==

<syntaxhighlight>-></syntaxhighlight>
Cette flèche pleine sert aux conversions.

=== Syntaxe ===

<syntaxhighlight>Valeur[Unite1]->[Unite2]</syntaxhighlight>

Le résultat de l'opération est la expression de la valeur d'origine, définie pour l'unité 1, dans l'unité 2.

== HYP ==

<syntaxhighlight>sinh </syntaxhighlight>
Calcule le sinus hyperbolique du paramètre.

<syntaxhighlight>cosh </syntaxhighlight>
Calcule le cosinus hyperbolique du paramètre.

<syntaxhighlight>tanh </syntaxhighlight>
Calcule la tangente hyperbolique du paramètre.

<syntaxhighlight>sinh-1 </syntaxhighlight>
Calcule l'arcsinus hyperbolique du paramètre.

<syntaxhighlight>cosh-1 </syntaxhighlight>
Calcule l'arccosinus hyperbolique du paramètre.

<syntaxhighlight>tanh-1 </syntaxhighlight>
Calcule l'arctangente hyperbolique du paramètre.

== PROB ==

<syntaxhighlight>x!</syntaxhighlight>
Calcule la factorielle x, c'est-à-dire le produit de tous les entiers naturels de 1 jusqu'à x.

<syntaxhighlight>nPr</syntaxhighlight>
Aucune information sur cette fonction.

<syntaxhighlight>nCr</syntaxhighlight>
Est utilisée pour la loi binomiale. Calcule le nombre de possibilités de r "vrai" parmi n.

=== RAND ===

<syntaxhighlight>Ran# </syntaxhighlight>
Génère un nombre aléatoire flottant entre 0 et 1.

<syntaxhighlight>RanInt#(A,B)</syntaxhighlight>
Génère un nombre entier aléatoire entre A inclus et B exclus, avec A strictement inférieur à B.

<syntaxhighlight>RanNorm#(O,U[,M])</syntaxhighlight>
Génère un nombre aléatoire de 10 chiffres significatifs selon une distribution normale, avec O la moyenne, et U l'écart-type.

<syntaxhighlight>RanBin#(N,P[,M])</syntaxhighlight>
Génère un nombre entier aléatoire en seloon une distribution binomiale, avec N le nombre d'essai, et M la probabilité.

<syntaxhighlight>RanList#(A[,B][,?])</syntaxhighlight>
Génère une liste de A nombres aléatoires flottants entre 0 et 1.

<syntaxhighlight>P()
Q()
R()
t()</syntaxhighlight>
Aucune information sur ces quatre fonctions.

== NUM ==

<syntaxhighlight>Abs </syntaxhighlight>
Renvoie la valeur absolue du paramètre.

<syntaxhighlight>Int </syntaxhighlight>
Renvoie la partie entière du paramètre flottant.

<syntaxhighlight>Frac </syntaxhighlight>
Renvoie la partie fractionnaire du paramètre flottant.

<syntaxhighlight>Rnd</syntaxhighlight>
Arrondit la valeur utilisée pour les calculs internes à 10 chiffres significatifs.

<syntaxhighlight>Intg </syntaxhighlight>
Contrairement à Int, renvoie, dans le cas d'un négatif, l'entier inférieur.

<syntaxhighlight>RndFix()</syntaxhighlight>
Aucune information.

<syntaxhighlight>GCD(A,B[,{...}])</syntaxhighlight>
Renvoie le PGCD (Greatest Common Divisor) des paramètres.

<syntaxhighlight>LCM(A,B[,{...}])</syntaxhighlight>
Renvoie le PPCM (Lower Common Multiple) des paramètres.

<syntaxhighlight>MOD(A,B)</syntaxhighlight>
Renvoie le reste de la division entière de A par B (équivalent à A Rmdr B).

<syntaxhighlight>MOD_Exp(A,B,C)</syntaxhighlight>
Aucune information.

== ANGL ==

<syntaxhighlight>°</syntaxhighlight>
Permet d'utiliser l'unité angulaire "degré" indépendamment de la configuration.

<syntaxhighlight>r</syntaxhighlight>
Permet d'utiliser l'unité angulaire "radian" indépendamment de la configuration.

<syntaxhighlight>g</syntaxhighlight>
Permet d'utiliser l'unité angulaire "grade" indépendamment de la configuration.

<syntaxhighlight>▫</syntaxhighlight>
Permet d'utiliser l'unité angulaire "degré carré".

<syntaxhighlight>Pol()
Rec()
->DMS</syntaxhighlight>
Aucune information sur ces trois fonctions.

== ESYM ==

Ces symboles multiplient les valeurs par des puissances de 10.

<syntaxhighlight>m</syntaxhighlight>
milli: 10^-3

<syntaxhighlight>µ</syntaxhighlight>
micro: 10^-6

<syntaxhighlight>n</syntaxhighlight>
nano: 10^-9

<syntaxhighlight>p</syntaxhighlight>
pico: 10^-12

<syntaxhighlight>f</syntaxhighlight>
femto: 10^-15

<syntaxhighlight>k</syntaxhighlight>
kilo: 10^3

<syntaxhighlight>M</syntaxhighlight>
mega: 10^6

<syntaxhighlight>G</syntaxhighlight>
giga: 10^9

<syntaxhighlight>T</syntaxhighlight>
tera: 10^12

<syntaxhighlight>P</syntaxhighlight>
peta: 10^15

<syntaxhighlight>E</syntaxhighlight>
exa: 10^18

== PICT ==

<syntaxhighlight>StoPict P</syntaxhighlight>
Enregistre le contenu de l'écran graphique dans la picture numéro P (de 1 à 6 ou à 20, selon les modèles).

<syntaxhighlight>RclPict P</syntaxhighlight>
Rappelle la picture numéro P de la mémoire et la trace en mode OR sur l'écran graphique.

== FMEM ==

<syntaxhighlight>STO</syntaxhighlight>
Permet de stocker une fonction dans la mémoire.

<syntaxhighlight>RCL</syntaxhighlight>
Permet de rappeler une fonction de la mémoire.

<syntaxhighlight>fn</syntaxhighlight>
Permet d'accéder à une fonction de la mémoire.

<syntaxhighlight>SEE</syntaxhighlight>
Montre une liste des fonctions enregistrées.

== LOGIC ==

<syntaxhighlight> And </syntaxhighlight>
Opérateur ET. Valide si et seulement si les deux paramètres sont non nuls.

<syntaxhighlight> Or </syntaxhighlight>
Opérateur OU. Valide si et seulement si au moins un des deux paramètres est non nul.

<syntaxhighlight>Not </syntaxhighlight>
Inverse le paramètre.

<syntaxhighlight> Xor </syntaxhighlight>
Opérateur OU EXCLUSIF. Valide si et seulement si un et un seul des paramètres est non nul.

== CAPT ==

<syntaxhighlight>RclCapt C</syntaxhighlight>
Rappelle la capture d'écran numéro C de la mémoire. Il est impossible de dessiner sur une capture.

== TVM ==

Aucune information sur les fonctions du menu TVM (Finance).

== Sources et références ==

La référence Basic Casio · Planète Casio
[http://www.planet-casio.com/Fr/reference_basic_casio/]

== Liste des fonctions manquantes ==

'''MAT'''

* Fonctions Ref et Rref

'''CALC'''

* Fonctions FMin() et FMax()

'''Le menu STAT'''

'''PROB'''

* Fonction nPr

* Paramètres de RanList#() (sous-menu RAND)

* Fonctions P(), Q(), R() et t()

'''NUM'''

* Fonction RndFix()

* Fonction Mod_Exp()

'''ANGL'''

* Fonctions Pol() et Rec()

* Fonction >DMS

'''Le menu TVM (Finance)'''

[[Catégorie:Pages en cours d'écriture]]

PrizmSDK

2014-04-05T14:00:59Z

Caillou15 : ajout de la structure du SDK

La Prizm n'est pas (et ne sera pas<ref>[http://planet-casio.com/Fr/forums/topic11179-1-Pas-de-SDK-officiel-pour-Fx-CG-10-20.html Confirmation de la part de Casio]</ref>) accompagnée d'un SDK officiel fournit par Casio. Face à ses faibles performances en Basic, un SDK communautaire a été réalisé, fournissant un environnement de développement en C/C++ basé sur GCC. Il est actuellement en version 0.3 et est utilisable tant sur Windows que sur la plupart des distributions Linux.

== Mise en Place du SDK ==

=== Sur Windows ===

Le PrizmSDK v0.3 est actuellement disponible sur le site de la communauté anglophone Cemetech à [http://www.cemetech.net/news.php?id=486 cette adresse].
Téléchargez simplement l'archive au format que vous souhaitez, sachant que le zip est le plus simple à manipuler et le plus commun.

Le SDK est conçu pour être utilisable rapidement sous Windows. En effet, une fois l'archive évoquée plus haut téléchargée, dézippez la quelque part sur votre disque. Il est conseillé de placer ce répertoire à la racine de votre disque dur, ou à tout autre endroit dont le chemin est sans parenthèses ou espaces.

Par exemple :
'''C:\PrizmSDK-0.3''' est valide.
'''D:\Prizm_dev\Prizm\PrizmSDK-0.3''' est également valide.
'''C:\Program Files(x86)\PrizmSDK-0.3''' posera des problèmes.

Vous pouvez vérifier que tout fonctionne une fois votre dossier extrait en allant exécuter le make.bat présent dans le dossier suivant :

'''PrizmSDK-0.3\projects\example'''

Si tout se passe bien, vous devriez assister à la compilation du projet "par défaut" du SDK, dont les étapes sont retranscrites dans une invite de commande.
Un fichier example.g3a devrait aussi être crée une fois la compilation achevée. Ça y est, vous êtes prêts à développer pour votre calculatrice couleur !

=== Sur Linux ===

ATTENTION : La procédure est encore incomplète, cependant les premières étapes décrites ci dessous sont à l'heure actuelle fonctionnelles.

La mise en place sur Linux du SDK n'est pas aussi simple et rapide que sur Windows (mais bon, vous êtes sur Linux, vous vous y attendiez et ça ne vous fait pas peur hein !).

La procédure ci dessous permet d'obtenir l'environnement le plus "récent" à l'heure actuelle, elle est basée sur le travail de Tari.

Ainsi, il faudra compiler une version de GCC permettant de créer des programmes compréhensibles par le processeur de la calculatrice.

==== Préparation de la compilation ====

Il faut d'abord s'assurer que les dépendances soient installées sur l'ordinateur : ''build-essential libmpfr-dev libmpc-dev libgmp-dev libpng-dev ppl-dev curl git cmake''
Pour vérifier leur présence, et les installer si ils ne sont effectivement pas installés, lancez dans un terminal :

'''$ sudo apt-get -y install build-essential libmpfr-dev libmpc-dev libgmp-dev libpng-dev ppl-dev curl git cmake'''

Il va ensuite falloir récupérer les sources des Binutils et de GCC, en prenant en compte la [http://wiki.osdev.org/Cross-Compiler_Successful_Builds compatibilité entre les deux]. A ce jour le couple le plus à jour et testé est [ftp://ftp.gnu.org/gnu/binutils/binutils-2.24.tar.bz2 Binutils 2.24] et [ftp://gcc.gnu.org/pub/gcc/releases/gcc-4.9.1/gcc-4.9.1.tar.bz2 GCC 4.9.1]. Néanmoins, si pour diverses raisons il était nécessaire d'utiliser d'autres versions, elles sont trouvables [ftp://ftp.gnu.org/gnu/binutils/ ici] pour Binutils et [ftp://gcc.gnu.org/pub/gcc/releases/ là] pour GCC.

Il faut ensuite préparer la compilation. Celle ci s'effectuera dans ''/usr/src''. Afin d'attribuer les privilèges nécessaires au dossier cible et de créer les répertoires temporaires utilisés pendant la compilation, il convient d’exécuter la suite de commandes suivante :
''' $ cd /usr
''' $ su
''' # chmod a+rw src
''' # exit
''' $ cd src
''' $ mkdir binutils gcc build-binutils build-gcc

Il faut ensuite décompresser les deux archives téléchargées précédemment dans leur dossier respectif (le contenu de l'archive binutils-x.y va dans le dossier binutils et le contenu de gcc-x.y.z dans gcc).

==== Compilation de Binutils ====
Avant de compiler binutils, il faut procéder à la configuration de ce qui va être compilé. Pour se faire, rendez vous dans le dossier ''build-binutils''

''' $ cd build-binutils

Et exécutez la commande suivante :

''' $ ../binutils/./configure --target=sh3eb-elf --prefix=/usr/local/prizm --program-prefix=prizm- --disable-nls

Lancez ensuite la compilation en effectuant :

''' $ sudo make -j

Puis l'installation grâce à :

''' $ sudo make install

Si il n'y a pas eu d'erreur explicite du compilateur, c'est que tout est censé avoir fonctionné, il est alors possible de supprimer les dossiers temporaires :

''' $ cd ..
''' $ sudo rm -rf binutils build-binutils

==== Compilation de GCC ====
De la même manière que pour binutils, il faut d'abord configurer la future compilation de GCC; pour se faire rendez vous dans le dossier ''build-gcc''

''' $ cd build-gcc

Puis exécutez la commande suivante :

''' $ ../gcc/./configure --target=sh3eb-elf --prefix=/usr/local/prizm --program-prefix=prizm- --disable-nls --enable-languages=c,c++ --without-headers

Lancez ensuite la compilation avec :

''' $ sudo make -j all-gcc

Notez que la compilation est relativement longue; si vous disposez d'un processeur multicœur, il est possible de spécifier l'option ''jn'' où ''n'' représente le nombre de cœurs de votre processeur, réduisant de manière notable le temps de compilation. Pour un processeur quadricœur on aurait donc :

''' $ sudo make -j4 all-gcc

L'installation se lance ensuite comme précédemment :

''' $ sudo make install

Il faut ensuite lancer la compilation de libgcc, de la manière suivante (là encore il est possible de modifier l'option ''-j'' en fonction de votre processeur) :

''' $ sudo make -j all-target-libgcc

Puis l'installation de libgcc :

''' $ sudo make install-target-libgcc

Si tout s'est déroulé comme prévu (pas d'erreurs à quelque moment que ce soit du processus), il est possible de supprimer les dossiers et fichiers temporaires :

''' $ sudo rm -rf build-gcc gcc

==== Installation de Mkg3a ====
Mkg3a est un programme permettant de "wrapper" les binaires obtenus lors d'une compilation avec GCC en fichiers [[Fichiers_lus_par_les_calculatrices|''.g3a'']] exécutables par la calculatrice.

Afin de l'installer, il est d'abord de nécessaire de récupérer les sources (on utilisera ici la version [[https://bitbucket.org/tari/mkg3a/downloads/mkg3a-0.2a.tar.gz 0.2a 0.2a]]). Une fois ceci fait, décompressez l'archive obtenue (l'emplacement importe peu), puis placez vous dans le répertoire extrait.

''' $ cd 'répertoire contenant l'archive extraite'

Lancez ensuite les commandes suivantes, à l’intérieur du dossier contenant les sources :

''' $ cmake .
''' $ make
''' $ su -c 'make install'

Normalement mkg3a est maintenant installé et utilisable.

==== Compilation de LibFxCG ====

Le compilateur étant normalement opérationnel, il va ensuite falloir compiler les librairies et headers permettant de développer à destination de la calculatrice.

Ainsi, il faut tout d'abord faut cloner le dépot git de [[LibFxCG]], l'emplacement encore une fois importe peu.

''' $ git clone https://github.com/Jonimoose/libfxcg.git
''' $ cd libfxcg

L'étape suivante est la compilation de LibFxCG :

''' $ make

Les bibliothèques (''libc.a'' et ''libfxcg.a'') sont maintenant compilées dans le dossier ''lib'', et les headers sont disponibles dans le dossier ''include'' de votre copie locale de libfxcg.

==== Mise en place de l'espace de travail ====

// En cours d'écriture

== Structure du SDK (pour Windows) ==
=== include ===
Contient les en-tête de fonctions utilisés pour programmer les add-ins

=== project ===

Contient les différents projets d'add-ins.
Chaque dossier-projet suit cette structure:
* src : contient le code source de l'add-in (*.c/*.h)
* unselected.bmp : icone de l'add-in dans le menu lorsque non sélectionné
* selected.bmp : icone de l'add-in lorsque sélectionné
* clean.bat : nettoie le projet
* make.bat : construit le projet et génère le *.g3a à transférer dans la calculatrice
* les autres sont moins importants

== Notes et références ==
{{Références|colonnes=2}}

[[Catégorie:C/C++/Asm]]
[[Catégorie:Pages en cours d'écriture]]

Menu RUN-MAT

2014-04-01T14:59:54Z

Lephenixnoir : /* MAT */

Le menu RUN-MAT propose de nombreuses fonctionnalités.

=== Légende des onglets ===

- Un onglet rectangulaire plein indique souvent une commande qui s'affiche à l'écran.

- Un onglet auquel il manque un coin (en bas à droite) ouvre un sous-menu ou une fenêtre popup si vous le validez.

- Les onglets vides, dont n'apparaissent que les bords haut et gauche représentent d'autres fonctions, qui peuvent agir sur la fenêtre d'affichage par exemple.

== JUMP ==

Le menu JUMP permet de naviguer dans la liste des calculs.

- TOP: Ramène en haut de la liste.

- BTM: Ramène en bas de la liste.

- PgUp: Remonte d'une page (la hauteur de l'écran).

- PgDn: Descend le curseur d'une page.

== DEL ==

Le menu DEL permet de vider la fenêtre de calculs.

- DEL-L: Supprime la ligne sélectionnée.

- DEL-A: Vide toute la liste des calculs.

== MAT ==

Le menu MAT permet l'accès et la modification des matrices.
Lorsque vous y entrez, l'écran de calcul disparaît au profit d'une liste des matrices qui affiche également leur taille.

=== Menu de sélection ===

- DEL: Supprime la matrice sélectionnée.

- DEL-A: Supprime toutes les matrices.

- DIM: Permet de créer une matrice en entrant ses dimensions. Les variables m et n correspondent respectivement aux nombres de lignes et de colonnes.

=== Menu d'édition ===

==== R-OP ====

- SWAP: Échange les deux lignes aux indexs entrés.

- XRw: Multiplie tous les nombres d'une ligne m par la valeur k spécifiée.

- XRw+: Multiplie une ligne m par une valeur k, et l'ajoute à la ligne n.

- Rw+: Ajoute la ligne m à la ligne n.

==== ROW ====

- DEL: Supprime la ligne actuelle.

- INS: Insère une nouvelle ligne à la position actuelle et décale celles du dessous.

- ADD: Insère une nouvelle ligne après la ligne actuelle.

==== COL ====

- DEL: Supprime la colonne actuelle.

- INS: Insère une nouvelle colonne sur celle sélectionnée et décale celles de droite.

- ADD: Insère une nouvelle colonne après la colonne actuelle.

==== EDIT ====

Permet d'éditer le contenu de la cellule sélectionnée.

== MATH ==

Le menu MATH permet l'utilisation de nombreuses fonctions mathématiques.

=== MAT ===
- 2x2: Insère une matrice carrée de 2x2 dans le calcul.

- 3x3: Insère une matrice carrée de 3x3 dans le calcul.

- mxn: Vous permet d'insérer une matrice de taille m*n dans le calcul.

- <math>log_n(a)</math>: Cacule le n-ième logarithme de <math>a</math>.

- Abs: Donne la valeur absolue du nombre passé en paramètre.

- <math>\frac{d}{dx}</math>: Donne la valeur de la dérivée en un point d'une fonction.

- <math>\frac{d^2}{dx^2}</math>: Donne la valeur de la dérivée seconde en un point d'une fonction.

- <math>\int_a^b f(x) dx</math>: Calcule l'intégrale de <math>a</math> à <math>b</math> de la fonction <math>f(x)</math>

- <math>\sum_{x=a}^b f(x)</math>: Calcule la somme de toutes les expressions <math>f</math> (de <math>x</math>) pour <math>x</math> allant de <math>a</math> à <math>b</math>.

Fx-FD10 Pro

2014-03-28T15:05:05Z

Totoyo : Page créée avec « <includeonly>{{InfoBox | IDtaille = {{{IDtaille|}}} | title = {{{modèle|}}} | image = {{{image|}}} | ImageLink= {{{lienImage|}}} | ImageSize= {{{imageTaille|}}} | c... »

<includeonly>{{InfoBox
| IDtaille = {{{IDtaille|}}}
| title = {{{modèle|}}}
| image = {{{image|}}}
| ImageLink= {{{lienImage|}}}
| ImageSize= {{{imageTaille|}}}
| caption = {{{legende|}}}
| label1 = Niveau scolaire
| data1 = {{{niveauScolaire|}}}
| label2 = Date de sortie
| data2 = {{{dateSortie|}}}
| label3 = CPU
| data3 = {{{CPU|}}}
| label4 = Fréquence du CPU
| data4 = {{{fréquence|}}}
| label5 = RAM
| data5 = {{{RAM|}}}
| label6 = Memoire de stockage
| data6 = {{{memoireStockage|}}}
| label7 = Taille de l'écran(px)
| data7 = {{{tailleEcran|}}}
| label8 = Couleur de l'écran
| data8 = {{{couleurEcran|}}}
| label9 = Masse sans protection (avec)
| data9 = {{{masse|}}}
| label10 = Connectivité
| data10 = {{{connectivité|}}}
| label11 = Calcul formel
| data11 = {{{calculFormel|}}}
| label12 = Ecriture naturelle
| data12 = {{{ecritureNaturelle|}}}
| label13 = Site officiel
| data13 = {{{siteOfficiel|}}}
| float = {{{float}}}
| articleDétaillé = {{{articleDétaillé| }}}
}}</includeonly><noinclude>{{InfoBox CalculatriceCasio
| modèle = fx-FD10 Pro
| image = fx-FD10 Pro.png
| imageTaille = 200px
| legende = La Casio fx-FD10 Pro
| niveauScolaire = Technicien et ingénieurs
| dateSortie = 2011
| CPU = Renesas SH-4A
| fréquence = ?
| RAM = 64 Ko
| memoireStockage = 4 MiB (1,2 MiB utilisateur)
| tailleEcran = 128x64
| masse = ?
| connectivité = Jack 2.5 - USB
| calculFormel = non
| siteOfficiel = [http://www.casio-education.fr/calculatrice_casio_graph35plus.html www.casio-education.fr]
}}

== Présentation générale ==
La fx-FD10 Pro est un modèle destiné au marché chinois, pour un usage professionnel, et est dérivé de la Graph 95 SD. Elle dispose d'une coque renforcée pour résister aux chocs.

De nombreuses applications ne sont pas présentes, et elle n'est fournie qu'avec RUN-MAT, PRGM, STAT, S-SHEET et SYSTEM.

Dans l'attente des tests, la compatibilité des programmes et addins de la même gamme n'est pas certaines (touches différentes, incertude sur la présence des fonctions graphiques en Basic Casio, etc...)

== Sources ==
- http://www.planet-casio.com/Fr/forums/topic12762-1-Une-nouvelle-Casio-graphique-pour-la-Chine.html
- http://tiplanet.org/forum/viewtopic.php?f=51&t=14152#p159793
- http://www.cncalc.org/forum.php?mod=viewthread&tid=10087

== Liens internes ==

{{Méta palette calculatrice}}

[[Catégorie:Calculatrices Casio]]
[[Catégorie:Calculatrices Basic]]

Basic Fx-CG

2014-03-10T21:38:48Z

Totoyo : résolution idéale des images pour être utilisées dans un programme Basic

== Introduction ==

Les Casio Fx-CG 10 et Fx-CG 20 apportent avec leur nouvel écran en couleur de haute résolution de nouvelles commandes et/ou de nouvelles astuces de programmation en [[Basic Casio]].
Il est à noter que ce nouvel écran n'est pas sans conséquences sur la vitesse d’exécution des programmes, en effet ceux-ci se trouvent être relativement plus lents que sur les consœurs de la Prizm. Il reste malgré tout possible de tirer parti des 65536 couleurs et de produire des jeux graphiquement réussis.

== ViewWindow ==

Le ViewWindow désigne le réglage de l'écran graphique. Alors que sur les anciens modèles, il était uniquement possible de régler la fenêtre graphique ainsi :
'''ViewWindow''' 1,127,0,1,63,0

Sur la Fx-CG, afin d'utiliser au mieux sa résolution trois fois supérieure, il est recommandé d'utiliser :
'''ViewWindow''' 1,379,0,1,187,0

== La couleur ==

Vos programmes en Basic se voient désormais offrir la possibilité d'utiliser 6 couleurs en plus du noir dans les fonctions de tracé et d'affichage. Elles sont accessibles via la combinaison [SHIFT][5][1].
On peut par exemple utiliser ces fonctions ainsi :

'''Cyan''' Text 1,1,"HELLO" // On écrit "HELLO" en cyan aux coordonnées (1;1)
'''Black''' F-line 100,100,200,150 // On trace une ligne noire entre les points (100;100) et (200;150)

Il est à noter que ces commandes couleur fonctionnent également avec la fonction '''Locate'''.

'''Red''' Locate 1,1,"HELLO" // Ainsi on verra s'afficher "HELLO" en Rouge
'''Blue''' Locate 5,5,"WORLD" // Et "WORLD" en Bleu

Les tracés selon une couleur non définies seront effectués dans la couleur dite par défaut, qu'il est possible de modifier grâce à la commande '''Plot/line-Color''' ([SHIFT][SETUP][F6][F6][F6][F6][F3]).

'''Plot/line-Color''' Green // La couleur par défaut est maintenant le vert
F-line 1,1,10,10 // Cette ligne sera dessinée en vert
'''Plot/line-Color''' Red // La couleur par défaut est maintenant le rouge
F-line 1,1,10,10 // Cette ligne sera dessinée en rouge

Notons aussi que PxlTest renvoie désormais la couleur du pixel testé (soit 0 pour le blanc, 1 pour le noir, ...dans le même ordre que leur apparition dans le menu des couleurs), dans le cas où ce dernier a été "allumé" autrement que par l'affichage d'une image.

== Les Images ==

Les commandes citées plus haut (relatives à la couleur) permettent de dessiner de 7 couleurs différentes, cependant la Prizm possède un écran pouvant afficher jusqu'à 65536 couleurs ! Ce potentiel peut être exploité en Basic avec l'utilisation d'images.

Pour se faire, il faut d'abord une image du format adapté, c'est à dire codée sur 16 bits, et de 384 x 185 pixels pour éviter toute déformation<ref>[http://www.planet-casio.com/Fr/forums/topic11298-1-Creation-et-transfert-d-mages-FX-CG20.html Création et transfert d'mages FX-CG20]</ref>. Celles-ci peuvent être réalisées depuis la calculatrice ''via'' des captures d'écran ou le menu de géométrie (d'un intérêt relativement limité) ou bien ''via'' le logiciel [http://www.casioeducation.com/prizm_convert Casio converter]. Ces images ne seront compatibles qu'avec les modèles "européens" de Prizm (soit les fx-CG20), néanmoins il est depuis peu possible de générer des images compatibles avec tout les modèles<ref>[http://www.cemetech.net/forum/viewtopic.php?t=10529 Annonce de SourceCoder 3, outil permettant entre autres de générer des g3p compatibles avec les fx-CG10]</ref>.
Elles devront être placées dans la mémoire de stockage de votre calculatrice.

Une fois dans l'éditeur de programmes Basic, effectuez la combinaison [OPTN][F6][F6][F2][F3](Open). Naviguez ensuite pour sélectionner votre image, puis validez. Une ligne du type ''CASIO/g3p/nom_image.g3p'' doit alors s'afficher dans votre code. Pour afficher cette image, il suffit de faire précéder cette ligne de '''RclPict''' ([OPTN], onglet PICT) ou de '''Bg-pict''' ([SETUP], onglet BACK).

Cls // Obligatoire pour que l'image s'affiche à l'écran
'''RclPict''' ''CASIO/g3p/Beach.g3p'' // Ceci affiche une image représentant une plage
'''BgPict''' ''CASIO/g3p/Beach.g3p'' // Ceci affiche aussi une image représentant une plage

== Réglage de l'épaisseur des tracés ==
Il existe plusieurs réglages possibles afin de régler l'épaisseur des segments tracés avec ''F-Line'', ou encore des cercles tracés avec ''Circle'' par exemple.
Les commandes de réglages sont disponibles avec la combinaison [SHIFT][F4][F6][F6][F5](STYLE). Les différents réglages proposés sont :

''' SketchNormal''' soit un trait "normal" (2 pixels)
''' SketchThick''' soit un trait "plus gros" (3 pixels)
''' SketchBroken''' soit un trait en pointillé "gros" (3 pixels)
''' SketchDot''' soit un trait en pointillé "normal" (2 pixels)
''' StetchThin''' soit un trait fin (1 pixel)

On utilise les réglages comme ci-dessous :

'''SketchBroken''' Red F-line 10,10,150,200 // Commande affichant un trait rouge et en pointillé entre les points de coordonnées (10,10) et (150,200)

== Notes et références ==
{{Références|colonnes=2}}

[[Catégorie:Langages de programmation]]
[[Catégorie:Basic]]
[[Catégorie:Pages en cours d'écriture]]

Fx-CG 20

2014-03-09T19:22:10Z

Lephenixnoir :

{{InfoBox CalculatriceCasio
| modèle = FX-CG20
| image = FX-CG20.jpg
| imageTaille = 200px
| legende = La Casio Prizm (FX-CG20)
| niveauScolaire = Lycée
| dateSortie = Début 2011
| CPU = Renesas SH-4A
| fréquence = 58Mhz
| RAM = 2Mo au total
| memoireStockage = 16Mo
| tailleEcran = 384x216
| masse = 230 g
| connectivité = Jack 2.5 - USB
| calculFormel = Add-In
| siteOfficiel = [http://www.casio-education.fr/calculatrice_casio_fx-CG20.html www.casio-education.fr]
}}

== Présentation générale ==
La Fx-CG 10/20, aussi appelée PRIZM, est une calculatrice graphique milieu de gamme (son coût est d'environ 130€). Elle fut la première calculatrice de la marque à avoir un écran 65 536 couleurs, jusqu'à l'arrivée de la [[Fx-CP 400]] qui succéda à la [[ClassPad 330 PLUS]] fin 2013.

La seule différence entre les Fx-CG 10 et 20 est d'ordre réglementaire vis-à-vis des examens aux États-Unis. Ainsi, sur les Fx-CG 10, il est impossible de lire des images au format g3b non signées par Casio, ceci afin d'éviter les triches. Toutefois, cette restriction est contournable grâce un outil communautaire<ref>[http://www.cemetech.net/forum/viewtopic.php?t=10529 Support du format g3p à SourceCoder 3] (Cemetech)</ref>. Pendant longtemps, la technique n'a pas été publiée pour éviter des problèmes avec Casio, comme un renforcement du verrouillage des calculatrices à la programmation. Or, avec l'arrivée des modèles concurrents, la TI-nSpire CX, la TI-84 Plus Silver Edition C et la HP Prime, les constructeurs autorisaient les images g3b personnalisées sur leurs calculatrices. La contrainte de représailles de Casio vis-à-vis de la communauté de programmeurs s'amoindrissait et SourceCoder s'ouvrit alors aux images g3p personnalisées pour la Fx-CG 10<ref>http://www.cemetech.net/forum/viewtopic.php?t=10516</ref> (pour rappel, la Fx-CG 20 accepte nativement les images g3p personnalisées).

=== Fiche technique ===
* CPU: Renesas SH-4A (selon modèle) 
* Ecran : 384x216 pixels, 65536 couleurs (16-bits) (résolution réelle : 396x224 pixels<ref>Forum de [http://www.cemetech.net/forum/viewtopic.php?p=180031#180031 Cemetech ]</ref>)
* Mémoire Flash (total): 32 Mio 
* Mémoire Flash (user): 16 Mio 
* RAM (total): 2 Mio 
* RAM (user): 62 Kio 
* Port USB: USB 2.0 mini-B 
* Port Série : 2.5 mm 3-pin 
* Alimentation: 4 piles AAA (LR03)

== Programmation ==
De base, cette calculatrice supporte les programmes en Basic Casio, ainsi que les applications (addins) écrites en C/C++.

== Notes et références ==
{{Références}}

== Liens internes ==

{{Méta palette calculatrice}}

[[Catégorie:Calculatrices Casio]]
[[Catégorie:Calculatrices Basic]]

Index des calculatrices Casio

2014-01-25T18:55:24Z

Lephenixnoir : Passage de l'image de chronologie en largeur complète.

[[Fichier:model-index-2019.png|class=fullwidth]]
<center>Chronologie des modèles de calculatrices Casio de 1985 à 2019.</center>

== Liens connexes ==

* [https://www.planet-casio.com/Fr/forums/topic12071-1-chronologie-des-calculatrices-graphiques.html Chronologie des calculatrices graphiques] par Persalteas
* [https://www.planet-casio.com/Fr/forums/topic12071-2-chronologie-des-calculatrices-graphiques.html#88671 Travaux originaux de Persalteas]
* [https://i.imgur.com/NFYg6Ww.png Une chronologie des modèles plus récents] par Critor
* [http://www.casio-calculator.com/ Casio Calculator Collectors]
* [http://mitiay4.narod.ru/casio_specs.htm Spécifications des anciennes calculatrices Casio]

[[Catégorie:Pages en cours d'écriture]]