ginsh - En ligne dans le Cloud

PROGRAMME:

Nom

ginsh - Coquille interactive GiNaC

RÉSUMÉ

ginsh [fichier...]

DESCRIPTION

ginsh est une interface interactive pour le framework de calcul symbolique GiNaC. Il est
conçu comme un outil pour tester et expérimenter les fonctionnalités de GiNaC, et non comme un
remplacement des systèmes traditionnels de calcul formel interactif. Bien qu'il puisse faire beaucoup
choses que ces systèmes traditionnels peuvent faire, ginsh ne fournit aucune construction de programmation comme
des boucles ou des expressions conditionnelles. Si vous avez besoin de cette fonctionnalité, il est conseillé d'écrire
votre programme en C++, en utilisant le framework de classe "natif" GiNaC.

UTILISATION

CONTRIBUTION Format
Après le démarrage, ginsh affiche une invite ("> ") indiquant qu'il est prêt à accepter votre
saisir. Les entrées acceptables sont des expressions numériques ou symboliques composées de nombres (par ex.
42, 2/3 or 0.17), symboles (par ex. x or résultat), des opérateurs mathématiques comme + ainsi que *et une
fonctions (par exemple sans or Ordinaire). Chaque expression d'entrée doit se terminer par un
point-virgule (;) ou deux points (:). S'il se termine par un point-virgule, ginsh évaluera le
expression et imprimez le résultat sur stdout. S'il se termine par deux points, ginsh ne fera que
évaluer l'expression mais pas imprimer le résultat. Il est possible de saisir plusieurs
expressions sur une seule ligne. Les espaces blancs (espaces, tabulations, nouvelles lignes) peuvent être appliqués librement entre
jetons. Pour quitter ginsh, entrez quitter or sortie, ou tapez un EOF (Ctrl-D) à l'invite.

COMMENTAIRES
Tout ce qui suit une double barre oblique (//) jusqu'à la fin de la ligne, et toutes les lignes commençant
avec un signe dièse (#) sont traités comme des commentaires et ignorés.

NOMBRES
ginsh accepte les nombres dans les notations décimales habituelles. Cela inclut la précision arbitraire
entiers et rationnels ainsi que des nombres à virgule flottante en standard ou scientifique
notation (par exemple 1.2E6). La règle générale est que si un nombre contient une virgule décimale
(.), c'est un nombre à virgule flottante (inexact); sinon c'est un entier (exact) ou
rationnel. Les entiers peuvent être spécifiés en binaire, octal, hexadécimal ou arbitraire (2-36)
base en les préfixant avec #b, #o, #xou #nR , Respectivement.

SYMBOLES
Les symboles sont constitués d'une chaîne de caractères alphanumériques et du trait de soulignement (_), avec
le premier caractère n'étant pas numérique. Par exemple a ainsi que mu_1 sont des noms de symboles acceptables, tandis que
2pi n'est pas. Il est possible d'utiliser des symboles avec les mêmes noms que des fonctions (ex. sans);
ginsh est capable de faire la distinction entre les deux.

Les symboles peuvent se voir attribuer des valeurs en entrant
symbole = expression;

Pour annuler l'attribution de la valeur d'un symbole attribué, tapez
unassign('symbole');

Les symboles attribués sont automatiquement évalués (= remplacés par leur valeur attribuée) lorsque
ils sont utilisés. Pour faire référence au symbole non évalué, mettez des guillemets simples (') autour du nom,
comme démontré pour la commande "unassign" ci-dessus.

Les symboles sont considérés par défaut comme faisant partie du domaine complexe, c'est-à-dire qu'ils sont traités comme si
ils remplacent les nombres complexes. Ce comportement peut être modifié en utilisant les mots-clés
symboles_réels ainsi que symboles_complexes et affecte tous les symboles nouvellement créés.

Les symboles suivants sont des constantes prédéfinies auxquelles aucune valeur ne peut être attribuée par le
utilisateur:

Pi Constante d'Archimède

Catalan Constante de Catalan

Euler Constante d'Euler-Mascheroni

I carré(-1)

FAIL un objet de la classe "fail" GiNaC

Il y a aussi le spécial
Digits
symbole qui contrôle la précision numérique des calculs avec des nombres inexacts.
L'attribution d'une valeur entière aux chiffres changera la précision au nombre donné de
décimales.

CARTES SAUVAGES
Les fonctions has(), find(), match() et subs() acceptent les caractères génériques comme espaces réservés pour
expressions. Ceux-ci ont la syntaxe
$nombre
par exemple 0 $, 1 $, etc.

DERNIER IMPRIMÉ EXPRESSIONS
ginsh fournit les trois symboles spéciaux
%, %% et %%%
qui font respectivement référence à la dernière, à l'avant-dernière et à la troisième dernière expression imprimée.
Ceux-ci sont pratiques si vous souhaitez utiliser les résultats des calculs précédents dans un nouveau
expression.

LES OPÉRATEURS
ginsh fournit les opérateurs suivants, classés par ordre décroissant de priorité :

! factorielle suffixe

^ alimenter

+ unaire plus

- unaire moins

* multiplication

/ division

+ ajout

- soustraction

< moins que

> plus grand que

<= inférieur ou égal

>= supérieur ou égal

== égal

!= inégal

= affectation de symboles

Tous les opérateurs binaires sont associatifs à gauche, à l'exception de ^ ainsi que = qui ont raison-
associatif. Le résultat de l'opérateur d'affectation (=) est son côté droit, donc c'est
possible d'attribuer plusieurs symboles dans une expression (par exemple a = b = c = 2;).

LISTE
Les listes sont utilisées par le sous-marins ainsi que je résous les fonctions. Une liste se compose d'une accolade ouvrante
({), une séquence (éventuellement vide) d'expressions séparées par des virgules et une accolade fermante
(}).

MATRICES
Une matrice se compose d'un crochet ouvrant ([), une séquence non vide séparée par des virgules
de lignes de matrice, et un crochet fermant (]). Chaque ligne de la matrice se compose d'une ouverture
crochet ([), une séquence non vide d'expressions séparées par des virgules et une fermeture
crochet (]). Si les lignes d'une matrice ne sont pas de même longueur, la largeur de la
matrice devient celle de la ligne la plus longue et les lignes les plus courtes sont remplies à la fin avec
éléments de valeur zéro.

FONCTIONS
Un appel de fonction en ginsh a la forme
prénom(arguments)
De arguments est une séquence d'expressions séparées par des virgules. ginsh fournit quelques
fonctions intégrées et "importe" également toutes les fonctions symboliques définies par GiNaC et
bibliothèques supplémentaires. Il n'y a aucun moyen de définir vos propres fonctions autre que la liaison
ginsh contre une bibliothèque qui définit des fonctions symboliques GiNaC.

ginsh fournit la tabulation sur les noms de fonction : si vous tapez la première partie d'une fonction
nom, appuyez sur Tab pour compléter le nom si possible. Si la partie que vous avez saisie n'est pas unique,
appuyer à nouveau sur Tab affichera une liste de fonctions correspondantes. Appuyer deux fois sur Tab à la
L'invite affiche la liste de toutes les fonctions disponibles.

Une liste des fonctions intégrées suit. Ils fonctionnent presque tous en tant que GiNaC respectif
méthodes du même nom, je ne les décrirai donc pas en détail ici. Veuillez vous référer au
Documentation GiNaC.

Charpoly(matrice, symbole) - polynôme caractéristique d'une matrice
coefficient(expression, objet, nombre) - extrait le coefficient de object^number d'un
polynôme
collecter(expression, objet-ou-liste) - collecte des coefficients de puissances similaires (résultat
sous forme récursive)
collect_distributed(expression, liste) - collecte des coefficients de puissances similaires
(résultat sous forme distribuée)
collect_common_factors(expression) - recueille des facteurs communs à partir des termes des sommes
conjuguer(expression) - conjugaison complexe
teneur(expression, symbole) - partie contenue d'un polynôme
décomp_rationnel(expression, symbole) - décomposer la fonction rationnelle en polynôme
et fonction rationnelle propre
diplôme(expression, objet) - degré d'un polynôme
dénomination(expression) - dénominateur d'une fonction rationnelle
déterminant(matrice) - déterminant d'une matrice
diagnostic(expression...) - construit une matrice diagonale
différence(expression, symbole [, numéro]) - différenciation partielle
diviser(expression, expression) - division polynomiale exacte
évaluer(expression [, niveau]) - évalue une expression en remplaçant les symboles par leur
valeur attribuée
évalf(expression [, niveau]) - évalue une expression à un nombre à virgule flottante
évaluation(expression) - évalue des sommes, des produits et des puissances entières de matrices
développer(expression) - développe une expression
facteur(expression) - factorise une expression (univariée)
trouve(expression, modèle) - renvoie une liste de toutes les occurrences d'un motif dans un
expression
frésoudre(expression, symbole, nombre, nombre) - trouver numériquement la racine d'une valeur réelle
fonctionner dans un intervalle
pgcd(expression, expression) - plus grand diviseur commun
a(expression, modèle) - renvoie "1" si la première expression contient le motif
comme sous-expression, "0" sinon
entier_contenu(expression) - contenu entier d'un polynôme
inverse(matrice) - inverse d'une matrice
est(rapport) - renvoie "1" si la relation est vraie, "0" sinon (faux ou
indécis)
lcm(expression, expression) - multiple moins commun
lcoeff(expression, objet) - coefficient dominant d'un polynôme
ldegré(expression, objet) - faible degré d'un polynôme
résoudre(liste d'équations, liste de symboles) - résoudre un système d'équations linéaires
carte(expression, modèle) - appliquer la fonction à chaque opérande ; la fonction à être
appliqué est spécifié comme un modèle avec le caractère générique "$0" représentant les opérandes
rencontre(expression, modèle) - vérifier si l'expression correspond à un modèle ; renvoie un
liste des substitutions de caractères génériques ou "FAIL" s'il n'y a pas de correspondance
non (expression) - nombre d'opérandes dans l'expression
Ordinaire(expression [, niveau]) - normalisation de la fonction rationnelle
nombre(expression) - numérateur d'une fonction rationnelle
nombre_denom(expression) - numérateur et dénominateur d'une fonction rationnelle en tant que
liste
op(expression, nombre) - extraire l'opérande de l'expression
Puissance(expression1, expression2) - exponentiation (équivalent à écrire expr1^expr2)
prem(expression, expression, symbole) - pseudo-reste de polynômes
primapart(expression, symbole) - partie primitive d'un polynôme
quo(expression, expression, symbole) - quotient de polynômes
rang(matrice) - rang d'une matrice
rem(expression, expression, symbole) - reste des polynômes
résultant(expression, expression, symbole) - résultante de deux polynômes avec
par rapport au symbole s
séries(expression, relation-ou-symbole, de commander) - extension de série
sperme (expression, expression, symbole) - pseudo-reste clairsemé de polynômes
sqrlibre(expression [, liste de symboles]) - factorisation sans carré d'un polynôme
carré(expression) - racine carrée
sous-marins(expression, relation-ou-liste)
sous-marins(expression, liste de recherche, remplacer-par-liste) - substituer des sous-expressions (vous
peut utiliser des caractères génériques)
tcoeff(expression, objet) - coefficient de fuite d'un polynôme
temps(expression) - renvoie le temps en secondes nécessaire pour évaluer le donné
expression
tracer(matrice) - trace d'une matrice
transposer(matrice) - transposer une matrice
désaffecter ('symbole') - désaffecter un symbole attribué (attention aux guillemets, s'il vous plaît !)
unité(expression, symbole) - partie unitaire d'un polynôme

SPECIAL COMMANDES
Pour quitter ginsh, entrez
quitter
or
sortie

ginsh peut afficher une aide (courte) pour un sujet donné (principalement sur les fonctions et les opérateurs)
en entrant
?sujet
Dactylographie
??
affichera une liste des rubriques d'aide disponibles.

La commande
impression(expression);
imprimera un dump de la représentation interne de GiNaC pour le expression. C'est
utile pour le débogage et pour en savoir plus sur les internes de GiNaC.

La commande
print_latex(expression);
imprime une représentation LaTeX du donné expression.

La commande
print_csrc(expression);
imprime le donné expression d'une manière qui peut être utilisée dans un programme C ou C++.

La commande
impression(expression);
imprime le donné expression (qui doit être évalué à un entier) en décimal, octal et
représentations hexadécimales.

Enfin, la coquille s'échappe
! [commander [arguments]]
passe le donné commander et éventuellement arguments au shell pour l'exécution. Avec ça
méthode, vous pouvez exécuter des commandes shell à partir de ginsh sans avoir à quitter.

EXEMPLES

> a = x^2-x-2 ;
-2-x+x^2
> b = (x+1)^2 ;
(x+1)^2
> s = a/b;
(x+1)^(-2)*(-2-x+x^2)
> diff(s, x);
(2*x-1)*(x+1)^(-2)-2*(x+1)^(-3)*(-x+x^2-2)
> normale(s) ;
(x-2)*(x+1)^(-1)
> x = 3^50 ;
717897987691852588770249
> s;
717897987691852588770247/717897987691852588770250
> Chiffres = 40 ;
40
> évalf(s) ;
0.999999999999999999999995821133292704384960990679
> unassign('x');
x
> s;
(x+1)^(-2)*(-x+x^2-2)
> série(sin(x),x==0,6) ;
1*x+(-1/6)*x^3+1/120*x^5+Order(x^6)
> lsolve({3*x+5*y == 7}, {x, y});
{x==-5/3*y+7/3,y==y}
> lsolve({3*x+5*y == 7, -2*x+10*y == -5}, {x, y});
{x==19/8,y==-1/40}
> M = [ [a, b], [c, d] ] ;
[[-x+x^2-2,(x+1)^2],[c,d]]
> déterminant(M);
-2*d-2*x*cx^2*cx*d+x^2*dc
> collecter(%, x);
(-d-2*c)*x+(dc)*x^2-2*dc
> résoudre la théorie quantique des champs ;
erreur d'analyse quantique
> quitter

DIAGNOSTIC

erreur d'analyse à foo
Vous avez entré quelque chose que ginsh n'a pas pu analyser. Veuillez vérifier la syntaxe de
votre entrée et réessayez.

argument num à fonction Doit être un type
Le numéro de l'argument num au donné fonction doit être d'un certain type (par exemple un
symbole ou une liste). Le premier argument a le numéro 0, le deuxième argument numéro 1,
et ainsi de suite

Utilisez ginsh en ligne en utilisant les services onworks.net