Manuel du propriétaire | Texas Instruments TI-NSPIRE CAS Manuel utilisateur

Ajouter à Mes manuels
200 Des pages
Manuel du propriétaire | Texas Instruments TI-NSPIRE CAS Manuel utilisateur | Fixfr
Guide de référence
Ce manuel fait référence au logiciel TI-Nspire™ version 3.0. Pour obtenir
la dernière version de ce document, rendez-vous sur
education.ti.com/guides.
Informations importantes
Sauf spécification contraire prévue dans la Licence fournie avec le
programme, Texas Instruments n’accorde aucune garantie expresse ou
implicite, ce qui inclut sans pour autant s’y limiter les garanties implicites
quant à la qualité marchande et au caractère approprié à des fins
particulières, liés aux programmes ou aux documents et fournit
seulement ces matériels en l’état. En aucun cas, Texas Instruments
n’assumera aucune responsabilité envers quiconque en cas de dommages
spéciaux, collatéraux, accessoires ou consécutifs, liés ou survenant du fait
de l’acquisition ou de l’utilisation de ces matériels. La seule et unique
responsabilité incombant à Texas Instruments, indépendamment de la
forme d’action, ne doit pas excéder la somme établie dans la licence du
programme. En outre, Texas Instruments ne sera pas responsable des
plaintes de quelque nature que soit, à l’encontre de l’utilisation de ces
matériels, déposées par une quelconque tierce partie.
Licence
Veuillez consulter la licence complète, copiée dans C:\Program Files\TI
Education\TI-Nspire CAS.
© 2006 - 2011 Texas Instruments Incorporated
ii
Table des matières
Informations importantes
Modèles d'expression
Modèle Fraction ........................................... 1
Modèle Exposant ......................................... 1
Modèle Racine carrée .................................. 1
Modèle Racine n-ième ................................. 1
Modèle e Exposant ...................................... 2
Modèle Logarithme ..................................... 2
Modèle Fonction définie par
morceaux (2 morceaux) ............................... 2
Modèle Fonction définie par
morceaux (n morceaux) ............................... 2
Modèle Système de 2 équations ................. 3
Modèle Système de n équations ................. 3
Modèle Valeur absolue ............................... 3
Modèle dd°mm’ss.ss’’ ................................... 3
Modèle Matrice (2 x 2) ................................ 3
Modèle Matrice (1 x 2) ................................ 3
Modèle Matrice (2 x 1) ................................ 4
Modèle Matrice (m x n) ............................... 4
Modèle Somme (G) ....................................... 4
Modèle Produit (Π) ...................................... 4
Modèle Dérivée première ........................... 4
Modèle Dérivée seconde ............................. 5
Modèle Dérivée n-ième ............................... 5
Modèle Intégrale définie ............................ 5
Modèle Intégrale indéfinie ......................... 5
Modèle Limite .............................................. 5
Liste alphabétique
A
abs() .............................................................. 6
amortTbl() .................................................... 6
and ................................................................ 6
angle() .......................................................... 7
ANOVA ......................................................... 7
ANOVA2way ................................................ 8
Ans .............................................................. 10
approx() ...................................................... 10
4approxFraction() ....................................... 10
approxRational() ........................................ 10
arccos() ........................................................ 10
arccosh() ..................................................... 11
arccot() ........................................................ 11
arccoth() ..................................................... 11
arccsc() ........................................................ 11
arccsch() ...................................................... 11
arcLen() ....................................................... 11
arcsec() ........................................................ 11
arcsech() ...................................................... 11
arcsin() ........................................................ 11
arcsinh() ...................................................... 11
arctan() ....................................................... 11
arctanh() ..................................................... 11
augment() .................................................. 11
avgRC() ....................................................... 12
B
bal() ............................................................ 13
4Base2 ......................................................... 13
4Base10 ....................................................... 14
4Base16 ....................................................... 15
binomCdf() ................................................. 15
binomPdf() ................................................. 15
C
ceiling() ...................................................... 15
centralDiff() ............................................... 16
cFactor() ..................................................... 16
char() .......................................................... 17
charPoly() ................................................... 17
c22way ........................................................ 17
c2Cdf() ........................................................ 18
c2GOF ......................................................... 18
c2Pdf() ........................................................ 18
ClearAZ ....................................................... 19
ClrErr .......................................................... 19
colAugment() ............................................. 19
colDim() ...................................................... 19
colNorm() ................................................... 19
comDenom() .............................................. 20
completeSquare() ...................................... 21
conj() .......................................................... 21
constructMat() ........................................... 21
CopyVar ...................................................... 22
corrMat() .................................................... 22
4cos ............................................................. 22
cos() ............................................................ 23
cos/() .......................................................... 24
cosh() .......................................................... 24
cosh/() ........................................................ 24
cot() ............................................................ 25
cot/() .......................................................... 25
coth() .......................................................... 25
coth/() ........................................................ 26
count() ........................................................ 26
countif() ..................................................... 26
cPolyRoots() ............................................... 27
crossP() ....................................................... 27
csc() ............................................................. 27
csc/() ........................................................... 28
csch() ........................................................... 28
csch/() ......................................................... 28
cSolve() ....................................................... 28
CubicReg .................................................... 30
cumulativeSum() ........................................ 31
Cycle ........................................................... 31
4Cylind ........................................................ 31
cZeros() ....................................................... 32
D
iii
dbd() ...........................................................33
4DD ..............................................................34
4Decimal ......................................................34
Define .........................................................34
Define LibPriv .............................................35
Define LibPub .............................................36
deltaList() ....................................................36
deltaTmpCnv() ............................................36
DelVar .........................................................36
delVoid() .....................................................36
derivative() .................................................36
deSolve() .....................................................37
det() ............................................................38
diag() ...........................................................38
dim() ............................................................38
Disp .............................................................39
4DMS ...........................................................39
dominantTerm() .........................................40
dotP() ..........................................................40
E
e^() ..............................................................41
eff() .............................................................41
eigVc() .........................................................41
eigVl() .........................................................42
Else ..............................................................42
ElseIf ............................................................42
EndFor .........................................................42
EndFunc ......................................................42
EndIf ............................................................42
EndLoop ......................................................42
EndPrgm .....................................................42
EndTry .........................................................42
EndWhile ....................................................43
euler() .........................................................43
exact() .........................................................43
Exit ..............................................................44
4exp .............................................................44
exp() ............................................................44
exp4list() ......................................................45
expand() ......................................................45
expr() ...........................................................46
ExpReg ........................................................46
F
factor() ........................................................47
FCdf() ..........................................................48
Fill ................................................................48
FiveNumSummary ......................................49
floor() ..........................................................49
fMax() .........................................................49
fMin() ..........................................................50
For ...............................................................50
format() ......................................................51
fPart() ..........................................................51
FPdf() ..........................................................51
freqTable4list() ............................................52
frequency() .................................................52
FTest_2Samp ..............................................52
iv
Func ............................................................ 53
G
gcd() ............................................................ 53
geomCdf() .................................................. 54
geomPdf() .................................................. 54
getDenom() ................................................ 54
getLangInfo() ............................................. 54
getLockInfo() .............................................. 55
getMode() .................................................. 55
getNum() .................................................... 56
getType() .................................................... 56
getVarInfo() ............................................... 56
Goto ............................................................ 57
4Grad ........................................................... 57
I
identity() ..................................................... 58
If .................................................................. 58
ifFn() ........................................................... 59
imag() ......................................................... 59
impDif() ...................................................... 60
Indirection .................................................. 60
inString() .................................................... 60
int() ............................................................. 60
intDiv() ........................................................ 60
integral ....................................................... 60
interpolate() ............................................... 61
invc2() ......................................................... 61
invF() .......................................................... 61
invNorm() ................................................... 61
invt() ........................................................... 61
iPart() .......................................................... 62
irr() .............................................................. 62
isPrime() ...................................................... 62
isVoid() ....................................................... 62
L
Lbl ............................................................... 63
lcm() ............................................................ 63
left() ............................................................ 63
libShortcut() ............................................... 64
limit() ou lim() ............................................ 64
LinRegBx ..................................................... 65
LinRegMx ................................................... 66
LinRegtIntervals ......................................... 67
LinRegtTest ................................................ 68
linSolve() ..................................................... 69
@list() ........................................................... 69
list4mat() ..................................................... 69
4ln ................................................................ 69
ln() .............................................................. 70
LnReg .......................................................... 70
Local ........................................................... 71
Lock ............................................................ 71
log() ............................................................ 72
4logbase ...................................................... 72
Logistic ....................................................... 73
LogisticD ..................................................... 74
Loop ............................................................ 75
LU ................................................................ 75
M
mat4list() ..................................................... 76
max() ........................................................... 76
mean() ........................................................ 76
median() ..................................................... 77
MedMed ..................................................... 77
mid() ........................................................... 78
min() ........................................................... 78
mirr() ........................................................... 79
mod() .......................................................... 79
mRow() ....................................................... 79
mRowAdd() ................................................ 79
MultReg ...................................................... 80
MultRegIntervals ........................................ 80
MultRegTests .............................................. 81
N
nCr() ............................................................ 82
nDerivative() ............................................... 82
newList() ..................................................... 82
newMat() .................................................... 82
nfMax() ....................................................... 83
nfMin() ........................................................ 83
nInt() ........................................................... 83
nom() .......................................................... 84
norm() ......................................................... 84
normalLine() ............................................... 84
normCdf() ................................................... 84
normPdf() ................................................... 84
not .............................................................. 85
nPr() ............................................................ 85
npv() ............................................................ 86
nSolve() ....................................................... 86
O
OneVar ....................................................... 87
or ................................................................. 88
ord() ............................................................ 88
P
P4Rx() ........................................................... 89
P4Ry() ........................................................... 89
PassErr ......................................................... 89
piecewise() .................................................. 90
poissCdf() .................................................... 90
poissPdf() .................................................... 90
4Polar .......................................................... 90
polyCoeffs() ................................................ 91
polyDegree() .............................................. 91
polyEval() .................................................... 91
polyGcd() .................................................... 92
polyQuotient() ........................................... 92
polyRemainder() ........................................ 92
polyRoots() ................................................. 93
PowerReg ................................................... 93
Prgm ........................................................... 94
prodSeq() ................................................... 94
Product (PI) ................................................ 94
product() .................................................... 94
propFrac() ................................................... 95
Q
QR ............................................................... 95
QuadReg .................................................... 96
QuartReg .................................................... 97
R
R4Pq() .......................................................... 98
R4Pr() ........................................................... 98
4Rad ............................................................ 98
rand() .......................................................... 98
randBin() .................................................... 99
randInt() ..................................................... 99
randMat() ................................................... 99
randNorm() ................................................ 99
randPoly() ................................................... 99
randSamp() ................................................ 99
RandSeed ................................................. 100
real() ......................................................... 100
4Rect ......................................................... 100
ref() ........................................................... 101
remain() .................................................... 101
Request .................................................... 102
RequestStr ................................................ 103
Return ...................................................... 103
right() ....................................................... 103
rk23() ........................................................ 104
root() ........................................................ 104
rotate() ..................................................... 105
round() ..................................................... 105
rowAdd() .................................................. 106
rowDim() .................................................. 106
rowNorm() ............................................... 106
rowSwap() ................................................ 106
rref() ......................................................... 106
S
sec() .......................................................... 107
sec/() ......................................................... 107
sech() ........................................................ 107
sech/() ...................................................... 108
seq() .......................................................... 108
seqGen() ................................................... 109
seqn() ........................................................ 109
series() ...................................................... 110
setMode() ................................................. 111
shift() ........................................................ 112
sign() ......................................................... 113
simult() ..................................................... 113
4sin ............................................................ 114
sin() ........................................................... 114
sin/() ......................................................... 115
sinh() ......................................................... 115
sinh/() ....................................................... 115
SinReg ...................................................... 116
v
solve() ........................................................117
SortA .........................................................119
SortD .........................................................119
4Sphere ......................................................120
sqrt() ..........................................................120
stat.results ................................................121
stat.values .................................................122
stDevPop() ................................................122
stDevSamp() ..............................................122
Stop ...........................................................123
Store ..........................................................123
string() ......................................................123
subMat() ...................................................123
Sum (Sigma) ..............................................123
sum() .........................................................123
sumIf() .......................................................124
sumSeq() ...................................................124
system() .....................................................124
T
T (transposée) ...........................................125
tan() ..........................................................125
tan/() .........................................................126
tangentLine() ............................................126
tanh() ........................................................126
tanh/() ......................................................127
taylor() ......................................................127
tCdf() .........................................................127
tCollect() ...................................................128
tExpand() ..................................................128
Text ...........................................................128
Then ..........................................................128
tInterval ....................................................129
tInterval_2Samp .......................................129
tmpCnv() ...................................................130
@tmpCnv() .................................................130
tPdf() .........................................................130
trace() ........................................................131
Try .............................................................131
tTest ..........................................................132
tTest_2Samp .............................................132
tvmFV() .....................................................133
tvmI() .........................................................133
tvmN() .......................................................133
tvmPmt() ...................................................133
tvmPV() .....................................................133
TwoVar .....................................................134
U
unitV() .......................................................136
unLock ......................................................136
V
varPop() ....................................................136
varSamp() ..................................................137
W
warnCodes() .............................................137
when() .......................................................137
vi
While ........................................................ 138
With .......................................................... 138
X
xor ............................................................. 138
Z
zeros() ....................................................... 139
zInterval ................................................... 141
zInterval_1Prop ........................................ 141
zInterval_2Prop ........................................ 141
zInterval_2Samp ...................................... 142
zTest ......................................................... 143
zTest_1Prop .............................................. 143
zTest_2Prop .............................................. 144
zTest_2Samp ............................................ 144
Symboles
+ (somme) ................................................. 145
N(soustraction) ......................................... 145
·(multiplication) ...................................... 146
à (division) ................................................ 146
^ (puissance) ............................................. 147
x2 (carré) ................................................... 148
.+ (addition élément par élément) ......... 148
.. (soustraction élément par élément) .... 148
.·(multiplication élément par
élément) ................................................... 148
. / (division élément par élément) ........... 149
.^ (puissance élément par élément) ....... 149
L(opposé) .................................................. 149
% (pourcentage) ...................................... 150
= (égal à) .................................................. 150
ƒ (différent de) ........................................ 151
< (inférieur à) ........................................... 151
{ (inférieur ou égal à) .............................. 151
> (supérieur à) .......................................... 151
| (supérieur ou égal à) ............................ 152
! (factorielle) ............................................ 152
& (ajouter) ................................................ 152
d() (dérivée) .............................................. 153
‰() (intégrale) ............................................ 153
‡() (racine carrée) .................................... 154
Π() (prodSeq) ............................................ 155
G() (sumSeq) ............................................. 155
GInt() ......................................................... 156
GPrn() ........................................................ 157
# (indirection) .......................................... 157
E (notation scientifique) .......................... 157
g (grades) ................................................. 158
R(radians) .................................................. 158
¡ (degré) ................................................... 158
¡, ', '' (degré/minute/seconde) ................. 159
± (angle) .................................................. 159
' (guillemets) ............................................ 159
_ (trait bas considéré comme
élément vide) ........................................... 160
_ (trait bas considéré comme unité) ....... 160
4 (conversion) ........................................... 160
10^() ..........................................................160
^/ (inverse) ...............................................161
| (“sachant que”) ...................................... 161
& (stocker) ................................................ 162
:= (assigner) .............................................. 162
© (commentaire) ...................................... 162
0b, 0h ........................................................ 163
Éléments vides
Calculs impliquant des éléments
vides ..........................................................164
Arguments de liste contenant des
éléments vides ..........................................164
Raccourcis de saisie
d'expressions mathématiques
Hiérarchie de l'EOS™ (Equation
Operating System)
Codes et messages d'erreur
Codes et messages
d'avertissement
Informations sur les services et la
garantie TI
vii
viii
Guide de référence TI-Nspire™ CAS
Ce guide fournit la liste des modèles, fonctions, commandes et opérateurs disponibles pour le
calcul d'expressions mathématiques.
Modèles d'expression
Les modèles d'expression facilitent la saisie d'expressions mathématiques en notation standard.
Lorsque vous utilisez un modèle, celui-ci s'affiche sur la ligne de saisie, les petits carrés
correspondants aux éléments que vous pouvez saisir. Un curseur identifie l'élément que vous
pouvez saisir.
Utilisez les touches fléchées ou appuyez sur e pour déplacer le curseur sur chaque élément,
puis tapez la valeur ou l'expression correspondant à chaque élément. Appuyez sur
· ou
/· pour calculer l'expression.
Modèle Fraction
Touches
/p
Exemple :
Remarque : Voir aussi / (division), page 146.
Modèle Exposant
Touche
l
Exemple :
l
Remarque : Tapez la première valeur, appuyez sur
, puis entrez
l'exposant. Pour ramener le curseur sur la ligne de base, appuyez sur
¢
la flèche droite ( ).
Remarque : Voir aussi ^ (puissance), page 147.
Modèle Racine carrée
Touches
/q
Touches
/l
Exemple :
Remarque : Voir aussi ‡() (racine carrée), page 154.
Modèle Racine n-ième
Exemple :
Remarque : Voir aussi root(), page 104.
Guide de référence TI-Nspire™ CAS
1
Modèle e Exposant
Touches
u
Exemple :
La base du logarithme népérien e élevée à une puissance
Remarque : Voir aussi e^(), page 41.
Modèle Logarithme
Touches
/s
Exemple :
Calcule le logarithme selon la base spécifiée. Par défaut la base est
10, dans ce cas ne spécifiez pas de base.
Remarque : Voir aussi log(), page 72.
Modèle Fonction définie par morceaux (2
morceaux)
Catalogue >
Exemple :
Permet de créer des expressions et des conditions pour une fonction
définie par deux morceaux.- Pour ajouter un morceau
supplémentaire, cliquez dans le modèle et appliquez-le de nouveau.
Remarque : Voir aussi piecewise(), page 90.
Modèle Fonction définie par morceaux (n
morceaux)
Permet de créer des expressions et des conditions pour une fonction
définie par n- morceaux. Le système vous invite à définir n.
Remarque : Voir aussi piecewise(), page 90.
2
Guide de référence TI-Nspire™ CAS
Catalogue >
Exemple :
Voir l'exemple donné pour le modèle Fonction définie par
morceaux (2 morceaux).
Modèle Système de 2 équations
Catalogue >
Exemple :
Crée une système de deux équations . Pour ajouter une nouvelle ligne
à un système existant, cliquez dans le modèle et appliquez-le de
nouveau.
Remarque : Voir aussi system(), page 124.
Modèle Système de n équations
Catalogue >
Permet de créer un système de N linéaires. Le système vous invite à
définir N.
Exemple :
Voir l'exemple donné pour le modèle Système de 2 équations.
Remarque : Voir aussi system(), page 124.
Modèle Valeur absolue
Catalogue >
Exemple :
Remarque : Voir aussi abs(), page 6.
Modèle dd°mm’ss.ss’’
Catalogue >
Exemple :
Permet d'entrer des angles en utilisant le format dd°mm’ss.ss’’, où
dd correspond au nombre de degrés décimaux, mm au nombre de
minutes et ss.ss au nombre de secondes.
Modèle Matrice (2 x 2)
Catalogue >
Exemple :
Crée une matrice de type 2 x 2.
Modèle Matrice (1 x 2)
Catalogue >
Exemple :
.
Guide de référence TI-Nspire™ CAS
3
Modèle Matrice (2 x 1)
Catalogue >
Exemple :
Modèle Matrice (m x n)
Le modèle s'affiche après que vous ayez saisi le nombre de lignes et
de colonnes.
Catalogue >
Exemple :
Remarque : si vous créez une matrice dotée de nombreuses lignes
et colonnes, son affichage peut prendre quelques minutes.
Modèle Somme (G)
Catalogue >
Exemple :
Remarque : voir aussi G() (sumSeq), page 155.
Modèle Produit (Π)
Catalogue >
Exemple :
Remarque : Voir aussi Π() (prodSeq), page 155.
Modèle Dérivée première
Catalogue >
Par exemple :
Vous pouvez utiliser ce modèle pour calculer la dérivée première en
un point.
Remarque : voir aussi d() (dérivée), page 153.
4
Guide de référence TI-Nspire™ CAS
Modèle Dérivée seconde
Catalogue >
Par exemple :
Vous pouvez utiliser ce modèle pour calculer la dérivée seconde en un
point.
Remarque : voir aussi d() (dérivée), page 153.
Modèle Dérivée n-ième
Catalogue >
Exemple :
Vous pouvez utiliser ce modèle pour calculer la dérivée n-ième.
Remarque : Voir aussi d() (dérivée), page 153.
Modèle Intégrale définie
Catalogue >
Exemple :
Remarque : voir aussi ‰() integral(), page 153.
Modèle Intégrale indéfinie
Catalogue >
Exemple :
Remarque : Voir aussi ‰() integral(), page 153.
Modèle Limite
Catalogue >
Exemple :
Utilisez N ou (N) pour définir la limite à gauche et la touche + pour la
limite à droite.
Remarque : Voir aussi limit(), page 64.
Guide de référence TI-Nspire™ CAS
5
Liste alphabétique
Les éléments dont le nom n'est pas alphabétique (comme +, !, et >) apparaissent à la fin de
cette section, à partir de la page 145. Sauf indication contraire, tous les exemples fournis dans
cette section ont été réalisés en mode de réinitialisation par défaut et toutes les variables sont
considérées comme indéfinies.
A
abs()
Catalogue >
abs(Expr1) ⇒ expression
abs(Liste1) ⇒ liste
abs(Matrice1) ⇒ matrice
Donne la valeur absolue de l'argument.
Remarque : Voir aussi Modèle Valeur absolue, page 3.
Si l'argument est un nombre complexe, donne le module de ce
nombre.
Remarque : toutes les variables non affectées sont considérées
comme réelles.
amortTbl()
Catalogue >
amortTbl(NPmt,N,I,PV, [Pmt], [FV], [PpY], [CpY], [PmtAt],
[valArrondi]) ⇒ matrice
Fonction d'amortissement affichant une matrice représentant un
tableau d'amortissement pour un ensemble d'arguments TVM.
NPmt est le nombre de versements à inclure au tableau. Le tableau
commence avec le premier versement.
N, I, PV, Pmt, FV, PpY, CpY et PmtAt sont décrits dans le tableau
des arguments TVM, page 134.
•
•
•
Si vous omettez Pmt, il prend par défaut la valeur
Pmt=tvmPmt(N,I,PV,FV,PpY,CpY,PmtAt).
Si vous omettez FV, il prend par défaut la valeur FV=0.
Les valeurs par défaut pour PpY, CpY et PmtAt sont les mêmes
que pour les fonctions TVM.
valArrondi spécifie le nombre de décimales pour arrondissement.
Valeur par défaut=2.
Les colonnes dans la matrice résultante apparaissent dans l'ordre
suivant : Numéro de versement, montant versé pour les intérêts,
montant versé pour le capital et solde.
Le solde affiché à la ligne n correspond au solde après le versement n.
Vous pouvez utiliser la matrice de sortie pour insérer les valeurs des
autres fonctions d'amortissement GInt() et GPrn(), page 156 et bal(),
page 13.
and
Catalogue >
Expr booléenne1 and Expr booléenne2
⇒ Expression booléenne
Liste booléenne1 et Liste booléenne2 ⇒ Liste booléenne
Matrice booléenne1 et Matrice booléenne2 ⇒ Matrice
booléenne
Donne true (vrai) ou false (faux) ou une forme simplifiée de l'entrée
initiale.
6
Guide de référence TI-Nspire™ CAS
and
Catalogue >
Entier1 and Entier2 ⇒ entier
En mode base Hex :
Compare les représentations binaires de deux entiers réels en
appliquant un and bit à bit. En interne, les deux entiers sont convertis
Important : utilisez le chiffre zéro et pas la lettre O.
en nombres binaires 64 bits signés. Lorsque les bits comparés
correspondent, le résultat est 1 si dans les deux cas il s'agit d'un bit 1
; dans les autres cas, le résultat est 0. La valeur donnée représente le En mode base Bin :
résultat des bits et elle est affichée selon le mode Base utilisé.
Les entiers de tout type de base sont admis. Pour une entrée binaire
ou hexadécimale, vous devez utiliser respectivement le préfixe 0b ou
0h. Tout entier sans préfixe est considéré comme un nombre en
écriture décimale (base 10).
En mode base Dec :
Si vous entrez un nombre dont le codage binaire signé dépasse 64
Remarque : une entrée binaire peut comporter jusqu'à 64
bits, il est ramené à l'aide d'une congruence dans la plage appropriée. chiffres (sans compter le préfixe 0b) ; une entrée hexadécimale
jusqu'à 16 chiffres.
angle()
angle(Expr1)
Catalogue >
⇒ expression
En mode Angle en degrés :
Donne l'argument de l'expression passée en paramètre, celle-ci étant
interprétée comme un nombre complexe.
Remarque : toutes les variables non affectées sont considérées
En mode Angle en grades :
comme réelles.
En mode Angle en radians :
angle(Liste1) ⇒ liste
angle(Matrice1) ⇒ matrice
Donne la liste ou la matrice des arguments des éléments de Liste1 ou
Matrice1, où chaque élément est interprété comme un nombre
complexe représentant un point de coordonnée rectangulaire à deux
dimensions.
ANOVA
Catalogue >
ANOVA Liste1,Liste2[,Liste3,...,Liste20][,Indicateur]
Effectue une analyse unidirectionnelle de variance pour comparer les
moyennes de deux à vingt populations. Un récapitulatif du résultat
est stocké dans la variable stat.results. (Voir page 121.)
Indicateur=0 pour Données, Indicateur=1 pour Stats
Variable de sortie
Description
stat.F
Valeur de F statistique
stat.PVal
Plus petit seuil de signification permettant de rejeter l'hypothèse nulle
stat.df
Degré de liberté des groupes
Guide de référence TI-Nspire™ CAS
7
Variable de sortie
Description
stat.SS
Somme des carrés des groupes
stat.MS
Moyenne des carrés des groupes
stat.dfError
Degré de liberté des erreurs
stat.SSError
Somme des carrés des erreurs
stat.MSError
Moyenne des carrés des erreurs
stat.sp
Écart-type du groupe
stat.xbarlist
Moyenne des entrées des listes
stat.CLowerList
Limites inférieures des intervalles de confiance de 95 % pour la moyenne de chaque liste d'entrée
stat.CUpperList
Limites supérieures des intervalles de confiance de 95 % pour la moyenne de chaque liste d'entrée
ANOVA2way
Catalogue >
ANOVA2way Liste1,Liste2[,…[,Liste10]][,NivLign]
Effectue une analyse de variance à deux facteurs pour comparer les
moyennes de deux à dix populations. Un récapitulatif du résultat est
stocké dans la variable stat.results. (Voir page 121.)
NivLign=0 pour Bloc
NivLign=2,3,...,Len-1, pour 2 facteurs, où
Long=length(Liste1)=length(Liste2) = … = length(Liste10) et
Long / NivLign ∈ {2,3,…}
Sorties : Bloc
Variable de sortie
8
Description
stat.F
F statistique du facteur de colonne
stat.PVal
Plus petit seuil de signification permettant de rejeter l'hypothèse nulle
stat.df
Degré de liberté du facteur de colonne
stat.SS
Somme des carrés du facteur de colonne
stat.MS
Moyenne des carrés du facteur de colonne
stat.FBlock
F statistique du facteur
stat.PValBlock
Plus petite probabilité permettant de rejeter l'hypothèse nulle
stat.dfBlock
Degré de liberté du facteur
stat.SSBlock
Somme des carrés du facteur
stat.MSBlock
Moyenne des carrés du facteur
stat.dfError
Degré de liberté des erreurs
stat.SSError
Somme des carrés des erreurs
stat.MSError
Moyenne des carrés des erreurs
stat.s
Écart-type de l'erreur
Guide de référence TI-Nspire™ CAS
Sorties FACTEUR DE COLONNE
Variable de sortie
Description
stat.Fcol
F statistique du facteur de colonne
stat.PValCol
Valeur de probabilité du facteur de colonne
stat.dfCol
Degré de liberté du facteur de colonne
stat.SSCol
Somme des carrés du facteur de colonne
stat.MSCol
Moyenne des carrés du facteur de colonne
Sorties FACTEUR DE LIGNE
Variable de sortie
Description
stat.Frow
F statistique du facteur de ligne
stat.PValRow
Valeur de probabilité du facteur de ligne
stat.dfRow
Degré de liberté du facteur de ligne
stat.SSRow
Somme des carrés du facteur de ligne
stat.MSRow
Moyenne des carrés du facteur de ligne
Sorties INTERACTION
Variable de sortie
Description
stat.FInteract
F statistique de l'interaction
stat.PValInteract
Valeur de probabilité de l'interaction
stat.dfInteract
Degré de liberté de l'interaction
stat.SSInteract
Somme des carrés de l'interaction
stat.MSInteract
Moyenne des carrés de l'interaction
Sorties ERREUR
Variable de sortie
Description
stat.dfError
Degré de liberté des erreurs
stat.SSError
Somme des carrés des erreurs
stat.MSError
Moyenne des carrés des erreurs
s
Écart-type de l'erreur
Guide de référence TI-Nspire™ CAS
9
Ans
Ans
Touches
/v
⇒ valeur
Donne le résultat de la dernière expression calculée.
approx()
approx(Expr1)
Catalogue >
⇒ expression
Donne une approximation décimale de l'argument sous forme
d'expression, dans la mesure du possible, indépendamment du mode
Auto ou Approché utilisé.
Ceci est équivalent à la saisie de l'argument suivie d'une pression sur
/·.
approx(Liste1) ⇒ liste
approx(Matrice1) ⇒ matrice
Donne une liste ou une matrice d'éléments pour lesquels une
approximation décimale a été calculée, dans la mesure du possible.
4approxFraction()
Catalogue >
Expr 4approxFraction([tol]) ⇒ expression
Liste 4approxFraction([tol]) ⇒ liste
Matrice 4approxFraction([tol]) ⇒ matrice
Donne l'entrée sous forme de fraction en utilisant une tolérance tol. Si
tol est omis, la tolérance 5.E-14 est utilisée.
Remarque : vous pouvez insérer cette fonction à partir du clavier
de l'ordinateur en entrant @>approxFraction(...).
approxRational()
Catalogue >
⇒ expression
⇒ liste
approxRational(Matrice[, tol]) ⇒ matrice
approxRational(Expr[, tol])
approxRational(Liste[, tol])
Donne l'argument sous forme de fraction en utilisant une tolérance
tol. Si tol est omis, la tolérance 5.E-14 est utilisée.
arccos()
10
Guide de référence TI-Nspire™ CAS
Voir cos/(), page 24.
Voir cosh/(), page 24.
arccosh()
Voir cot/(), page 25.
arccot()
Voir coth/(), page 26.
arccoth()
Voir csc/(), page 28.
arccsc()
Voir csch/(), page 28.
arccsch()
arcLen()
Catalogue >
arcLen(Expr1,Var,Début,Fin)
⇒ expression
Donne la longueur de l'arc de la courbe définie par Expr1 entre les
points d'abscisses Début et Fin en fonction de la variable Var.
La longueur d'arc est calculée sous forme d'intégrale en supposant la
définition du mode fonction.
arcLen(Liste1,Var,Début,Fin)
⇒ liste
Donne la liste des longueurs d'arc de chaque élément de Liste1 entre
les points d'abscisses Début et Fin en fonction de la variable Var.
Voir sec/(), page 107.
arcsec()
Voir sech/(), page 108.
arcsech()
Voir sin/(), page 115.
arcsin()
arcsinh()
Voir sinh/(), page 115.
arctan()
Voir tan/(), page 126.
Voir tanh/(), page 127.
arctanh()
augment()
augment(Liste1, Liste2)
Catalogue >
⇒ liste
Donne une nouvelle liste obtenue en plaçant les éléments de Liste2 à
la suite de ceux de Liste1.
Guide de référence TI-Nspire™ CAS
11
augment()
augment(Matrice1, Matrice2)
Catalogue >
⇒ matrice
Donne une nouvelle matrice obtenue en ajoutant les lignes/colonnes
de la Matrice2 à celles de la Matrice1. Les matrices doivent avoir le
même nombre de lignes et Matrice2 est ajoutée à Matrice1 via la
création de nouvelles colonnes. Matrice1 et Matrice2 ne sont pas
modifiées.
avgRC()
avgRC(Expr1, Var [=Valeur] [, Incrément])
Catalogue >
⇒ expression
⇒ liste
⇒ liste
avgRC(Matrice1, Var [=Valeur] [, Incrément]) ⇒ matrice
avgRC(Expr1, Var [=Valeur] [, Liste1])
avgRC(Liste1, Var [=Valeur] [, Incrément])
Donne le taux d'accroissement moyen (quotient à différence
antérieure) de l'expression.
Expr1 peut être un nom de fonction défini par l'utilisateur
(voir Func).
Si valeur est spécifiée, celle-ci prévaut sur toute affectation de
variable ou substitution précédente de type “sachant que” pour la
variable.
Incrément correspond à la valeur de l'incrément. Si Incrément n'est
pas spécifié, il est fixé par défaut à 0,001.
Notez que la fonction comparable nDeriv() utilise le quotient à
différence symétrique.
Notez que la fonction comparable centralDiff() utilise le quotient à
différence centrée.
12
Guide de référence TI-Nspire™ CAS
B
bal()
Catalogue >
bal(NPmt,N,I,PV,[Pmt], [FV], [PpY], [CpY], [PmtAt],
[valArrondi]) ⇒ valeur
bal(NPmt,tblAmortissement)
⇒ valeur
Fonction d'amortissement destinée à calculer le solde après
versement d'un montant spécifique.
N, I, PV, Pmt, FV, PpY, CpY et PmtAt sont décrits dans le tableau
des arguments TVM, page 134.
NPmt indique le numéro de versement après lequel vous souhaitez
que les données soient calculées.
N, I, PV, Pmt, FV, PpY, CpY et PmtAt sont décrits dans le tableau
des arguments TVM, page 134.
•
•
•
Si vous omettez Pmt, il prend par défaut la valeur
Pmt=tvmPmt(N,I,PV,FV,PpY,CpY,PmtAt).
Si vous omettez FV, il prend par défaut la valeur FV=0.
Les valeurs par défaut pour PpY, CpY et PmtAt sont les mêmes
que pour les fonctions TVM.
valArrondi spécifie le nombre de décimales pour arrondissement.
Valeur par défaut=2.
bal(NPmt,tblAmortissement) calcule le solde après le numéro de
paiement NPmt, sur la base du tableau d'amortissement
tblAmortissement. L'argument tblAmortissement doit être une
matrice au format décrit à tblAmortissement(), page 6.
Remarque : voir également GInt() et GPrn(), page 156.
4Base2
Catalogue >
Entier1 4Base2 ⇒ entier
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>Base2.
Convertit Entier1 en nombre binaire. Les nombres binaires et les
nombres hexadécimaux présentent toujours respectivement un
préfixe, 0b ou 0h.
Guide de référence TI-Nspire™ CAS
13
4Base2
Catalogue >
Zéro et pas la lettre O, suivi de b ou h.
0b nombreBinaire
0h nombreHexadécimal
Une entrée binaire peut comporter jusqu'à 64
chiffres (sans compter le préfixe 0b) ; une entrée
Si Entier1 est entré sans préfixe, il est considéré comme un nombre
en écriture décimale (base 10). Le résultat est affiché sous forme
binaire, indépendamment du mode Base utilisé.
Les nombres négatifs sont affichés sous forme de complément à deux.
Par exemple,
N1 s'affiche sous la forme
0hFFFFFFFFFFFFFFFF en mode Base Hex
0b111...111 (64 1’s) en mode Base Binaire
N263 s'affiche sous la forme
0h8000000000000000 en mode Base Hex
0b100...000 (63 zéros) en mode Base Binaire
Si vous entrez un nombre dont le codage binaire signé est hors de la
plage des 64 bits, il est ramené à l'aide d'une congruence dans la
plage appropriée. Consultez les exemples suivants de valeurs hors
plage.
263 devient N263 et s'affiche sous la forme
0h8000000000000000 en mode Base Hex
0b100...000 (63 zéros) en mode Base Binaire
264 devient 0 et s'affiche sous la forme
0h0 en mode Base Hex
0b0 en mode Base Binaire
N263 N 1 devient 263 N 1 et s'affiche sous la forme
0h7FFFFFFFFFFFFFFF en mode Base Hex
0b111...111 (64 1) en mode Base Binaire
4Base10
Entier1 4Base10 ⇒ entier
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>Base10.
Convertit Entier1 en un nombre décimal (base 10). Toute entrée
binaire ou hexadécimale doit avoir respectivement un préfixe 0b ou
0h.
0b nombreBinaire
0h nombreHexadécimal
Zéro et pas la lettre O, suivi de b ou h.
Une entrée binaire peut comporter jusqu'à 64 chiffres (sans compter
le préfixe 0b) ; une entrée hexadécimale jusqu'à 8 chiffres.
Sans préfixe, Entier1 est considéré comme décimal. Le résultat est
affiché en base décimale, quel que soit le mode Base en cours
d'utilisation.
14
Guide de référence TI-Nspire™ CAS
Catalogue >
4Base16
Catalogue >
Entier1 4Base16 ⇒ entier
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>Base16.
Convertit Entier1 en nombre hexadécimal. Les nombres binaires et
les nombres hexadécimaux présentent toujours respectivement un
préfixe, 0b ou 0h.
0b nombreBinaire
0h nombreHexadécimal
Zéro et pas la lettre O, suivi de b ou h.
Une entrée binaire peut comporter jusqu'à 64 chiffres (sans compter
le préfixe 0b) ; une entrée hexadécimale jusqu'à 16 chiffres.
Si Entier1 est entré sans préfixe, il est considéré comme un nombre
en écriture décimale (base 10). Le résultat est affiché sous forme
hexadécimal, indépendamment du mode Base utilisé.
Si vous entrez un nombre dont le codage binaire signé dépasse 64
bits, il est ramené à l'aide d'une congruence dans la plage appropriée.
Pour de plus amples informations, voir 4Base2, page 13.
binomCdf()
binomCdf(n,p)
Catalogue >
⇒ nombre
binomCdf(n,p,lowBound,upBound) ⇒ nombre si les bornes
lowBound et upBound sont des nombres, liste si les bornes
lowBound et upBound sont des listes
binomCdf(n,p,upBound) pour P(0{X{upBound) ⇒ nombre
si la borne upBound est un nombre, liste si la borne upBound
est une liste
Calcule la probabilité cumulée d'une variable suivant une loi
binomiale de paramètres n = nombre d'essais et p = probabilité de
réussite à chaque essai.
Pour P(X { upBound), définissez la borne lowBound=0
binomPdf()
Catalogue >
⇒ nombre
binomPdf(n,p,ValX) ⇒ nombre si ValX est un nombre, liste si
binomPdf(n,p)
ValX est une liste
Calcule la probabilité de ValX pour la loi binomiale discrète avec un
nombre n d'essais et la probabilité p de réussite pour chaque essai.
C
ceiling()
ceiling(Expr1)
Catalogue >
⇒ entier
Donne le plus petit entier | à l'argument.
L'argument peut être un nombre réel ou un nombre complexe.
Remarque : Voir aussi floor().
ceiling(Liste1) ⇒ liste
ceiling(Matrice1) ⇒ matrice
Donne la liste ou la matrice de plus petites valeurs supérieures ou
égales à chaque élément.
Guide de référence TI-Nspire™ CAS
15
centralDiff()
Catalogue >
⇒ expression
centralDiff(Expr1,Var [,Pas])|Var=Valeur ⇒ expression
centralDiff(Expr1,Var [=Valeur][,Liste]) ⇒ liste
centralDiff(Liste1,Var [=Valeur][,Incrément]) ⇒ liste
centralDiff(Matrice1,Var [=Valeur][,Incrément]) ⇒ matrice
centralDiff(Expr1,Var [=Valeur][,Pas])
Affiche la dérivée numérique en utilisant la formule du quotient à
différence centrée.
Si valeur est spécifiée, celle-ci prévaut sur toute affectation de
variable ou substitution précédente de type "sachant que" pour la
variable.
Incrément correspond à la valeur de l'incrément. Si Incrément n'est
pas spécifié, il est fixé par défaut à 0,001.
Si vous utilisez Liste1 ou Matrice1, l'opération s'étend aux valeurs
de la liste ou aux éléments de la matrice.
Remarque : voir aussi avgRC() et d().
cFactor()
Catalogue >
cFactor(Expr1[,Var]) ⇒ expression
cFactor(Liste1[,Var]) ⇒ liste
cFactor(Matrice1[,Var]) ⇒ matrice
cFactor(Expr1) factorise Expr1 dans C en fonction de toutes ses
variables et sur un dénominateur commun.
La factorisation de Expr1 décompose l'expression en autant de
facteurs rationnels linéaires que possible même si cela introduit de
nouveaux nombres non réels. Cette alternative peut s'avérer utile
pour factoriser l'expression en fonction de plusieurs variables.
cFactor(Expr1,Var) factorise Expr1 dans C en fonction de la variable
Var.
La factorisation de Expr1 décompose l'expression en autant de
facteurs possible qui sont linéaires dans Var, avec peut-être des
constantes non réelles, même si cela introduit des constantes
irrationnelles ou des sous-expressions qui sont irrationnelles dans
d'autres variables.
Les facteurs et leurs termes sont triés, Var étant la variable principale.
Les mêmes puissances de Var sont regroupées dans chaque facteur.
Incluez Var si la factorisation ne doit s'effectuer que par rapport à
cette variable et si vous acceptez les expressions irrationnelles dans
les autres variables pour augmenter la factorisation par rapport à Var.
Une factorisation incidente peut se produire par rapport aux autres
variables.
Avec le réglage Auto du mode Auto ou Approché
(Approximate) l'utilisation de Var permet également une
approximation avec des coefficients en virgule flottante dans le cadre
de laquelle les coefficients irrationnels ne peuvent pas être exprimés
explicitement suivant les termes des fonctions intégrées. Même en
présence d'une seule variable, l'utilisation de Var peut contribuer à
une factorisation plus complète.
Remarque : voir aussi factor().
Pour afficher le résultat entier, appuyez sur
touches
16
Guide de référence TI-Nspire™ CAS
¡ et ¢ pour déplacer le curseur.
£, puis utilisez les
char()
char(Entier)
Catalogue >
⇒ caractère
Donne le caractère dont le code dans le jeu de caractères de l'unité
nomade est Entier. La plage valide pour Entier est comprise entre 0
et 65535.
charPoly()
Catalogue >
⇒ expression polynomiale
charPoly(matriceCarrée,Expr) ⇒ expression polynomiale
charPoly(matriceCarrée1,matriceCarrée2) ⇒ expression
charPoly(matriceCarrée,Var)
polynomiale
Donne le polynôme caractéristique de matriceCarrée. Le polynôme
caractéristique d'une matrice n×n A, désigné par pA(l), est le
polynôme défini par
pA(l) = det(l• I NA)
où I désigne la matrice identité n×n.
matriceCarrée1 et matriceCarrée2 doivent avoir les mêmes
dimensions.
c22way
Catalogue >
c22way MatriceObservée
chi22way MatriceObservée
Effectue un test c2 d'association sur le tableau 2*2 de valeurs dans la
matrice observée MatriceObservée. Un récapitulatif du résultat est
stocké dans la variable stat.results. (Voir page 121.)
Pour plus d'informations concernant les éléments vides dans une
matrice, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
stat.c
2
Description
Stats Khi2 : sum(observée - attendue)2/attendue
stat.PVal
Plus petit seuil de signification permettant de rejeter l'hypothèse nulle
stat.df
Degré de liberté des statistiques khi2
stat.ExpMat
Matrice du tableau de valeurs élémentaires attendues, acceptant l'hypothèse nulle
stat.CompMat
Matrice des contributions statistiques khi2 élémentaires
Guide de référence TI-Nspire™ CAS
17
c2Cdf()
Catalogue >
Cdf(lowBound,upBound,dl) ⇒ nombre si les bornes
lowBound et upBound sont des nombres, liste si les bornes
lowBound et upBound sont des listes
chi2Cdf(lowBound,upBound,dl) ⇒ nombre si les bornes
lowBound et upBound sont des nombres, liste si les bornes
lowBound et upBound sont des listes
c
2
Calcule la probabilité qu'une variable suivant une loi c2 à dl degrés
de liberté prenne une valeur entre les bornes lowBound et upBound.
Pour P(X { upBound), définissez la borne lowBound=0.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
c2GOF
Catalogue >
c2GOF ListeObservée,ListeAttendue,df
chi2GOF ListeObservée,ListeAttendue,df
Effectue un test pour s'assurer que les données des échantillons sont
issues d'une population conforme à la loi spécifiée. ListeObservée
est une liste de comptage qui doit contenir des entiers.
Un récapitulatif du résultat est stocké dans la variable stat.results.
(Voir page 121.)
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.c2
Stats Khi2 : sum(observée - attendue)2/attendue
stat.PVal
Plus petit seuil de signification permettant de rejeter l'hypothèse nulle
stat.df
Degré de liberté des statistiques khi2
stat.CompList
Contributions statistiques khi2 élémentaires
c2Pdf()
c2Pdf(ValX,dl) ⇒ nombre si ValX est un nombre, liste si XVal
est une liste
chi2Pdf(ValX,dl) ⇒ nombre si ValX est un nombre, liste si
ValX est une liste
Calcule la probabilité qu'une variable suivant une loi c2 à dl degrés
de liberté prenne une valeur ValX spécifiée.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
18
Guide de référence TI-Nspire™ CAS
Catalogue >
ClearAZ
Catalogue >
ClearAZ
Supprime toutes les variables à une lettre de l'activité courante.
Si une ou plusieurs variables sont verrouillées, cette commande
affiche un message d'erreur et ne supprime que les variables non
verrouillées. Voir unLock, page 136.
ClrErr
Catalogue >
ClrErr
Efface le statut d'erreur et règle la variable système errCode sur zéro.
Pour obtenir un exemple de ClrErr, reportez-vous à l'exemple 2
de la commande Try, page 131.
L'instruction Else du bloc Try...Else...EndTry doit utiliser EffErr ou
PassErr. Si vous comptez rectifier ou ignorer l'erreur, sélectionnez
EffErr. Si vous ne savez pas comment traiter l'erreur, sélectionnez
PassErr pour la transférer au traitement d'erreurs suivant. S'il n'y a
plus d'autre traitement d'erreurs Try...Else...EndTry, la boîte de
dialogue Erreur s'affiche normalement.
Remarque : voir également PassErr, page 89 et Try, page 131.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
définitions sur plusieurs lignes en appuyant sur @ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
colAugment()
Catalogue >
colAugment(Matrice1, Matrice2)
⇒ matrice
Donne une nouvelle matrice obtenue en ajoutant les lignes/colonnes
de la Matrice2 à celles de la Matrice1. Les matrices doivent avoir le
même nombre de colonnes et Matrice2 est ajoutée à Matrice1 via la
création de nouvelles lignes. Matrice1 et Matrice2 ne sont pas
modifiées.
colDim()
colDim(Matrice)
Catalogue >
⇒ expression
Donne le nombre de colonnes de la matrice Matrice.
Remarque : voir aussi rowDim().
colNorm()
colNorm(Matrice)
Catalogue >
⇒ expression
Donne le maximum des sommes des valeurs absolues des éléments
situés dans chaque colonne de la matrice Matrice.
Remarque : les éléments non définis de matrice ne sont pas
autorisés. Voir aussi rowNorm().
Guide de référence TI-Nspire™ CAS
19
comDenom()
comDenom(Expr1[,Var]) ⇒ expression
comDenom(Liste1[,Var]) ⇒ liste
comDenom(Matrice1[,Var]) ⇒ matrice
comDenom(Expr1) donne le rapport réduit d'un numérateur
entièrement développé sur un dénominateur entièrement
développement.
comDenom(Expr1,Var) donne le rapport réduit d'un numérateur et
d'un dénominateur développé par rapport à Var. Les termes et leurs
facteurs sont triés, Var étant la variable principale. Les mêmes
puissances de Var sont regroupées. Une factorisation incidente des
coefficients regroupés peut se produire. L'utilisation de Var permet de
gagner du temps, de la mémoire et de l'espace sur l'écran tout en
facilitant la lecture de l'expression. Les opérations suivantes basées
sur le résultat obtenu sont également plus rapides et moins
consommatrices de mémoire.
Si Var n'intervient pas dans Expr1, comDenom(Expr1,Var) donne le
rapport réduit d'un numérateur non développé sur un dénominateur
non développé. Ce type de résultat offre généralement un gain de
temps, de mémoire et d'espace sur l'écran. La factorisation partielle
du résultat contribue également à accélérer les opérations suivantes
basées sur le résultat et à utiliser moins de mémoire.
Même en l'absence de tout dénominateur, la fonction comden
permet d'obtenir rapidement une factorisation partielle si la fonction
factor() est trop lente ou si elle utilise trop de mémoire.
Conseil : entrez cette définition de la fonction comden() et utilisezla régulièrement comme solution alternative à comDenom() et à
factor().
20
Guide de référence TI-Nspire™ CAS
Catalogue >
completeSquare()
completeSquare(ExprOuÉqn, Var)
Catalogue >
⇒
expression ou équation
completeSquare(ExprOuÉqn, Var^Puissance)
équation
completeSquare(ExprOuÉqn, Var1, Var2 [,...])
équation
⇒
⇒
completeSquare(ExprOuÉqn, Var1, Var2 [,...])
ou équation
expression ou
expression ou
⇒
expression
Convertit une expression polynomiale du second degré de type
a·x2+b·x+c en a·(x-h)2+k.
- ou Convertit une équation du second degré de type x2+b·x+c=d en a·(xh)2=k.
Le premier argument doit être une expression ou une équation du
second degré en notation standard par rapport au deuxième
argument.
Le deuxième argument doit être un terme à une seule variable ou un
terme à une seule variable élevé à une puissance rationnelle (par
exemple x, y2 ou z(1/3).
Le troisième et le quatrième tentent de compléter le carré en fonction
des variables Var1, Var2 [,… ]).
conj()
Catalogue >
conj(Expr1) ⇒ expression
conj(Liste1) ⇒ liste
conj(Matrice1) ⇒ matrice
Donne le conjugué de l'argument.
Remarque : toutes les variables non affectées sont considérées
comme réelles.
constructMat()
Catalogue >
constructMat(Expr,Var1,Var2,nbreLignes,nbreColonnes)
⇒ matrice
Donne une matrice basée sur les arguments.
Expr est une expression composée de variables Var1 et Var2. Les
éléments de la matrice résultante sont formés en évaluant Expr pour
chaque valeur incrémentée de Var1 et de Var2.
Var1 est incrémentée automatiquement de 1 à nbreLignes. Dans
chaque ligne, Var2 est incrémentée de 1 à nbreColonnes.
Guide de référence TI-Nspire™ CAS
21
CopyVar
Catalogue >
CopyVar Var1, Var2
CopyVar Var1. , Var2.
CopyVar Var1, Var2 copie la valeur de la variable Var1 dans la
variable Var2 et crée Var2, si nécessaire. La variable Var1 doit avoir
une valeur.
Si Var1 correspond au nom d'une fonction existante définie par
l'utilisateur, copie la définition de cette fonction dans la fonction
Var2. La fonction Var1 doit être définie.
Var1 doit être conforme aux règles de dénomination des variables ou
correspondre à une expression d'indirection correspondant à un nom
de variable conforme à ces règles.
CopyVar Var1. , Var2. copie tous les membres du groupe de
variables Var1. dans le groupe Var2 et crée le groupe Var2. si
nécessaire.
Var1. doit être le nom d'un groupe de variables existant, comme
stat,le résultat nn ou les variables créées à l'aide de la fonction
LibShortcut(). Si Var2. existe déjà, cette commande remplace tous
les membres communs aux deux groupes et ajoute ceux qui n'existent
pas. Si un ou plusieurs membres de Var2. sont verrouillés, tous les
membres de Var2. restent inchangés.
corrMat()
Catalogue >
corrMat(Liste1,Liste2[,…[,Liste20]])
Calcule la matrice de corrélation de la matrice augmentée [Liste1
Liste2 ... List20].
4cos
Catalogue >
Expr 4cos
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>cos.
Exprime Expr en cosinus. Il s'agit d'un opérateur de conversion utilisé
pour l'affichage. Cet opérateur ne peut être utilisé qu'à la fin d'une
ligne.
4cos réduit toutes les puissances modulo
sin(...) 1Ncos(...)^2
de sorte que les puissances de cos(...) restantes ont des exposants
dans (0, 2). Le résultat ne contient donc pas sin(...) si et seulement si
sin(...) dans l'expression donnée s'applique uniquement aux
puissances paires.
Remarque : L'opérateur de conversion n'est pas autorisé en mode
Angle Degré ou Grade. Avant de l'utiliser, assurez-vous d'avoir défini
le mode Angle sur Radian et de l'absence de références explicites à
des angles en degrés ou en grades dans Expr.
22
Guide de référence TI-Nspire™ CAS
cos()
cos(Expr1)
cos(Liste1)
Touche
⇒ expression
⇒ liste
μ
En mode Angle en degrés :
cos(Expr1) calcule le cosinus de l'argument et l'affiche sous forme
d'expression.
cos(Liste1) donne la liste des cosinus des éléments de Liste1.
Remarque : l'argument est interprété comme la mesure d'un angle
en degrés, en grades ou en radians, suivant le mode angulaire en
cours d'utilisation. Vous pouvez utiliser ¡, G ou R pour préciser l'unité
employée temporairement pour le calcul.
En mode Angle en grades :
En mode Angle en radians :
cos(matriceCarrée1)
⇒ matriceCarrée
En mode Angle en radians :
Calcule le cosinus de la matrice matriceCarrée1. Ce calcul est
différent du calcul du cosinus de chaque élément.
Si une fonction scalaire f(A) opère sur matriceCarrée1 (A), le résultat
est calculé par l'algorithme suivant :
Calcul des valeurs propres (li) et des vecteurs propres (Vi) de A.
matriceCarrée1 doit être diagonalisable et ne peut pas présenter de
variables symboliques sans valeur affectée.
Formation des matrices :
Alors A = X B X/et f(A) = X f(B) X/. Par exemple, cos(A) = X cos(B)
X/ où :
cos (B) =
Tous les calculs sont exécutés en virgule flottante.
Guide de référence TI-Nspire™ CAS
23
cos /()
Touche
⇒ expression
cos/(Liste1) ⇒ liste
cos/(Expr1)
En mode Angle en degrés :
cos/(Expr1) donne l'arc cosinus de Expr1 et l'affiche sous forme
d'expression.
En mode Angle en grades :
μ
cos/(Liste1) donne la liste des arcs cosinus de chaque élément de
Liste1.
Remarque : donne le résultat en degrés, en grades ou en radians,
suivant le mode angulaire utilisé.
En mode Angle en radians :
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant arccos(...).
cos/(matriceCarrée1)
⇒ matriceCarrée
Donne l'arc cosinus de matriceCarrée1. Ce calcul est différent du
calcul de l'arc cosinus de chaque élément. Pour plus d'informations
sur la méthode de calcul, reportez-vous à cos().
En mode Angle en radians et en mode Format complexe
Rectangulaire :
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
Pour afficher le résultat entier, appuyez sur
touches
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
cosh()
Catalogue >
cosh(Expr1)
cosh(Liste1)
⇒ expression
⇒ liste
cosh(Expr1) donne le cosinus hyperbolique de l'argument et l'affiche
sous forme d'expression.
cosh(Liste1) donne la liste des cosinus hyperboliques de chaque
élément de Liste1.
cosh(matriceCarrée1)
⇒ matriceCarrée
En mode Angle en radians :
Donne le cosinus hyperbolique de la matrice matriceCarrée1. Ce
calcul est différent du calcul du cosinus hyperbolique de chaque
élément. Pour plus d'informations sur la méthode de calcul, reportezvous à cos().
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
cosh /()
⇒ expression
cosh/(List1) ⇒ liste
cosh/(Expr1)
cosh/(Expr1) donne l'argument cosinus hyperbolique de l'argument
et l'affiche sous forme d'expression.
/cosh/(Liste1) donne la liste des arguments cosinus hyperboliques
de chaque élément de Liste1.
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant arccosh(...).
24
Guide de référence TI-Nspire™ CAS
Catalogue >
cosh /()
Catalogue >
cosh/(matriceCarrée1)
⇒ matriceCarrée
Donne l'argument cosinus hyperbolique de la matrice
matriceCarrée1. Ce calcul est différent du calcul de l'argument
cosinus hyperbolique de chaque élément. Pour plus d'informations
sur la méthode de calcul, reportez-vous à cos().
En mode Angle en radians et en mode Format complexe
Rectangulaire :
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
Pour afficher le résultat entier, appuyez sur
touches
cot()
cot(Expr1)
cot(Liste1)
⇒ expression
⇒ liste
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
Touche
μ
Touche
μ
En mode Angle en degrés :
Affiche la cotangente de Expr1 ou retourne la liste des cotangentes
des éléments de Liste1.
En mode Angle en grades :
Remarque : l'argument est interprété comme la mesure d'un angle
en degrés, en grades ou en radians, suivant le mode angulaire en
cours d'utilisation. Vous pouvez utiliser ¡, G ou R pour préciser l'unité
employée temporairement pour le calcul.
En mode Angle en radians :
cot /()
cot/(Expr1)
cot/(Liste1)
⇒ expression
⇒ liste
En mode Angle en degrés :
Donne l'arc cotangente de Expr1 ou affiche une liste comportant les
arcs cotangentes de chaque élément de Liste1.
En mode Angle en grades :
Remarque : donne le résultat en degrés, en grades ou en radians,
suivant le mode angulaire utilisé.
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant arccot(...).
coth()
coth(Expr1)
coth(Liste1)
En mode Angle en radians :
Catalogue >
⇒ expression
⇒ liste
Affiche la cotangente hyperbolique de Expr1 ou donne la liste des
cotangentes hyperboliques des éléments de Liste1.
Guide de référence TI-Nspire™ CAS
25
coth/()
coth/(Expr1)
coth/(Liste1)
Catalogue >
⇒ expression
⇒ liste
Affiche l'argument cotangente hyperbolique de Expr1 ou donne la
liste comportant les arguments cotangentes hyperboliques des
éléments de Liste1.
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant arccoth(...).
count()
Catalogue >
count(Valeur1ouListe1 [,Valeur2ouListe2[,...]])
⇒ valeur
Affiche le nombre total des éléments dans les arguments qui
s'évaluent à des valeurs numériques.
Un argument peut être une expression, une valeur, une liste ou une
matrice. Vous pouvez mélanger les types de données et utiliser des
arguments de dimensions différentes.
Pour une liste, une matrice ou une plage de cellules, chaque élément
est évalué afin de déterminer s'il doit être inclus dans le comptage.
Dans l'application Tableur & listes, vous pouvez utiliser une plage de
cellules à la place de n'importe quel argument.
Les éléments vides sont ignorés. Pour plus d'informations concernant Dans le dernier exemple, seuls 1/2 et 3+4*i sont comptabilisés.
Les autres arguments, dans la mesure où x est indéfini, ne
les éléments vides, reportez-vous à la page 164.
correspondent pas à des valeurs numériques.
countif()
countif(Liste,Critère)
Catalogue >
⇒ valeur
Affiche le nombre total d'éléments dans Liste qui répondent au
critère spécifié.
Compte le nombre d'éléments égaux à 3.
Le critère peut être :
•
•
Une valeur, une expression ou une chaîne. Par exemple, 3 compte
uniquement les éléments dans Liste qui ont pour valeur 3.
Compte le nombre d'éléments égaux à “def.”
Une expression booléenne contenant le symbole ? comme
paramètre substituable à tout élément. Par exemple, ?<5 ne
compte que les éléments dans Liste qui sont inférieurs à 5.
Dans l'application Tableur & listes, vous pouvez utiliser une plage de
cellules à la place de Liste.
Compte le nombre d'éléments égaux à x ; cet exemple part du
principe que la variable x est indéfinie.
Les éléments vides de la liste sont ignorés. Pour plus d'informations
concernant les éléments vides, reportez-vous à la page 164.
Remarque : voir également sumIf(), page 124 et frequency(),
page 52.
Compte 1 et 3.
Compte 3, 5 et 7.
Compte 1, 3, 7 et 9.
26
Guide de référence TI-Nspire™ CAS
cPolyRoots()
Catalogue >
⇒ liste
cPolyRoots(ListeCoeff) ⇒ liste
cPolyRoots(Poly,Var)
La première syntaxe, cPolyRoots(Poly,Var), affiche une liste de
racines complexes du polynôme Poly pour la variable Var.
Poly doit être un polynôme d'une seule variable.
La deuxième syntaxe, cPolyRoots(ListeCoeff), affiche une liste des
racines complexes pour les coefficients de la liste ListeCoeff.
Remarque : voir aussi polyRoots(), page 93.
crossP()
Catalogue >
crossP(Liste1, Liste2)
⇒ liste
Donne le produit vectoriel de Liste1 et de Liste2 et l'affiche sous
forme de liste.
Liste1 et Liste2 doivent être de même dimension et cette dimension
doit être égale à 2 ou 3.
crossP(Vecteur1, Vecteur2)
⇒ vecteur
Donne le vecteur ligne ou le vecteur colonne (en fonction des
arguments) obtenu en calculant le produit vectoriel de Vecteur1 et
Vecteur2.
Ces deux vecteurs, Vecteur1 et Vecteur2, doivent être de même type
(ligne ou colonne) et de même dimension, cette dimension devant
être égale à 2 ou 3.
csc()
csc(Expr1)
csc(Liste1)
Touche
⇒ expression
⇒ liste
μ
En mode Angle en degrés :
Affiche la cosécante de Expr1 ou donne une liste comportant les
cosécantes de tous les éléments de Liste1.
En mode Angle en grades :
En mode Angle en radians :
Guide de référence TI-Nspire™ CAS
27
csc/()
Touche
csc /(Expr1)
csc /(Liste1)
⇒ expression
⇒ liste
Affiche l'angle dont la cosécante correspond à Expr1 ou donne la
liste des arcs cosécante de chaque élément de Liste1.
En mode Angle en degrés :
En mode Angle en grades :
Remarque : donne le résultat en degrés, en grades ou en radians,
suivant le mode angulaire utilisé.
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant arccsc(...).
csch()
En mode Angle en radians :
Catalogue >
csch(Expr1)
csch(Liste1)
⇒ expression
⇒ liste
Affiche la cosécante hyperbolique de Expr1 ou donne la liste des
cosécantes hyperboliques de tous les éléments de Liste1.
csch/()
csch/(Expr1)
csch/(Liste1)
Catalogue >
⇒ expression
⇒ liste
Affiche l'argument cosécante hyperbolique de Expr1 ou donne la
liste des arguments cosécantes hyperboliques de tous les éléments de
Liste1.
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant arccsch(...).
cSolve()
⇒ Expression booléenne
cSolve(Équation, Var=Init) ⇒ expression booléenne
cSolve(Inéquation, Var) ⇒ Expression booléenne
cSolve(Équation, Var)
Résout dans C une équation ou une inéquation pour Var. L'objectif
est de trouver toutes les solutions réelles et non réelles possibles.
Même si Équation est à coefficients réels, cSolve() autorise les
résultats non réels en mode Format complexe : Réel.
Bien que toutes les variables non affectées dont le nom ne se termine
pas par (_) soient considérées comme réelles, cSolve() permet de
résoudre des systèmes d'équations polynomiales en utilisant des
solutions complexes.
cSolve() définit temporairement le domaine sur complexe pendant la
résolution, même si le domaine courant est réel. Dans le domaine
complexe, les puissances fractionnaires possédant un dénominateur
impair utilisent la branche principale plutôt que la branche réelle. Par
conséquent, les solutions de solve() pour les équations impliquant de
telles puissances fractionnaires n'appartiennent pas nécessairement à
un sous-ensemble de celles de cSolve().
28
Guide de référence TI-Nspire™ CAS
Catalogue >
μ
cSolve()
Catalogue >
cSolve() commence la résolution en utilisant les méthodes
symboliques exactes. Excepté en mode Exact, cSolve() utilise aussi
En mode Afficher chiffres, Fixe 2 :
une factorisation itérative approchée des polynômes complexes, si
nécessaire.
Remarque : voir aussi cZeros(), solve() et zeros().
Remarque : si Équation n'est pas polynomiale avec les fonctions
comme abs(), angle(), conj(), real() ou imag(), ajoutez un caractère
/_
) à la fin de Var. Par
de soulignement (en appuyant sur
défaut, les variables sont considérées comme réelles.
Pour afficher le résultat entier, appuyez sur
touches
Si vous utilisez var_, la variable est considérée comme complexe.
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
z est considéré comme réel :
Vous pouvez également utiliser var_ pour toutes les autres variables
de Équation pouvant avoir des valeurs non réelles. Sinon, vous
risquez d'obtenir des solutions inattendues.
z_ est considéré comme complexe :
cSolve(Équation1 and Équation2 [and
…],
VarOuInit1, VarOuInit2 [, … ]) ⇒ expression booléenne
cSolve(SystèmeÉqu, VarOuInit1,
VarOuInit2 [, …]) ⇒ expression booléenne
Donne les solutions complexes possibles d'un système d'équations
algébriques, où chaque VarOuInit définit une variable dont vous
cherchez la valeur.
Vous pouvez également spécifier une condition initiale pour les
variables. Chaque VarOuInit doit utiliser le format suivant :
variable
– ou –
variable = nombre réel ou non réel
Par exemple, x est autorisé, de même que x=3+i.
Si toutes les équations sont polynomiales et si vous NE spécifiez PAS Remarque : les exemples suivants utilisent un caractère de
de condition initiale, cSolve() utilise la méthode d'élimination lexicale soulignement (obtenu en appuyant sur
) pour que
Gröbner/Buchberger pour tenter de trouver toutes les solutions
toutes les variables soient considérées comme complexes.
complexes.
/_
Les solutions complexes peuvent combiner des solutions réelles et des
solutions non réelles, comme illustré dans l'exemple ci-contre.
Pour afficher le résultat entier, appuyez sur
touches
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
Les systèmes d'équations polynomiales peuvent comporter des
variables supplémentaires auxquelles aucune valeur n'est affectée,
mais qui représentent des valeurs numériques données pouvant s'y
substituer par la suite.
Pour afficher le résultat entier, appuyez sur
touches
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
Guide de référence TI-Nspire™ CAS
29
cSolve()
Catalogue >
Vous pouvez également utiliser des variables qui n'apparaissent pas
dans les équations. Ces solutions montrent comment des solutions
peuvent dépendre de paramètres arbitraires de type ck, où k est un
suffixe entier compris entre 1 et 255.
Pour les systèmes d'équations polynomiales, le temps de calcul et
l'utilisation de la mémoire peuvent considérablement varier en
Pour afficher le résultat entier, appuyez sur
fonction de l'ordre dans lequel les variables inconnues sont spécifiées.
touches et pour déplacer le curseur.
Si votre choix initial ne vous satisfait pas pour ces raisons, vous
pouvez modifier l'ordre des variables dans les équations et/ou la liste
des variables VarOuInit.
£, puis utilisez les
¡ ¢
Si vous choisissez de ne pas spécifier de condition et s'il l'une des
équations n'est pas polynomiale en l'une des variables, mais que
toutes les équations sont linéaires par rapport à toutes les variables
de solution inconnues, cSolve() utilise l'élimination gaussienne pour
tenter de trouver toutes les solutions.
Si un système d'équations n'est pas polynomial par rapport à toutes
ses variables ni linéaire par rapport aux inconnues, cSolve() cherche
au moins une solution en utilisant la méthode itérative approchée.
Pour cela, le nombre d'inconnues doit être égal au nombre
d'équations et toutes les autres variables contenues dans les
équations doivent pouvoir être évaluées à des nombres.
Une condition non réelle est souvent nécessaire pour la détermination
d'une solution non réelle. Pour assurer une convergence correcte, la
valeur utilisée doit être relativement proche de la solution.
Pour afficher le résultat entier, appuyez sur
touches
CubicReg
Catalogue >
CubicReg X, Y[, [Fréq] [, Catégorie, Inclure]]
Effectue l'ajustement polynomial de degré 3 y = a·x3+b·
x2+c·x+d sur les listes X et Y en utilisant la fréquence Fréq.
Un récapitulatif du résultat est stocké dans la variable stat.results.
(Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes, à
l'exception de Inclure.
X et Y sont des listes de variables indépendantes et dépendantes.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque couple X et Y. Par défaut, cette valeur est égale à 1.
Tous les éléments doivent être des entiers | 0.
Catégorie est une liste de codes de catégories pour les couples X et Y
correspondants.
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : a·x3+b·x2+c·x+d
stat.a, stat.b, stat.c,
stat.d
Coefficients d'ajustement
30
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
Guide de référence TI-Nspire™ CAS
Variable de sortie
Description
stat.R2
Coefficient de détermination
stat.Resid
Valeurs résiduelles de l'ajustement
stat.XReg
Liste des points de données de la liste Liste X modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.YReg
Liste des points de données de la liste Liste Y modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.FreqReg
Liste des fréquences correspondant à stat.XReg et stat.YReg
cumulativeSum()
cumulativeSum(Liste1)
Catalogue >
⇒ liste
Donne la liste des sommes cumulées des éléments de Liste1, en
commençant par le premier élément (élément 1).
cumulativeSum(Matrice1)
⇒ matrice
Donne la matrice des sommes cumulées des éléments de Matrice1.
Chaque élément correspond à la somme cumulée de tous les
éléments situés au-dessus, dans la colonne correspondante.
Un élément vide de Liste1 ou Matrice1 génère un élement vide dans
la liste ou la matrice résultante. Pour plus d'informations concernant
les éléments vides, reportez-vous à la page 164
Cycle
Catalogue >
Cycle
Procède au passage immédiat à l'itération suivante de la boucle
courante (For, While ou Loop).
Liste de fonctions qui additionne les entiers compris entre 1 et
100, en sautant 50.
La fonction Cycle ne peut pas s'utiliser indépendamment de l'une
des trois structures de boucle (For, While ou Loop).
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
définitions sur plusieurs lignes en appuyant sur @ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
4Cylind
Catalogue >
Vecteur 4Cylind
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>Cylind.
Affiche le vecteur ligne ou colonne en coordonnées cylindriques
[r,±q, z].
Vecteur doit être un vecteur à trois éléments. Il peut s'agir d'un
vecteur ligne ou colonne.
Guide de référence TI-Nspire™ CAS
31
cZeros()
cZeros(Expr, Var)
Catalogue >
⇒ liste
En mode Afficher chiffres, Fixe 3 :
Donne la liste des valeurs réelles et non réelles possibles de Var qui
annulent Expr. Pour y parvenir, cZeros() calcule
exp4list(cSolve(Expr=0,Var),Var). Pour le reste, cZeros() est
comparable à zeros().
Remarque : voir aussi cSolve(), solve() et zeros().
Pour afficher le résultat entier, appuyez sur
touches
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
Remarque : si Expr n'est pas polynomiale par rapport aux
z est considéré comme réel :
fonctions comme abs(), angle(), conj(), real() ou imag(), vous
pouvez utiliser un caractère de soulignement (obtenu en appuyant sur
/_
) à la fin du nom de Var. Par défaut, les variables sont
considérées comme réelles. Si vous utilisez var_, la variable est
considérée comme complexe.
z_ est considéré comme complexe :
Vous pouvez également utiliser var_ pour les autres variables de
Expr pouvant avoir des valeurs non réelles. Sinon, vous risquez
d'obtenir des solutions inattendues.
cZeros({Expr1, Expr2 [, … ] },
{VarOuInit1,VarOuInit2 [, … ] })
⇒ matrice
Donne les valeurs possibles auxquelles les expressions s'annulent
simultanément. Chaque VarOuInit définit une inconnue dont vous
recherchez la valeur.
Vous pouvez également spécifier une condition initiale pour les
variables. Chaque VarOuInit doit utiliser le format suivant :
variable
– ou –
variable = nombre réel ou non réel
Par exemple, x est autorisé, de même que x=3+i.
Si toutes les expressions sont polynomiales et si vous NE spécifiez
PAS de condition initiale, cZeros() utilise la méthode d'élimination
lexicale Gröbner/Buchberger pour tenter de trouver tous les zéros
complexes.
Remarque : les exemples suivants utilisent un _ (obtenu en
/_
) pour que toutes les variables soient
appuyant sur
considérées comme complexes.
Les zéros complexes peuvent combiner des zéros réels et des zéros
non réels, comme illustré dans l'exemple ci-contre.
Chaque ligne de la matrice résultante représente un n_uplet, l'ordre
des composants étant identique à celui de la liste VarOuInit. Pour
extraire une ligne, indexez la matrice par [ligne].
Extraction ligne 2 :
Les systèmes d'équations polynomiales peuvent comporter des
variables supplémentaires auxquelles aucune valeur n'est affectée,
mais qui représentent des valeurs numériques données pouvant s'y
substituer par la suite.
32
Guide de référence TI-Nspire™ CAS
cZeros()
Catalogue >
Vous pouvez également utiliser des inconnues qui n'apparaissent pas
dans les expressions. Ces exemples montrent comment des
ensembles de zéros peuvent dépendre de constantes arbitraires de
type ck, où k est un suffixe entier compris entre 1 et 255.
Pour les systèmes d'équations polynomiales, le temps de calcul et
l'utilisation de la mémoire peuvent considérablement varier en
fonction de l'ordre dans lequel les inconnues sont spécifiées. Si votre
choix initial ne vous satisfait pas pour ces raisons, vous pouvez
modifier l'ordre des variables dans les expressions et/ou la liste
VarOuInit.
Si vous choisissez de ne pas spécifier de condition et s'il l'une des
expressions n'est pas polynomiale en l'une des variables, mais que
toutes les expressions sont linéaires par rapport à toutes les
inconnues, cZeros() utilise l'élimination gaussienne pour tenter de
trouver tous les zéros.
Si un système d'équations n'est pas polynomial en toutes ses
variables ni linéaire par rapport à ses inconnues, cZeros() cherche au
moins un zéro en utilisant une méthode itérative approchée. Pour
cela, le nombre d'inconnues doit être égal au nombre d'expressions et
toutes les autres variables contenues dans les expressions doivent
pouvoir être évaluées à des nombres.
Une condition non réelle est souvent nécessaire pour la détermination
d'un zéro non réel. Pour assurer une convergence correcte, la valeur
utilisée doit être relativement proche d'un zéro.
D
dbd()
dbd(date1,date2)
Catalogue >
⇒ valeur
Calcule le nombre de jours entre date1 et date2 à l'aide de la
méthode de calcul des jours.
date1 et date2 peuvent être des chiffres ou des listes de chiffres
compris dans une plage de dates d'un calendrier normal. Si date1 et
date2 sont toutes deux des listes, elles doivent être de la même
longueur.
date1 et date2 doivent être comprises entre 1950 et 2049.
Vous pouvez saisir les dates à l'un des deux formats. L'emplacement
de la décimale permet de distinguer les deux formats.
MM.JJAA (format communément utilisé aux Etats-Unis)
JJMM.AA (format communément utilisé en Europe)
Guide de référence TI-Nspire™ CAS
33
4DD
Catalogue >
Valeur 4DD ⇒ valeur
Liste1 4DD ⇒ liste
Matrice1 4DD ⇒ matrice
En mode Angle en degrés :
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>DD.
Donne l'équivalent décimal de l'argument exprimé en degrés.
L'argument est un nombre, une liste ou une matrice interprété suivant
le mode Angle utilisé (grades, radians ou degrés).
En mode Angle en grades :
En mode Angle en radians :
4Decimal
Catalogue >
Expr1 4Decimal ⇒ expression
Liste1 4Decimal ⇒ expression
Matrice1 4Decimal ⇒ expression
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>Decimal.
Affiche l'argument sous forme décimale. Cet opérateur ne peut être
utilisé qu'à la fin d'une ligne.
Define
Define Var = Expression
Define Fonction(Param1, Param2, ...) = Expression
Définit la variable Var ou la fonction définie par l'utilisateur
Fonction.
Les paramètres, tels que Param1, sont des paramètres substituables
utilisés pour transmettre les arguments à la fonction. Lors de l'appel
d'une fonction définie par l'utilisateur, des arguments (par exemple,
les valeurs ou variables) qui correspondent aux paramètres doivent
être fournis. La fonction évalue ensuite Expression en utilisant les
arguments fournis.
Var et Fonction ne peuvent pas être le nom d'une variable système
ni celui d'une fonction ou d'une commande prédéfinie.
Remarque : cette utilisation de Define est équivalente à celle de
l'instruction : expression & Fonction(Param1,Param2).
34
Guide de référence TI-Nspire™ CAS
Catalogue >
Define
Catalogue >
Define Fonction(Param1, Param2, ...) = Func
Bloc
EndFunc
Define Programme(Param1, Param2, ...) = Prgm
Bloc
EndPrgm
Dans ce cas, la fonction définie par l'utilisateur ou le programme
permet d'exécuter plusieurs instructions (bloc).
Bloc peut correspondre à une instruction unique ou à une série
d'instructions réparties sur plusieurs lignes. Bloc peut également
contenir des expressions et des instructions (comme If, Then, Else et
For).
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
définitions sur plusieurs lignes en appuyant sur @ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
Remarque : voir aussi Define LibPriv, page 35 et Define LibPub,
page 36.
Define LibPriv
Catalogue >
Define LibPriv Var = Expression
Define LibPriv Fonction(Param1, Param2, ...) = Expression
Define LibPriv Fonction(Param1, Param2, ...) = Func
Bloc
EndFunc
Define LibPriv Programme(Param1, Param2, ...) = Prgm
Bloc
EndPrgm
S'utilise comme Define, mais permet de définir des objets (variables,
fonctions, programmes) dans la bibliothèque privée. Les fonctions et
programmes privés ne s'affichent pas dans le Catalogue.
Remarque : voir aussi Define, page 34 et Define LibPub, page 36.
Guide de référence TI-Nspire™ CAS
35
Define LibPub
Catalogue >
Define LibPub Var = Expression
Define LibPub Fonction(Param1, Param2, ...) = Expression
Define LibPub Fonction(Param1, Param2, ...) = Func
Bloc
EndFunc
Define LibPub Programme(Param1, Param2, ...) = Prgm
Bloc
EndPrgm
S'utilise comme Define, mais permet de définir des objets (variables,
fonctions, programmes) dans la bibliothèque publique. Les fonctions
et programmes publics s'affichent dans le Catalogue après
l'enregistrement et le rafraîchissement de la bibliothèque.
Remarque : voir aussi Define, page 34 et Define LibPriv, page 35.
Voir @List(), page 69.
deltaList()
deltaTmpCnv()
DelVar
Voir @tmpCnv(), page 130.
Catalogue >
DelVar Var1[, Var2] [, Var3] ...
DelVar Var.
Supprime de la mémoire la variable ou le groupe de variables spécifié.
Si une ou plusieurs variables sont verrouillées, cette commande
affiche un message d'erreur et ne supprime que les variables non
verrouillées. Voir unLock, page 136.
DelVar Var. supprime tous les membres du groupe de variables
Var, comme les variables statistiques du groupe stat,le résultat nn
ou les variables créées à l'aide de la fonction LibShortcut(). Le point
(.) dans cette utilisation de la commande DelVar limite la suppression
au groupe de variables ; la variable simple Var n'est pas supprimée.
delVoid()
delVoid(Liste1)
Catalogue >
⇒ liste
Donne une liste contenant les éléments de Liste1 sans les éléments
vides.
Pour plus d'informations concernant les éléments vides, reportez-vous
à la page 164.
derivative()
36
Guide de référence TI-Nspire™ CAS
Voir d(), page 153.
deSolve()
Catalogue >
deSolve(ode1erOu2ndOrdre, Var, VarDép)
⇒ une solution générale
Donne une équation qui définit explicitement ou implicitement la
solution générale de l'équation différentielle du 1er ou du 2ème
ordre. Dans l'équation différentielle :
•
Utilisez uniquement le symbole « prime » (obtenu en appuyant
º
•
) pour indiquer la dérivée première de la fonction
sur
(variable dépendante) par rapport à la variable (variable
indépendante).
Utilisez deux symboles « prime » pour indiquer la dérivée
seconde correspondante.
Le symbole « prime » s'utilise pour les dérivées uniquement dans
deSolve(). Dans tous les autres cas, utilisez d().
La solution générale d'une équation du 1er ordre comporte une
constante arbitraire de type ck, où k est un suffixe entier compris
entre 1 et 255. La solution générale d'une équation de 2ème ordre
contient deux constantes de ce type.
Appliquez solve() à une solution implicite si vous voulez tenter de la
convertir en une ou plusieurs solutions explicites équivalente
déterminées explicitement.
Si vous comparez vos résultats avec ceux de vos manuels de cours ou
ceux obtenus manuellement, sachez que certaines méthodes
introduisent des constantes arbitraires en plusieurs endroits du calcul,
ce qui peut induire des solutions générales différentes.
deSolve(ode1erOrdre and condInit, Var, VarDép)
⇒ une solution particulière
Donne une solution particulière qui satisfait à la fois ode1erOrdre et
condInit. Ceci est généralement plus simple que de déterminer une
solution générale car on substitue les valeurs initiales, calcule la
constante arbitraire, puis substitue cette valeur dans la solution
générale.
codInit est une équation de type :
VarDép (valeurIndépendanteInitiale) = valeurDépendanteInitiale
valeurIndépendanteInitiale et valeurDépendanteInitiale peuvent
être des variables comme x0 et y0 non affectées. La différentiation
implicite peut aider à vérifier les solutions implicites.
deSolve(ode2ndOrdre and condInit1 and condInit2,
Var, VarDép) ⇒ une solution particulière
Donne une solution particulière qui satisfait ode2ndOrdre et qui a
une valeur spécifique de la variable dépendante et sa dérivée
première en un point.
Pour condInit1, utilisez :
VarDép (valeurIndépendanteInitiale) = valeurDépendanteInitiale
Pour condInit2, utilisez :
VarDép (ValeurIndépendanteInitiale) = ValeurInitialeDérivée1
Guide de référence TI-Nspire™ CAS
37
deSolve()
Catalogue >
deSolve(ode2ndOrdre and condBorne1 and
condBorne2, Var, VarDép) ⇒ une solution particulière
Donne une solution particulière qui satisfait ode2ndOrdre et qui a
des valeurs spécifiques en deux points différents.
det()
Catalogue >
det(matriceCarrée[, Tolérance])
⇒ expression
Donne le déterminant de matriceCarrée.
L'argument facultatif Tolérance permet de considérer comme nul tout
élément de la matrice dont la valeur absolue est inférieure à
Tolérance. Cet argument n'est utilisé que si la matrice contient des
nombres en virgule flottante et ne contient pas de variables
symboliques sans valeur affectée. Dans le cas contraire, Tolérance
est ignoré.
•
•
/·
Si vous utilisez
ou définissez le mode Auto ou
Approché sur Approché, les calculs sont effectués en virgule
flottante.
Si Tolérance est omis ou inutilisé, la tolérance par défaut est
calculée comme suit :
5EM14 ·max(dim(matriceCarrée))·
rowNorm(matriceCarrée)
diag()
Catalogue >
diag(Liste) ⇒ matrice
diag(matriceLigne) ⇒ matrice
diag(matriceColonne) ⇒ matrice
Donne une matrice diagonale, ayant sur sa diagonale principale les
éléments de la liste passée en argument.
diag(matriceCarrée)
⇒ matriceLigne
Donne une matrice ligne contenant les éléments de la diagonale
principale de matriceCarrée.
matriceCarrée doit être une matrice carrée.
dim()
Catalogue >
dim(Liste)
⇒ entier
Donne le nombre d'éléments de Liste.
dim(Matrice)
⇒ liste
Donne les dimensions de la matrice sous la forme d'une liste à deux
éléments {lignes, colonnes}.
dim(Chaîne)
⇒ entier
Donne le nombre de caractères contenus dans Chaîne.
38
Guide de référence TI-Nspire™ CAS
Disp
Catalogue >
Disp [exprOuChaîne1] [, exprOuChaîne2] ...
Affiche les arguments dans l'historique de Calculator. Les arguments
apparaissent les uns après les autres, séparés par des espaces fines.
Très utile dans les programmes et fonctions pour l'affichage de
calculs intermédiaires.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
définitions sur plusieurs lignes en appuyant sur @ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
4DMS
Catalogue >
Expr 4DMS
Liste 4DMS
Matrice 4DMS
En mode Angle en degrés :
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>DMS.
Interprète l'argument comme un angle et affiche le nombre DMS
équivalent (DDDDDD¡MM'SS.ss''). Voir ¡, ', '' page 159 pour le
détail du format DMS (degrés, minutes, secondes).
Remarque : 4DMS convertit les radians en degrés lorsque
l'instruction est utilisée en mode radians. Si l'entrée est suivie du
symbole des degrés ¡, aucune conversion n'est effectuée. Vous ne
pouvez utiliser 4DMS qu'à la fin d'une ligne.
Guide de référence TI-Nspire™ CAS
39
dominantTerm()
Catalogue >
dominantTerm(Expr1, Var [, Point])
⇒ expression
dominantTerm(Expr1, Var [, Point]) | Var>Point
⇒ expression
dominantTerm(Expr1, Var [, Point]) | Var<Point
⇒ expression
Donne le terme dominant du développement en série généralisé de
Expr1 au Point. Le terme dominant est celui dont le module croît le
plus rapidement en Var = Point. La puissance de (Var N Point) peut
avoir un exposant négatif et/ou fractionnaire. Le coefficient de cette
puissance peut inclure des logarithmes de (Var N Point) et d'autres
fonctions de Var dominés par toutes les puissances de (Var N Point)
ayant le même signe d'exposant.
La valeur par défaut de Point est 0. Point peut être ˆ ou Nˆ,
auxquels cas le terme dominant est celui qui a l'exposant de Var le
plus grand au lieu de celui qui l'exposant de Var le plus petit.
dominantTerm(…) donne “dominantTerm(…)” s'il ne parvient pas
à déterminer la représentation, comme pour les singularités
essentielles de type sin(1/z) en z=0, eN1/z en z=0 ou ez en z = ˆ ou
Nˆ.
Si la série ou une de ses dérivées présente une discontinuité en Point,
le résultat peut contenir des sous-expressions de type sign(…) ou
abs(…) pour une variable réelle ou (-1)floor(…angle(…)…) pour une
variable complexe, qui se termine par « _ ». Si vous voulez utiliser le
terme dominant uniquement pour des valeurs supérieures ou
inférieures à Point, vous devez ajouter à dominantTerm(...)
l'élément approprié « | Var > Point », « | Var < Point », « | » « Var
| Point » ou « Var { Point » pour obtenir un résultat simplifié.
dominantTerm() est appliqué à chaque élément d'une liste ou
d'une matrice passée en 1er argument.
dominantTerm() est utile pour connaître l'expression la plus simple
correspondant à l'expression asymptotique d'un équivalent d'une
expression quand Var " Point. dominantTerm() peut également
être utilisé lorsqu'il n'est pas évident de déterminer le degré du
premier terme non nul d'une série et que vous ne souhaitez pas tester
les hypothèses de manière interactive ou via une boucle.
Remarque : voir aussi series(), page 110.
dotP()
dotP(Liste1, Liste2)
Catalogue >
⇒ expression
Donne le produit scalaire de deux listes.
dotP(Vecteur1, Vecteur2)
⇒ expression
Donne le produit scalaire de deux vecteurs.
Les deux vecteurs doivent être de même type (ligne ou colonne).
40
Guide de référence TI-Nspire™ CAS
E
e^()
e^(Expr1)
Touche
u
⇒ expression
Donne e élevé à la puissance de Expr1.
Remarque : voir aussi Modèle e Exposant, page 2.
u pour afficher e^( est différente
E du clavier.
Remarque : une pression sur
d'une pression sur le caractère
Vous pouvez entrer un nombre complexe sous la forme polaire rei q.
N'utilisez toutefois cette forme qu'en mode Angle en radians ; elle
provoque une erreur de domaine en mode Angle en degrés ou en
grades.
e^(Liste1)
⇒ liste
Donne une liste constituée des exponentielles des éléments de
Liste1.
e^(matriceCarrée1)
⇒ matriceCarrée
Donne l'exponentielle de matriceCarrée1. Le résultat est différent de
la matrice obtenue en prenant l'exponentielle de chaque élément.
Pour plus d'informations sur la méthode de calcul, reportez-vous à
cos().
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
eff()
eff(tauxNominal,CpY)
Catalogue >
⇒ valeur
Fonction financière permettant de convertir un taux d'intérêt nominal
tauxNominal en un taux annuel effectif, CpY étant le nombre de
périodes de calcul par an.
tauxNominal doit être un nombre réel et CpY doit être un nombre
réel > 0.
Remarque : voir également nom(), page 84.
eigVc()
eigVc(matriceCarrée)
Catalogue >
⇒ matrice
En mode Format complexe Rectangulaire :
Donne une matrice contenant les vecteurs propres d'une
matriceCarrée réelle ou complexe, chaque colonne du résultat
correspond à une valeur propre. Notez qu'il n'y a pas unicité des
vecteurs propres. Ils peuvent être multipliés par n'importe quel
facteur constant. Les vecteurs propres sont normés, ce qui signifie que
si V = [x 1, x 2, …, x n], alors :
x 12 + x 22 + … + x n2 = 1
matriceCarrée est d'abord transformée en une matrice semblable
dont la norme par rapport aux lignes soit le plus proche de celle par
rapport aux colonnes. La matriceCarrée est ensuite réduite à la
forme de Hessenberg supérieure et les vecteurs propres calculés via
une factorisation de Schur.
Pour afficher le résultat entier, appuyez sur
touches
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
Guide de référence TI-Nspire™ CAS
41
eigVl()
eigVl(matriceCarrée)
Catalogue >
⇒ liste
En mode Format complexe Rectangulaire :
Donne la liste des valeurs propres d'une matriceCarrée réelle ou
complexe.
matriceCarrée est d'abord transformée en une matrice semblable
dont la norme par rapport aux lignes soit le plus proche de celle par
rapport aux colonnes. La matriceCarrée est ensuite réduite à la
forme de Hessenberg supérieure et les valeurs propres calculées à
partir de la matrice de Hessenberg supérieure.
Pour afficher le résultat entier, appuyez sur
touches
Else
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
Voir If, page 58.
ElseIf
Catalogue >
If Expr booléenne1 Then
Bloc1
ElseIf Expr booléenne2 Then
Bloc2
©
ElseIf Expr booléenneN Then
BlocN
EndIf
©
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
@ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
définitions sur plusieurs lignes en appuyant sur
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
EndFor
EndFunc
EndIf
Voir For, page 50.
Voir Func, page 53.
Voir If, page 58.
EndLoop
Voir Loop, page 75.
EndPrgm
Voir Prgm, page 94.
EndTry
42
Guide de référence TI-Nspire™ CAS
Voir Try, page 131.
EndWhile
Voir While, page 138.
euler()
Catalogue >
euler(Expr, Var, VarDép, {Var0, MaxVar}, Var0Dép, IncVar
[, IncEuler]) ⇒ matrice
euler(SystèmeExpr, Var, ListeVarDép, {Var0, MaxVar},
ListeVar0Dép, IncVar [, IncEuler]) ⇒ matrice
euler(ListeExpr, Var, ListeVarDép, {Var0, MaxVar},
ListeVar0Dép, IncVar [, IncEuler]) ⇒ matrice
Équation différentielle :
y'=0.001*y*(100-y) et y(0)=10
Utilise la méthode d'Euler pour résoudre le système.
d--------------------depVar
- = Expr(Var, VarDép)
d Var
Pour afficher le résultat en entier, appuyez sur
les touches
£, puis utilisez
¡ et ¢ pour déplacer le curseur.
avec VarDép(Var0)=Var0Dép pour l'intervalle [Var0,MaxVar].
Comparez le résultat ci-dessus avec la solution exacte CAS
Retourne une matrice dont la première ligne définit les valeurs de
sortie de Var et la deuxième ligne la valeur du premier composant de obtenue en utilisant deSolve() et seqGen() :
la solution pour les valeurs correspondantes de Var, etc.
Expr représente la partie droite qui définit l'équation différentielle.
SystèmeExpr correspond aux côtés droits qui définissent le système
des équations différentielles (en fonction de l'ordre des variables
dépendantes de la ListeVarDép).
ListeExpr est la liste des côtés droits qui définissent le système des
équations différentielles (en fonction de l'ordre des variables
dépendantes de la ListeVarDép).
Var est la variable indépendante.
ListeVarDép est la liste des variables dépendantes.
{Var0, MaxVar} est une liste à deux éléments qui indique la fonction à Système d'équations :
intégrer de Var0 à MaxVar.
ListeVar0Dép est la liste des valeurs initiales pour les variables
avec y1(0)=2 et y2(0)=5
dépendantes.
IncVar est un nombre différent de zéro, défini par sign(IncVar) =
sign(MaxVar-Var0) et les solutions sont retournées pour
Var0+i·IncVar pour tout i=0,1,2,… de sorte que Var0+i·IncVar soit
dans [var0,MaxVar] (il est possible qu'il n'existe pas de solution en
MaxVar).
IncEuler est un entier positif (valeur par défaut : 1) qui définit le
nombre d'incréments dans la méthode d'Euler entre deux valeurs de
sortie. La taille d'incrément courante utilisée par la méthode d'Euler
est IncVar àIncEuler.
exact()
Catalogue >
exact( Expr1 [, Tolérance]) ⇒ expression
exact( Liste1 [, Tolérance]) ⇒ liste
exact( Matrice1 [, Tolérance]) ⇒ matrice
Utilise le mode Exact pour donner, si possible, la valeur formelle de
l'argument.
Tolérance fixe la tolérance admise pour cette approximation. Par
défaut, cet argument est égal à 0 (zéro).
Guide de référence TI-Nspire™ CAS
43
Exit
Catalogue >
Liste des fonctions :
Exit
Permet de sortir de la boucle For, While ou Loop courante.
Exit ne peut pas s'utiliser indépendamment de l'une des trois
structures de boucle (For, While ou Loop).
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
@ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
définitions sur plusieurs lignes en appuyant sur
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
4exp
Catalogue >
Expr 4exp
Exprime Expr en base du logarithme népérien e. Il s'agit d'un
opérateur de conversion utilisé pour l'affichage. Cet opérateur ne
peut être utilisé qu'à la fin d'une ligne.
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>exp.
exp()
Touche
exp(Expr1)
⇒ expression
Donne l'exponentielle de Expr1.
Remarque : voir aussi Modèle e Exposant, page 2.
Vous pouvez entrer un nombre complexe sous la forme polaire rei q.
N'utilisez toutefois cette forme qu'en mode Angle en radians ; elle
provoque une erreur de domaine en mode Angle en degrés ou en
grades.
exp(Liste1)
⇒ liste
Donne une liste constituée des exponentielles des éléments Liste1.
exp(matriceCarrée1)
⇒ matriceCarrée
Donne l'exponentielle de matriceCarrée1. Le résultat est différent de
la matrice obtenue en prenant l'exponentielle de chaque élément.
Pour plus d'informations sur la méthode de calcul, reportez-vous à
cos().
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
44
Guide de référence TI-Nspire™ CAS
u
exp4list()
exp4list(Expr,Var)
Catalogue >
⇒ liste
Recherche dans Expr les équations séparées par le mot « or » et
retourne une liste des membres de droite des équations du type
Var=Expr. Cela permet en particulier de récupérer facilement sous
forme de liste les résultats fournis par les fonctions solve(), cSolve(),
fMin() et fMax().
Remarque : exp4list() n'est pas nécessaire avec les fonctions zeros
et cZeros() étant donné que celles-ci donnent directement une liste
de solutions.
vous pouvez insérer cette fonction à partir du clavier de l'ordinateur
en entrant exp@>list(...).
expand()
Catalogue >
⇒ expression
⇒ liste
expand(Matrice1 [,Var]) ⇒ matrice
expand(Expr1 [, Var])
expand(Liste1 [,Var])
expand(Expr1) développe Expr1 en fonction de toutes ses variables.
C'est un développement polynomial pour les expressions
polynomiales et une décomposition en éléments simples pour les
expressions rationnelles.
L'objectif de expand() est de transformer Expr1 en une somme et/ou
une différence de termes simples. Par opposition, l'objectif de
factor() est de transformer Expr1 en un produit et/ou un quotient de
facteurs simples.
expand(Expr1,Var) développe Expr1 en fonction de Var. Les
mêmes puissances de Var sont regroupées. Les termes et leurs
facteurs sont triés, Var étant la variable principale. Une factorisation
ou un développement incident des coefficients regroupés peut se
produire. L'utilisation de Var permet de gagner du temps, de la
mémoire et de l'espace sur l'écran tout en facilitant la lecture de
l'expression.
Même en présence d'une seule variable, l'utilisation de Var peut
contribuer à une factorisation du dénominateur, utilisée pour une
décomposition en éléments simples, plus complète.
Conseil : Pour les expressions rationnelles, propFrac() est une
alternative plus rapide mais moins extrême à expand().
Remarque : voir aussi comDenom() pour un numérateur
développé sur un dénominateur développé.
Guide de référence TI-Nspire™ CAS
45
expand()
Catalogue >
expand(Expr1,[Var]) « distribue » également des logarithmes et des
puissances fractionnaires indépendamment de Var. Pour un plus
grand développement des logarithmes et des puissances
fractionnaires, l'utilisation de contraintes peut s'avérer nécessaire
pour s'assurer que certains facteurs ne sont pas négatifs.
expand(Expr1, [Var]) « distribue » également des valeurs absolues,
sign(), et des exponentielles, indépendamment de Var.
Remarque : voir aussi tExpand() pour le développement contenant
des sommes et des multiples d'angles.
expr()
Catalogue >
expr(Chaîne)
⇒ expression
Convertit la chaîne de caractères contenue dans Chaîne en une
expression. L'expression obtenue est immédiatement évaluée.
ExpReg
Catalogue >
ExpReg X, Y [, [Fréq] [, Catégorie, Inclure]]
Effectue l'ajustement exponentiel y = a·(b)x sur les listes X et Y en
utilisant la fréquence Fréq. Un récapitulatif du résultat est stocké
dans la variable stat.results. (Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes, à
l'exception de Inclure.
X et Y sont des listes de variables indépendantes et dépendantes.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque couple X et Y. Par défaut, cette valeur est égale à 1.
Tous les éléments doivent être des entiers | 0.
Catégorie est une liste de codes de catégories pour les couples X et Y
correspondants.
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : a·(b)x
stat.a, stat.b
Coefficients d'ajustement
46
Guide de référence TI-Nspire™ CAS
Variable de sortie
Description
stat.r2
Coefficient de détermination linéaire pour les données transformées
stat.r
Coefficient de corrélation pour les données transformées (x, ln(y))
stat.Resid
Valeurs résiduelles associées au modèle exponentiel
stat.ResidTrans
Valeurs résiduelles associées à l'ajustement linéaire des données transformées
stat.XReg
Liste des points de données de la liste Liste X modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.YReg
Liste des points de données de la liste Liste Y modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.FreqReg
Liste des fréquences correspondant à stat.XReg et stat.YReg
F
factor()
Catalogue >
⇒ expression
factor(Liste1[,Var]) ⇒ liste
factor(Matrice1[,Var]) ⇒ matrice
factor(Expr1[, Var])
factor(Expr1) factorise Expr1 en fonction de l'ensemble des
variables associées sur un dénominateur commun.
La factorisation Expr1 décompose l'expression en autant de
facteurs rationnels linéaires que possible sans introduire de nouvelles
sous-expressions non réelles. Cette alternative peut s'avérer utile
pour factoriser l'expression en fonction de plusieurs variables.
factor(Expr1,Var) factorise Expr1 en fonction de la variable Var.
La factorisation de Expr1 décompose l'expression en autant de
facteurs réels possible linéaires par rapport à Var, même si cela
introduit des constantes irrationnelles ou des sous-expressions qui
sont irrationnelles dans d'autres variables.
Les facteurs et leurs termes sont triés, Var étant la variable principale.
Les mêmes puissances de Var sont regroupées dans chaque facteur.
Utilisez Var si la factorisation ne doit s'effectuer que par rapport à
cette variable et si vous acceptez les expressions irrationnelles dans
les autres variables pour augmenter la factorisation par rapport à Var.
Une factorisation incidente peut se produire par rapport aux autres
variables.
Avec le réglage Auto du mode Auto ou Approché
(Approximate), l'utilisation de Var permet également une
approximation des coefficients en virgule flottante dans le cas où les
coefficients irrationnels ne peuvent pas être exprimés explicitement
en termes de fonctions usuelles. Même en présence d'une seule
variable, l'utilisation de Var peut contribuer à une factorisation plus
complète.
Remarque : voir aussi comDenom() pour obtenir rapidement une
factorisation partielle si la fonction factor() est trop lente ou si elle
utilise trop de mémoire.
Remarque : voir aussi cFactor() pour une factorisation à
coefficients complexes visant à chercher des facteurs linéaires.
Guide de référence TI-Nspire™ CAS
47
factor()
Catalogue >
factor(nombreRationnel) factorise le nombre rationnel en facteurs
premiers. Pour les nombres composites, le temps de calcul augmente
de façon exponentielle avec le nombre de chiffres du deuxième
facteur le plus grand. Par exemple, la factorisation d'un entier
composé de 30 chiffres peut prendre plus d'une journée et celle d'un
nombre à 100 chiffres, plus d'un siècle.
Pour arrêter un calcul manuellement,
•
•
•
Windows® : maintenez enfoncé la touche F12 et appuyez
plusieurs fois sur Entrée.
Macintosh® : maintenez enfoncé la touche F6 et appuyez
plusieurs fois sur Entrée.
Unité : maintenez enfoncé la touche
plusieurs fois sur
c et appuyez
·.
Si vous souhaitez uniquement déterminer si un nombre est un nombre
premier, utilisez isPrime(). Cette méthode est plus rapide, en
particulier si nombreRationnel n'est pas un nombre premier et si le
deuxième facteur le plus grand comporte plus de cinq chiffres.
FCdf()
Catalog >
FCdf(lowBound,upBound,dfNumér,dfDénom) ⇒ nombre si
lowBound et upBound sont des nombres, liste si lowBound et
upBound sont des listes
FCdf(lowBound,upBound,dfNumér,dfDénom) ⇒ nombre si
lowBound et upBound sont des nombres, liste si lowBound et
upBound sont des listes
Calcule la probabilité qu'une variable suivant une loi de Fischer (F)
prenne une valeur à dfNumér (degrés de liberté) et à dfDénom
(dénominateur) entre lowBound et upBound.
Pour P(X { upBound), définissez la borne lowBound=0.
Fill
Catalogue >
Fill Expr, VarMatrice
⇒ matrice
Remplace chaque élément de la variable VarMatrice par Expr.
VarMatrice doit avoir été définie.
Fill Expr, VarListe
⇒ liste
Remplace chaque élément de la variable VarListe par Expr.
VarListe doit avoir été définie.
48
Guide de référence TI-Nspire™ CAS
FiveNumSummary
Catalogue >
FiveNumSummary X[,[Fréq][,Catégorie,Inclure]]
Donne la version abrégée des statistiques à une variable pour la liste
X. Un récapitulatif du résultat est stocké dans la variable stat.results.
(Voir page 121.)
X est une liste qui contient les données.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque valeur X correspondante. Par défaut, cette valeur est
égale à 1. Tous les éléments doivent être des entiers | 0.
Catégorie est une liste de codes numériques de catégories pour les
valeurs X correspondantes.
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Tout élément vide dans les listes X, Fréq ou Catégorie correspond a
un élément vide dans l'ensemble des listes résultantes. Pour plus
d'informations concernant les éléments vides, reportez-vous à la page
164.
Variable de sortie
Description
stat.MinX
Minimum des valeurs de x
stat.Q1X
1er quartile de x
stat.MedianX
Médiane de x
stat.Q3X
3ème quartile de x
stat.MaxX
Maximum des valeurs de x
floor()
floor(Expr1)
Catalogue >
⇒ entier
Donne le plus grand entier { à l'argument (partie entière). Cette
fonction est comparable à int().
L'argument peut être un nombre réel ou un nombre complexe.
floor(Liste1) ⇒ liste
floor(Matrice1) ⇒ matrice
Donne la liste ou la matrice de la partie entière de chaque élément.
Remarque : voi aussi ceiling() et int().
fMax()
Catalogue >
fMax(Expr, Var) ⇒ Expression booléenne
fMax(Expr, Var,LimitInf)
fMax(Expr, Var,LimitInf,LimitSup)
fMax(Expr, Var) | LimitInf<Var<LimitSup
Donne une expression booléenne spécifiant les valeurs possibles de
Var pour laquelle Expr est à son maximum ou détermine au moins sa
limite supérieure.
Guide de référence TI-Nspire™ CAS
49
fMax()
Catalogue >
Vous pouvez utiliser l'opérateur « | » pour préciser l'intervalle de
recherche et/ou spécifier d'autres contraintes.
Avec le réglage Approché (Approximate) du mode Auto ou
Approché (Approximate), fMax() permet de rechercher de
façon itérative un maximum local approché. C'est souvent plus
rapide, surtout si vous utilisez l'opérateur « | » pour limiter la
recherche à un intervalle relativement réduit qui contient exactement
un maximum local.
Remarque : voir aussi fMin() et max().
fMin()
fMin(Expr, Var)
Catalogue >
⇒ Expression booléenne
fMin(Expr, Var,LimitInf)
fMin(Expr, Var,LimitInf,LimitSup)
fMin(Expr, Var) | LimitInf<Var<LimitSup
Donne une expression booléenne spécifiant les valeurs possibles de
Var pour laquelle Expr est à son minimum ou détermine au moins sa
limite inférieure.
Vous pouvez utiliser l'opérateur « | » pour préciser l'intervalle de
recherche et/ou spécifier d'autres contraintes.
Avec le réglage Approché (Approximate) du mode Auto ou
Approché (Approximate), fMin() permet de rechercher de
façon itérative un minimum local approché. C'est souvent plus rapide,
surtout si vous utilisez l'opérateur « | » pour limiter la recherche à un
intervalle relativement réduit qui contient exactement un minimum
local.
Remarque : voir aussi fMax() et min().
For
Catalogue >
For Var, Début, Fin [, Incrément]
Bloc
EndFor
Exécute de façon itérative les instructions de Bloc pour chaque valeur
de Var, à partir de Début jusqu'à Fin, par incréments équivalents à
Incrément.
Var ne doit pas être une variable système.
Incrément peut être une valeur positive ou négative. La valeur par
défaut est 1.
Bloc peut correspondre à une ou plusieurs instructions, séparées par
un « : ».
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
@ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
définitions sur plusieurs lignes en appuyant sur
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
50
Guide de référence TI-Nspire™ CAS
format()
format(Expr[, chaîneFormat])
Catalogue >
⇒ chaîne
Donne Expr sous la forme d'une chaîne de caractères correspondant
au modèle de format spécifié.
Expr doit avoir une valeur numérique.
chaîneFormat doit être une chaîne du type : « F[n] », « S[n] », « E[n]
», « G[n][c] », où [ ] identifie les parties facultatives.
F[n] : format Fixe. n correspond au nombre de chiffres à afficher après
le séparateur décimal.
S[n] : format Scientifique. n correspond au nombre de chiffres à
afficher après le séparateur décimal.
E[n] : format Ingénieur. n correspond au nombre de chiffres après le
premier chiffre significatif. L'exposant est ramené à un multiple de
trois et le séparateur décimal est décalé vers la droite de zéro, un ou
deux chiffres.
G[n][c] : identique au format Fixe, mais sépare également les chiffres
à gauche de la base par groupes de trois. c spécifie le caractère
séparateur des groupes et a pour valeur par défaut la virgule. Si c est
un point, la base s'affiche sous forme de virgule.
[Rc] : tous les formats ci-dessus peuvent se voir ajouter en suffixe
l'indicateur de base Rc, où c correspond à un caractère unique
spécifiant le caractère à substituer au point de la base.
fPart()
Catalogue >
fPart(Expr1) ⇒ expression
fPart(Liste1) ⇒ liste
fPart(Matrice1) ⇒ matrice
Donne la partie fractionnaire de l'argument.
Dans le cas d'une liste ou d'une matrice, donne les parties
fractionnaires des éléments.
L'argument peut être un nombre réel ou un nombre complexe.
FPdf()
Catalogue >
FPdf(ValX,dfNumér,dfDénom) ⇒ nombre si ValX est un
nombre, liste si ValX est une liste
FPdf(ValX,dfNumér,dfDénom) ⇒ nombre si ValX est un
nombre, liste si ValX est une liste
Calcule la densité de la loi F (Fisher) de degrés de liberté
dfNumér et dfDénom en ValX.
Guide de référence TI-Nspire™ CAS
51
freqTable4list()
Catalogue >
freqTable4list(Liste1, listeEntFréq)
⇒ liste
Donne la liste comprenant les éléments de Liste1 développés en
fonction des fréquences contenues dans listEntFréq. Cette fonction
peut être utilisée pour créer une table de fréquences destinée à être
utilisée avec l'application Données & statistiques.
Liste1 peut être n'importe quel type de liste valide.
listEntFréq doit avoir le même nombre de lignes que Liste1 et
contenir uniquement des éléments entiers non négatifs. Chaque
élément indique la fréquence à laquelle l'élément correspondant de
Liste1 doit être répété dans la liste des résultats. La valeur zéro (0)
exclut l'élément correspond de Liste1.
Remarque : vous pouvez insérer cette fonction à partir du clavier
de l'ordinateur en entrant freqTable@>list(...).
Les éléments vides sont ignorés. Pour plus d'informations concernant
les éléments vides, reportez-vous à la page 164.
frequency()
frequency(Liste1,ListeBinaires)
Catalogue >
⇒ liste
Affiche une liste contenant le nombre total d'éléments dans Liste1.
Les comptages sont effectués à partir de plages (binaires) définies par
l'utilisateur dans listeBinaires.
Si listeBinaires est {b(1), b(2), …, b(n)}, les plages spécifiées sont
{?{b(1), b(1)<?{b(2),…,b(n-1)<?{b(n), b(n)>?}. Le résultat
comporte un élément de plus que listeBinaires.
Chaque élément du résultat correspond au nombre d'éléments dans
Liste1 présents dans la plage. Exprimé en termes de fonction
countIf(), le résultat est { countIf(liste, ?{b(1)), countIf(liste,
b(1)<?{b(2)), …, countIf(liste, b(n-1)<?{b(n)), countIf(liste, b(n)>?)}.
Explication du résultat :
2 éléments de Datalist sont {2,5
4 éléments de Datalist sont >2,5 et {4,5
3 éléments de Datalist sont >4,5
L'élément « hello » est une chaîne et ne peut être placé dans
aucune des plages définies.
Les éléments de Liste1 qui ne sont pas “placés dans une plage” ne
sont pas pris en compte. Les éléments vides sont également ignorés.
Pour plus d'informations concernant les éléments vides, reportezvous à la page 164.
Dans l'application Tableur & listes, vous pouvez utiliser une plage de
cellules à la place des deux arguments.
Remarque : voir également countIf(), page 26.
FTest_2Samp
FTest_2Samp Liste1,Liste2[,Fréq1[,Fréq2[,Hypoth]]]
FTest_2Samp Liste1,Liste2[,Fréq1[,Fréq2[,Hypoth]]]
(Entrée de liste de données)
FTest_2Samp sx1,n1,sx2,n2[,Hypoth]
FTest_2Samp sx1,n1,sx2,n2[,Hypoth]
(Récapitulatif des statistiques fournies en entrée)
Effectue un test F sur deux échantillons. Un récapitulatif du résultat
est stocké dans la variable stat.results. (Voir page 121.)
Pour Ha : s1 > s2, définissez Hypoth>0
Pour Ha : s1 ƒ s2 (par défaut), définissez Hypoth =0
Pour Ha : s1 < s2, définissez Hypoth<0
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
52
Guide de référence TI-Nspire™ CAS
Catalogue >
Variable de sortie
Description
stat.F
Statistique Û estimée pour la séquence de données
stat.PVal
Plus petit seuil de signification permettant de rejeter l'hypothèse nulle
stat.dfNumer
Numérateur degrés de liberté = n1-1
stat.dfDenom
Dénominateur degrés de liberté = n2-1.
stat.sx1, stat.sx2
Écarts types de population d'échantillon des séquences de données dans Liste 1 et Liste 2.
stat.x1_bar
stat.x2_bar
Moyenne de population d'échantillon des séquences de données dans Liste 1 et Liste 2.
stat.n1, stat.n2
Taille des échantillons
Func
Catalogue >
Définition d'une fonction par morceaux :
Func
Bloc
EndFunc
Modèle de création d'une fonction définie par l'utilisateur.
Bloc peut correspondre à une instruction unique ou à une série
d'instructions séparées par le caractère “:” ou à une série
d'instructions réparties sur plusieurs lignes. La fonction peut utiliser
l'instruction Return pour donner un résultat spécifique.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
définitions sur plusieurs lignes en appuyant sur @ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
Résultat de la représentation graphique de g(x)
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
G
gcd()
Catalogue >
gcd(Nombre1, Nombre2)
⇒ expression
Donne le plus grand commun diviseur des deux arguments. Le gcd de
deux fractions correspond au gcd de leur numérateur divisé par le
lcm de leur dénominateur.
En mode Auto ou Approché, le gcd de nombre fractionnaires en
virgule flottante est égal à 1.
gcd(Liste1, Liste2)
⇒ liste
Donne la liste des plus grands communs diviseurs des éléments
correspondants de Liste1 et Liste2.
gcd(Matrice1, Matrice2)
⇒ matrice
Donne la matrice des plus grands communs diviseurs des éléments
correspondants de Matrice1 et Matrice2.
Guide de référence TI-Nspire™ CAS
53
geomCdf()
Catalogue >
geomCdf(p,lowBound,upBound) ⇒ nombre si les bornes
lowBound et upBound sont des nombres, liste si les bornes
lowBound et upBound sont des listes
geomCdf(p,upBound) pour P(1{X{upBound) ⇒ nombre si la
borne upBound est un nombre, liste si la borne upBound est
une liste
Calcule la probabilité qu'une variable suivant la loi géométrique
prenne une valeur entre les bornes lowBound et upBound en
fonction de la probabilité de réussite p spécifiée.
Pour P(X { upBound), définissez lowBound = 1.
geomPdf()
Catalogue >
geomPdf(p,ValX)
ValX est une liste
⇒ nombre si ValX est un nombre, liste si
Calcule la probabilité que le premier succès intervienne au rang ValX,
pour la loi géométrique discrète en fonction de la probabilité de
réussite p spécifiée.
getDenom()
Catalogue >
getDenom(Expr1)
⇒ expression
Transforme l'argument en une expression dotée d'un dénominateur
commun réduit, puis en donne le numérateur.
getLangInfo()
getLangInfo()
⇒ chaîne
Retourne une chaîne qui correspond au nom abrégé de la langue
active. Vous pouvez, par exemple, l'utiliser dans un programme ou
une fonction afin de déterminer la langue courante.
Anglais = « en »
Danois = « da »
Allemand = « de »
Finlandais = « fi »
Français = « fr »
Italien = « it »
Néerlandais = « nl »
Néerlandais belge = « nl_BE »
Norvégien = « no »
Portugais = « pt »
Espagnol = « es »
Suédois = « sv »
54
Guide de référence TI-Nspire™ CAS
Catalogue >
getLockInfo()
getLockInfo(Var)
Catalogue >
⇒ valeur
Donne l'état de verrouillage/déverrouillage de la variable Var.
valeur =0 : Var est déverrouillée ou n'existe pas.
valeur =1 : Var est verrouillée et ne peut être ni modifiée ni
supprimée.
Voir Lock, page 71 et unLock, page 136.
getMode()
Catalogue >
getMode(EntierNomMode)
getMode(0)
⇒ valeur
⇒ liste
getMode(EntierNomMode) affiche une valeur représentant le
réglage actuel du mode EntierNomMode.
getMode(0) affiche une liste contenant des paires de chiffres.
Chaque paire consiste en un entier correspondant au mode et un
entier correspondant au réglage.
Pour obtenir une liste des modes et de leurs réglages, reportez-vous
au tableau ci-dessous.
Si vous enregistrez les réglages avec getMode(0) & var, vous
pouvez utiliser setMode(var) dans une fonction ou un programme
pour restaurer temporairement les réglages au sein de l'exécution de
la fonction ou du programme uniquement. Voir également
setMode(), page 111.
Nom du
mode
Entier
du
mode
Afficher chiffres
1
1=Flottant, 2=Flottant 1, 3=Flottant 2, 4=Flottant 3, 5=Flottant 4, 6=Flottant 5,
7=Flottant 6, 8=Flottant 7, 9=Flottant 8, 10=Flottant 9, 11=Flottant 10, 12=Flottant 11,
13=Flottant 12, 14=Fixe 0, 15=Fixe 1, 16=Fixe 2, 17=Fixe 3, 18=Fixe 4, 19=Fixe 5,
20=Fixe 6, 21=Fixe 7, 22=Fixe 8, 23=Fixe 9, 24=Fixe 10, 25=Fixe 11, 26=Fixe 12
Angle
2
1=Radian, 2=Degré, 3=Grade
Format Exponentiel
3
1=Normal, 2=Scientifique, 3=Ingénieur
Réel ou Complexe
4
1=Réel, 2=Rectangulaire, 3=Polaire
Auto ou Approché
5
1=Auto, 2=Approché, 3=Exact
Entiers de réglage
Format Vecteur
6
1=Rectangulaire, 2=Cylindrique, 3=Sphérique
Base
7
1=Décimale, 2=Hexadécimale, 3=Binaire
Système d'unités
8
1=SI, 2=Ang/US
Guide de référence TI-Nspire™ CAS
55
getNum()
Catalogue >
getNum(Expr1)
⇒ expression
Transforme l'argument en une expression dotée d'un dénominateur
commun réduit, puis en donne le dénominateur.
getType()
Catalogue >
⇒ chaîne de caractères
getType(var)
Retourne une chaîne de caractère qui indique le type de données de
la variable var.
Si var n'a pas été définie, retourne la chaîne "AUCUNE".
getVarInfo()
getVarInfo()
Catalogue >
⇒ matrice ou chaîne
getVarInfo(chaîneNomBibliothèque)
⇒ matrice ou chaîne
getVarInfo() donne une matrice d'informations (nom et type de la
variable, accès à la bibliothèque et état de verrouillage/
déverrouillage) pour toutes les variables et objets de la bibliothèque
définis dans l'activité courante.
Si aucune variable n'est définie, getVarInfo() donne la chaîne
« NONE » (AUCUNE).
getVarInfo(chaîneNomBibliothèque) donne une matrice
d'informations pour tous les objets de bibliothèque définis dans la
bibliothèque chaîneNomBibliothèque. chaîneNomBibliothèque
doit être une chaîne (texte entre guillemets) ou une variable.
Si la bibliothèque chaîneNomBibliothèque n'existe pas, une erreur
est générée.
56
Guide de référence TI-Nspire™ CAS
getVarInfo()
Catalogue >
Observez l'exemple de gauche dans lequel le résultat de getVarInfo()
est affecté à la variable vs. La tentative d'afficher la ligne 2 ou 3 de vs
génère un message d'erreur “Liste ou matrice invalide” car pour au
moins un des éléments de ces lignes (variable b, par exemple)
l'évaluation redonne une matrice.
Cette erreur peut également survenir lors de l'utilisation de Ans pour
réévaluer un résultat de getVarInfo().
Le système génère l'erreur ci-dessus car la version courante du logiciel
ne prend pas en charge les structures de matrice généralisées dans
lesquelles un élément de matrice peut être une matrice ou une liste.
Goto
Catalogue >
Goto nomÉtiquette
Transfère le contrôle du programme à l'étiquette nomÉtiquette.
nomÉtiquette doit être défini dans la même fonction à l'aide de
l'instruction Lbl.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
définitions sur plusieurs lignes en appuyant sur @ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
4Grad
Catalogue >
Expr1 4 Grad ⇒ expression
En mode Angle en degrés :
Convertit Expr1 en une mesure d'angle en grades.
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>Grad.
En mode Angle en radians :
Guide de référence TI-Nspire™ CAS
57
I
identity()
identity(Entier)
Catalogue >
⇒ matrice
Donne la matrice identité (matrice unité) de dimension Entier.
Entier doit être un entier positif.
If
Catalogue >
If Expr booléenne
Instruction
If Expr booléenne Then
Bloc
EndIf
Si Expr booléenne passe le test de condition, exécute l'instruction
Instruction ou le bloc d'instructions Bloc avant de poursuivre
l'exécution de la fonction.
Si Expr booléenne ne passe pas le test de condition, poursuit
l'exécution en ignorant l'instruction ou le bloc d'instructions.
Bloc peut correspondre à une ou plusieurs instructions, séparées par
un « : ».
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
@ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
définitions sur plusieurs lignes en appuyant sur
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
If Expr booléenne Then
Bloc1
Else
Bloc2
EndIf
Si Expr booléenne passe le test de condition, exécute Bloc1 et
ignore Bloc2.
Si Expr booléenne ne passe pas le texte de condition, ignore Bloc1,
mais exécute Bloc2.
Bloc1 et Bloc2 peuvent correspondre à une seule instruction.
58
Guide de référence TI-Nspire™ CAS
If
Catalogue >
If Expr booléenne1 Then
Bloc1
ElseIf Expr booléenne2 Then
Bloc2
©
ElseIf Expr booléenneN Then
BlocN
EndIf
Permet de traiter les conditions multiples. Si Expr booléenne1 passe
le test de condition, exécute Bloc1. Si Expr booléenne1 ne passe pas
le test de condition, calcule Expr booléenne2, et ainsi de suite.
ifFn()
Catalogue >
ifFn(exprBooléenne,Valeur_si_Vrai [,Valeur_si_Faux
[,Valeur_si_Inconnu]]) ⇒ expression, liste ou matrice
Evalue l'expression booléenne exprBooléenne(ou chacun des
éléments de exprBooléenne) et produit un résultat reposant sur les
règles suivantes :
•
•
•
•
•
exprBooléenne peut tester une valeur unique, une liste ou une
matrice.
Si un élément de exprBooléenne est vrai, l'élément
correspondant de Valeur_si_Vrai s'affiche.
Si un élément de exprBooléenne est faux, l'élément
correspondant de Valeur_si_Faux s'affiche. Si vous omettez
Valeur_si_Faux, undef s'affiche.
Si un élément de exprBooléenne n'est ni vrai ni faux, l'élément
correspondant de Valeur_si_Inconnu s'affiche. Si vous omettez
Valeur_si_Inconnu, undef s'affiche.
Si le deuxième, troisième ou quatrième argument de la fonction
ifFn() est une expression unique, le test booléen est appliqué à
toutes les positions dans exprBooléenne.
La valeur d'essai 1 est inférieure à 2,5, ainsi l'élément
correspondant dans
Valeur_si_Vrai (5) est copié dans la liste de résultats.
La valeur d'essai 2 est inférieure à 2,5, ainsi l'élément
correspondant dans
Valeur_si_Vrai(6) est copié dans la liste de résultats.
La valeur d'essai 3 n'est pas inférieure à 2,5, ainsi l'élément
correspondant dans Valeur_si_Faux (10) est copié dans la liste
de résultats.
Valeur_si_Vrai est une valeur unique et correspond à
Remarque : si l'instruction simplifiée exprBooléenne implique une n'importe quelle position sélectionnée.
liste ou une matrice, tous les autres arguments de type liste ou
matrice doivent avoir la ou les même(s) dimension(s) et le résultat
aura la ou les même(s) dimension(s).
Valeur_si_Faux n'est pas spécifié. Undef est utilisé.
Un élément sélectionné à partir de Valeur_si_Vrai. Un élément
sélectionné à partir de Valeur_si_Inconnu.
imag()
imag(Expr1)
Catalogue >
⇒ expression
Donne la partie imaginaire de l'argument.
Remarque : toutes les variables non affectées sont considérées
comme réelles. Voir aussi real(), page 100
Guide de référence TI-Nspire™ CAS
59
imag()
imag(Liste1)
Catalogue >
⇒ liste
Donne la liste des parties imaginaires des éléments.
imag(Matrice1)
⇒ matrice
Donne la matrice des parties imaginaires des éléments.
impDif()
Catalogue >
impDif(Équation, Var, VarDép[,Ordre])
⇒ expression
où la valeur par défaut de l'argument Ordre est 1.
Calcule la dérivée implicite d'une équation dans laquelle une variable
est définie implicitement par rapport à une autre.
Indirection
Voir #(), page 157.
inString()
inString(chaîneSrce, sousChaîne[, Début])
Catalogue >
⇒ entier
Donne le rang du caractère de la chaîne chaîneSrce où commence la
première occurrence de sousChaîne.
Début, s'il est utilisé, indique le point de départ de la recherche dans
chaîneSrce. Par défaut, la recherche commence à partir du premier
caractère de chaîneSrce.
Si chaîneSrce ne contient pas sousChaîne ou si Début est > à la
longueur de ChaîneSrce, on obtient zéro.
int()
Catalogue >
int(Expr) ⇒ entier
int(Liste1) ⇒ liste
int(Matrice1) ⇒ matrice
Donne le plus grand entier inférieur ou égal à l'argument. Cette
fonction est identique à floor() (partie entière).
L'argument peut être un nombre réel ou un nombre complexe.
Dans le cas d'une liste ou d'une matrice, donne la partie entière de
chaque élément.
intDiv()
Catalogue >
intDiv(Nombre1, Nombre2) ⇒ entier
intDiv(Liste1, Liste2) ⇒ liste
intDiv(Matrice1, Matrice2) ⇒ matrice
Donne le quotient dans la division euclidienne de
(Nombre1 ÷ Nombre2).
Dans le cas d'une liste ou d'une matrice, donne le quotient de
(argument 1 ÷ argument 2) pour chaque paire d'éléments.
integral
60
Guide de référence TI-Nspire™ CAS
Voir ‰(), page 153.
interpolate()
interpolate(Valeurx, Listex, Listey, ListePrincy)
Catalogue >
⇒
Équation différentielle :
y'=-3·y+6·t+5 et y(0)=5
liste
Cette fonction effectue l'opération suivante :
Étant donné Listex, Listey=f(Listex) et ListePrincy=f'(Listex) pour
une fonction f inconnue, une interpolation par une spline cubique est
utilisée pour donner une approximation de la fonction f en Valeurx.
On suppose que Listex est une liste croissante ou décroissante de
nombres, cette fonction pouvant retourner une valeur même si ce
Pour afficher le résultat en entier, appuyez sur ,
n'est pas le cas. Elle examine la Listex et recherche un intervalle
puis utilisez les touches et pour déplacer le
[Listex[i], Listex[i+1]] qui contient Valeurx. Si elle trouve cet
curseur.
intervalle, elle retourne une valeur d'interpolation pour f(Valeurx),
sinon elle donne undef.
Utilisez la fonction interpolate() pour calculer les valeurs de la
Listex, Listey, et ListePrincy doivent être de même dimensions | 2 et fonction pour la listevaleursx :
contenir des expressions pouvant être évaluées à des nombres.
£
¡ ¢
Valeurx peut être une variable indéfinie, un nombre ou une liste de
nombres.
invc2()
Catalogue >
invc2(Zone,df)
invChi2(Zone,df)
Calcule l'inverse de la fonction de répartition de la loi c2 (Khi2) de
degré de liberté df en un point donné (Zone).
invF()
Catalogue >
invF(Zone,dfNumer,dfDenom)
invF(Zone,dfNumer,dfDenom)
Calcule l'inverse de la fonction de répartition de la loi F (Fisher) de
paramètres spécifiée par dfNumer et dfDenom en un point donné
(Zone).
invNorm()
Catalogue >
invNorm(Zone[,m[,s]])
Calcule l'inverse de la fonction de répartition de la loi normale de
paramètres mu et sigma (m et s) en un point donné (Zone).
invt()
Catalogue >
invt(Zone,df)
Calcule l'inverse de la fonction de répartition de la loi student-t de
degré de liberté df en un point donné (Zone).
Guide de référence TI-Nspire™ CAS
61
iPart()
Catalogue >
iPart(Nombre) ⇒ entier
iPart(Liste1) ⇒ liste
iPart(Matrice1) ⇒ matrice
Donne l'argument moins sa partie fractionnaire.
Dans le cas d'une liste ou d'une matrice, applique la fonction à
chaque élément.
L'argument peut être un nombre réel ou un nombre complexe.
irr()
Catalogue >
irr(MT0,ListeMT [,FréqMT])
⇒ valeur
Fonction financière permettant de calculer le taux interne de
rentabilité d'un investissement.
MT0 correspond au mouvement de trésorerie initial à l'heure 0 ; il
doit s'agir d'un nombre réel.
Liste MT est une liste des montants de mouvements de trésorerie
après le mouvement de trésorerie initial MT0.
FréqMT est une liste facultative dans laquelle chaque élément
indique la fréquence d'occurrence d'un montant de mouvement de
trésorerie groupé (consécutif), correspondant à l'élément de ListeMT.
La valeur par défaut est 1 ; si vous saisissez des valeurs, elles doivent
être des entiers positifs < 10 000.
Remarque : voir également mirr(), page 79.
isPrime()
isPrime(Nombre)
Catalogue >
⇒ Expression booléenne constante
Donne true ou false selon que nombre est ou n'est pas un entier
naturel premier | 2, divisible uniquement par lui-même et 1.
Si Nombre dépasse 306 chiffres environ et n'a pas de diviseur
inférieur à {1021, isPrime(Nombre) affiche un message d'erreur.
Fonction permettant de trouver le nombre premier suivant un
nombre spécifié :
Si vous souhaitez uniquement déterminer si Nombre est un nombre
premier, utilisez isPrime() et non factor(). Cette méthode est plus
rapide, en particulier si Nombre n'est pas un nombre premier et si le
deuxième facteur le plus grand comporte plus de cinq chiffres.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
@ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
définitions sur plusieurs lignes en appuyant sur
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
isVoid()
isVoid(Var) ⇒ expression booléenne constante
isVoid(Expr) ⇒ expression booléenne constante
isVoid(Liste) ⇒ liste des expressions booléennes constantes
Retourne true ou false pour indiquer si l'argument est un élément de
type données vide.
Pour plus d'informations concernant les éléments vides, reportez-vous
à la page 164.
62
Guide de référence TI-Nspire™ CAS
Catalogue >
L
Lbl
Catalogue >
Lbl nomÉtiquette
Définit une étiquette en lui attribuant le nom nomÉtiquette dans une
fonction.
Vous pouvez utiliser l'instruction Goto nomÉtiquette pour transférer
le contrôle du programme à l'instruction suivant immédiatement
l'étiquette.
nomÉtiquette doit être conforme aux mêmes règles de dénomination
que celles applicables aux noms de variables.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
définitions sur plusieurs lignes en appuyant sur @ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
lcm()
Catalogue >
lcm(Nombre1, Nombre2) ⇒ expression
lcm(Liste1, Liste2) ⇒ liste
lcm(Matrice1, Matrice2) ⇒ matrice
Donne le plus petit commun multiple des deux arguments. Le lcm de
deux fractions correspond au lcm de leur numérateur divisé par le
gcd de leur dénominateur. Le lcm de nombres fractionnaires en
virgule flottante correspond à leur produit.
Pour deux listes ou matrices, donne les plus petits communs multiples
des éléments correspondants.
left()
Catalogue >
left(chaîneSrce[, Nomb])
⇒ chaîne
Donne la chaîne formée par les Nomb premiers caractères de la
chaîne chaîneSrce.
Si Nomb est absent, on obtient chaîneSrce.
left(Liste1[, Nomb])
⇒ liste
Donne la liste formée par les Nomb premiers éléments de Liste1.
Si Nomb est absent, on obtient Liste1.
left(Comparaison)
⇒ expression
Donne le membre de gauche d'une équation ou d'une inéquation.
Guide de référence TI-Nspire™ CAS
63
libShortcut()
libShortcut(chaîneNomBibliothèque, chaîneNomRaccourci
[, LibPrivFlag]) ⇒ liste de variables
Crée un groupe de variables dans l'activité courante qui contient des
références à tous les objets du classeur de bibliothèque spécifié
chaîneNomBibliothèque. Ajoute également les membres du groupe
au menu Variables. Vous pouvez ensuite faire référence à chaque
objet en utilisant la chaîneNomRaccourci correspondante.
Catalogue >
Cet exemple utilise un classeur de bibliothèque enregistré et
rafraîchi linalg2 qui contient les objets définis comme
clearmat, gauss1 et gauss2.
Définissez LibPrivFlag=0 pour exclure des objets de la bibliothèque
privée (par défaut) et
LibPrivFlag=1 pour inclure des objets de bibliothèque privée.
Pour copier un groupe de variables, reportez-vous à CopyVar,
page 22.
Pour supprimer un groupe de variables, reportez-vous à DelVar, page
36.
limit() ou lim()
limit(Expr1, Var, Point [,Direction]) ⇒ expression
limit(Liste1, Var, Point [, Direction]) ⇒ liste
limit(Matrice1, Var, Point [, Direction]) ⇒ matrice
Donne la limite recherchée.
Remarque : voir aussi Modèle Limite, page 5.
Direction : négative=limite à gauche, positive=limite à droite,
sinon=gauche et droite. (Si Direction est absent, la valeur par défaut
est gauche et droite.)
Les limites en +ˆ et en -ˆ sont toujours converties en limites
unilatérales.
Dans certains cas, limit() retourne lui-même ou undef (non défini) si
aucune limite ne peut être déterminée. Cela ne signifie pas pour
autant qu'aucune limite n'existe. undef signifie que le résultat est soit
un nombre inconnu fini ou infini soit l'ensemble complet de ces
nombres.
limit() utilisant des méthodes comme la règle de L’Hôpital, il existe
des limites uniques que cette fonction ne permet pas de déterminer.
Si Expr1 contient des variables non définies autres que Var, il peut
s'avérer nécessaire de les contraindre pour obtenir un résultat plus
précis.
Les limites peuvent être affectées par les erreurs d'arrondi. Dans la
mesure du possible, n'utilisez pas le réglage Approché (Approximate)
du mode Auto ou Approché (Approximate) ni des nombres
approchés lors du calcul de limites. Sinon, les limites normalement
nulles ou infinies risquent de ne pas l'être.
64
Guide de référence TI-Nspire™ CAS
Catalogue >
LinRegBx
Catalogue >
LinRegBx X,Y[,[Fréq][,Catégorie,Inclure]]
Effectue l'ajustement linéaire y = a+b·x sur les listes X et Y en
utilisant la fréquence Fréq. Un récapitulatif du résultat est stocké
dans la variable stat.results. (Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes, à
l'exception de Inclure.
X et Y sont des listes de variables indépendantes et dépendantes.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque couple X et Y. Par défaut, cette valeur est égale à 1.
Tous les éléments doivent être des entiers | 0.
Catégorie est une liste de codes de catégories pour les couples X et Y
correspondants.
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : a+b·x
stat.a, stat.b
Coefficients d'ajustement
stat.r2
Coefficient de détermination
stat.r
Coefficient de corrélation
stat.Resid
Valeurs résiduelles de l'ajustement
stat.XReg
Liste des points de données de la liste Liste X modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.YReg
Liste des points de données de la liste Liste Y modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.FreqReg
Liste des fréquences correspondant à stat.XReg et stat.YReg
Guide de référence TI-Nspire™ CAS
65
LinRegMx
Catalogue >
LinRegMx X,Y[,[Fréq][,Catégorie,Inclure]]
Effectue l'ajustement linéaire y = m·x+b sur les listes X et Y en
utilisant la fréquence Fréq. Un récapitulatif du résultat est stocké
dans la variable stat.results. (Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes, à
l'exception de Inclure.
X et Y sont des listes de variables indépendantes et dépendantes.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque couple X et Y. Par défaut, cette valeur est égale à 1.
Tous les éléments doivent être des entiers | 0.
Catégorie est une liste de codes de catégories pour les couples X et Y
correspondants.
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : m·x+b
stat.m, stat.b
Coefficients d'ajustement
stat.r2
Coefficient de détermination
stat.r
Coefficient de corrélation
stat.Resid
Valeurs résiduelles de l'ajustement
stat.XReg
Liste des points de données de la liste Liste X modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.YReg
Liste des points de données de la liste Liste Y modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.FreqReg
Liste des fréquences correspondant à stat.XReg et stat.YReg
66
Guide de référence TI-Nspire™ CAS
LinRegtIntervals
Catalogue >
LinRegtIntervals X,Y[,F[,0[,NivC]]]
Pente. Calcule un intervalle de confiance de niveau C pour la pente.
LinRegtIntervals X,Y[,F[,1,Xval[,NivC]]]
Réponse. Calcule une valeur y prévue, un intervalle de prévision de
niveau C pour une seule observation et un intervalle de confiance de
niveau C pour la réponse moyenne.
Un récapitulatif du résultat est stocké dans la variable stat.results.
(Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes.
X et Y sont des listes de variables indépendantes et dépendantes.
F est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans F spécifie la fréquence d'occurrence pour
chaque couple X et Y. Par défaut, cette valeur est égale à 1. Tous les
éléments doivent être des entiers | 0.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : a+b·x
stat.a, stat.b
Coefficients d'ajustement
stat.df
Degrés de liberté
stat.r2
Coefficient de détermination
stat.r
Coefficient de corrélation
stat.Resid
Valeurs résiduelles de l'ajustement
Pour les intervalles de type Slope uniquement
Variable de sortie
Description
[stat.CLower,
stat.CUpper]
Intervalle de confiance de pente
stat.ME
Marge d'erreur de l'intervalle de confiance
stat.SESlope
Erreur type de pente
stat.s
Erreur type de ligne
Pour les intervalles de type Response uniquement
Variable de sortie
Description
[stat.CLower,
stat.CUpper]
Intervalle de confiance pour une réponse moyenne
stat.ME
Marge d'erreur de l'intervalle de confiance
stat.SE
Erreur type de réponse moyenne
Guide de référence TI-Nspire™ CAS
67
Variable de sortie
Description
[stat.LowerPred,
stat.UpperPred]
Intervalle de prévision pour une observation simple
stat.MEPred
Marge d'erreur de l'intervalle de prévision
stat.SEPred
Erreur type de prévision
a + b·ValX
y
stat.
LinRegtTest
Catalogue >
LinRegtTest X,Y[,Fréq[,Hypoth]]
Effectue l'ajustement linéaire sur les listes X et Y et un t-test sur la
valeur de la pente b et le coefficient de corrélation r pour l'équation
y=a+bx. Il teste l'hypothèse nulle H0 :b=0 (équivalent, r=0) par
rapport à l'une des trois hypothèses.
Toutes les listes doivent comporter le même nombre de lignes.
X et Y sont des listes de variables indépendantes et dépendantes.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque couple X et Y. Par défaut, cette valeur est égale à 1.
Tous les éléments doivent être des entiers | 0.
Hypoth est une valeur facultative qui spécifie une des trois
hypothèses par rapport à laquelle l'hypothèse nulle (H0 :b=r=0) est
testée.
Pour Ha : bƒ0 et rƒ0 (par défaut), définissez Hypoth=0
Pour Ha : b<0 et r<0, définissez Hypoth<0
Pour Ha : b>0 et r>0, définissez Hypoth>0
Un récapitulatif du résultat est stocké dans la variable stat.results.
(Voir page 121.)
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : a + b·x
stat.t
t-Statistique pour le test de signification
stat.PVal
Plus petit seuil de signification permettant de rejeter l'hypothèse nulle
stat.df
Degrés de liberté
stat.a, stat.b
Coefficients d'ajustement
stat.s
Erreur type de ligne
stat.SESlope
Erreur type de pente
stat.r2
Coefficient de détermination
stat.r
Coefficient de corrélation
stat.Resid
Valeurs résiduelles de l'ajustement
68
Guide de référence TI-Nspire™ CAS
linSolve()
Catalogue >
linSolve( SystèmÉqLin, Var1, Var2, ...)
⇒ liste
linSolve(ÉqLin1 and ÉqLin2 and ...,
Var1, Var2, ...) ⇒ liste
linSolve({ÉqLin1, ÉqLin2, ...}, Var1, Var2, ...)
⇒ liste
linSolve(SystèmÉqLin, {Var1, Var2, ...})
⇒ liste
linSolve(ÉqLin1 and ÉqLin2 and ...,
{Var1, Var2, ...}) ⇒ liste
linSolve({ÉqLin1, ÉqLin2, ...}, {Var1, Var2, ...})
⇒ liste
Affiche une liste de solutions pour les variables Var1, Var2, etc.
Le premier argument doit être évalué à un système d'équations
linéaires ou à une seule équation linéaire. Si tel n'est pas le cas, une
erreur d'argument se produit.
Par exemple, le calcul de linSolve(x=1 et x=2,x) génère le résultat
“Erreur d'argument”.
@list()
Catalogue >
@list(Liste1) ⇒ liste
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant deltaList(...).
Donne la liste des différences entre les éléments consécutifs de
Liste1. Chaque élément de Liste1 est soustrait de l'élément suivant
de Liste1. Le résultat comporte toujours un élément de moins que la
liste Liste1 initiale.
list4mat()
list4mat( Liste [, élémentsParLigne])
Catalogue >
⇒ matrice
Donne une matrice construite ligne par ligne à partir des éléments de
Liste.
Si élémentsParLigne est spécifié, donne le nombre d'éléments par
ligne. La valeur par défaut correspond au nombre d'éléments de Liste
(une ligne).
Si Liste ne comporte pas assez d'éléments pour la matrice, on
complète par zéros.
Remarque : vous pouvez insérer cette fonction à partir du clavier
de l'ordinateur en entrant list@>mat(...).
4ln
Catalogue >
Expr 4ln ⇒ expression
Convertit Expr en une expression contenant uniquement des
logarithmes népériens (ln).
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>ln.
Guide de référence TI-Nspire™ CAS
69
ln()
Touches
/u
ln(Expr1) ⇒ expression
ln(Liste1) ⇒ liste
Donne le logarithme népérien de l'argument.
En mode Format complexe Réel :
Dans le cas d'une liste, donne les logarithmes népériens de tous les
éléments de celle-ci.
En mode Format complexe Rectangulaire :
ln(matriceCarrée1)
⇒ matriceCarrée
Donne le logarithme népérien de la matrice matriceCarrée1. Ce
calcul est différent du calcul du logarithme népérien de chaque
élément. Pour plus d'informations sur la méthode de calcul,
reportezvous à cos().
En mode Angle en radians et en mode Format complexe
Rectangulaire :
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
Pour afficher le résultat entier, appuyez sur
touches
LnReg
Catalogue >
LnReg X, Y[, [Fréq] [, Catégorie, Inclure]]
Effectue l'ajustement logarithmique y = a+b·ln(x) sur les listes X et
Y en utilisant la fréquence Fréq. Un récapitulatif du résultat est
stocké dans la variable stat.results. (Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes, à
l'exception de Inclure.
X et Y sont des listes de variables indépendantes et dépendantes.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque couple X et Y. Par défaut, cette valeur est égale à 1.
Tous les éléments doivent être des entiers | 0.
Catégorie est une liste de codes de catégories pour les couples X et Y
correspondants.
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : a+b·ln(x)
stat.a, stat.b
Coefficients d'ajustement
stat.r
Coefficient de détermination linéaire pour les données transformées
stat.r
Coefficient de corrélation pour les données transformées (ln(x), y)
2
70
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.s
Guide de référence TI-Nspire™ CAS
Variable de sortie
Description
stat.Resid
Valeurs résiduelles associées au modèle logarithmique
stat.ResidTrans
Valeurs résiduelles associées à l'ajustement linéaire des données transformées
stat.XReg
Liste des points de données de la liste Liste X modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.YReg
Liste des points de données de la liste Liste Y modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.FreqReg
Liste des fréquences correspondant à stat.XReg et stat.YReg
Local
Catalogue >
Local Var1[, Var2] [, Var3] ...
Déclare les variables vars spécifiées comme variables locales. Ces
variables existent seulement lors du calcul d'une fonction et sont
supprimées une fois l'exécution de la fonction terminée.
Remarque : les variables locales contribuent à libérer de la
mémoire dans la mesure où leur existence est temporaire. De même,
elle n'interfère en rien avec les valeurs des variables globales
existantes. Les variables locales s'utilisent dans les boucles For et
pour enregistrer temporairement des valeurs dans les fonctions de
plusieurs lignes dans la mesure où les modifications sur les variables
globales ne sont pas autorisées dans une fonction.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
définitions sur plusieurs lignes en appuyant sur @ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
Lock
Catalogue >
Lock Var1 [, Var2] [, Var3] ...
Lock Var.
Verrouille les variables ou les groupes de variables spécifiés. Les
variables verrouillées ne peuvent être ni modifiées ni supprimées.
Vous ne pouvez pas verrouiller ou déverrouiller la variable système
Ans, de même que vous ne pouvez pas verrouiller les groupes de
variables système stat. ou tvm.
Remarque : La commande Verrouiller (Lock) efface le contenu
de l'historique Annuler/Rétablir lorsqu'elle est appliquée à des
variables non verrouillées.
Voir unLock, page 136 et getLockInfo(), page 55.
Guide de référence TI-Nspire™ CAS
71
log()
Touches
log(Expr1[,Expr2])
log(Liste1[,Expr2])
/s
⇒ expression
⇒ liste
Donne le logarithme de base Expr2 de l'argument.
Remarque : voir aussi Modèle Logarithme, page 2.
Dans le cas d'une liste, donne le logarithme de base Expr2 des
éléments.
Si Expr2 est omis, la valeur de base 10 par défaut est utilisée.
En mode Format complexe Réel :
En mode Format complexe Rectangulaire :
log(matriceCarrée1[,Expr])
⇒ matriceCarrée
Donne le logarithme de base Expr de matriceCarrée1. Ce calcul est
différent du calcul du logarithme de base Expr de chaque élément.
Pour plus d'informations sur la méthode de calcul, reportez-vous à
cos().
En mode Angle en radians et en mode Format complexe
Rectangulaire :
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
Si l'argument de base est omis, la valeur de base 10 par défaut est
utilisée.
Pour afficher le résultat entier, appuyez sur
touches
4logbase
Expr1 4logbase(Expr2) ⇒ expression
Provoque la simplification de l'expression entrée en une expression
utilisant uniquement des logarithmes de base Expr2.
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>logbase(...).
72
Guide de référence TI-Nspire™ CAS
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
Catalogue >
Logistic
Catalogue >
Logistic X, Y[, [Fréq] [, Catégorie, Inclure]]
Effectue l'ajustement logistique y = (c/(1+a·e-bx)) sur les listes X et
Y en utilisant la fréquence Fréq. Un récapitulatif du résultat est
stocké dans la variable stat.results. (Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes, à
l'exception de Inclure.
X et Y sont des listes de variables indépendantes et dépendantes.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque couple X et Y. Par défaut, cette valeur est égale à 1.
Tous les éléments doivent être des entiers | 0.
Catégorie est une liste de codes de catégories pour les couples X et Y
correspondants.
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : c/(1+a·e-bx)
stat.a, stat.b, stat.c
Coefficients d'ajustement
stat.Resid
Valeurs résiduelles de l'ajustement
stat.XReg
Liste des points de données de la liste Liste X modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.YReg
Liste des points de données de la liste Liste Y modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.FreqReg
Liste des fréquences correspondant à stat.XReg et stat.YReg
Guide de référence TI-Nspire™ CAS
73
LogisticD
Catalogue >
LogisticD X, Y [, [Itérations], [Fréq] [, Catégorie, Inclure] ]
Effectue l'ajustement logistique y = (c/(1+a·e-bx)+d) sur les listes X
et Y en utilisant la fréquence Fréq et un nombre spécifique
d'Itérations. Un récapitulatif du résultat est stocké dans la variable
stat.results. (Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes, à
l'exception de Inclure.
X et Y sont des listes de variables indépendantes et dépendantes.
L'argument facultatif Itérations spécifie le nombre maximum
d'itérations utilisées lors de ce calcul. Si Itérations est omis, la valeur
par défaut 64 est utilisée. On obtient généralement une meilleure
précision en choisissant une valeur élevée, mais cela augmente
également le temps de calcul, et vice versa.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque couple X et Y. Par défaut, cette valeur est égale à 1.
Tous les éléments doivent être des entiers | 0.
Catégorie est une liste de codes de catégories pour les couples X et Y
correspondants.
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : c/(1+a·e-bx)+d)
stat.a, stat.b, stat.c,
stat.d
Coefficients d'ajustement
stat.Resid
Valeurs résiduelles de l'ajustement
stat.XReg
Liste des points de données de la liste Liste X modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.YReg
Liste des points de données de la liste Liste Y modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.FreqReg
Liste des fréquences correspondant à stat.XReg et stat.YReg
74
Guide de référence TI-Nspire™ CAS
Loop
Catalogue >
Loop
Bloc
EndLoop
Exécute de façon itérative les instructions de Bloc. Notez que la
boucle se répète indéfiniment, jusqu'à l'exécution d'une instruction
Goto ou Exit à l'intérieur du Bloc.
Bloc correspond à une série d'instructions, séparées par un « : ».
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
définitions sur plusieurs lignes en appuyant sur @ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
LU
Catalogue >
LU Matrice, lMatrice, uMatrice, pMatrice[,Tol]
Calcule la décomposition LU (lower-upper) de Doolittle d'une matrice
réelle ou complexe. La matrice triangulaire inférieure est stockée dans
IMatrice, la matrice triangulaire supérieure dans uMatrice et la
matrice de permutation (qui décrit les échange de lignes exécutés
pendant le calcul) dans pMatrice.
lMatrice · uMatrice = pMatrice · matrice
L'argument facultatif Tol permet de considérer comme nul tout
élément de la matrice dont la valeur absolue est inférieure à Tol. Cet
argument n'est utilisé que si la matrice contient des nombres en
virgule flottante et ne contient pas de variables symbolique sans
valeur affectée. Dans le cas contraire, Tol est ignoré.
•
Si vous utilisez
/· ou définissez le mode Auto ou
Approché (Approximate) sur Approché (Approximate), les
•
calculs sont exécutés en virgule flottante.
Si Tol est omis ou inutilisé, la tolérance par défaut est calculée
comme suit :
5EM14 ·max(dim(Matrice)) ·rowNorm(Matrice)
L'algorithme de factorisation LU utilise la méthode du Pivot partiel
avec échanges de lignes.
Guide de référence TI-Nspire™ CAS
75
M
mat4list()
Catalogue >
mat4list(Matrice)
⇒ liste
Donne la liste obtenue en copiant les éléments de Matrice ligne par
ligne.
Remarque : vous pouvez insérer cette fonction à partir du clavier
de l'ordinateur en entrant mat@>list(...).
max()
Catalogue >
max(Expr1, Expr2) ⇒ expression
max(Liste1, Liste2) ⇒ liste
max(Matrice1, Matrice2) ⇒ matrice
Donne le maximum des deux arguments. Si les arguments sont deux
listes ou matrices, donne la liste ou la matrice formée de la valeur
maximale de chaque paire d'éléments correspondante.
max(Liste)
⇒ expression
Donne l'élément maximal de liste.
max(Matrice1)
⇒ matrice
Donne un vecteur ligne contenant l'élément maximal de chaque
colonne de la matrice Matrice1.
Les éléments vides sont ignorés. Pour plus d'informations concernant
les éléments vides, reportez-vous à la page 164.
Remarque : voir aussi fMax() et min().
mean()
mean(Liste[, listeFréq])
Catalogue >
⇒ expression
Donne la moyenne des éléments de Liste.
Chaque élément de la liste listeFréq totalise le nombre d'occurrences
de l'élément correspondant de Liste.
mean(Matrice1[, matriceFréq])
⇒ matrice
Donne un vecteur ligne des moyennes de toutes les colonnes de
Matrice1.
Chaque élément de matriceFréq totalise le nombre d'occurrences de
l'élément correspondant de Matrice1.
Les éléments vides sont ignorés. Pour plus d'informations concernant
les éléments vides, reportez-vous à la page 164.
76
Guide de référence TI-Nspire™ CAS
En mode Format Vecteur Rectangulaire :
median()
median(Liste[, listeFréq])
Catalogue >
⇒ expression
Donne la médiane des éléments de Liste.
Chaque élément de la liste listeFréq totalise le nombre d'occurrences
de l'élément correspondant de Liste.
median(Matrice1[, matriceFréq])
⇒ matrice
Donne un vecteur ligne contenant les médianes des colonnes de
Matrice1.
Chaque élément de matriceFréq totalise le nombre d'occurrences
consécutives de l'élément correspondant de Matrice1.
Remarques :
•
•
tous les éléments de la liste ou de la matrice doivent
correspondre à des valeurs numériques.
Les éléments vides de la liste ou de la matrice sont ignorés. Pour
plus d'informations concernant les éléments vides, reportez-vous
à la page 164.
MedMed
Catalogue >
MedMed X,Y [, Fréq] [, Catégorie, Inclure]]
Calcule la ligne Med-Med y = (m·x+b) sur les listes X et Y en
utilisant la fréquence Fréq. Un récapitulatif du résultat est stocké
dans la variable stat.results. (Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes, à
l'exception de Inclure.
X et Y sont des listes de variables indépendantes et dépendantes.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque couple X et Y. Par défaut, cette valeur est égale à 1.
Tous les éléments doivent être des entiers | 0.
Catégorie est une liste de codes de catégories pour les couples X et Y
correspondants..
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation de ligne Med-Med : m·x+b
stat.m, stat.b
Coefficient de modèle
stat.Resid
Valeurs résiduelles de la ligne Med-Med
stat.XReg
Liste des points de données de la liste Liste X modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.YReg
Liste des points de données de la liste Liste Y modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.FreqReg
Liste des fréquences correspondant à stat.XReg et stat.YReg
Guide de référence TI-Nspire™ CAS
77
mid()
Catalogue >
mid(chaîneSrce, Début[, Nbre])
⇒ chaîne
Donne la portion de chaîne de Nbre de caractères extraite de la
chaîne chaîneSrce, en commençant au numéro de caractère Début.
Si Nbre est omis ou s'il dépasse le nombre de caractères de la chaîne
chaîneSrce, on obtient tous les caractères de chaîneSrce, compris
entre le numéro de caractère Début et le dernier caractère.
Nbre doit être | 0. Si Nbre = 0, on obtient une chaîne vide.
mid(listeSource, Début [, Nbre])
⇒ liste
Donne la liste de Nbre d'éléments extraits de listeSource, en
commençant à l'élément numéro Début.
Si Nbre est omis ou s'il dépasse le nombre d'éléments de la liste
listeSource, on obtient tous les éléments de listeSource, compris
entre l'élément numéro Début et le dernier élément.
Nbre doit être | 0. Si Nbre = 0, on obtient une liste vide.
mid(listeChaînesSource, Début[, Nbre])
⇒ liste
Donne la liste de Nbre de chaînes extraites de la liste
listeChaînesSource, en commençant par l'élément numéro Début.
min()
Catalogue >
min(Expr1, Expr2) ⇒ expression
min(Liste1, Liste2) ⇒ liste
min(Matrice1, Matrice2) ⇒ matrice
Donne le minimum des deux arguments. Si les arguments sont deux
listes ou matrices, donne la liste ou la matrice formée de la valeur
minimale de chaque paire d'éléments correspondante.
min(Liste)
⇒ expression
Donne l'élément minimal de Liste.
min(Matrice1)
⇒ matrice
Donne un vecteur ligne contenant l'élément minimal de chaque
colonne de la matrice Matrice1.
Remarque : voir aussi fMin() et max().
78
Guide de référence TI-Nspire™ CAS
mirr()
Catalogue >
mirr(tauxFinancement,tauxRéinvestissement,MT0,ListeMT
[,FréqMT]) ⇒ expression
Fonction financière permettant d'obtenir le taux interne de rentabilité
modifié d'un investissement.
tauxFinancement correspond au taux d'intérêt que vous payez sur
les montants de mouvements de trésorerie.
tauxRéinvestissement est le taux d'intérêt auquel les mouvements de
trésorerie sont réinvestis.
MT0 correspond au mouvement de trésorerie initial à l'heure 0 ; il
doit s'agir d'un nombre réel.
Liste MT est une liste des montants de mouvements de trésorerie
après le mouvement de trésorerie initial MT0.
FréqMT est une liste facultative dans laquelle chaque élément
indique la fréquence d'occurrence d'un montant de mouvement de
trésorerie groupé (consécutif), correspondant à l'élément de ListeMT.
La valeur par défaut est 1 ; si vous saisissez des valeurs, elles doivent
être des entiers positifs < 10 000.
Remarque : voir également irr(), page 62.
mod()
Catalogue >
mod(Exp1, Exp2) ⇒ expression
mod(Liste1, List2) ⇒ liste
mod(Matrice1, Matrice2) ⇒ matrice
Donne le premier argument modulo le deuxième argument, défini par
les identités suivantes :
mod(x,0) = x
mod(x,y) = x -Ïy floor(x/y)
Lorsque le deuxième argument correspond à une valeur non nulle, le
résultat est de période dans cet argument. Le résultat est soit zéro
soit une valeur de même signe que le deuxième argument.
Si les arguments sont deux listes ou deux matrices, on obtient une
liste ou une matrice contenant la congruence de chaque paire
d'éléments correspondante.
Remarque : voir aussi remain(), page 101
mRow()
mRow(Expr, Matrice1, Index)
Catalogue >
⇒ matrice
Donne une copie de Matrice1 obtenue en multipliant chaque
élément de la ligne Index de Matrice1 par Expr.
mRowAdd()
mRowAdd(Expr, Matrice1, Index1, Index2)
Catalogue >
⇒ matrice
Donne une copie de Matrice1 obtenue en remplaçant chaque
élément de la ligne Index2 de Matrice1 par :
Expr × ligne Index1 + ligne Index2
Guide de référence TI-Nspire™ CAS
79
MultReg
Catalogue >
MultReg Y, X1[,X2[,X3,…[,X10]]]
Calcule la régression linéaire multiple de la liste Y sur les listes X1,
X2, …, X10. Un récapitulatif du résultat est stocké dans la variable
stat.results. (Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : b0+b1·x1+b2·x2+ ...
stat.b0, stat.b1, ...
Coefficients d'ajustement
Coefficient de détermination multiple
2
stat.R
stat. Liste
y
yListe = b0+b1·x1+ ...
stat.Resid
Valeurs résiduelles de l'ajustement
MultRegIntervals
Catalogue >
MultRegIntervals Y, X1[,X2[,X3,…[,X10]]],listeValX[,CLevel]
Calcule une valeur y prévue, un intervalle de prévision de niveau C
pour une seule observation et un intervalle de confiance de niveau C
pour la réponse moyenne.
Un récapitulatif du résultat est stocké dans la variable stat.results.
(Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : b0+b1·x1+b2·x2+ ...
y
y = b0 + b1 · xl + ... pour listeValX
stat.
Prévision d'un point :
stat.dfError
Degrés de liberté des erreurs
stat.CLower, stat.CUpper
Intervalle de confiance pour une réponse moyenne
stat.ME
Marge d'erreur de l'intervalle de confiance
stat.SE
Erreur type de réponse moyenne
stat.LowerPred,
stat.UpperrPred
Intervalle de prévision pour une observation simple
stat.MEPred
Marge d'erreur de l'intervalle de prévision
stat.SEPred
Erreur type de prévision
stat.bList
Liste de coefficients de régression, {b0,b1,b2,...}
80
Guide de référence TI-Nspire™ CAS
Variable de sortie
Description
stat.Resid
Valeurs résiduelles de l'ajustement
MultRegTests
Catalogue >
MultRegTests Y, X1[,X2[,X3,…[,X10]]]
Le test de régression linéaire multiple calcule une régression linéaire
multiple sur les données et donne les statistiques du F-test et du ttest globaux pour les coefficients.
Un récapitulatif du résultat est stocké dans la variable stat.results.
(Voir page 121.)
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Sorties
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : b0+b1·x1+b2·x2+ ...
stat.F
Statistique du F-test global
stat.PVal
Valeur P associée à l'analyse statistique F globale
stat.R
Coefficient de détermination multiple
stat.AdjR2
Coefficient ajusté de détermination multiple
stat.s
Écart-type de l'erreur
stat.DW
Statistique de Durbin-Watson ; sert à déterminer si la corrélation automatique de premier ordre est
présente dans le modèle
2
stat.dfReg
Degrés de liberté de la régression
stat.SSReg
Somme des carrés de la régression
stat.MSReg
Moyenne des carrés de la régression
stat.dfError
Degrés de liberté des erreurs
stat.SSError
Somme des carrés des erreurs
stat.MSError
Moyenne des carrés des erreurs
stat.bList
{b0,b1,...} Liste de coefficents
stat.tList
Liste des statistiques t pour chaque coefficient dans la liste bList
stat.PList
Liste des valeurs p pour chaque statistique t
stat.SEList
Liste des erreurs type des coefficients de la liste bList
stat. Liste
y
yListe = b0+b1·x1+ . . .
stat.Resid
Valeurs résiduelles de l'ajustement
stat.sResid
Valeurs résiduelles normalisées ; valeur obtenue en divisant une valeur résiduelle par son écart-type
stat.CookDist
Distance de Cook ; Mesure de l'influence d'une observation basée sur la valeur résiduelle et le levier
stat.Leverage
Mesure de la distance séparant les valeurs de la variable indépendante de leurs valeurs moyennes
Guide de référence TI-Nspire™ CAS
81
N
nCr()
Catalogue >
nCr(Expr1, Expr2)
⇒ expression
Pour les expressions Expr1 et Expr2 avec Expr1 | Expr2 | 0, nCr()
donne le nombre de combinaisons de Expr1 éléments pris parmi
Expr2 éléments. (Appelé aussi « coefficient binomial ».) Les deux
arguments peuvent être des entiers ou des expressions symboliques.
nCr(Expr, 0)
⇒
1
nCr(Expr, entierNég)
⇒
nCr(Expr, entierPos)
⇒ Expr·(ExprN1)...
0
(ExprNentierPos+1)/ entierPos!
nCr(Expr, nonEntier)
⇒ expression!/
((ExprNnonEntier)!·nonEntier!)
nCr(Liste1, Liste2)
⇒ liste
Donne une liste de combinaisons basées sur les paires d'éléments
correspondantes dans les deux listes. Les arguments doivent être des
listes comportant le même nombre d'éléments.
nCr(Matrice1, Matrice2)
⇒ matrice
Donne une matrice de combinaisons basées sur les paires d'éléments
correspondantes dans les deux matrices. Les arguments doivent être
des matrices comportant le même nombre d'éléments.
nDerivative()
Catalogue >
nDerivative(Expr1,Var=Valeur[,Ordre])
⇒ valeur
⇒ valeur
nDerivative(Expr1,Var [,Ordre]) | Var=Valeur
Affiche la dérivée numérique calculée avec les méthodes de
différenciation automatique.
Si valeur est spécifiée, celle-ci prévaut sur toute affectation de
variable ou substitution précédente de type "sachant que" pour la
variable.
L'ordre de la dérivée doit être 1 ou 2.
newList()
newList(nbreÉléments)
Catalogue >
⇒ liste
Donne une liste de dimension nbreÉléments. Tous les éléments sont
nuls.
newMat()
newMat(nbreLignes, nbreColonnes)
Catalogue >
⇒ matrice
Donne une matrice nulle de dimensions nbreLignes, nbreColonnes.
82
Guide de référence TI-Nspire™ CAS
nfMax()
Catalogue >
nfMax(Expr, Var) ⇒ valeur
nfMax(Expr, Var, LimitInf) ⇒ valeur
nfMax(Expr, Var, LimitInf, LimitSup)
⇒ valeur
⇒ valeur
nfMax(Expr, Var) | LimitInf<Var<LimitSup
Donne la valeur numérique possible de la variable Var au point où le
maximum local de Expr survient.
Si LimitInf et LimitSup sont spécifiés, la fonction recherche le
maximum local entre ces valeurs.
Remarque : voir aussi fMax() et d().
nfMin()
Catalogue >
nfMin(Expr, Var) ⇒ valeur
nfMin(Expr, Var, LimitInf) ⇒ valeur
nfMin(Expr, Var, LimitInf, LimitSup)
⇒ valeur
⇒ valeur
nfMin(Expr, Var) | LimitInf<Var<LimitSup
Donne la valeur numérique possible de la variable Var au point où le
minimum local de Expr survient.
Si LimitInf et LimitSup sont spécifiés, la fonction recherche le
minimum local entre ces valeurs.
Remarque : voir aussi fMin() et d().
nInt()
nInt(Expr1, Var, Borne1, Borne2)
Catalogue >
⇒ expression
Si l'intégrande Expr1 ne contient pas d'autre variable que Var et si
Borne1 et Borne2 sont des constantes, en +ˆ ou en -ˆ, alors nInt()
donne le calcul approché de ‰(Expr1, Var, Borne1, Borne2). Cette
approximation correspond à une moyenne pondérée de certaines
valeurs d'échantillon de l'intégrande dans l'intervalle
Borne1<Var<Borne2.
L'objectif est d'atteindre une précision de six chiffres significatifs.
L'algorithme s'adaptant, met un terme au calcul lorsqu'il semble avoir
atteint cet objectif ou lorsqu'il paraît improbable que des échantillons
supplémentaires produiront une amélioration notable.
Le message « Précision incertaine » s'affiche lorsque cet objectif ne
semble pas atteint.
Il est possible de calculer une intégrale multiple en imbriquant
plusieurs appels nInt(). Les bornes d'intégration peuvent dépendre
des variables d'intégration les plus extérieures.
Remarque : voir aussi ‰(), page 153.
Guide de référence TI-Nspire™ CAS
83
nom()
Catalogue >
nom(tauxEffectif,CpY)
⇒ valeur
Fonction financière permettant de convertir le taux d'intérêt effectif
tauxEffectif à un taux annuel nominal, CpY étant le nombre de
périodes de calcul par an.
tauxEffectif doit être un nombre réel et CpY doit être un nombre réel
> 0.
Remarque : voir également eff(), page 41.
norm()
Catalogue >
⇒ expression
norm(Vecteur) ⇒ expression
norm(Matrice)
Donne la norme de Frobenius.
normalLine()
normalLine(Expr1,Var,Point)
normalLine(Expr1,Var=Point)
Catalogue >
⇒ expression
⇒ expression
Donne la normale à la courbe représentée par Expr1 au point spécifié
par Var=Point.
Assurez-vous de ne pas avoir affecté une valeur à la variable
indépendante. Par exemple, si f1(x):=5 et x:=3, alors
normalLine(f1(x),x,2) retourne « faux».
normCdf()
Catalogue >
normCdf(lowBound,upBound[,m[,s]]) ⇒ nombre si lowBound
et upBound sont des nombres, liste si lowBound et upBound
sont des listes
Calcule la probabilité qu'une variable suivant la loi normale de
moyenne (m, valeur par défaut =0) et d'écart-type (sigma, valeur par
défaut = 1) prenne des valeurs entre les bornes lowBound et
upBound.
Pour P(X { upBound), définissez lowBound = .ˆ.
normPdf()
normPdf(ValX[,m[,s]]) ⇒ nombre si ValX est un nombre,
liste si ValX est une liste
Calcule la densité de probabilité de la loi normale à la valeur ValX
spécifiée pour les paramètres m et s.
84
Guide de référence TI-Nspire™ CAS
Catalogue >
not
Catalogue >
not Expr booléenne1
⇒ Expression booléenne
Donne true (vrai) ou false (faux) ou une forme simplifiée de
l'argument.
not Entier1
⇒ entier
En mode base Hex :
Important : utilisez le chiffre zéro et pas la
Donne le complément à 1 d'un entier. En interne, Entier1 est converti
en nombre binaire 64 bits signé. La valeur de chaque bit est inversée
(0 devient 1, et vice versa) pour le complément à 1. Le résultat est
affiché en fonction du mode Base utilisé.
Les entiers de tout type de base sont admis. Pour une entrée binaire
ou hexadécimale, vous devez utiliser respectivement le préfixe 0b ou
0h. Tout entier sans préfixe est considéré comme un nombre en
écriture décimale (base 10).
lettre O.
En mode base Bin :
Si vous entrez un nombre dont le codage binaire signé dépasse 64
bits, il est ramené à l'aide d'une congruence dans la plage appropriée.
Pour de plus amples informations, voir 4Base2, page 13.
Pour afficher le résultat entier, appuyez sur
touches
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
Remarque : une entrée binaire peut comporter jusqu'à 64
chiffres (sans compter le préfixe 0b) ; une entrée hexadécimale
jusqu'à 16 chiffres.
nPr()
Catalogue >
nPr(Expr1, Expr2)
⇒ expression
Pour les expressions Expr1 et Expr2 avec Expr1 | Expr2 | 0, nPr()
donne le nombre de permutations de Expr1 éléments pris parmi
Expr2 éléments. Les deux arguments peuvent être des entiers ou des
expressions symboliques.
nPr(Expr, 0)
⇒
1
nPr(Expr, entierNég)
⇒
1/((Expr+1)·(Expr+2)...
(expressionNentierNég))
nPr(Expr, entierPos)
⇒ Expr·(ExprN1)...
(ExprNentierPos+1)
nPr(Expr, nonEntier)
nPr(Liste1, Liste2)
⇒ Expr! / (ExprNnonEntier)!
⇒ liste
Donne une liste de permutations basées sur les paires d'éléments
correspondantes dans les deux listes. Les arguments doivent être des
listes comportant le même nombre d'éléments.
nPr(Matrice1, Matrice2)
⇒ matrice
Donne une matrice de permutations basées sur les paires d'éléments
correspondantes dans les deux matrices. Les arguments doivent être
des matrices comportant le même nombre d'éléments.
Guide de référence TI-Nspire™ CAS
85
npv()
Catalogue >
npv(tauxIntérêt,MTO,ListeMT[,FréqMT])
Fonction financière permettant de calculer la valeur actuelle nette ; la
somme des valeurs actuelles des mouvements d'entrée et de sortie de
fonds. Un résultat positif pour NPV indique un investissement
rentable.
tauxIntérêt est le taux à appliquer pour l'escompte des mouvements
de trésorerie (taux de l'argent) sur une période donnée.
MT0 correspond au mouvement de trésorerie initial à l'heure 0 ; il
doit s'agir d'un nombre réel.
Liste MT est une liste des montants de mouvements de trésorerie
après le mouvement de trésorerie initial MT0.
FréqMT est une liste dans laquelle chaque élément indique la
fréquence d'occurrence d'un montant de mouvement de trésorerie
groupé (consécutif), correspondant à l'élément de ListeMT. La valeur
par défaut est 1 ; si vous saisissez des valeurs, elles doivent être des
entiers positifs < 10 000.
nSolve()
nSolve(Équation,Var[=Condition])
Catalogue >
⇒ chaîne_nombre ou
erreur
nSolve(Équation,Var[=Condition],LimitInf)
⇒ chaîne_nombre ou erreur
nSolve(Équation,Var[=Condition],LimitInf,LimitSup)
⇒ chaîne_nombre ou erreur
nSolve(Équation,Var[=Condition]) | LimitInf<Var<LimitSup
⇒ chaîne_nombre ou erreur
Recherche de façon itérative une solution numérique réelle approchée
pour Équation en fonction de sa variable. Spécifiez la variable
comme suit :
variable
– ou –
variable = nombre réel
Par exemple, x est autorisé, de même que x=3.
nSolve() est souvent plus rapide que solve() ou zeros(), notamment
si l'opérateur « | » est utilisé pour limiter la recherche à un intervalle
réduit qui contient exactement une seule solution.
nSolve() tente de déterminer un point où la valeur résiduelle est zéro
ou deux points relativement rapprochés où la valeur résiduelle a un
signe négatif et où son ordre de grandeur n'est pas excessif. S'il n'y
parvient pas en utilisant un nombre réduit de points d'échantillon, la
chaîne « Aucune solution n'a été trouvée » s'affiche.
Remarque : voir aussi cSolve(), cZeros(), solve(), et zeros().
86
Guide de référence TI-Nspire™ CAS
Remarque : si plusieurs solutions sont possibles, vous pouvez
utiliser une condition pour mieux déterminer une solution
particulière.
O
OneVar
Catalogue >
OneVar [1,]X[,[Fréq][,Catégorie,Inclure]]
OneVar [n,]X1,X2[X3[,…[,X20]]]
Effectue le calcul de statistiques à une variable sur un maximum de
20 listes. Un récapitulatif du résultat est stocké dans la variable
stat.results. (Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes, à
l'exception de Inclure.
Les arguments X sont des listes de données.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque valeur X correspondante. Par défaut, cette valeur est
égale à 1. Tous les éléments doivent être des entiers | 0.
Catégorie est une liste de codes numériques de catégories pour les
valeurs X correspondantes.
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Tout élément vide dans les listes X, Fréq ou Catégorie a un élément
vide correspondant dans l'ensemble des listes résultantes. Tout
élément vide dans les listes X1 à X20 correspond a un élément vide
dans l'ensemble des listes résultantes. Pour plus d'informations
concernant les éléments vides, reportez-vous à la page 164.
Variable de sortie
Description
stat.v
Moyenne des valeurs x
stat.Gx
Somme des valeurs x
stat.Gx2
Somme des valeurs x2.
stat.sx
Écart-type de l'échantillon de x
stat.sx
Écart-type de la population de x
stat.n
Nombre de points de données
stat.MinX
Minimum des valeurs de x
stat.Q1X
1er quartile de x
stat.MedianX
Médiane de x
stat.Q3X
3ème quartile de x
stat.MaxX
Maximum des valeurs de x
stat.SSX
Somme des carrés des écarts par rapport à la moyenne de x
Guide de référence TI-Nspire™ CAS
87
or
Catalogue >
Expr booléenne1 or Expr booléenne2
⇒ Expression booléenne
Donne true (vrai) ou false (faux) ou une forme simplifiée de l'entrée
initiale.
Donne true si la simplification de l'une des deux ou des deux
expressions est vraie. Donne false uniquement si la simplification des
deux expressions est fausse.
Remarque : voir xor.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
@ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
définitions sur plusieurs lignes en appuyant sur
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
Entier1 or Entier2 ⇒ entier
En mode base Hex :
Compare les représentations binaires de deux entiers réels en
appliquant un or bit par bit. En interne, les deux entiers sont convertis
Important : utilisez le chiffre zéro et pas la lettre O.
en nombres binaires 64 bits signés. Lorsque les bits comparés
correspondent, le résultat est 1 si dans les deux cas il s'agit d'un bit 1
En mode base Bin :
; le résultat est 0 si, dans les deux cas, il s'agit d'un bit 0. La valeur
donnée représente le résultat des bits et elle est affichée selon le
mode Base utilisé.
Remarque : une entrée binaire peut comporter jusqu'à 64
Les entiers de tout type de base sont admis. Pour une entrée binaire
chiffres (sans compter le préfixe 0b) ; une entrée hexadécimale
ou hexadécimale, vous devez utiliser respectivement le préfixe 0b ou
jusqu'à 16 chiffres.
0h. Tout entier sans préfixe est considéré comme un nombre en
écriture décimale (base 10).
Si vous entrez un nombre dont le codage binaire signé dépasse 64
bits, il est ramené à l'aide d'une congruence dans la plage appropriée.
Pour de plus amples informations, voir 4Base2, page 13.
Remarque : voir xor.
ord()
Catalogue >
ord(Chaîne) ⇒ entier
ord(Liste1) ⇒ liste
Donne le code numérique du premier caractère de la chaîne de
caractères Chaîne ou une liste des premiers caractères de tous les
éléments de la liste.
88
Guide de référence TI-Nspire™ CAS
P
P4Rx()
Catalogue >
P4Rx(ExprR, qExpr) ⇒ expression
P4Rx(ListeR, qListe) ⇒ liste
P4Rx(MatriceR, qMatrice) ⇒ matrice
En mode Angle en radians :
Donne la valeur de l'abcisse du point de coordonnées polaires
(r, q).
Remarque : l'argument q est interprété comme une mesure en
degrés, en grades ou en radians, suivant le mode Angle utilisé. Si
l'argument est une expression, vous pouvez utiliser ¡, G ou Rpour
ignorer temporairement le mode Angle sélectionné.
Remarque : vous pouvez insérer cette fonction à partir du clavier
de l'ordinateur en entrant P@>Rx(...).
P4Ry()
Catalogue >
P4Ry(ExprR, qExpr) ⇒ expression
P4Ry(ListeR, qListe) ⇒ liste
P4Ry(MatriceR, qMatrice) ⇒ matrice
En mode Angle en radians :
Donne la valeur de l'ordonnée du point de coordonnées polaires
(r, q).
Remarque : l'argument q est interprété comme une mesure en
degrés, en grades ou en radians, suivant le mode Angle utilisé. Si
l'argument est une expression, vous pouvez utiliser ¡, G ou Rpour
ignorer temporairement le mode Angle sélectionné.
Remarque : vous pouvez insérer cette fonction à partir du clavier
de l'ordinateur en entrant P@>Ry(...).
PassErr
Catalogue >
Pour obtenir un exemple de PassErr, reportez-vous à l'exemple
2 de la commande Try, page 131.
PassErr
Passe une erreur au niveau suivant.
Si la variable système errCode est zéro, PassErr ne fait rien.
L'instruction Else du bloc Try...Else...EndTry doit utiliser EffErr ou
PassErr. Si vous comptez rectifier ou ignorer l'erreur, sélectionnez
EffErr. Si vous ne savez pas comment traiter l'erreur, sélectionnez
PassErr pour la transférer au niveau suivant. S'il n'y a plus d'autre
programme de traitement des erreurs Try...Else...EndTry, la boîte de
dialogue Erreur s'affiche normalement.
Remarque : voir également ClrErr, page 19 et Try, page 131.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
définitions sur plusieurs lignes en appuyant sur @ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
Guide de référence TI-Nspire™ CAS
89
piecewise()
Catalogue >
piecewise(Expr1 [, Condition1 [, Expr2 [, Condition2 [, … ]]]])
Permet de créer des fonctions définies par morceaux sous forme de
liste. Il est également possible de créer des fonctions définies par
morceaux en utilisant un modèle.
Remarque : voir aussi Modèle Fonction définie par morceaux,
page 2.
poissCdf()
Catalogue >
poissCdf(l,lowBound,upBound) ⇒ nombre si lowBound et
upBound sont des nombres, liste si lowBound et upBound sont
des listes
poissCdf(l,upBound) (pour P(0{X{upBound) ⇒ nombre si
la borne upBound est un nombre, liste si la borne upBound est
une liste
Calcule la probabilité cumulée d'une variable suivant une loi de
Poisson de moyenne l.
Pour P(X { upBound), définissez la borne lowBound=0
poissPdf()
poissPdf(l,ValX)
ValX est une liste
Catalogue >
⇒ nombre si ValX est un nombre, liste si
Calcule la probabilité de ValX pour la loi de Poisson de moyenne l
spécifiée.
4Polar
Catalogue >
Vecteur 4Polar
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>Polar.
Affiche vecteur sous forme polaire [r ±q]. Le vecteur doit être un
vecteur ligne ou colonne et de dimension 2.
Remarque : 4Polar est uniquement une instruction d'affichage et
non une fonction de conversion. On ne peut l'utiliser qu'à la fin d'une
ligne et elle ne modifie pas le contenu du registre ans.
Remarque : voir aussi 4Rect, page 100.
valeurComplexe 4Polar
En mode Angle en radians :
Affiche valeurComplexe sous forme polaire.
•
•
Le mode Angle en degrés affiche (r±q).
Le mode Angle en radians affiche reiq.
valeurComplexe peut prendre n'importe quelle forme complexe.
Toutefois, une entrée reiq génère une erreur en mode Angle en
degrés.
Remarque : vous devez utiliser les parenthèses pour les entrées
polaires (r±q).
En mode Angle en grades :
En mode Angle en degrés :
90
Guide de référence TI-Nspire™ CAS
polyCoeffs()
polyCoeffs(Poly [,Var])
Catalogue >
⇒ liste
Affiche une liste des coefficients du polynôme Poly pour la variable
Var.
Poly doit être une expression polynomiale de Var Nous conseillons
de ne pas omettre Var à moins que Poly ne soit une expression dans
une variable unique.
Etend le polynôme et sélectionne x pour la variable omise Var.
polyDegree()
polyDegree(Poly [,Var])
Catalogue >
⇒ valeur
Affiche le degré de l'expression polynomiale Poly pour la variable
Var. Si vous omettez Var, la fonction polyDegree() sélectionne une
variable par défaut parmi les variables contenues dans le polynôme
Poly.
Polynômes constants
Poly doit être une expression polynomiale de Var Nous conseillons
de ne pas omettre Var à moins que Poly ne soit une expression dans
une variable unique.
Il est possible d'extraire le degré, même si cela n'est pas possible
pour les coefficients. Cela s'explique par le fait qu'un degré peut
être extrait sans développer le polynôme.
polyEval()
polyEval(Liste1, Expr1)
polyEval(Liste1, Liste2)
Catalogue >
⇒ expression
⇒ expression
Interprète le premier argument comme les coefficients d'un polynôme
ordonné suivant les puissances décroissantes et calcule la valeur de
ce polynôme au point indiqué par le deuxième argument.
Guide de référence TI-Nspire™ CAS
91
polyGcd()
polyGcd(Expr1,Expr2)
Catalogue >
⇒ expression
Donne le plus grand commun diviseur des deux arguments.
Expr1 et Expr2 doivent être des expressions polynomiales.
Les listes, matrices et arguments booléens ne sont pas autorisés.
polyQuotient()
polyQuotient(Poly1,Poly2 [,Var])
Catalogue >
⇒ expression
Affiche le quotient de polynôme Poly1 divisé par le polynôme Poly2
par rapport à la variable spécifiée Var.
Poly1 et Poly2 doivent être des expressions polynomiales de Var.
Nous conseillons de ne pas omettre Var à moins que Poly1 et Poly2
ne soient des expressions dans une même variable unique.
polyRemainder()
polyRemainder(Poly1,Poly2 [,Var])
Catalogue >
⇒ expression
Affiche le reste du polynôme Poly1 divisé par le polynôme Poly2 par
rapport à la variable spécifiée Var.
Poly1 et Poly2 doivent être des expressions polynomiales de Var.
Nous conseillons de ne pas omettre Var à moins que Poly1 et Poly2
ne soient des expressions dans une même variable unique.
92
Guide de référence TI-Nspire™ CAS
polyRoots()
Catalogue >
⇒ liste
polyRoots(ListeCoeff) ⇒ liste
polyRoots(Poly,Var)
La première syntaxe, polyRoots(Poly,Var), affiche une liste des
racines réelles du polynôme Poly pour la variable Var. S'il n'existe
pas de racine réelle, une liste vide est affichée : { }.
Poly doit être un polynôme d'une seule variable.
La deuxième syntaxe, polyRoots(ListeCoeff), affiche une liste de
racines réelles du polynôme dont les coefficients sont donnés par la
liste ListeCoeff.
Remarque : voir aussi cPolyRoots(), page 27.
PowerReg
Catalogue >
PowerReg X,Y [, Fréq] [, Catégorie, Inclure]]
Effectue l'ajustement exponentiel y = (a·(x)b) sur les listes X et Y
en utilisant la fréquence Fréq. Un récapitulatif du résultat est stocké
dans la variable stat.results. (Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes, à
l'exception de Inclure.
X et Y sont des listes de variables indépendantes et dépendantes.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque couple X et Y. Par défaut, cette valeur est égale à 1.
Tous les éléments doivent être des entiers | 0.
Catégorie est une liste de codes de catégories pour les couples X et Y
correspondants.
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : a·(x)b
stat.a, stat.b
Coefficients d'ajustement
stat.r2
Coefficient de détermination linéaire pour les données transformées
stat.r
Coefficient de corrélation pour les données transformées (ln(x), ln(y))
stat.Resid
Valeurs résiduelles associées au modèle exponentiel
stat.ResidTrans
Valeurs résiduelles associées à l'ajustement linéaire des données transformées
stat.XReg
Liste des points de données de la liste Liste X modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.YReg
Liste des points de données de la liste Liste Y modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.FreqReg
Liste des fréquences correspondant à stat.XReg et stat.YReg
Guide de référence TI-Nspire™ CAS
93
Prgm
Catalogue >
Calcule le plus grand commun diviseur et affiche les résultats
intermédiaires.
Prgm
Bloc
EndPrgm
Modèle de création d'un programme défini par l'utilisateur. À utiliser
avec la commande Define, Define LibPub, ou Define LibPriv.
Bloc peut correspondre à une instruction unique ou à une série
d'instructions séparées par le caractère “:” ou à une série
d'instructions réparties sur plusieurs lignes.
Remarque pour la saisie des données de l'exemple : dans
l'application Calculs de l'unité nomade, vous pouvez entrer des
définitions sur plusieurs lignes en appuyant sur @ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
Voir Π( ), page 155.
prodSeq()
Voir Π( ), page 155.
Product (PI)
product()
product(Liste[, Début[, Fin]])
Catalogue >
⇒ expression
Donne le produit des éléments de Liste. Début et Fin sont facultatifs.
Ils permettent de spécifier une plage d'éléments.
product(Matrice1[, Début[, Fin]])
⇒ matrice
Donne un vecteur ligne contenant les produits des éléments ligne par
ligne de Matrice1. Début et Fin sont facultatifs. Ils permettent de
spécifier une plage de colonnes.
Les éléments vides sont ignorés. Pour plus d'informations concernant
les éléments vides, reportez-vous à la page 164.
94
Guide de référence TI-Nspire™ CAS
propFrac()
Catalogue >
propFrac(Expr1[, Var])
⇒ expression
propFrac(nombre_rationnel) décompose nombre_rationnel sous la
forme de la somme d'un entier et d'une fraction de même signe et
dont le dénominateur est supérieur au numérateur (fraction propre).
propFrac(expression_rationnelle,Var) donne la somme des
fractions propres et d'un polynôme par rapport à Var. Le degré de Var
dans le dénominateur est supérieur au degré de Var dans le
numérateur pour chaque fraction propre. Les mêmes puissances de
Var sont regroupées. Les termes et leurs facteurs sont triés, Var étant
la variable principale.
Si Var est omis, le développement des fractions propres s'effectue par
rapport à la variable la plus importante. Les coefficients de la partie
polynomiale sont ensuite ramenés à leur forme propre par rapport à
leur variable la plus importante, et ainsi de suite.
Pour les expressions rationnelles, propFrac() est une alternative plus
rapide mais moins extrême à expand().
Vous pouvez utiliser la fonction propFrac() pour représenter des
fractions mixtes et démontrer l'addition et la soustraction de fractions
mixtes.
Q
QR
Catalogue >
QR Matrice, qMatrice, rMatrice [,Tol]
Calcule la factorisation QR Householder d'une matrice réelle ou
complexe. Les matrices Q et R obtenues sont stockées dans les
NomsMat spécifiés. La matrice Q est unitaire. La matrice R est
triangulaire supérieure.
Le nombre en virgule flottante (9.) dans m1 fait que les résultats
seront tous calculés en virgule flottante.
L'argument facultatif Tol permet de considérer comme nul tout
élément de la matrice dont la valeur absolue est inférieure à Tol. Cet
argument n'est utilisé que si la matrice contient des nombres en
virgule flottante et ne contient pas de variables symbolique sans
valeur affectée. Dans le cas contraire, Tol est ignoré.
•
Si vous utilisez
/· ou définissez le mode Auto ou
Approché (Approximate) sur Approché (Approximate), les
•
calculs sont exécutés en virgule flottante.
Si Tol est omis ou inutilisé, la tolérance par défaut est calculée
comme suit :
5EL14 ·max(dim(Matrice)) ·rowNorm(Matrice)
Guide de référence TI-Nspire™ CAS
95
QR
Catalogue >
La factorisation QR sous forme numérique est calculée en utilisant la
transformation de Householder. La factorisation symbolique est
calculée en utilisant la méthode de Gram-Schmidt. Les colonnes de
NomMatq sont les vecteurs de base orthonormaux de l'espace
vectoriel engendré par les vecteurs colonnes de matrice.
QuadReg
Catalogue >
QuadReg X,Y [, Fréq] [, Catégorie, Inclure]]
Effectue l'ajustement polynomial de degré 2 y = a·x2+b·x+c sur
les listes X et Y en utilisant la fréquence Fréq. Un récapitulatif du
résultat est stocké dans la variable stat.results. (Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes, à
l'exception de Inclure.
X et Y sont des listes de variables indépendantes et dépendantes.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque couple X et Y. Par défaut, cette valeur est égale à 1.
Tous les éléments doivent être des entiers | 0.
Catégorie est une liste de codes de catégories pour les couples X et Y
correspondants..
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : a·x2+b·x+c
stat.a, stat.b, stat.c
Coefficients d'ajustement
stat.R2
Coefficient de détermination
stat.Resid
Valeurs résiduelles de l'ajustement
stat.XReg
Liste des points de données de la liste Liste X modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.YReg
Liste des points de données de la liste Liste Y modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.FreqReg
Liste des fréquences correspondant à stat.XReg et stat.YReg
96
Guide de référence TI-Nspire™ CAS
QuartReg
Catalogue >
QuartReg X,Y [, Fréq] [, Catégorie, Inclure]]
Effectue l'ajustement polynomial de degré 4
y = a·x4+b·x3+c· x2+d·x+e sur les listes X et Y en utilisant la
fréquence Fréq. Un récapitulatif du résultat est stocké dans la
variable stat.results. (Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes, à
l'exception de Inclure.
X et Y sont des listes de variables indépendantes et dépendantes.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque couple X et Y. Par défaut, cette valeur est égale à 1.
Tous les éléments doivent être des entiers | 0.
Catégorie est une liste de codes de catégories pour les couples X et Y
correspondants..
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : a·x4+b·x3+c· x2+d·x+e
stat.a, stat.b, stat.c,
stat.d, stat.e
Coefficients d'ajustement
stat.R2
Coefficient de détermination
stat.Resid
Valeurs résiduelles de l'ajustement
stat.XReg
Liste des points de données de la liste Liste X modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.YReg
Liste des points de données de la liste Liste Y modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.FreqReg
Liste des fréquences correspondant à stat.XReg et stat.YReg
Guide de référence TI-Nspire™ CAS
97
R
R4Pq()
Catalogue >
R4Pq (ExprX, ExprY) ⇒ expression
R4Pq (ListeX, ListeY) ⇒ liste
R4Pq (MatriceX, MatriceY) ⇒ matrice
Donne la coordonnée q d'un point de coordonnées rectangulaires
(x,y).
Remarque : donne le résultat en degrés, en grades ou en radians,
suivant le mode angulaire utilisé.
En mode Angle en degrés :
En mode Angle en grades :
Remarque : vous pouvez insérer cette fonction à partir du clavier
de l'ordinateur en entrant R@>Ptheta(...).
En mode Angle en radians :
R4Pr()
Catalogue >
R4Pr (ExprX, ExprY) ⇒ expression
R4Pr (ListeX, ListeY) ⇒ liste
R4Pr (MatriceX, MatriceY) ⇒ matrice
En mode Angle en radians :
Donne la coordonnée r d'un point de coordonnées rectangulaires
(x,y).
Remarque : vous pouvez insérer cette fonction à partir du clavier
de l'ordinateur en entrant R@>Pr(...).
4Rad
Catalogue >
Expr14Rad ⇒ expression
En mode Angle en degrés :
Convertit l'argument en mesure d'angle en radians.
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>Rad.
rand()
Catalogue >
rand() ⇒ expression
rand(nmbreEssais) ⇒ liste
rand() donne un nombre aléatoire compris entre 0 et 1.
rand(nbreEssais) donne une liste de nombres aléatoires compris
entre 0 et 1 pour le nombre d'essais nbreEssais.
98
En mode Angle en grades :
Guide de référence TI-Nspire™ CAS
Réinitialise le générateur de nombres aléatoires.
randBin()
Catalogue >
randBin(n, p) ⇒ expression
randBin(n, p, nbreEssais) ⇒ liste
randBin(n, p) donne un nombre aléatoire tiré d'une distribution
binomiale spécifiée.
randBin(n, p, nbreEssais) donne une liste de nombres aléatoires
tirés d'une distribution binomiale spécifiée pour un nombre d'essais
nbreEssais.
randInt()
Catalogue >
randInt(LimiteInf,LimiteSup) ⇒ expression
randInt(LimiteInf,LimiteSup,nbreEssais) ⇒ liste
randInt(LimiteInf,LimiteSup) donne un entier aléatoire pris entre
les limites entières LimiteInf et LimiteSup.
randInt(LimiteInf,LimiteSup,nbreEssais) donne une liste d'entiers
aléatoires pris entre les limites spécifiées pour un nombre d'essais
nbreEssais.
randMat()
Catalogue >
randMat(nbreLignes, nbreColonnes)
⇒ matrice
Donne une matrice aléatoire d'entiers compris entre -9 et 9 de la
dimension spécifiée.
Les deux arguments doivent pouvoir être simplifiés en entiers.
Remarque : Les valeurs de cette matrice changent chaque
fois que l'on appuie sur
randNorm()
randNorm(m,
randNorm(m,
·.
Catalogue >
s) ⇒ expression
s, nbreEssais) ⇒ liste
Donne un nombre décimal aléatoire issu de la loi normale spécifiée. Il
peut s'agir de tout nombre réel, mais le résultat obtenu sera
essentiellement compris dans l'intervalle [mN3·s, m+3·s].
randNorm(m, s, nbreEssais) donne une liste de nombres
décimaux tirés d'une distribution normale spécifiée pour un nombre
d'essais nbreEssais.
randPoly()
randPoly(Var, Ordre)
Catalogue >
⇒ expression
Donne un polynôme aléatoire de la variable Var de degré Ordre
spécifié. Les coefficients sont des entiers aléatoires compris entre L9
et 9. Le premier coefficient sera non nul.
Ordre doit être un entier compris entre 0 et 99.
randSamp()
randSamp(Liste,nbreEssais[,sansRem])
Catalogue >
⇒ liste
Donne une liste contenant un échantillon aléatoire de nbreEssais
éléments choisis dans Liste avec option de remise (sansRem=0) ou
sans option de remise (sansRem=1). L'option par défaut est avec
remise.
Guide de référence TI-Nspire™ CAS
99
RandSeed
Catalogue >
RandSeed Nombre
Si Nombre = 0, réinitialise le générateur de nombres aléatoires. Si
Nombre ƒ 0, sert à générer deux nombres initiaux qui sont stockés
dans les variables système seed1 et seed2.
real()
Catalogue >
real( Expr1)
⇒ expression
Donne la partie réelle de l'argument.
Remarque : toutes les variables non affectées sont considérées
comme réelles. Voir aussi imag(), page 59.
real( Liste1)
⇒ liste
Donne la liste des parties réelles de tous les éléments.
real( Matrice1)
⇒ matrice
Donne la matrice des parties réelles de tous les éléments.
4Rect
Catalogue >
Vecteur 4Rect
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>Rect.
Affiche Vecteur en coordonnées rectangulaires [x, y, z]. Le vecteur
doit être un vecteur ligne ou colonne de dimension 2 ou 3.
Remarque : 4Rect est uniquement une instruction d'affichage et
non une fonction de conversion. On ne peut l'utiliser qu'à la fin d'une
ligne et elle ne modifie pas le contenu du registre ans.
Remarque : Voir aussi 4Polar, page 90.
valeurComplexe 4Rect
En mode Angle en radians :
Affiche valeurComplexe sous forme rectangulaire (a+bi).
valeurComplexe peut prendre n'importe quelle forme rectangulaire.
Toutefois, une entrée reiq génère une erreur en mode Angle en
degrés.
Remarque : vous devez utiliser les parenthèses pour les entrées
polaires (r±q).
En mode Angle en grades :
En mode Angle en degrés :
Remarque : pour taper ± à partir du clavier, sélectionnez-le
dans la liste des symboles du Catalogue.
100
Guide de référence TI-Nspire™ CAS
ref()
Catalogue >
ref( Matrice1[, Tol])
⇒ matrice
Donne une réduite de Gauss de la matrice Matrice1.
L'argument facultatif Tol permet de considérer comme nul tout
élément de la matrice dont la valeur absolue est inférieure à Tol. Cet
argument n'est utilisé que si la matrice contient des nombres en
virgule flottante et ne contient pas de variables symbolique sans
valeur affectée. Dans le cas contraire, Tol est ignoré.
•
Si vous utilisez
/· ou définissez le mode Auto ou
Approché (Approximate) sur Approché (Approximate), les
•
calculs sont exécutés en virgule flottante.
Si Tol est omis ou inutilisé, la tolérance par défaut est calculée
comme suit :
5EL14 ·max(dim(Matrice1)) ·rowNorm(Matrice1)
N'utilisez pas d'éléments non définis dans Matrice1. L'utilisation
d'éléments non définis peut générer des résultats inattendus.
Par exemple, si a est un élément non défini dans l'expression
suivante, un message d'avertissement s'affiche et le résultat affiché
est le suivant :
Un message d'avertissement est affiché car l'élément 1/a n'est pas
valide pour a=0.
Pour éviter ce problème, vous pouvez stocker préalablement une
valeur dans a ou utiliser le mécanisme de substitution “|”, comme
illustré dans l'exemple suivant.
Remarque : voir aussi rref(), page 106.
remain()
Catalogue >
remain(Expr1, Expr2) ⇒ expression
remain(Liste1, Liste2) ⇒ liste
remain(Matrice1, Matrice2) ⇒ matrice
Donne le reste de la division euclidienne du premier argument par le
deuxième argument, défini par les identités suivantes :
remain(x,0)  x
remain(x,y)  xNy·iPart(x/y)
Vous remarquerez que remain(Nx,y)  Nremain(x,y). Le résultat
peut soit être égal à zéro, soit être du même signe que le premier
argument.
Remarque : voir aussi mod(), page 79.
Guide de référence TI-Nspire™ CAS
101
Request
Catalogue >
Request ChaîneInvite, var [, IndicAff [, VarÉtat]]
Request ChaîneInvite, fonc ( arg1, ...argn )
[, IndicAff [, VarÉtat]]
Définissez un programme :
Define request_demo()=Prgm
Request “Rayon : ”,r
Disp “Area = “,pi*r2
EndPrgm
Commande de programmation : Marque une pause dans l'exécution
du programme et affiche une boîte de dialogue contenant le message
Exécutez le programme et saisissez une réponse :
chaîneinvite, ainsi qu'une zone de saisie pour la réponse de
request_demo()
l'utilisateur.
Lorsque l'utilisateur saisit une réponse et clique sur OK, le contenu de
la zone de saisie est affecté à la variable var.
Si l'utilisateur clique sur Annuler, le programme poursuit sans
accepter la saisie. Le programme utilise la précédente valeur de var si
var a déjà été définie.
L'argument optionnel IndicAff peut correspondre à toute expression. Après avoir sélectionné OK, le résultat suivant s'affiche :
• Si IndicAff est omis ou a pour valeur 1, le message d'invite et la Rayon : 6/2
Area= 28.2743
réponse de l'utilisateur sont affichés dans l'historique de
l'application Calculs.
• Si IndicAff a pour valeur 0, le message d'invite et la réponse de
l'utilisateur ne sont pas affichés dans l'historique.
L'argument optionnel VarÉtat indique au programme comment
déterminer si l'utilisateur a fermé la boîte de dialogue. Notez que
VarÉtat nécessite la saisie de l'argument IndicAff.
•
•
Si l'utilisateur a cliqué sur OK, appuyé sur Entrée ou sur
Ctrl+Entrée, la variable VarÉtat prend la valeur 1.
Sinon, elle prend la valeur 0.
L'argument func() permet à un programme de stocker la réponse de
l'utilisateur sous la forme d'une définition de fonction. Cette syntaxe
équivaut à l'exécution par l'utilisateur de la commande suivante :
Définissez un programme :
Define polynomial()=Prgm
Request "Saisissez un polynôme en x :",p(x)
Disp "Les racines réelles sont :",polyRoots(p(x),x)
EndPrgm
Exécutez le programme et saisissez une réponse :
polynomial()
Define func(arg1, ...argn) = réponse de l'utilisateur
Le programme peut alors utiliser la fonction définie func().
chaîneinvite doit guider l'utilisateur pour la saisie d'une réponse de
l'utilisateur appropriée qui complète la définition de la fonction.
Après avoir sélectionné OK, le résultat suivant s'affiche :
Saisissez un polynôme en x : x^3+3x+1
Remarque : vous pouvez utiliser la commande Request dans un Les racines réelles sont : {-0.322185}
programme créé par l'utilisateur, mais pas dans une fonction.
Pour arrêter un programme qui contient une Request commande
dans une boucle infinie :
•
•
•
Windows® : maintenez enfoncé la touche F12 et appuyez
plusieurs fois sur Entrée.
Macintosh® : maintenez enfoncé la touche F6 et appuyez
plusieurs fois sur Entrée.
Unité : maintenez enfoncé la touche
plusieurs fois sur
c et appuyez
·.
Remarque : voir aussi RequestStr, page 103.
102
Guide de référence TI-Nspire™ CAS
RequestStr
Catalogue >
RequestStr chaîneinvite, var [, IndicAff]
Définissez un programme :
Define requestStr_demo()=Prgm
Commande de programmation : Fonctionne de façon similaire à la
RequestStr “Votre nom :”,name,0
première syntaxe de la commande Request, excepté que la réponse Disp “La réponse comporte “,dim(name),”
caractères.”
de l'utilisateur est toujours interprétée comme une chaîne. La
commande Request interprète la réponse comme une expression, à EndPrgm
moins que l'utilisateur ne la saisisse entre guillemets (““).
Exécutez le programme et saisissez une réponse :
Remarque : vous pouvez utiliser la commande RequestStr dans requestStr_demo()
un programme créé par l'utilisateur, mais pas dans une fonction.
Pour arrêter un programme qui contient une RequestStr commande
dans une boucle infinie :
•
•
•
Windows® : maintenez enfoncé la touche F12 et appuyez
plusieurs fois sur Entrée.
Macintosh® : maintenez enfoncé la touche F6 et appuyez
plusieurs fois sur Entrée.
Unité : maintenez enfoncé la touche
plusieurs fois sur
c et appuyez
·.
Remarque : voir aussi Request, page 102.
Après avoir sélectionné OK, le résultat affiché est le suivant
(notez que si l'argument IndicAff a pour valeur 0, le message
d'invite et la réponse de l'utilisateur ne s'affichent pas dans
l'historique) :
requestStr_demo()
La réponse comporte 5 caractères.
Return
Catalogue >
Return [Expr]
Donne Expr comme résultat de la fonction. S'utilise dans les blocs
Func...EndFunc.
Remarque : Vous pouvez utiliser Return sans argument dans un
bloc Prgm...EndPrgm pour quitter un programme.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
définitions sur plusieurs lignes en appuyant sur @ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
right()
Catalogue >
right(Liste1[, Nomb])
⇒ liste
Donne les Nomb éléments les plus à droite de la liste Liste1.
Si Nomb est absent, on obtient Liste1.
right(chaîneSrce[, Nomb])
⇒ chaîne
Donne la chaîne formée par les Nomb caractères les plus à droite de
la chaîne de caractères chaîneSrce.
Si Nomb est absent, on obtient chaîneSrce.
right(Comparaison)
⇒ expression
Donne le membre de droite d'une équation ou d'une inéquation.
Guide de référence TI-Nspire™ CAS
103
rk23()
Catalogue >
rk23(Expr, Var, VarDép, {Var0, MaxVar}, Var0Dép, IncVar
[, TolErr]) ⇒ matrice
rk23(SystèmeExpr, Var, ListeVarDép, {Var0, MaxVar},
ListeVar0Dép, IncVar [, TolErr]) ⇒ matrice
rk23(SystèmeExpr, Var, ListeVarDép, {Var0, MaxVar},
ListeVar0Dép,
IncVar [, TolErr]) ⇒ matrice
Utilise la méthode de Runge-Kutta pour résoudre le système
d'équations.
d--------------------depVar
- = Expr(Var, VarDép)
d Var
avec VarDép(Var0)=Var0Dép pour l'intervalle [Var0,MaxVar].
Retourne une matrice dont la première ligne définit les valeurs de
sortie de Var, définies à partir de IncVar. La deuxième ligne définit la
valeur du premier composant de la solution aux valeurs Var
correspondantes, etc.
Équation différentielle :
y'=0.001*y*(100-y) et y(0)=10
£,
¡ et ¢ pour déplacer le
Pour afficher le résultat entier, appuyez sur
puis utilisez les touches
curseur.
Même équation avec TolErr définie à 1.E• 6
Expr représente la partie droite qui définit l'équation différentielle.
SystèmeExpr correspond aux côtés droits qui définissent le système
des équations différentielles (en fonction de l'ordre des variables
dépendantes de la ListeVarDép).
Comparez le résultat ci-dessus avec la solution exacte CAS
obtenue en utilisant deSolve() et seqGen() :
ListeExpr est la liste des côtés droits qui définissent le système des
équations différentielles (en fonction de l'ordre des variables
dépendantes de la ListeVarDép).
Var est la variable indépendante.
ListeVarDép est la liste des variables dépendantes.
{Var0, MaxVar} est une liste à deux éléments qui indique la fonction à
intégrer, comprise entre Var0 et MaxVar.
ListeVar0Dép est la liste des valeurs initiales pour les variables
dépendantes.
Si IncVar est un nombre différent de zéro, signe(IncVar) =
signe(MaxVar-Var0) et les solutions sont retournées pour
Var0+i*·IncVar pour tout i=0,1,2,… tel que Var0+i·IncVar soit dans
[var0,MaxVar] (il est possible qu'il n'existe pas de solution en
MaxVar).
Système d'équations :
avec y1(0)=2 et y2(0)=5
Si IncVar est un nombre égal à zéro, les solutions sont retournées aux
valeurs Var "Runge-Kutta".
TolErr correspond à la tolérance d'erreur (valeur par défaut 0,001).
root()
Catalogue >
⇒ root
root(Expr1, Expr2) ⇒ root
root(Expr)
root(Expr) affiche la racine carrée de Expr.
root(Expr1, Expr2) affiche la racine Expr2 de Expr1. Expr1 peut
être un nombre réel ou une constant complexe en virgule flottante, un
entier ou une constante rationnelle complexe, ou une expression
symbolique générale.
Remarque : voir aussi Modèle Racine n-ième, page 1.
104
Guide de référence TI-Nspire™ CAS
rotate()
Catalogue >
rotate(Entier1[,nbreRotations])
⇒ entier
En mode base Bin :
Permute les bits de la représentation binaire d'un entier. Entier1 peut
être un entier de n'importe quelle base ; il est automatiquement
converti sous forme binaire (64 bits) signée. Si Entier1 est trop
important pour être codé sur 32 bits, il est ramené à l'aide d'une
congruence dans la plage appropriée. Pour de plus amples
Pour afficher le résultat entier, appuyez sur
informations, voir 4Base2, page 13.
touches
Si nbreRotations est positif, la permutation circulaire s'effectue vers
la gauche. Si nbreRotations est négatif, la permutation circulaire
s'effectue vers la droite. La valeur par défaut est L1 (permutation
circulation de un bit vers la droite).
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
En mode base Hex :
Par exemple, dans une permutation circulaire vers la droite :
Tous les bits permutent vers la droite.
Important : pour une entrée binaire ou hexadécimale, vous
devez utiliser respectivement le préfixe 0b ou 0h (zéro, pas la
lettre O).
0b00000000000001111010110000110101
Le bit le plus à droite passe à la position la plus à gauche.
donne :
0b10000000000000111101011000011010
Le résultat est affiché selon le mode Base utilisé.
rotate(Liste1[,nbreRotations])
⇒ liste
En mode base Dec :
Donne une copie de Liste1 dont les éléments ont été permutés
circulairement vers la gauche ou vers la droite de nbreRotations
éléments. Ne modifie en rien Liste1.
Si nbreRotations est positif, la permutation circulaire s'effectue vers
la gauche. Si nbreRotations est négatif, la permutation circulaire
s'effectue vers la droite. La valeur par défaut est L1 (permutation
circulation de un bit vers la droite).
rotate(Chaîne1[,nbreRotations])
⇒ chaîne
Donne une copie de Chaîne1 dont les caractères ont été permutés
circulairement vers la gauche ou vers la droite de nbreRotations
caractères. Ne modifie en rien Chaîne1.
Si nbreRotations est positif, la permutation circulaire s'effectue vers
la gauche. Si nbreRotations est négatif, la permutation circulaire
s'effectue vers la droite. La valeur par défaut est L1 (permutation
circulaire d'un caractère vers la droite).
round()
round( Expr1[, n])
Catalogue >
⇒ expression
Arrondit l'argument au nombre de chiffres n spécifié après la virgule.
n doit être un entier compris entre 0 et 12. Si n est omis, arrondit
l'argument à 12 chiffres significatifs.
Remarque : le mode d'affichage des chiffres peut affecter le
résultat affiché.
round( Liste1[, n])
⇒ liste
Donne la liste des éléments arrondis au nombre de chiffres n spécifié.
round( Matrice1[, n])
⇒ matrice
Donne la matrice des éléments arrondis au nombre de chiffres n
spécifié.
Guide de référence TI-Nspire™ CAS
105
rowAdd()
Catalogue >
rowAdd( Matrice1, IndexL1, IndexL2)
⇒ matrice
Donne une copie de Matrice1 obtenue en remplaçant dans la matrice
la ligne IndexL2 par la somme des lignes IndexL1 et IndexL2.
rowDim()
rowDim( Matrice)
Catalogue >
⇒ expression
Donne le nombre de lignes de Matrice.
Remarque : voir aussi colDim(), page 19.
rowNorm()
rowNorm( Matrice)
Catalogue >
⇒ expression
Donne le maximum des sommes des valeurs absolues des éléments
de chaque ligne de Matrice.
Remarque : la matrice utilisée ne doit contenir que des éléments
numériques. Voir aussi colNorm(), page 19.
rowSwap()
Catalogue >
rowSwap( Matrice1, IndexL1, IndexL2)
⇒ matrice
Donne la matrice Matrice1 obtenue en échangeant les lignes
IndexL1 et IndexL2.
rref()
Catalogue >
rref(Matrice1[, Tol])
⇒ matrice
Donne la réduite de Gauss-Jordan de Matrice1.
106
Guide de référence TI-Nspire™ CAS
rref()
Catalogue >
L'argument facultatif Tol permet de considérer comme nul tout
élément de la matrice dont la valeur absolue est inférieure à Tol. Cet
argument n'est utilisé que si la matrice contient des nombres en
virgule flottante et ne contient pas de variables symbolique sans
valeur affectée. Dans le cas contraire, Tol est ignoré.
•
Si vous utilisez
/· ou définissez le mode Auto ou
Approché (Approximate) sur Approché (Approximate), les
•
calculs sont exécutés en virgule flottante.
Si Tol est omis ou inutilisé, la tolérance par défaut est calculée
comme suit :
5EL14 ·max(dim(Matrice1)) ·rowNorm(Matrice1)
Remarque : Voir aussi ref(), page 101.
S
sec()
sec(Expr1)
sec(Liste1)
⇒ expression
⇒ liste
Touche
μ
Touche
μ
En mode Angle en degrés :
Affiche la sécante de Expr1 ou retourne la liste des sécantes des
éléments de Liste1.
Remarque : l'argument est interprété comme la mesure d'un angle
en degrés, en grades ou en radians, suivant le mode angulaire en
cours d'utilisation. Vous pouvez utiliser ¡, G ou R pour préciser l'unité
employée temporairement pour le calcul.
sec /()
sec/(Expr1)
sec/(Liste1)
⇒ expression
⇒ liste
En mode Angle en degrés :
Affiche l'angle dont la sécante correspond à Expr1 ou retourne la
liste des arcs sécantes des éléments de Liste1.
En mode Angle en grades :
Remarque : donne le résultat en degrés, en grades ou en radians,
suivant le mode angulaire utilisé.
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant arcsec(...).
sech()
sech(Expr1)
sech(Liste1)
En mode Angle en radians :
Catalogue >
⇒ expression
⇒ liste
Affiche la sécante hyperbolique de Expr1 ou retourne la liste des
sécantes hyperboliques des éléments de liste1.
Guide de référence TI-Nspire™ CAS
107
sech/()
Catalogue >
⇒ expression
sech/ (Liste1) ⇒ liste
sech /(Expr1)
En mode Angle en radians et en mode Format complexe
Rectangulaire :
Donne l'argument sécante hyperbolique de Expr1 ou retourne la liste
des arguments sécantes hyperboliques des éléments de Liste1.
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant arcsech(...).
seq()
Catalogue >
seq(Expr, Var, Début, Fin[, Incrément])
⇒ liste
Incrémente la valeur de Var comprise entre Début et Fin en fonction
de l'incrément (Inc) spécifié et affiche le résultat sous forme de liste
Le contenu initial de Var est conservé après l'application de seq().
La valeur par défaut de Inc
= 1.
Appuyez sur Ctrl+Entrée
“+Enter) pour évaluer :
108
Guide de référence TI-Nspire™ CAS
/· (Macintosh®:
seqGen()
Catalogue >
seqGen(Expr, Var, VarDép, {Var0, MaxVar}[, ListeValeursInit
[, IncVar [, ValeurMax]]]) ⇒ liste
Génère les cinq premières valeurs de la suite u(n) = u(n-1)2/2,
avec u(1)=2 et IncVar=1.
Génère une liste de valeurs pour la suite VarDép(Var)=Expr comme
suit : Incrémente la valeur de la variable indépendante Var de Var0 à
MaxVar par pas de IncVar, calcule VarDép(Var) pour les valeurs
correspondantes de Var en utilisant Expr et ListeValeursInit, puis
retourne le résultat sous forme de liste.
seqGen(ListeOuSystèmeExpr, Var, ListeVarDép, {Var0, MaxVar}
[, MatriceValeursInit [, IncVar [, ValeurMax]]]) ⇒ matrice
Génère une matrice de valeurs pour un système (ou une liste) de
suites ListeVarDép(Var)=ListeOuSystèmeExpr comme suit :
Incrémente la valeur de la variable indépendante Var de Var0 à
MaxVar par pas de IncVar, calcule ListeVarDép(Var) pour les
valeurs correspondantes de Var en utilisant ListeOuSystèmeExpr et
MatriceValeursInit, puis retourne le résultat sous forme de matrice.
Exemple avec Var0=2 :
Le contenu initial de Var est conservé après l'application de
seqGen().
La valeur par défaut de IncVar est 1.
Exemple dans lequel la valeur initiale est symbolique :
Système de deux suites :
Remarque : L'élément vide (_) dans la matrice de valeurs
initiales ci-dessus est utilisé pour indiquer que la valeur initiale
de u1(n) est calculée en utilisant la suite explicite u1(n)=1/n.
seqn()
Catalogue >
Génère les cinq premières valeurs de la suite u(n) = u(n-1)/2,
avec u(1)=2.
seqn(Expr(u, n [, ListeValeursInit[, nMax
[, ValeurMax]]]) ⇒ liste
Génère une liste de valeurs pour la suite u(n)=Expr(u, n) comme suit
: Incrémente n de 1 à nMax par incrément de 1, calcule u(n) pour les
valeurs correspondantes de n en utilisant Expr(u, n) et
ListeValeursInit, puis retourne le résultat sous forme de liste.
seqn(Expr(n [, nMax [, ValeurMax]])
⇒
liste
Génère une liste de valeurs pour la suite u(n)=Expr(n) comme suit :
Incrémente n de 1 à nMax par incrément de 1, calcule u(n) pour les
valeurs correspondantes de n en utilisant Expr(n), puis retourne le
résultat sous forme de liste.
Si nMax n'a pas été défini, il prend la valeur 2500.
Si nMax=0 n'a pas été défini, nMax prend la valeur 2500.
Remarque : seqn() appel seqGen( ) avec n0=1 et Incn =1
Guide de référence TI-Nspire™ CAS
109
series()
Catalogue >
⇒ expression
series(Expr1, Var, Ordre [, Point]) | Var>Point ⇒ expression
series(Expr1, Var, Ordre [, Point]) | Var<Point ⇒ expression
series(Expr1, Var, Ordre [, Point])
Donne un développement en série généralisé, tronqué, de Expr1 en
Point jusqu'au degré Ordre. Ordre peut être un nombre rationnel
quelconque. Les puissances de (Var N Point) peuvent avoir des
exposants négatifs et/ou fractionnaires. Les coefficients de ces
puissances peuvent inclure les logarithmes de (Var N Point) et
d'autres fonctions de Var dominés par toutes les puissances de (Var
N Point) ayant le même signe d'exposant.
La valeur par défaut de Point est 0. Point peut être ˆ ou Nˆ,
auxquels cas le développement s'effectue jusqu'au degré Ordre en 1/
(Var N Point).
series(...) donne “series(...)” s'il ne parvient pas à déterminer la
représentation, comme pour les singularités essentielles sin(1/z) en
z=0, eN1/z en z=0 ou ez en z = ˆ ou Nˆ.
Si la série ou une de ses dérivées présente une discontinuité en Point,
le résultat peut contenir des sous-expressions de type sign(…) ou
abs(…) pour une variable réelle ou (-1)floor(…angle(…)…) pour une
variable complexe, qui se termine par « _ ». Si vous voulez utiliser la
série uniquement pour des valeurs supérieures ou inférieures à Point,
vous devez ajouter l'élément approprié « | Var > Point », « | Var <
Point », « | » « Var | Point » ou « Var { Point » pour obtenir un
résultat simplifié.
series() peut donner des approximations symboliques pour des
intégrales indéfinies et définies pour lesquelles autrement, il n'est pas
possible d'obtenir des solutions symboliques.
series() est appliqué à chaque élément d'une liste ou d'une matrice
passée en 1er argument.
series() est une version généralisée de taylor().
Comme illustré dans l'exemple ci-contre, le développement des
routines de calcul du résultat donnée par series(...) peut réorganiser
l'ordre des termes de sorte que le terme dominant ne soit pas le terme
le plus à gauche.
Remarque : voir aussi dominantTerm(), page 40.
110
Guide de référence TI-Nspire™ CAS
setMode()
Catalogue >
setMode(EntierNomMode, EntierRéglage)
setMode(liste) ⇒ liste des entiers
⇒ entier
Accessible uniquement dans une fonction ou un programme.
Affiche la valeur approchée de p à l'aide du réglage par défaut de
Afficher chiffres, puis affiche p avec le réglage Fixe 2. Vérifiez que la
valeur par défaut est bien restaurée après l'exécution du programme.
setMode(EntierNomMode, EntierRéglage) règle
provisoirement le mode EntierNomMode sur le nouveau réglage
EntierRéglage et affiche un entier correspondant au réglage
d'origine de ce mode. Le changement est limité à la durée
d'exécution du programme/de la fonction.
EntierNomMode indique le mode que vous souhaitez régler. Il
doit s'agir d'un des entiers du mode du tableau ci-dessous.
EntierRéglage indique le nouveau réglage pour ce mode. Il doit
s'agir de l'un des entiers de réglage indiqués ci-dessous pour le
mode spécifique que vous configurez.
setMode(liste) permet de modifier plusieurs réglages. liste
contient les paires d'entiers de mode et d'entiers de réglage.
setMode(liste) affiche une liste dont les paires d'entiers
représentent les modes et réglages d'origine.
Si vous avez enregistré tous les réglages du mode avec
& var, setMode(var) permet de restaurer ces
réglages jusqu'à fermeture du programme ou de la fonction. Voir
getMode(), page 55.
getMode(0)
Remarque : Les réglages de mode actuels sont transférés dans
les sous-programmes appelés. Si un sous-programme change un
quelconque réglage du mode, le changement sera perdu dès le
retour au programme appelant.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer
des définitions sur plusieurs lignes en appuyant sur
@ à la place
·
de
à chaque fin de ligne. Sur le clavier de l'ordinateur,
maintenez enfoncée la touche Alt tout en appuyant sur Entrée
(Enter).
Nom du
mode
Entier
du
mode
Afficher chiffres
1
1=Flottant, 2=Flottant 1, 3=Flottant 2, 4=Flottant 3, 5=Flottant 4, 6=Flottant 5,
7=Flottant 6, 8=Flottant 7, 9=Flottant 8, 10=Flottant 9, 11=Flottant 10, 12=Flottant 11,
13=Flottant 12, 14=Fixe 0, 15=Fixe 1, 16=Fixe 2, 17=Fixe 3, 18=Fixe 4, 19=Fixe 5,
20=Fixe 6, 21=Fixe 7, 22=Fixe 8, 23=Fixe 9, 24=Fixe 10, 25=Fixe 11, 26=Fixe 12
Angle
2
1=Radian, 2=Degré, 3=Grade
Format Exponentiel
3
1=Normal, 2=Scientifique, 3=Ingénieur
Réel ou Complexe
4
1=Réel, 2=Rectangulaire, 3=Polaire
Auto ou Approché
5
1=Auto, 2=Approché, 3=Exact
Format Vecteur
6
1=Rectangulaire, 2=Cylindrique, 3=Sphérique
Base
7
1=Décimale, 2=Hexadécimale, 3=Binaire
Système d'unités
8
1=SI, 2=Ang/US
Entiers de réglage
Guide de référence TI-Nspire™ CAS
111
shift()
Catalogue >
shift(Entier1[,nbreDécal])
⇒ entier
Décale les bits de la représentation binaire d'un entier. Entier1 peut
être un entier de n'importe quelle base ; il est automatiquement
converti sous forme binaire (64 bits) signée. Si Entier1 est trop
important pour être codé sur 32 bits, il est ramené à l'aide d'une
congruence dans la plage appropriée. Pour de plus amples
informations, voir 4Base2, page 13.
Si nbreDécal est positif, le décalage s'effectue vers la gauche. Si
nbreDécal est négatif, le décalage s'effectue vers la droite. La valeur
par défaut est L1 (décalage d'un bit vers la droite).
En mode base Bin :
En mode base Hex :
Dans un décalage vers la droite, le dernier bit est éliminé et 0 ou 1 est
inséré à gauche selon le premier bit. Dans un décalage vers la gauche,
le premier bit est éliminé et 0 est inséré comme dernier bit.
Important : pour une entrée binaire ou hexadécimale, vous
devez utiliser respectivement le préfixe 0b ou 0h (zéro, pas la
Par exemple, dans un décalage vers la droite :
lettre O).
Tous les bits sont décalés vers la droite.
0b0000000000000111101011000011010
Insère 0 si le premier bit est un 0
ou 1 si ce bit est un 1.
donne :
0b00000000000000111101011000011010
Le résultat est affiché selon le mode Base utilisé. Les zéros de tête ne
sont pas affichés.
shift(Liste1 [,nbreDécal])
⇒ liste
En mode base Dec :
Donne une copie de Liste1 dont les éléments ont été décalés vers la
gauche ou vers la droite de nbreDécal éléments. Ne modifie en rien
Liste1.
Si nbreDécal est positif, le décalage s'effectue vers la gauche. Si
nbreDécal est négatif, le décalage s'effectue vers la droite. La valeur
par défaut est L1 (décalage d'un élément vers la droite).
Les éléments introduits au début ou à la fin de liste par l'opération de
décalage sont remplacés par undef (non défini).
shift(Chaîne1 [,nbreDécal])
⇒ chaîne
Donne une copie de Chaîne1 dont les caractères ont été décalés vers
la gauche ou vers la droite de nbreDécal caractères. Ne modifie en
rien Chaîne1.
Si nbreDécal est positif, le décalage s'effectue vers la gauche. Si
nbreDécal est négatif, le décalage s'effectue vers la droite. La valeur
par défaut est L1 (décalage d'un caractère vers la droite).
Les caractères introduits au début ou à la fin de Chaîne par
l'opération de décalage sont remplacés par un espace.
112
Guide de référence TI-Nspire™ CAS
sign()
Catalogue >
sign(Expr1) ⇒ expression
sign(Liste1) ⇒ liste
sign(Matrice1) ⇒ matrice
Pour une Expr1 réelle ou complexe, donne Expr1/abs(Expr1) si
Expr1ƒ 0.
En mode Format complexe Réel :
Donne 1 si l'expression Expression1 est positive.
Donne L1 si l'expression Expr1 est négative.
Lsign(0) donne L1 en mode Format complexe Réel ; sinon, donne luimême.
sign(0) représente le cercle d'unité dans le domaine complexe.
Dans le cas d'une liste ou d'une matrice, donne les signes de tous les
éléments.
simult()
simult(matriceCoeff, vecteurConst[, Tol])
Catalogue >
⇒ matrice
Donne un vecteur colonne contenant les solutions d'un système
d'équations.
Résolution de x et y :
x + 2y = 1
3x + 4y = L1
Remarque : voir aussi linSolve(), page 69.
matriceCoeff doit être une matrice carrée qui contient les coefficients
des équations.
La solution est x=L3 et y=2.
vecteurConst doit avoir le même nombre de lignes (même dimension)
Résolution :
que matriceCoeff et contenir le second membre.
ax + by = 1
L'argument facultatif Tol permet de considérer comme nul tout
cx + dy = 2
élément de la matrice dont la valeur absolue est inférieure à Tol. Cet
argument n'est utilisé que si la matrice contient des nombres en
virgule flottante et ne contient pas de variables symbolique sans
valeur affectée. Dans le cas contraire, Tol est ignoré.
•
•
Si vous réglez le mode Auto ou Approché (Approximate)
sur Approché (Approximate), les calculs sont exécutés en virgule
flottante.
Si Tol est omis ou inutilisé, la tolérance par défaut est calculée
comme suit :
5EL14 ·max(dim(matriceCoeff)) ·rowNorm(matriceCoeff)
Résolution :
⇒ matrice
x + 2y = 1
Permet de résoudre plusieurs systèmes d'équations, ayant les mêmes 3x + 4y = L1
coefficients mais des seconds membres différents.
simult(matriceCoeff, matriceConst[, Tol])
Chaque colonne de matriceConst représente le second membre d'un x + 2y = 2
système d'équations. Chaque colonne de la matrice obtenue contient 3x + 4y = L3
la solution du système correspondant.
Pour le premier système, x=L3 et y=2. Pour le deuxième
système, x=L7 et y=9/2.
Guide de référence TI-Nspire™ CAS
113
4sin
Catalogue >
Expr 4sin
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @>sin.
Exprime Expr en sinus. Il s'agit d'un opérateur de conversion utilisé
pour l'affichage. Cet opérateur ne peut être utilisé qu'à la fin d'une
ligne.
4sin réduit toutes les puissances modulo
sin(...) 1Nsin(...)^2
de sorte que les puissances de sin(...) restantes ont des exposants
dans (0, 2). Le résultat ne contient donc pas cos(...) si et seulement si
cos(...) dans l'expression donnée s'applique uniquement aux
puissances paires.
Remarque : L'opérateur de conversion n'est pas autorisé en mode
Angle Degré ou Grade. Avant de l'utiliser, assurez-vous d'avoir défini
le mode Angle Radian et de l'absence de références explicites à des
angles en degrés ou en grades dans Expr.
sin()
Touche
sin(Expr1)
sin(Liste1)
⇒ expression
⇒ liste
En mode Angle en degrés :
sin(Expr1) donne le sinus de l'argument sous forme d'expression.
sin(Liste1) donne la liste des sinus des éléments de Liste1.
Remarque : l'argument est interprété comme mesure d'angle en
degrés, en grades ou en radians, suivant le mode angulaire
sélectionné. Vous pouvez utiliser ¡,G ou R pour ignorer
temporairement le mode angulaire sélectionné.
En mode Angle en grades :
En mode Angle en radians :
sin(matriceCarrée1)
⇒ matriceCarrée
En mode Angle en radians :
Donne le sinus de la matrice matriceCarrée1. Ce calcul est différent
du calcul du sinus de chaque élément. Pour plus d'informations sur la
méthode de calcul, reportez-vous à cos().
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
114
Guide de référence TI-Nspire™ CAS
μ
sin/()
sin/(Expr1)
sin/(Liste1)
Touche
⇒ expression
⇒ liste
μ
En mode Angle en degrés :
sin/(Expr1) donne l'arc sinus de Expr1 sous forme d'expression.
sin/(List1) donne la liste des arcs sinus des éléments de Liste1.
En mode Angle en grades :
Remarque : donne le résultat en degrés, en grades ou en radians,
suivant le mode angulaire utilisé.
Remarque : vous pouvez insérer cette fonction à partir du clavier
En mode Angle en radians :
en entrant arcsin(...).
sin/(matriceCarrée1)
⇒ matriceCarrée
Donne l'argument arc sinus de la matrice matriceCarrée1. Ce calcul
est différent du calcul de l'argument arc sinus de chaque élément.
Pour plus d'informations sur la méthode de calcul, reportez-vous à
cos().
En mode Angle en radians et en mode Format complexe
Rectangulaire :
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
Pour afficher le résultat entier, appuyez sur
touches
sinh()
sinh(Expr1)
sinh(Liste1)
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
Catalogue >
⇒ expression
⇒ liste
sinh (Expr1) donne le sinus hyperbolique de l'argument sous forme
d'expression.
sinh (Liste1) donne la liste des sinus hyperboliques des éléments de
Liste1.
sinh(matriceCarrée1)
⇒ matriceCarrée
En mode Angle en radians :
Donne le sinus hyperbolique de la matrice matriceCarrée1. Ce calcul
est différent du calcul du sinus hyperbolique de chaque élément. Pour
plus d'informations sur la méthode de calcul, reportez-vous à cos().
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
sinh /()
sinh/(Expr1)
sinh/(Liste1)
Catalogue >
⇒ expression
⇒ liste
sinh/(Expr1) donne l'argument sinus hyperbolique de l'argument
sous forme d'expression.
sinh/(Liste1) donne la liste des arguments sinus hyperboliques des
éléments de Liste1.
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant arcsinh(...).
Guide de référence TI-Nspire™ CAS
115
sinh /()
Catalogue >
sinh/(matriceCarrée1)
⇒ matriceCarrée
En mode Angle en radians :
Donne l'argument sinus hyperbolique de la matrice matriceCarrée1.
Ce calcul est différent du calcul de l'argument sinus hyperbolique de
chaque élément. Pour plus d'informations sur la méthode de calcul,
reportez-vous à cos().
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
SinReg
Catalogue >
SinReg X, Y [, [Itérations],[ Période] [, Catégorie, Inclure] ]
Effectue l'ajustement sinusoïdal sur les listes X et Y. Un récapitulatif
du résultat est stocké dans la variable stat.results. (Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes, à
l'exception de Inclure.
X et Y sont des listes de variables indépendantes et dépendantes.
Itérations spécifie le nombre maximum d'itérations (1 à 16) utilisées
lors de ce calcul. S'il est omis, la valeur par défaut est 8. On obtient
généralement une meilleure précision en choisissant une valeur
élevée, mais cela augmente également le temps de calcul, et vice
versa.
Période spécifie une période estimée. S'il est omis, la différence entre
les valeurs de X doit être égale et en ordre séquentiel. Si vous
spécifiez la Période, les différences entre les valeurs de x peuvent
être inégales.
Catégorie est une liste de codes de catégories pour les couples X et Y
correspondants..
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Le résultat obtenu avec SinReg est toujours exprimé en radians,
indépendamment du mode Angle sélectionné.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.RegEqn
Équation d'ajustement : a·sin(bx+c)+d
stat.a, stat.b, stat.c,
stat.d
Coefficients d'ajustement
stat.Resid
Valeurs résiduelles de l'ajustement
stat.XReg
Liste des points de données de la liste Liste X modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.YReg
Liste des points de données de la liste Liste Y modifiée, actuellement utilisée dans l'ajustement basé sur
les restrictions de Fréq, Liste de catégories et Inclure les catégories
stat.FreqReg
Liste des fréquences correspondant à stat.XReg et stat.YReg
116
Guide de référence TI-Nspire™ CAS
solve()
Catalogue >
solve(Équation, Var) ⇒ expression booléenne
solve(Équation, Var=Init) ⇒ expression booléenne
solve(Inéquation, Var) ⇒ expression booléenne
Résout dans R une équation ou une inéquation en Var. L'objectif est
de trouver toutes les solutions possibles. Toutefois, il peut arriver
avec certaines équations ou inéquations que le nombre de solutions
soit infini.
Les solutions peuvent ne pas être des solutions réelles finies pour
certaines valeurs des paramètres.
Avec le réglage Auto du mode Auto ou Approché
(Approximate), l'objectif est de trouver des solutions exactes
quand elles sont concises et de compléter l'opération par des
recherches itératives de calcul approché lorsque des solutions exactes
ne peuvent pas être trouvées.
En raison de l'annulation par défaut du plus grand commun diviseur
du numérateur et du dénominateur des rapports, les solutions
trouvées peuvent ne pas être valides.
Pour les inéquations de type |, {, < ou >, il est peut probable de
trouver des solutions explicites, sauf si l'inéquation est linéaire et ne
contient que Var.
Avec le réglage Exact du mode Auto ou Approché
(Approximate), les portions qui ne peuvent pas être résolues sont
données sous forme d'équation ou d'inéquation implicite.
Utilisez l'opérateur « | » pour limiter l'intervalle de la solution et/ou
les autres variables rencontrées dans l'équation ou l'inéquation.
Lorsqu'une solution est trouvée dans un intervalle, vous pouvez
utiliser les opérateurs d'inéquation pour exclure cet intervalle des
recherches suivantes.
En mode Angle en radians :
false est affiché si aucune solution réelle n'est trouvée. true est
affiché si solve() parvient à déterminer que tout réel est solution de
l'équation ou de l'inéquation.
Dans la mesure où solve() donne toujours un résultat booléen, vous
pouvez utiliser « and », « or » et « not » pour combiner les résultats
de solve() entre eux ou avec d'autres expressions booléennes.
Les solutions peuvent contenir une nouvelle constante non définie de En mode Angle en radians :
type nj, où j correspond à un entier compris entre 1 et 255. Ces
variables désignent un entier arbitraire.
En mode Réel, les puissances fractionnaires possédant un
dénominateur impair font uniquement référence à la branche
principale. Sinon, les expressions à plusieurs branches, telles que les
puissances fractionnaires, les logarithmes et les fonctions
trigonométriques inverses font uniquement référence à la branche
principale. Par conséquent, solve() donne uniquement des solutions
correspondant à cette branche réelle ou principale.
Remarque : voir aussi cSolve(), cZeros(), nSolve() et zeros().
Guide de référence TI-Nspire™ CAS
117
solve()
Catalogue >
solve(Éqn1 and Éqn2 [and … ], VarOuInit1,
VarOuInit2 [, … ]) ⇒ expression booléenne
solve(SystèmeÉq, VarOuInit1,
VarOuInit2 [, … ]) ⇒ expression booléenne
solve({Eqn1, Eqn2 [,...]} {VarOuInit1, VarOuInit2 [, … ]})
⇒ expression booléenne
Donne les solutions réelles possibles d'un système d'équations
algébriques, où chaque VarOuInit définit une variable du système à
résoudre.
Vous pouvez séparer les équations par l'opérateur and ou entrer un
système d'équations SystèmÉq en utilisant un modèle du Catalogue.
Le nombre d'arguments VarOuInit doit correspondre au nombre
d'équations. Vous pouvez également spécifier une condition initiale
pour les variables. Chaque VarOuInit doit utiliser le format suivant :
variable
– ou –
variable = nombre réel ou non réel
Par exemple, x est autorisé, de même que x=3.
Si toutes les équations sont polynomiales et si vous NE spécifiez PAS
de condition initiale, solve() utilise la méthode d'élimination lexicale
Gröbner/Buchberger pour tenter de trouver toutes les solutions
réelles.
Par exemple, si vous avez un cercle de rayon r centré à l'origine et un
autre cercle de rayon r centré, au point où le premier cercle coupe
l'axe des x positifs. Utilisez solve() pour trouver les intersections.
Comme l'illustre r dans l'exemple ci-contre, les systèmes d'équations
polynomiales peuvent avoir des variables auxquelles on peut affecter
par la suite des valeurs numériques.
Vous pouvez également utiliser des variables qui n'apparaissent pas
dans les équations. Par exemple, vous pouvez utiliser z comme
variable pour développer l'exemple précédent et avoir deux cylindres
parallèles sécants de rayon r.
La résolution du problème montre comment les solutions peuvent
contenir des constantes arbitraires de type ck, où k est un suffixe
entier compris entre 1 et 255.
Pour les systèmes d'équations polynomiales, le temps de calcul et
l'utilisation de la mémoire peuvent considérablement varier en
fonction de l'ordre dans lequel les inconnues sont spécifiées. Si votre
choix initial ne vous satisfait pas pour ces raisons, vous pouvez
modifier l'ordre des variables dans les équations et/ou la liste des
variables VarOuInit.
Pour afficher le résultat entier, appuyez sur
touches
Si vous choisissez de ne pas spécifier de condition et s'il l'une des
équations n'est pas polynomiale dans l'une des variables, mais que
toutes les équations sont linéaires par rapport à toutes les variables,
solve() utilise l'élimination gaussienne pour tenter de trouver toutes
les solutions réelles.
118
Guide de référence TI-Nspire™ CAS
¡ et ¢ pour déplacer le curseur.
£, puis utilisez les
solve()
Catalogue >
Si un système d'équations n'est ni polynomial par rapport à toutes ses
variables ni linéaire par rapport aux inconnues, solve() cherche au
moins une solution en utilisant une méthode itérative approchée.
Pour cela, le nombre d'inconnues doit être égal au nombre
d'équations et toutes les autres variables contenues dans les
Pour afficher le résultat entier, appuyez sur
équations doivent pouvoir être évaluées à des nombres.
touches
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
Chaque variable du système commence à sa valeur supposée, si elle
existe ; sinon, la valeur de départ est 0.0.
Utilisez des valeurs initiales pour rechercher des solutions
supplémentaires, une par une. Pour assurer une convergence
correcte, une valeur initiale doit être relativement proche de la
solution.
SortA
Catalogue >
SortA Liste1[, Liste2] [, Liste3] ...
SortA Vecteur1[, Vecteur2] [, Vecteur3] ...
Trie les éléments du premier argument en ordre croissant.
Si d'autres arguments sont présents, trie les éléments de chacun
d'entre eux de sorte que leur nouvelle position corresponde aux
nouvelles positions des éléments dans le premier argument.
Tous les arguments doivent être des noms de listes ou de vecteurs et
tous doivent être de même dimension.
Les éléments vides compris dans le premier argument ont été
déplacés au bas de la liste. Pour plus d'informations concernant les
éléments vides, reportez-vous à la page 164.
SortD
Catalogue >
SortD Liste1[, Liste2] [, Liste3] ...
SortD Vecteur1[,Vecteur2] [,Vecteur3] ...
Identique à SortA, mais SortD trie les éléments en ordre décroissant.
Les éléments vides compris dans le premier argument ont été
déplacés au bas de la liste. Pour plus d'informations concernant les
éléments vides, reportez-vous à la page 164.
Guide de référence TI-Nspire™ CAS
119
4Sphere
Catalogue >
Vecteur 4Sphere
Appuyez sur Ctrl+Entrée
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
“+Enter) pour évaluer :
/· (Macintosh®:
l'ordinateur en entrant @>Sphere.
Affiche le vecteur ligne ou colonne en coordonnées sphériques
[r ±q ±f].
Vecteur doit être un vecteur ligne ou colonne de dimension 3.
Remarque : 4Sphere est uniquement une instruction d'affichage et
non une fonction de conversion. On ne peut l'utiliser qu'à la fin d'une
ligne.
Appuyez sur Ctrl+Entrée
“+Enter) pour évaluer :
Appuyez sur
/· (Macintosh®:
·
Z
(ρ,θ,φ)
φ
ρ
Y
θ
X
sqrt()
Catalogue >
sqrt(Expr1)
sqrt(Liste1)
⇒ expression
⇒ liste
Donne la racine carrée de l'argument.
Dans le cas d'une liste, donne la liste des racines carrées des éléments
de Liste1.
Remarque : voir aussi Modèle Racine carrée, page 1.
120
Guide de référence TI-Nspire™ CAS
stat.results
Catalogue >
stat.results
Affiche le résultat d'un calcul statistique.
Les résultats sont affichés sous forme d'ensemble de paires nomvaleur. Les noms spécifiques affichés varient suivant la fonction ou
commande statistique la plus récemment calculée ou exécutée.
Vous pouvez copier un nom ou une valeur et la coller à d'autres
emplacements.
Remarque : ne définissez pas de variables dont le nom est
identique à celles utilisées dans le cadre de l'analyse statistique. Dans
certains cas, cela peut générer une erreur. Les noms de variables
utilisés pour l'analyse statistique sont répertoriés dans le tableau cidessous.
stat.a
stat.AdjR²
stat.b
stat.b0
stat.b1
stat.b2
stat.b3
stat.b4
stat.b5
stat.b6
stat.b7
stat.b8
stat.b9
stat.b10
stat.bList
stat.c²
stat.c
stat.CLower
stat.CLowerList
stat.CompList
stat.CompMatrix
stat.CookDist
stat.CUpper
stat.CUpperList
stat.d
stat.dfDenom
stat.dfBlock
stat.dfCol
stat.dfError
stat.dfInteract
stat.dfReg
stat.dfNumer
stat.dfRow
stat.DW
stat.e
stat.ExpMatrix
stat.F
stat.FBlock
stat.Fcol
stat.FInteract
stat.FreqReg
stat.Frow
stat.Leverage
stat.LowerPred
stat.LowerVal
stat.m
stat.MaxX
stat.MaxY
stat.ME
stat.MedianX
stat.MedianY
stat.MEPred
stat.MinX
stat.MinY
stat.MS
stat.MSBlock
stat.MSCol
stat.MSError
stat.MSInteract
stat.MSReg
stat.MSRow
stat.n
stat.Ç
stat.Ç1
stat.Ç2
stat.ÇDiff
stat.PList
stat.PVal
stat.PValBlock
stat.PValCol
stat.PValInteract
stat.PValRow
stat.Q1X
stat.Q1Y
stat.Q3X
stat.Q3Y
stat.r
stat.r²
stat.RegEqn
stat.Resid
stat.ResidTrans
stat.sx
stat.sy
stat.sx1
stat.sx2
stat.Gx
stat.Gx²
stat.Gxy
stat.Gy
stat.Gy²
stat.s
stat.SE
stat.SEList
stat.SEPred
stat.sResid
stat.SEslope
stat.sp
stat.SS
stat.SSBlock
stat.SSCol
stat.SSX
stat.SSY
stat.SSError
stat.SSInteract
stat.SSReg
stat.SSRow
stat.tList
stat.UpperPred
stat.UpperVal
stat.v
stat.v1
stat.v2
stat.vDiff
stat.vList
stat.XReg
stat.XVal
stat.XValList
stat.w
y
y
stat.
stat. List
stat.YReg
Remarque : Chaque fois que l'application Tableur & listes calcule des résultats statistiques, les variables du groupe « stat . » sont
copiées dans un groupe « stat#. », où # est un nombre qui est incrémenté automatiquement. Cela vous permet de conserver les
résultats précédents tout en effectuant plusieurs calculs.
Guide de référence TI-Nspire™ CAS
121
stat.values
Catalogue >
Voir l'exemple donné pour stat.results.
stat.values
Affiche une matrice des valeurs calculées pour la fonction ou
commande statistique la plus récemment calculée ou exécutée.
Contrairement à stat.results, stat.values omet les noms associés
aux valeurs.
Vous pouvez copier une valeur et la coller à d'autres emplacements.
stDevPop()
stDevPop(Liste[, listeFréq])
Catalogue >
⇒ expression
En mode Angle en radians et en modes Auto :
Donne l'écart-type de population des éléments de Liste.
Chaque élément de la liste listeFréq totalise le nombre d'occurrences
de l'élément correspondant de Liste.
Remarque : Liste doit contenir au moins deux éléments. Les
éléments vides sont ignorés. Pour plus d'informations concernant les
éléments vides, reportez-vous à la page 164.
stDevPop(Matrice1[, matriceFréq])
⇒ matrice
Donne un vecteur ligne des écarts-types de population des colonnes
de Matrice1.
Chaque élément de matriceFréq totalise le nombre d'occurrences de
l'élément correspondant de Matrice1.
Remarque : Matrice1 doit contenir au moins deux lignes. Les
éléments vides sont ignorés. Pour plus d'informations concernant les
éléments vides, reportez-vous à la page 164.
stDevSamp()
stDevSamp(Liste[, listeFréq])
Catalogue >
⇒ expression
Donne l'écart-type d'échantillon des éléments de Liste.
Chaque élément de la liste listeFréq totalise le nombre d'occurrences
de l'élément correspondant de Liste.
Remarque : Liste doit contenir au moins deux éléments. Les
éléments vides sont ignorés. Pour plus d'informations concernant les
éléments vides, reportez-vous à la page 164.
stDevSamp(Matrice1[, matriceFréq])
⇒ matrice
Donne un vecteur ligne des écarts-types de population des colonnes
de Matrice1.
Chaque élément de matriceFréq totalise le nombre d'occurrences de
l'élément correspondant de Matrice1.
Remarque : Matrice1 doit contenir au moins deux lignes. Les
éléments vides sont ignorés. Pour plus d'informations concernant les
éléments vides, reportez-vous à la page 164.
122
Guide de référence TI-Nspire™ CAS
Stop
Catalogue >
Stop
Commande de programmation : Ferme le programme.
Stop n'est pas autorisé dans les fonctions.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
définitions sur plusieurs lignes en appuyant sur @ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
Voir & (store), page 162.
Store
string()
string(Expr)
Catalogue >
⇒ chaîne
Simplifie Expr et donne le résultat sous forme de chaîne de
caractères.
subMat()
Catalogue >
subMat(Matrice1[, colDébut] [, colDébut] [, ligneFin] [,
colFin]) ⇒ matrice
Donne la matrice spécifiée, extraite de Matrice1.
Valeurs par défaut : ligneDébut=1, colDébut=1, ligneFin=dernière
ligne, colFin=dernière colonne.
Voir G(), page 155.
Sum (Sigma)
sum()
sum(Liste[, Début[, Fin]])
Catalogue >
⇒ expression
Donne la somme des éléments de Liste.
Début et Fin sont facultatifs. Ils permettent de spécifier une plage
d'éléments.
Tout argument vide génère un résultat vide. Les éléments vides de
Liste sont ignorés. Pour plus d'informations concernant les éléments
vides, reportez-vous à la page 164.
Guide de référence TI-Nspire™ CAS
123
sum()
Catalogue >
sum(Matrice1[, Début[, Fin]])
⇒ matrice
Donne un vecteur ligne contenant les sommes des éléments de
chaque colonne de Matrice1.
Début et Fin sont facultatifs. Ils permettent de spécifier une plage de
colonnes.
Tout argument vide génère un résultat vide. Les éléments vides de
Matrice1 sont ignorés. Pour plus d'informations concernant les
éléments vides, reportez-vous à la page 164.
sumIf()
Catalogue >
sumIf(Liste,Critère[, ListeSommes])
⇒ valeur
Affiche la somme cumulée de tous les éléments dans Liste qui
répondent au critère spécifié. Vous pouvez aussi spécifier une autre
liste, ListeSommes, pour fournir les éléments à cumuler.
Liste peut être une expression, une liste ou une matrice.
ListeSommes, si spécifiée, doit avoir la/les même(s) dimension (s)
que Liste.
Le critère peut être :
•
•
Une valeur, une expression ou une chaîne. Par exemple, 34
cumule uniquement les éléments dans Liste qui donnent la
valeur 34.
Une expression booléenne contenant le symbole ? comme
paramètre substituable à tout élément. Par exemple, ?<10
cumule uniquement les éléments de Liste qui sont inférieurs à
10.
Lorsqu'un élément de Liste répond au critère, il est ajouté à la
somme cumulée. Si vous incluez ListeSommes, c'est l'élément
correspondant dans ListeSommes qui est ajouté à la somme.
Dans l'application Tableur & listes, vous pouvez utiliser une plage de
cellules à la place de Liste et ListeSommes.
Les éléments vides sont ignorés. Pour plus d'informations concernant
les éléments vides, reportez-vous à la page 164.
Remarque : voir également countIf(), page 26.
sumSeq()
system()
system(Eqn1 [, Eqn2 [, Eqn3 [, ...]]])
system(Expr1 [, Expr2 [, Expr3 [, ...]]])
Donne un système d'équations, présenté sous forme de liste. Vous
pouvez également créer un système d'équation en utilisant un
modèle.
Remarque : voir aussi Système d'équations, page 3.
124
Guide de référence TI-Nspire™ CAS
Voir G(), page 155.
Catalogue >
T
T (transposée)
Catalogue >
Matrix1T ⇒ matrice
Donne la transposée de la conjuguée de Matrice1.
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @t.
tan()
tan(Expr1)
tan(Liste1)
Touche
⇒ expression
⇒ liste
μ
En mode Angle en degrés :
tan(Expr1) donne la tangente de l'argument.
tan(List1) donne la liste des tangentes des éléments de Liste1.
Remarque : l'argument est interprété comme mesure d'angle en
degrés, en grades ou en radians, suivant le mode angulaire
sélectionné. Vous pouvez utiliser ¡, G ou Rpour ignorer
temporairement le mode Angle sélectionné.
En mode Angle en grades :
En mode Angle en radians :
tan(matriceMatrice1)
⇒ matriceCarrée
En mode Angle en radians :
Donne la tangente de la matrice matriceCarrée1. Ce calcul est
différent du calcul de la tangente de chaque élément. Pour plus
d'informations sur la méthode de calcul, reportez-vous à cos().
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
Guide de référence TI-Nspire™ CAS
125
tan/()
Touche
tan/(Expr1)
tan/(Liste1)
⇒ expression
⇒ liste
En mode Angle en degrés :
tan/(Expr1) donne l'arc tangente de Expr1.
tan/(List1) donne la liste des arcs tangentes des éléments de Liste1. En mode Angle en grades :
Remarque : donne le résultat en degrés, en grades ou en radians,
suivant le mode angulaire utilisé.
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant arctan(...).
tan/(matriceCarrée1)
⇒ matriceCarrée
En mode Angle en radians :
En mode Angle en radians :
Donne l'arc tangente de la matrice matriceCarrée1. Ce calcul est
différent du calcul de l'arc tangente de chaque élément. Pour plus
d'informations sur la méthode de calcul, reportez-vous à cos().
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
tangentLine()
Catalogue >
⇒ expression
tangentLine(Expr1,Var=Point) ⇒ expression
tangentLine(Expr1,Var,Point)
Donne la tangente de la courbe représentée par Expr1 au point
spécifié par Var=Point.
Assurez-vous de ne pas avoir affecté une valeur à la variable
indépendante. Par exemple, si f1(x):=5 et x:=3, alors
tangentLine(f1(x),x,2) donne « faux ».
tanh()
Catalogue >
tanh(Expr1)
tanh(Liste1)
⇒ expression
⇒ liste
tanh(Expr1) donne la tangente hyperbolique de l'argument.
tanh(Liste1) donne la liste des tangentes hyperboliques des éléments
de Liste1.
tanh(matriceCarrée1)
⇒ matriceCarrée
En mode Angle en radians :
Donne la tangente hyperbolique de la matrice matriceCarrée1. Ce
calcul est différent du calcul de la tangente hyperbolique de chaque
élément. Pour plus d'informations sur la méthode de calcul, reportezvous à cos().
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
126
Guide de référence TI-Nspire™ CAS
μ
tanh /()
tanh/(Expr1)
tanh/(Liste1)
Catalogue >
⇒ expression
⇒ liste
En mode Format complexe Rectangulaire :
tanh/(Expr1) donne l'argument tangente hyperbolique de
l'argument sous forme d'expression.
tanh/(Liste1) donne la liste des arguments tangentes hyperboliques
des éléments de Liste1.
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant arctanh(...).
tanh/(matriceCarrée1)
⇒ matriceCarrée
Donne l'argument tangente hyperbolique de matriceCarrée1. Ce
calcul est différent du calcul de l'argument tangente hyperbolique de
chaque élément. Pour plus d'informations sur la méthode de calcul,
reportez-vous à cos().
En mode Angle en radians et en mode Format complexe
Rectangulaire :
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
Pour afficher le résultat entier, appuyez sur
touches
taylor()
taylor(Expr1, Var, Ordre[, Point])
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
Catalogue >
⇒ expression
Donne le polynôme de Taylor demandé. Le polynôme comprend des
termes non nuls de degrés entiers compris entre zéro et Ordre dans
(Var moins Point). taylor() donne lui-même en l'absence de
développement limité de cet ordre ou si l'opération exige l'utilisation
d'exposants négatifs ou fractionnaires. Utilisez des opérations de
substitution et/ou de multiplication temporaire par une puissance de
(Var moins Point) pour déterminer un développement généralisé.
Par défaut, la valeur de Point est égale à zéro et il s'agit du point de
développement.
Comme illustré dans l'exemple ci-contre, le développement des
routines de calcul du résultat donnée par taylor(...) peut réorganiser
l'ordre des termes de sorte que le terme dominant ne soit pas le terme
le plus à gauche.
tCdf()
Catalogue >
tCdf(LimitInf,LimitSup,df) ⇒ nombre si LimitInf et LimitSup
sont des nombres, liste si LimitInf et LimitSup sont des listes
Calcule la fonction de répartition de la loi de Student-t à df degrés de
liberté entre LimitInf et LimitSup.
Pour P(X { upBound), définissez lowBound = .ˆ.
Guide de référence TI-Nspire™ CAS
127
tCollect()
tCollect(Expr1)
Catalogue >
⇒ expression
Donne une expression dans laquelle les produits et les puissances
entières des sinus et des cosinus sont convertis en une combinaison
linéaire de sinus et de cosinus de multiples d'angles, de sommes
d'angles et de différences d'angles. La transformation convertit les
polynômes trigonométriques en une combinaison linéaire de leurs
harmoniques.
Quelquefois, tCollect() permet d'atteindre vos objectifs lorsque la
simplification trigonométrique n'y parvient pas. tCollect() fait
l'inverse des transformations effectuées par tExpand(). Parfois,
l'application de tExpand() à un résultat de tCollect(), ou vice versa,
permet en deux étapes de simplifier une expression.
tExpand()
tExpand(Expr1)
Catalogue >
⇒ expression
Donne une expression dans laquelle les sinus et les cosinus de
multiples entiers d'angles, de sommes d'angles et de différences
d'angles sont développés. En raison de la présence de l'identité
(sin(x))2+(cos(x))2=1, il existe plusieurs résultats équivalents
possibles. Par conséquent, un résultat peut différer d'un autre résultat
affiché dans d'autres publications.
Quelquefois, tExpand() permet d'atteindre vos objectifs lorsque le
développement trigonométrique n'y parvient pas. tExpand() tend à
faire l'inverse des transformations effectuées par tCollect(). Parfois,
l'application de tCollect() à un résultat de tExpand(), ou vice versa,
permet en deux étapes de simplifier une expression.
Remarque : la conversion en degrés par p/180 peut interférer avec
la capacité de tExpand() de reconnaître les formes pouvant être
développées. Pour de meilleurs résultats, tExpand() doit être utilisé
en mode Angle en radians.
Text
Catalogue >
Text chaîneinvite [, IndicAff]
Commande de programmation : Marque une pause dans l'exécution
du programme et affiche la chaîne de caractères chaîneinvite dans
une boîte de dialogue.
Lorsque l'utilisation sélectionne OK, l'exécution du programme se
poursuit.
L'argument optionnel IndicAff peut correspondre à n'importe quelle
expression.
•
•
Si IndicAff est omis ou a pour valeur 1, le message est ajouté à
l'historique de l'application Calculs.
Si IndicAff a pour valeur 0, le message n'est pas ajouté à
l'historique.
Si le programme nécessite une réponse saisie par l'utilisateur, voir
Request, page 102 ou RequestStr, page 103.
Définissez un programme qui marque une pause afin d'afficher
cinq nombres aléatoires dans une boîte de dialogue.
Dans le modèle Prgm...EndPrgm, validez chaque ligne en
@
·
appuyant sur
à la place de
. Sur le clavier de
l'ordinateur, maintenez enfoncée la touche Alt tout en
appuyant sur Entrée.
Define text_demo()=Prgm
Pour i,1,5
strinfo:=”Nombre aléatoire “ & string(rand(i))
Text strinfo
Next
EndPrgm
Exécutez le programme :
text_demo()
Exemple de boîte de dialogue :
Remarque : vous pouvez utiliser cette commande dans un
programme créé par l'utilisateur, mais pas dans une fonction.
Then
128
Voir If, page 58.
Guide de référence TI-Nspire™ CAS
tInterval
Catalogue >
tInterval Liste[,Fréq[,CLevel]]
(Entrée de liste de données)
tInterval
v,sx,n[,CLevel]
(Récapitulatif des statistiques fournies en entrée)
Calcule un intervalle de confiance t. Un récapitulatif du résultat est
stocké dans la variable stat.results. (Voir page 121.)
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.CLower, stat.CUpper
Intervalle de confiance pour une moyenne inconnue de population
stat.x
Moyenne d'échantillon de la série de données suivant la loi normale aléatoire
stat.ME
Marge d'erreur
stat.df
Degrés de liberté
stat.sx
Écart-type d’échantillon
stat.n
Taille de la série de données avec la moyenne d'échantillon
tInterval_2Samp
Catalogue >
tInterval_2Samp
Liste1,Liste2[,Fréq1[,Freq2[,CLevel[,Group]]]]
(Entrée de liste de données)
tInterval_2Samp
v1,sx1,n1,v2,sx2,n2[,CLevel[,Group]]
(Récapitulatif des statistiques fournies en entrée)
Calcule un intervalle de confiance t sur 2 échantillons. Un récapitulatif
du résultat est stocké dans la variable stat.results. (Voir page 121.)
Group=1 met en commun les variances ; Groupe=0 ne met pas en
commun les variances.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.CLower, stat.CUpper
Intervalle de confiance contenant la probabilité du niveau de confiance de la loi
stat.x1-x2
Moyennes d'échantillon des séries de données suivant la loi normale aléatoire
stat.ME
Marge d'erreur
stat.df
Degrés de liberté
stat.x1, stat.x2
Moyennes d'échantillon des séries de données suivant la loi normale aléatoire
stat.sx1, stat.sx2
Écarts-types d'échantillon pour Liste 1 et Liste 2
stat.n1, stat.n2
Nombre d'échantillons dans les séries de données
stat.sp
Écart-type du groupe. Calculé lorsque Group = YES.
Guide de référence TI-Nspire™ CAS
129
tmpCnv()
Catalogue >
tmpCnv(Expr_¡unitéTemp1,
⇒ expression _¡unitéTemp2
_¡unitéTemp2)
Remarque : vous pouvez insérer cette fonction à partir du clavier
de l'ordinateur en entrant deltaTmpCnv(...).
Convertit un écart de température (la différence entre deux valeurs de
température) spécifié par Expr d'une unité à une autre. Les unités de
Remarque : vous pouvez utiliser le Catalogue pour
température utilisables sont :
sélectionner des unités de température.
_¡C Celsius
_¡F Fahrenheit
_¡K Kelvin
_¡R Rankine
Pour taper ¡, sélectionnez ce symbole dans le Jeu de symboles ou
entrez @d.
Pour taper _, appuyez sur
/_.
Par exemple, 100_¡C donne 212_¡F.
Pour convertir un écart de température, utilisez @tmpCnv().
@tmpCnv()
Catalogue >
@tmpCnv(Expr_¡unitéTemp1, _¡unitéTemp2)
⇒ expression _¡unitéTemp2
Pour taper @, sélectionnez-le dans les symboles du Catalogue.
Convertit un écart de température (la différence entre deux valeurs de
température) spécifié par Expr d'une unité à une autre. Les unités de
température utilisables sont :
_¡C Celsius
_¡F Fahrenheit
_¡K Kelvin
_¡R Rankine
Remarque : vous pouvez utiliser le Catalogue pour
Pour taper ¡, sélectionnez-le dans les symboles du Catalogue.
Pour taper _, appuyez sur
sélectionner des unités de température.
/_.
Des écarts de 1_¡C et 1_¡K représentent la même grandeur, de
même que 1_¡F et 1_¡R. Par contre, un écart de 1_¡C correspond au
9/5 d'un écart de 1_¡F.
Par exemple, un écart de 100_¡C (de 0_¡C à 100_¡C) est équivalent
à un écart de 180_¡F.
Pour convertir une valeur de température particulière au lieu d'un
écart, utilisez la fonction tmpCnv().
tPdf()
Catalogue >
tPdf(ValX,df)
est une liste
⇒ nombre si ValX est un nombre, liste si ValX
Calcule la densité de probabilité (pdf) de la loi de Student-t à df
degrés de liberté en ValX.
130
Guide de référence TI-Nspire™ CAS
trace()
trace(matriceCarrée)
Catalogue >
⇒ expression
Donne la trace (somme de tous les éléments de la diagonale
principale) de matriceCarrée.
Try
Catalogue >
Try
bloc1
Else
bloc2
EndTry
Exécute bloc1, à moins qu'une erreur ne se produise. L'exécution du
programme est transférée au bloc2 si une erreur se produit au bloc1.
La variable système errCode contient le numéro d'erreur pour
permettre au programme de procéder à une reprise sur erreur. Pour
obtenir la liste des codes d'erreur, voir la section « Codes et messages
d'erreur », page 170.
bloc1 et bloc2 peuvent correspondre à une instruction unique ou à
une série d'instructions séparées par le caractère “:”.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
définitions sur plusieurs lignes en appuyant sur @ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
Exemple 2
Définition du programme eigenvals(a,b)=Prgm
© Le programme eigenvals(A,B) présente les valeurs propres A·B
Pour voir fonctionner les commandes Try, ClrErr et PassErr, saisissez Try
Disp "A= ",a
le programme eigenvals() décrit à droite. Exécutez le programme en
Disp "B= ",b
exécutant chacune des expressions suivantes.
Disp " "
Disp "Eigenvalues of A·B are:",eigVl(a*b)
Else
If errCode=230 Then
Disp "Error: Product of A·B must be a square matrix"
ClrErr
Else
PassErr
EndIf
EndTry
EndPrgm
Remarque : voir aussi ClrErr, page 19 et PassErr, page 89.
Guide de référence TI-Nspire™ CAS
131
tTest
tTest
Catalogue >
m0,Liste[,Fréq[,Hypoth]]
(Entrée de liste de données)
tTest
m0,x,sx,n,[Hypoth]
(Récapitulatif des statistiques fournies en entrée)
Teste une hypothèse pour une moyenne inconnue de population m
quand l'écart-type de population s est inconnu. Un récapitulatif du
résultat est stocké dans la variable stat.results. (Voir page 121.)
Test de H0 : m = m0, en considérant que :
Pour Ha : m < m0, définissez Hypoth<0
Pour Ha : m ƒ m0 (par défaut), définissez Hypoth=0
Pour Ha : m > m0, définissez Hypoth>0
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.t
(x N m0) / (stdev / sqrt(n))
stat.PVal
Plus petit seuil de signification permettant de rejeter l'hypothèse nulle
stat.df
Degrés de liberté
stat.x
Moyenne d'échantillon de la série de données dans Liste
stat.sx
Écart-type d'échantillon de la série de données
stat.n
Taille de l'échantillon
tTest_2Samp
Catalogue >
tTest_2Samp Liste1,Liste2[,Fréq1[,Fréq2[,Hypoth[,Group]]]]
(Entrée de liste de données)
tTest_2Samp
v1,sx1,n1,v2,sx2,n2[,Hypoth[,Group]]
(Récapitulatif des statistiques fournies en entrée)
Effectue un test t sur deux échantillons. Un récapitulatif du résultat
est stocké dans la variable stat.results. (Voir page 121.)
Test de H0 : m1 = m2, en considérant que :
Pour Ha : m1< m2, définissez Hypoth<0
Pour Ha : m1ƒ m2 (par défaut), définissez Hypoth=0
Pour Ha : m1> m2, définissez Hypoth>0
Group=1 met en commun les variances
Group=0 ne met pas en commun les variances
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.t
Valeur normale type calculée pour la différence des moyennes
132
Guide de référence TI-Nspire™ CAS
Variable de sortie
Description
stat.PVal
Plus petit seuil de signification permettant de rejeter l'hypothèse nulle
stat.df
Degrés de liberté des statistiques t
stat.x1, stat.x2
Moyennes d'échantillon des séquences de données dans Liste 1 et Liste 2
stat.sx1, stat.sx2
Écarts-types d'échantillon des séries de données dans Liste 1 et Liste 2
stat.n1, stat.n2
Taille des échantillons
stat.sp
Écart-type du groupe. Calculé lorsque Group=1.
tvmFV()
tvmFV(N,I,PV,Pmt,[PpY],[CpY],[PmtAt])
Catalogue >
⇒ valeur
Fonction financière permettant de calculer la valeur acquise de
l'argent.
Remarque : Les arguments utilisés dans les fonctions TVM sont
décrits dans le tableau des arguments TVM, page 134. Voir
également amortTbl(), page 6.
tvmI()
tvmI(N,PV,Pmt,FV,[PpY],[CpY],[PmtAt])
Catalogue >
⇒ valeur
Fonction financière permettant de calculer le taux d'intérêt annuel.
Remarque : Les arguments utilisés dans les fonctions TVM sont
décrits dans le tableau des arguments TVM, page 134. Voir
également amortTbl(), page 6.
tvmN()
tvmN(I,PV,Pmt,FV,[PpY],[CpY],[PmtAt])
Catalogue >
⇒ valeur
Fonction financière permettant de calculer le nombre de périodes de
versement.
Remarque : Les arguments utilisés dans les fonctions TVM sont
décrits dans le tableau des arguments TVM, page 134. Voir
également amortTbl(), page 6.
tvmPmt()
tvmPmt(N,I,PV,FV,[PpY],[CpY],[PmtAt])
Catalogue >
⇒ valeur
Fonction financière permettant de calculer le montant de chaque
versement.
Remarque : Les arguments utilisés dans les fonctions TVM sont
décrits dans le tableau des arguments TVM, page 134. Voir
également amortTbl(), page 6.
tvmPV()
tvmPV(N,I,Pmt,FV,[PpY],[CpY],[PmtAt])
Catalogue >
⇒ valeur
Fonction financière permettant de calculer la valeur actuelle.
Remarque : Les arguments utilisés dans les fonctions TVM sont
décrits dans le tableau des arguments TVM, page 134. Voir
également amortTbl(), page 6.
Guide de référence TI-Nspire™ CAS
133
Argument
TVM*
Description
Type de données
N
Nombre de périodes de versement
nombre réel
I
Taux d'intérêt annuel
nombre réel
PV
Valeur actuelle
nombre réel
Pmt
Montant des versements
nombre réel
FV
Valeur acquise
nombre réel
PpY
Versements par an, par défaut=1
Entier> 0
CpY
Nombre de périodes de calcul par an, par défaut=1
Entier> 0
PmtAt
Versement dû à la fin ou au début de chaque période, par défaut=fin
entier (0=fin, 1=début)
* Ces arguments de valeur temporelle de l'argent sont similaires aux noms des variables TVM (comme tvm.pv et tvm.pmt) utilisées
par le solveur finance de l'application Calculator. Cependant, les fonctions financières n'enregistrent pas leurs valeurs ou résultats dans
les variables TVM.
TwoVar
Catalogue >
TwoVar X, Y[, [Fréq] [, Catégorie, Inclure]]
Calcule des statistiques pour deux variables. Un récapitulatif du
résultat est stocké dans la variable stat.results. (Voir page 121.)
Toutes les listes doivent comporter le même nombre de lignes, à
l'exception de Inclure.
X et Y sont des listes de variables indépendantes et dépendantes.
Fréq est une liste facultative de valeurs qui indiquent la fréquence.
Chaque élément dans Fréq correspond à une fréquence d'occurrence
pour chaque couple X et Y. Par défaut, cette valeur est égale à 1.
Tous les éléments doivent être des entiers | 0.
Catégorie est une liste de codes de catégories pour les couples X et Y
correspondants.
Inclure est une liste d'un ou plusieurs codes de catégories. Seuls les
éléments dont le code de catégorie figure dans cette liste sont inclus
dans le calcul.
Tout élément vide dans les listes X, Fréq ou Catégorie a un élément
vide correspondant dans l'ensemble des listes résultantes. Tout
élément vide dans les listes X1 à X20 a un élément vide
correspondant dans l'ensemble des listes résultantes. Pour plus
d'informations concernant les éléments vides, reportez-vous à la page
164.
Variable de sortie
Description
stat.v
Moyenne des valeurs x
stat.Gx
Somme des valeurs x
stat.Gx2
Somme des valeurs x2
stat.sx
Écart-type de l'échantillon de x
stat.sx
Écart-type de la population de x
stat.n
Nombre de points de données
134
Guide de référence TI-Nspire™ CAS
Variable de sortie
Description
stat.w
Moyenne des valeurs y
stat.Gy
stat.Gy
Somme des valeurs y
Somme des valeurs y2
2
stat.sy
Écart-type de y dans l'échantillon
stat.sy
Écart-type de population des valeurs de y
stat.Gxy
Somme des valeurs de x·y.
stat.r
Coefficient de corrélation
stat.MinX
Minimum des valeurs de x
stat.Q1X
1er quartile de x
stat.MedianX
Médiane de x
stat.Q3X
3ème quartile de x
stat.MaxX
Maximum des valeurs de x
stat.MinY
Minimum des valeurs de y
stat.Q1Y
1er quartile de y
stat.MedY
Médiane de y
stat.Q3Y
3ème quartile de y
stat.MaxY
Maximum des valeurs y
stat.G(x-v)2
Somme des carrés des écarts par rapport à la moyenne de x
2
Somme des carrés des écarts par rapport à la moyenne de y
stat.G(y-w)
Guide de référence TI-Nspire™ CAS
135
U
unitV()
Catalogue >
unitV(Vecteur1)
⇒ vecteur
Donne un vecteur unitaire ligne ou colonne, en fonction de la nature
de Vecteur1.
Vecteur1 doit être une matrice d'une seule ligne ou colonne.
Pour afficher le résultat entier, appuyez sur
touches
unLock
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
Catalogue >
unLock Var1 [, Var2] [, Var3] ...
unLock Var.
Déverrouille les variables ou les groupes de variables spécifiés. Les
variables verrouillées ne peuvent être ni modifiées ni supprimées.
Voir Lock, page 71 et getLockInfo(), page 55.
V
varPop()
varPop(Liste[, listeFréq])
Catalogue >
⇒ expression
Donne la variance de population de Liste.
Chaque élément de la liste listeFréq totalise le nombre d'occurrences
de l'élément correspondant de Liste.
Remarque : Liste doit contenir au moins deux éléments.
Si un élément des listes est vide, il est ignoré et l'élément
correspondant dans l'autre liste l'est également. Pour plus
d'informations concernant les éléments vides, reportez-vous à la page
164.
136
Guide de référence TI-Nspire™ CAS
varSamp()
varSamp(Liste[, listeFréq])
Catalogue >
⇒ expression
Donne la variance d'échantillon de Liste.
Chaque élément de la liste listeFréq totalise le nombre d'occurrences
de l'élément correspondant de Liste.
Remarque : Liste doit contenir au moins deux éléments.
Si un élément des listes est vide, il est ignoré et l'élément
correspondant dans l'autre liste l'est également. Pour plus
d'informations concernant les éléments vides, reportez-vous à la page
164.
varSamp(Matrice1[, matriceFréq])
⇒ matrice
Donne un vecteur ligne contenant la variance d'échantillon de chaque
colonne de Matrice1.
Chaque élément de matriceFréq totalise le nombre d'occurrences de
l'élément correspondant de Matrice1.
Remarque : Matrice1 doit contenir au moins deux lignes.
Si un élément des matrices est vide, il est ignoré et l'élément
correspondant dans l'autre matrice l'est également. Pour plus
d'informations concernant les éléments vides, reportez-vous à la page
164.
W
warnCodes()
warnCodes(Expr1, VarÉtat)
Catalogue >
⇒
expression
Évalue l'expression Expr1, donne le résultat et stocke les codes de
tous les avertissements générés dans la variable de liste VarÉtat. Si
aucun avertissement n'est généré, cette fonction affecte une liste vide
à VarÉtat.
Expr1 peut être toute expression mathématique TI-Nspire™ ou
TI-Nspire™ CAS valide. Expr1 ne peut pas être une commande ou
une affectation.
Pour afficher le résultat entier, appuyez sur
touches
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
VarÉtat doit être un nom de variable valide.
Pour la liste des codes d'avertissement et les messages associés, voir
page 175.
when()
Catalogue >
when(Condition, résultSiOui [, résultSiNon][, résultSiInconnu])
⇒ expression
Donne résultSiOui, résultSiNon ou résultSiInconnu, suivant que la
Condition est vraie, fausse ou indéterminée. Donne l'entrée si le
nombre d'argument est insuffisant pour spécifier le résultat
approprié.
Ne spécifiez pas résultSiNon ni résultSiInconnu pour obtenir une
expression définie uniquement dans la région où Condition est vraie.
Utilisez undef résultSiNon pour définir une expression représentée
graphiquement sur un seul intervalle.
Guide de référence TI-Nspire™ CAS
137
when()
Catalogue >
when() est utile dans le cadre de la définition de fonctions récursives.
While
Catalogue >
While Condition
Bloc
EndWhile
Exécute les instructions contenues dans Bloc si Condition est vraie.
Bloc peut correspondre à une ou plusieurs instructions, séparées par
un « : ».
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
@ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
définitions sur plusieurs lignes en appuyant sur
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
|
With
Voir , page 161.
X
xor
Catalogue >
Expr booléenne1 xor Expr booléenne2 ⇒ Expression
booléenne
Donne true si Expr booléenne1 est vraie et si Expr booléenne2 est
fausse, ou vice versa.
Donne false si les deux arguments sont tous les deux vrais ou faux.
Donne une expression booléenne simplifiée si l'un des deux
arguments ne peut être résolu vrai ou faux.
Remarque : voir or, page 88.
138
Guide de référence TI-Nspire™ CAS
xor
Catalogue >
Entier1 xor Entier2 ⇒ entier
En mode base Hex :
Important : utilisez le chiffre zéro et pas la lettre O.
Compare les représentations binaires de deux entiers, en appliquant
un xor bit par bit. En interne, les deux entiers sont convertis en
nombres binaires 64 bits signés. Lorsque les bits comparés
correspondent, le résultat est 1 si dans l'un des deux cas (pas dans les
deux) il s'agit d'un bit 1 ; le résultat est 0 si, dans les deux cas, il s'agit En mode base Bin :
d'un bit 0 ou 1. La valeur donnée représente le résultat des bits et elle
est affichée selon le mode Base utilisé.
Remarque : une entrée binaire peut comporter jusqu'à 64
Les entiers de tout type de base sont admis. Pour une entrée binaire chiffres (sans compter le préfixe 0b) ; une entrée hexadécimale
ou hexadécimale, vous devez utiliser respectivement le préfixe 0b ou jusqu'à 16 chiffres.
0h. Tout entier sans préfixe est considéré comme un nombre en
écriture décimale (base 10).
Si vous entrez un nombre dont le codage binaire signé dépasse 64
bits, il est ramené à l'aide d'une congruence dans la plage appropriée.
Pour de plus amples informations, voir 4Base2, page 13.
Remarque : voir or, page 88.
Z
zeros()
Catalogue >
⇒ liste
zeros(Expr, Var=Init) ⇒ liste
zeros(Expr, Var)
Donne la liste des valeurs réelles possibles de Var avec lesquelles
Expr=0. Pour y parvenir, zeros() calcule
exp4list(solve(Expr=0,Var),Var).
Dans certains cas, la nature du résultat de zeros() est plus
satisfaisante que celle de solve(). Toutefois, la nature du résultat de
zeros() ne permet pas d'exprimer des solutions implicites, des
solutions nécessitant des inéquations ou des solutions qui
n'impliquent pas Var.
Remarque : voir aussi cSolve(), cZeros() et solve().
zeros({Expr1, Expr2},
{VarOuInit1, VarOuInit2 [, … ]})
⇒ matrice
Donne les zéros réels possibles du système d'expressions algébriques,
où chaque VarOuInit spécifie une inconnue dont vous recherchez la
valeur.
Vous pouvez également spécifier une condition initiale pour les
variables. Chaque VarOuInit doit utiliser le format suivant :
variable
– ou –
variable = nombre réel ou nonréel
Par exemple, x est autorisé, de même que x=3.
Guide de référence TI-Nspire™ CAS
139
zeros()
Catalogue >
Si toutes les expressions sont polynomiales et si vous NE spécifiez
PAS de condition initiale, zeros() utilise la méthode d'élimination
lexicale Gröbner/Buchberger pour tenter de trouver tous les zéros
réels.
Par exemple, si vous avez un cercle de rayon r centré à l'origine et un
autre cercle de rayon r centré, au point où le premier cercle coupe
l'axe des x positifs. Utilisez zeros() pour trouver les intersections.
Comme l'illustre r dans l'exemple ci-contre, des expressions
polynomiales simultanées peuvent avoir des variables
supplémentaires sans valeur assignée, mais représenter des valeurs
auxquelles on peut affecter par la suite des valeurs numériques.
Chaque ligne de la matrice résultante représente un n_uplet, l'ordre
des composants étant identique à celui de la liste VarOuInit. Pour
extraire une ligne, indexez la matrice par [ligne].
Extraction ligne 2 :
Vous pouvez également utiliser des inconnues qui n'apparaissent pas
dans les expressions. Par exemple, vous pouvez utiliser z comme
inconnue pour développer l'exemple précédent et avoir deux cylindres
parallèles sécants de rayon r. La solution des cylindres montre
comment des groupes de zéros peuvent contenir des constantes
arbitraires de type ck, où k est un suffixe entier compris entre 1 et
255.
Pour les systèmes d'équations polynomiaux, le temps de calcul et
l'utilisation de la mémoire peuvent considérablement varier en
fonction de l'ordre dans lequel les inconnues sont spécifiées. Si votre
choix initial ne vous satisfait pas pour ces raisons, vous pouvez
modifier l'ordre des variables dans les expressions et/ou la liste
VarOuInit.
Si vous choisissez de ne pas spécifier de condition et s'il l'une des
expressions n'est pas polynomiale dans l'une des variables, mais que
toutes les expressions sont linéaires par rapport à toutes les
inconnues, zeros() utilise l'élimination gaussienne pour tenter de
trouver tous les zéros réels.
Si un système d'équations n'est pas polynomial dans toutes ses
variables ni linéaire par rapport à ses inconnues, zeros() cherche au
moins un zéro en utilisant une méthode itérative approchée. Pour
cela, le nombre d'inconnues doit être égal au nombre d'expressions et
toutes les autres variables contenues dans les expressions doivent
pouvoir être évaluées à des nombres.
Chaque inconnue commence à sa valeur supposée, si elle existe ;
sinon, la valeur de départ est 0.0.
Utilisez des valeurs initiales pour rechercher des zéros
supplémentaires, un par un. Pour assurer une convergence correcte,
une valeur initiale doit être relativement proche d'un zéro.
140
Guide de référence TI-Nspire™ CAS
zInterval
Catalogue >
zInterval s,Liste[,Fréq[,CLevel]]
(Entrée de liste de données)
zInterval s,v,n [,CLevel]
(Récapitulatif des statistiques fournies en entrée)
Calcule un intervalle de confiance z. Un récapitulatif du résultat est
stocké dans la variable stat.results. (Voir page 121.)
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.CLower, stat.CUpper
Intervalle de confiance pour une moyenne inconnue de population
stat.x
Moyenne d'échantillon de la série de données suivant la loi normale aléatoire
stat.ME
Marge d'erreur
stat.sx
Écart-type d’échantillon
stat.n
Taille de la série de données avec la moyenne d'échantillon
stat.s
Écart-type connu de population pour la série de données Liste
zInterval_1Prop
Catalogue >
zInterval_1Prop x,n [,CLevel]
Calcule un intervalle de confiance z pour une proportion. Un
récapitulatif du résultat est stocké dans la variable stat.results. (Voir
page 121.)
x est un entier non négatif.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.CLower, stat.CUpper
Intervalle de confiance contenant la probabilité du niveau de confiance de la loi
stat.Ç
Proportion calculée de réussite
stat.ME
Marge d'erreur
stat.n
Nombre d'échantillons dans la série de données
zInterval_2Prop
Catalogue >
zInterval_2Prop x1,n1,x2,n2[,CLevel]
Calcule un intervalle de confiance z pour deux proportions. Un
récapitulatif du résultat est stocké dans la variable stat.results. (Voir
page 121.)
x1 et x2 sont des entiers non négatifs.
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Guide de référence TI-Nspire™ CAS
141
Variable de sortie
Description
stat.CLower, stat.CUpper
Intervalle de confiance contenant la probabilité du niveau de confiance de la loi
stat.ÇDiff
Différence calculée entre les proportions
stat.ME
Marge d'erreur
stat.Ç1
Proportion calculée sur le premier échantillon
stat.Ç2
Proportion calculée sur le deuxième échantillon
stat.n1
Taille de l'échantillon dans la première série de données
stat.n2
Taille de l'échantillon dans la deuxième série de données
zInterval_2Samp
Catalogue >
zInterval_2Samp s1,s2
,Liste1,Liste2[,Fréq1[,Fréq2,[CLevel]]]
(Entrée de liste de données)
zInterval_2Samp
s1,s2,v1,n1,v2,n2[,CLevel]
(Récapitulatif des statistiques fournies en entrée)
Calcule un intervalle de confiance z sur deux échantillons. Un
récapitulatif du résultat est stocké dans la variable stat.results. (Voir
page 121.)
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.CLower, stat.CUpper
Intervalle de confiance contenant la probabilité du niveau de confiance de la loi
stat.x1-x2
Moyennes d'échantillon des séries de données suivant la loi normale aléatoire
stat.ME
Marge d'erreur
stat.x1, stat.x2
Moyennes d'échantillon des séries de données suivant la loi normale aléatoire
stat.sx1, stat.sx2
Écarts-types d'échantillon pour Liste 1 et Liste 2
stat.n1, stat.n2
Nombre d'échantillons dans les séries de données
stat.r1, stat.r2
Écart-type connu de population pour la série de données Liste 1 et Liste 2
142
Guide de référence TI-Nspire™ CAS
zTest
zTest
Catalogue >
m0,s,Liste,[Fréq[,Hypoth]]
(Entrée de liste de données)
zTest
m0,s,v,n[,Hypoth]
(Récapitulatif des statistiques fournies en entrée)
Effectue un test z en utilisant la fréquence listeFréq. Un récapitulatif
du résultat est stocké dans la variable stat.results. (Voir page 121.)
Test de H0 : m = m0, en considérant que :
Pour Ha : m < m0, définissez Hypoth<0
Pour Ha : m ƒ m0 (par défaut), définissez Hypoth=0
Pour Ha : m > m0, définissez Hypoth>0
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.z
(x N m0) / (s / sqrt(n))
stat.P Value
Plus petite probabilité permettant de rejeter l'hypothèse nulle
stat.x
Moyenne d'échantillon de la série de données dans Liste
stat.sx
Écart-type d'échantillon de la série de données Uniquement donné pour l'entrée Data.
stat.n
Taille de l'échantillon
zTest_1Prop
Catalogue >
zTest_1Prop p0,x,n[,Hypoth]
Effectue un test z pour une proportion unique. Un récapitulatif du
résultat est stocké dans la variable stat.results. (Voir page 121.)
x est un entier non négatif.
Test de H0 : p = p0, en considérant que :
Pour Ha : p > p0, définissez Hypoth>0
Pour Ha : p ƒ p0 (par défaut), définissez Hypoth=0
Pour Ha : p < p0, définissez Hypoth<0
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.p0
Proportion de population hypothétique
stat.z
Valeur normale type calculée pour la proportion
stat.PVal
Plus petit seuil de signification permettant de rejeter l'hypothèse nulle
stat.Ç
Proportion calculée sur l'échantillon
stat.n
Taille de l'échantillon
Guide de référence TI-Nspire™ CAS
143
zTest_2Prop
Catalogue >
zTest_2Prop x1,n1,x2,n2[,Hypoth]
Calcule un test z pour deux proportions. Un récapitulatif du résultat
est stocké dans la variable stat.results. (Voir page 121.)
x1 et x2 sont des entiers non négatifs.
Test de H0 : p1 = p2, en considérant que :
Pour Ha : p1 > p2, définissez Hypoth>0
Pour Ha : p1 ƒ p2 (par défaut), définissez Hypoth=0
Pour Ha : p < p0, définissez Hypoth<0
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.z
Valeur normale type calculée pour la différence des proportions
stat.PVal
Plus petit seuil de signification permettant de rejeter l'hypothèse nulle
stat.Ç1
Proportion calculée sur le premier échantillon
stat.Ç2
Proportion calculée sur le deuxième échantillon
stat.Ç
Proportion calculée de l'échantillon mis en commun
stat.n1, stat.n2
Nombre d'échantillons pris lors des essais 1 et 2
zTest_2Samp
zTest_2Samp
Catalogue >
s1,s2,Liste1,Liste2[,Fréq1[,Fréq2[,Hypoth]]]
(Entrée de liste de données)
zTest_2Samp
s1,s2,v1,n1,v2,n2[,Hypoth]
(Récapitulatif des statistiques fournies en entrée)
Calcule un test z sur deux échantillons. Un récapitulatif du résultat est
stocké dans la variable stat.results. (Voir page 121.)
Test de H0 : m1 = m2, en considérant que :
Pour Ha : m1 < m2, définissez Hypoth<0
Pour Ha : m1 ƒ m2 (par défaut), définissez Hypoth=0
Pour Ha : m1 > m2, Hypoth>0
Pour plus d'informations concernant les éléments vides dans une
liste, reportez-vous à “Éléments vides” , page 164.
Variable de sortie
Description
stat.z
Valeur normale type calculée pour la différence des moyennes
stat.PVal
Plus petit seuil de signification permettant de rejeter l'hypothèse nulle
stat.x1, stat.x2
Moyennes d'échantillon des séquences de données dans Liste 1 et Liste 2
stat.sx1, stat.sx2
Écarts-types d'échantillon des séries de données dans Liste 1 et Liste 2
stat.n1, stat.n2
Taille des échantillons
144
Guide de référence TI-Nspire™ CAS
Symboles
+ (somme)
Touche
+
Touche
-
Expr1 + Expr2 ⇒ expression
Donne la somme des deux arguments.
Liste1 + Liste2 ⇒ liste
Matrice1 + Matrice2 ⇒ matrice
Donne la liste (ou la matrice) contenant les sommes des éléments
correspondants de Liste1 et Liste2 (ou Matrice1 et Matrice2).
Les arguments doivent être de même dimension.
Expr + Liste1 ⇒ liste
Liste1 + Expr ⇒ liste
Donne la liste contenant les sommes de Expr et de chaque élément
de Liste1.
Expr + Matrice1 ⇒ matrice
Matrice1 + Expr ⇒ matrice
Donne la matrice obtenue en ajoutant Expr à chaque élément de la
diagonale de Matrice1. Matrice1 doit être carrée.
Remarque : utilisez .+ pour ajouter une expression à chaque
élément de la matrice.
N(soustraction)
Expr1 N Expr2 ⇒ expression
Donne la différence de Expr1 et de Expr2.
Liste1 N Liste2 ⇒ liste
Matrice1 N Matrice2 ⇒ matrice
Soustrait chaque élément de Liste2 (ou Matrice2) de l'élément
correspondant de Liste1 (ou Matrice1) et donne le résultat obtenu.
Les arguments doivent être de même dimension.
Expr N Liste1 ⇒ liste
Liste1 N Expr ⇒ liste
Soustrait chaque élément de Liste1 de Expr ou soustrait Expr de
chaque élément de Liste1 et donne la liste de résultats obtenue.
Guide de référence TI-Nspire™ CAS
145
N(soustraction)
Touche
-
Touche
r
Touche
p
Expr N Matrice1 ⇒ matrice
Matrice1 N Expr ⇒ matrice
Expr N Matrice1 donne la matrice Expr fois la matrice d'identité
moins Matrice1. Matrice1 doit être carrée.
Matrice1 N Expr donne la matrice obtenue en soustrayant Expr à
chaque élément de la diagonale de Matrice1. Matrice1 doit être
carrée.
Remarque : Utilisez .N pour soustraire une expression à chaque
élément de la matrice.
·(multiplication)
Expr1
·Expr2 ⇒
expression
Donne le produit des deux arguments.
Liste1·Liste2 ⇒ liste
Donne la liste contenant les produits des éléments correspondants de
Liste1 et Liste2.
Les listes doivent être de même dimension.
Matrice1
·Matrice2 ⇒
matrice
Donne le produit des matrices Matrice1 et Matrice2.
Le nombre de colonnes de Matrice1 doit être égal au nombre de
lignes de Matrice2.
Expr
·Liste1 ⇒
·Expr ⇒
Liste1
liste
liste
Donne la liste des produits de Expr et de chaque élément de Liste1.
Expr
·Matrice1 ⇒
·Expr ⇒
Matrice1
matrice
matrice
Donne la matrice contenant les produits de Expr et de chaque
élément de Matrice1.
Remarque : Utilisez .·pour multiplier une expression par chaque
élément.
à (division)
Expr1 à Expr2 ⇒ expression
Donne le quotient de Expr1 par Expr2.
Remarque : voir aussi Modèle Fraction, page 1.
146
Guide de référence TI-Nspire™ CAS
à (division)
Touche
p
Touche
l
Liste1 à Liste2 ⇒ liste
Donne la liste contenant les quotients de Liste1 par Liste2.
Les listes doivent être de même dimension.
Expr à Liste1 ⇒ liste
Liste1 à Expr ⇒ liste
Donne la liste contenant les quotients de Expr par Liste1 ou de
Liste1 par Expr.
Matrice1 à Expr ⇒ matrice
Donne la matrice contenant les quotients des éléments de
Matrice1àExpression.
Remarque : Utilisez . / pour diviser une expression par chaque
élément.
^ (puissance)
Expr1 ^ Expr2 ⇒ expression
Liste1 ^ Liste2 ⇒ liste
Donne le premier argument élevé à la puissance du deuxième
argument.
Remarque : voir aussi Modèle Exposant, page 1.
Dans le cas d'une liste, donne la liste des éléments de Liste1 élevés à
la puissance des éléments correspondants de Liste2.
Dans le domaine réel, les puissances fractionnaires possédant des
exposants réduits avec des dénominateurs impairs utilise la branche
réelle, tandis que le mode complexe utilise la branche principale.
Expr ^ Liste1 ⇒ liste
Donne Expr élevé à la puissance des éléments de Liste1.
List1 ^ Expr ⇒ liste
Donne les éléments de Liste1 élevés à la puissance de l'expression.
matriceCarrée1 ^ entier ⇒ matrice
Donne matriceCarrée1 élevée à la puissance de la valeur de l'entier.
matriceCarrée1 doit être une matrice carrée.
Si entier = L1, calcule la matrice inverse.
Si entier < L1, calcule la matrice inverse à une puissance positive
appropriée.
Guide de référence TI-Nspire™ CAS
147
x2 (carré)
Touche
q
Expr1 2 ⇒ expression
Donne le carré de l'argument.
Liste1 2 ⇒ liste
Donne la liste comportant les carrés des éléments de Liste1.
matriceCarrée1 2 ⇒ matrice
Donne le carré de la matrice matriceCarrée1. Ce calcul est différent
du calcul du carré de chaque élément. Utilisez .^2 pour calculer le
carré de chaque élément.
.+ (addition élément par élément)
Touches
^+
Touches
^-
Touches
^r
Matrice1 .+ Matrice2 ⇒ matrice
Expr .+ Matrice1 ⇒ matrice
Matrice1 .+ Matrice2 donne la matrice obtenue en effectuant la
somme de chaque paire d'éléments correspondants de Matrice1 et
de Matrice2.
Expr .+ Matrice1 donne la matrice obtenue en effectuant la somme
de Expr et de chaque élément de Matrice1.
.. (soustraction élément par élément)
Matrice1 .N Matrice2 ⇒ matrice
Expr .NMatrice1 ⇒ matrice
Matrice1 .NMatrice2 donne la matrice obtenue en calculant la
différence entre chaque paire d'éléments correspondants de
Matrice1 et de Matrice2.
Expr .NMatrice1 donne la matrice obtenue en calculant la différence
de Expr et de chaque élément de Matrice1.
.·(multiplication élément par élément)
Matrice1 .· Matrice2 ⇒ matrice
Expr .·Matrice1 ⇒ matrice
Matrice1 .· Matrice2 donne la matrice obtenue en calculant le
produit de chaque paire d'éléments correspondants de Matrice1 et
de Matrice2.
Expr .· Matrice1 donne la matrice contenant les produits de Expr
et de chaque élément de Matrice1.
148
Guide de référence TI-Nspire™ CAS
. / (division élément par élément)
Touches
^p
Touches
^l
Matrice1 . / Matrice2 ⇒ matrice
Expr . / Matrice1 ⇒ matrice
Matrice1 ./ Matrice2 donne la matrice obtenue en calculant le
quotient de chaque paire d'éléments correspondants de Matrice1 et
de Matrice2.
Expr ./ Matrice1 donne la matrice obtenue en calculant le quotient
de Expr et de chaque élément de Matrice1.
.^ (puissance élément par élément)
Matrice1 .^ Matrice2 ⇒ matrice
Expr . ^ Matrice1 ⇒ matrice
Matrice1 .^ Matrice2 donne la matrice obtenue en élevant chaque
élément de Matrice1 à la puissance de l'élément correspondant de
Matrice2.
Expr .^ Matrice1 donne la matrice obtenue en élevant Expr à la
puissance de chaque élément de Matrice1.
L(opposé)
Touche
v
LExpr1 ⇒ expression
LListe1 ⇒ liste
LMatrice1 ⇒ matrice
Donne l'opposé de l'argument.
Dans le cas d'une liste ou d'une matrice, donne l'opposé de chacun
des éléments.
Si l'argument est un entier binaire ou hexadécimal, la négation donne
le complément à deux.
En mode base Bin :
Important : utilisez le chiffre zéro et
pas la lettre O.
Pour afficher le résultat entier, appuyez sur
touches
£, puis utilisez les
¡ et ¢ pour déplacer le curseur.
Guide de référence TI-Nspire™ CAS
149
% (pourcentage)
Expr1 % ⇒ expression
Liste1 % ⇒ liste
Matrice1 % ⇒ matrice
Touches
/k
Appuyez sur Ctrl+Entrée
“+Enter) pour évaluer :
/· (Macintosh®:
Appuyez sur Ctrl+Entrée
“+Enter) pour évaluer :
/· (Macintosh®:
Donne
Dans le cas d'une liste ou d'une matrice, donne la liste ou la matrice
obtenue en divisant chaque élément par 100.
= (égal à)
Expr1 = Expr2 ⇒ Expression booléenne
Liste1 = Liste2 ⇒ Liste booléenne
Matrice1 = Matrice2 ⇒ Matrice booléenne
Touche
Exemple de fonction qui utilise les symboles de test
mathématiques : =, ƒ, <, {, >, |
Donne true s'il est possible de vérifier que la valeur de Expr1 est
égale à celle de Expr2.
Donne false s'il est possible de déterminer que la valeur de Expr1
n'est pas égale à celle de Expr2.
Dans les autres cas, donne une forme simplifiée de l'équation.
Dans le cas d'une liste ou d'une matrice, donne le résultat des
comparaisons, élément par élément.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
@ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
définitions sur plusieurs lignes en appuyant sur
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
Résultat de la représentation graphique de g(x)
150
Guide de référence TI-Nspire™ CAS
=
ƒ (différent de)
Touches
Expr1 ƒ Expr2 ⇒ Expression booléenne
Liste1 ƒ Liste2 ⇒ Liste booléenne
Matrice1 ƒ Matrice2 ⇒ Matrice booléenne
/=
Voir l'exemple fourni pour « = » (égal à).
Donne true s'il est possible de déterminer que la valeur de Expr1
n'est pas égale à celle de Expr2.
Donne false s'il est possible de vérifier que la valeur de Expr1 est
égale à celle de Expr2.
Dans les autres cas, donne une forme simplifiée de l'équation.
Dans le cas d'une liste ou d'une matrice, donne le résultat des
comparaisons, élément par élément.
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant /=
< (inférieur à)
Touches
Expr1 < Expr2 ⇒ Expression booléenne
Liste1 < Liste2 ⇒ Liste booléenne
Matrice1 < Matrice2 ⇒ Matrice booléenne
/=
Voir l'exemple fourni pour « = » (égal à).
Donne true s'il est possible de déterminer que la valeur de Expr1 est
strictement inférieure à celle de Expr2.
Donne false s'il est possible de déterminer que la valeur de Expr1 est
strictement supérieure ou égale à celle de Expr2.
Dans les autres cas, donne une forme simplifiée de l'équation.
Dans le cas d'une liste ou d'une matrice, donne le résultat des
comparaisons, élément par élément.
{ (inférieur ou égal à)
Touches
Expr1 { Expr2 ⇒ Expression booléenne
Liste1 { Liste2 ⇒ Liste booléenne
Matrice1 { Matrice2 ⇒ Matrice booléenne
/=
Voir l'exemple fourni pour « = » (égal à).
Donne true s'il est possible de déterminer que la valeur de Expr1 est
inférieure ou égale à celle de Expr2.
Donne false s'il est possible de déterminer que la valeur de Expr1 est
strictement supérieure à celle de Expr2.
Dans les autres cas, donne une forme simplifiée de l'équation.
Dans le cas d'une liste ou d'une matrice, donne le résultat des
comparaisons, élément par élément.
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant <=
> (supérieur à)
Touches
Expr1 > Expr2 ⇒ Expression booléenne
Liste1 > Liste2 ⇒ Liste booléenne
Matrice1 > Matrice2 ⇒ Matrice booléenne
/=
Voir l'exemple fourni pour « = » (égal à).
Donne true s'il est possible de déterminer que la valeur de Expr1 est
supérieure à celle de Expr2.
Donne false s'il est possible de déterminer que la valeur de Expr1 est
strictement inférieure ou égale à celle de Expr2.
Dans les autres cas, donne une forme simplifiée de l'équation.
Dans le cas d'une liste ou d'une matrice, donne le résultat des
comparaisons, élément par élément.
Guide de référence TI-Nspire™ CAS
151
| (supérieur ou égal à)
Expr1 | Expr2 ⇒ Expression booléenne
Liste1 | Liste2 ⇒ Liste booléenne
Matrice1 | Matrice2 ⇒ Matrice booléenne
Touches
/=
Voir l'exemple fourni pour « = » (égal à).
Donne true s'il est possible de déterminer que la valeur de Expr1 est
supérieure ou égale à celle de Expr2.
Donne false s'il est possible de déterminer que la valeur de Expr1 est
inférieure ou égale à celle de Expr2.
Dans les autres cas, donne une forme simplifiée de l'équation.
Dans le cas d'une liste ou d'une matrice, donne le résultat des
comparaisons, élément par élément.
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant >=
! (factorielle)
Touche
º
Expr1! ⇒ expression
Liste1! ⇒ liste
Matrice1! ⇒ matrice
Donne la factorielle de l'argument.
Dans le cas d'une liste ou d'une matrice, donne la liste ou la matrice
des factorielles de tous les éléments.
& (ajouter)
Chaîne1 & Chaîne2 ⇒ chaîne
Donne une chaîne de caractères obtenue en ajoutant Chaîne2 à
Chaîne1.
152
Guide de référence TI-Nspire™ CAS
Touches
/k
d() (dérivée)
Catalogue >
d(Expr1, Var [,Ordre])
⇒ expression
d(Liste1,Var [,Ordre])
⇒ liste
d(Matrice1,Var [,Ordre])
⇒ matrice
Affiche la dérivée première du premier argument par rapport à la
variable Var.
Ordre, si spécifié, doit être un entier. Si l'ordre spécifié est inférieur à
zéro, on obtient une primitive.
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant derivative(...).
d() n'applique pas la méthode de calcul standard qui consiste à
simplifier entièrement ses arguments, puis à appliquer la définition de
la fonction aux arguments simplifiés obtenus. Par contre, d() procède
de la façon suivante :
1.
Il simplifie le deuxième argument uniquement dans la mesure où
cette opération permet d'obtenir une variable.
2.
Il simplifie le premier argument uniquement dans la mesure où
cette opération appelle une valeur stockée pour la variable
déterminée à l'étape 1.
3.
Il détermine la dérivée symbolique du résultat obtenu à l'étape 2
par rapport à la variable générée à l'étape 1.
Si la variable déterminée à l'étape 1 a une valeur stockée ou une
valeur spécifiée par un opérateur « sachant que » (|), cette valeur est
substituée dans le résultat obtenu à l'étape 3.
Remarque : voir aussi Dérivée première, page 4, Dériviée
seconde, page 5 ou Dérivée n-ième, page 5.
‰() (intégrale)
Catalogue >
‰(Expr1, Var[, Borne1, Borne2]) ⇒ expression
‰(Expr1, Var[, Constante]) ⇒ expression
Affiche l'intégrale de Expr1 pour la variable Var entre Borne1 et
Borne2.
Remarque : voir aussi le modèle Intégrale définie ou indéfinie,
page 5.
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant integral(...).
Donne une primitive si Borne1 et Borne2 sont omises. La constante
d'intégration est omise si vous spécifiez l'argument Constante.
Les primitives valides peuvent différer d'une constante numérique. Ce
type de constante peut être masqué, notamment lorsqu'une primitive
contient des logarithmes ou des fonctions trigonométriques inverses.
De plus, des expressions constantes par morceaux sont parfois
ajoutées pour assurer la validité d'une primitive sur un intervalle plus
grand que celui d'une formule courante.
Guide de référence TI-Nspire™ CAS
153
‰() (intégrale)
Catalogue >
‰() retourne les intégrales non évaluées des morceaux de Expr1 dont
les primitives ne peuvent pas être déterminées sous forme de
combinaison explicite finie de fonctions usuelles.
Si Borne1 et Borne2 sont toutes les deux spécifiées, la fonction tente
de localiser toute discontinuité ou dérivée discontinue comprise dans
l'intervalle Borne1 < Var < Borne2 et de subdiviser l'intervalle en
ces points.
Avec le réglage Auto du mode Auto ou Approché
(Approximate), l'intégration numérique est utilisée, si elle est
applicable, chaque fois qu'une primitive ou une limite ne peut pas
être déterminée.
Avec le réglage Approché, on procède en premier à une intégration
numérique, si elle est applicable. Les primitives ne peuvent être
trouvées que dans le cas où cette intégration numérique ne
s'applique pas ou échoue.
Appuyez sur Ctrl+Entrée
/· (Macintosh®:
“+Enter) pour évaluer :
‰() peut être imbriqué pour obtenir des intégrales multiples. Les
bornes d'intégration peuvent dépendre des variables d'intégration les
plus extérieures.
Remarque : voir aussi nInt(), page 83.
‡() (racine carrée)
‡ (Expr1) ⇒ expression
‡ (Liste1) ⇒ liste
Donne la racine carrée de l'argument.
Dans le cas d'une liste, donne la liste des racines carrées des éléments
de Liste1.
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant sqrt(...)
Remarque : voir aussi Modèle Racine carrée, page 1.
154
Guide de référence TI-Nspire™ CAS
Touches
/q
Π() (prodSeq)
Catalogue >
Π(Expr1, Var, Début, Fin) ⇒ expression
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant prodSeq(...).
Calcule Expr1 pour chaque valeur de Var comprise entre Début et
Fin et donne le produit des résultats obtenus.
Remarque : voir aussi Modèle Produit (Π), page 4.
Π(Expr1, Var, Début, DébutN1) ⇒ 1
Π(Expr1, Var, Début, Fin)
⇒ 1/Π(Expr1, Var, Fin+1, DébutN1) if Début < FinN1
Les formules de produit utilisées sont extraites des références cidessous :
Ronald L. Graham, Donald E. Knuth et Oren Patashnik. Concrete
Mathematics: A Foundation for Computer Science. Reading,
Massachusetts: Addison-Wesley, 1994.
G() (sumSeq)
Catalogue >
G(Expr1, Var, Début, Fin) ⇒ expression
Remarque : vous pouvez insérer cette fonction à partir du clavier
en entrant sumSeq(...).
Calcule Expr1 pour chaque valeur de Var comprise entre Début et
Fin et donne la somme des résultats obtenus.
Remarque : voir aussi Modèle Somme, page 4.
Guide de référence TI-Nspire™ CAS
155
G() (sumSeq)
Catalogue >
G(Expr1, Var, Début, FinN1) ⇒ 0
G(Expr1, Var, Début, Fin)
⇒ LG(Expr1, Var, Fin+1, DébutN1) if Fin < DébutN1
Le formules d'addition utilisées sont extraites des références cidessous :
Ronald L. Graham, Donald E. Knuth et Oren Patashnik. Concrete
Mathematics: A Foundation for Computer Science. Reading,
Massachusetts: Addison-Wesley, 1994.
GInt()
Catalogue >
GInt(NPmt1, NPmt2, N, I, PV,[Pmt], [FV], [PpY], [CpY],
[PmtAt], [valArrondi]) ⇒ valeur
GInt(NPmt1,NPmt2,tblAmortissement) ⇒ valeur
Fonction d'amortissement permettant de calculer la somme des
intérêts au cours d'une plage de versements spécifiée.
NPmt1 et NPmt2 définissent le début et la fin de la plage de
versements.
N, I, PV, Pmt, FV, PpY, CpY et PmtAt sont décrits dans le tableau
des arguments TVM, page 134.
•
•
•
Si vous omettez Pmt, il prend par défaut la valeur
Pmt=tvmPmt(N,I,PV,FV,PpY,CpY,PmtAt).
Si vous omettez FV, il prend par défaut la valeur FV=0.
Les valeurs par défaut pour PpY, CpY et PmtAt sont les mêmes
que pour les fonctions TVM.
valArrondi spécifie le nombre de décimales pour arrondissement.
Valeur par défaut=2.
GInt(NPmt1,NPmt2,tblAmortissement) calcule la somme de
l'intérêt sur la base du tableau d'amortissement tblAmortissement.
L'argument tblAmortissement doit être une matrice au format décrit
à tblAmortissement(), page 6.
Remarque : voir également GPrn() ci dessous et Bal(), page 13.
156
Guide de référence TI-Nspire™ CAS
GPrn()
Catalogue >
GPrn(NPmt1, NPmt2, N, I, PV, [Pmt], [FV], [PpY], [CpY],
[PmtAt], [valArrondi]) ⇒ valeur
GPrn(NPmt1,NPmt2,tblAmortissement) ⇒ valeur
Fonction d'amortissement permettant de calculer la somme du capital
au cours d'une plage de versements spécifiée.
NPmt1 et NPmt2 définissent le début et la fin de la plage de
versements.
N, I, PV, Pmt, FV, PpY, CpY et PmtAt sont décrits dans le tableau
des arguments TVM, page 134.
•
•
•
Si vous omettez Pmt, il prend par défaut la valeur
Pmt=tvmPmt(N,I,PV,FV,PpY,CpY,PmtAt).
Si vous omettez FV, il prend par défaut la valeur FV=0.
Les valeurs par défaut pour PpY, CpY et PmtAt sont les mêmes
que pour les fonctions TVM.
valArrondi spécifie le nombre de décimales pour arrondissement.
Valeur par défaut=2.
GPrn(NPmt1,NPmt2,tblAmortissement) calcule la somme du capital
sur la base du tableau d'amortissement tblAmortissement.
L'argument tblAmortissement doit être une matrice au format décrit
à tblAmortissement(), page 6.
Remarque : voir également GInt() ci-dessus et Bal(), page 13.
# (indirection)
Touches
/k
# ChaîneNomVar
Fait référence à la variable ChaîneNomVar. Permet d'utiliser des
chaînes de caractères pour créer des noms de variables dans une
fonction.
Crée ou fait référence à la variable xyz.
Donne la valeur de la variable (r) dont le nom est stocké dans la
variable s1.
E (notation scientifique)
Touche
i
mantisseEexposant
Saisit un nombre en notation scientifique. Ce nombre est interprété
sous la forme mantisse × 10exposant.
Conseil : pour entrer une puissance de 10 sans passer par un résultat
de valeur décimale, utilisez 10^entier.
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant @E. Par exemple, entrez 2.3@E4 pour avoir
2.3E4.
Guide de référence TI-Nspire™ CAS
157
g
(grades)
Expr1g ⇒ expression
Liste1g ⇒ liste
Matrice1g ⇒ matrice
Touche
¹
Touche
¹
Touche
¹
En mode Angle en degrés, grades ou radians :
Cette fonction permet d'utiliser un angle en grades en mode Angle en
degrés ou en radians.
En mode Angle en radians, multiplie Expr1 par p/200.
En mode Angle en degrés, multiplie Expr1 par g/100.
En mode Angle en grades, donne Expr1 inchangée.
Remarque : vous pouvez insérer ce symbole à partir du clavier de
l'ordinateur en entrant @g.
R(radians)
Expr1R ⇒ expression
Liste1R ⇒ liste
Matrice1R ⇒ matrice
En mode Angle en degrés, grades ou radians :
Cette fonction permet d'utiliser un angle en radians en mode Angle
en degrés ou en grades.
En mode Angle en degrés, multiplie l'argument par 180/p.
En mode Angle en radians, donne l'argument inchangé.
En mode Angle en grades, multiplie l'argument par 200/p.
Conseil : utilisez Rsi vous voulez forcer l'utilisation des radians dans
une définition de fonction quel que soit le mode dominant lors de
l'utilisation de la fonction.
Remarque : vous pouvez insérer ce symbole à partir du clavier de
l'ordinateur en entrant @r.
¡ (degré)
Expr1¡ ⇒ expression
Liste1¡ ⇒ liste
Matrice1¡ ⇒ matrice
En mode Angle en degrés, grades ou radians :
Cette fonction permet d'utiliser un angle en degrés en mode Angle en
grades ou en radians.
En mode Angle en radians, multiplie l'argument par p/180.
En mode Angle en degrés, donne l'argument inchangé.
En mode Angle en radians :
Appuyez sur Ctrl+Entrée
“+Enter) pour évaluer :
En mode Angle en grades, multiplie l'argument par 10/9.
Remarque : vous pouvez insérer ce symbole à partir du clavier de
l'ordinateur en entrant @d.
158
Guide de référence TI-Nspire™ CAS
/· (Macintosh®:
¡, ', '' (degré/minute/seconde)
dd¡mm'ss.ss'' ⇒ expression
dd
Touches
/k
Touches
/k
En mode Angle en degrés :
Nombre positif ou négatif
mm Nombre positif ou nul
ss.ss Nombre positif ou nul
Donne dd+(mm/60)+(ss.ss/3600).
Ce format d'entrée en base 60 permet :•
•
d'entrer un angle en degrés/minutes/secondes quel que soit le
mode angulaire utilisé.
d'entrer un temps exprimé en heures/minutes/secondes.
Remarque : faites suivre ss.ss de deux apostrophes ('') et non de
guillemets (").
± (angle)
[Rayon,±q_Angle] ⇒ vecteur
(entrée polaire)
En mode Angle en radians et avec le Format vecteur réglé sur :
rectangulaire
[Rayon,±q_Angle,Valeur_Z] ⇒ vecteur
(entrée cylindrique)
[Rayon,±q_Angle,±q_Angle] ⇒ vecteur
(entrée sphérique)
cylindrique
Donne les coordonnées sous forme de vecteur, suivant le réglage du
mode Format Vecteur : rectangulaire, cylindrique ou sphérique.
Remarque : vous pouvez insérer ce symbole à partir du clavier de
l'ordinateur en entrant @<.
sphérique
(Grandeur ± Angle) ⇒ valeurComplexe
(entrée polaire)
En mode Angle en radians et en mode Format complexe
Rectangulaire :
Saisit une valeur complexe en coordonnées polaires (r±q). L'Angle
est interprété suivant le mode Angle sélectionné.
Appuyez sur Ctrl+Entrée
“+Enter) pour évaluer :
' (guillemets)
/· (Macintosh®:
Touche
º
variable '
variable ''
Saisit le symbole prime dans une équation différentielle. Ce symbole
caractérise une équation différentielle du premier ordre ; deux
symboles prime, une équation différentielle du deuxième ordre, et
ainsi de suite.
Guide de référence TI-Nspire™ CAS
159
_ (trait bas considéré comme élément vide)
Voir “Éléments vides” , page 164.
_ (trait bas considéré comme unité)
Touches
/_
Expr_Unité
Indique l'unité d'une Expr. Tous les noms d'unités doivent
commencer par un trait de soulignement.
Il est possible d'utiliser les unités prédéfinies ou de créer des unités
personnalisées. Pour obtenir la liste des unités prédéfinies, ouvrez le
Catalogue et affichez l'onglet Conversion d'unité. Vous pouvez
sélectionner les noms d'unités dans le Catalogue ou les taper
directement.
Variable_
Remarque : vous pouvez trouver le symbole de conversion, 4,
dans le Catalogue. Cliquez sur
mathématiques.
, puis sur Opérateurs
En supposant que z est une variable non définie :
Si Variable n'a pas de valeur, elle est considérée comme représentant
un nombre complexe. Par défaut, sans _, la variable est considérée
comme réelle.
Si Variable a une valeur, _ est ignoré et Variable conserve son type
de données initial.
Remarque : vous pouvez stocker un nombre complexe dans une
variable sans utiliser _. Toutefois, pour optimiser les résultats dans
des calculs tels que cSolve() et cZeros(), l'utilisation de _ est
recommandée.
4 (conversion)
Touches
/k
Expr_Unité1 4 _Unité2 ⇒ Expr_Unité2
Convertit l'unité d'une expression.
Le trait bas de soulignement _ indique les unités. Les unités doivent
être de la même catégorie, comme Longueur ou Aire.
Pour obtenir la liste des unités prédéfinies, ouvrez le Catalogue et
affichez l'onglet Conversion d'unité :
•
•
Vous pouvez sélectionner un nom d'unité dans la liste.
Vous pouvez sélectionner l'opérateur de conversion, 4, en haut
de la liste.
Il est également possible de saisir manuellement les noms d'unités.
Pour saisir « _ » lors de l'entrée des noms d'unités sur la calculatrice,
appuyez sur
/_.
Remarque : pour convertir des unités de température, utilisez
tmpCnv() et @tmpCnv(). L'opérateur de conversion 4 ne gère pas les
unités de température.
10^()
Catalogue >
10^ (Expr1)
10^ (Liste1)
⇒ expression
⇒ liste
Donne 10 élevé à la puissance de l'argument.
Dans le cas d'une liste, donne 10 élevé à la puissance des éléments de
Liste1.
160
Guide de référence TI-Nspire™ CAS
10^()
10^(matriceCarrée1)
Catalogue >
⇒ matriceCarrée
Donne 10 élevé à la puissance de matriceCarrée1. Ce calcul est
différent du calcul de 10 élevé à la puissance de chaque élément.
Pour plus d'informations sur la méthode de calcul, reportez-vous à
cos().
matriceCarrée1 doit être diagonalisable. Le résultat contient
toujours des chiffres en virgule flottante.
^/ (inverse)
Catalogue >
Expr1 ^/ ⇒ expression
Liste1 ^/ ⇒ liste
Donne l'inverse de l'argument.
Dans le cas d'une liste, donne la liste des inverses des éléments de
Liste1.
matriceCarrée1 ^/ ⇒ matriceCarrée
Donne l'inverse de matriceCarrée1.
matriceCarrée1 doit être une matrice carrée non singulière.
| (“sachant que”)
Touches
/k
Expr | Expr booléenne1 [and Expr booléenne2]...
Le symbole | est utilisé comme opérateur binaire. L'opérande à
gauche du symbole | est une expression. L'opérande à droite du
symbole | spécifie une ou plusieurs relations destinées à affecter la
simplification de l'expression. Plusieurs relations après le symbole |
peuvent être reliées au moyen d'un « and ».
Cet opérateur fournit les trois types de fonctionnalités suivants :
substitutions, contraintes d'intervalle et exclusions.
Les substitutions se présentent sous forme d'une égalité, telle que
x=3 ou y=sin(x). Pour de meilleurs résultats, la partie gauche doit être
une variable simple. Expr | Variable = valeur substituera valeur à
chaque occurrence de Variable dans Expr.
Les contraintes d'intervalle se présentent sous la forme d'une ou
plusieurs inéquations reliées par des opérateurs « and » logiques. Les
contraintes d'intervalle permettent également la simplification qui
autrement pourrait ne pas être valide ou calculable.
Guide de référence TI-Nspire™ CAS
161
| (“sachant que”)
Touches
/k
Les exclusions utilisent l'opérateur relationnel « différent de » (/= ou
ƒ) pour exclure une valeur spécifique du calcul. Elles servent
principalement à exclure une solution exacte lors de l'utilisation de
cSolve(), cZeros(), fMax(), fMin(), solve(), zeros(), et ainsi de suite.
& (stocker)
Touche
/h
Expr & Var
Liste& Var
Matrice & Var
Expr & Fonction(Param1,...)
Liste & Fonction(Param1,...)
Matrice & Fonction(Param1,...)
Si la variable Var n'existe pas, celle-ci est créée par
cette instruction et est initialisée à Expr, Liste ou Matrice.
Si Var existe déjà et n'est pas verrouillée ou protégée, son contenu
est remplacé par Expr, Liste ou Matrice.
Conseil : si vous envisagez d'effectuer des calculs symboliques en
utilisant des variables non définies, ne stockez aucune valeur dans les
variables communément utilisées à une lettre, telles que a, b, c, x, y,
z, et ainsi de suite.
Remarque : vous pouvez insérer cet opérateur à partir du clavier de
l'ordinateur en entrant =: comme un raccourci. Par exemple,
tapez pi/4 =: Mavar.
:= (assigner)
Touches
/t
Touches
/k
Var := Expr
Var := Liste
Var := Matrice
Fonction(Param1,...) := Expr
Fonction(Param1,...) := Liste
Fonction(Param1,...) := Matrice
Si la variable Var n'existe pas, celle-ci est créée par
cette instruction et est initialisée à Expr, Liste ou Matrice.
Si Var existe déjà et n'est pas verrouillée ou protégée, son contenu
est remplacé par Expr, Liste ou Matrice.
Conseil : si vous envisagez d'effectuer des calculs symboliques en
utilisant des variables non définies, ne stockez aucune valeur dans les
variables communément utilisées à une lettre, telles que a, b, c, x, y,
z, et ainsi de suite.
© (commentaire)
© [texte]
© traite texte comme une ligne de commentaire, vous permettant
d'annoter les fonctions et les programmes que vous créez.
© peut être utilisé au début ou n'importe où dans la ligne. Tous les
caractères situés à droite de ©, jusqu'à la fin de la ligne, sont
considérés comme partie intégrante du commentaire.
Remarque pour la saisie des données de l'exemple :
dans l'application Calculs de l'unité nomade, vous pouvez entrer des
@ à la place de
· à chaque fin de ligne. Sur le clavier de l'ordinateur, maintenez
définitions sur plusieurs lignes en appuyant sur
enfoncée la touche Alt tout en appuyant sur Entrée (Enter).
162
Guide de référence TI-Nspire™ CAS
0b, 0h
0b nombreBinaire
0h nombreHexadécimal
Touches
0B, touches 0H
En mode base Dec :
Indique un nombre binaire ou hexadécimal, respectivement. Pour
entrer un nombre binaire ou hexadécimal, vous devez utiliser
respectivement le préfixe 0b ou 0h, quel que soit le mode Base utilisé. En mode base Bin :
Un nombre sans préfixe est considéré comme décimal (base 10).
Le résultat est affiché en fonction du mode Base utilisé.
En mode base Hex :
Guide de référence TI-Nspire™ CAS
163
Éléments vides
Lors de l'analyse de données réelles, il est possible que vous ne disposiez pas toujours d'un jeu
complet de données. TI-Nspire™ CAS vous permet d'avoir des éléments de données vides pour
vous permettre de disposer de données presque complètes plutôt que d'avoir à tout
recommencer ou à supprimer les données incomplètes.
Vous trouverez un exemple de données impliquant des éléments vides dans le chapitre Tableur
et listes, sous « Représentation graphique des données de tableau ».
La fonction delVoid() vous permet de supprimer les éléments vides d'une liste, tandis que la
fonction isVoid() vous offre la possibilité de tester si un élément est vide. Pour plus de détails,
voir delVoid(), page 36 et isVoid(), page 62.
Remarque : Pour entrer un élément vide manuellement dans une expression, tapez « _ » ou le
mot clé void. Le mot clé void est automatiquement converti en caractère « _ » lors du calcul
de l'expression. Pour saisir le caractère « _ » sur la calculatrice, appuyez sur / _.
Calculs impliquant des éléments vides
La plupart des calculs impliquant des éléments vides génère des
résultats vides. Reportez-vous à la liste des cas spéciaux ci-dessous.
Arguments de liste contenant des éléments vides
Les fonctions et commandes suivantes ignorent (passent) les
éléments vides rencontrés dans les arguments de liste.
count, countIf, cumulativeSum, freqTable4list,
frequency, max, mean, median, product, stDevPop,
stDevSamp, sum, sumIf, varPop et varSamp, ainsi que
les calculs de régression, OneVar, TwoVar et les statistiques
FiveNumSummary, les intervalles de confiance et les tests
statistiques.
SortA et SortD déplacent tous les éléments vides du premier
argument au bas de la liste.
164
Guide de référence TI-Nspire™ CAS
Arguments de liste contenant des éléments vides(continued)
Dans les regressions, la présence d'un élément vide dans la liste X ou
Y génère un élément vide correspondant dans le résidu.
L'omission d'une catégorie dans les calculs de régression génère un
élément vide correspondant dans le résidu.
Une fréquence 0 dans les calculs de régression génère un élement
vide correspondant dans le résidu.
Guide de référence TI-Nspire™ CAS
165
Raccourcis de saisie d'expressions mathématiques
Les raccourcis vous permettent de saisir directement des éléments d'expressions
mathématiques sans utiliser le Catalogue ni le Jeu de symboles. Par exemple, pour saisir
l'expression ‡6, vous pouvez taper sqrt(6) dans la ligne de saisie. Lorsque vous appuyez sur
·, l'expression sqrt(6) est remplacée par ‡6. Certains raccourcis peuvent s'avérer très utiles
aussi bien sur la calculatrice qu'à partir du clavier de l'ordinateur. Certains sont plus
spécifiquement destinés à être utilisés à partir du clavier de l'ordinateur.
Sur la calculatrice ou le clavier de l'ordinateur
Pour saisir :
Utilisez le raccourci :
p
pi
q
theta
ˆ
infinity
{
<=
|
>=
ƒ
/=
& (opérateur de stockage)
:=
| | (valeur absolue)
abs(...)
‡()
sqrt(...)
d()
derivative(...)
‰()
integral(...)
G() (Modèle Somme)
sumSeq(...)
Π() (Modèle Produit)
prodSeq(...)
sin/(), cos/(),
arcsin(...), arccos(...), ...
...
@List()
deltaList(...)
@tmpCnv()
deltaTmpCnv(...)
Sur le clavier de l'ordinateur
Pour saisir :
Utilisez le raccourci :
c1, c2,
... (constantes)
@c1, @c2, ...
n1, n2, ... (constantes
entières)
@n1, @n2, ...
i (le nombre complexe)
@i
e (base du logarithme
népérien e)
@e
166
Guide de référence TI-Nspire™ CAS
Pour saisir :
Utilisez le raccourci :
E (notation scientifique)
@E
T (transposée)
@t
R (radians)
@r
¡ (degré)
@d
G
@g
(grades)
± (angle)
@<
4 (conversion)
@>
4Decimal, 4approxFraction(), et
ainsi de suite.
@>Decimal, @>approxFraction(), et ainsi de suite.
Guide de référence TI-Nspire™ CAS
167
Hiérarchie de l'EOS™ (Equation Operating System)
Cette section décrit l'EOS™ (Equation Operating System) qu'utilise le labo de maths
TI-Nspire™ CAS. Avec ce système, la saisie des nombres, des variables et des fonctions est simple
et directe. Le logiciel EOS™ évalue les expressions et les équations en utilisant les groupements
à l'aide de parenthèses et en respectant l'ordre de priorité décrit ci-dessous.
Ordre d'évaluation
Nive
au
Opérateur
1
Parenthèses ( ), crochets [ ], accolades { }
2
Indirection (#)
3
Appels de fonction
4
Opérateurs en suffixe : degrés-minutes-secondes (-,',"), factoriel (!), pourcentage
Q
(%), radian ( RS), indice ([ ]), transposée (T)
5
Élévation à une puissance, opérateur de puissance (^)
6
Négation ( )
7
Concaténation de chaîne (&)
L
8
Multiplication (¦), division (/)
9
Addition (+), soustraction (-)
10
Relations d'égalité : égal à (=), différent de (ƒ ou /=),
inférieur à (<), inférieur ou égal à ({ ou <=), supérieur à (>), supérieur ou égal à (|
ou >=)
11
not logique
12
and logique
13
or logique, xor logique exclusif
14
Opérateur de contrainte « sachant que » (|)
15
De...vers (")
Parenthèses, crochets et accolades
Toutes les opérations entre parenthèses, crochets ou accolades sont calculées en premier lieu.
Par exemple, dans l'expression 4(1+2), l'EOS™ évalue en premier la partie de l'expression entre
parenthèses, 1+2, puis multiplie le résultat, 3, par 4.
Le nombre de parenthèses, crochets et accolades ouvrants et fermants doit être identique dans
une équation ou une expression. Si tel n'est pas le cas, un message d'erreur s'affiche pour
indiquer l'élément manquant. Par exemple, (1+2)/(3+4 génère l'affichage du message d'erreur
“) manquante”.
168
Guide de référence TI-Nspire™ CAS
Remarque : Parce que le logiciel TI-Nspire™ CAS vous permet de définir des fonctions
personnalisées, un nom de variable suivi d'une expression entre parenthèses est considéré
comme un « appel de fonction » et non comme une multiplication implicite. Par exemple,
a(b+c) est la fonction a évaluée en b+c. Pour multiplier l'expression b+c par la variable a, utilisez
la multiplication explicite : a∗(b+c).
Indirection
L'opérateur d'indirection (#) convertit une chaîne en une variable ou en un nom de fonction.
Par exemple, #(“x”&”y”&”z”) crée le nom de variable « xyz ». Cet opérateur permet également
de créer et de modifier des variables à partir d'un programme. Par exemple, si 10"r et “r”"s1,
donc #s1=10.
Opérateurs en suffixe
Les opérateurs en suffixe sont des opérateurs qui suivent immédiatement un argument, comme
5!, 25 % ou 60¡15' 45". Les arguments suivis d'un opérateur en suffixe ont le niveau de priorité
4 dans l'ordre d'évaluation. Par exemple, dans l'expression 4^3!, 3! est évalué en premier. Le
résultat, 6, devient l'exposant de 4 pour donner 4096.
Élévation à une puissance
L'élévation à la puissance (^) et l'élévation à la puissance élément par élément (.^) sont évaluées
de droite à gauche. Par exemple, l'expression 2^3^2 est évaluée comme 2^(3^2) pour donner
512. Ce qui est différent de (2^3)^2, qui donne 64.
Négation
Pour saisir un nombre négatif, appuyez sur v suivi du nombre. Les opérations et élévations à
la puissance postérieures sont évaluées avant la négation. Par exemple, le résultat de Lx2 est un
nombre négatif et L92 = L81. Utilisez les parenthèses pour mettre un nombre négatif au carré,
comme (L9)2 qui donne 81.
Contrainte (|)
L'argument qui suit l'opérateur “sachant que” (|) applique une série de contraintes qui
affectent l'évaluation de l'argument qui précède l'opérateur “sachant que”.
Guide de référence TI-Nspire™ CAS
169
Codes et messages d'erreur
En cas d'erreur, le code correspondant est assigné à la variable errCode. Les programmes et
fonctions définis par l'utilisateur peuvent être utilisés pour analyser errCode et déterminer
l'origine de l'erreur. Pour obtenir un exemple d'utilisation de errCode, reportez-vous à
l'exemple 2 fourni pour la commande Try, page 131.
certaines erreurs ne s'appliquent qu'aux produits TI-Nspire™ CAS, tandis que
d'autres ne s'appliquent qu'aux produits TI-Nspire™.
Remarque :
Code d'erreur
Description
10
La fonction n'a pas retourné de valeur.
20
Le test n'a pas donné de résultat VRAI ou FAUX.
En général, les variables indéfinies ne peuvent pas être comparées. Par exemple, le test If a<b génère cette erreur si
a ou b n'est pas défini lorsque l'instruction If est exécutée.
30
L'argument ne peut pas être un nom de dossier.
40
Erreur d'argument
50
Argument inadapté
Deux arguments ou plus doivent être de même type.
60
L'argument doit être une expression booléenne ou un entier.
70
L'argument doit être un nombre décimal.
90
L'argument doit être une liste.
100
L'argument doit être une matrice.
130
L'argument doit être une chaîne de caractères.
140
L'argument doit être un nom de variable.
Assurez-vous que ce nom :
• ne commence pas par un chiffre,
• ne contienne ni espaces ni caractères spéciaux,
• n'utilise pas le tiret de soulignement ou le point de façon incorrecte,
• ne dépasse pas les limitations de longueur.
Pour plus d'informations à ce sujet, reportez-vous à la section Calculs dans la documentation.
160
L'argument doit être une expression.
165
Piles trop faibles pour envoi/réception
Installez des piles neuves avant toute opération d'envoi ou de réception.
170
Bornes
Pour définir l'intervalle de recherche, la limite inférieure doit être inférieure à la limite supérieure.
180
Arrêt de calcul
Une pression sur la touche
programme.
d ou c a été détectée au cours d'un long calcul ou lors de l'exécution d'un
190
Définition circulaire
Ce message s'affiche lors des opérations de simplification afin d'éviter l'épuisement total de la mémoire lors d'un
remplacement infini de valeurs dans une variable en vue d'une simplification. Par exemple, a+1->a, où a représente
une variable indéfinie, génère cette erreur.
200
Condition invalide
Par exemple, solve(3x^2-4=0,x) | x<0 or x>5 génère ce message d'erreur car “or” est utilisé à la place de “and”
pour séparer les contraintes.
210
Type de données incorrect
Le type de l'un des arguments est incorrect.
170
Guide de référence TI-Nspire™ CAS
Code d'erreur
Description
220
Limite dépendante
230
Dimension
Un index de liste ou de matrice n'est pas valide. Par exemple, si la liste {1,2,3,4} est stockée dans L1, L1[5] constitue
une erreur de dimension, car L1 ne comporte que quatre éléments.
235
Erreur de dimension. Le nombre d'éléments dans les listes est insuffisant.
240
Dimension inadaptée
Deux arguments ou plus doivent être de même dimension. Par exemple, [1,2]+[1,2,3] constitue une dimension
inadaptée, car les matrices n'ont pas le même nombre d'éléments.
250
Division par zéro
260
Erreur de domaine
Un argument doit être situé dans un domaine spécifique. Par exemple, rand(0) est incorrect.
270
Nom de variable déjà utilisé
280
Else et ElseIf sont invalides hors du bloc If..EndIf.
290
La déclaration Else correspondant à EndTry manque.
295
Nombre excessif d'itérations
300
Une liste ou une matrice de dimension 2 ou 3 est requise.
310
Le premier argument de nSolve doit être une équation d'une seule variable. Il ne doit pas contenir d'inconnue autre
que la variable considérée.
320
Le premier argument de solve ou cSolve doit être une équation ou une inéquation.
Par exemple, solve(3x^2-4,x) n'est pas correct car le premier argument n'est pas une équation.
345
Unités incompatibles
350
Indice non valide
360
La chaîne d'indirection n'est pas un nom de variable valide.
380
Ans invalide
Le calcul précédent n'a pas créé Ans, ou aucun calcul précédent n'a pas été entré.
390
Affectation invalide
400
Valeur d'affectation invalide
410
Commande invalide
430
Invalide pour les réglages du mode en cours
435
Valeur Init invalide
440
Multiplication implicite invalide
Par exemple, x(x+1) est incorrect ; en revanche, x*(x+1) est correct. Cette syntaxe permet d'éviter toute confusion
entre les multiplications implicites et les appels de fonction.
450
Invalide dans une fonction ou expression courante
Seules certaines commandes sont valides à l'intérieure d'une fonction définie par l'utilisateur.
490
Invalide dans un bloc Try..EndTry
510
Liste ou matrice invalide
550
Invalide hors fonction ou programme
Un certain nombre de commandes ne sont pas valides hors d'une fonction ou d'un programme. Par exemple, la
commande Local ne peut pas être utilisée, excepté dans une fonction ou un programme.
560
Invalide hors des blocs Loop..EndLoop, For..EndFor ou While..EndWhile
Par exemple, la commande Exit n'est valide qu'à l'intérieur de ces blocs de boucle.
Guide de référence TI-Nspire™ CAS
171
Code d'erreur
Description
565
Invalide hors programme
570
Nom de chemin invalide
Par exemple, \var est incorrect.
575
Complexe invalide en polaire
580
Référence de programme invalide
Les programmes ne peuvent pas être référencés à l'intérieur de fonctions ou d'expressions, comme par exemple
1+p(x), où p est un programme.
600
Table invalide
605
Utilisation invalide d'unités
610
Nom de variable invalide dans une déclaration locale
620
Nom de variable ou de fonction invalide
630
Référence invalide à une variable
640
Syntaxe vectorielle invalide
650
Transmission
La transmission entre deux unités n'a pas pu aboutir. Vérifiez que les deux extrémités du câble sont correctement
branchées.
665
Matrice non diagonalisable
670
Mémoire insuffisante
1. Supprimez des données de ce classeur.
2. Enregistrez, puis fermez ce classeur.
Si les suggestions 1 & 2 échouent, retirez les piles, puis remettez-les en place.
680
( manquante
690
) manquante
700
“ manquant
710
] manquant
720
} manquante
730
Manque d'une instruction de début ou de fin de bloc
740
Then manquant dans le bloc If..EndIf
750
Ce nom n'est pas un nom de fonction ou de programme.
765
Aucune fonction n'est sélectionnée.
780
Aucune solution n'a été trouvée.
800
Résultat non réel
Par exemple, si le logiciel est réglé sur Réel, ‡(-1) n'est pas valide.
Pour autoriser les résultats complexes, réglez le mode “Réel ou Complexe” sur “RECTANGULAIRE ou POLAIRE”.
830
Capacité
850
Programme introuvable
Une référence de programme à l'intérieur d'un autre programme est introuvable au chemin spécifié au cours de
l'exécution.
855
Les fonctions aléatoires ne sont pas autorisées en mode graphique.
860
Le nombre d'appels est trop élevé.
172
Guide de référence TI-Nspire™ CAS
Code d'erreur
Description
870
Nom ou variable système réservé
900
Erreur d'argument
Le modèle Med-Med n'a pas pu être appliqué à l'ensemble de données.
920
Texte introuvable
930
Il n'y a pas assez d'arguments.
Un ou plusieurs arguments de la fonction ou de la commande n'ont pas été spécifiés.
940
Il y a trop d'arguments.
L'expression ou l'équation comporte un trop grand nombre d'arguments et ne peut pas être évaluée.
950
Il y a trop d'indices.
955
Il y a trop de variables indéfinies.
960
La variable n'est pas définie.
Aucune valeur n'a été associée à la variable. Utilisez l'une des commandes suivantes :
• sto &
• :=
•
Define
pour assigner des valeurs aux variables.
965
O.S sans licence
970
La variable est en cours d'utilisation. Aucune référence ni modification n'est autorisée.
980
Variable protégée
990
Nom de variable invalide
Assurez-vous que le nom n'excède pas la limite de longueur.
1000
Domaine de variables de fenêtre
1010
Zoom
1020
Erreur interne
1030
Accès illicite à la mémoire
1040
Fonction non prise en charge. Cette fonction requiert CAS (Computer Algebra System). Essayez d'utiliser TI-Nspire™
CAS.
1045
Opérateur non pris en charge. Cet opérateur requiert CAS (Computer Algebra System). Essayez d'utiliser TI-Nspire™
CAS.
1050
Fonction non prise en charge. Cet opérateur requiert CAS (Computer Algebra System). Essayez d'utiliser TI-Nspire™
CAS.
1060
L'argument entré doit être numérique. Seules les entrées comportant des valeurs numériques sont autorisées.
1070
L'argument de la fonction trig est trop grand pour une réduction fiable.
1080
Utilisation de Ans non prise en charge. Cette application n'assure pas la prise en charge de Ans.
1090
La fonction n'est pas définie. Utilisez l'une des commandes suivantes :
•
Define
• :=
• sto &
pour définir une fonction.
1100
Calcul non réel
Par exemple, si le logiciel est réglé sur Réel, ‡(-1) n'est pas valide.
Pour autoriser les résultats complexes, réglez le mode “Réel ou Complexe” sur “RECTANGULAIRE ou POLAIRE”.
1110
Limites invalides
Guide de référence TI-Nspire™ CAS
173
Code d'erreur
Description
1120
Pas de changement de signe
1130
L'argument ne peut être ni une liste ni une matrice.
1140
Erreur d'argument
Le premier argument doit être une expression polynomiale du second argument. Si le second argument est omis, le
logiciel tente de sélectionner une valeur par défaut.
1150
Erreur d'argument
Les deux premiers arguments doivent être des expressions polynomiales du troisième argument. Si le troisième
argument est omis, le logiciel tente de sélectionner une valeur par défaut.
1160
Nom de chemin de bibliothèque invalide
Les noms de chemins doivent utiliser le format xxx\yyy, où :
• La partie xxx du nom peut contenir de 1 à 16 caractères, et
• la partie yyy, si elle est utilisée, de 1 à 15 caractères.
Pour plus d'informations à ce sujet, reportez-vous à la section Bibliothèques dans la documentation.
1170
Utilisation invalide de nom de chemin de bibliothèque
• Une valeur ne peut pas être assignée à un nom de chemin en utilisant la commande Define, := ou sto &.
• Un nom de chemin ne peut pas être déclaré comme variable Local ni être utilisé dans une définition de
fonction ou de programme.
1180
Nom de variable de bibliothèque invalide.
Assurez-vous que ce nom :
• ne contienne pas de point,
• ne commence pas par un tiret de soulignement,
• ne contienne pas plus de 15 caractères.
Pour plus d'informations à ce sujet, reportez-vous à la section Bibliothèques dans la documentation.
1190
Classeur de bibliothèque introuvable :
• Vérifiez que la bibliothèque se trouve dans le dossier Ma bibliothèque.
• Rafraîchissez les bibliothèques.
Pour plus d'informations à ce sujet, reportez-vous à la section Bibliothèques dans la documentation.
1200
Variable de bibliothèque introuvable :
• Vérifiez que la variable de bibliothèque existe dans la première activité de la bibliothèque.
• Assurez-vous d'avoir défini la variable de bibliothèque comme objet LibPub ou LibPriv.
• Rafraîchissez les bibliothèques.
Pour plus d'informations à ce sujet, reportez-vous à la section Bibliothèques dans la documentation.
1210
Nom de raccourci de bibliothèque invalide
Assurez-vous que ce nom :
• ne contienne pas de point,
• ne commence pas par un tiret de soulignement,
• ne contienne pas plus de 16 caractères,
• ne soit pas un nom réservé.
Pour plus d'informations à ce sujet, reportez-vous à la section Bibliothèques dans la documentation.
1220
Erreur d'argument :
Les fonctions tangentLine et normalLine prennent uniquement en charge les fonctions à valeurs réelles.
1230
Erreur de domaine.
Les opérateurs de conversion trigonométrique ne sont pas autorisés en mode Angle Degré ou Grade.
1250
Erreur d'argument
Utilisez un système d'équations linéaires.
Exemple de système à deux équations linéaires avec des variables x et y :
3x+7y=5
2y-5x=-1
1260
Erreur d'argument :
Le premier argument de nfMin ou nfMax doit être une expression dans une seule variable. Il ne doit pas contenir
d'inconnue autre que la variable considérée.
1270
Erreur d'argument
La dérivée doit être une dérivée première ou seconde.
174
Guide de référence TI-Nspire™ CAS
Code d'erreur
Description
1280
Erreur d'argument
Utilisez un polynôme dans sa forme développée dans une seule variable.
1290
Erreur d'argument
Utilisez un polynôme dans une seule variable.
1300
Erreur d'argument
Les coefficients du polynôme doivent s'évaluer à des valeurs numériques.
1310
Erreur d'argument :
Une fonction n'a pas pu être évaluée en un ou plusieurs de ses arguments.
Codes et messages d'avertissement
Vous pouvez utiliser la fonction warnCodes() pour stocker les codes d'avertissement générés lors
du calcul d'une expression. Le tableau ci-dessous présente chaque code d'avertissement et le
message associé.
Pour un exemple de stockage des codes d'avertissement, voir warnCodes(), page 137.
Code
d'avertissem
ent
Message
10000
L’opération peut donner des solutions fausses.
10001
L'équation générée par dérivation peut être fausse.
10002
Solution incertaine
10003
Précision incertaine
10004
L’opération peut omettre des solutions.
10005
CSolve peut donner plus de zéros.
10006
Solve peut donner plus de zéros.
10007
Autres solutions possibles
10008
Le domaine du résultat peut être plus petit que le domaine de l’entrée.
10009
Le domaine du résultat peut être plus grand que le domaine de l’entrée.
10012
Calcul non réel
10013
ˆ^0 ou undef^0 remplacés par 1.
10014
undef^0 remplacé par 1.
10015
1^ou 1^undef remplacés par 1
10016
1^undef remplacé par 1
10017
Capacité remplacée par ˆ ou Lˆ
10018
Requiert et retourne une valeur 64 bits.
10019
Ressources insuffisantes, la simplification peut être incomplète.
10020
L'argument de la fonction trigonométrique est trop grand pour une réduction fiable.
10021
Les données saisies comportent un paramètre non défini.
Le résultat peut ne pas être valide pour toutes les valeurs possibles du paramètre.
Guide de référence TI-Nspire™ CAS
175
Code
d'avertissem
ent
Message
10022
La spécification des bornes inférieure et supérieure peut donner une solution.
10023
Le scalaire a été multiplié par la matrice d'identité.
10024
Résultat obtenu en utilisant un calcule approché
10025
L'équivalence ne peut pas être vérifiée en mode EXACT.
10026
La contrainte peut être ignorée. Spécifiez la contrainte sous forme de type 'Constante avec symbole de test
mathématique variable' "\" ou en combinant ces deux formes (par exemple, par exemple "x<3 et x>-12").
176
Guide de référence TI-Nspire™ CAS
Informations générales
Informations sur les services et la garantie TI
Informations sur les Pour plus d'informations sur les produits et les
produits et les
services TI, contactez TI par e-mail ou consultez
services TI
la pages du site Internet éducatif de TI.
adresse e-mail : ti-cares@ti.com
adresse internet : education.ti.com
Informations sur les Pour plus d'informations sur la durée et les
services et le
termes du contrat de garantie ou sur les services
contrat de garantie liés aux produits TI, consultez la garantie
fournie avec ce produit ou contactez votre
revendeur Texas Instruments habituel.
Informations générales
177
178
Informations générales
Index
Symboles
Nombre
^, puissance 147
^/, inverse 161
_, désignation d'unité 160
:=, assigner 162
!, factorielle 152
.^, Puissance élément par élément
149
.*, multiplication élément par
élément 148
.+, addition élément par élément
148
.N, soustraction élément par
élément 148
.P, division élément par élément 149
', minutes 159
", secondes 159
{, inférieur ou égal à 151
©, commentaire 162
@list( ), liste des différences 69
-, degrés 158
-, degrés/minutes/secondes 159
4, conversion d'unité 160
â, intégrale 153
á, racine carrée 154
É, différent de 151
N, soustraction 145
P, division 146
Π, produit 155
Σ( ), somme 155
*, multiplication 146
&, ajouter 152
&, stocker 162
#, indirection 157
#, opérateur d'indirection 169
%, pourcentage 150
+, somme 145
<, inférieur à 151
=, égal à 150
>, supérieur à 151
|, sachant que 161
|, supérieur ou égal à 152
0b, indicateur binaire 163
0h, indicateur hexadécimal 163
10^( ), puissance de 10 160
4approxFraction( ) 10
A
abs( ), valeur absolue 6
affichage degrés/minutes/secondes,
4DMS 39
afficher
vecteur en données
rectangulaires, 4Rect 100
afficher comme
angle décimal, 4DD 34
afficher données, Disp 39
afficher vecteur
en coordonnées cylindriques,
4Cylind 31
en coordonnées polaires, 4Polar
90
vecteur en coordonnées
sphériques, 4Sphere 120
afficher vecteur en coordonnées
cylindriques, 4Cylind 31
afficher vecteur en coordonnées
rectangulaires, 4Rect 100
afficher vecteur en coordonnées
sphériques, 4Sphere 120
afficher/donner
dénominateur, getDenom( ) 54
informations sur les variables,
getVarInfo( ) 54, 56
nombre, getNum( ) 56
ajouter, & 152
ajustement
degré 2, QuadReg 96
degré 4, QuartReg 97
exponentiel, ExpReg 46
linéaire MedMed, MedMed 77
logarithmique, LnReg 70
Logistic 73
logistique, Logistic 74
MultReg 80
179
puissance, PowerReg 93
régression linéaire, LinRegBx 65,
67
régression linéaire, LinRegMx 66
sinusoïdale, SinReg 116
ajustement de degré 2, QuadReg 96
ajustement de degré 3, CubicReg 30
ajustement exponentiel, ExpReg 46
aléatoire
initialisation nombres, RandSeed
100
matrice, randMat( ) 99
nombre, randNorm( ) 99
polynôme, randPoly( ) 99
amortTbl( ), tableau
d'amortissement 6, 13
and, et booléen 6
angle( ), argument 7
ANOVA, analyse unidirectionnelle
de variance 7
ANOVA2way, analyse de variance à
deux facteurs 8
Ans, dernière réponse 10
approché, approx( ) 10, 11
approx( ), approché 10, 11
approxRational( ) 10
arc cosinus, cos/( ) 24
arc sinus, sin/( ) 115
arc tangente, tan/( ) 126
arccos() 10
arccosh() 11
arccot() 11
arccoth() 11
arccsc() 11
arccsch() 11
arcLen( ), longueur d'arc 11
arcsec() 11
arcsech() 11
arcsin() 11
arctan() 11
argsh() 11
argth() 11
argument, angle( ) 7
arguments présents dans les
fonctions TVM 134
arguments TVM 134
arrondi, round( ) 105
180
augment( ), augmenter/concaténer
11
augmenter/concaténer, augment( )
11
avgRC( ), taux d'accroissement
moyen 12
B
4Base10, afficher comme entier
décimal 14
4Base16, convertir en nombre
hexadécimal 15
4Base2, convertir en nombre binaire
13
bibliothèque
créer des raccourcis vers des
objets 64
binaire
convertir, 4Base2 13
indicateur, 0b 163
binomCdf( ) 15
binomPdf( ) 15
booléen
ou exclusif, xor 138
ou, or 88
booléenne
négation, not 85
boucle, Loop 75
C
c22way 17
c2Cdf( ) 18
c2GOF 18
c2Pdf( ) 18
caractère
chaîne, char( ) 17
code de caractère, ord( ) 88
Cdf( ) 48
ceiling( ), entier suivant 15
centralDiff( ) 16
cFactor( ), facteur complexe 16
chaîne
ajouter, & 152
chaîne de caractères, char( ) 17
code de caractère, ord( ) 88
convertir chaîne en expression,
expr( ) 46, 72
convertir expression en chaîne,
string( ) 123
décalage, shift( ) 112
dimension, dim( ) 38
droite, right( ) 103
format, format( ) 51
formatage 51
gauche, left( ) 63
indirection, # 157
longueur 38
numéro dans la chaîne, InString
60
permutation circulaire, rotate( )
105
pivoter, pivoter( ) 104
portion de chaîne, mid( ) 78
utilisation, création de nom de
variable 169
chaîne de caractères, char( ) 17
chaîne format, format( ) 51
char( ), chaîne de caractères 17
charPoly( ) 17
ClearAZ 19
ClrErr, effacer erreur 19
codes et messages d'avertissement
175
colAugment 19
colDim( ), nombre de colonnes de la
matrice 19
colNorm( ), norme de la matrice 19
combinaisons, nCr( ) 82
comDenom( ), dénominateur
commun 20
Commande Stop 123
commande Text 128
commentaire, © 162
completeSquare( ), complete square
21
complexe
conjugué, conj( ) 21
facteur, cFactor( ) 16
résolution, cSolve( ) 28
zéros, cZeros( ) 32
comptage conditionnel d'éléments
dans une liste, countif( ) 26
comptage du nombre de jours entre
deux dates, dbd( ) 33
compter les éléments d'une liste,
count( ) 26
conj( ), conjugué complexe 21
constante
dans solve( ) 117
constantes
dans cSolve( ) 30
dans cZeros( ) 33
dans deSolve( ) 37
dans solve( ) 118
raccourcis 166
constructMat( ), construire une
matrice 21
construire une matrice,
constructMat( ) 21
convertir
4Grad 57
4Rad 98
binaire, 4Base2 13
degrés/minutes/secondes, 4DMS
39
entier décimal, 4Base10 14
hexadécimal, 4Base16 15
unité 160
convertir liste en matrice, list4mat( )
69
convertir matrice en liste, mat4list( )
76
coordonnée x rectangulaire, P4Rx( )
89
coordonnée y rectangulaire, P4Ry( )
89
copier la variable ou fonction,
CopyVar 22
copyright statement ii
corrMat( ), matrice de corrélation
22
4cos, exprimer les valeurs en cosinus
22
cos( ), cosinus 23
cos/, arc cosinus 24
cosh( ), cosinus hyperbolique 24
cosh/( ), argument cosinus
hyperbolique 24
cosinus
afficher l'expression en 22
cosinus, cos( ) 23
cot( ), cotangente 25
181
cot/( ), argument cotangente
hyperbolique 25
cotangente, cot( ) 25
coth( ), cotangente hyperbolique 25
coth/( ), arc cotangente
hyperbolique 26
count( ), compter les éléments d'une
liste 26
countif( ), comptage conditionnel
d'éléments dans une liste 26
cPolyRoots() 27
crossP( ), produit vectoriel 27
csc( ), cosécante 27
csc/( ), argument cosécante 28
csch( ), cosécante hyperbolique 28
csch/( ), argument cosécante
hyperbolique 28
cSolve( ), résolution complexe 28
CubicReg, ajustement de degré 3 30
cumulativeSum( ), somme cumulée
31
Cycle, cycle 31
cycle, Cycle 31
4Cylind, afficher vecteur en
coordonnées cylindriques 31
cZeros( ), zéros complexes 32
D
d ( ), dérivée première 153
dbd( ), nombre de jours entre deux
dates 33
4DD, afficher comme angle décimal
34
décalage, shift( ) 112
4Decimal, afficher le résultat sous
forme décimale 34
décimal
afficher angle, 4DD 34
afficher entier, 4Base10 14
Define 34
Define LibPriv 35
Define LibPub 36
Define, définir 34
définir, Define 34
définition
fonction ou programme privé 35
182
fonction ou programme public
36
degrés, - 158
degrés/minutes/secondes 159
deltaList() 36
deltaTmpCnv() 36
DelVar, suppression variable 36
delVoid( ), supprimer les éléments
vides 36
dénominateur 20
dénominateur commun,
comDenom( ) 20
densité de probabilité pour la loi
normale, normPdf( ) 84
densité de probabilité pour la loi
Student-t, tPdf( ) 130
derivative() 36
dérivée
dérivée numérique, nDeriv( ) 83
dérivée première, d ( ) 153
dérivée implicite, Impdif( ) 60
dérivée ou dérivée n-ième
modèle 5
dérivée première
modèle 4
dérivée seconde
modèle 5
dérivées
dérivée numérique,
nDerivative( ) 82
deSolve( ), solution 37
det( ), déterminant de matrice 38
développement trigonométrique,
tExpand( ) 128
développer, expand( ) 45
déverrouillage des variables et des
groupes de variables 136
diag( ), matrice diagonale 38
différent de, É 151
dim( ), dimension 38
dimension, dim( ) 38
Disp, afficher données 39
division, P 146
4DMS, afficher en degrés/minutes/
secondes 39
dominantTerm( ), terme dominant
40
dotP( ), produit scalaire 40
effacer erreur, ClrErr 19
passer erreur, PassErr 89
droite, right( ) 103
E
e élevé à une puissance, e^( ) 41, 44
e^( ), e élevé à une puissance 41
e, afficher l'expression en 44
E, exposant 157
écart-type, stdDev( ) 122, 136
échantillon aléatoire 99
eff ), conversion du taux nominal au
taux effectif 41
effacer
erreur, ClrErr 19
égal à, = 150
eigVc( ), vecteur propre 41
eigVl( ), valeur propre 42
élément par élément
addition, .+ 148
division, .P 149
multiplication, .* 148
puissance, .^ 149
soustraction, .N 148
élément vide, tester 62
éléments vides 164
éléments vides, supprimer 36
else, Else 58
ElseIf 42
end
EndLoop 75
fonction, EndFunc 53
if, EndIf 58
programme, EndPrgm 94
try, EndTry 131
while, EndWhile 138
end function, EndFunc 53
end while, EndWhile 138
EndIf 58
EndLoop 75
EndTry, end try 131
EndWhile 138
entier suivant, ceiling( ) 15, 16, 27
entrée, Input 60
EOS (Equation Operating System)
168
Equation Operating System (EOS)
168
erreurs et dépannage
et
booléen, and 6
étiquette, Lbl 63
euler( ), Euler function 43
évaluation, ordre d' 168
évaluer le polynôme, polyEval( ) 91
exact, exact( ) 43
exact( ), exact 43
Exit 44
exp( ), e élevé à une puissance 44
exp4liste( ), conversion expression en
liste 45
expand( ), développer 45
exposant
modèle 1
exposant e
modèle 2
exposant, E 157
4exp, exprimer les valeurs en e 44
expr( ), convertir chaîne en
expression 46, 72
ExpReg, ajustement exponentiel 46
expression
conversion expression en liste,
exp4list( ) 45
convertir chaîne en expression,
expr( ) 46, 72
F
factor( ), factoriser 47
factorielle, ! 152
factorisation QR, QR 95
factoriser, factor( ) 47
Fill, remplir matrice 48
fin
EndFor 50
FiveNumSummary 49
floor( ), partie entière 49
fMax( ), maximum de fonction 49
fMin( ), minimum de fonction 50
fonction
définie par l'utilisateur 34
fractionnaire, fpart( ) 51
Func 53
maximum, fMax( ) 49
183
minimum, fMin( ) 50
Fonction de répartition de la loi de
Student-t, tCdf( ) 127
fonction définie par morceaux (2
morceaux)
modèle 2
fonction définie par morceaux (n
morceaux)
modèle 2
fonction financière, tvmFV( ) 133
fonction financière, tvmI( ) 133
fonction financière, tvmN( ) 133
fonction financière, tvmPmt( ) 133
fonction financière, tvmPV( ) 133
fonctions de distribution
binomCdf( ) 15
binomPdf( ) 15
c22way( ) 17
c2Cdf( ) 18
c2GOF( ) 18
c2Pdf( ) 18
Invc2( ) 61
invNorm( ) 61
invt( ) 61
normCdf( ) 84
normPdf( ) 84
poissCdf( ) 90
poissPdf( ) 90
tCdf( ) 127
tPdf( ) 130
fonctions définies par l'utilisateur
34
fonctions et programmes définis par
l'utilisateur 35, 36
fonctions et variables
copie 22
For 50
format( ), chaîne format 51
forme échelonnée (réduite de
Gauss), ref( ) 101
forme échelonnée réduite par lignes
(réduite de Gauss-Jordan), rref( )
106
fpart( ), partie fractionnaire 51
fraction
FracProp 95
modèle 1
fraction propre, propFrac 95
184
freqTable( ) 52
frequency( ) 52
F-Test sur 2 échantillons 52
Func 53
Func, fonction 53
G
G
, grades 158
gauche, left( ) 63
gcd( ), plus grand commun diviseur
53
geomCdf( ) 54
geomPdf( ) 54
getDenom( ), afficher/donner
dénominateur 54
getLangInfo( ), afficher/donner les
informations sur la langue 54
getLockInfo( ), teste l'état de
verrouillage d'une variable ou
d'un groupe de variables 55
getMode( ), réglage des modes 55
getNum( ), afficher/donner nombre
56
getType( ), get type of variable 56
getVarInfo( ), afficher/donner les
informations sur les variables 56
Goto 57
4, convertir mesure d'angle en
grades 57
grades, G 158
groupes, tester l'état de verrouillage
55
groupes, verrouillage et
déverrouillage 71, 136
H
hexadécimal
convertir, 4Base16 15
indicateur, 0h 163
hyperbolique
argument cosinus, cosh/( ) 24
argument sinus, sinh/( ) 115
argument tangente, tanh/( )
127
cosinus, cosh( ) 24
sinus, sinh( ) 115
tangente, tanh( ) 126
I
identity( ), matrice identité 58
If 58
ifFn( ) 59
imag( ), partie imaginaire 59
ImpDif( ), dérivée implicite 60
indirection, # 157
inférieur à, < 151
inférieur ou égal à, { 151
Input, entrée 60
inString( ), numéro dans la chaîne
60
int( ), partie entière 60
intDiv( ), quotient (division
euclidienne) 60
intégrale définie
modèle 5
intégrale indéfinie
modèle 5
intégrale, â 153
interpolate( ), interpolate 61
Invc2( ) 61
inverse fonction de répartition loi
normale (invNorm( ) 61
inverse, ^/ 161
invF( ) 61
invNorm( ), inverse fonction de
répartition loi normale 61
invt( ) 61
iPart( ), partie entière 62
irr( ), taux interne de rentabilité
taux interne de rentabilité, irr( )
62
isPrime( ), test de nombre premier
62
isVoid( ), tester l'élément vide 62
L
langue
afficher les informations sur la
langue 54
Lbl, étiquette 63
lcm, plus petit commun multiple 63
left( ), gauche 63
LibPriv 35
LibPub 36
libShortcut( ), créer des raccourcis
vers des objets de bibliothèque
64
limit( ) ou lim( ), limite 64
limite
lim( ) 64
limit( ) 64
modèle 5
linéarisation trigonométrique,
tCollect( ) 128
LinRegBx, régression linéaire 65
LinRegMx, régression linéaire 66
LinRegtIntervals, régression linéaire
67
LinRegtTest 68
linSolve() 69
list4mat( ), convertir liste en matrice
69
liste
augmenter/concaténer,
augment( ) 11
conversion expression en liste,
exp4list( ) 45
convertir liste en matrice,
list4mat( ) 69
convertir matrice en liste,
mat4list( ) 76
des différences, @list( ) 69
différences dans une liste, @list( )
69
éléments vides 164
maximum, max( ) 76
minimum, min( ) 78
nouvelle, newList( ) 82
portion de chaîne, mid( ) 78
produit scalaire, dotP( ) 40
produit vectoriel, crossP( ) 27
produit, product( ) 94
somme cumulée,
cumulativeSum( ) 31
somme, sum( ) 123, 124
tri croissant, SortA 119
tri décroissant, SortD 119
liste, comptage conditionnel
d'éléments dans 26
liste, compter les éléments 26
ln( ), logarithme népérien 70
LnReg, régression logarithmique 70
185
Local, variable locale 71
locale, Local 71
Lock, verrouiller une variable ou
groupe de variables 71
logarithme 70
modèle 2
logarithme népérien, ln( ) 70
Logistic, régression logistique 73
LogisticD, régression logistique 74
longueur d'arc, arcLen( ) 11
longueur d'une chaîne 38
Loop, boucle 75
LU, décomposition LU d'une matrice
75
M
mat4list( ), convertir matrice en liste
76
matrice
addition élément par élément, .+
148
ajout ligne, rowAdd( ) 106
aléatoire, randMat( ) 99
augmenter/concaténer,
augment( ) 11
convertir liste en matrice,
list4mat( ) 69
convertir matrice en liste,
mat4list( ) 76
décomposition LU, LU 75
déterminant, det( ) 38
diagonale, diag( ) 38
dimension, dim( ) 38
division élément par élément, .P
149
échange de lignes, rowSwap( )
106
factorisation QR, QR 95
forme échelonnée (réduite de
Gauss), ref( ) 101
forme échelonnée réduite par
lignes (réduite de GaussJordan), rref( ) 106
maximum, max( ) 76
minimum, min( ) 78
multiplication élément par
élément, .* 148
186
multiplication et addition sur
ligne de matrice,
mRowAdd( ) 79
nombre de colonnes, colDim( )
19
nombre de lignes, rowDim( )
106
norme (colonnes), colNorm( ) 19
norme (lignes), rowNorm( ) 106
nouvelle, newMat( ) 82
opération sur ligne de matrice,
mRow( ) 79
produit, product( ) 94
Puissance élément par élément,
.^ 149
remplir, Fill 48
somme cumulée,
cumulativeSum( ) 31
somme, sum( ) 123, 124
sous-matrice, subMat( ) 123,
124
soustraction élément par
élément, .N 148
transposée, T 125
unité, identity( ) 58
valeur propre, eigVl( ) 42
vecteur propre, eigVc( ) 41
matrice (1 Q 2)
modèle 3
matrice (2 Q 1)
modèle 4
matrice (2 Q 2)
modèle 3
matrice (m Q n)
modèle 4
matrice de corrélation, corrMat( )
22
matrice identité, identity( ) 58
max( ), maximum 76
maximum, max( ) 76
mean( ), moyenne 76
median( ), médiane 77
médiane, median( ) 77
MedMed, régression linéaire
MedMed 77
mid( ), portion de chaîne 78
min( ), minimum 78
minimum, min( ) 78
minutes, ' 159
mirr( ), Taux interne de rentabilité
modifié 79
mod( ), modulo 79
modèle
dérivée ou dérivée n-ième 5
dérivée première 4
dérivée seconde 5
e exposant 2
exposant 1
fonction définie par morceaux (2
morceaux) 2
fonction définie par morceaux (n
morceaux) 2
fraction 1
intégrale définie 5
intégrale indéfinie 5
limite 5
logarithme 2
matrice (1 Q 2) 3
matrice (2 Q 1) 4
matrice (2 Q 2) 3
matrice (m Q n) 4
produit (Π) 4
racine carrée 1
racine n-ième 1
somme (G) 4
système de 2 équations 3
système de n équations 3
Valeur absolue 3
modes
définition, setMode( ) 111
modulo, mod( ) 79
moyenne, mean( ) 76
mRow( ), opération sur ligne de
matrice 79
mRowAdd( ), multiplication et
addition sur ligne de matrice 79
multiplication, * 146
MultReg 80
MultRegIntervals( ) 80
MultRegTests( ) 81
N
nCr( ), combinaisons 82
nDerivative( ), dérivée numérique
82
négation (booléenne), not 85
négation, saisie de nombres négatifs
169
newList( ), nouvelle liste 82
newMat( ), nouvelle matrice 82
nfMax( ), maximum de fonction
numérique 83
nfMin( ), minimum de fonction
numérique 83
nInt( ), intégrale numérique 83
nom ), conversion du taux effectif au
taux nominal 84
nombre de jours entre deux dates,
dbd( ) 33
nombre de permutations, nPr( ) 85
norm( ), norme de Frobenius 84
normale, normalLine( ) 84
normalLine( ) 84
normCdf( ) 84
norme de Frobenius, norm( ) 84
normPdf( ) 84
not, négation booléenne 85
nouvelle
liste, newList( ) 82
matrice, newMat( ) 82
nPr( ), nombre de permutations 85
npv( ), valeur actuelle nette 86
nSolve( ), solution numérique 86
numérique
dérivée, nDeriv( ) 83
dérivée, nDerivative( ) 82
intégrale, nInt( ) 83
solution, nSolve( ) 86
numéro dans la chaîne, inString( )
60
O
objet
créer des raccourcis vers la
bibliothèque 64
OneVar, statistiques à une variable
87
opérateur
ordre d'évaluation 168
opérateur d'indirection (#) 169
or, ou booléen 88
187
ord( ), code numérique de caractère
88
ou (booléen), or 88
ou exclusif (booléen), xor 138
P
P4Rx( ), coordonnée x rectangulaire
89
P4Ry( ), coordonnée y rectangulaire
89
partie entière, floor( ) 49
partie entière, int( ) 60
partie entière, iPart( ) 62
partie imaginaire, imag( ) 59
passer erreur, PassErr 89
PassErr, passer erreur 89
Pdf( ) 51
permutation circulaire, rotate( ) 105
piecewise( ) 90
pivoter, pivoter( ) 104
pivoter( ), pivoter 104
plus grand commun diviseur, gcd( )
53
plus petit commun multiple, lcm()
63
poissCdf( ) 90
poissPdf( ) 90
polaire
coordonnée, R4Pq( ) 98
coordonnée, R4Pr( ) 98
4Polar, afficher vecteur en
coordonnées polaires 90
polar
afficher vecteur, vecteur en
coordonnées 4Polar 90
polyCoef( ) 91
polyDegree( ) 91
polyEval( ), évaluer le polynôme 91
polyGcd( ) 92
polynôme
aléatoire, randPoly( ) 99
évaluer, polyEval( ) 91
polynôme de Taylor, taylor( ) 127
PolyRoots() 93
portion de chaîne, mid( ) 78
pourcentage, % 150
PowerReg, puissance 93
188
Prgm, définir programme 94
probabilité de loi normale,
normCdf( ) 84
prodSeq() 94
product( ), produit 94
produit (Π)
modèle 4
produit vectoriel, crossP( ) 27
produit, Π( ) 155
produit, product( ) 94
programmation
afficher données, Disp 39
définir programme, Prgm 94
passer erreur, PassErr 89
programmes
définition d'une bibliothèque
privée 35
définition d'une bibliothèque
publique 36
programmes et programmation
afficher écran E/S, Disp 39
effacer erreur, ClrErr 19
end program, EndPrgm 94
end try, EndTry 131
try, Try 131
propFrac, fraction propre 95
puissance de 10, 10^( ) 160
puissance, ^ 147
puissance, PowerReg 93, 102, 103,
128
Q
QR, factorisation QR 95
QuadReg, ajustement de degré 2 96
QuartReg, régression de degré 4 97
quotient (division euclidienne),
intDiv( ) 60
R
R, radians 158
R4Pq( ), coordonnée polaire 98
R4Pr( ), coordonnée polaire 98
raccourcis clavier 166
raccourcis, clavier 166
racine carrée
modèle 1
racine carrée, ‡( ) 120, 154
racine n-ième
modèle 1
4Rad, convertir angle en radians 98
radians, R 158
rand( ), nombre aléatoire 98
randBin, nombre aléatoire 99
randInt( ), entier aléatoire 99
randMat( ), matrice aléatoire 99
randNorm( ), nombre aléatoire 99
randPoly( ), polynôme aléatoire 99
randSamp( ) 99
RandSeed, initialisation nombres
aléatoires 100
real( ), réel 100
4Rect, afficher vecteur en
coordonnées rectangulaires 100
réel, real( ) 100
ref( ), forme échelonnée (réduite de
Gauss) 101
réglage des modes, getMode( ) 55
réglages, mode actuel 55
régression
degré 3, CubicReg 30
puissance, PowerReg 93, 102,
103, 128
régression de degré 4, QuartReg 97
régression linéaire MedMed,
MedMed 77
régression linéaire, LinRegBx 65, 67
régression linéaire, LinRegMx 66
régression logarithmique, LnReg 70
régression logistique, Logistic 73
régression logistique, LogisticD 74
régression sinusoïdale, SinReg 116
remain( ), reste (division
euclidienne) 101
réponse (dernière), Ans 10
RequestStr 103
Requête 102
résolution simultanée d'équations,
simult( ) 113
résolution, solve( ) 117
reste (division euclidienne),
remain( ) 101
résultat
exprime les valeurs en e 44
exprimer les valeurs en cosinus
22
exprimer les valeurs en sinus 114
résultat, statistiques 121
Return, return 103
return, Return 103
right, right( ) 21, 43, 61, 104,
137
right( ), droite 103
rk23( ), Runge Kutta function 104
rotate( ), permutation circulaire 105
round( ), arrondi 105
rowAdd( ), ajout ligne de matrice
106
rowDim( ), nombre de lignes de
matrice 106
rowNorm( ), norme des lignes de la
matrice 106
rowSwap( ), échange de lignes de la
matrice 106
rref( ), forme échelonnée réduite
par lignes (réduite de GaussJordan) 106
S
sachant que, | 161
scalaire
produit, dotP( ) 40
sec( ), secante 107
sec/( ), arc sécante 107
sech( ), sécante hyperbolique 107
sech/( ), argument sécante
hyperbolique 108
secondes, " 159
seq( ), suite 108
seqGen( ) 109
seqn( ) 109
sequence, seq( ) 109
série, series( ) 110
series( ), série 110
set
mode, setMode( ) 111
setMode( ), définir mode 111
shift( ), décalage 112
sign( ), signe 113
signe, sign( ) 113
simult( ), résolution simultanée
d'équations 113
189
4sin, exprimer les valeurs en sinus
114
sin( ), sinus 114
sin/( ), arc sinus 115
sinh( ), sinus hyperbolique 115
sinh/( ), argument sinus
hyperbolique 115
SinReg, régression sinusoïdale 116
ΣInt( ) 156
sinus
afficher l'expression en 114
sinus, sin( ) 114
solution, deSolve( ) 37
solve( ), résolution 117
somme (G)
modèle 4
somme cumulée, cumulativeSum( )
31
somme des intérêts versés 156
somme du capital versé 157
somme, + 145
somme, Σ( ) 155
somme, sum( ) 123
SortA, tri croissant 119
SortD, tri décroissant 119
soulignement, _ 160
sous-matrice, subMat( ) 123, 124
soustraction, N 145
4Sphere, afficher vecteur en
coordonnées sphériques 120
ΣPrn( ) 157
sqrt( ), racine carrée 120
stat.results 121
stat.values 122
statistique
combinaisons, nCr( ) 82
écart-type, stdDev( ) 122, 136
factorielle, ! 152
initialisation nombres aléatoires,
RandSeed 100
médiane, median( ) 77
moyenne, mean( ) 76
nombre aléatoire, randNorm( )
99
nombre de permutations, nPr( )
85
statistiques à deux variables,
TwoVar 134
190
statistiques à une variable,
OneVar 87
variance, variance( ) 137
statistiques à deux variables, TwoVar
134
statistiques à une variable, OneVar
87
stdDevPop( ), écart-type de
population 122
stdDevSamp( ), écart-type
d'échantillon 122
stockage
symbole, & 162
string( ), convertir expression en
chaîne 123
strings
right, right( ) 21, 43, 61, 104,
137
subMat( ), sous-matrice 123, 124
suite, seq( ) 108
sum( ), somme 123
sumIf( ) 124
sumSeq() 124
supérieur à, > 151
supérieur ou égal à, | 152
suppression
variable, DelVar 36
supprimer
éléments vides d'une liste 36
système de 2 équations
modèle 3
système de n équations
modèle 3
T
T, transposée 125
tableau d'amortissement,
amortTbl( ) 6, 13
tan( ), tangente 125
tan/( ), arc tangente 126
tangente, tan( ) 125
tangente, tangentLine( ) 126
tangentLine( ) 126
tanh( ), tangente hyperbolique 126
tanh/( ), argument tangente
hyperbolique 127
taux d'accroissement moyen,
avgRC( ) 12
taux effectif, eff ) 41
Taux interne de rentabilité modifié,
mirr( ) 79
Taux nominal, nom( ) 84
taylor( ), polynôme de Taylor 127
tCdf( ), fonction de répartition de loi
de student-t 127
tCollect( ), linéarisation
trigonométrique 128
terme dominant, dominantTerm( )
40
test de nombre premier, isPrime( )
62
test t, tTest 132
Test_2S, F-Test sur 2 échantillons 52
tester l'élément vide, isVoid( ) 62
tExpand( ), développement
trigonométrique 128
tInterval_2Samp, intervalle de
confiance- t sur 2 échantillons
129
tInterval, intervalle de confiance t
129
4tmpCnv() 130
tmpCnv() 130
tPdf( ), densité de probabilité pour
la loi Student-t 130
trace( ) 131
trait bas, _ 160
transposée, T 125
tri
croissant, SortA 119
décroissant, SortD 119
Try, commande de gestion des
erreurs 131
Try, try 131
try, Try 131
t-test de régression linéaire multiple
81
tTest_2Samp, test t sur deux
échantillons 132
tTest, test t 132
tvmFV( ) 133
tvmI( ) 133
tvmN( ) 133
tvmPmt( ) 133
tvmPV( ) 133
TwoVar, statistiques à deux variables
134
U
unité
convertir 160
unitV( ), vecteur unitaire 136
unLock, déverrouiller une variable
ou un groupe de variables 136
V
Valeur absolue
modèle 3
valeur actuelle nette, npv( ) 86
valeur propre, eigVl( ) 42
valeur temporelle de l'argent,
montant des versements 133
valeur temporelle de l'argent,
nombre de versements 133
valeur temporelle de l'argent, taux
d'intérêt 133
valeur temporelle de l'argent, valeur
acquise 133
valeur temporelle de l'argent, valeur
actuelle 133
valeurs de résultat, statistiques 122
variable
locale, Local 71
nom, création à partir d'une
chaîne de caractères 169
suppression, DelVar 36
supprimer toutes les variables à
une lettre 19
variable locale, Local 71
variables et fonctions
copie 22
variables, verrouillage et
déverrouillage 55, 71, 136
variance, variance( ) 137
varPop( ) 136
varSamp( ), variance d'échantillon
137
vecteur
afficher vecteur en coordonnées
cylindriques, 4Cylind 31
produit scalaire, dotP( ) 40
191
produit vectoriel, crossP( ) 27
unitaire, unitV( ) 136
vecteur propre, eigVc( ) 41
vecteur unitaire, unitV( ) 136
verrouillage des variables et des
groupes de variables 71
W
warnCodes( ), Warning codes 137
when, when( ) 137
when( ), when 137
While, while 138
while, While 138
X
x2, carré 148
xor, ou exclusif booléen 138
Z
zéros, zeros( ) 139
zeros( ), zéros 139
zInterval_1Prop, intervalle de
confiance z pour une proportion
141
zInterval_2Prop, intervalle de
confiance z pour deux
proportions 141
zInterval_2Samp, intervalle de
confiance z sur 2 échantillons
142
zInterval, intervalle de confiance z
141
zTest 143
zTest_1Prop, test z pour une
proportion 143
zTest_2Prop, test z pour deux
proportions 144
zTest_2Samp, test z sur deux
échantillons 144
192

Manuels associés