Manuel d'utilisation de la Calculatrice multiprécision v1.2 Indice Introduction La calculatrice multiprécision est une application qui permet d'effectuer des calculs avec précision configurable.

Il n'est pas vraiment utile de disposer d'une précision supérieure à 15 décimales dans les calculs habituels, mais c'est une curiosité et un défi de programmer une calculatrice de ce type.

Il y a quelques années, j'ai programmé la première version de cette calculatrice multi-précision et regardant en arrière, il me semblait dommage qu'elle reste telle quelle, avec une architecture de classes très améliorée.

J'ai sauvé de mon passé lointain le défi de la dérive algébrique, et j'ai décidé de programmer une nouvelle version de l'application.

La fonctionnalité précédente continue de fonctionner, et ce qui a été fait est d'ajouter de nouvelles options pour l'utilisateur.

La fonctionnalité offerte par la version précédente est la suivante: Moteur de calcul Fonctions utilisateur, dans une ou plusieurs variables. Variables utilisateur. Calculs numériques avec précision variable.

Les améliorations apportées à la version v1.1 sont les suivantes: Nouvelles fonctionnalités: Calcul de la fonction dérivée de manière algébrique. Diviseur maximum commun. Calcul en utilisant plusieurs fils en parallèle.

Version invocable à partir de l'interface de commande. Améliorations de l'interface utilisateur: Plusieurs langues. Niveau de zoom configurable. Autocompletation. Aide améliorée. Formatage de texte.

Défaire / refaire dans le panneau de texte d'entrée Améliorations du code: Meilleur architecture de classe. Possibilité de croissance de manière simple et structurée.

Les améliorations apportées à la version v1.2 sont les suivantes: Nouvelles fonctionnalités: Consultez la nouvelle version du serveur.

Aspect visuel de l'écran Aspect visuel de l'écran: L'écran a les composants suivants: Menu principal dans la ligne supérieure Ligne inférieure: Précision.

Permet de configurer la précision pour les calculs. Bouton Annuler. Permet d'annuler les calculs en cours. Panneaux de texte: Panneau 1. Panneau d'entrée, les commandes à exécuter doivent être tapées là-bas.

Panneau 2. Panneau de sortie. L'application écrit les résultats des opérations dans ce panneau. Panneau 3. Panneau de fonctions et variables utilisateur.

Ce panneau affiche les fonctions et variables définies par l'utilisateur.

Démarrer rapidement Exigences Pour exécuter l'application, vous devez avoir l'environnement de java installé (Java Runtime Environment), dans la version 8 ou plus.

De cette façon, vous pouvez ouvrir le fichier.jar existant dans le dossier./_binary/ Démarrer rapidement Pour commencer à utiliser l'application, suivez les étapes suivantes: Ouvre la Calculatrice multi-précision, en double-cliquant sur: le.jar de l'application: qui est dans.../_binary/ multicalcu-gui-main-v1.2-SNAPSHOT-all.jar Choisissez la précision des calculs (composante texte:  & #160;  & #160;:  & #160; Precision & #160;:  & #160;  & #160;: & #160;  & #160;: & #160;:  & #160; Precision & #160;: & #160;: & #160;: & #160;: & #160; / & #160; / & #160; / & #160; binari & #160; / & #160; Démarrer & #160; / & #160; % & #160; / & #160; Multicalcu & #160; / & #160; Multicalcu-main-v1.2-v1.2-v1.2 & #160;: Choisissez la précision des calculs.

Par exemple help + return Définit une fonction. Par exemple f(x) = 2 * x ^ 2 + return Écrivez une opération numérique.

print( 2 * 4 ^ 2 ) + return Calcule une fonction dérivée.

g(x) = subst( derivative( x, 1, f(x) ) ) + return Exemples help Affiche l'aide de l'application dans la langue choisie.

help functions Affiche l'aide du mot-clé functions (c'est l'aide des fonctions).

print( 2 * pi) Affiche le résultat de l'opération 2 * pi avec la précision sélectionnée a = 1.1 Assigne la valeur 1.1 à la variable a, qui peut être utilisée dans les calculs numériques d'expressions, mais pas dans la définition des fonctions.

fun(A, f, alpha, t) = A * cos( 2 * pi * f * t + alpha ) Définit la fonction fun en fonction de quatre variables.

g(f, t) = fun( 2.7, f, pi / 2, t) Définit la fonction g en fonction du fun, mais sans remplacer l'expression.

C'est-à-dire, lorsque l'on calcule une valeur de la fonction g, on prend la définition du fun, et la composition des variables définie est effectuée.

Cela signifie que si f change après avoir défini g, g est également affecté.

h(f, f2, t) = subst( fun( 2.7 * sin( 2 * pi * f2 * t + pi / 3)), f, pi/2, t) ) Définit la fonction h en fonction du fun, accomplissant la composition des fonctions et prenant l'expression qui en résulte.

Cela signifie que la relation entre h et fun est seulement au moment de la définition de h. Si fun change après la définition de h, h sera inchangée, car l'expression avait déjà été remplacée (grâce à la fonction subst).

print( h( 10, 0.26, 3.7 ) ) Affiche le résultat de la fonction h pour ses valeurs d'entrée.

print( 10 * log( 10, (25.2 * h( 10, 0.26, 3.7) ) ^ 2 ) ) Affiche le résultat de l'opération.

Pour plus de détails, voir le paragraphe 4.1.7.26-log.

print( 10 * arccos( tanh( 3 * atan( 500 / pi * 3.6 ) ) ) + sqrt( ex( 5.3 ) ^ (30 * sin( 1 / 30.7 ) ) ) / ( 7.3 + sin( 27 + pi ) + sin( 27 ) ) ) ) calcule le résultat numérique d'une expression complexe.

i(f, f2, t) = subst( derivative( t, 2, h(f, f2, t) ) ) Calcule la dérivée partielle de deuxième ordre d'h en fonction de t et l'attribue à la fonction i. Interface utilisateur Dans ce chapitre, vous verrez comment utiliser les panneaux de la fenêtre principale.

Écran principal Lorsque vous démarrez l'application graphique, un écran apparaît comme suit: L'écran a les composants suivants: Menu principal dans la ligne supérieure Ligne inférieure: Précision.

Permet de configurer la précision pour les calculs. Bouton Annuler. Permet d'annuler les calculs en cours. Panneaux de texte: Panneau 1. Panneau d'entrée, les commandes à exécuter doivent être tapées là-bas.

Panneau 2. Panneau de sortie. L'application écrit les résultats des opérations dans ce panneau. Panneau 3. Panneau de fonctions et variables utilisateur.

Ce panneau affiche les fonctions et variables définies par l'utilisateur.

Exemple de fenêtre dans une utilisation normale: Menu de l'application Le menu est la barre d'options qui est sur la ligne du haut de la fenêtre.

Il a différentes options que nous verrons ci-dessous. Menu fichier Le menu Fichier a cet aspect: Ce menu a une option: Quitter. Permet de quitter l'application.

Menu Vue Le menu Vue ressemble à ceci: Ce menu n'a qu'une seule option: Zoom.

Il permet de choisir la taille de la partie visuelle de l'application, avec un pourcentage indiquant la taille des composants par rapport à l'affichage normal des fenêtres (100%).

Menu Outils Le menu Outils ressemble à ceci: Ce menu a deux options: Langue. Lorsque vous ouvrez ce sous-menu, les langues disponibles apparaissent.

Il sert à changer la langue de l'application. Par défaut, les langues suivantes sont disponibles: "EN". Anglais "FR". Castellano "CAT". Catalán Configuration.

Lorsque vous cliquez sur cet élément de menu, un formulaire vous permet de modifier les paramètres généraux de configuration de l'application.

Voir point: 3.3-Configuration Menu Aide Le menu Aide ressemble à ceci: Ce menu a trois options: Aide. Ouvre ce fichier d'aide. À propos de.

Lorsque vous cliquez sur cet élément de menu, un formulaire apparaît avec les données de l'application, les remerciements et les coordonnées. Voir paragraphe: 3.5-A propos de... Licence.

Affiche la licence qui a été acceptée la première fois que l'application a été exécutée. Voir paragraphe: 3.6-Licence Configuration Ce formulaire permet de modifier les paramètres généraux de l'application.

Le formulaire comporte plusieurs onglets que nous détaillons ci-dessous. Moteur de calcul L'onglet a l'aspect suivant: Les paramètres qui peuvent être configurés sont les suivants: Précision pour les calculs.

C'est la précision dans laquelle les calculs effectués seront affichés.

En interne, les calculs sont effectués avec une précision légèrement plus élevée, pour essayer d'éviter des inexactitudes dans le résultat affiché (ce qui n'est pas toujours obtenu).

Nombre maximal de fils à utiliser pour les calculs. Indique le nombre maximal de fils à utiliser pour les calculs.

Il est conseillé d'utiliser un nombre égal au nombre de fils simultanés supportés par le processeur moins un.

Par exemple, si vous avez un i7 avec 4 cœurs et deux fils par noyau, le nombre conseillé serait 7 (à moins que vous ne vouliez réserver la capacité de processus pour d'autres programmes qui sont en cours d'exécution simultanément).

Interface utilisateur L'onglet a l'aspect suivant: Les paramètres qui peuvent être configurés sont les suivants: Afficher l'autocomplet de commande.

Lorsque cette option est cochée, au fur et à mesure qu'elle est tapée dans le panneau texte d'entrée, une fenêtre s'affiche avec les options d'autocomplet.

Lorsque cette fenêtre est affichée et qu'il y a des options, vous pouvez vous déplacer avec les curseurs en haut et en bas, pour choisir une autre option possible, ou continuer à taper (la recherche sera fermée).

Si vous cliquez sur return pendant que cette fenêtre a des options possibles, l'option sélectionnée est tapée dans le panneau texte et cette fenêtre est fermée.

Vous pouvez également choisir par le pointeur de la souris l'option d'autocomplet que vous voulez. Afficher l'aide du paramètre courant.

Lorsque cette option est cochée, au fur et à mesure qu'elle est tapée dans le panneau texte d'entrée, une fenêtre s'affiche avec le paramètre actif que nous remplirons.

Ceci est utile pour savoir, par exemple, dans une fonction qui est le paramètre que nous remplirons.

Paramètres linguistiques de l'application L'onglet a l'aspect suivant: Les paramètres qui peuvent être configurés sont les suivants: Langue.

C'est la langue des textes qui écrivent l'application. Les langues que vous pouvez choisir sont: EN. Anglais ES. Espagnol CAT. Catalan Locale de langue.

C'est le local Java qui va utiliser l'application pour cette langue. L'application l'utilise pour convertir des nombres en chaînes numériques formatées. Langue supplémentaire.

C'est une nouvelle langue supplémentaire qui apparaît au moment de changer de langue. Pour la nouvelle langue, vous devrez sélectionner le local Java à utiliser.

Si vous voulez mettre une langue dont il n'y a pas de texte dans l'application, vous pouvez ajouter votre langue en traduisant les fichiers qui se trouvent dans le répertoire créé lorsque vous appuyez sur le bouton " & #160;  & #160;  & #160; " (Ajouter une langue & #160; ").

Les fichiers à traduire sont copiés dans le répertoire indiqué dans: "Directoire de langue supplémentaire" Le format de ces fichiers de texte est celui de properties de java.

Pour ceux qui ne connaissent pas ce format, je vais vous dire qu'un fichier properties a un titre, et après celui-ci, un nombre variable d'étiquettes avec sa valeur, similaire à ce qui suit: # TITULO # xxxxxxxEVIS1=texte 1.1.2=texte 2... Les étiquettes doivent rester inchangées, et les textes doivent être modifiés en fonction de la traduction dans la langue choisie.

En outre, il y a aussi quelques fichiers au format RTF, que vous devrez traduire avec un éditeur RTF (un éditeur typique pour ce format est le Word Office).

Si vous créez la traduction pour une autre langue que celle disponible dans l'application, vous pouvez m'envoyer (frojasg1@hotmail.com) et je l'inclureai dans les versions suivantes de l'application.

Paramètres d'affichage de l'application L'onglet a l'aspect suivant: Taille des fenêtres de l'application.

Ce paramètre permet de contrôler l'aspect des fenêtres qui apparaissent dans l'application, avec la possibilité de choisir la petite taille, la normale, ou la grande taille.

Fenêtre d'auto-complet La fenêtre d'auto-complet est une fenêtre d'aide qui apparaît au fur et à mesure qu'elle est en cours d'écriture, et à condition qu'elle soit configurée pour être affichée.

L'idée a été tirée de la fonctionnalité qui ont de nombreux Environnements intégrés de développement, dans lesquels au fur et à mesure que vous écrivez, vous avez des options, qui vous rafraîchissent comme la syntaxe de ce que vous voulez écrire, ainsi que ce sont les arguments que vous prenez au cas où l'option soit une fonction.

Pendant que vous affichez cette fenêtre avec des options (panneau supérieur), vous pouvez vous déplacer par ces options avec les curseurs, ou en cliquant sur l'option désirée avec la souris.

La façon de choisir une option, c'est en cliquant avec le pointeur de la souris sur elle, ou en cliquant sur return.

Ensuite, l'option complète sera tapée dans le panneau texte d'entrée et cette fenêtre disparaîtra.

La fenêtre disparaît également lorsque le foyer sort de la fenêtre elle-même, ou de la fenêtre principale, et aussi lorsque la fenêtre principale est minimisée.

Voici un exemple d'écran d'auto-complet: Dans ce cas, les deux paramètres de configuration sont actifs.

La fenêtre d'auto-complètement a deux panneaux panneau supérieur: indique les options d'auto-complètement. Panneau inférieur, indique le paramètre courant dans lequel nous nous trouvons en écrivant.

À propos de... L'option À propos de..., affiche une fenêtre avec un résumé des nouveautés dans cette version. Les remerciements sont également inclus.

Il a un aspect comme celui-ci: Licence L'option Licence, dans le menu Aide, permet d'afficher la licence qui a été acceptée la première fois que l'application a été exécutée.

Il a un aspect comme celui-ci: Liste des opérations La calculatrice multiprécision permet d'effectuer des calculs en précision configurable, ainsi que certaines opérations avec des fonctions et des variables.

Tout cela se fait par l'introduction d'instructions via le clavier. Ces instructions sont constituées de différents mots réservés et paramètres.

Mots réservés Les mots réservés sont des mots ou des signes qui ont une signification concrète pour l'analyseur d'expressions.

Beaucoup de ces mots réservés sont des commandes ou des fonctions, bien qu'il y ait d'autres types. Dans cette section, nous allons faire un tour pour tous ces mots.

print La commande print permet d'afficher le résultat numérique de l'expression que vous avez comme argument.

Format: print(expression) Exemple: print( 2 + 2 ) Résultat: 4 Constantes Les constantes sont des éléments tels que les variables, mais qui ont une valeur fixe calculée automatiquement par l'application.

e Numéro Euler. Résultat: 2.718281828459045235360287471352662... pi Constante pi. Résultat: 3.1415926535897932384643383279502... ln2 Logaritmo neperiano de 2.

Résultat: 0.6931471805599459417232114581... Commandes de variables utilisateur Ce type de commandes permet de gérer la définition/la suppression de variables avec une valeur numérique spécifique.

Affectation de variables Permet d'attribuer une valeur numérique à une variable.

Format: nomVariable = expression numérique Exemple: aa = 2 + 2 Résultat: La valeur 4 est attribuée à la variable aa. clearvars Supprime toutes les variables utilisateur.

Format & #160;: clearvars Exemple & #160;: clearvars Résultat & #160;: efface toutes les variables. erasevar Supprime la variable utilisateur indiquée. Format & #160;: erasevar nomVariable Exemple: erasevar aa Résultat: efface la variable aa.

Commandes et fonctions de fonctions utilisateur Ce type de commandes permet de gérer la définition/la suppression des fonctions et il y a certains d'entre eux qui ne sont pas vraiment des commandes, mais qui sont des fonctions qui doivent faire partie d'une expression et qui ne forment par eux-mêmes aucune instruction complète.

Attribution de fonctions Permet d'enregistrer une fonction dans la liste des fonctions utilisateur.

Format: nomFonction( variable1,..., variableN) = expression( variable1,..., variableN ) Exemple: fun(x, y, z ) = 2 * x ^ 2 * et ^ 2 * z ^ 2 Résultat: l'expression est attribuée en fonction de trois variables au nom de fonction fun.

Notes: L'expression de la fonction permet de définir les relations entre les fonctions, c'est-à-dire que nous pourrions définir la fonction: fun2(x, y) = fun(x, y, x*y) Dans ce cas, si nous voulons calculer la valeur de fun2( 1, 1 ), le moteur de calcul prendra la fonction fun(x, y, z), et créera les opérations dynamiquement.

L'expression de fun peut changer après la définition de fun2, mais dans la définition de fun2, nous n'avons pas mis d'expression explicite, donc elle serait réglée de manière satisfaisante au moment de l'exécution, en prenant la définition de fun'x, et, z) plus nouvelle.

Si nous voulons que fun2 ait une expression concrète qui ne dépend pas de la définition d'autres fonctions, nous devrons utiliser la commande (fonction) subst, qui fait remplacer l'expression qu'elle prend comme paramètre au moment de l'invocation.

Par exemple, si nous définissons: fun2(x, y) = subst( fun(x, y, x*y) ), nous obtiendrons directement une expression concrète pour fun2, et même si la définition de fun change ensuite, nous ne constaterons aucun changement dans la définition de fun2.

Dans ce cas, le résultat serait directement: fun2(x, y) = 2 * x ^ 2 * et ^ 2 * (x * et ^) ^ 2 et l'expression de fun2 n'aurait plus de rapport avec l'expression de fun.

Quelque chose de similaire se produit avec la commande (fonction) dérivative. Cette commande permet d'obtenir la fonction dérivée de l'expression que vous prenez comme argument.

Ainsi, nous pouvons définir une fonction en prenant comme entrée d'autres fonctions ou même leurs fonctions dérivées, comme l'expression d'une équation différentielle, bien que dans ce cas, la partie gauche de l'expression, serait une fonction simple (ne peut pas être dérivée).

(L'application ne résout pas les équations différentielles!!).

Par exemple, pour illustrer ce que vous ressentez, nous pourrions définir: fun3(x, y, z) = derivative( x, 2, fun( x, y, z ) )

Composition des fonctions Cette possibilité permet de calculer une expression en remplaçant les variables d'une fonction par des expressions.

Format: nomFonction( expression1,..., expressionN ) Exemple: fun( 2*x, x*y, x*z ) Résultat: Si fun( x, y, z ) = 2 * x ^ 2 * et ^ 2 * z ^ 2 Donc: fun( 2*x, x*y, x*z ) = 2 * ( 2 * x ) ^ 2 * ( x * et ) ^ 2 * ( x * z) ^ 2 val Cette commande (qui est en fait une fonction) permet de remplacer une expression qui donne un nombre par ce nombre.

Ceci est utile, car, si nous définissons une fonction, il pourrait être utile de remplacer une expression numérique complexe par son résultat (pour que moins d'opérations soient effectuées chaque fois qu'une valeur de la fonction est calculée).

La partie négative, c'est que cette opération est liée à la précision que nous avons au moment de l'utiliser, et si nous changeons ensuite de précision, la valeur calculée n'est pas réévaluée.

Format: val(expression ) Exemple: f( x ) = val( tan( pi / 4 ) / 2 ) * x ^ 2 Résultat: f( x ) = 0.5 * x ^ 2 subst Cette commande (qui est en fait une fonction) permet de remplacer une composition de fonctions ou un calcul de dérivée par ses expressions concrètes.

Si cette fonction n'est pas utilisée, le résultat est exprimé en fonction des fonctions référencés dans la composition ou le calcul de la dérivée.

(Pour plus de détails, voir la rubrique Notes, au point: 4. l'attribution des fonctions) Format: subst( composition de la fonction ) ou subst( calcul de la fonction dérivée ) Exemple: f( x ) = subst( g( 2 * x ) ) Résultat: si g(x) = 2 * x alors f( x ) = 2 * 2 * x derivative Cette commande (qui est en fait une fonction) permet de calculer la dérivée nième sur l'une des variables d'une fonction qui peut être définie en fonction de plusieurs variables.

Pour l'instant, la possibilité de calculer des dérivés partiels croisés n'a pas été mise en œuvre.

Si cette fonction n'est pas utilisée comme argument d'une fonction subst, le résultat sera exprimé sur la base des fonctions référencés dans le calcul de dérivée.

(Pour plus de détails, voir la rubrique Notes du point: 4. '4'-Affectation des fonctions') Format: dérivative( variable, ordre, expression ') Exemple: g(x) = dérivative( x, 1, f(x) ') Résultat: si f( x ')= x ^ 2 puis g( x ') = 2 * x simplify Cette commande (qui est en fait une fonction) permet de simplifier une expression.

Il ne remplace pas les fonctions, même s'il s'agit d'un argument d'une commande subst.

Il a été créé à des fins d'épuration, car cette fonction de simplification est invoquée chaque fois qu'une dérivée est calculée avec la commande dérivative.

Format: simplify( expression ) Exemple: f( x ) = simplify( x ^ 2 / ( 2 * x ) - 3 + 1 / 2 ) Résultat: f( x )= x / 2 - 5 / 2 eraseafunc Cette commande permet d'effacer une fonction utilisateur.

Format: erasefunc(nomFonction) Exemple: erasefunc( f) Résultat: efface la fonction utilisateur f clearfuncs Cette commande permet d'effacer toutes les fonctions utilisateur.

Format: clearfuncs Exemple: clearfuncs Résultat: supprime toutes les fonctions utilisateur Opérateurs Les opérateurs sont des chaînes, généralement constituées d'un seul caractère, qui permettent de contacter des expressions.

Opérateur de somme (+) Ajoute deux numéros. Format: addition1 + addition2 Exemple: 1.01 + 3.45 Résultat: 4.46 Opérateur de soustraction (-) Reste deux numéros.

Format: minuendo + soustrayant Exemple: 7.25 - 3.743 Résultat: 3.507 Opérateur de multiplication (*) Multipliant deux numéros.

Format: facteur1 * facteur2 Exemple: 7.25 * 3 Résultat: 21.75 Opérateur de division (/) Divise deux numéros.

Format: dividende / diviseur Exemple: 16 / 4 Résultat: 4 Opérateur de puissance (^) Téléchargez un nombre à l'autre.

Format: base ^ exposant Exemple: 16 / 4 Résultat: 4 Parenthèse ( ( () ) Donne la priorité à l'opération entre parenthèses.

Format: (expression ) Exemple: ( 3 + 4 ) * ( 2 - 7 ) Résultat: 7 * ( -5 ) Précédemment d'opérateurs Les opérateurs seront évalués dans l'ordre suivant: Les expressions entre parenthèses (... ) L'opérateur de puissance ^ La multiplication et la division: *, / La somme et reste: +, - Autres commandes Autres commandes, se rapporte à des commandes mises en œuvre qui n'ont rien à voir avec le moteur de calcul.

exit Quitter l'application. Format: exit Exemple: exit Résultat: Sortie de l'application. Fonctions mathématiques prédéfinies Ce sont des fonctions mathématiques qui existent sans que l'utilisateur ait à les définir.

Ils produisent un résultat en fonction des paramètres d'entrée. abs Calcule la valeur absolue de l'argument.

Format: abs(argument) Exemple: abs( -2.35 ) Résultat: 2.35 absolute Calcule la valeur absolue de l'argument.

Format: absolute( argument) Exemple: absolute( -2.35 ) Résultat: 2.35 acos Calcule l'arc cosinus de l'argument, donnant le résultat en radians.

Format: acos( argument) Exemple: acos( 1 ) Résultat: 0 acosh Calcule l'arc cosinus hyperbolique de l'argument.

Format: acosh( argument) Exemple: acosh( 1 ) Résultat: 0 add Calcule la somme des deux additions.

Format: add(sumendo1, somme2) Exemple: add(2, 3 ) Résultat: 5 arccos Calcule l'arc cosinus de l'argument, donnant le résultat en radians.

Format: arccos (argument) Exemple: arccos( 1 ) Résultat: 0 arccosh Calcule l'arc cosinus hyperbolique de l'argument.

Format: arccosh( argument) Exemple: arccosh( 1 ) Résultat: 0 arcsin Calcule l'arc-en-tête de l'argument, donnant le résultat en radians.

Format: arcsin( argument) Exemple: arcsin( 0 ) Résultat: 0 arcsinh Calcule l'arc sein hyperbolique de l'argument.

Format: arcsinh( argument) Exemple: arcsinh( 0 ) Résultat: 0 arctan Calcule l'arc tangent de l'argument, donnant le résultat en radians.

Format: arctan( argument) Exemple: arctan( 0 ) Résultat: 0 arctanh Calcule l'arc tangent hyperbolique de l'argument.

Format: arctanh( argument) Exemple: arctanh( 0 ) Résultat: 0 asin Calcule l'arc-en-tête de l'argument, donnant le résultat en radians.

Format: asin{argument) Exemple: asin( 0) Résultat: 0 asinh Calcule l'arc sein hyperbolique de l'argument.

Format: asinh( argument) Exemple: asinh( 0 ) Résultat: 0 atan Calcule l'arc tangent de l'argument, donnant le résultat en radians.

Format: atan{argument) Exemple: atan( 0) Résultat: 0 atantanh Calcule l'arc de tangent hyperbolique de l'argument.

Format: atanh( argument) Exemple: atanh( 0 ) Résultat: 0 ceil Calcule le nombre suivant avec n décimales supérieure ou égale à l'argument (direction la plus infinie).

Format: ceil( n, argument ) Exemple: ceil( 0, 1.01 ) Résultat: 2 Exemple: ceil( 0, -1.01 ) Résultat: -1 ceiling Calcule le nombre suivant avec n décimales supérieure ou égale à l'argument (direction la plus infinie).

Format: ceiling( n, argument ) Exemple: ceiling( 0, 1.01 ) Résultat: 2 Exemple: ceiling( 0, -1.01 ) Résultat: -1 cos Calcule le cosinus de l'argument en radians.

Format: cos( argument) Exemple: cos( 0 ) Résultat: 1 cosh Calcule le cosinus hyperbolique de l'argument.

Format: cosh(argument) Exemple: cosh( 0 ) Résultat: 1 divise Calcule la division des arguments.

Format: divise( dividende, diviseur ) Exemple: divise( 16, 4 ) Résultat: 4 down Calcule le nombre suivant avec n décimale avec moins ou égale valeur absolue que l'argument (direction 0).

Format: down( n, argument ) Exemple: down( 0, 1.01 ) Résultat: 1 Exemple: down( 0, -1.01 ) Résultat: -1 exponentielle. Calcule la puissance du nombre et élevé à l'argument.

Format: exp(argument) Exemple: ex( 0 ) Résultat: 1 floor Calcule le nombre suivant avec des décimales inférieures ou égales à l'argument (direction à moins infini) Format: floor( n, argument ) Exemple: floor( 0, 1.01 ) Résultat: 1 Exemple: floor( 0, -1.01 ) Résultat: -2 gcd Calcule le maximum commun de division des arguments.

Format: gcd(argument1,..., argumentN ) Exemple: gcd( 26, 39 ) Résultat: 13 ln Logaritmo neperiano.

Format: ln'argument ) Exemple: ln( 1 ) Résultat: 0 log Calcule le logarithme de l'argument dans la base indiquée.

Format: log(base, argument ) Exemple: log( 10, 100 ) Résultat: 2 max Calcule le maximum des arguments.

Format: max(argument1,..., argumentN ) Exemple: max( 7, 16, 5 ) Résultat: 16 min Calcule le minimum des arguments.

Format: min(argument1,..., argumentN ) Exemple: min( 1, 7, -1 ) Résultat: -1 multiply Calcule le produit des facteurs.

Format: multiply( factor1, factor2 ) Exemple: multiply( 1, 7 ) Résultat: 7 power Power. Calcule la puissance: base élevée à l'exposant.

Format: power( base, exposant ) Exemple: power( 3, 4 ) Résultat: 81 quota Division. Calcule la division: dividende divisé par division.

Format: quotient( dividende, diviseur ) Exemple: quotient( 16, 4 ) Résultat: 4 root Calcule la racine n-ème de l'argument.

Format: root( n, argument ) Exemple: root( 4, 81 ) Résultat: 3 round Calcule le nombre le plus proche de l'argument avec des décimales.

Format: round( n, argument ) Exemple: round( 2, 0.513 ) Résultat: 0.51 sgn Calcule le signe de l'argument (retourne -1 s'il est négatif, 0 s'il est 0 et 1 s'il est positif).

Format: sgn(argument) Exemple: sgn( -0.1 ) Résultat: -1 sans Calculer le sein de l'argument en radians.

Format: sans [argument] Exemple: sans [pi / 2] Résultat: 1 sinh calcule le sein hyperbolique de l'argument.

Format: sinh( argument ) Exemple: sinh( 0 ) Résultat: 0 sqrt Calcule la racine carrée de l'argument. Format: sqrt( argument ) Exemple: sqrt( 9 ) Résultat: 3 subtract Resta.

Calcule la soustraction: minuant moins en soustrayant. Format: subtract( minuendo, soustrayant ) Exemple: subtract( 3, -2 ) Résultat: 5 sum Calcule la somme des deux additions.

Format: somme1, somme2 ) Exemple: somme 2, 3 ) Résultat: 5 ainsi Calcule la force de l'argument en radians.

Format: tan( argument) Exemple: tan( pi / 4 ) Résultat: 1 tanh Calcule la force hyperbolique de l'argument.

Format: tanh( argument ) Exemple: tanh( 0 ) Résultat: 0 up Calcule le nombre suivant avec n décimale avec une valeur absolue supérieure ou égale à l'argument (direction à moins infini si l'argument est négatif, ou à plus infini si l'argument est positif).

Format: up( n, argument ) Exemple: up( 1, 1.01 ) Résultat: 1.1 value Calcule la valeur numérique de l'argument.

Format: value( argument) Exemple: value( sqrt(2)/ 2 ^ (1/2) ) Résultat: 1 Commande help La commande help montre l'aide de l'application, dont le résumé figure dans le tableau détaillé ci-dessous.

Référence-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX Format: help nom Exemple: help functions Résultat: Affiche l'aide des fonctions ainsi qu'un résumé de chacune d'elles.

L'aide est organisée de manière hiérarchique.

Si la commande help ne prend pas d'arguments, l'aide globale de l'application est affichée, qui est un résumé de chacune des rubriques qui ont de l'aide.

Si la commande help prend comme argument un nom, un texte explicatif de tag nom est affiché à côté d'un résumé de chaque contenu dérivé de celui-ci, chaque contenu dérivé à son tour avec un nom bleu et gras, qui permet d'obtenir de l'aide plus détaillée de chacun de ces tags, tout simplement en faisant: help nom Lorsque vous utilisez la commande help, de nouveaux contenus dérivés par lesquels vous pouvez naviguer apparaissent normalement.

Si vous vous déplacez avec le pointeur de la souris dans le panneau de sortie sur les noms dérivés (nom), vous verrez que lorsque le pointeur est au-dessus d'un nom  < < fils > >, le pointeur de la souris affiche l'icône du type  < < suivre le lien > >, et si à ce moment-là vous appuyez sur le bouton gauche de la souris, vous obtenez directement de l'aide de ce tag, comme si vous écriviez: help nom + return.

Cette fonctionnalité facilite grandement la navigation par l'aide qui sinon serait très cher.

Les noms possibles qui reconnaissent la commande help sont ceux qui sont dans la première colonne du tableau de la section suivante.

Tableau récapitulatif des mots réservés Nous récapitulons ci-dessous dans un tableau la signification des mots réservés.

Invocation à partir de l'interface de commande Dans cette version de l'application, un binaire.jar minimal a été créé et peut être invoqué à partir de l'interface de commande, mais ne permet pas l'exécution interactive.

L'application d'interface de commande exécute une seule commande qui est passée par paramètre dans l'invocation. Cette application accepte trois paramètres d'entrée: -précision (-précision=valeur).

Précision à utiliser -threads (-threads=valeur).

Noter que ce paramètre devra normalement aller entre guillemets doubles, car il est plus normal d'inclure des espaces, et sans guillemets, ces espaces ne pourraient pas faire partie du même paramètre.

Exemple: java -jar multicalcu-commandline-v1.2-SNAPSHOT-all.jar -precision=1000 -threads=7 "-command=print( pi)" Résultat: 3.1415926535893238464338279508419716939937510582049494944230781640862089986288484444470679821480865132823047438445050582231717353594284817528470703521105559644622929494930383884897559334444474747452387678316527120190454545656534948610454326677177717171717171717171717171717177717171717171717171717171777171717171717171717171717171717171717171717171717171717171717171717171717451717171745174545454545454545454545454545454545454545454545454545454545454545454545artartartartartartartartartartartartartartartartartartartartartartIVe pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour l &apos pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour pour l' pour l' pour l &apos pour l' pour l' pour l' pour l' pour l &apos pour l &apos pour l' pour l' pour l' pour l' pour l' pour l'être pour l' pour l' pour l'être pour l' pour l'être pour l' pour l' pour l'être pour l' pour l' pour l' pour l' pour l' pour l'être pour l'être pour l'être pour l'être pour l'être pour l'être pour l'être pour l'être pour l'être pour l'être pour l'être pour l'être pour l'être pour l'être pour l'être pour