by En priorité, référez-vous ici : FAQ Calculatrice TI-Nspire
Et allez à la question 5.
En revanche, si vous trouvez le pdf trop long, voici la liste des fonctions expliquées ici.
La liste suivante n'est pas exhaustive.
- Algèbre :
Show/Hide spoilerAfficher/Masquer le spoiler
- développer une expression : expand(expr)
- développer une expression et regrouper selon une variable : expand(expr,var)
- factoriser une expression dans R : factor(expr)
- factoriser une expression dans R et regrouper selon une variable : factor(expr,var)
- factoriser une expression dans C : cFactor(expr)
- factoriser une expression dans C et regrouper selon une variable : cFactor(expr,var)
- réduire au même dénominateur : comDenom(expr)
- valeur d'une expression en un point : expression|variable=valeur
- valeur d'une expression en spécifiant plusieurs points : expression|variable1=valeur1 and variable2=valeur2 and variable3=valeur3... - Équations :
Show/Hide spoilerAfficher/Masquer le spoiler
- résoudre une équation dans R : solve(eq,var)
- résoudre une équation dans R avec des conditions : solve(eq,var)|variable opérateur valeur (ex: solve(2x+1=0,x)|x>5), on peut mettre plusieurs conditions si on veut (voir dans Algèbre))
- résoudre une équation dans C : cSolve(eq,var) en ajoutant aux variables complexes "_" (ex: cSolve(2x_+1=0,x))
- résoudre une équation dans C avec des conditions : cSolve(eq,var)|variable opérateur valeur (ex: cSolve(2x_+1=0,x)|x>5), on peut mettre plusieurs conditions si on veut (voir dans Algèbre))
- résoudre un système d'équations dans R : solve({eq1,eq2...},{var1,var2...})
- résoudre un système d'équations dans C : cSolve({eq1,eq2...},{var1,var2...}) en ajoutant aux variables complexes "_"
- résoudre un système linéaire sous forme matricielle : simult(a,b) avec a matrice carrée et b vecteur colonne
- résolution approchée de (n'importe quelle équation vue au-dessus) : approx(blabla) ou ctrl+entrée au lieu de entrée pour faire le calcul ou utiliser un nombre ayant un "." (ex: solve(2x+1.=0,x) ou approx(solve(2x+1=0,x))) - Polynômes et fractions rationnelles :
Show/Hide spoilerAfficher/Masquer le spoiler
- degré d'un polynôme : polyDegree(poly,var)
- coefficients d'un polynôme : polyCoeffs(poly,var)
- écriture d'un polynôme à partir de la liste de ses coefficients : polyEval(list,var)
- PGCD de deux polynômes : polyGcd(poly1,poly2)
- quotient de la division euclidienne de deux polynômes : polyQuotient(poly1,poly2)
- reste de la division euclidienne de deux polynômes : polyRemainder(poly1,poly2)
- racines réelles d'un polynôme : zeros(expr,var)
- racines complexes d'un polynôme : cZeros(expr,var) en ajoutant aux variables complexes "_"
- dénominateur d'une fraction rationnelle : getDenom(frac)
- numérateur d'une fraction rationnelle : getNum(frac)
- réduction au même dénominateur : comDenom(frac) - Nombres complexes :
Show/Hide spoilerAfficher/Masquer le spoiler
- argument d'un nombre complexe : angle(z)
- conjugué d'un nombre complexe : conj(z)
- module d'un nombre complexe : abs(z)
- partie imaginaire d'un nombre complexe : imag(z)
- partie réelle d'un nombre complexe : real(z)
- conversion en polaire d'un nombre complexe : z▶Polar - Analyse :
Show/Hide spoilerAfficher/Masquer le spoiler
- conversion d'une expression en ln : expr▶ln
- conversion d'une expression en logbase(n) : expr▶logbase(n)
- conversion d'une expression en exponentielle : expr▶exp
- conversion d'une expression en sinus : expr▶sin
- conversion d'une expression en cosinus : expr▶cos
- dérivée d'une fonction ou dérivée partielle : d(expr,var) ("d" du catalogue)
- nombre dérivé : d(expr,var)|variable=valeur ("d" du catalogue)
- dérivée d'ordre n d'une fonction ou dérivée partielle d'ordre n : d(expr,var,n) ("d" du catalogue)
- développement limité d'une fonction : taylor(expr,var,ordre,point) (on peut omettre le "point" si le point est 0)
- développement limité généralisé d'une fonction : series(expr,var,ordre)
- développement asymptotique d'une fonction : series(expr,var,ordre,∞) (trouver le "∞"dans le catalogue)
- équivalent d'une fonction en un point : dominantTerm(expr,var,point) (on peut omettre le "point" si le point est 0)
- équation d'une tangente : tangentLine(expr,var,point)
- équation d'une normale : normalLine(expr,var,point)
- maximum d'une fonction : fMax(expr,var)
- minimum d'une fonction : fMin(expr,var)
- intégrale (impropre ou non) d'une fonction : ∫(expr,var,a,b) (trouver le ∫ dans la boite mathématique)
- primitive d'une fonction : ∫(expr,var) (trouver le ∫ dans la boite mathématique)
- intégrale double : ∫(∫(expr,var1),var2) (trouver le ∫ dans la boite mathématique)
- intégrale triple : ∫(∫(∫(expr,var1),var2),var3) (trouver le ∫ dans la boite mathématique)
- limite en un point : limit(expr,var,point)
- limite à droite : limit(expr,var,point,1)
- limite à gauche : limit(expr,var,point,-1)
- limite à l'infini : limit(expr,var,point,∞) (soit ∞ soit -∞ selon votre choix)
- somme et séries : ∑(f(n),n,indice initial, indice final)
- produit : ∏(f(n),n,indice initial, indice final) - Nombres réels :
Show/Hide spoilerAfficher/Masquer le spoiler
- arrondi : round(nombre,n) (n qui spécifie le nombre de décimales peut être omis)
- partie entière : floor(nombre) ou int(nombre)
- troncature : iPart(nombre)
- partie décimale : fPart(nombre)
- entier supérieur : ceiling(nombre)
- valeur absolue : abs(nombre) ou |nombre| (pour le second cas, utiliser via la boite mathématique)
- valeur approchée : ▶Decimal ou approx(nombre) ou ctrl+entrée pour faire le calcul en approché
- conversion d'un décimal en rationnel : exact(nombre)
- approximation par un rationnel : approxRationnal(nombre,tol) (la tolérance "tol" peut être omise) - Arithmétique :
Show/Hide spoilerAfficher/Masquer le spoiler
- décomposition en produit de facteurs premiers : factor(nombre)
- quotient d'une division euclidienne : intDiv(nombre1,nombre2)
- reste d'une division euclidienne : remain(nombre1,nombre2) ou mod(nombre1,nombre2)
- factorielle n : n!
- PGCD : gcd(nombre1,nombre2)
- PPCM : lcm(nombre1,nombre2)
- test de primalité : isPrime(nombre) - Dénombrement :
Show/Hide spoilerAfficher/Masquer le spoiler
- nombre d'arrangements (sans répétition) de p objets pris parmi n : nPr(n,p)
- nombre de combinaisons (sans répétition) de p objets pris parmi n : nCr(n,p)
- nombre de permutations de n objets : n! - Transformation d'expressions trigonométriques :
Show/Hide spoilerAfficher/Masquer le spoiler
- conversion en sinus : expr▶sin
- conversion en cosinus : expr▶cos
- développer une expression trigonométrique ou transformation récirproque : tExpand(expr)
- linéariser un produit d'expressions trigonométriques : tCollect(expr) - Statistiques et probabilités :
Show/Hide spoilerAfficher/Masquer le spoiler
- écart type d'échantillon : stdDevSamp(liste)
- écart type de population : stdDevPop(liste)
- médiane : median(liste)
- moyenne : mean(liste)
- régression linéaire : LinRegMx (faire via le catalogue)
- variance d'échantillon : varSamp(liste)
- variance de population : varPop(liste) - Équations différentielles :
Show/Hide spoilerAfficher/Masquer le spoiler
- résolution d'équations différentielles : deSolve(eq,x,y)
- résolution d'équations différentielles avec conditions : deSolve(eq and condition1 and condition2...,x,y) ou deSolve(eq,x,y)|condition 1 and condition 2... - Calcul matriciel :
Show/Hide spoilerAfficher/Masquer le spoiler
- accès à l'élément d'une matrice de ligne n et colonne p: mat[n,p]
- sous-matrice d'une matrice : subMat(mat,l1,c1,l2,c2)
- concaténation de deux matrices par juxtaposition : augment(mat1,mat2)
- concaténation de deux matrices par superposition : colAugment(mat1,mat2)
- matrice nulle avec n lignes et p colonnes : newMat(n,p)
- matrice aléatoire avec n lignes et p colonnes : randMat(n,p)
- matrice carrée diagonale avec x1,x2... dans la diagonale : diag({x1,x2...})
- matrice unité d'ordre n : identity(n)
- remplir une matrice par une expression : fill(expr,mat)
- conversion en vecteur en coordonnées polaires : ▶Polar
- conversion en vecteur en coordonnées cylindriques : ▶Cylind
- conversion en vecteur en coordonnées sphériques : ▶Sphere
- décomposition LU de Crout : LU matr,l,u,p (utiliser le catalogue)
- décomposition QR de Householder : QR matr,q,u (utiliser le catalogue)
- déterminant : det(matr)
- dimension d'un vecteur : dim(vect)
- dimensions d'une matrice : dim(mat)
- exponentielle d'une matrice diagonalisable : e^(mat)
- inverse d'une matrice : mat^-1
- nombre de lignes d'une matrice : rowDim(mat)
- nombre de colonnes d'une matrice : colDim(mat)
- norme euclidienne d'un vecteur : norm(vecteur)
- normalisation d'un vecteur : unitV(vecteur)
- échanger deux lignes d'une matrice : rowSwap(mat,i,j)
- multiplier une ligne d'une matrice par une expression : mRow(expr,mat,i)
- additionner une ligne d'une matrice à une autre ligne de la matrice: rowAdd(mat,i,j)
- multiplier une ligne d'une matrice par une expression et additionner le résultat à une autre ligne : mRowAdd(expr,mat,i,j)
- polynôme caractéristique d'une matrice : charPoly(mat,var)
- produit scalaire : dotP(u,v)
- produit vectoriel : crossP(u,v)
- réduction de Gauss d'une matrice : ref(mat)
- réduction de Gauss-Jordan d'une matrice : rref(mat)
- transposée d'une matrice : mat^T (^T à trouver dans le catalogue)
- trace d'une matrice : trace(mat)
- valeurs propres d'une matrice : eigVI(matr)
- vecteurs propres d'une matrice : eigVc(matr) - Listes :
Show/Hide spoilerAfficher/Masquer le spoiler
- concaténation de deux listes : augment(list1,list2)
- conversion d'une liste en matrice : list▶mat(liste,nombre d'éléments par ligne)
- conversion d'une matrice en liste : mat▶list(mat)
- différences entre les termes d'une liste : Δlist(list)
- maximum des termes d'une liste : max(list)
- minimum des termes d'une liste : min(list)
- nombre d'éléments d'une liste : dim(list)
- nombre d'éléments d'une liste égaux à une valeur donnée ou expression : countIf(list,expr)
- produit des termes d'une liste : product(list)
- répartition des éléments d'une liste : frequency(list1,list2)
- somme des termes d'une liste : sum(list)
- sommes cumulées croissantes d'une liste : cumSum(list)
- tri des termes d'une liste dans l'ordre croissant : SortA list
- tri des termes d'une liste dans l'ordre décroissant : SortD list
.
