Cmath.xyz

Compiler CmathOOoCAS

Christophe Devalland — 2023-07-25T14:22:01Z

Voici les étapes pour compiler et installer l'extension CmathOOoCAS sur votre distribution Linux. Ce qui suit est à adapter à votre numéro de version de LibreOffice.

Installer la librairie GIAC

Il y plusieurs méthodes :
– Le plus simple est de compiler la version disponible sur le site XCAS, ce qui apporte tout ce qu'il faut et permet d'avoir la version la plus à jour. En plus vous aurez un chouette logiciel.
– Vous pouvez utiliser le package fourni avec votre distribution mais assurez-vous que les fichiers "header" de giac soient bien installées en plus des exécutables (vérifier la présence d'un répertoire /usr/include/giac). Ils sont en effet nécessaires à l'étape de la compilation de l'extension.
– Sur des distributions récentes (c'est le cas avec Linux Mint 21.2), il est possible d'installer uniquement les paquets libgiac0 et libgiac-dev mais vous n'aurez pas XCAS.

Installer LibreOffice en version au moins égale à 7.1 et le SDK lui correspondant

Les distributions fournissent une version packagée de LibreOffice qui ne permet pas de terminer la compilation et qui sont rarement mises à jour. Il y a donc tout à gagner à supprimer tout ce qui concerne libreoffice et libuno avec votre gestionnaire de paquet et de vous rendre sur le site LibreOffice pour télécharger et installer les quatre paquets qui conviennent à votre système :

le programme LibreOffice,
l'interface utilisateur dans votre langue (facultatif),
l'aide pour l'utilisation hors ligne (facultatif),
le 'SDK et code source' (lien présent sur la même page)

Configurer le SDK de LibreOffice

Ouvrir un terminal et taper :

cd /opt/libreoffice7.4/sdk sh setsdkenv_unix

Choisir les réponses proposées par défaut, sauf pour l'autodéploiement des composants UNO : répondre NO.

Compiler CmathOOoCAS avec le SDK

– Télécharger les sources de CmathOOoCAS,
– Créer un répertoire et y dézipper les sources,
– Ouvrir un terminal dans ce répertoire et taper /opt/libreoffice7.4/sdk/setsdkenv_unix, ce qui devrait renvoyer à peu de choses près :

************************************************************************ * * SDK environment is prepared for Linux * * SDK = /opt/libreoffice7.4/sdk * Office = /opt/libreoffice7.4/sdk/.. * Make = /usr/bin * Zip = /usr/bin * cat = /usr/bin * sed = /usr/bin * C++ Compiler = /usr/bin * Java = * SDK Output directory = /home/chris/libreoffice7.4_sdk * Auto deployment = NO * ************************************************************************

– Taper make
– S'il n'y a pas d'erreur, la librairie ainsi compilée CmathOOoCAS.uno.so se trouve dans ~/libreoffice7.4_sdk/LINUXexample.out/lib/

Installer l'extension

– Enregistrer CmathOOoCAS.oxt dans un répertoire et l'ouvrir avec un gestionnaire d'archive (malgré l'extension oxt, c'est un fichier zip). Ne pas extraire les fichiers, juste ouvrir l'archive pour afficher son contenu. Se déplacer dans le répertoire Linux_x86_64.
– Remplacer le fichier /Linux_x86_64/CmathOOoCAS.uno.so de l'archive par celui obtenu par compilation. Il suffit de glisser déposer le nouveau fichier dans l'archive.
– Double-cliquer sur CmathOOoCAS.oxt pour l'installer.

Toujours pas ?

Il se peut que l'installation échoue à cause de quelques librairies manquantes. Pour le savoir, suivre cette démarche :
Ouvrir un terminal dans le répertoire contenant la librairie compilée CmathOOoCAS.uno.so et taper ldd CmathOOoCAS.uno.so. Voici ce que j'ai sur ma distribution Linux Mint 21.2 :

ldd CmathOOoCAS.uno.so linux-vdso.so.1 (0x00007ffd25fe9000) libuno_cppuhelpergcc3.so.3 => not found libgiac.so.0 => /home/chris/.config/libreoffice/4/user/uno_packages/cache/uno_packages/lu51395immg6.tmp_/CmathOOoCAS.oxt/Linux_x86_64/./libgiac.so.0 (0x00007fb1a4990000) libuno_cppu.so.3 => not found libuno_sal.so.3 => not found libstdc++.so.6 => /lib/x86_64-linux-gnu/libstdc++.so.6 (0x00007fb1a4766000) libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007fb1a4744000) libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fb1a451c000) libntl.so.44 => /lib/x86_64-linux-gnu/libntl.so.44 (0x00007fb1a42af000) libpari-gmp-tls.so.7 => /lib/x86_64-linux-gnu/libpari-gmp-tls.so.7 (0x00007fb1a37a7000) libgsl.so.27 => /lib/x86_64-linux-gnu/libgsl.so.27 (0x00007fb1a34e8000) libpng16.so.16 => /lib/x86_64-linux-gnu/libpng16.so.16 (0x00007fb1a34ad000) libmpfi.so.0 => /lib/x86_64-linux-gnu/libmpfi.so.0 (0x00007fb1a3491000) libmpfr.so.6 => /lib/x86_64-linux-gnu/libmpfr.so.6 (0x00007fb1a31e2000) libgmp.so.10 => /lib/x86_64-linux-gnu/libgmp.so.10 (0x00007fb1a3160000) libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007fb1a3079000) /lib64/ld-linux-x86-64.so.2 (0x00007fb1a60be000) libgf2x.so.3 => /lib/x86_64-linux-gnu/libgf2x.so.3 (0x00007fb1a306a000) libgslcblas.so.0 => /lib/x86_64-linux-gnu/libgslcblas.so.0 (0x00007fb1a3026000) libz.so.1 => /lib/x86_64-linux-gnu/libz.so.1 (0x00007fb1a300a000)

Rechercher les "not found" et installer les librairies manquantes avec votre gestionnaire de paquets favori.
Ne pas tenir compte des "not found" concernant les "libuno_*". Ces librairies sont propres à LibreOffice et ne sont visibles que par lui.
Lorsqu'il ne reste plus aucun "not found", retenter l'installation en double cliquant sur le fichier CmathOOoCAS.oxt.
Si cela ne fonctionne toujours pas, me contacter.

Présentation de CmathOOoCAS

Christophe Devalland — 2023-07-20T20:55:00Z

CmathOOoCAS en résumé

CmathOOoCAS est une extension écrite en C++ en 2009 pour la suite bureautique OpenOffice.org. C'est un logiciel libre développé par Christophe Devalland et publié sous Licence publique générale GNU version 3.
CmathOOoCAS s'appuie sur le moteur de calcul de XCAS (appelé Giac) pour étendre les capacités du tableur Calc de LibreOffice (mais pas seulement) et le rendre apte à manipuler des expressions mathématiques.
En effet, les fonctions mathématiques incluses dans Calc ne savent travailler que sur des nombres décimaux et, comme les calculatrices courantes, les limites du logiciel sont vite atteintes. Impossible par exemple de manipuler des nombres réels tels que ${\sqrt{2}}$ ou des expressions polynomiales. CmathOOoCAS définit donc de nouvelles fonctions permettant de travailler sur des objets mathématiques formels et de calculer en multi-précision.
CmathOOoCAS utilise maintenant des fonctions disponibles uniquement dans LibreOffice ce qui la rend incompatible avec OpenOffice.org et nécessite au moins la version 7.1 de LibreOffice.

L'extension

Une fois l'extension installée (téléchargement de CmathOOoCAS) et LibreOffice redémarré, vous obtiendrez dans Calc un menu "CmathOOoCAS" et une barre d'outils supplémentaires :

– Le menu CmathOOoCAS donne accès, entre autres, à la liste des fonctions ajoutées à Calc, à la configuration de l'extension, à l'éditeur de fonctions et à la documentation.
– La barre d'outils donne des raccourcis vers, entre autres, la configuration de l'extension, l'éditeur de fonctions et la documentation.

Les fonctionnalités

Voici une utilisation simple de CmathOOoCAS :

Sur cet exemple, a et b prennent successivement des valeurs entières, rationnelles, complexes et polynomiales.
C'est la même formule qui sert pour tous les calculs de somme.
La première somme, par exemple, a été définie en tapant la formule =CSOMME(A2;B2).
Les suivantes ont été obtenues en « recopiant » cette formule jusqu'en C5 grâce au petit carré noir visible dans le coin inférieur droit de la cellule.
On procède de même pour les produits en tapant =CPRODUIT(A2;B2) dans D2 puis en « recopiant ».

De façon générale, lorsqu'une fonction existait dans Calc (comme ici SOMME et PRODUIT) CmathOOoCAS ajoute la même fonction précédée de la lettre C comme "CAS". Ces nouvelles fonctions opèrent sur des objets formels. Ainsi, on trouvera, par exemple, dans CmathOOoCAS les fonctions : CLN, CEXP, CPUISSANCE, CSIN, CRACINE, etc...
Lorsqu'une fonction n'existait pas dans Calc, un nom explicite lui est attribué : SIMPLIFIER, FACTORISER, RESOUDRE, DERIVER, INTEGRER, etc... Plus de 80 fonctions de calculs formels sont disponibles grâce à CmathOOoCAS et il est possible d'en créer de nouvelles très facilement puisqu'il est possible de programmer ses propres fonctions en langage Python et de les utiliser dans le tableur ou le traitement de texte, comme n'importe quelle fonction prédéfinie. Cela étend les capacités de LibreOffice au calcul formel et au calcul numérique en multi-précision.

Utilisation des nouvelles fonctions

Il est conseillé d'activer l'AutoSaisie de Calc, accessible grâce au menu Outils pour n'avoir qu'à saisir les premières lettres d'une fonction. Par exemple, sur l'écran suivant, pour calculer le produit des deux cellules A1 et B1, il suffit de taper dans la cellule C1 =cpr pour que les fonctions commençant par ces trois lettres s'affichent :

Valider avec la touche entrée pour confirmer la fonction CPRODUIT puis cliquer sur la cellule A1, appuyer sur la touche CTRL et cliquer sur la cellule A2 et enfin valider avec entrée :

L'éditeur de fonctions et la ligne de commande

Une boîte de dialogue contenant un éditeur de fonctions ainsi qu'une ligne de commandes de calculs formels est accessible via le menu CmathOOoCAS ou l'icône de la barre de menu CmathOOoCAS.
– La ligne de commande est disponible dans la partie droite de cette boîte pour y taper des instructions comme dans Xcas :

La ligne de commande donne accès au calcul formel.

– La partie gauche est composée d'un éditeur permettant de créer ses propres fonctions. Une fois compilées à l'aide du bouton ad-hoc, la ligne de commande peut servir à tester le bon fonctionnement de ces fonctions :

Voir l'article consacré à la Conjecture de Syracuse pour en savoir plus.

– Plusieurs langages de programmation sont utilisables dans CmathOOoCAS : Python, XCAS et « algorithmique ».
La fonction syracuse précédente est écrite en langage Python. Il était possible de l'écrire autrement :

Syntaxe Python Syntaxe XCAS Syntaxe Algorithmique

Syntaxe Python	Syntaxe XCAS	Syntaxe Algorithmique
`def syracuse(n): if n % 2 == 0: return (n//2) else: return (3*n+1)`	`syracuse(n):={ if ((n mod 2)==0) { return(n/2);} else { return(3*n+1);} }`	`fonction syracuse(n) si (n mod 2)==0 alors retourne n/2 sinon retourne 3*n+1 fsi ffonction`

def syracuse(n): if n % 2 == 0: return (n//2) else: return (3*n+1)

syracuse(n):={ if ((n mod 2)==0) { return(n/2);} else { return(3*n+1);} }

fonction syracuse(n) si (n mod 2)==0 alors retourne n/2 sinon retourne 3*n+1 fsi ffonction

Utilisation dans le tableur des fonctions définies par l'utilisateur

– Une fois compilées, les fonctions créées sont sauvegardées avec le document et sont immédiatement disponibles dans le tableur :

La fonction syracuse sert ici à calculer le vol d'un entier défini en B2 (le vol d'un entier est la suite obtenue en partant de cet entier). On aboutit au cycle 4-2-1, ce qui semble être le cas pour tous les entiers positifs (non démontré à ce jour).

– Les fonctions créées par l'utilisateur sont réutilisables dans toute autre fonction créée ultérieurement. Par exemple la fonction DureeVol renvoie le nombre d'étapes nécessaires à un vol pour atterrir à 1 :

et son utilisation dans le tableur :

– Ces nouvelles fonctions exploitent les possibilités apportées par le moteur de calcul formel Giac et peuvent travailler dans $\mathbb{C}$. Grâce aux capacités de calculs de CmathOOoCAS sur des entiers longs, on peut répondre partiellement au défi lancé en l'an 2000 : « Quel est le plus petit entier $n$ dont la durée de vol est 2000 ? » :

377060271667498687 a bien une durée de vol égale à 2000 mais on ne sait pas si ce nombre est le plus petit possible.

– Toutes les fonctions formelles de XCAS sont utilisables dans CmathOOoCAS. Par exemple la fonction calculant le nombre dérivé en $a$, tel qu'il est défini en mathématiques

nbderive(mafonction,x,a):={ local f:=x->mafonction; return(limite((f(x)-f(a))/(x-a),x,a)); }

permet d'obtenir avec une seule formule le tableau qui suit. Il peut servir à conjecturer l'expression des fonctions dérivées usuelles.

– Contrairement au tableur numérique, le tableur formel permet de valider les conjectures émises. Ici, en ajoutant simplement une colonne, la même formule calcule formellement le nombre dérivé en $a$ :

Les fonctions vectorielles

– Il est possible de créer des fonctions renvoyant plusieurs objets, sous la forme d'une liste, nommée aussi vecteur :

Cette fonction « dichotomie » recherche un encadrement d'amplitude inférieur à epsilon d'une solution de l'équation $f \left( x\right) =0 $. La fonction renvoie un vecteur formé des bornes inférieures et supérieures de l'encadrement.

– Dans le tableur, CmathOOoCAS répartit les objets de cette liste en colonne, dans des cellules contiguës. Pour bénéficier de cette fonctionnalité, il faut valider la formule avec Control + Majuscule + Entrée, comme pour toutes les fonctions matricielles de Calc :

On obtient ici des encadrements de plus en plus fins du nombre $\pi$. En validant avec Control+Majuscule+Entrée, la fonction "dichotomie" remplit en même temps les lignes 3 et 4.

– Si on préfère une écriture du vecteur en ligne plutôt qu'en colonne, la fonction TRANSPOSE pourra être utilisée. Reprenons l'exemple de la suite de Syracuse et définissons la fonction VOL(n) renvoyant pour un entier n, le vecteur (durée,altitude) du vol de cet entier.

def vol(n): d, a, u = 0, n, n while u > 1: if u % 2 == 0: u = u // 2 else: u = 3 * u + 1 d += 1 a = max(a, u) return (d,a)

– Une fonction peut également renvoyer une matrice. CmathOOoCAS transformera cette matrice en tableau dans le tableur, à condition de valider la formule avec Control + Majuscule + Entrée. Par exemple, la fonction :

identite(n):={ return(idn(n))}

une fois compilée et suivie dans le tableur de la formule "=identite(4)" renverra la matrice identité de ${{{ \mathrm{M}}}_{4}}{\left( {\mathbb{R}}\right) }$.

Accès au calcul formel dans le traitement de texte Writer

Avec l'extension CmathOOo qui permet de formater des expressions mathématiques, il est possible d'effectuer des calculs formels directement dans Writer :

Consultez cette page pour voir cette fonctionnalité en vidéo.
Voir aussi la documentation disponible dans le menu CmathOOoCAS après installation de l'extension.

Accès au calcul formel dans le module Basic

Les développeurs voulant utiliser les fonctions de CmathOOoCAS ou de XCAS peuvent le faire dans LibreOffice Basic de cette manière :

REM ***** BASIC ***** Sub Main monCalcul=CmathOOoCAS("factor(x^2-1)") End Sub Function CmathOOoCAS(Expression as string) as string Dim mgr as Object, AddinCAS as Object mgr=getProcessServiceManager() AddinCAS=mgr.createInstance("com.sun.star.sheet.addin.CmathOOoCASAddin") CmathOOoCAS=AddinCAS.cas(Expression) End Function

La fonction CmathOOoCAS accepte toute expression respectant la syntaxe Giac et renverra une chaîne de caractères contenant le résultat après évaluation. Dans cet exemple, la variable monCalcul contiendra (x-1)*(x+1).

Quelques exemples

En plus des exemples présentés sur cette page, des activités utilisant les fonctions formelles de CmathOOoCAS sont accessibles à cette page.

Téléchargement de CmathOOoCAS

Christophe Devalland — 2023-07-19T19:14:00Z

L'utilisation de CmathOOoCAS est soumise à conditions

– CmathOOoCAS est une extension écrite en C++ pour la suite bureautique LibreOffice. C'est un logiciel libre développé par Christophe Devalland et publié sous Licence publique générale GNU version 3.
– CmathOOoCAS est gratuit pour une utilisation pédagogique non commerciale. Pour d'autres utilisations, me contacter.

Lien de téléchargement

CmathOOoCAS est disponible pour LibreOffice, version 7.1 minimale, sur les plateformes Windows 64 bits et Linux 64 bits : CmathOOoCAS.oxt (23 Mo)

Installation de CmathOOoCAS

– Après l'avoir téléchargé, ouvrir le fichier CmathOOoCAS.oxt. Le gestionnaire d'extensions de LibreOffice devrait s'ouvrir et vous proposer l'installation.
– Si ce n'est pas le cas alors il faut procéder autrement. Essayez ceci :

Cliquez avec le bouton droit sur le lien et choisissez "enregistrer la cible du lien" ou une formulation équivalent.
Vérifiez que votre navigateur n'a pas changé le nom du fichier. Firefox ne pose pas de problème mais d'autres enregistrent le fichier sous le nom CmathOOoCAS.zip ou CmathOOoCAS.oxt.zip. Il faudra alors le renommer en CmathOOoCAS.oxt.
Méthode 1 : double-cliquez sur le fichier CmathOOoCAS.oxt précédemment téléchargé. Méthode 2 : ouvrez le gestionnaire d'extensions de OOo (menu outils) puis cliquez sur "Ajouter". Choisissez le fichier CmathOOoCAS.oxt téléchargé.

– Sur une distribution Linux, l'installation peut réussir mais les fonctions ne pas être disponibles : l'appel de l'Éditeur de fonctions du menu CmathOOoCAS provoquera une erreur. Il s'agit probablement d'une incompatibilité avec les librairies fournies dans l'extension et celles fournies avec la distribution. Il faut alors passer par une compilation. Suivez ce guide.
– Une fois installé, lisez le manuel d'utilisation disponible depuis le menu CmathOOoCAS.

Problème de Monty Hall

Christophe Devalland — 2023-06-30T22:07:00Z

Le nom de ce problème mathématique vient du nom de l'animateur d'origine canadienne Monty Hall qui a présenté ce jeu aux États-Unis pendant treize ans. Voici son déroulement :

Le jeu oppose un présentateur à un candidat (le joueur). Ce joueur est placé devant trois portes fermées. Derrière l'une d'elles se trouve une voiture et derrière chacune des deux autres se trouve une chèvre. Il doit tout d'abord désigner une porte. Puis le présentateur ouvre une porte qui n'est ni celle choisie par le candidat, ni celle cachant la voiture (le présentateur sait quelle est la bonne porte dès le début). Le candidat a alors le droit ou bien d'ouvrir la porte qu'il a choisie initialement, ou bien d'ouvrir la troisième porte.

La question que l'on se pose est :
Quelle est la stratégie qui offre le plus de chance de gagner la voiture ?

La fonction suivante permet de simuler une partie de ce jeu. Si le paramètre vaut "change" le joueur change de porte, sinon, il conserve son choix initial. Cette fonction renvoie le gain obtenu.

def MontyHall(change_porte): # simule une partie du jeu de Monty Hall # choisir la porte de la voiture porte_voiture=randint(1,3) # le joueur choisit une porte au hasard choix1=randint(1,3) # Monty Hall ouvre une porte montrant une chèvre # construire la liste des portes pouvant être ouvertes nb_portes=0 liste_portes=[] for i in range(1,4): if i<>porte_voiture and i<>choix1: liste_portes.append(i) nb_portes=nb_portes+1 # choisir au hasard une porte à ouvrir parmi celles possibles choix_Monty = liste_portes[randint(0,nb_portes-1)] # construire la liste des portes restantes pour le joueur liste_portes = [] for i in range(1,4): if i<>choix_Monty: liste_portes.append(i) # le joueur choisit une porte à ouvrir if change_porte=="change": if liste_portes[0]==choix1: choix2=liste_portes[1] else: choix2=liste_portes[0] else: choix2=choix1 # on regarde ce que le joueur gagne if choix2==porte_voiture: return("Voiture") else: return("Chevre")

Une fois compilée, on crée un tableau qui simule dans une colonne 100 parties de ce jeu en faisant changer le joueur de porte. Dans une autre colonne on simule 100 autres parties en ne faisant pas changer le joueur de porte. On calcule la fréquence de gain de la voiture dans chaque cas :

Les simulations font apparaître une fréquence de gain de la voiture deux fois plus élevée lorsque le joueur change de porte. Ce résultat étonnant peut se justifier à l'aide d'un arbre pondéré.

En appuyant sur Ctrl+Maj+F9, Calc recalcule toutes les cellules ce qui permet de resimuler 200 nouvelles parties. On constate qu'il vaut mieux changer de porte pour espérer gagner la voiture.

Le lièvre et la tortue

Christophe Devalland — 2022-07-09T12:22:48Z

Le lièvre et la tortue font la course.

Voici les règles de cette course :

On lance un dé à six faces non truqué.
Si le 6 sort, le lièvre fait un bond jusqu'à la coupe et gagne la course.
Sinon, la tortue avance d'une case.
Si la tortue atteint la quatrième case, elle gagne la course.
On relance le dé jusqu'à ce qu'il y ait un gagnant.

Lequel des deux a le plus de chances de gagner la course ?

Les règles du jeu sont telles qu'il n'est pas évident de savoir, a priori, lequel des deux a le plus de chances de gagner la course. Dans cette activité, quelques programmes Python servent à modéliser la situation et à conjecturer la réponse à ce problème grâce au principe de l'estimation d'une probabilité par une fréquence observée sur un échantillon.

Les compétences mises en œuvre dans cette activité couvrent la totalité du paragraphe « Échantillonnage » du programme de Seconde :

Commençons par définir une fonction qui simule une course :

def uneCourse(): for i in range(4): if randint(1,6)==6: return lièvre return tortue

Tapons ce code dans la fenêtre « Commandes CAS » :

Après compilation, la fonction est utilisable dans le tableur, comme toute autre fonction intégrée à LibreOffice :

Dans cette feuille de calcul, on simule 40 courses. Est-ce suffisant pour conjecturer qui gagnera le plus souvent cette course ?
Pour répondre à cette question, nous pouvons relancer ces 40 simulations en forçant le recalcul des cellules avec la combinaison de touches CTRL+MAJ+F9. Après plusieurs actualisation de la feuille de calculs, nous constatons que la fluctuation d'échantillonnage est très marquée et que les fréquences calculées ne permettent pas de deviner qui est avantagé dans cette course.

Augmentons donc le nombre de courses pour approcher les fréquences de gains grâce à la loi des grands nombres. Le code suivant permettra de compter le nombre de victoire de la tortue après n courses :

def courses(n): t=0 for j in range(n): if uneCourse()==tortue: t=t+1 return t

Tapons ce code dans la fenêtre « Commandes CAS » :

Son utilisation dans CALC :

On constate que la fréquence de gain de la tortue semble se stabiliser vers 0,482 pour 100000 courses.
La construction d'un arbre pondéré peut permettre de déterminer que la probabilité de gain de la tortue vaut exactement ${\left( \frac{5}{6}\right)}^4$, ce qui est cohérent avec la valeur trouvée expérimentalement, dans le respect de la loi des grands nombres.

Nous allons maintenant, conformément aux capacités attendues par le programme, simuler N échantillons de taille n de cette expérience aléatoire à deux issues (la tortue gagne ou perd). On admet que la probabilité du gain p vaut 0,482 à $10^{-3}$ près. On appelle f la fréquence de gain observée dans un échantillon. On veut calculer proportion des cas où l'écart entre p et ƒ est inférieur ou égal à $\frac{1}{\sqrt{n}}$.

Le code suivant permet de renvoyer cette proportion :

def simuler(N,n): c=0 for k in range(N): frequence=courses(n)/n if abs(frequence-0.482)<=1/sqrt(n): c=c+1 return c/N

Tapons ce code dans la fenêtre « Commandes CAS » :

Son utilisation dans CALC :

On constate une proportion proche de 95%.

Présentation de CmathLuaTeX

Christophe Devalland — 2016-08-31T20:29:00Z

Pour profiter de Cmath avec la qualité LaTeX : https://github.com/cdevalland/cmath...

- CmathLuatex

Présentation de CmathOOo

Christophe Devalland — 2016-08-14T22:00:00Z

CmathOOo est une extension sous licence GPL pour OpenOffice et LibreOffice. Elle permet de rédiger et calculer des expressions mathématiques rapidement et sans trop d'efforts. Elle fonctionne sous Windows, Linux et Mac. Pour en savoir plus sur la licence GPL, lire le document joint dans la distribution CmathOOo ou sa traduction française non officielle.

– Ces quelques vidéos vous montreront certaines fonctionnalités de CmathOOo. Pour les visualiser correctement, je vous conseille de les ouvrir en plein écran et avec la meilleure résolution possible.

Présentation de CmathOOo :

Le calcul formel avec CmathOOo :

La boîte à outils CAS :

Le bouton "Préférences" :

Le bouton "Alignement automatique des formules" :

– Pour connaître les principales nouveautés de cette version, consultez l'historique des changements.

– Accès à la page de Téléchargement

Compte rendu de l'atelier « Que faire avec un tableur formel au collège et au lycée ? »

Christophe Devalland — 2011-09-25T08:16:06Z

Atelier APMEP, journées nationales de Paris 2010
Lycée Louis le Grand, le 24 octobre 2010
Article paru dans le bulletin vert de l'APMEP en février 2011.

- CmathOOoCAS

Algèbre dynamique avec CmathOOoCAS

Christophe Devalland — 2011-08-22T19:49:15Z

L'une des particularités des fonctions de CmathOOoCAS est de pouvoir travailler non pas sur une seule cellule du tableur mais sur une zone rectangulaire de cellules formant un tableau. Mathématiquement, ce tableau sera interprété comme une matrice.
L'éditeur de fonctions de CmathOOoCAS permet alors d'utiliser les programmes de XCAS manipulant les vecteurs, les matrices ou les listes. Les domaines d'applications sont nombreux : statistiques, probabilités, géométrie analytique, algèbre linéaire, ...
Voici un exemple en vidéo illustrant cette fonctionnalité (pour le visualiser correctement, je vous conseille de l'ouvrir en plein écran avec la meilleure résolution possible).

De l'algèbre dynamique (belle expression trouvée par Bernard Parisse) :

Une utilisation de la forme canonique : étude des variations d'une fonction trinôme

Christophe Devalland — 2011-07-01T10:09:00Z

Extrait du document ressource « fonctions » de la classe de seconde :
“Lorsqu'il s'agira ensuite pour un élève de donner les variations d'une fonction polynôme du second degré quelconque, il pourra par exemple :
Prendre appui sur le fait – établi en cours – qu'une fonction polynôme de degré 2 est soit croissante puis décroissante soit le contraire. Il ne lui restera plus alors qu'à trouver pour quel nombre réel il y a changement de variation.
Si la forme canonique est disponible (soit parce que l'expression de la fonction est mise naturellement sous cette forme soit parce que l'élève identifie qu'il en a besoin et qu'il l'obtient en utilisant un logiciel de calcul formel), il pourra en déduire à la fois l'extremum, la valeur en laquelle il est atteint et son caractère (minimum ou maximum)”

Le fichier "forme canonique (étude d'extremum).ods" sert de document de travail pour cette étude :

forme canonique (étude des variations).ods

Voici son contenu :

Remarques : La fonction trinome a été préalablement définie dans l'éditeur de fonction (icône CAS) par : trinome(a,b,c) :=a*x^2+b*x+c
formecanonique, fmin et fmax sont des fonctions de CmathOOoCAS.
Les trois curseurs permettent de modifier les valeurs de a, b et c avec un pas défini dans la cellule F27.

Les réponses aux questions suivantes peuvent être conjecturées en manipulant les curseurs :

Quelles est l'influence de $a$ sur l'allure de la courbe représentative C de la fonction trinôme $f$ ?
Sous quelle condition $f$ présente-t-elle un maximum, un minimum ?
Quelle est l'influence de $c$ sur $f$ ?
Quel intérêt présente la forme canonique de $f$ ?
Expliquer les « infinity » qui apparaissent à Xmin ou Xmax
Commenter les valeurs de Xmin, f(Xmin), Xmax et f(Xmax) lorsque ${a}={0}$. Quelle est alors la nature de $f$ ?
à compléter suivant inspiration ...