Manual Ti Nspire CX Cas PDF

Guía de Referencia
Este manual de instrucciones es válido para el software TI-Nspire

versión 2.0. Para obtener la versión más reciente de la documentación,
vaya a education.ti.com/guides.
Información importante
A menos que la licencia que acompaña a este programa recoja
expresamente lo contrario, Texas Instruments no otorga ningún tipo de
garantía, ya sea implícita o explícita, con carácter enunciativo mas no
limitativo, a ninguna garantía implícita de comerciabilidad o idoneidad
para ningún propósito determinado, en relación con ningún programa o
material impreso, y pone a disposición esos materiales únicamente tal y
como están. Texas Instruments queda eximida de toda responsabilidad
por daños especiales, colaterales, accidentales o derivados en relación
con o a causa de la adquisición o el uso de estos materiales. La
responsabilidad única de Texas Instruments independientemente de la
acción legal adoptada, no podrá exceder la cantidad señalada en la
licencia del programa. Además, Texas Instruments quedará exenta de
toda responsabilidad frente a cualquier reclamación,
independientemente de la clase que sea, en referencia al uso de estos
materiales por un tercero.
Licencia
Sírvase ver la licencia completa instalada en C:\Program Files\TI
Education\TI-Nspire CAS.
© 2006-2009 Texas Instruments Incorporated
ii
Índice
Información importante B
bal() ............................................................ 13
Plantillas de expresión 4Base2 ......................................................... 14
Plantilla de fracción ..................................... 1 4Base10 ....................................................... 14
Plantilla de exponente ................................ 1 4Base16 ....................................................... 15
Plantilla de raíz cuadrada ............................ 1 binomCdf() ................................................. 15
Plantilla de raíz enésima ............................. 1 binomPdf() ................................................. 15
Plantilla de base e ........................................ 2
Plantilla de logaritmo .................................. 2 C
Plantilla de función definida a ceiling() ...................................................... 15
trozos (2 partes) ........................................... 2 centralDiff() ............................................... 16
Plantilla de función definida a cFactor() ..................................................... 16
trozos (N partes) .......................................... 2 char() .......................................................... 17
Plantilla de sistema de 2 ecuaciones ........... 3 charPoly() ................................................... 17
Plantilla de sistema de N ecuaciones .......... 3 c2 de 2 elementos ...................................... 17
Plantilla de valor absoluto .......................... 3 c2Cdf() ........................................................ 18
Plantilla de gg°mm’ss.ss’’ ............................. 3 c2GOF ......................................................... 18
Plantilla de matriz (2 x 2) ............................ 3 c2Pdf() ........................................................ 18
Plantilla de matriz (1 x 2) ............................ 4 ClearAZ ....................................................... 19
Plantilla de matriz (2 x 1) ............................ 4 ClrErr .......................................................... 19
Plantilla de matriz (m x n) ........................... 4 colAugment() ............................................. 19
Plantilla de suma (G) .................................... 4 colDim() ...................................................... 19
Plantilla de producto (Π) ............................. 4 colNorm() ................................................... 19
Plantilla de primera derivada ...................... 5 comDenom() .............................................. 20
Plantilla de segunda derivada ..................... 5 conj() .......................................................... 20
Plantilla de derivada enésima ..................... 5 constructMat() ........................................... 21
Plantilla de integral definida ...................... 5 CopyVar ...................................................... 21
Plantilla de integral indefinida ................... 5 corrMat() .................................................... 21
Plantilla de límite ......................................... 6 4cos ............................................................. 22
cos() ............................................................ 22
Listado alfabético cosê() .......................................................... 23
cosh() .......................................................... 24
A coshê() ........................................................ 24
abs() .............................................................. 7 cot() ............................................................ 24
amortTbl() .................................................... 7 cotê() .......................................................... 25
and ................................................................ 7 coth() .......................................................... 25
angle() .......................................................... 8 cothê() ........................................................ 25
ANOVA ......................................................... 8 count() ........................................................ 25
ANOVA de 2 variables ................................. 9 countif() ..................................................... 26
Ans .............................................................. 11 cPolyRoots() ............................................... 26
approx() ...................................................... 11 crossP() ....................................................... 26
4approxFraction() ....................................... 11 csc() ............................................................. 27
aproxRational() .......................................... 11 cscê() ........................................................... 27
arccos() ........................................................ 11 csch() ........................................................... 27
arccosh() ..................................................... 12 cschê() ......................................................... 27
arccot() ........................................................ 12 cSolve() ....................................................... 28
arccoth() ..................................................... 12 CubicReg .................................................... 30
arccsc() ........................................................ 12 cumulativeSum() ........................................ 30
arccsch() ...................................................... 12 Cycle ........................................................... 31
arcLen() ....................................................... 12 4Cylind ........................................................ 31
arcsec() ........................................................ 12 cZeros() ....................................................... 31
arcsech() ...................................................... 12
arcsin() ........................................................ 12 D
arcsinh() ...................................................... 12 dbd() ........................................................... 33
arctan() ....................................................... 12 4DD ............................................................. 33
arctanh() ..................................................... 12 4Decimal ..................................................... 33
augment() ................................................... 12 Define (Definir) .......................................... 34
avgRC() ....................................................... 13 Define LibPriv ............................................ 34
Define LibPub ............................................ 35
iii
deltaList() ....................................................35 getVarInfo() ............................................... 54
deltaTmpCnv() ............................................35 Goto ............................................................ 55
DelVar .........................................................35 4Grad ........................................................... 55
delVoid() .....................................................35
derivative() .................................................35 I
deSolve() .....................................................36 identity() ..................................................... 56
det() ............................................................37 If .................................................................. 56
diag() ...........................................................37 ifFn() ........................................................... 57
dim() ............................................................37 imag() ......................................................... 57
Disp .............................................................38 impDif() ...................................................... 58
4DMS ...........................................................38 Indirection .................................................. 58
dominantTerm() .........................................39 inString() .................................................... 58
dotP() ..........................................................39 int() ............................................................. 58
intDiv() ........................................................ 58
E integral ....................................................... 58
e^() ..............................................................40 invc2() ......................................................... 59
eff() .............................................................40 invF() .......................................................... 59
eigVc() .........................................................40 invNorm() ................................................... 59
eigVl() .........................................................41 invt() ........................................................... 59
Else ..............................................................41 iPart() .......................................................... 59
ElseIf ............................................................41 irr() .............................................................. 59
EndFor .........................................................41 isPrime() ...................................................... 60
EndFunc ......................................................41 isVoid() ....................................................... 60
EndIf ............................................................41
EndLoop ......................................................41 L
EndPrgm .....................................................41 Lbl ............................................................... 60
EndTry .........................................................41 lcm() ............................................................ 61
EndWhile ....................................................42 left() ............................................................ 61
exact() .........................................................42 libShortcut() ............................................... 61
Exit ..............................................................42 limit() o lim() .............................................. 62
4exp .............................................................42 LinRegBx ..................................................... 62
exp() ............................................................42 LinRegMx ................................................... 63
exp4lista() ....................................................43 LinRegtIntervals ......................................... 64
expand() ......................................................43 LinRegTTest (Test t de
expr() ...........................................................44 regresión lineal) ......................................... 65
ExpReg ........................................................44 linSolve() ..................................................... 66
@List() .......................................................... 66
F list4mat() ..................................................... 66
factor() ........................................................45 4ln ................................................................ 67
FCdf() ..........................................................46 ln() .............................................................. 67
Fill ................................................................46 LnReg .......................................................... 67
FiveNumSummary ......................................47 Local ........................................................... 68
floor() ..........................................................47 Lock ............................................................ 68
fMax() .........................................................47 log() ............................................................ 69
fMin() ..........................................................48 4logbase ...................................................... 69
For ...............................................................48 Logistic ....................................................... 70
format() ......................................................49 LogisticD ..................................................... 71
fPart() ..........................................................49 Loop ............................................................ 72
FPdf() ..........................................................49 LU ................................................................ 72
freqTable4list() ............................................50
frequency() .................................................50 M
Func .............................................................51 mat4list() ..................................................... 73
FTest_2Samp ..............................................51 max() ........................................................... 73
mean() ........................................................ 73
G median() ..................................................... 74
gcd() ............................................................52 MedMed ..................................................... 74
geomCdf() ...................................................52 mid() ........................................................... 75
geomPdf() ...................................................52 min() ........................................................... 75
getDenom() ................................................52 mirr() ........................................................... 75
getLangInfo() .............................................53 mod() .......................................................... 76
getLockInfo() ..............................................53 mRow() ....................................................... 76
getMode() ...................................................53 mRowAdd() ................................................ 76
getNum() ....................................................54 MultReg ...................................................... 76
iv
MultRegIntervals ........................................ 77 randSamp() ................................................ 97
MultRegTests .............................................. 77 RandSeed ................................................... 97
real() ........................................................... 97
N 4Rect ........................................................... 97
nCr() ............................................................ 78 ref() ............................................................. 98
nDerivative() ............................................... 79 remain() ...................................................... 99
newList() ..................................................... 79 Request ...................................................... 99
newMat() .................................................... 79 RequestStr ................................................ 100
nfMax() ....................................................... 79 Return ...................................................... 100
nfMin() ........................................................ 80 right() ....................................................... 100
nInt() ........................................................... 80 root() ........................................................ 101
nom() .......................................................... 80 rotate() ..................................................... 101
norm() ......................................................... 81 round() ..................................................... 102
normalLine() ............................................... 81 rowAdd() .................................................. 102
normCdf() ................................................... 81 rowDim() .................................................. 102
normPdf() ................................................... 81 rowNorm() ............................................... 102
not .............................................................. 81 rowSwap() ................................................ 102
nPr() ............................................................ 82 rref() ......................................................... 103
npv() ............................................................ 83
nSolve() ....................................................... 83 S
sec() .......................................................... 103
O sec/() ......................................................... 103
OneVar ....................................................... 84 sech() ........................................................ 104
or ................................................................. 85 sechê() ...................................................... 104
ord() ............................................................ 85 seq() .......................................................... 104
series() ...................................................... 105
P setMode() ................................................. 106
P4Rx() ........................................................... 86 shift() ........................................................ 107
P4Ry() ........................................................... 86 sign() ......................................................... 108
PassErr ......................................................... 86 simult() ..................................................... 108
piecewise() .................................................. 87 4sin ............................................................ 109
poissCdf() .................................................... 87 sin() ........................................................... 109
poissPdf() .................................................... 87 sinê() ......................................................... 110
4Polar .......................................................... 87 sinh() ......................................................... 110
polyCoeffs() ................................................ 88 sinhê() ....................................................... 110
polyDegree() .............................................. 88 SinReg ...................................................... 111
polyEval() .................................................... 88 solve() ....................................................... 112
polyGcd() .................................................... 89 SortA ........................................................ 114
polyQuotient() ........................................... 89 SortD ........................................................ 114
polyRemainder() ........................................ 89 4Sphere ..................................................... 115
polyRoots() ................................................. 90 sqrt() ......................................................... 115
PowerReg ................................................... 90 stat.results ................................................ 116
Prgm ........................................................... 91 stat.values ................................................ 117
prodSeq() .................................................... 91 stDevPop() ................................................ 117
Product (PI) ................................................. 91 stDevSamp() ............................................. 117
product() ..................................................... 91 Stop .......................................................... 118
propFrac() ................................................... 92 Store ......................................................... 118
string() ...................................................... 118
Q subMat() ................................................... 118
QR ............................................................... 92 Sum (Sigma) ............................................. 118
QuadReg ..................................................... 93 sum() ......................................................... 119
QuartReg .................................................... 94 sumIf() ...................................................... 119
sumSeq() ................................................... 119
R system() .................................................... 119
R4Pq() .......................................................... 95
R4Pr() ........................................................... 95 T
4Rad ............................................................. 95 T (transponer) .......................................... 120
rand() .......................................................... 95 tan() .......................................................... 120
randBin() ..................................................... 96 tanê() ........................................................ 121
randInt() ..................................................... 96 tangentLine() ........................................... 121
randMat() ................................................... 96 tanh() ........................................................ 121
randNorm() ................................................. 96 tanhê() ...................................................... 122
randPoly() ................................................... 96 taylor() ...................................................... 122
v
tCdf() .........................................................122 ë(negación) .............................................. 145
tCollect() ...................................................123 % (porcentaje) ......................................... 145
tExpand() ..................................................123 = (igual) .................................................... 146
Text ...........................................................123 ƒ (no igual) ............................................... 146
Then ..........................................................123 < (menor que) .......................................... 147
tInterval ....................................................124 { (menor o igual que) .............................. 147
tInterval_2Samp .......................................124 > (mayor que) ........................................... 147
tmpCnv() ...................................................125 | (mayor o igual que) .............................. 148
@tmpCnv() .................................................125 ! (factorial) ............................................... 148
tPdf() .........................................................126 & (añadir) ................................................. 148
trace() ........................................................126 d() (derivada) ........................................... 149
Try .............................................................126 ‰() (integral) .............................................. 149
tTest ..........................................................127 ‡() (raíz cuadrada) ................................... 150
tTest_2Samp .............................................128 Π() (prodSeq) ............................................ 151
tvmFV() .....................................................128 G() (sumSeq) ............................................. 151
tvmI() .........................................................128 GInt() ......................................................... 152
tvmN() .......................................................129 GPrn() ........................................................ 153
tvmPmt() ...................................................129 # (dirección) ............................................. 153
tvmPV() .....................................................129 í (notación científica) .............................. 153
TwoVar .....................................................130 g (grado centesimal) ................................ 154
ô(radián) ................................................... 154
U ¡ (grado) ................................................... 154
unitV() .......................................................131 ¡, ', '' (grados/minutos/segundos) ........... 155
unLock ......................................................131  (ángulo) ................................................ 155
' (primo) .................................................... 155
V _ (carácter de subrayado como
varPop() ....................................................132 elemento vacío) ....................................... 156
varSamp() ..................................................132 _ (carácter de subrayado como
designador de unidad) ............................ 156
W 4 (convertir) .............................................. 156
when() .......................................................132 10^() .......................................................... 156
While .........................................................133 ^ê (inverso de un valor) ........................... 157
“With” ......................................................133 | (“with”) .................................................. 157
& (almacenar) .......................................... 158
X := (asignar) ............................................... 158
xor .............................................................133 © (comentario) ......................................... 158
0b, 0h ........................................................ 159
Z
zeros() .......................................................134 Elementos vacíos (sin valor)
zInterval ....................................................136 Cálculos que incluyen elementos
zInterval_1Prop ........................................136 sin valor .................................................... 160
zInterval_2Prop ........................................137 Listas de argumentos que contienen
zInterval_2Samp .......................................137 elementos sin valor .................................. 160
zTest ..........................................................138
zTest_1Prop ..............................................138 Métodos abreviados para
zTest_2Prop ..............................................139 introducir expresiones
zTest_2Samp .............................................140
matemáticas
Símbolos
+ (suma) ....................................................141
Jerarquía de EOS™ (Sistema
N(resta) ......................................................141 operativo de ecuaciones)
·(multiplicación) ......................................142
à (división) ................................................142 Códigos y mensajes de error
^ (potencia) ..............................................143
x2 (cuadrado) ............................................144 Información sobre productos,
.+ (punto suma) ........................................144 servicios y garantías de TI
.. (punto resta) .........................................144
.·(punto multiplic.) ..................................144
. / (punto división) ....................................145
.^ (punto de potencia) .............................145
vi
Guía de referencia de TI-Nspire™ CAS
En esta guía se describen las plantillas, funciones, órdenes y operadores que podrá utilizar para
calcular expresiones matemáticas.
Plantillas de expresión
Las plantillas de expresión son un medio fácil de introducir expresiones matemáticas en
notación estándar. Cada plantilla que se inserta aparece en la línea de entrada y presenta
bloques pequeños para indicar los elementos que se pueden introducir. Los elementos se
indican por medio de un cursor.
Utilice las teclas de flecha o pulse e para desplazar el cursor a cada posición del elemento, y
escriba un valor o una expresión. Pulse · o /· para calcular la expresión.
Plantilla de fracción Teclas /p

Ejemplo:
Nota: Consulte también / (división), en la página 142.
Plantilla de exponente Tecla l

Ejemplo:
Nota: Escriba el primer valor, pulse l , y escriba el exponente.

Para desplazar el cursor hasta la línea de base, pulse la tecla de flecha
¢
( ).
Nota: Consulte también ^ (potencia), en la página 143.
Plantilla de raíz cuadrada Teclas /q

Ejemplo:
Nota: Consulte también ‡() (raíz cuadrada), en la página

150.
Plantilla de raíz enésima Teclas /l

Ejemplo:
Nota: Consulte también root(), en la página 101.
Guía de referencia de TI-Nspire™ CAS 1

Plantilla de base e Teclas u
Ejemplo:
Base el número e y exponente cualquiera

Nota: Consulte también e^(), en la página 40.
Plantilla de logaritmo Tecla /s

Ejemplo:
Calcula el logaritmo de la base que se indique. En el caso de la base

por defecto, 10, no hay que indicar la base.
Nota: Consulte también log(), en la página 69.
Plantilla de función definida a trozos (2 partes)

Catálogo >
Ejemplo:
Permite crear expresiones y condiciones para una función definida a

trozos -con dos partes. Para añadir un trozo, haga clic en la plantilla y
repita los pasos.
Nota: Consulte también piecewise(), en la página 87.
Plantilla de función definida a trozos (N partes)

Catálogo >
Permite crear expresiones y condiciones para una función definida a Ejemplo:

trozos con N-partes. Solicita la introducción del número de partes, N. Consulte el ejemplo de la plantilla definida a trozos (2 partes).
Nota: Consulte también piecewise(), en la página 87.
2 Guía de referencia de TI-Nspire™ CAS

Plantilla de sistema de 2 ecuaciones
Catálogo >
Ejemplo:
Crea un sistema de dos ecuaciones . Para añadir una fila a un sistema

existente, haga clic en la plantilla y repita los pasos anteriores.
Nota: Consulte también system(), en la página 119.
Plantilla de sistema de N ecuaciones

Catálogo >
Permite crear un sistema de N ecuaciones . Solicita la introducción Ejemplo:

del número de ecuaciones, N. Consulte el ejemplo de Plantilla de sistema de ecuaciones (2
ecuaciones).
Nota: Consulte también system(), en la página 119.
Plantilla de valor absoluto

Catálogo >
Ejemplo:
Nota: Consulte también abs(), en la página 7.
Plantilla de gg°mm’ss.ss’’
Catálogo >
Ejemplo:
Permite introducir ángulos en formato gg°mm’ss.ss’’, donde gg es el

número de grados sexagesimales, mm corresponde al número de
minutos y ss.ss al de segundos.
Plantilla de matriz (2 x 2)
Catálogo >
Ejemplo:
Crea una matriz de 2 por 2.

Catálogo >
Ejemplo:
.
Catálogo >
Ejemplo:
Plantilla de matriz (m x n)
Catálogo >
La plantilla aparece tras la solicitud para especificar el número de filas Ejemplo:

y columnas.
Nota: Si la matriz que ha creado tiene gran cantidad de filas y

columnas puede tardar unos minutos en aparecer.
Plantilla de suma (G)

Catálogo >
Ejemplo:
Nota: Consulte también G() (sumSeq), en la página 151.
Plantilla de producto (Π)

Catálogo >
Ejemplo:
Nota: Consulte también Π() (prodSeq), en la página 151.

Plantilla de primera derivada
Catálogo >
Ejemplo:
Puede utilizar esta plantilla para calcular la derivada de primer orden

en un punto.
Nota: Consulte también d() (derivada), en la página 149.
Plantilla de segunda derivada

Catálogo >
Ejemplo:
Puede utilizar esta plantilla para calcular la derivada de segundo

orden en un punto.
Plantilla de derivada enésima

Catálogo >
Ejemplo:
La plantilla de derivada enésima se puede utilizar para calcular la

derivada enésima.
Plantilla de integral definida

Catálogo >
Ejemplo:
Nota: Consulte también ‰() integral(), en la página 149.
Plantilla de integral indefinida

Catálogo >
Ejemplo:
Nota: Consulte también ‰() integral(), en la página 149.

Plantilla de límite
Catálogo >
Ejemplo:
Utilice N o (N) para el límite izquierdo. Utilice + para el límite

derecho.
Nota: Consulte también limit(), en la página 62.

Listado alfabético
Los elementos con nombres no alfabéticos (por ejemplo, +, ! y >) se incluyen al final de esta
sección, en una lista que comienza en la página 141. A menos que se especifique lo contrario,
todos los ejemplos de esta sección se han realizado en el modo de restablecimiento
predeterminado y suponiendo que todas las variables están sin definir.
A
abs()
Catálogo >
abs(Expr1) ⇒ expresión
abs(Lista1) ⇒ lista
abs(Matriz1) ⇒ matriz
Calcula el valor absoluto de un argumento.

Nota: Consulte también Plantilla de valor absoluto, en la página
3.
Si el argumento es un número complejo, el resultado es el módulo del
número.
Nota: Se considera que todas las variables no definidas son variables
reales.
amortTbl()
Catálogo >
amortTbl(NPmt,N,I,PV, [Pmt], [FV], [PpY], [CpY], [PmtAt],

[redondValor]) ⇒ matriz
Función de amortización que genera una matriz como una tabla de

amortización para un conjunto de argumentos de TVM (valor
temporal del dinero).
NPmt es el número de pagos que se han de incluir en la tabla. La
tabla se inicia con el primer pago.
N, I, PV, Pmt, FV, PpY, CpY y PmtAt se describen en la tabla de
argumentos para TVM, en la página 129.
• Si se omite el valor de Pmt, se aplica de forma predeterminada
Pmt=tvmPmt(N,I,PV,FV,PpY,CpY,PmtAt).
• Si se omite el valor de FV, se aplica de forma predeterminada
FV=0.
• Los valores predeterminados para PpY, CpY y PmtAt son los
mismos que los de las funciones de TVM.
redondValor especifica el número de decimales de redondeo. Valor
predeterminado = 2.
Las columnas de la matriz de resultados siguen este orden: Número
de pago, interés pagado, principal amortizado y principal que resta
por pagar.
El principal que resta por pagar n corresponde al principal que resta
por pagar tras el pago n.
La matriz de salida se puede utilizar como entrada de las otras
funciones de amortización, GInt() y GPrn(), en la página 152, y bal(),
en la página 13.
and
Catálogo >
ExprBooleana1 and ExprBooleana2 ⇒ Expresión booleana

ListaBooleana1 and ListaBooleana2 ⇒ Lista booleana
MatrizBooleana1 and MatrizBooleana2 ⇒ Matriz booleana
Muestra el resultado verdadero o falso o una forma simplificada de la
entrada original.

and
Catálogo >
Entero1 and Entero2 ⇒ entero En modo base Hex:
Compara bit a bit dos números enteros reales mediante una

operación and. Internamente, ambos enteros se convierten en
números binarios con signo de 64 bits. Cuando se comparan los bits Importante: Cero, no la letra O.
correspondientes, el resultado es 1 si ambos bits son 1; en caso
contrario, el resultado será 0. El valor obtenido representa el En modo base Bin:
resultado de los bits, y aparece conforme al modo base especificado.
Los números enteros se pueden introducir en cualquier base. Para una
entrada binaria o hexadecimal es necesario utilizar el prefijo 0b o 0h, En modo base Dec:
respectivamente. Si no se indica un prefijo, los enteros se consideran
decimales (base 10).
Si el entero decimal que se introduce es demasiado largo para un Nota: Una entrada binaria puede tener hasta 64 dígitos (sin
formato binario con signo de 64 bits, se utiliza una operación de contar el prefijo 0b). Una entrada hexadecimal puede tener
módulo simétrico para llevar el valor al rango apropiado. hasta 16 dígitos.
angle()
Catálogo >
angle(Expr1) ⇒ expresión En el modo de ángulo en grados:

Devuelve el ángulo del argumento, interpretando el argumento como
un número complejo.
Nota: Se considera que todas las variables no definidas son variables En el modo de ángulo en grados centesimales:
reales.
En el modo de ángulo en radianes:
angle(Lista1) ⇒ lista
angle(Matriz1) ⇒ matriz
Devuelve una lista o matriz de ángulos de los elementos en Lista1 o

Matriz1, interpretando cada elemento como un número complejo
que representa las coordenadas de un punto del plano.
ANOVA
Catálogo >
ANOVA Lista1,Lista2[,Lista3,...,Lista20][,Etiqueta]
Realiza un análisis de varianza de un factor para comparar la media

de 2 a 20 poblaciones. El resumen de los resultados se guarda en la
variable stat.results. (Consulte la página 116.)
Etiqueta = 0 para Datos, Etiqueta = 1 para Estadística
Variable de Descripción
salida
stat.F Valor de la estadística F
stat.PVal Nivel de significancia mínimo al que se puede rechazar la hipótesis nula
stat.df Grados de libertad de los grupos

salida
stat.SS Suma de los cuadrados de los grupos
stat.MS Media de los cuadrados de los grupos
stat.dfError Grados de libertad de los errores
stat.SSError Suma de los cuadrados de los errores
stat.MSError Media de los cuadrados de los errores
stat.sp Desviación estándar sondeada
stat.xbarlist Media de las entradas de las listas
stat.CLowerList 95% de los intervalos de confianza para la media de cada lista de entrada
stat.CUpperList 95% de los intervalos de confianza para la media de cada lista de entrada
ANOVA de 2 variables
Catálogo >
ANOVA2way Lista1,Lista2[,Lista3,…,Lista10][,nivelFila]
Realiza un análisis de varianza de dos factores comparando las

medias de 2 a 10 poblaciones. El resumen de los resultados se guarda
en la variable stat.results. (Consulte la página 116.)
nivelFila = 0 para Bloque
nivelFila=2,3,...,Len-1, para Dos Factor, donde
Len=lenght(Lista1)=length(Lista2) = … = length(Lista10) y
Len / nivelFila ∈ {2,3,…}
Salidas: Estudio conjunto
salida
stat.F Estadístico F de la variable columna
stat.df Grados de libertad de la variable columna
stat.SS Suma de los cuadrados de la variable columna
stat.MS Media de los cuadrados de la variable columna
stat.FBlock Estadístico F de la variable
stat.PValBlock Probabilidad mínima a la que se puede rechazar la hipótesis nula
stat.dfBlock Grados de libertad de la variable
stat.SSBlock Suma de los cuadrados de la variable
stat.MSBlock Media de los cuadrados de la variable
stat.s Desviación estándar del error

Salidas para la variable COLUMNA
salida
stat.Fcol Estadístico F de la variable columna
stat.PValCol Valor de probabilidad de la variable columna
stat.dfCol Grados de libertad de la variable columna
stat.SSCol Suma de los cuadrados de la variable columna
stat.MSCol Media de los cuadrados de la variable columna
Salidas para la variable FILA
salida
stat.FRow Estadístico F de la variable fila
stat.PValRow Valor de probabilidad de la variable fila
stat.dfRow Grados de libertad de la variable fila
stat.SSRow Suma de los cuadrados de la variable fila
stat.MSRow Media de los cuadrados de la variable fila
Salidas para INTERACCIÓN
salida
stat.FInteract Estadístico F de la interacción
stat.PValInteract Probabilidad de la interacción
stat.dfInteract Grados de libertad de la interacción
stat.SSInteract Suma de los cuadrados de la interacción
stat.MSInteract Media de los cuadrados de la interacción
Salida para ERROR
salida
s Desviación estándar del error

Ans Teclas /v
Ans ⇒ valor
Devuelve el resultado de la expresión calculada en último lugar.
approx()
Catálogo >
approx(Expr1) ⇒ expresión
Devuelve el cálculo del argumento como una expresión que contiene
cifras decimales, siempre que sea posible, sin tener en cuenta el modo
actual, Auto o Aproximado.
Equivale a introducir el argumento y pulsar /·.
approx(Lista1) ⇒ lista
approx(Matriz1) ⇒ matriz
Devuelve una lista o una matriz en donde cada elemento se ha

calculado hasta un valor decimal, siempre que sea posible.
4approxFraction() Catálogo >
Expr 4approxFraction([Tol]) ⇒ expresión

Lista 4approxFraction([Tol]) ⇒ lista
Matriz 4approxFraction([Tol]) ⇒ matriz
Devuelve la entrada como una fracción, que utiliza la tolerancia Tol.
Si se omite el valor de Tol, se utiliza una tolerancia de 5.E-14.
Nota: Si desea insertar esta función con el teclado del ordenador,
escriba @>approxFraction(...).
aproxRational()
Catálogo >
aproxRational(Expr[, Tol]) ⇒ expresión

aproxRational(Lista[, Tol])⇒ lista
aproxRational(Matriz[, Tol]) ⇒ matriz
Devuelve el argumento como una fracción que utiliza la tolerancia

Tol. Si se omite el valor de Tol, se utiliza una tolerancia de 5.E-14.
arccos() Consulte cosê(), en la página 23.

arccosh() Consulte coshê(), en la página 24.
arccot() Consulte cotê(), en la página 25.
arccoth() Consulte cothê(), en la página 25.
arccsc() Consulte cscê(), en la página 27.
arccsch() Consulte cschê(), en la página 27.
arcLen()
Catálogo >
arcLen(Expr1,Var,Inic,Fin) ⇒ expresión
Devuelve la longitud de arco de Expr1 desde Inicio a Fin con
respecto a la variable Var.
La longitud de arco se calcula mediante una integral.
arcLen(Lista1,Var,Inic,Fin) ⇒ lista
Devuelve una lista de las longitudes de arco de cada elemento de
Lista1 desde Inicio a Fin con respecto aVar.
arcsec() Consulte secê(), en la página 103.
arcsech() Consulte sechê(), en la página 104.
arcsin() Consulte sinê(), en la página 110.
arcsinh() Consulte sinhê(), en la página 110.
arctan() Consulte tanê(), en la página 121.
arctanh() Consulte tanhê(), en la página 122.
augment()
Catálogo >
augment(Lista1, Lista2) ⇒ lista

Devuelve una nueva lista que es Lista2 añadida al final de Lista1.

augment()
Catálogo >
augment(Matriz1, Matriz2) ⇒ matriz

Devuelve una nueva matriz que es Matriz2 añadida a Matriz1.
Cuando se utiliza el carácter “,”, las matrices deben tener el mismo
número de filas, y Matriz2 se añade a Matriz1 como si fueran
nuevas columnas. No se altera el contenido de Matriz1 ni Matriz2.
avgRC()
Catálogo >
avgRC(Expr1, Var [=Valor] [, Paso]) ⇒ expresión

avgRC(Expr1, Var [=Valor] [, Lista1]) ⇒ lista
avgRC(Lista1, Var [=Valor] [, Paso]) ⇒ lista
avgRC(Matriz1, Var [=Valor] [, Paso]) ⇒ matriz
Devuelve el cociente incremental positivo (tasa media de cambio).

Expr1 se puede utilizar como un nombre de función definido por el
usuario (consulte Func).
Cuando se especifica, valor sobrescribe cualquier otra asignación de
variable anterior o cualquier sustitución “with” actual de la variable.
Paso es el valor del paso. Si se omite, Paso adopta el valor
predeterminado 0,001.
Observe que la función similar, centralDiff(), utiliza el cociente de

diferencia central.
B
bal()
Catálogo >
bal(NPmt,N,I,PV ,[Pmt], [FV], [PpY], [CpY], [PmtAt],

[redondValor]) ⇒ valor
bal(NPmt,amortTable) ⇒ valor
Función de amortización que calcula el principal que resta por pagar
tras un pago especificado.
NPmt especifica el número de pagos tras el cual se desean calcular
los datos.
FV=0.
predeterminado = 2.
bal(NPmt,amortTable) calcula el principal que resta por pagar tras el
número de pago NPmt, según una tabla de amortización
amortTable. El argumento amortTable debe ser una matriz en la
forma descrita en la sección amortTbl(), en la página 7.
Nota: Consulte también GInt() y GPrn(), en la página 152.

4Base2 Catálogo >
Entero1 4Base2 ⇒ entero

escriba @>Base2.
Convierte Entero1 en un número binario. Los números binarios o
hexadecimales llevan siempre un prefijo 0b o 0h, respectivamente.
Cero, no la letra O, seguido de b o h.
0b NúmeroBinario
0h NúmeroHexadecimal
Un número binario puede tener hasta 64 dígitos. Un

número hexadecimal puede tener hasta 16 dígitos.
Si no se indica un prefijo, Entero1 se trata como decimal (base 10). El

resultado aparece en formato binario, sea cual sea el modo de la
base.
Los números negativos se muestran en la forma “complemento a
dos”. Por ejemplo,
N1 aparece como
0hFFFFFFFFFFFFFFFF en modo base hexadecimal
0b111...111 (64 unos) en modo base binaria
N263 aparece como

0h8000000000000000 en modo base hexadecimal
0b100...000 (63 ceros) en modo base binaria
Si el entero decimal que se introduce queda fuera del rango de un
formato binario con signo de 64 bits, se utiliza una operación de
módulo simétrico para llevar el valor al rango apropiado. Suponga
que los valores de los ejemplos siguientes quedan fuera del rango.
263 se convierte en N263 y aparece como

0h8000000000000000 en modo base hexadecimal
0b100...000 (63 ceros) en modo base binaria
264 se convierte en 0 y aparece como

0h0 el modo base hexadecimal
0b0 en modo base binaria
N263 N 1 se convierte en 263 N 1 y aparece como

0h7FFFFFFFFFFFFFFF en modo base hexadecimal
0b111...111 (64 unos) en modo base binaria
4Base10 Catálogo >

Nota: Si desea insertar este operador con el teclado del ordenador,
escriba @>Base10.
Convierte Entero1 en un número decimal (base 10). Una entrada
binaria o hexadecimal debe llevar siempre el prefijo 0b o 0h,
respectivamente.
0b NúmeroBinario
Un número binario puede tener hasta 64 dígitos. Un número
hexadecimal puede tener hasta 16 dígitos.
Si no se indica un prefijo, Entero1 se considera decimal. El resultado
aparece en formato decimal, sea cual sea el modo de la base.

4Base16 Catálogo >

escriba @>Base16.
Convierte Entero1 en un número hexadecimal. Los números binarios
o hexadecimales llevan siempre un prefijo 0b o 0h, respectivamente.
0b NúmeroBinario
Un número binario puede tener hasta 64 dígitos. Un número
hexadecimal puede tener hasta 16 dígitos.
Si no se indica un prefijo, Entero1 se considera decimal (base 10).
El resultado aparece en formato hexadecimal, sea cual sea el modo
de la base.
Si el entero decimal que se introduce es demasiado largo para un
módulo simétrico para llevar el valor al rango apropiado. Para
obtener más información, consulte 4Base2, en la página 14.
binomCdf()
Catálogo >
binomCdf(n,p) ⇒ número
binomCdf(n,p,Extremoinferior,Extremosuperior) ⇒ número si
Extremoinferior y Extremosuperior son números, lista si
Extremoinferior y Extremosuperior son listas
binomCdf(n,p,Extremosuperior) para
P(0XExtremosuperior) ⇒ número si Extremosuperior es un
número, lista si Extremosuperior es una lista
Calcula una probabilidad acumulada para la distribución binomial

discreta para un número de pruebas n y probabilidad de éxito p en
cada prueba.
Para P(X  Extremosuperior), defina Extremoinferior=0
binomPdf()
Catálogo >
binomPdf(n,p) ⇒ número
binomPdf(n,p,XVal) ⇒ número si XVal es un número, lista si
XVal es una lista
Calcula una probabilidad para la distribución binomial discreta para
un número de pruebas n y probabilidad de éxito p en cada prueba.
C
ceiling()
Catálogo >
ceiling(Expr1) ⇒ entero
Devuelve el menor entero que sea ‚ el argumento.
El argumento puede ser un número real o complejo.
Nota: Consulte también floor().
ceiling(Lista1) ⇒ lista
ceiling(Matriz1) ⇒ matriz
Devuelve una lista o una matriz con los correspondientes menores

enteros.

centralDiff()
Catálogo >
centralDiff(Expr1,Var [=Valor][,Paso]) ⇒ expresión

centralDiff(Expr1,Var [,Paso])|Var=Valor ⇒ expresión
centralDiff(Expr1,Var [=Valor][,Lista]) ⇒ lista
centralDiff(Lista1,Var [=Valor][,Paso]) ⇒ lista
centralDiff(Matriz1,Var [=Valor][,Paso]) ⇒ matriz
Devuelve la derivada numérica utilizando la fórmula de cociente de

diferencia central.
variable anterior o cualquier sustitución "with" actual de la variable.
Paso es el valor del paso. Si se omite, Paso adopta el valor
predeterminado 0,001.
Cuando se utiliza Lista1 o Matriz1, la operación se aplica a los
valores de la lista o los elementos de la matriz.
Nota: Consulte también avgRC() y d().
cFactor()
Catálogo >
cFactor(Expr1[,Var]) ⇒ expresión
cFactor(Lista1[,Var]) ⇒ lista
cFactor(Matriz1[,Var]) ⇒ matriz
cFactor(Expr1) devuelve Expr1 factorizado con respecto a todas sus

variables, sobre un denominador común.
Expr1 se factoriza tanto como sea posible hacia factores racionales
lineales incluso aunque dé lugar a números no reales. Esta alternativa
resulta apropiada si desea que la factorización se realice con respecto
a más de una variable.
cFactor(Expr1,Var) devuelve Expr1 factorizado con respecto a la

variable Var.
Expr1 se factoriza tanto como sea posible hacia factores que son
lineales en Var, aunque sean constantes no reales, incluso aunque
genere constantes irracionales o subexpresiones que sean irracionales
en otras variables.
Los factores y sus términos se ordenan con Var como variable
principal. En cada factor se recogen potencias de Var similares.
Incluya Var si la factorización es necesaria sólo con respecto a la
variable y no tiene inconveniente en aceptar expresiones irracionales
en cualquier otra variable para incrementar la factorización con
respecto a Var. Puede haber alguna factorización incidental con
respecto a otras variables.
Para el ajuste Auto del modo Auto or Approximate, la inclusión
de Var permite también una aproximación con coeficientes de coma
flotante cuando no sea posible expresar los coeficientes explícita y
concisamente en términos de las funciones integradas. Incluso
cuando sólo hay una variable, la inclusión de Var puede generar una
factorización más completa.
Nota: Consulte también factor().
Para ver todos los resultados, pulse £ y utilice ¡ y ¢ para

mover el cursor.

char()
Catálogo >
char(Entero) ⇒ carácter
Devuelve una cadena de caracteres que contiene el carácter dado
por el número Entero del juego de caracteres de la unidad portátil.
El rango válido para Entero es 0–65535.
charPoly()
Catálogo >
charPoly(Matrizcuadrada,Var) ⇒ expresión polinómica

charPoly(Matrizcuadrada,Expr) ⇒ expresión polinómica
charPoly(Matrizcuadrada1,Matriz2) ⇒ expresión polinómica
Devuelve el polinomio característico de Matrizcuadrada. El

polinomio característico de la matriz cuadrada A de dimensión nxn,
indicado por medio de pA(l), es el polinomio definido por
pA(l) = det(l• I NA)
donde I indica la matriz de identidad n×n.

Matrizcuadrada1 y Matrizcuadrada2 deben tener las mismas
dimensiones.
c2 de 2 elementos Catálogo >
c22way ObsMatriz
chi22way ObsMatriz
Calcula un test de c2 para determinar si hay asociación con la tabla

de recuentos de dos elementos incluida en la matriz observada
ObsMatriz. El resumen de los resultados se guarda en la variable
stat.results. (Consulte la página 116.)
Para obtener más información sobre el efecto de los elementos vacíos
en una matriz, consulte “Elementos vacíos (sin valor)” en la página
160.
salida
stat.c2 Estadística de chi cuadrado: suma (observada - esperada)2/esperada
stat.df Grados de libertad para la estadística de chi cuadrado
stat.ExpMat Matriz de tabla de recuentos de elementos esperada, suponiendo una hipótesis nula
stat.CompMat Matriz de contribuciones para estadística de chi cuadrado de los elementos

c2Cdf() Catálogo >
c Cdf(Extremoinferior,Extremosuperior,gl) ⇒ número si
2

chi2Cdf(Extremoinferior,Extremosuperior,gl) ⇒ número si
Calcula la probabilidad de distribución de c2 entre el

Extremoinferior y el Extremosuperior para los grados de libertad gl
especificados.
Para P(X Extremosuperior), defina Extremoinferior=0.
en una lista, consulte “Elementos vacíos (sin valor)” en la página
160.
c2GOF Catálogo >
c2GOF obsLista,expLista,gl
chi2GOF obsLista,expLista,gl
Lleva a cabo un test para confirmar que los datos de la muestra son
de una población que cumple una distribución especificada. obsList
es una lista de recuentos y debe contener números enteros.
El resumen de los resultados se guarda en la variable stat.results.
(Consulte la página 116).
160.
salida
stat.c2 Estadística de chi cuadrado: suma (observada - esperada)2/esperada
stat.df Grados de libertad para la estadística de chi cuadrado
stat.CompList Contribuciones para estadística de chi cuadrado de los elementos
c2Pdf() Catálogo >

2
c Pdf(XVal,gl) ⇒ número si XVal es un número, lista si XVal
es una lista
chi2Pdf(XVal,gl) ⇒ número si XVal es un número, lista si
XVal es una lista
Calcula la función de densidad de probabilidad (pdf) para la
distribución de c2 para un valor XVal especificado para los grados de
libertad gl especificados.
160.

ClearAZ
Catálogo >
ClearAZ
Borra todas las variables cuyo nombre esté compuesto por un único
carácter del espacio del problema actual.
Si hay una o más variables bloqueadas, la orden muestra un mensaje
de error y borra sólo las variables que no están bloqueadas. Consulte
unLock, en la página 131.
ClrErr
Catálogo >
ClrErr Para ver un ejemplo de ClrErr, consulte el ejemplo 2 de la orden
Try, en la página 127.
Borra el estado de error y define la variable del sistema errCode en
cero.
La cláusula Else del bloque Try...Else...EndTry debería utilizar ClrErr
o PassErr. Si va a procesar o ignorar el error, utilice ClrErr. Si
desconoce el tratamiento que se va a dar al error, utilice PassErr para
enviarlo al siguiente gestor de errores. Si no hay más gestores de
errores de tipo Try...Else...EndTry, el cuadro de diálogo de errores
aparecerá en su forma normal.
Nota: Consulte también PassErr, en la página 86, y Try, en la página
126.
Nota para introducir el ejemplo: En la aplicación Calculadora
de la unidad portátil, puede introducir definiciones formadas por
@
varias líneas si pulsa en lugar de · al final de cada línea.
En el teclado del ordenador, mantenga pulsada la tecla Alt y pulse
Enter (Intro).
colAugment()
Catálogo >
colAugment(Matriz1, Matriz2) ⇒ matriz

Devuelve una nueva matriz que es Matriz2 añadida a Matriz1.
Las dos matrices han de tener el mismo número de columnas, y
Matriz2 se añade a Matriz1 como si fueran nuevas filas. No se altera
el contenido de Matriz1 ni Matriz2.
colDim()
Catálogo >
colDim(Matriz) ⇒ expresión
Devuelve el número de columnas de Matriz.
Nota: Consulte también rowDim().
colNorm()
Catálogo >
colNorm(Matriz) ⇒ expresión
Devuelve el máximo de las sumas de los valores absolutos de los
elementos de las columnas de MatriZ.
Nota: No se admiten elementos de matriz sin definir. Consulte
también rowNorm().

comDenom()
Catálogo >
comDenom(Expr1[,Var]) ⇒ expresión
comDenom(Lista1[,Var]) ⇒ lista
comDenom(Matriz1[,Var]) ⇒ matriz
comDenom(Expr1) devuelve una fracción con un numerador

totalmente desarrollado sobre un denominador también totalmente
desarrollado.
comDenom(Expr1,Var) devuelve una fracción reducida con un

numerador y un denominador desarrollados con respecto a Var. Los
términos y sus factores se ordenan con Var como variable principal.
Se agrupan potencias similares de Var. Puede haber alguna
factorización incidental de los coeficientes agrupados. Comparada
con la omisión de Var, supone ahorro de tiempo, memoria y espacio
de pantalla, al tiempo que hace que la expresión sea más
comprensible. También hace que el resultados de las operaciones
siguientes se genere más rápidamente con menos riesgo de agotar la
memoria.
Si Var no ocurre en Expr1, comDenom(Expr1,Var) devuelve una

fracción reducida de un numerador no desarrollado sobre un
denominador no desarrollado. Estos resultados suelen ahorrar
tiempo, memoria y espacio en pantalla. Tales resultados con
factorización parcial hacen que los resultados de las operaciones
siguientes se generen más rápido y con menos gasto de memoria.
Incluso si no hay denominador, la función comden suele ser un medio

rápido de conseguir una factorización parcial si factor() es demasiado
lento o consume mucha memoria.
Sugerencia: Introduzca esta definición de función comden() y
pruébela cada cierto tiempo como método alternativo de
comDenom() y factor().
conj()
Catálogo >
conj(Expr1) ⇒ expresión
conj(Lista1) ⇒ lista
conj(Matriz1) ⇒ matriz
Muestra el complejo conjugado del argumento.

reales.

constructMat()
Catálogo >
constructMat(Expr,Var1,Var2,númeroFilas,númeroColumnas)
⇒ matriz
Devuelve una matriz basada en los argumentos.
Expr es una expresión en las variables Var1 y Var2. Los elementos de
la matriz resultante se forman calculando Expr para cada valor
incrementado de Var1 y Var2.
Var1 se incrementa automáticamente desde 1 hasta númeroFilas.
En cada fila, Var2 se incrementa desde 1 hasta númeroColumnas.
CopyVar
Catálogo >
CopyVar Var1, Var2

CopyVar Var1. , Var2.
CopyVar Var1, Var2 copia el valor de la variable Var1 hasta la

variable Var2, creando Var2 si es necesario. La variable Var1 debe
tener un valor.
Si Var1 es el nombre de una función definida por el usuario, copia su
definición en la función Var2. La función Var1 debe estar definida.
Var1 debe cumplir los requisitos de nomenclatura aplicables a las
variables o ser una expresión que pueda convertirse en un nombre de
variable que cumpla dichos requisitos.
CopyVar Var1. , Var2. copia todos los miembros del grupo de
variables Var1. en el grupo Var2. creando Var2. si es necesario.
Var1. debe ser el nombre de un grupo de variables existente como,

por ejemplo, el de estadística stat.nn, o variables creadas mediante la
función LibShortcut(). Si Var2. ya existe, la orden sustituye todos los
miembros que son comunes a ambos grupos y añade los que no
existen. Si uno o más miembros de Var2. están bloqueados, todos los
miembros de Var2. se mantienen sin cambios.
corrMat()
Catálogo >
corrMat(Lista1,Lista2[,…[,Lista20]])
Calcula la matriz de correlación de la matriz aumentada [Lista1,

Lista2, ..., Lista20].

4cos Catálogo >
Expr 4cos
escriba @>cos.
Representa Expr en función de coseno. Es un operador de conversión
de presentación, y se puede utilizar únicamente al final de la línea de
entrada.
4cos reduce todas las potencias de
sin(...) módulo 1Ncos(...)^2
para que las restantes potencias de cos(...) tengan exponentes en el
rango (0, 2). Por lo tanto, en el resultado no aparecerá en función de
sin(...) si y sólo si sin(...) se aparece en la expresión dada sólo en
potencias pares.
Nota: Este operador de conversión no es válido para los modos de
ángulo en grados o grados centesimales. Antes de utilizarlo,
asegúrese de que el modo ángulo está definido en radianes y que
Expr no contiene referencias explícitas a ángulos en grados o grados
centesimales.
cos() Tecla μ
cos(Expr1) ⇒ expresión En el modo de ángulo en grados:
cos(Lista1) ⇒ lista
cos(Expr1) devuelve el coseno del argumento en forma de expresión.
cos(Lista1) devuelve una lista de los cosenos de todos los elementos

de Lista1.
Nota: El argumento se interpreta como un ángulo en grados, grados
centesimales o radianes, según el modo de ángulo actual. Puede
utilizar ó, G o ôpara sobrescribir el modo de ángulo temporalmente.
En el modo de ángulo en grados centesimales:

cos() Tecla μ
cos(Matrizcuadrada1) ⇒ Matrizcuadrada En el modo de ángulo en radianes:
Devuelve el coseno de la matriz Matrizcuadrada1. El resultado no es

igual que calcular el coseno de cada elemento.
Cuando la función escalar f(A) actúa sobre Matrizcuadrada1 (A), el
resultado se calcula mediante el algoritmo:
Calcula los valores propios (li) y los vectores propios (Vi) de A.
Matrizcuadrada1 debe ser diagonizable. Además, no puede tener

variables simbólicas que no tengan un valor asignado.
Escriba las matrices:
A continuación, A = X B Xêy f(A) = X f(B) Xê. Por ejemplo, cos(A) =

X cos(B) Xê donde:
cos(B) =
Todos los cálculos se realizan utlizando la coma aritmética flotante.
cos ê() Tecla μ

cosê(Expr1) ⇒ expresión En el modo de ángulo en grados:
cosê(Lista1) ⇒ lista
cosê(Expr1) devuelve el ángulo cuyo coseno es Expr1 en forma de

expresión.
cosê(Lista1) devuelve una lista de los cosenos inversos de cada
elemento de Lista1.
Nota: El resultado se muestra como un ángulo en grados, grados
centesimales o radianes, según el modo de ángulo actual.
escriba arccos(...).
cosê(Matrizcuadrada1) ⇒ Matrizcuadrada En el modo de ángulo en radianes y formato complejo

rectangular:
Devuelve el coseno inverso de la matriz Matrizcuadrada1. El
resultado no es igual que calcular el coseno inverso de cada
elemento. Para obtener más información sobre el método de cálculo,
consulte cos().
Matrizcuadrada1 debe ser diagonizable. El resultado contiene
siempre números con coma flotante.

mover el cursor.

cosh()
Catálogo >
cosh(Expr1) ⇒ expresión
cosh(Lista1) ⇒ lista
cosh(Expr1) devuelve el coseno hiperbólico del argumento en forma
de expresión.
cosh(Lista1) devuelve una lista de cosenos hiperbólicos de cada
elemento de Lista1.
cosh(Matrizcuadrada1) ⇒ Matrizcuadrada En el modo de ángulo en radianes:
Devuelve el coseno hiperbólico de la matriz Matrizcuadrada1. El

resultado no es igual que calcular el coseno hiperbólico de cada
consulte cos().
cosh ê()
Catálogo >
coshê(Expr1) ⇒ expresión
coshê(Lista1) ⇒ lista
coshê(Expr1) devuelve el coseno hiperbólico inverso del argumento

en forma de expresión.
coshê(Lista1) devuelve una lista de cosenos hiperbólicos inversos de
cada elemento de Lista1.
escriba arccosh(...).
coshê(Matrizcuadrada1) ⇒ Matrizcuadrada En el modo de ángulo en radianes y formato complejo
rectangular:
Devuelve el coseno hiperbólico inverso de la matriz
Matrizcuadrada1. El resultado no es igual que calcular el coseno
hiperbólico inverso de cada elemento. Para obtener más información
sobre el método de cálculo, consulte cos().

mover el cursor.
cot() Tecla μ
cot(Expr1) ⇒ expresión En el modo de ángulo en grados:
cot(Lista1) ⇒ lista
Devuelve la cotangente de Expr1 o una lista de las cotangentes de

todos los elementos de Lista1.
utilizar ó, G oôpara sobrescribir el modo de ángulo temporalmente.

cot ê() Tecla μ
cotê(Expr1) ⇒ expresión En el modo de ángulo en grados:
cotê(Lista1) ⇒ lista
Devuelve el ángulo cuya cotangente es Expr1 o una lista de las
cotangentes inversas de cada elemento de Lista1.
Nota: El resultado se muestra como un ángulo en grados, radianes o
grados centesimales, según el modo de ángulo actual.
escriba arccot(...). En el modo de ángulo en radianes:
coth()
Catálogo >
coth(Expr1) ⇒ expresión
coth(Lista1) ⇒ lista
Devuelve la cotangente hiperbólica de Expr1 o una lista de las
cotangentes hiperbólicas de todos los elementos de Lista1.
cothê()
Catálogo >
cothê(Expr1) ⇒ expresión
cothê(Lista1) ⇒ lista
Devuelve la cotangente hiperbólica inversa de Expr1 o una lista de
las cotangentes hiperbólicas inversas de todos los elementos de
Lista1.
escriba arccoth(...).
count()
Catálogo >
count(Valor1 o Lista1 [,Valor2 o Lista2 [,...]]) ⇒ valor

Devuelve el recuento acumulado de todos los elementos de los
argumentos que sirven para calcular valores numéricos.
Cada argumento puede ser una expresión, valor, lista o matriz. Es
posible mezclar tipos de datos y utilizar argumentos con distintas
dimensiones.
En listas, matrices o rangos de celdas, se calcula cada elemento para
determinar si debe incluirse en el recuento.
En la aplicación Listas y Hojas de cálculo, puede utilizarse un rango de
celdas en lugar de cualquier argumento.
Se desestiman los elementos vacíos (sin valor). Para obtener más En el último ejemplo, sólo se han contado los valores 1/2 y
información sobre los elementos vacíos consulte la página 160. 3+4*i. Los restantes argumentos, suponiendo que x esté sin
definir, no se utilizan para calcular valores numéricos.

countif()
Catálogo >
countif(Lista,Criterios) ⇒ valor
Devuelve el recuento acumulado de todos los elementos de Lista que
cumplen los Criterios especificados. Cuenta el número de elementos que son iguales a 3.
Los criterios pueden ser:

• Un valor, una expresión o una cadena. Por ejemplo, 3 cuenta sólo
los elementos de Lista que se simplifican al valor 3. Cuenta el número de elementos que son iguales a “def”.
• Una expresión booleana que contenga el símbolo ? como lugar
donde introducir cada elemento. Por ejemplo, ?<5 cuenta sólo
los elementos de Lista que son menores de 5.
En la aplicación Listas y Hojas de cálculo, puede utilizarse un rango de
Cuenta el número de elementos que son iguales a x; en este
celdas en lugar de Lista.
ejemplo se supone que la variable x está sin definir.
Se desestiman los elementos vacíos (sin valor) de la lista. Para
obtener más información sobre los elementos vacíos consulte la
página 160.
Nota: Consulte también sumIf(), en la página 119, y frequency(), Cuenta 1 y 3.
en la página 50.
Cuenta 3, 5 y 7.
Cuenta 1, 3, 7 y 9.
cPolyRoots()
Catálogo >
cPolyRoots(Poli,Var)⇒ lista
cPolyRoots(ListaDeCoef) ⇒ lista
La primera sintaxis, cPolyRoots(Poli,Var), devuelve una lista de

las raíces complejas de un polinomio Poli con respecto a la variable
Var.
Poli debe ser un polinomio en una variable.
La segunda sintaxis, cPolyRoots(ListaDeCoef), devuelve una lista
de raíces complejas para los coeficientes de ListaDeCoef.
Nota: Consulte también polyRoots(), en la página 90.
crossP() Catálogo >
crossP(Lista1, Lista2) ⇒ lista

Devuelve el producto vectorial de Lista1 y Lista2 en forma de lista.
Lista1 y Lista2 deben tener la misma dimensión, que deberá ser 2 o
3.
crossP(Vector1, Vector2) ⇒ vector

Devuelve un vector fila o columna (depende del argumento) que es el
producto vectorial de Vector1 y Vector2.
Tanto Vector1 como Vector2 deben ser vectores fila, o vectores
columna. Los dos vectores deben tener la misma dimensión, que
deberá ser 2 o 3.

csc() Tecla μ
csc(Expr1) ⇒ expresión En el modo de ángulo en grados:
csc(Lista1) ⇒ lista
Devuelve la cosecante de Expr1 o una lista de las cosecantes de
todos los elementos de Lista1.
cscê() Tecla μ
csc ê(Expr1) ⇒ expresión En el modo de ángulo en grados:
csc ê(Lista1) ⇒ lista
Devuelve el ángulo cuya cosecante es Expr1 o una lista de las

cosecantes inversas de todos los elementos de Lista1.
escriba arccsc(...). En el modo de ángulo en radianes:
csch()
Catálogo >
csch(Expr1) ⇒ expresión
csch(Lista1) ⇒ lista
Devuelve la cosecante hiperbólica de Expr1 o una lista de las
cosecantes hiperbólicas de todos los elementos de Lista1.
cschê()
Catálogo >
cschê(Expr1) ⇒ expresión
cschê(Lista1) ⇒ lista
Devuelve la cosecante hiperbólica inversa de Expr1 o una lista de las
cosecantes hiperbólicas inversas de todos los elementos de Lista1.
escriba arccsch(...).

cSolve()
Catálogo >
cSolve(Ecuación, Var) ⇒ Expresión boolena

cSolve(Equación, Var=Conjetura) ⇒ Expresión booleana
cSolve(Desigualdad, Var) ⇒ Expresión booleana
Devuelve las posibles soluciones complejas de una ecuación o

desigualdad para Var. El objetivo es presentar todas las posibles
soluciones, tanto reales como no reales. Incluso si Ecuación es real,
cSolve() permite resultados no reales en formato complejo.
Aunque todas las variables no definidas no terminen con un carácter

de subrayado (_) se procesan como si fueran reales, cSolve() puede
resolver ecuaciones polinómicas mediante soluciones complejas.
Durante la solución, cSolve() define temporalmente el dominio
como complejo incluso aunque el dominio actual sea real. En el
dominio complejo, las potencias de fracción que tengan
denominadores impares utilizan la rama principal en lugar de la real.
Por lo tanto, las soluciones de solve() en ecuaciones que requieran
tales potencias de fracción no constituyen necesariamente un
subconjunto derivado de cSolve().
cSolve() se inicia con métodos simbólicos exactos. cSolve() utiliza En modo Mostrar dígitos como Fijo 2:
también factoriales polinómicos complejos aproximados iterativos, en
caso necesario.
Nota: Consulte también cZeros(), solve() y zeros().
Nota: Si Ecuación no es un polinomio con funciones como abs(),

angle(), conj(), real() o imag(), deberá insertarse un carácter de
subrayado (pulse /_ ) al final de Var. De forma
predeterminada, las variables se tratan como valores reales.
mover el cursor.
Si utiliza var_, la variable será tratada como un número complejo. z tratado como real:
También deberá utilizar var_ para cualquier otra variable de
Ecuación que pueda tener valores no reales. De lo contrario puede
obtener resultados imprevistos.
z_ tratado como complejo:
cSolve(Ecuación1 and Ecuación2 [and …],

VarOConjetura1, VarOConjetura2 [, … ])
⇒ Expresión booleana
cSolve(SistemaDeEcuaciones, VarOConjetura1,
VarOConjetura2 [, …]) ⇒ Expresión booleana
Devuelve las posibles soluciones complejas para las ecuaciones
algebraicas simultáneas, donde cada varOConjetura especifica una
variable para la que se desea resolver.
Opcionalmente se puede especificar un valor inicial para una variable.
Cada varOConjetura debe tener la forma:
variable
–o–
variable = número real o no real.
Por ejemplo, x es válido y también x=3+i.
Si todas las ecuaciones son polinómicas y NO se ha especificado Nota: Los ejemplos siguientes utilizan un carácter de subrayado
ningún valor inicial, cSolve() utiliza el método de eliminación léxica
de Gröbner/Buchberger para tratar de determinar todas las
(pulse/_ ) para que las variables se puedan considerar
soluciones complejas. como números complejos.

cSolve()
Catálogo >
Las soluciones complejas pueden incluir tanto números reales como

no reales, tal y como se indica en el ejemplo de la derecha.

mover el cursor.
Las ecuaciones polinómicas simultáneas pueden tener variables extra
que carezcan de valores pero que representen valores numéricos
dados que puedan ser sustituidos más adelante.

mover el cursor.
También puede incluir variables de solución que no aparezcan en las
ecuaciones. Dichas soluciones muestran cómo las familias de
soluciones pueden contener constantes arbitrarias de la forma ck,
donde k sea un sufijo entero de 1 a 255.
Para sistemas polinómicos, el tiempo de cálculo o el agotamiento de
la memoria pueden depender del orden con el que aparecen las
variables de solución. Si la opción de memoria, o su paciencia, se
mover el cursor.
agota, pruebe a reorganizar las variables de las ecuaciones, la lista de
varOConjetura o ambos elementos.
Si no incluye ningún valor inicial y alguna de las ecuaciones es no
polinómica en cualquier variable pero todas las ecuaciones son
lineales en todas las variables de solución, cSolve() utiliza un método
de eliminación gaussiana para tratar de determinar todas las
soluciones.
Si el sistema no es polinómico en todas sus variables ni lineal en

todas sus variables de solución, cSolve() determina una solución
como máximo utilizando un método de iteración aproximada. Para
ello, el número de las variables de la solución debe ser igual al
número de ecuaciones, y todas las demás variables de las ecuaciones
deben simplificarse en números.
A veces puede ser necesario utilizar un valor inicial no real para
determinar una solución no real. Por convergencia, es probable que el
valor inicial esté bastante próximo a la solución.

mover el cursor.

CubicReg
Catálogo >
CubicReg X, Y[, [Frec] [, Categoría, Incluir]]
Calcula la regresión polinómica cúbica y = a·x3+b· x2+c·x+d de

las listas X e Y con la frecuencia Frec. El resumen de los resultados se
guarda en la variable stat.results. (Consulte la página 116).
Todas las listas, salvo Incluir, deben tener la misma dimensión.
X e Y son listas que contienen, respectivamente, la variable
independiente y la variable dependiente.
Frec es una lista opcional de valores de frecuencia. Cada elemento
de Frec especifica la frecuencia de ocurrencia de cada punto de datos
en X e Y. El valor predeterminado es 1. Todos los elementos deben
ser enteros | 0.
Categoría es una lista de códigos categoría para los
correspondientes datos de X e Y.
Incluir es una lista de uno o varios códigos de categoría. En el cálculo
sólo se incluyen los elementos de datos cuyo código de categoría se
encuentre en la lista.
160.
salida
stat.RegEqn Ecuación de regresión: a·x3+b·x2+c·x+d
stat.a, stat.b, stat.c, Coeficientes de regresión

stat.d
stat.R2 Coeficiente de determinación
stat.Resid Residuos de la regresión
stat.XReg Lista de puntos de datos en la Lista X modificada utilizada realmente en la regresión basada en
restricciones de Frec, Lista Categoría e Incluir Categoría
stat.YReg Lista de puntos de datos en la Lista Y modificada utilizada realmente en la regresión basada en las
stat.FreqReg Lista de frecuencias correspondiente a stat.XReg y stat.YReg
cumulativeSum()
Catálogo >
cumulativeSum(Lista1) ⇒ lista
Devuelve una lista de las sumas acumuladas de los elementos de
Lista1, a partir del elemento 1.
cumulativeSum(Matriz1) ⇒ matriz
Devuelve una matriz de las sumas acumuladas de los elementos de
Matriz1. Cada elemento es la suma acumulada de los elementos de
la columna desde arriba hacia abajo.
Un elemento vacío (sin valor) de Lista1 o Matriz1 genera un
elemento sin valor en la lista o la matriz resultante. Para obtener más
información sobre los elementos vacíos consulte la página 160

Cycle
Catálogo >
Cycle Listado de función que suma los enteros de 1 a 100 omitiendo
50.
Transfiere el control de forma inmediata a la siguiente iteración del
bucle actual (For, While o Loop).
Cycle no está admitido fuera de las tres estructuras de bucle (For,
While o Loop).

@
Enter (Intro).
4Cylind Catálogo >
Vector 4Cylind
escriba @>Cylind.
Muestra el vector de la fila o la columna en formato cilíndrico [r,q,
z].
Vector debe tener tres elementos exactamente. Puede ser una fila o
una columna.
cZeros()
Catálogo >
cZeros(Expr, Var) ⇒ lista En modo Mostrar dígitos como Fijo 3:
Devuelve una lista de posibles valores, tanto reales como no reales,

para Var que hacen Expr=0. cZeros() lo consigue calculando
exp4lista(cSolve(Expr=0,Var),Var). De lo contrario, cZeros() es
similar a zeros().
Nota: Consulte también cSolve(), solve() y zeros().
mover el cursor.
Nota: Si Expr no es un polinomio con funciones como abs(), z tratado como real:
angle(), conj(), real() o imag(), deberá insertarse un carácter de
subrayado (pulse /_ ) al final de Var. De forma
predeterminada, las variables se tratan como valores reales. Si utiliza
var_ , la variable será tratada como un número complejo. z_ tratado como complejo:
También deberá utilizar var_ para cualquier otra variable de Expr
que pueda tener valores no reales. De lo contrario puede obtener
resultados imprevistos.
cZeros({Expr1, Expr2 [, … ] },
{VarOConjetura1,VarOConjetura2 [, … ] }) ⇒ matriz
Devuelve las posibles posiciones donde las expresiones son cero
simultáneamente. Cada VarOConjetura especifica una incógnita
cuyo valor se desea determinar.
Cada varOConjetura debe tener la forma:
variable
–o–
variable = número real o no real
Por ejemplo, x es válido y también x=3+i.

cZeros()
Catálogo >
Si todas las expresiones son polinomios y NO se ha especificado Nota: Los ejemplos siguientes utilizan un carácter de
ningún valor inicial, cZeros() utiliza el método de eliminación léxica
de Gröbner/Buchberger para tratar de determinar todos los ceros
subrayado _ (pulse /_ ) para que las variables se
puedan considerar como números complejos.
complejos.
Los ceros complejos pueden incluir tanto números reales como no
reales, tal y como se indica en el ejemplo de la derecha.
Cada fila de la matriz resultante representa un cero alternativo, con
los componentes ordenados igual que en la lista de VarOConjetura.
Para extraer una fila, indexe la matriz por [fila].
Extraer fila 2:
Los polinomios simultáneos pueden tener variables extra que

carezcan de valores pero que representen valores numéricos dados
que puedan ser sustituidos más adelante.
También puede incluir variables incógnitas que no aparezcan en las

expresiones. Dichos ceros muestran cómo las familias de soluciones
pueden contener constantes arbitrarias de la forma ck, donde k sea
un sufijo entero de 1 a 255.
Para sistemas de polinomios, el tiempo de cálculo o el agotamiento
de la memoria pueden depender del orden con que el aparecen las
incógnitas. Si la opción de memoria inicial, o su paciencia, se agota,
pruebe a reorganizar las variables de las expresiones, la lista de
VarOConjetura o ambos elementos.
Si no incluye ningún valor inicial y alguna de las expresiones no es

polinómica en cualquier variable pero todas las expresiones son
lineales en todas las incógnitas, cZeros() utiliza un método de
eliminación gaussiana para tratar de determinar todos los ceros.
Si el sistema no es polinómico en todas sus variables ni lineal en sus

incógnitas, cZeros() determina una solución como máximo utilizando
un método de iteración aproximada. Para ello, el número de las
variables de la solución debe ser igual al número de expresiones, y
todas las demás variables de las expresiones deben simplificarse en
números.
A veces puede ser necesario utilizar un valor inicial no real para
determinar un cero no real. Por convergencia, es probable que un
valor inicial esté bastante próximo a cero.

D
dbd()
Catálogo >
dbd(fecha1,fecha2) ⇒ valor
Devuelve el número de días entre fecha1 y fecha2 utilizando el
método de recuento de días reales.
fecha1 y fecha2 pueden ser números o listas de números
comprendidos en el rango de fechas del calendario estándar. Si tanto
fecha1 como fecha2 son listas, deben tener la misma longitud.
fecha1 y fecha2 deben estar comprendidas en los años 1950 y 2049.
Puede introducir las fechas en cualquiera de los dos formatos.
El separador decimal permite diferenciar los formatos de fecha.
MM.DDAA (es el formato de uso más frecuente en EE. UU.)
DDMM.AA (es el formato de uso más frecuente en Europa)
4DD Catálogo >
Expr1 4DD ⇒ valor En el modo de ángulo en grados:

Lista1 4DD ⇒ list
Matriz1 4DD ⇒ matriz
escriba @>DD.
Devuelve el equivalente decimal del argumento expresado en grados.
El argumento es un número, lista o matriz que se interpreta en
grados, radianes o grados centesimales según el modo de ángulo
actual. En el modo de ángulo en grados centesimales:
4Decimal Catálogo >
Expresión1 4Decimal ⇒ expresión

Lista1 4Decimal ⇒ expresión
Matriz1 4Decimal ⇒ expresión
escriba @>Decimal.
Muestra el argumento en formato decimal. El operador sólo se puede
utilizar al final de la línea de entrada.

Define (Definir)
Catálogo >
Define Var = Expresión

Define Function(Param1, Param2, ...) = Expresión
Define la variable Var o la función definida por el usuario Function.

Los parámetros, como Param1, son lugares donde insertar los
argumentos que pasan a la función. Al designar una función definida
por el usuario es necesario facilitar los argumentos (por ejemplo,
valores o variables) correspondientes a los parámetros. Cuando se
activa, la función calcula el valor de Expresión con los argumentos
facilitados.
Var y Function no pueden ser el nombre de una variable del sistema
ni de una orden o función integrada.
Nota: Esta forma de la orden Define equivale a ejecutar la
expresión: expresión & Function(Param1,Param2).
Define Function(Param1, Param2, ...) = Func

Bloque
EndFunc
Define Program(Param1, Param2, ...) = Prgm

Bloque
EndPrgm
De esta forma, la función o programa definidos por el usuario pueden
ejecutar un bloque de varias sentencias.
Bloque puede ser una sentencia sencilla o una serie de sentencias
escritas en varias líneas. Bloque puede incluir también expresiones e
instrucciones (como If, Then, Else y For).
@
Enter (Intro).
Nota: Consulte también Define LibPriv, en la página 34 y Define

LibPub, en la página 35.
Define LibPriv
Catálogo >
Define LibPriv Var = Expresión

Define LibPriv Function(Param1, Param2, ...) = Expresión
Define LibPriv Function(Param1, Param2, ...) = Func
Bloque
EndFunc
Define LibPriv Program(Param1, Param2, ...) = Prgm
Bloque
EndPrgm
Funciona igual que Define, salvo en que define una variable de
biblioteca, función o programa privados. Las funciones y los
programas privados no aparecen en el Catálogo.
Nota: Consulte también Define, en la página 34 y Define LibPub,
en la página 35.

Define LibPub
Catálogo >
Define LibPub Var = Expresión

Define LibPub Function(Param1, Param2, ...) = Expresión
Define LibPub Function(Param1, Param2, ...) = Func
Bloque
EndFunc
Define LibPub Program(Param1, Param2, ...) = Prgm
Bloque
EndPrgm
Funciona igual que Define, salvo en que define una variable de
biblioteca, función o programa públicos. Las funciones y los
programas públicos aparecen en el Catálogo una vez que la biblioteca
ha sido guardada y actualizada.
Nota: Consulte también Define, en la página 34 y Define LibPriv,
en la página 34.
deltaList() Consulte @List(), en la página 66.
deltaTmpCnv() Consulte @tmpCnv(), en la página 125.
DelVar
Catálogo >
DelVar Var1[, Var2] [, Var3] ...

DelVar Var.
Borra la variable o el grupo de variables especificado de la memoria.

Si hay una o más variables bloqueadas, la orden muestra un mensaje
de error y borra sólo las variables que no están bloqueadas. Consulte
unLock, en la página 131.
DelVar Var. borra todos los miembros del grupo de variables Var.
(por ejemplo, el estadístico stat.nn resultados o variables creadas
utilizando la función LibShortcut()). El punto (.) en este formato de
orden de DelVar impide borrar un grupo de variables; no tiene efecto
sobre la variable sencilla Var.
delVoid()
Catálogo >
delVoid(Lista1) ⇒ lista
Devuelve una lista que muestra el contenido de Lista1 del que se han
eliminado todos los elementos vacíos (sin valor).
Para obtener más información sobre los elementos vacíos, consulte la
página 160.
derivative() Consulte d(), en la página 149.

deSolve()
Catálogo >
deSolve(ODE1erO2ºOrden, Var, depVar)

⇒ una solución general
Devuelve una ecuación que implícita o explícitamente especifica una
solución general para la ecuación deferencial ordinaria (ODE) de
primer o segundo grado. En la ODE:
• Utilice el símbolo principal (pulse º ) para indicar la primera

derivada de la variable dependiente con respecto a la variable
independiente.
• Utilice los dos símbolos principales para indicar la segunda
derivada correspondiente.
El símbolo principal se utiliza sólo para las derivadas incluidas en
deSolve(). En los demás casos, utilice d().
La solución general de una ecuación de primer grado contiene una
constante arbitraria de la forma ck, donde k es un sufijo entero de 1 a
255. La solución de la ecuación de segundo grado contiene dos
constantes de ese tipo.
Aplique solve() a una solución implícita si desea tratar de convertirla
en una o varias soluciones equivalentes explícitas.
Al comparar los resultados con las soluciones del libro o el manual,

tenga en cuenta que métodos distintos introducen constantes
arbitrarias en diferentes puntos del cálculo, lo que puede generar
diversas soluciones generales.
deSolve(ODE1erOrden and Condinicial, Var, Vardependiente)

⇒ una solución particular
Devuelve una solución particular que satisface la ODE de primer
orden y la Condición inicial. Es un método que suele resultar más
fácil que determinar una solución general, sustituir los valores
iniciales, hallar la constante arbitraria y, finalmente, sustituir el valor
en la solución general.
Condición inicial es una ecuación de la forma:
depVar (ValorIndependienteInicial) = ValorDependienteInicial
El ValorIndependienteInicial y el ValorDependienteInicial pueden
ser variables como x0 e y0 que tengan valores no almacenados. La
diferenciación implícita puede facilitar la comprobación de las
soluciones implícitas.
deSolve(ODE2ºOrden and Condinicial1 and Condinicial2,
Var, Vardependiente) ⇒ una solución particular
Devuelve una solución concreta que satisface la ODE2ºOrden y tiene
un valor especificado de la variable dependiente y de su primera
derivada en un punto.
Para Condinicial1, utilice la forma:
depVar (ValorIndependienteInicial) = ValorDependienteInicial
Para Condinicial2, utilice la forma:
depVar (ValorIndependienteInicial) = Valor1ªDerivadaInicial

deSolve()
Catálogo >
deSolve(ODE2ºOrden and Condextremo1 and

Condextremo2, Var, Vardependiente) ⇒ una solución
particular
Devuelve una solución particular que satisface la ODE de segundo
orden y tiene el valor especificado en dos puntos diferentes.
det()
Catálogo >
det(Matrizcuadrada[, Tolerancia]) ⇒ expresión

Devuelve la determinante de Matrizcuadrada.
Opcionalmente, cualquier elemento de la matriz se trata como cero si
su valor absoluto es menor que Tolerancia. Esta tolerancia se utiliza
sólo si la matriz tiene entradas de coma flotante y no contiene
ninguna variable simbólica que no tenga asignado un valor. De lo
contrario, se ignorará el valor de Tolerancia.
• Si utiliza/· o define el modo Auto o Aproximado

en Aproximado, los cálculos se efectuarán utilizando la coma
flotante aritmética.
• Si el valor de Tolerancia se omite o no se utiliza, la tolerancia
predeterminada se calcula como:
5EM14 ·max(dim(Matrizcuadrada))·
rowNorm(Matrizcuadrada)
diag()
Catálogo >
diag(Lista) ⇒ matriz
diag(Matrizfila) ⇒ matriz
diag(Matrizcolumna) ⇒ matriz
Devuelve una matriz con los valores de la lista de argumentos o de la

diagonal principal de la matriz.
diag(Matrizcuadrada) ⇒ Matrizfila
Devuelve una matriz fila con los elementos de la diagonal principal de
Matrizcuadrada.
Matrizcuadrada debe ser cuadrada.
dim()
Catálogo >
dim(Lista) ⇒ entero
Devuelve la dimensión de Lista.
dim(Matriz) ⇒ lista
Devuelve las dimensiones de la matriz como una lista de dos
elementos {filas, columnas}.
dim(Cadena) ⇒ entero
Devuelve el número de caracteres contenido en la cadena de
caracteres Cadena.

Disp
Catálogo >
Disp [exprOCadena1] [, exprOCadena2] ...
Muestra los argumentos del historial de Calculadora. Los argumentos

aparecen uno tras otro separados por pequeños espacios.
Resulta especialmente útil en programas y funciones ya que permite
garantizar la presentación de cálculos intermedios.
@
varias líneas si pulsa en lugar de· al final de cada línea.
Enter (Intro).
4DMS Catálogo >
Expr 4DMS En el modo de ángulo en grados:

List 4DMS
Matriz 4DMS
escriba @>DMS.
Interpreta el argumento como un ángulo y muestra el número GMS
equivalente (GGGGGG¡MM'SS.ss''). Consulte ¡, ', '', en la página
155 para ver información sobre el formato DMS(grados, minutos,
segundos).
Nota: 4DMS se convertirá de radianes a grados cuando se utilice en
modo radianes. Si la entrada va seguida de un símbolo de grados, ¡,
no se producirá conversión alguna. Sólo se puede utilizar 4DMS al
final de una línea de entrada.

dominantTerm()
Catálogo >
dominantTerm(Expr1, Var [, Punto]) ⇒ expresión

dominantTerm(Expr1, Var [, Punto]) | Var>Punto
⇒ expresión
dominantTerm(Expr1, Var [, Punto]) | Var<Punto
⇒ expresión
Devuelve el término dominante de una representación de series de
potencias de Expr1 ampliadas a partir de Punto. El término
dominante es aquel cuya magnitud crece más rápidamente a media
que se aproxima a Var = Punto. La potencia resultante de (Var N
Punto) puede tener un exponente negativo y/o fraccionario. El
coeficiente de esta potencia puede incluir logaritmos de (Var N
Punto) y otras funciones de Var que estén dominadas por todas las
potencias de (Var N Punto) con el mismo signo de exponente.
Punto valor predeterminado 0. Punto puede ser ˆ o Nˆ, en cuyo

caso el término dominante será el que tenga el exponente mayor de
Var, no el de menor exponente de Var.
dominantTerm(…) devuelve “dominantTerm(…)” si no puede
obtener una representación concreta como, por ejemplo,
singularidades esenciales como sin(1/z) en z=0, eN1/z en z=0, o ez en
z = ˆ o Nˆ.
Si la serie o una de sus derivadas tiene un salto de discontinuidad en
Punto, el resultado puede contener subexpresiones en la forma
sign(…) o abs(…) para una variable de desarrollo real, o (-
1)floor(…angle(…)…) para una variable de desarrollo complejo, como
una que termine con “_”. Si piensa utilizar el término dominante sólo
para los valores de un lado de Punto, añada a dominantTerm(...) el
valor apropiado de “| Var > Punto”, “| Var < Punto”, “| “Var ‚
Punto” o “Var  Punto” para obtener un resultado más simple.
dominantTerm() se distribuye sobre los primeros argumentos,
listas y matrices.
dominantTerm() resulta útil cuando desea conocer la expresión más
simple posible que es asintótica a otra expresión como Var " Punto.
dominantTerm() también resulta útil cuando no es evidente el grado
del primer término distinto de cero de una serie, y no desea realizar
aproximaciones iterativas, ya sea de forma interactiva o mediante un
bucle de programa.
Nota: Consulte también series(), en la página 105.
dotP()
Catálogo >
dotP(Lista1, Lista2) ⇒ expresión

Devuelve el producto escalar de dos listas.
dotP(Vector1, Vector2) ⇒ expresión

Devuelve el producto escalar de dos vectores.
Los dos vectores deben ser fila o columna.

E
e^() Tecla u
e^(Expr1) ⇒ expresión
Devuelve el valor de e elevado al exponente Expr1.
Nota: Consulte también Plantilla de base e, en la página 2.
Nota: Pulsar u para mostrar e^( no es lo mismo que pulsar el

carácter E del teclado.
Puede introducir un número complejo en la forma polar rei q. No
obstante, deberá utilizar esta forma sólo en el modo de ángulo en
radianes: genera un error de dominio en el modo de ángulo en grados
o grados centesimales.
e^(Lista1) ⇒ lista
Devuelve el valor de e elevado a cada elemento de Lista1.
e^(Matrizcuadrada1) ⇒ Matrizcuadrada
Devuelve la matriz exponencial de Matrizcuadrada1. El resultado no
es igual que calcular e elevado a cada elemento. Para obtener más
información sobre el método de cálculo, consulte cos().
eff()
Catálogo >
eff(Tasanominal,CpY) ⇒ valor
Función financiera que convierte la tasa de interés nominal
Tasanominal en una tasa anual efectiva, siendo CpY el número de
periodos compuestos por año.
Tasanominal debe ser un número real; CpY debe ser un número real
> 0.
Nota: Consulte también nom(), en la página 80.
eigVc()
Catálogo >
eigVc(Matrizcuadrada) ⇒ matriz En el formato complejo rectangular:
Devuelve una matriz que contiene los vectores propios para una
Matrizcuadrada real o compleja, donde cada columna del resultado
corresponde a un valor propio. Tenga en cuenta que los vectores
propios no son únicos; pueden venir multiplicados por cualquier
factor constante. Los vectores propios están normalizados, de tal
modo que si V = [x 1, x 2, … , x n], entonces:
x 12 + x 22 + … + x n2 = 1
Matrizcuadrada se transforma en primer lugar hasta que las normas

de la fila y la columna se aproximen al mismo valor tanto como sea
posible. A continuación se reduce Matrizcuadrada hasta la forma
superior de Hessenberg y los vectores propios se calculan por medio
de una factorización de Schur. Para ver todos los resultados, pulse £ y utilice ¡ y ¢ para
mover el cursor.

eigVl()
Catálogo >
eigVl(Matrizcuadrada) ⇒ lista En el modo de formato complejo rectangular:

Devuelve una lista de valores propios de una Matrizcuadrada real o
compleja.
Matrizcuadrada se transforma en primer lugar hasta que las normas
de la fila y la columna se aproximen al mismo valor tanto como sea
posible. A continuación se reduce Matrizcuadrada hasta la forma
superior de Hessenberg y los valores propios se calculan a partir de la
matriz superior de Hessenberg.
mover el cursor.
Else Consulte If, en la página 56.
ElseIf
Catálogo >
If ExprBooleana1 Then
Bloque1
ElseIf ExprBooleana2 Then
Bloque2
©
ElseIf ExprBooleanaN Then
BloqueN
EndIf
©
@
Enter (Intro).
EndFor Consulte For, en la página 48.
EndFunc Consulte Func, en la página 51.
EndIf Consulte If, en la página 56.
EndLoop Consulte Loop, en la página 72.
EndPrgm Consulte Prgm, en la página 91.
EndTry Consulte Try, en la página 126.

EndWhile Consulte While, en la página 133.
exact()
Catálogo >
exact( Expr1 [, Tolerancia]) ⇒ expresión

exact( Lista1 [, Tolerancia]) ⇒ lista
exact( Matriz1 [, Tolerancia]) ⇒ matriz
Utiliza el modo aritmético Exact para devolver, siempre que sea

posible, el número racional equivalente de un argumento.
Tolerancia especifica la tolerancia de la conversión; el valor
predeterminado es 0 (cero).
Exit
Catálogo >
Exit Listado de funciones:
Sale del bloque For, While o Loop actual.
Exit no está admitido fuera de las tres estructuras de bucle (For,
While o Loop).

@
Enter (Intro).
4exp Catálogo >
Expr 4exp
Representa Expr en función de potencias de base e. Es un operador
de conversión de presentación, y se puede utilizar únicamente al final
de la línea de entrada.
escriba @>exp.
exp() Tecla u
exp(Expr1) ⇒ expresión
Devuelve el valor de e elevado al exponente Expr1.
Nota: Consulte también Plantilla de base e, en la página 2.
Puede introducir un número complejo en la forma polar rei q. No

obstante, deberá utilizar esta forma sólo en el modo de ángulo en
radianes: genera un error de dominio en el modo de ángulo en grados
o grados centesimales.

exp() Tecla u
exp(Lista1) ⇒ lista
Devuelve el valor de e elevado a cada elemento de Lista1.
exp(Matrizcuadrada1) ⇒ Matrizcuadrada
Devuelve la matriz exponencial de Matrizcuadrada1. El resultado no
es igual que calcular e elevado a cada elemento. Para obtener más
exp4lista()
Catálogo >
exp4list(Expr,Var) ⇒ lista
Examina Expr para ecuaciones separadas por la palabra “or”, y
devuelve una lista que contiene los extremos derechos de las
ecuaciones en la forma Var=Expr. Es una forma fácil de extraer
algunos valores solución incluidos en los resultados de las funciones
solve(), cSolve(), fMin() y fMax().
Nota: exp4list() no aparece necesariamente con las funciones zeros

y cZeros() ya que éstas devuelven directamente una lista de valores
solución.
Si desea insertar esta función con el teclado del ordenador, escriba
exp@>list(...).
expand()
Catálogo >
expand(Expr1 [, Var]) ⇒ expresión

expand(Lista1 [,Var]) ⇒ lista
expand(Matriz1 [,Var]) ⇒ matriz
expand(Expr1) devuelve Expr1 desarrollada con respecto a todas

sus variables. El desarrollo es una expresión polinómica para los
polinomios y de fracción parcial para las expresiones racionales.
El objetivo de expand() es convertir Expr1 en una suma o una
diferencia de términos sencillos o en ambas. Por el contrario, el
objetivo de factor() es convertir Expr1 en un producto o un cociente
de factores sencillos o en ambos.
expand(Expr1,Var) devuelve Expr1 desarrollado con respecto a
Var. Se agrupan potencias similares de Var. Los términos y sus
factores se ordenan con Var como variable principal. Puede haber
alguna factorización o desarrollo incidental de los coeficientes
agrupados. Comparada con la omisión de Var, supone ahorro de
tiempo, memoria y espacio de pantalla, al tiempo que hace que la
expresión sea más comprensible.

expand()
Catálogo >
Incluso cuando sólo hay una variable, el uso de Var puede hacer que
la factorizacion del denominador utilizado para un desarrollo de
fracción parcial sea más completa.
Sugerencia: Para expresiones racionales, propFrac() es más rápido
pero ofrece una alternativa más reducida que expand().
Nota: Consulte también comDenom() para ver más información de
un numerador desarrollado sobre un denominador desarrollado.
expand(Expr1,[Var]) desarrolla también logaritmos y potencias de

fracción al margen del valor de Var. El desarrollo de logaritmos y
potencias puede requerir el uso de algunas restricciones en las
desigualdades para garantizar que algunos factores sean no
negativos.
expand(Expr1, [Var]) desarrolla también valores absolutos, sign() y

exponenciales, sin tener en cuenta Var.
Nota: Consulte también tExpand() para ver información sobre suma
de ángulos y desarrollo de varios ángulos.
expr()
Catálogo >
expr(Cadena) ⇒ expresión
Devuelve la cadena de caracteres contenida en Cadena como una
expresión y la ejecuta de inmediato.
ExpReg
Catálogo >
ExpReg X, Y [, [Frec] [, Categoría, Incluir]]
Calcula la regresión exponencial y = a·(b)x en las listas X e Y con la

frecuencia Frec. El resumen de los resultados se guarda en la variable
stat.results. (Consulte la página 116).
ser enteros | 0.
160.

salida
stat.RegEqn Ecuación de regresión: a·(b)x
stat.a, stat.b Coeficientes de regresión
2
stat.r Coeficiente de determinación lineal para los datos transformados
stat.r Coeficiente de correlación para los datos transformados (x, ln(y))
stat.Resid Residuos asociados con el modelo exponencial
stat.ResidTrans Residuos asociados con el ajuste lineal de los datos transformados
F
factor()
Catálogo >
factor(Expr1[, Var]) ⇒ expresión

factor(Lista1[,Var]) ⇒ lista
factor(Matriz1[,Var]) ⇒ matriz
factor(Expr1) devuelve Expr1 factorizado con respecto a todas sus

variables sobre un denominador común.
Expr1 se factoriza tanto como sea posible en factores lineales sin

introducir nuevas subexpresiones no reales. Esta alternativa resulta
apropiada si la factorización se realiza con respecto a más de una
variable.
factor(Expr1,Var) devuelve Expr1 factorizado con respecto a la

variable Var.
Expr1 se factoriza tanto como sea posible en factores reales que

sean lineales en Var, incluso si introduce constantes irracionales o
subexpresiones que sean irracionales en otras variables.
Los factores y sus términos se ordenan con Var como variable
principal. En cada factor se agrupan potencias de Var similares.
Incluya Var si la factorización es necesaria sólo con respecto a la
variable y no tiene inconveniente en aceptar expresiones irracionales
en cualquier otra variable para incrementar la factorización con
respecto a Var. Puede haber alguna factorización incidental con
respecto a otras variables.

factor()
Catálogo >
Para el ajuste Auto del modo Auto or Approximate, la inclusión

de Var permite también una aproximación con coeficientes de coma
flotante cuando no sea posible expresar explícita y concisamente los
coeficiente en términos de funciones integradas. Incluso cuando sólo
haya una variable, la inclusión de Var puede generar una
factorización más completa.
Nota: Consulte también comDenom() como método rápido de
alcanzar una factorización parcial cuando factor() no es lo bastante
rápido o si se agota la memoria.
Nota: Consulte también cFactor() para factorizar al máximo los
coeficientes complejos en busca de factores lineales.
factor(Númeroracional) devuelve el número racional factorizado en
primos. Para los números compuestos, el tiempo de cálculo crece
exponencialmente con el número de dígitos del segundo factor más
grande. Por ejemplo, factorizar un número entero de 30 dígitos puede
tardar más de un día; factorizar uno de 100 dígitos podría tardar más
de un siglo.
Nota: Para interrumpir un cálculo, pulse y mantenga pulsada la tecla
d o c.
Si sólo desea determinar si el número es primo, utilice isPrime(). Es
una opción mucho más rápida, especialmente si Númeroracional no
es primo y el segundo factor más grande tiene más de cinco dígitos.
FCdf() Catálogo >
FCdf(Extremoinferior,Extremosuperior,dfNumer,dfDenom) ⇒
número si Extremoinferior y Extremosuperior son números, lista
si Extremoinferior y Extremosuperior son listas
FCdf(Extremoinferior,Extremosuperior,dfNumer,dfDenom) ⇒
número si Extremoinferior y Extremosuperior son números, lista
si Extremoinferior y Extremosuperior son listas
Calcula la probabilidad de la distribución F entre el Extremoinferior

y el Extremosuperior para los dfNumer (grados de libertad) y
dfDenom especificados.
Para P(X Extremosuperior), defina Extremoinferior=0.
Fill
Catálogo >
Fill Expr, matrizVar ⇒ matriz

Sustituye cada elemento de la variable matrizVar con Expr.
matrizVar debe ser un valor ya existente.
Fill Expr, listaVar ⇒ lista

Sustituye cada elemento de la variable listaVar con Expr.
listaVar debe ser un valor ya existente.

FiveNumSummary
Catálogo >
FiveNumSummary X[,[Frec][,Categoría,Incluir]]
Ofrece una versión abreviada de la estadística de una variable en la

lista X. El resumen de los resultados se guarda en la variable
X representa una lista que contiene los datos.
de Frec especifica la ocurrencia de cada valor X correspondiente.
El valor predeterminado es 1. Todos los elementos deben ser enteros
| 0.
Categoría es una lista de códigos numéricos de categoría para los
valores X correspondientes.
Un elemento vacío (sin valor) en cualquiera de las listas X, Frec o
Categoría genera un dato sin valor para el mismo elemento presente
en todas las listas. Para obtener más información sobre los elementos
vacíos, consulte la página 160.
salida
stat.MinX Mínimo de valores de x
stat.Q1X Primer cuartil de x
stat.MedianX Mediana de x
stat.Q3X Tercer cuartil de x
stat.MaxX Máximo de valores de x
floor()
Catálogo >
floor(Expr1) ⇒ entero
Devuelve el mayor entero que es { el argumento. Esta función es
idéntica a int().
floor(Lista1) ⇒ lista
floor(Matriz1) ⇒ matriz
Devuelve una lista o una matriz con las correspondientes partes

enteras de los elementos.
Nota: Consulte también ceiling() e int().
fMax()
Catálogo >
fMax(Expr, Var) ⇒ Expresión booleana

fMax(Expr, Var,Extremoinferior)
fMax(Expr, Var,Extremoinferior,Extremosuperior)
fMax(Expr, Var) | Extremoinferior<Var<Extremosuperior
Devuelve una expresión booleana expecificando los valores

candidatos para Var que maximizan Expr o localizan su extremo
superior mínimo.

fMax()
Catálogo >
Puede utilizar el operador “|” para restringir el intervalo de

soluciones, especificar otros límites o ambos.
Para el ajuste Approximate (Aproximado) del modo Auto or
Approximate (Auto o Aproximado), fMax() busca
iterativamente un máximo local aproximado. Suele ser más rápido, en
especial si se utiliza el operador “|” para restringir la búsqueda a un
intervalo relativamente pequeño que contenga exactamente un
máximo local.
Nota: Consulte también fMin() y max().
fMin()
Catálogo >
fMin(Expr, Var) ⇒ Expresión booleana

fMin(Expr, Var,Extremoinferior)
fMin(Expr, Var,Extremoinferior,Extremosuperior)
fMin(Expr, Var) | Extremoinferior<Var<Extremosuperior
Devuelve una expresión booleana expecificando los valores

candidatos para Var que minimizan Expr o localizan su extremo
inferior máximo.
Puede utilizar el operador “|” para restringir el intervalo de
soluciones, especificar otros límites o ambos.
Para el ajuste Approximate (Aproximado) del modo Auto or
Approximate (Auto o Aproximado), fMin() busca
iterativamente un mínimo local aproximado. Suele ser más rápido, en
especial si se utiliza el operador “|” para restringir la búsqueda a un
intervalo relativamente pequeño que contenga exactamente un
mínimo local.
Nota: Consulte también fMax() y min().
For
Catálogo >
For Var, Inferior, Superior [, Paso]

Bloque
EndFor
Ejecuta la sentencia de Bloque iterativamente por cada valor de Var,
de Inferior a Superior, en incrementos de Paso.
Var no debe ser una variable del sistema.
Paso puede ser un valor positivo o negativo. El valor predeterminado
es 1.
separadas por el carácter “:”.
varias líneas si pulsa@ en lugar de · al final de cada línea.
Enter (Intro).

format()
Catálogo >
format(Expr[, formatoCadena]) ⇒ cadena

Devuelve Expr como una cadena de caracteres basada en la plantilla
de formato.
Expr debe simplificarse a un número.
formatoCadena es una cadena y debe estar en la forma: “F[n]”,
“S[n]”, “E[n]”, “G[n][c]”, donde [ ] indica partes opcionales.
F[n]: Formato fijo. n es el número de dígitos que aparece después del
decimal.
S[n]: Formato científico. n es el número de dígitos que aparece
después del decimal.
E[n]: Formato de ingeniería. n es el número de dígitos que aparece
después del primer dígito significante. El exponente se ajusta a un
múltiplo de tres, y el decimal se mueve hacia la derecha en cero, uno
o dos dígitos.
G[n][c]: Igual que el formato fijo pero, además, separa en grupos de
tres los dígitos situados a la izquierda del radical. c especifica el
carácter separador de grupo; el valor predeterminado es coma. Si c es
un punto, el radical aparecerá como una coma.
[Rc]: Todos los especificadores anteriores pueden llevar el sufijo
indicador de rádix RC, donde c es un único carácter que especifica el
que se va a utilizar como separador.
fPart()
Catálogo >
fPart(Expr1) ⇒ expresión
fPart(Lista1) ⇒ lista
fPart(Matriz1) ⇒ matriz
Devuelve la parte decimal de un argumento.

Para una lista o una matriz, devuelve la parte decimal de los
elementos.
FPdf() Catálogo >
FPdf(XVal,glNúmero,glDenom) ⇒ número si XVal es un

número, lista si XVal es una lista
Calcula la probabilidad de la distribución F en XVal con los grados

de libertad especificados para glNum y glDenom.

freqTable4list()
Catálogo >
freqTable4list(Lista1, ListaEnterosFrecuencia) ⇒ lista

Devuelve una lista que contiene los elementos de Lista1 ampliados
según las frecuencias de ListaEnterosFrecuencia. Esta función se
puede utilizar para construir una tabla de frecuencias para la
aplicación Datos y Estadística.
Lista1 puede ser cualquier lista válida.
ListaEnterosFrecuencia debe tener la misma dimensión que Lista1
y contener elementos enteros no negativos solamente. Cada
elemento especifica el número de veces que el correspondiente
elemento de Lista1 se va a repetir en la lista resultante. Un valor de
cero excluye el correspondiente elemento de Lista1.
escriba freqTable@>list(...).
Se desestiman los elementos vacíos (sin valor). Para obtener más
información sobre los elementos vacíos, consulte la página 160.
frequency()
Catálogo >
frequency(Lista1,Listabin) ⇒ lista
Devuelve una lista con el recuento de los elementos contenidos en
Lista1. El recuento se basa en los rangos definidos en Listabin.
Si Listabin es {b(1), b(2), …, b(n)}, los rangos especificados son
{?{b(1), b(1)<?{b(2),…,b(n-1)<?{b(n), b(n)>?}. La lista resultante
es un elemento más extenso que Listabin.
Explicación del resultado:
Cada elemento del resultado se corresponde con el número de 2 elementos de Datalist que son {2.5
elementos de Lista1 comprendidos en el rango. Expresado en 4 elementos de Datalist que son >2.5 y {4.5
términos de la función countIf(), el resultado es { countIf(list, ?{b(1)), 3 elementos de Datalist que son >4.5
countIf(list, b(1)<?{b(2)), …, countIf(list, b(n-1)<?{b(n)), El elemento “hello” es una cadena y no se puede incluir en
countIf(list, b(n)>?)}. ninguno de los rangos definidos.
Los elementos de Lista1 que no se pueden “incluir en un rango” son
desestimados.
Se desestiman los elementos de Lista1 que no se pueden “incluir en
un rango”. También se desestiman los elementos vacíos (sin valor).
Para obtener más información sobre los elementos vacíos, consulte la
página 160.
En la aplicación Listas y Hojas de cálculo, puede utilizar un rango de
celdas en lugar de ambos argumentos.
Nota: Consulte también countIf(), en la página 26.

FTest_2Samp Catálogo >
FTest_2Samp Lista1,Lista2[,Frec1[,Frec2[,Hipótesis]]]
FTest_2Samp Lista1,Lista2[,Frec1[,Frec2[,Hipótesis]]]
(Entrada de lista de datos)

FTest_2Samp sx1,n1,sx2,n2[,Hipótesis]
FTest_2Samp sx1,n1,sx2,n2[,Hipótesis]
(Entrada de resumen estadístico)

Realiza un test F de dos muestras. El resumen de los resultados se
guarda en la variable stat.results. (Consulte la página 116.)
Para Ha: s1 > s2, defina Hipótesis>0
Para Ha: s1 ƒ s2 (predeterminado), defina Hipótesis =0
Para Ha: s1 < s2, defina Hipótesis<0

160.
salida
stat.F Estadística ó calculada para la sucesión de datos
stat.dfNumer Grados de libertad del numerador = n1-1
stat.dfDenom Grados de libertad del denominador = n2-1
stat.sx1, stat.sx2 Desviaciones estándar de la muestra de las sucesiones de datos en Lista 1 y Lista 2
stat.x1_bar Medias de la muestra de las sucesiones de datos en Lista 1 y Lista 2

stat.x2_bar
stat.n1, stat.n2 Tamaño de las muestras
Func
Catálogo >
Func Definir una función a trozos:
Bloque
EndFunc
Plantilla para crear una función definida por el usuario.
Bloque puede ser una sentencia sencilla, una serie de sentencias
separadas por el carácter “:”, o una serie de sentencias escritas en
varias líneas. La función puede utilizar la instrucción Return para
devolver un resultado concreto.
@
varias líneas si pulsa en lugar de · al final de cada línea. Resultado de representar gráficamente g(x)
Enter (Intro).

G
gcd()
Catálogo >
gcd(Valor1, Valor2) ⇒ expresión

Devuelve el máximo común divisor de los dos argumentos. El gcd de
dos fracciones es el gcd de sus numeradores dividido por el lcm de
sus denominadores.
En modo Auto o Aproximado, el gcd de números con decimal flotante
es 1.0.
gcd(Lista1, Lista2) ⇒ lista
Devuelve el máximo común divisor correspondiente a cada elemento
de Lista1 y Lista2.
gcd(Matriz1, Matriz2) ⇒ matriz
Devuelve el máximo común divisor correspondiente a cada elemento
de Matriz1 y Matriz2.
geomCdf()
Catálogo >
geomCdf(p, Extremoinferior,Extremosuperior) ⇒ número si

geomCdf(p,Extremosuperior) para P(1XExtremosuperior)
⇒ número si Extremosuperior es un número, lista si
Extremosuperior es una lista
Calcula la probabilidad geométrica acumulada de Extremoinferior a
Extremosuperior con la probabilidad de éxito p especificada.
Para P(X  Extremosuperior), defina Extremoinferior = 1.
geomPdf()
Catálogo >
geomPdf(p,XVal) ⇒ número si XVal es un número, lista si

XVal es una lista
Calcula la probabilidad de que se verifique XVal, número del intento
en el que se va a producir el primer acierto, para la distribución
geométrica discreta con la probabilidad de aciertos p especificada.
getDenom()
Catálogo >
getDenom(Expr1) ⇒ expresión
Transforma el argumento en una expresión con un común
denominador reducido y, a continuación, devuelve su denominador.

getLangInfo()
Catálogo >
getLangInfo() ⇒ cadena
Devuelve una cadena que se corresponde con el nombre corto del
idioma activo en cada momento. Por ejemplo, puede utilizar el
nombre en un programa o una función para determinar el idioma
actual.
Inglés = “en”
Danés = “da”
Alemán = “de”
Finlandés = “fi”
Francés = “fr”
Italiano = “it”
Neerlandés = “nl”
Flamenco = “nl_BE”
Noruego = “no”
Portugués = “pt”
Español = “es”
Sueco = “sv”
getLockInfo()
Catálogo >
getLockInfo(Var) ⇒ valor
Devuelve el estado actual, bloqueado/desbloqueado, de la variable
Var.
value =0: Var está desbloqueada o no existe.
value =1: Var está bloqueada y no se puede modificar ni borrar.
Consulte Lock, en la página 68 y unLock, en la página 131.
getMode()
Catálogo >
getMode(ModoNombreEntero) ⇒ valor
getMode(0) ⇒ lista
getMode(ModoNombreEntero) devuelve un valor que representa
la configuración actual del modo ModoNombreEntero.
getMode(0) devuelve una lista que contiene pares de números. Cada
par consta de un entero de modo y un entero de configuración.
Para ver una lista de los modos y sus configuraciones, consulte la
tabla siguiente.
Si guarda los valores de configuración con getMode(0) & var,
puede utilizar setMode(var) en una función o un programa para
restaurar temporalmente la configuración sólo durante la ejecución
de la función o el programa. Consulte setMode(), en la página 106.
Nombre del Modo

modo del Configuración de enteros
entero
Display Digits 1 1=Flotante, 2=Flotante1, 3=Flotante2, 4=Flotante3, 5=Flotante4, 6=Flotante5,

(Mostrar dígitos) 7=Flotante6, 8=Flotante7, 9=Flotante8, 10=Flotante9, 11=Flotante10, 12=Flotante11,
13=Flotante12, 14=Fijo0, 15=Fijo1, 16=Fijo2, 17=Fijo3, 18=Fijo4, 19=Fijo5, 20=Fijo6,
21=Fijo7, 22=Fijo8, 23=Fijo9, 24=Fijo10, 25=Fijo11, 26=Fijo12

Nombre del Modo
entero
Angle (Ángulo) 2 1=Radianes, 2=Grados, 3=Grados centesimales
Exponential Format 3 1=Normal, 2=Científico, 3=Ingeniería

(Formato
exponencial)
Real or Complex 4 1=Real, 2=Rectangular, 3=Polar

(Real o complejo)
Auto or Approximate 5 1=Auto, 2=Aproximado, 3=Exacto

(Auto o aproximado)
Vector Format 6 1=Rectangular, 2=Cilíndrico, 3=Esférico

(Formato vectorial)
Base 7 1=Decimal, 2=Hex, 3=Binario
Unit System (Sistema 8 1=SI, 2=Inglés/EE UU

de unidades)
getNum()
Catálogo >
getNum(Expr1) ⇒ expresión
Transforma el argumento en una expresión con un común
denominador reducido y, a continuación, devuelve su numerador.
getVarInfo()
Catálogo >
getVarInfo() ⇒ matriz o cadena

getVarInfo(CadenaNombreBiblioteca) ⇒ matriz o cadena
getVarInfo() devuelve una matriz con información (nombre de
variable, tipo, accesibilidad a la biblioteca y estado actual bloqueado/
desbloqueado) para todas las variables y objetos de biblioteca
definidos en el problema actual.
Si no hay ninguna variable definida, getVarInfo() devuelve la
cadena "NONE".
getVarInfo(CadenaNombreBiblioteca) devuelve una matriz de
información para todos los objetos de biblioteca definidos en
CadenaNombreBiblioteca. CadenaNombreBiblioteca debe ser una
cadena (texto entre comillas) o una variable de cadena.
Si la biblioteca CadenaNombreBibliotea no existe, devuelve un
error.

getVarInfo()
Catálogo >
Observe el ejemplo de la izquierda en donde el resultado de

getVarInfo() se ha asignado a la variable vs. El intento de mostrar la
fila 2 o la fila 3 de vs devuelve un error “Lista o matriz no válidas” ya
que, al menos uno de los elementos de las filas (por ejemplo, variable
b) se recalcula en una matriz.
Este error se produce también cuando se utiliza Ans para recalcular
un resultado getVarInfo().
El sistema muestra el error anterior porque la versión actual del
software no admite una estructura de matriz generalizada donde un
elemento de una matriz puede ser tanto una matriz como una lista.
Goto
Catálogo >
Goto Nombreetiqueta
Transfiere el control a la etiqueta Nombreetiqueta.

Nombreetiqueta debe estar definido en la misma función por medio
de una instrucción Lbl.
Enter (Intro).
4Grad Catálogo >
Expr1 4Grad ⇒ expresión En el modo de ángulo en grados:
Convierte Expr1 a grados centesimales.

escriba @>Grad. En el modo de ángulo en radianes:

I
identity()
Catálogo >
identity(Entero) ⇒ matriz
Devuelve la matriz identidad de dimensión Entero.
Entero debe ser un número entero positivo.
If
Catálogo >
If Declarac ExprBooleana
If ExprBooleana Then
Bloque
EndIf
If ExprBooleana evalúa la condición como verdadera, ejecuta la
sentencia sencilla Declarac o el bloque de sentencias Bloque antes
de continuar con la ejecución.
If BooleanExpr evalúa la condición como falsa, continúa el proceso
sin ejecutar la sentencia o el bloque de sentencias.
@
varias líneas si pulsa en lugar de· al final de cada línea.
Enter (Intro).
If ExprBooleana Then
Bloque1
Else
Bloque2
EndIf
If ExprBooleana evalúa la condición como verdadera, ejecuta
Bloque1 e ignora Bloque2.
If ExprBooleana evalúa la condición como falsa, ignora Bloque1
pero ejecuta Bloque2.
Bloque1 y Bloque2 pueden ser una sentencia sencilla.

If
Catálogo >
If ExprBooleana1 Then
Bloque1
ElseIf ExprBooleana2 Then
Bloque2
©
ElseIf ExprBooleanaN Then
BloqueN
EndIf
Permite la ramificación. If ExprBooleana1 evalúa la condición como
verdadera, ejecuta Bloque1. If ExprBooleana1 evalúa la condición
como falsa, evalúa ExprBooleana2, y así.
ifFn()
Catálogo >
ifFn(ExprBooleana,Valor_Si_verd [,Valor_Si_falso
[,Valor_Si_desconocido]]) ⇒ expresión, lista o matriz
Evalúa la expresión booleana ExprBooleana (o cada elemento de

ExprBooleana ) y genera un resultado conforme a las reglas
Al ser 1 menor que 2.5 su valor correspondiente en
siguientes:
Valor_Si_verd, el 5, se copia.
• ExprBooleana puede verificar un valor, lista o matriz únicos.
• Si un elemento de ExprBooleana verifica la condición, devuelve Al ser 2 menor que 2.5 su valor correspondiente en
el elemento correspondiente de Valor_Si_verd. Valor_Si_verd, el 6, se copia.
• Si un elemento de ExprBooleana no verifica la condición,
devuelve el elemento correspondiente de Valor_Si_falso. Si se Al ser 3 mayor que 2.5 su valor correspondiente en
omite Valor_Si_falso, devuelve un valor sin definir. Valor_Si_falso, el 10, se copia.
• Si un elemento de ExprBooleana resultara no ser verdadero ni
falso, se devolverá el elemento correspondiente
Valor_Si_desconocido. Si se omite Valor_Si_desconocido,
devuelve un valor sin definir. Valor_Si_verd es un valor sencillo y corresponde a cualquier
• Si el argumento segundo, tercero o cuarto de la función ifFn() es posición seleccionada.
una expresión sencilla, la prueba booleana se aplica a cada
posición de ExprBooleana.
Nota: Si la sentencia ExprBooleana simplificada afecta a una lista o
una matriz, todos los demás argumentos de listas o matrices deberán Valor_Si_falso está sin especificar. Se utilizar Undef (sin
tener las mismas dimensiones, y el resultado tendrá también la definir).
misma dimensión.
Un elemento seleccionado de Valor_Si_verd. Un elemento

seleccionado de Valor_Si_desconocido.
imag()
Catálogo >
imag(Expr1) ⇒ expresión
Devuelve la parte imaginaria de un argumento.
reales. Consulte también real(), en la página 97.

imag()
Catálogo >
imag(Lista1) ⇒ lista
Devuelve una lista de las partes imaginarias de los elementos.
imag(Matriz1) ⇒ matriz
Devuelve una matriz de las partes imaginarias de los elementos.
impDif()
Catálogo >
impDif(Ecuación, Var, Vardependiente[,Ord])

⇒ expresión
donde el valor predeterminado de Orden es 1.
Calcula la derivada implícita de las ecuaciones en las que una variable
se define implícitamente en términos de la otra.
Indirection Consulte #(), en la página 153.
inString()
Catálogo >
inString(Cadenabsq, subCadena[, Inic]) ⇒ entero

Devuelve la posición del carácter en la cadena Cadenabsq donde
comienza la primera ocurrencia de la cadena subCadena.
Inic, si va incluido, especifica la posición del carácter de Cadenabsq
donde se inicia la búsqueda. Valor predeterminado = 1 (el primer
carácter de Cadenabsq).
Si Cadenabsq no contiene subCadena o Inic es > la longitud de
Cadenabsq, devuelve cero.
int()
Catálogo >
int(Expr) ⇒ entero
int(Lista1) ⇒ lista
int(Matriz1) ⇒ matriz
Devuelve el mayor entero menor o igual que el argumento.

Esta función es idéntica a floor().
Para una lista o una matriz, devuelve la correspondiente parte entera
de cada elemento.
intDiv()
Catálogo >
intDiv(Número1, Número2) ⇒ entero

intDiv(Lista1, Lista2) ⇒ lista
intDiv(Matriz1, Matriz2) ⇒ matriz
Devuelve la parte entera con su signo de (Número1 ÷ Número2).

Para las listas y las matrices, devuelve la parte entera con su signo de
(argumento 1 ÷ argumento 2) para cada par de elementos.
integral Consulte ‰(), en la página 149.

invc2() Catálogo >
2
invc (Área,gl)
invChi2(Área,gl)
Calcula la probabilidad acumulada inversa c2 (chi cuadrado)

especificada por el grado de libertad, gl de un Área dada bajo la
curva.
invF() Catálogo >
invF(Área,glNumer,glDenom)
invF(Área,glNumer,glDenom)
Calcula la función de distribución acumulada normal inversa F

especificada por el glNumer y el glDenom de un Área dada bajo la
curva.
invNorm()
Catálogo >
invNorm(Área[,m[,s]])
Calcula la función de distribución acumulada normal inversa de un

Área dada bajo la curva de distribución normal especificada por m y
s.
invt()
Catálogo >
invt(Área,gl)
Calcula la función de probabilidad acumulada inversa de t de Student

especificada por el grado de libertad, gl, de un Área dada bajo la
curva.
iPart()
Catálogo >
iPart(Número) ⇒ entero
iPart(Lista1) ⇒ lista
iPart(Matriz1) ⇒ matriz
Devuelve la parte entera de un argumento.

Para las listas y las matrices, devuelve la parte entera de cada
elemento.
irr()
Catálogo >
irr(CF0,CFLista [,CFFrec]) ⇒ valor

Función financiera que calcula la tasa interna de retorno de una
inversión.
CF0 es el flujo de caja inicial en el tiempo 0; debe ser un número real.
CFLista es una lista de cantidades de flujo de caja tras el flujo de
caja inicial CF0.
CFFrec es una lista opcional en la que cada elemento especifica la
frecuencia de ocurrencia de una cantidad de flujo de caja agrupada
(consecutiva), que es el elemento correspondiente de CFLista. El
valor predeterminado es 1; si introduce valores, deberán ser números
enteros positivos < 10.000.
Nota: Consulte también mirr(), en la página 75.

isPrime()
Catálogo >
isPrime(Número) ⇒ Expresión booleana constante

Devuelve verdadero (true) o falso (false) para indicar si número es un
número entero ‚ 2 divisible sólo por sí mismo y por 1.
Si Número supera los 306 dígitos y no tiene factores {1021,

Función para hallar el siguiente primo tras un número
isPrime(Número) muestra un mensaje de error.
especificado:
Si sólo desea determinar si Número es primo, utilice isPrime() en
lugar de factor(). Es una opción mucho más rápida, especialmente si
Número no es primo y tiene un segundo factor más grande que
supera los cinco dígitos.
@
Enter (Intro).
isVoid()
Catálogo >
isVoid(Var) ⇒ Expresión booleana constante

isVoid(Expr) ⇒ Expresión booleana constante
isVoid(Lista) ⇒ lista de expresiones booleanas constantes
Devuelve verdadero o falso para indicar si el argumento es un tipo de

datos sin valor.
Para obtener más información sobre elementos sin valor, consulte la
página 160.
L
Lbl
Catálogo >
Lbl Nombreetiqueta
Define una etiqueta con el nombre Nombreetiqueta dentro de una

función.
Puede utilizar la instrucción Goto Nombreetiqueta para transferir el
control a la instrucción situada inmediatamente después de la
etiqueta.
Nombreetiqueta debe cumplir los mismos requisitos de nombre que
las variables:
@
Enter (Intro).

lcm()
Catálogo >
lcm(Número1, Número2) ⇒ expresión

lcm(Lista1, Lista2) ⇒ lista
lcm(Matriz1, Matriz2) ⇒ matriz
Devuelve el mínimo común múltiplo de los dos argumentos. El lcm de

dos fracciones es el lcm de sus numeradores dividido por el gcd de
sus denominadores. El lcm de números con decimal flotante es su
producto.
Para dos listas o dos matrices, devuelve el mínimo común múltiplo de
los elementos correspondientes.
left()
Catálogo >
left(Cadenaorigen[, Número]) ⇒ cadena

Devuelve el Número de caracteres situados a la izquierda y
contenidos en la cadena de caracteres Cadenaorigen.
Si se omite Número, devuelve todos los de Cadenaorigen.
left(Lista1[, Número]) ⇒ lista
Devuelve el Número de caracteres situados a la izquierda y
contenidos en Lista1*.
Si se omite Número, devuelve todos los de Lista1.
left(Comparación) ⇒ expresión
Devuelve el miembro de la zquierda de una ecuación o una
desigualdad.
libShortcut()
Catálogo >
libShortcut(CadenaNombreBiblioteca, En este ejemplo se supone la existencia de un documento de

CadenaNombreAccesoDirecto biblioteca llamado linalg2 almacenado y actualizado
[, EtiquetaBibliotecaPriv]) ⇒ lista de variables correctamente y que contiene objetos definidos como clearmat,
gauss1 y gauss2.
Crea un grupo de variables en el problema actual que contiene
referencias a todos los objetos del documento de biblioteca
CadenaNombreBiblioteca especificado. También añade los
miembros del grupo al menú Variables. Luego podrá hacer referencia
a cada objeto utilizando su CadenaNombreAccesoDirecto.
Defina EtiquetaBibliotecaPriv=0 para excluir objetos de biblioteca
privada (valor predeterminado)
Defina EtiquetaBiblioteca=1 para incluir objetos de biblioteca
privada.
Para copiar un grupo de variables, consulte CopyVar, en la
página 21.
Para borrar un grupo de variables, consulte DelVar, en la página 35.

limit() o lim()
Catálogo >
limit(Expr1, Var, Punto [,Dirección]) ⇒ expresión

limit(Lista1, Var, Punto [, Dirección]) ⇒ lista
limit(Matriz1, Var, Punto [, Dirección]) ⇒ matriz
Devuelve el límite solicitado.

Nota: Consulte también Plantilla de límite, en la página 6.
Dirección: negativa = por la izquierda, positiva = por la derecha, en

caso contrario = ambas. (Si se omite, el valor predeterminado para
Dirección es ambas.)
Los límites hacia ˆ positivo y hacia ˆ negativo se convierten siempre

en el límite lateral del lado correspondiente.
Dependiendo de las circunstancias, limit() se devuelve a sí mismo o
“sin definir” cuando no es posible determinar un límite único. Esto no
significa necesariamente que no exista un límite único. Sin definir
significa que el resultado es tanto un número desconocido, con una
magnitud finita o infinita, como el conjunto completo de esos mismos
números.
limit() utiliza métodos como la regla de L'Hôpital para obtener el
límite en el caso de indeterminación. Si Expr1 contiene otras
variables sin definir que no sean Var, puede que deba restringirlas
para obtener resultados más concisos.
Los límites pueden ser muy sensibles a errores de redondeo. En la
medida de lo posible, evite el uso del ajuste Aproximado del modo
Auto o Aproximado y aproxime los números cuando calcule los
límites. De lo contrario, es probable que los límites que deban tener
una magnitud cero o infinito no presenten estos resultados, y los
límites que deban tener una magnitud no cero o finita tampoco los
cumplan.
LinRegBx
Catálogo >
LinRegBx X,Y[,[Frec][,Categoría,Incluir]]
Calcula la regresión lineal y = a+b·x de las listas X e Y con una
Todas las listas, salvo Incluir, han de tener la misma dimensión.
ser enteros | 0.
160.

salida
stat.RegEqn Ecuación de regresión: a+b·x
stat.r2 Coeficiente de determinación
stat.r Coeficiente de correlación
restricciones de Frec, Lista Categoría e Incluir Categorías
LinRegMx
Catálogo >
LinRegMx X,Y[,[Frec][,Categoría,Incluir]]
Calcula la regresión lineal y = m·x+b para las listas X e Y con una

ser enteros | 0.
correspondientes datos de X e Y..
160.
salida
stat.RegEqn Ecuación de regresión: m·x+b
stat.m, stat.b Coeficientes de regresión

salida
LinRegtIntervals
Catálogo >
LinRegtIntervals X,Y[,F[,0[,NivelC]]]
Para la pendiente. Calcula el intervalo de confianza de nivel C para la

pendiente.
LinRegtIntervals X,Y[,F[,1,Xval[,NivelC]]]
Para la respuesta. Calcula el valor de Y previsto, un intervalo de

predicción de nivel C para una única observación y un intervalo de
confianza de nivel C para la respuesta media.
Todas las listas deben tener las mismas dimensiones.
F es una lista opcional de valores de frecuencia. Cada elemento de F
es la frecuencia de ocurrencia de cada punto de datos en X e Y. El
valor predeterminado es 1. Todos los elementos deben ser números
enteros | 0.
Para obtener información sobre el efecto de los elementos vacíos en
una lista, consulte “Elementos vacíos (sin valor)” en la página 160.
salida
stat.RegEqn Ecuación de regresión: a+b·x
stat.df Grados de libertad
Sólo para tipo de pendiente
salida
[stat.CLower, Intervalo de confianza para la pendiente.

stat.CUpper]
stat.ME Margen de error del intervalo de confianza
stat.SESlope Error estándar de la pendiente
stat.s Error estándar para la recta

Sólo para el tipo de respuesta
salida
[stat.CLower, Intervalo de confianza para la respuesta media

stat.CUpper]
stat.SE Error estándar de la respuesta media
[stat.LowerPred, Intervalo de predicción para una única observación

stat.UpperPred]
stat.MEPred Margen de error del intervalo de predicción
stat.SEPred Error estándar para la predicción
stat.y a + b·XVal
LinRegTTest (Test t de regresión lineal)

Catálogo >
LinRegtTest X,Y[,Frec[,Hipótesis]]
Calcula una regresión lineal en las listas X e Y junto con un test t para
el valor de la pendiente b y el coeficiente de correlación r para la
ecuación y=a+bx. Prueba la hipótesis nula H0:b=0 (equivalencia,
r=0) frente a una de las tres alternativas siguientes.
Todas las listas deben tener la misma dimensión.
ser enteros | 0.
Hipótesis es un valor opcional que especifica una de las tres hipótesis
alternativas frente a las que se va a probar la hipótesis nula
(H0:b=r=0).
Para Ha: bƒ0 y rƒ0 (predeterminado), defina Hipótesis=0

Para Ha: b<0 y r<0, defina Hipótesis<0
Para Ha: b>0 y r>0, defina Hipótesis>0

160.
salida
stat.RegEqn Ecuación de regresión: a + b·x
stat.t t Test estadístico para significancia

salida
stat.s Error estándar para la recta
stat.SESlope Error estándar de la pendiente
linSolve()
Catálogo >
linSolve( SistemaEcuaLineales, Var1, Var2, ...) ⇒ lista

linSolve(EcuaLineal1 and EcuaLineal2 and ...,
Var1, Var2, ...) ⇒ lista
linSolve({EcuaLineal1, EcuaLineal2, ...}, Var1, Var2, ...)
⇒ lista
linSolve(SistemaEcuaLineales, {Var1, Var2, ...})
⇒ lista
linSolve(EcuaLineal1 and EcuaLineal2 and ...,
{Var1, Var2, ...}) ⇒ lista
linSolve({EcuaLineal1, EcuaLineal2, ...}, {Var1, Var2, ...})
⇒ lista
Devuelve una lista de soluciones para las variables Var1, Var2, ...
El primer argumento se debe calcular en un sistema de ecuaciones
lineales o en una única ecuación lineal. De lo contrario, se generará
un error en el argumento.
Por ejemplo, al calcular linSolve(x=1 y x=2,x) se genera un
resultado “Error en el argumento”.
@List() Catálogo >
@List(Lista1) ⇒ lista
escriba deltaList(...).
Devuelve una lista que contiene las diferencias entre elementos
consecutivos de Lista1. Cada elemento de Lista1 se resta del
siguiente elemento de Lista1. La lista resultante tiene siempre un
elemento menos que la Lista1 original.
list4mat()
Catálogo >
list4mat( Lista [, elementosPorFila]) ⇒ matriz

Devuelve una matriz rellena fila a fila con los elementos de Lista.
elementosPorFila, si se incluye, especifica el número de elementos
por fila. El valor predeterminado es el número de elementos de Lista
(una fila).
Si Lista no rellena la matriz resultante se añaden ceros.
escriba list@>mat(...).

4ln Catálogo >
Expr 4ln ⇒ expresión

Hace que Expr se convierta en una expresión que contiene sólo
logaritmos naturales (ln).
escriba @>ln.
ln() Teclas /u
ln(Expr1) ⇒ expresión
ln(Lista1) ⇒ lista
Devuelve el logaritmo natural del argumento.
Si el modo de formato complejo es Real:
Para una lista, devuelve los logaritmos naturales de los elementos.
Si el modo de formato complejo es Rectangular:
ln(Matrizcuadrada1) ⇒ Matrizcuadrada En el modo de ángulo en radianes y formato complejo

rectangular:
Devuelve el logaritmo natural de la matriz Matrizcuadrada1. El
resultado no es igual que calcular el logaritmo natural de cada
consulte cos().

mover el cursor.
LnReg
Catálogo >
LnReg X, Y[, [Frec] [, Categoría, Incluir]]
Calcula la regresión logarítmica y = a+b·ln(x) de las listas X e Y con

una frecuencia Frec. El resumen de los resultados se guarda en la
variable stat.results. (Consulte la página 116).
ser enteros | 0.
160.

salida
stat.RegEqn Ecuación de regresión: a+b·ln(x)
stat.r2 Coeficiente de determinación lineal para los datos transformados
stat.r Coeficiente de correlación para los datos transformados (ln(x), y)
stat.Resid Residuos asociados al modelo logarítmico
Local
Catálogo >
Local Var1[, Var2] [, Var3] ...
Declara las vars especificadas como variables locales. Las variables

sólo están presentes durante el cálculo de la función y se borran
cuando finaliza la ejecución de la misma.
Nota: Las variables locales permiten ahorrar memoria puesto que su
existencia es sólo temporal. Además, no interfieren con los valores de
ninguna variable global existente. Las variables locales deben
utilizarse para bucles For y para guardar temporalmente los valores
de una función de varias líneas, ya que no está permitido modificar
variables globales de una función.
@
Enter (Intro).
Lock
Catálogo >
Lock Var1[, Var2] [, Var3] ...

Lock Var.
Bloquea las variables o el grupo de variables especificado. Las

variables bloqueadas no se pueden borrar ni modificar.
No es posible bloquear o desbloquear la variable del sistema Ans, ni
bloquear los grupos de variables del sistema stat. o tvm.
Nota: La orden Bloquear (Lock) limpia el historial de Deshacer/
Rehacer cuando se aplica a variables no bloqueadas.
Consulte unLock, en la página 131, y getLockInfo(), en la página 53.

log() Teclas /s
log(Expr1[,Expr2]) ⇒ expresión
log(Lista1[,Expr2]) ⇒ lista
Devuelve el logaritmo base -Expr2 del primer argumento.

Nota: Consulte también Plantilla de registro, en la página 2.
Para una lista, devuelve el logaritmo base -Expr2 de los elementos.

Si se omite el segundo argumento, la base utilizada será 10.
Si el modo de formato complejo es Real:
Si el modo de formato complejo es Rectangular:
log(Matrizcuadrada1[,Expr]) ⇒ Matrizcuadrada En el modo de ángulo en radianes y formato complejo

rectangular:
Devuelve el logaritmo base Expr de la matriz Matrizcuadrada1. El
resultado no es igual que calcular el logaritmo base -Expr de cada
consulte cos().
Si se omite el argumento base, la utilizada será 10.

mover el cursor.
4logbase Catálogo >
Expr 4logbase(Expr1) ⇒ expresión

Simplifica la Expresión de entrada a una expresión que utiliza base
Expr1.
escriba @>logbase(...).

Logistic
Catálogo >
Logistic X, Y[, [Frec] [, Categoría, Incluir]]
Calcula la regresión logística y = (c/(1+a·e-bx)) de las listas X e Y

con una frecuencia Frec. El resumen de los resultados se guarda en la
ser enteros | 0.
160.
salida
stat.RegEqn Ecuación de regresión: c/(1+a·e-bx)
stat.a, stat.b, stat.c Coeficientes de regresión

LogisticD
Catálogo >
LogisticD X, Y [ , [Iteraciones] , [Frec] [, Categoría, Incluir] ]
Calcula la regresión logística y = (c/(1+a·e-bx)+d) de las listas X e Y

con una frecuencia Frec, utilizando un número de Iteraciones
especificado. El resumen de los resultados se guarda en la variable
Iteraciones es un valor opcional que especifica el número máximo de
veces que se debe intentar la solución. Si se omite, se utiliza 64. Por
lo general, los valores más grandes ofrecen más precisión aunque
requieren más tiempo de ejecución, y viceversa.
ser enteros | 0.
160.
salida
stat.RegEqn Ecuación de regresión: c/(1+a·e-bx)+d)

stat.d
stat.YReg Lista de puntos de datos en la Lista Y modificada utilizada realmente en la regresión basada en

Loop
Catálogo >
Loop
Bloque
EndLoop
Ejecuta repetidamente las sentencias de Bloque. El bucle se repetirá
indefinidamente a menos que haya incluido una instrucción Goto o
Exit para que se ejecute en el Bloque.
Bloque es una serie de sentencias separadas por el carácter “:”.

Enter (Intro).
LU
Catálogo >
LU Matriz, Matrizb, Matriza, Matrizp[,Tol]
Calcula la descomposición LU (inferior-superior) Doolittle de una

matriz real o compleja. La matriz triangular inferior se guarda en
Matrizb, la matriz triangular superior en Matriza y la matriz de
permutación (que describe las filas intercambiadas durante el cálculo)
en Matrizp.
Matrizb · Matriza = Matrizp · matriz
Opcionalmente, cualquier elemento de matriz se trata como cero si su
valor absoluto es menor que el de Tol. Esta tolerancia se utiliza sólo si
la matriz tiene entradas de coma flotante y no contiene ninguna
variable simbólica que no tenga asignado un valor. De lo contrario se
ignorará el valor de Tol.
• /·
Si utiliza o define el modo Auto o Aproximado
• Si el valor de Tol se omite o no se utiliza, la tolerancia
predeterminada se calculará como:
5EM14 ·max(dim(Matriz)) ·rowNorm(Matriz)
El algoritmo de factorización LU se vale de un sistema de giro parcial
para el intercambio de las filas.

M
mat4list() Catálogo >
mat4list(Matriz) ⇒ lista
Devuelve una matriz construida a partir de los elementos de Matriz.
Los elementos proceden de Matriz y se han copiado fila a fila.
escriba mat@>list(...).
max()
Catálogo >
max(Expr1, Expr2) ⇒ expresión

max(Lista1, Lista2) ⇒ lista
max(Matriz1, Matriz2) ⇒ matriz
Devuelve el máximo de los dos argumentos. Si los argumentos son

dos listas o dos matrices, devuelve una lista o una matriz que
contiene el valor máximo de cada par de elementos correspondientes.
max(Lista) ⇒ expresión
Devuelve el elemento máximo de lista.
max(Matriz1) ⇒ matriz
Devuelve un vector fila que contiene el elemento máximo de cada
columna de Matriz1.
Nota: Consulte también fMax() y min().
mean()
Catálogo >
mean(Lista[, Listafrecuencia]) ⇒ expresión

Devuelve la media de los elementos de Lista.
Cada elemento de Listafrecuencia cuenta el número de ocurrencias
consecutivas del elemento correspondiente en Lista.
mean(Matriz1[, Matrizfrecuencia]) ⇒ matriz En el formato de vector rectangualr:
Devuelve un vector fila de las medias de todas las columnas de

Matriz1.
Cada elemento de Matrizfrecuencia cuenta el número de
ocurrencias consecutivas del elemento correspondiente en Matriz1.

median()
Catálogo >
median(Lista[, Listafrecuencia]) ⇒ expresión

Devuelve la mediana de los elementos de Lista.
median(Matriz1[, Matrizfrecuencia]) ⇒ matriz
Devuelve un vector de fila que contiene las medianas de las columnas
de Matriz1.
Notas:
• Es necesario simplificar a números todas las entradas de la lista o

la matriz.
• Se desestiman los elementos vacíos (sin valor) de la lista o la
matriz. Para obtener más información sobre los elementos
MedMed
Catálogo >
MedMed X,Y [, Frec] [, Categoría, Incluir]]
Calcula la recta mediana-mediana y = (m·x+b) de las listas X e Y

con una frecuencia Frec. El resumen de los resultados se guarda en la
ser enteros | 0.
160.
salida
stat.RegEqn Ecuación de la recta mediana-mediana: m·x+b
stat.m, stat.b Coeficientes de modelo
stat.Resid Residuos de la recta mediana-mediana

mid()
Catálogo >
mid(Cadenaorigen, Inicio[, Cont]) ⇒ cadena

Devuelve los caracteres Cont incluidos en la cadena Cadenaorigen,
a partir del número de carácter de Inicio.
Si Cont se omite o es mayor que la dimensión de Cadenaorigen,
devuelve todos los caracteres de Cadenaorigen, a partir del número
de carácter de Inicio.
Cont debe ser ‚ 0. Si Cont = 0, devuelve una cadena vacía.
mid(Listaorigen, Inicio [, Cont]) ⇒ lista
Devuelve Cont de los elementos incluidos en Listaorigen, a partir del
número de elemento de Inicio.
Si Cont se omite o es mayor que la dimensión de Listaorigen,
devuelve todos los elementos de Lista origen, a partir del número de
elemento de Inicio.
Cont debe ser ‚ 0. Si Cont = 0, devuelve una lista vacía.
mid(ListaCadenaorigen, Inicio[, Cont]) ⇒ lista
Devuelve Cont de las cadenas incluidas en la lista de cadenas
ListaCadenaorigen, a partir del número de elemento de Inicio.
min()
Catálogo >
min(Expr1, Expr2) ⇒ expresión

min(Lista1, Lista2) ⇒ lista
min(Matriz1, Matriz2) ⇒ matriz
Devuelve el mínimo de los dos argumentos. Si los argumentos son

dos listas o dos matrices, devuelve una lista o una matriz que
contiene el valor mínimo de cada par de elementos correspondientes.
min(Lista) ⇒ expresión
Devuelve el elemento mínimo de Lista.
min(Matriz1) ⇒ matriz
Devuelve un vector fila que contiene el elemento mínimo de cada
columna de Matriz1.
Nota: Consulte también fMin() y max().
mirr()
Catálogo >
mirr(TasaFinan,TasaReinver,CF0,CFLista[,CFFrec])
Función financiera que calcula la tasa interna modificada o de retorno

de una inversión.
TasaFinan es la tasa de interés que se paga sobre las cantidades del
flujo de caja.
TasaReinver es la tasa de interés a la que se reinvierten los flujos de
caja.
CFLista es una lista de cantidades de flujo de caja tras el flujo de
caja inicial CF0.
Nota: Consulte también irr(), en la página59.

mod()
Catálogo >
mod(Expr1, Expr2) ⇒ expresión

mod(Lista1, Lista2) ⇒ lista
mod(Matriz1, Matriz2) ⇒ matriz
Devuelve el primer argumento módulo del segundo argumento según

estas definiciones:
mod(x,0) = x
mod(x,y) = x - y floor(x/y)
Cuando el segundo argumento es distinto de cero, el resultado es
periódico en dicho argumento. El resultado puede ser cero o tener el
mismo signo que el segundo argumento.
Si los argumentos son dos listas o dos matrices, devuelve una lista o
una matriz que contiene el módulo de cada par de elementos
correspondientes.
Nota: Consulte también remain(), en la página 99
mRow()
Catálogo >
mRow(Expr, Matriz1, Índice) ⇒ matriz

Devuelve una copia de Matriz1 con cada elemento de la fila Índice
de Matriz1 multiplicado por el valor de Expr.
mRowAdd()
Catálogo >
mRowAdd(Expr, Matriz1, Índice1, Índice2) ⇒ matriz

Devuelve una copia de Matriz1 con cada elemento de la fila Índice2
de Matriz1 sustituido por:
Expr · fila Índice1 + fila Índice2
MultReg
Catálogo >
MultReg Y, X1[,X2[,X3,…[,X10]]]
Calcula la regresión lineal múltiple de la lista Y en las listas X1, X2,
…, X10. El resumen de los resultados se guarda en la variable
160.
salida
stat.RegEqn Ecuación de regresión: b0+b1·x1+b2·x2+ ...
stat.b0, stat.b1, ... Coeficientes de regresión
stat.R2 Coeficiente de determinación múltiple
y
stat. Lista yLista = b0+b1·x1+ ...

MultRegIntervals
Catálogo >
MultRegIntervals Y, X1[,X2[,X3,…[,X10]]],XValLista[,NivelC]
Calcula el valor de y que se prevé, un intervalo de predicción de nivel

C para una única observación y un intervalo de confianza de nivel C
para la respuesta media.
160.
salida
y
stat. Punto estimado: y = b0 + b1 · xl + ... para XValLista
stat.CLower, stat.CUpper Intervalo de confianza para una respuesta media
stat.SE Error estándar de la respuesta media
stat.LowerPred, Intervalo de predicción para una única observación

stat.UpperrPred
stat.MEPred Margen de error del intervalo de predicción
stat.SEPred Error estándar para la predicción
stat.bList Lista de coeficientes de regresión, {b0,b1,b2,...}
MultRegTests
Catálogo >
MultRegTests Y, X1[,X2[,X3,…[,X10]]]
Test de regresión lineal múltiple, calcula una regresión lineal múltiple

de los datos dados y proporciona el test estadístico F general y el test
estadístico t para los coeficientes.
160.
Salidas
salida
stat.F Test estadístico F general

salida
stat.PVal Valor P asociado con el test estadístico F general
stat.R2 Coeficiente de determinación múltiple
stat.AdjR2 Coeficiente de determinación múltiple ajustado
stat.s Desviación estándar del error
stat.DW Estadística de Durbin-Watson; utilizada para determinar si en el modelo está presente la correlación
automática de primer orden
stat.dfReg Grados de libertad de la regresión
stat.SSReg Suma de cuadrados de la regresión
stat.MSReg Media de cuadrados de la regresión
stat.bList {b0,b1,...} Lista de coeficientes
stat.tList Lista de los estadísticos t, uno por cada coeficiente de la ListaB
stat.PList Lista de valores P para cada estadístico t
stat.SEList Lista de errores estándar para los coeficientes de la ListaB
y
stat. Lista yLista = b0+b1·x1+ . . .
stat.sResid Residuos estandarizados; obtenidos al dividir un residuo por su desviación estándar
stat.CookDist Distancia de Cook; medida de la influencia de una observación basada en el valor residual y medio
stat.Leverage Medida de la distancia entre los valores de la variable independiente y los valores medios
N
nCr()
Catálogo >
nCr(Expr1, Expr2) ⇒ expresión

Para Expr1 y Expr2 enteros con Expr1 ‚ Expr2 ‚ 0, nCr() es el
número de combinaciones de elementos de Expr1 tomando Expr2
cada vez. (También se conoce como coeficiente binomial). Ambos
argumentos pueden ser expresiones enteras o simbólicas.
nCr(Expr, 0) ⇒ 1
nCr(Expr, EnteroNeg) ⇒ 0
nCr(Expr, EnteroPos) ⇒ Expr·(ExprN1)...
(ExprNEnteroPos+1)/ EnteroPos!
nCr(Expr, NoEntero) ⇒ expresión!/
((ExprNNoEntero)!·NoEntero!)

nCr()
Catálogo >
nCr(Lista1, Lista2) ⇒ lista

Devuelve una lista de combinaciones basada en los pares de
elementos correspondientes de las dos listas. Los argumentos deben
tener el mismo tamaño que la lista.
nCr(Matriz1, Matriz2) ⇒ matriz
Devuelve una matriz de combinaciones basada en los pares de
elementos correspondientes de las dos matrices. Los argumentos
deben tener el mismo tamaño que la matriz.
nDerivative()
Catálogo >
nDerivative(Expr1,Var=Valor[,Orden]) ⇒ valor
nDerivative(Expr1,Var [,Orden]) | Var=Valor ⇒ valor
Devuelve la derivada numérica calculada utilizando métodos de

diferenciación automática.
variable anterior o cualquier sustitución "with" actual de la variable.
El orden de la derivada debe ser 1 o 2.
newList()
Catálogo >
newList(númElementos) ⇒ lista
Devuelve una lista con la dimensión númElementos. Cada elemento
es cero.
newMat()
Catálogo >
newMat(númeroFilas, númeroColumnas) ⇒ matriz

Devuelve la matriz de ceros de dimensión númeroFilas por
númeroColumnas.
nfMax()
Catálogo >
nfMax(Expr, Var) ⇒ valor

nfMax(Expr, Var, Extremoinferior) ⇒ valor
nfMax(Expr, Var, Extremoinferior, Extremosuperior) ⇒ valor
nfMax(Expr, Var) |
Extremoinferior<Var<Extremosuperior ⇒ valor
Devuelve el posible valor numérico de la variable Var donde se
produce el máximo local de Expr.
Si se facilitan los valores de Extremoinferior y Extremosuperior, la
función busca el máximo local entre dichos valores.
Nota: Consulte también fMax() y d().

nfMin()
Catálogo >
nfMin(Expr, Var) ⇒ valor

nfMin(Expr, Var, Extremoinferior) ⇒ valor
nfMin(Expr, Var, Extremoinferior, Extremosuperior) ⇒ valor
nfMin(Expr, Var) |
Extremoinferior<Var<Extremosuperior ⇒ valor
Devuelve el posible valor numérico de la variable Var donde se
produce el mínimo local de Expr.
Si se facilitan los valores de Extremoinferior y Extremosuperior, la
función busca el mínimo local entre dichos valores.
Nota: Consulte también fMin() y d().
nInt()
Catálogo >
nInt(Expr1, Var, Inferior, Superior) ⇒ expresión

Si el integrando Expr1 no contiene otra variable que Var, y si los
valores Inferior y Superior son constantes, ˆ positivo o ˆ negativo,
entonces nInt() devuelve una aproximación de ‰(Expr1, Var,
Inferior, Superior). Esta aproximación es una media ponderada de
algunos valores de ejemplo del integrando en el intervalo
Inferior<Var<Superior.
El objetivo es conseguir seis dígitos significativos. El algoritmo de
búsqueda termina cuando parece que se ha logrado el objetivo, o
cuando parece que ningún otro ejemplo adicional ofrecerá una
mejoría satisfactoria.
La pantalla muestra una advertencia (“Exactitud dudosa”) cuando no
parece que vaya a alcanzarse el objetivo.
Anide la función nInt() para realizar varias integraciones numéricas.

Los límites de la integración pueden depender de las variables de
integración que quedan fuera de las mismas.
Nota: Consulte también ‰(), en la página 149.
nom()
Catálogo >
nom(TasaEfectiva,CpY) ⇒ valor
Función financiera que convierte la tasa de interés anual efectiva
TasaEfectiva en una tasa nominal, siendo CpY el número de
periodos compuestos por año.
TasaEfectiva debe ser un número real; CpY debe ser un número real
> 0.
Nota: Consulte también eff(), en la página 40.

norm()
Catálogo >
norm(Matriz) ⇒ expresión
norm(Vector) ⇒ expresión
Devuelve la norma de Frobenius.
normalLine()
Catálogo >
normalLine(Expr1,Var,Punto) ⇒ expresión
normalLine(Expr1,Var=Punto) ⇒ expresión
Devuelve la recta normal a la curva representada por Expr1 en el

punto especificado en Var=Punto.
Asegúrese de que la variable independiente no esté definida.
Por ejemplo, Si f1(x):=5 y x:=3, entonces normalLine(f1(x),x,2)
devuelve “falso”.
normCdf()
Catálogo >
normCdf(Extremoinferior,Extremosuperior[,m[,s]]) ⇒ númer
o si Extremoinferior y Extremosuperior son números, lista si
Calcula la probabilidad de distribución normal entre Extremoinferior
y Extremosuperior para los valores de m (predeterminado=0) y s
(predeterminado=1) especificados.
Para P(X  Extremosuperior), defina Extremoinferior = .ˆ.
normPdf()
Catálogo >
normPdf(XVal[,m[,s]]) ⇒ número si XVal es un número, lista

si XVal es una lista
Calcula la función de densidad de probabilidad para la distribución

normal para un valor XVal especificado para unos valores m y s
especificados.
not
Catálogo >
not ExprBooleana ⇒ Expresión booleana

Indica si el argumento es verdadero (true), falso (false) o muestra una
forma simplificada del mismo.

not
Catálogo >
not Entero1 ⇒ entero En modo base Hex:
Devuelve el complemento a uno para un número entero real. Importante: Cero, no la letra O.
Internamente, Entero1 se convierte en un número binario con signo
de 64 bits. El valor de cada bit se invierte (0 se convierte en 1, y
viceversa) por el complemento de uno. Los resultados se muestran
conforme al modo de la base.
Los números enteros se pueden introducir en cualquier base. Para una En modo base Bin:
entrada binaria o hexadecimal es necesario utilizar el prefijo 0b o 0h,
respectivamente. Si no se indica un prefijo, el entero se considera
como decimal (base 10).
£
Para ver todos los resultados, pulse ¡ ¢
y utilice y para
mover el cursor.
Nota: Una entrada binaria puede tener hasta 64 dígitos (sin
contar el prefijo 0b). Una entrada hexadecimal puede tener
hasta 16 dígitos.
nPr()
Catálogo >
nPr(Expr1, Expr2) ⇒ expresión

Para Expr1 y Expr2 enteros con Expr1 ‚ Expr2 ‚ 0, nPr() es el
número de variaciones de elementos de Expr1 tomando Expr2 cada
vez. Ambos argumentos pueden ser números enteros o expresiones
simbólicas.
nPr(Expr, 0) ⇒ 1
nPr(Expr, EnteroNeg) ⇒ 1/((Expr+1)·(Expr+2)...
(expresiónNEnteroNeg))
nPr(Expr, EnteroPos) ⇒ Expr·(ExprN1)...
(ExprNEnteroPos+1)
nPr(Expr, NoEntero) ⇒ Expr! / (ExprNNoEntero)!
nPr(Lista1, Lista2) ⇒ lista

Devuelve una lista de variaciones basada en los pares de elementos
correspondientes de las dos listas. Los argumentos deben tener el
mismo tamaño que la lista.
nPr(Matriz1, Matriz2) ⇒ matriz
Devuelve una lista de variaciones basada en los pares de elementos
correspondientes de las dos matrices. Los argumentos deben tener el
mismo tamaño que la matriz.

npv()
Catálogo >
npv(TasaInterés,CFO,CFList[,CFFrec])
Función financiera que calcula el valor presente neto; la suma de los

valores presentes para las entradas y salidas de flujos de caja. Un
resultado de npv positivo indica una inversión rentable.
TasaInterés es la tasa de descuento que se aplica a los flujos de caja
(coste del dinero) en un periodo de tiempo.
CFLista es una lista de cantidades de flujo de caja tras el flujo inicial
CF0.
nSolve()
Catálogo >
nSolve(Ecuación,Var[=Conjetura]) ⇒ número o error_cadena

nSolve(Ecuación,Var[=Conjetura],Extremoinferior)
⇒ número o error_cadena
nSolve(Ecuación,Var[=Conjetura],Extremoinferior,Extremosup
erior) ⇒ número o error_cadena
nSolve(Ecuación,Var[=Conjetura]) |
Extremoinferior<Var<Extremosuperior Nota: Si hay varias soluciones, puede utilizar una conjetura que
⇒ número o error_cadena le ayude a hallar una solución concreta.
Busca repetidamente una solución numérica real aproximada de
Ecuación para su única variable. Especifique la variable como:
variable
–o–
variable = número real
Por ejemplo, x es válido y también lo es x=3.
nSolve() suele ser más rápido que solve() o zeros(), en especial si se
utiliza el operador “|” para restringir la búsqueda a un intervalo
relativamente pequeño que contenga exactamente una solución
sencilla.
nSolve() intenta determinar un punto donde el residuo es cero, o dos
puntos relativamente cercanos donde el residuo tenga signos
opuestos y su diferencia no sea excesiva. Si no consigue alcanzar un
número modesto de puntos de ejemplo, devuelve la cadena “no
solution found (no se ha encontrado una solución”).
Nota: Consulte también cSolve(), cZeros(), solve() y zeros().

O
OneVar
Catálogo >
OneVar [1,]X[,[Frec][,Categoría,Incluir]]
OneVar [n,]X1,X2[X3[,…[,X20]]]
Calcula una estadística de una variable para un máximo de 20 listas.

(Consulte la página 116.)
Los argumentos de X son listas de datos.
de Frec especifica la ocurrencia de cada valor X correspondiente. El
valor predeterminado es 1. Todos los elementos deben ser enteros |
0.
Categoría es una lista de códigos numéricos de categoría para los
valores X correspondientes.
Categoría genera un dato sin valor para el elemento correspondiente
de todas las listas. Un elemento vacío en cualquiera de las listas
desde X1 hasta X20 genera un dato sin valor para el elemento
correspondiente de todas las listas. Para obtener más información
sobre los elementos vacíos, consulte la página 160.
salida
stat.v Media de los valores de x
stat.Gx Suma de los valores de x
2
stat.Gx Suma de los valores de x2
stat.sx Desviación estándar de la muestra x
sx
stat.s Desviación estándar de población x
stat.n Número de puntos de datos
stat.SSX Suma de cuadrados de desviaciones con respecto a la media de x

or
Catálogo >
ExprBooleana1 or ExprBooleana2
⇒ Expresión booleana
Indica si la entrada original es verdadera (true), falsa (false) o muestra
una forma simplificada de la misma.
Devuelve “verdadero” si una cualquiera o las dos expresiones se
evalúan como verdadero. Devuelve “falso” sólo si las dos expresiones
se evalúan como falso.
Nota: Consulte xor.

Enter (Intro).
Entero1 or Entero2 ⇒ entero En modo base Hex:

Compara bit a bit dos números enteros reales mediante una
operación or. Internamente, ambos enteros se convierten en números
binarios con signo de 64 bits. Cuando se comparan los bits Importante: Cero, no la letra O.
correspondientes, el resultado es 1 si cualquiera de ellos es 1; el
resultado será 0 sólo si los dos bits son 0. El valor obtenido representa En modo base Bin:
el resultado de los bits, y aparece conforme al modo base
especificado.
Los números enteros se pueden introducir en cualquier base. Para una
contar el prefijo 0b). Una entrada hexadecimal puede tener
entrada binaria o hexadecimal es necesario utilizar el prefijo 0b o 0h,
hasta 16 dígitos.
Nota: Consulte xor.
ord()
Catálogo >
ord(Cadena) ⇒ entero
ord(Lista1) ⇒ lista
Devuelve el código numérico del primer carácter de la cadena de

caracteres Cadena, o una lista de los primeros caracteres de cada
elemento de la lista.

P
P4Rx()
Catálogo >
P4Rx(rExpr, qExpr) ⇒ expresión En el modo de ángulo en radianes:

P4Rx(rLista, qLista) ⇒ lista
P4Rx(rMatriz, qMatriz) ⇒ matriz
Devuelve la coordenada X equivalente del par

(r, q).
Nota: El argumento q se interpreta como un ángulo en grados,

radianes o grados centesimales, según el modo de ángulo actual. Si el
argumento es una expresión, puede utilizar ó, G o ôpara sobrescribir
el modo de ángulo temporalmente.
escriba P@>Rx(...).
P4Ry()
Catálogo >
P4Ry(rExpr, qExpr) ⇒ expresión En el modo de ángulo en radianes:

P4Ry(rLista, qLista) ⇒ lista
P4Ry(rMatriz, qMatriz) ⇒ matriz
Devuelve la coordenada Y equivalente del par (r, q).
Nota: El argumento q se interpreta como un ángulo en grados,

radianes o grados centesimales, según el modo de ángulo actual. Si el
argumento es una expresión, puede utilizar ó, G o ôpara sobrescribir
el modo de ángulo temporalmente.
escriba P@>Ry(...).
PassErr
Catálogo >
PassErr Para ver un ejemplo de PassErr, consulte el Ejemplo 2 de la
orden Try, en la página 127.
Pasa un error al siguiente nivel.
Si la variable del sistema errCode es cero, PassErr no realiza acción
alguna.
La cláusula Else del bloque Try...Else...EndTry debería utilizar ClrErr
o PassErr. Si va a procesar o ignorar el error, utilice ClrErr. Si
desconoce el tratamiento que se va a dar al error, utilice PassErr para
enviarlo al siguiente gestor de errores. Si no hay más gestores de
errores de tipo Try...Else...EndTry, el cuadro de diálogo de errores
aparecerá en su forma normal.
Nota: Consulte también ClrErr, en la página 19, y Try, en la página
126.
Enter (Intro).

piecewise()
Catálogo >
piecewise(Expr1 [, Cond1 [, Expr2 [, Cond2 [, … ]]]])
Devuelve definiciones para una función definida a trozos en forma de

lista. También puede crear definiciones de funciones definidas a
trozos con una plantilla.
Nota: Consulte también Plantilla para funciones definidas a
trozos, en la página 2.
poissCdf()
Catálogo >
poissCdf(l,Extremoinferior,Extremosuperior) ⇒ número si
poissCdf(l,Extremosuperior) (para
P(0XExtremosuperior) ⇒ número si Extremosuperior es un
número, lista si Extremosuperior es una lista
Calcula la probabilidad acumulada para la distribución de Poisson

discreta con la media especificada l.
Para P(X  Extremosuperior), defina Extremoinferior=0
poissPdf()
Catálogo >
poissPdf(l,XVal) ⇒ número si XVal es un número, lista si

XVal es una lista
Calcula la probabilidad para la distribución de Poisson discreta con la
media especificada l.
4Polar Catálogo >
Vector 4Polar
escriba @>Polar.
Muestra el vector en formato polar [r q]. El vector debe ser
bidimensional y ser fila o columna.
Nota: 4Polar es una orden para un formato de presentación, no una
función de conversión. Se puede utilizar sólo al final de una línea de
entrada y no actualiza el valor de ans.
Nota: Consulte también 4Rect, en la página 97.
complexValue 4Polar En el modo de ángulo en radianes:
Muestra complexVector en formato polar.

• El modo de ángulo en grados devuelve (rq).
• El modo de ángulo en radianes devuelve reiq.
complexValue puede tener cualquier formato complejo. Sin embargo,
una entrada reiq generará un error si el modo de ángulo es grados.
Nota: Debe utilizar paréntesis para una entrada polar (rq).
En el modo de ángulo en grados:

polyCoeffs()
Catálogo >
polyCoeffs(Poli [,Var]) ⇒ lista

Devuelve la lista de los coeficientes de un polinomio Poli con
respecto a la variable Var.
Poli debe ser una expresión polinómica en Var. Se recomienda no
omitir Var a menos que Poli sea una expresión en una variable
sencilla.
Desarrolle el polinomio y seleccione x para la Var omitida.
polyDegree()
Catálogo >
polyDegree(Poli [,Var]) ⇒ valor

Devuelve el grado de la expresión polinómica Poli con respecto a la
variable Var. Si omite Var, la función polyDegree() seleccionará un
valor predeterminado de entre las variables contenidas en el
polinomio Poli. Constantes polinómicas
Poli debe ser una expresión polinómica en Var. Se recomienda no

omitir Var a menos que Poli sea una expresión en una variable
sencilla.
Es posible extraer el grado aunque no se puedan extraer los

coeficientes. El motivo es que el grado se puede extraer sin
desarrollar el polinomio.
polyEval()
Catálogo >
polyEval(Lista1, Expr1) ⇒ expresión

polyEval(Lista1, Lista2) ⇒ expresión
Interpreta el primer argumento como los coeficientes de un polinomio
de grado descendente y devuelve el valor numérico del polinomio
calculado para el segundo argumento.

polyGcd()
Catálogo >
polyGcd(Expr1,Expr2) ⇒ expresión
Devuelve el máximo común divisor de los dos argumentos.
Expr1 y Expr2 deben ser expresiones polinómicas.
No se admiten listas, matrices ni argumentos booleanos.
polyQuotient()
Catálogo >
polyQuotient(Poli1,Poli2 [,Var]) ⇒ expresión

Devuelve el cociente del polinomio Poli1 dividido por el polinomio
Poli2 con respecto a la variable especificada Var.
Poli1 y Poli2 deben ser expresiones polinómicas en Var. Se
recomienda no omitir Var a menos que Poli1 y Poli2 sean
expresiones de la misma variable sencilla.
polyRemainder()
Catálogo >
polyRemainder(Poli1,Poli2 [,Var]) ⇒ expresión

Devuelve el resto del polinomio Poli1 dividido por el polinomio Poli2
con respecto a la variable especificada Var.
Poli1 y Poli2 deben ser expresiones polinómicas en Var. Se
recomienda no omitir Var a menos que Poli1 y Poli2 sean
expresiones de la misma variable sencilla.

polyRoots()
Catálogo >
polyRoots(Poli,Var)⇒ lista
polyRoots(ListaDeCoef) ⇒ lista
La primera sintaxis, polyRoots(Poli,Var), devuelve una lista de las

raíces reales de un polinomio Poli con respecto a la variable Var. Si
no hay raíces reales, devuelve una lista vacía: { }.
Poli debe ser un polinomio en una variable.
La segunda sintaxis, polyRoots(ListaDeCoef), devuelve una lista
de raíces reales para los coeficientes de ListaDeCoef.
Nota: Consulte también cPolyRoots(), en la página 26.
PowerReg
Catálogo >
PowerReg X,Y [, Frec] [, Categoría, Incluir]]
Calcula la regresión potencial y = (a·(x)b) de las listas X e Y con

una frecuencia Frec. El resumen de los resultados se guarda en la
ser enteros | 0.
160.
salida
stat.RegEqn Ecuación de regresión: a·(x)b
2
stat.r Coeficiente de determinación lineal para los datos transformados
stat.r Coeficiente de correlación para los datos transformados (ln(x), ln(y))
stat.Resid Residuos asociados con el modelo potencial

Prgm
Catálogo >
Prgm Calcular el valor de GCD y mostrar resultados intermedios.
Bloque
EndPrgm
Plantilla para crear una programa definido por el usuario. Debe
utilizarse junto con la orden Define, Define LibPub o Define LibPriv.
Bloque puede ser una sentencia sencilla, una serie de sentencias
separadas por el carácter “:”, o una serie de sentencias escritas en
varias líneas.
@
Enter (Intro).
prodSeq() Consulte Π( ), en la página 151.
Product (PI) Consulte Π( ), en la página 151.
product()
Catálogo >
product(Lista[, Inicio[, Fin]]) ⇒ expresión

Devuelve el producto de los elementos contenidos en Lista. Inicio y
Fin son opcionales. Permiten especificar un rango de elementos.
product(Matriz1[, Inicio[, Final]]) ⇒ matriz

Devuelve un vector fila que contiene los productos de los elementos
de las columnas de Matriz1. Inicio y Fin son opcionales. Permiten
especificar un rango de elementos.

propFrac()
Catálogo >
propFrac(Expr1[, Var]) ⇒ expresión

propFrac(número_racional) devuelve número_racional como la
suma de un entero y una fracción que tienen el mismo signo y un
denominador mayor que el numerador.
propFrac(expresión_racional,Var) devuelve la suma de las

fracciones propias y un polinomio con respecto a Var. El grado de Var
del denominador supera el grado de Var del numerador en cada
fracción propia. Se agrupan potencias similares de Var. Los términos
y sus factores se ordenan con Var como variable principal.
Si se omite Var, se efectúa un desarrollo en fracciones propias con
respecto a la variable más relevante. Los coeficientes de la parte
polinómica se corrigen con respecto a su primera variable más
importante y, así, sucesivamente.
Para expresiones racionales, propFrac() es más rápido pero ofrece
una alternativa más reducida que expand().
Puede utilizar la función propFrac() para representar fracciones
mixtas y demostrar sumas y restas de fracciones mixtas.
Q
QR
Catálogo >
QR Matriz, qMatriz, rMatriz[, Tol] El número de coma flotante (9.) en m1 hace que los resultados
se calculen en formato de coma flotante.
Calcula la factorización QR de Householder de una matriz real o
compleja. Las matrices resultantes Q y R se almacenan con los
Matrices especificados. La matriz Q es unitaria. La matriz R es una
matriz triangular superior.
su valor absoluto es menor que el de Tol. Esta tolerancia se utiliza
contrario se ignorará el valor de Tol.
• /·
5Eë14 ·max(dim(Matriz)) ·rowNorm(Matriz)

QR
Catálogo >
La factorización QR se calcula numéricamente mediante el uso de

transformaciones de Householder. La solución simbólica se calcula
mediante un proceso de Gram-Schmidt. Las columnas de
NombreMatq son los vectores de base ortonormal que definen el
espacio dado por matriz.
QuadReg
Catálogo >
QuadReg X,Y [, Frec] [, Categoría, Incluir]]
Calcula la regresión polinómica cuadrática y = a·x2+b·x+c de las

listas X e Y con una frecuencia Frec. El resumen de los resultados se
ser enteros | 0.
160.
salida
stat.RegEqn Ecuación de regresión: a·x2+b·x+c
stat.a, stat.b, stat.c Coeficientes de regresión

QuartReg
Catálogo >
QuartReg X,Y [, Frec] [, Categoría, Incluir]]
Calcula la regresión polinómica cuártica

y = a·x4+b·x3+c· x2+d·x+e de las listas X e Y para una
ser enteros | 0.
160.
salida
stat.RegEqn Ecuación de regresión: a·x4+b·x3+c· x2+d·x+e

stat.d, stat.e

R
R4Pq()
Catálogo >
R4Pq (Exprx, Expry) ⇒ expresión En el modo de ángulo en grados:

R4Pq (Listax, Listay) ⇒ lista
R4Pq (Matrizx, Matrizy) ⇒ matriz
Devuelve la coordenada q equivalente del par de argumentos

(x,y).
escriba R@>Ptheta(...).
R4Pr()
Catálogo >
R4Pr (Exprx, Expry) ⇒ expresión En el modo de ángulo en radianes:

R4Pr (Listax, Listay) ⇒ lista
R4Pr (Matrizx, Matrizy) ⇒ matriz
Devuelve la coordenada r equivalente del par de argumentos (x,y).

escriba R@>Pr(...).
4Rad Catálogo >
Expr14Rad ⇒ expresión En el modo de ángulo en grados:
Convierte el argumento a radianes.

escriba @>Rad. En el modo de ángulo en grados centesimales:
rand()
Catálogo >
rand() ⇒ expresión
Define el número raíz aleatorio.
rand(númeroPruebas) ⇒ lista
rand() devuelve un valor aleatorio entre 0 y 1.
rand(númeroPruebas) devuelve una lista que contiene

númeroPruebas valores aleatorios entre 0 y 1.

randBin()
Catálogo >
randBin(n, p) ⇒ expresión
randBin(n, p, númeroPruebas) ⇒ lista
randBin(n, p) devuelve un número real aleatorio de una
distribución binomial especificada.
randBin(n, p, númeroPruebas) devuelve una lista que contiene
númeroPruebas números reales aleatorios de una distribución
binomial especificada.
randInt()
Catálogo >
randInt(Extremoinferior,Extremosuperior) ⇒ expresión
randInt(Extremoinferior,Extremosuperior,númeroPruebas) ⇒
lista
randInt(Extremoinferior,Extremosuperior) devuelve un entero
aleatorio comprendido en el rango especificado por los límites
enteros Extemoinferior y Extremosuperior.
randInt(Extremoinferior,Extremosuperior,númeroPruebas)
devuelve una lista que contiene númeroPruebas enteros aleatorios
comprendidos en el rango especificado.
randMat()
Catálogo >
randMat(númeroFilas, númeroColumnas) ⇒ matriz

Devuelve una matriz de números enteros entre -9 y 9 de la dimensión
especificada.
Ambos argumentos deben simplificarse a números enteros.
Nota: Los valores de la matriz cambiarán cada vez que se pulse

·.
randNorm()
Catálogo >
randNorm(m, s) ⇒ expresión
randNorm(m, s, númeroPruebas) ⇒ lista
Devuelve un número decimal a partir de la distribución normal
especificada. Puede ser cualquier número real, pero estará
concentrado principalmente en el intervalo [mN3·s, m+3·s].
randNorm(m, s, númeroPruebas) devuelve una lista que

contiene tantos números decimales como númeroPruebas
correspondientes a la distribución normal especificada.
randPoly()
Catálogo >
randPoly(Var, Orden) ⇒ expresión

Devuelve un polinomio en Var del Orden especificado. Los
coeficientes son número enteros aleatorios comprendidos en el rango
de ë9 a 9. El coeficiente inicial nunca es cero.
Orden debe ser 0–99.

randSamp()
Catálogo >
randSamp(Lista,númeroPruebas[,noResp]) ⇒ lista
Devuelve una lista que contiene una muestra aleatoria de
númeroPruebas pruebas procedentes de una Lista con una opción
para muestra con reemplazamiento (noResp=0), o muestra sin
reemplazamiento (noResp=1). El valor predeterminado es sustituir el
ejemplo.
RandSeed
Catálogo >
RandSeed Número
Si Número = 0, define el valor raíz en los ajustes predeterminados de

fábrica para el generador de números aleatorios. Si Número ƒ 0, se
utiliza para generar dos números raíz, que se almacenan en las
variables del sistema como seed1 y seed2.
real()
Catálogo >
real( Expr1) ⇒ expresión

Devuelve la parte real del argumento.
reales. Consulte también imag(), en la página 57.
real( Lista1) ⇒ lista

Devuelve la parte real de todos los elementos.
real( Matriz1) ⇒ matriz

Devuelve la parte real de todos los elementos.
4Rect Catálogo >
Vector 4Rect
escriba @>Rect.
Muestra el Vector en formato rectangular [x, y, z]. El vector debe ser
bidimensional o tridimensional y ser fila o columna.
Nota: 4Rect es una orden para un formato de presentación, no una
función de conversión. Se puede utilizar sólo al final de una línea de
entrada y no actualiza el valor de ans.
Nota: Consulte también 4Polar, en la página 87.

4Rect Catálogo >
complexValue 4Rect En el modo de ángulo en radianes:

Muestra complexValue en formato rectangular a+bi. complexValue
puede tener cualquier formato complejo. Sin embargo, una entrada
reiq generará un error si el modo de ángulo es grados.
Nota: Debe utilizar paréntesis para una entrada polar (rq).
En el modo de ángulo en grados:
Nota: Para introducir , selecciónelo en la lista de símbolos

del catálogo.
ref()
Catálogo >
ref( Matriz1[, Tol]) ⇒ matriz

Devuelve una forma de fila escalonada de Matriz1.
Opcionalmente, cualquier elemento de matriz se trata como cero si su
valor absoluto es menor que Tol. Esta tolerancia se utiliza sólo si la
matriz tiene entradas de coma flotante y no contiene ninguna
variable simbólica que no tenga asignado un valor. De lo contrario se
ignorará el valor de Tol.
• /·
5Eë14 ·max(dim(Matriz1)) ·rowNorm(Matriz1)
Evite utilizar elementos no definidos en Matriz1. Pueden generar
resultados inesperados.
Por ejemplo, si el elemento a no está definido en la siguiente
expresión, aparecerá un mensaje de advertencia y el resultado se
mostrará como:
El mensaje de advertencia aparece porque el elemento generalizado

1/a podría no ser válido para a=0.
Puede evitar este problema si almacena un valor en a con antelación
o si utiliza el mecanismo de sustitución “|”, como se indica en el
siguiente ejemplo.
Nota: Consulte también rref(), en la página 103.

remain()
Catálogo >
remain(Expr1, Expr2) ⇒ expresión

remain(Lista1, Lista2) ⇒ lista
remain(Matriz1, Matriz2) ⇒ matriz
Devuelve el resto del primer argumento con respecto al segundo

argumento, según se define en las identidades:
remain(x,0)  x
remain(x,y)  xNy·iPart(x/y)
Como consecuencia, observe que remain(Nx,y)  Nremain(x,y). El

resultado puede ser cero o tener el mismo signo que el primer
argumento.
Nota: Consulte también mod(), en la página 76.
Request
Catálogo >
Request cadenaSolicitud, var [, MostrEtiqueta] Defina un programa:

Request cadenaSolicitud, func ( arg1, ...argn ) [, MostrEtiqueta] Define request_demo()=Prgm
Request “Radio: ”,r
Orden de programación: Interrumpe el programa y abre un cuadro de Disp “Área = “,pi*r2
diálogo que muestra el mensaje cadenaSolicitud y un cuadro de EndPrgm
entrada para que el usuario escriba la respuesta.
Ejecute el programa y escriba una respuesta:
Cuando el usuario escribe la respuesta y hace clic en Aceptar, el request_demo()
contenido del cuadro de entrada se asigna a la variable var.
El argumento opcional MostrEtiqueta puede ser cualquier expresión.
• Si MostrEtiqueta se omite o se calcula en 1, en el historial de
Calculadora aparecen tanto el mensaje de solicitud como la
respuesta del usuario.
• Si MostrEtiqueta se calcula en 0, el historial no muestra la
solicitud ni la respuesta del usuario. Resultado después de seleccionar Aceptar:
Radio: 6/2
Área= 28,2743
El argumento func() permite a un programa almacenar la respuesta Defina un programa:
del usuario como una definición de función. Esta sintaxis funciona si Define polynomial()=Prgm
el usuario ha ejecutado la orden: Request "Introducir un polinomio en x:",p(x)
Disp "Las raíces reales son:",polyRoots(p(x),x)
Define func(arg1, ...argn) = respuesta del usuario EndPrgm
El programa puede utilizar luego la función definida func(). El Ejecute el programa y escriba una respuesta:
argumento cadenaSolicitud sirve para indicar al usuario que polynomial()
introduzca una respuesta del usuario correcta que complete la
definición de la función.
Nota: La orden Request se puede utilizar en un programa definido
por el usuario, pero no en una función.
Nota: Consulte también RequestStr, en la página 100.
Resultado después de seleccionar Aceptar:

Introducir un polinomio en x: x^3+3x+1
Las raíces reales son: {-0,322185}

RequestStr
Catálogo >
RequestStr cadenaSolicitud, var [, MostrEtiqueta] Defina un programa:

Define requestStr_demo()=Prgm
Orden de programación: Funciona igual que la primera sintaxis de la RequestStr “Su nombre:”,nombre,0
orden Request, salvo en que la respuesta del usuario se interpreta Disp “La respuesta tiene “,dim(name),”
siempre como una cadena. Por su parte, la orden Request interpreta caracteres”.
la respuesta como una expresión, a menos que el usuario la encierre EndPrgm
entre comillas (““).
Ejecute el programa y escriba una respuesta:
Nota: La orden RequestStr se puede utilizar en un programa requestStr_demo()
definido por el usuario, pero no en una función.
Nota: Consulte también Request, en la página 99.
Resultado después de seleccionar Aceptar (observe que el

argumento MostrEtiqueta de 0 no muestra la solicitud ni la
respuesta del historial):
requestStr_demo()
La respuesta tiene 5 caracteres.
Return
Catálogo >
Return [Expr]
Devuelve Expr como resultado de la función. Se utiliza en un bloque

Func...EndFunc.
Nota: Utilice Return sin argumento en un bloque Prgm...EndPrgm

para salir de un programa.
@
Enter (Intro).
right()
Catálogo >
right(Lista1[, Número]) ⇒ lista

Devuelve Número elementos situados a la derecha y contenidos en
Lista1.
Si se omite Número, devuelve todos los de Lista1.
right(Cadenaorigen[, Número]) ⇒ cadena
Devuelve Número caracteres situados a la derecha en la cadena de
caracteres Cadenaorigen.
Si se omite Número, devuelve todos los de Cadenaorigen.
right(Comparación) ⇒ expresión
Devuelve el miembro de la derecha de una ecuación o una
desigualdad.

root()
Catálogo >
root(Expr) ⇒ root
root(Expr1, Expr2) ⇒ raíz
root(Expr) devuelve la raíz cuadrada de Expr.
root(Expr1, Expr2) devuelve la raíz Expr2 de Expr1. Expr1 puede

ser una constante de coma flotante real o compleja, una constante
racional entera o compleja o una expresión simbólica general.
Nota: Consulte también Plantilla de raíz enésima, en la página 1.
rotate()
Catálogo >
rotate(Entero1[,númeroDeRotaciones]) ⇒ entero En modo base Bin:
Rota los bits de un entero binario. Entero1 se puede introducir en

cualquier base numérica; se convierte automáticamente a un formato
binario con signo de 64 bits. Si el módulo de Entero1 es demasiado
largo para este formato, se utiliza una operación de módulo simétrico
para llevar el valor al rango apropiado. Para obtener más
información, consulte 4Base2, en la página 14.
mover el cursor.
Si númeroDeRotaciones es positivo, la rotación es hacia la izquierda. En modo base Hex:
Si númeroDeRotaciones es negativo, la rotación es hacia la derecha.
El valor predeterminado es ë1 (rotar un bit hacia la derecha).
Por ejemplo, en una rotación hacia la derecha:
Cada bit se rota hacia la derecha. Importante: Para introducir un número binario o hexadecimal,
utilice siempre el prefijo 0b o 0h (cero, no la letra O).
0b00000000000001111010110000110101
El bit situado en el extremo derecho se rota hacia la izquierda.
generando:
0b10000000000000111101011000011010
El resultado se muestra en conformidad con el modo de base.
rotate(Lista1[,númeroDeRotaciones]) ⇒ lista En modo base Dec:
Devuelve una copia de Lista1 rotada hacia la derecha o la izquierda

tantos elementos como indica númeroDeRotaciones. No altera el
contenido de Lista1.
Si númeroDeRotaciones es positivo, la rotación es hacia la izquierda.
El valor predeterminado es ë1 (rotar un elemento hacia la derecha).
rotate(Cadena1[,númeroDeRotaciones]) ⇒ cadena
Devuelve una copia de Cadena1 rotada hacia la derecha o la
izquierda tantos caracteres como indica númeroDeRotaciones. No
altera el contenido de Cadena1.
Si númeroDeRotaciones es positivo, la rotación es hacia la izquierda.
El valor predeterminado es ë1 (rotar un carácter hacia la derecha).

round()
Catálogo >
round( Expr1[, dígitos]) ⇒ expresión

Devuelve el argumento redondeado a tantas cifras decimales como
dígitos se especifiquen.
dígitos debe ser un número entero en el rango de 0–12. Si dígitos no
se incluye, devuelve el argumento redondeado a 12 dígitos
significativos.
Nota: El modo de presentación de los dígitos puede afectar a la
forma en que aparecen en pantalla.
round( Lista1[, dígitos]) ⇒ lista
Devuelve una lista de los elementos redondeados al número de
dígitos especificado.
round( Matriz1[, dígitos]) ⇒ matriz

Devuelve una matriz de los elementos redondeados al número de
dígitos especificado.
rowAdd()
Catálogo >
rowAdd( Matriz1, filaÍndice1, filaÍndice2) ⇒ matriz

Devuelve una copia de Matriz1 con la fila de filaÍndice2 sustituida
por la suma de las filas filaÍndice1 y filaÍndice2.
rowDim()
Catálogo >
rowDim( Matriz) ⇒ expresión

Devuelve el número de filas de Matriz.
Nota: Consulte también colDim(), en la página 19.
rowNorm()
Catálogo >
rowNorm( Matriz) ⇒ expresión

Devuelve el máximo de las sumas de los valores absolutos de los
elementos de las filas de Matriz.
Nota: Todos los elementos de la matriz deben simplificarse a
números. Consulte también colNorm(), en la página 19.
rowSwap()
Catálogo >
rowSwap( Matriz1, filaÍndice1, filaÍndice2) ⇒ matriz

Devuelve Matriz1 con las filas de filaÍndice1 y filaÍndice2
intercambiadas entre sí.

rref()
Catálogo >
rref(Matriz1[, Tol]) ⇒ matriz

Devuelve una forma de fila escalonada reducida de Matriz1.

su valor absoluto es menor que el de Tol. Esta tolerancia se utiliza
contrario se ignorará el valor de Tol.
• /·
5Eë14 ·max(dim(Matriz1)) ·rowNorm(Matriz1)
Nota: Consulte también ref(), en la página 98.
S
sec() Tecla μ
sec(Expr1) ⇒ expresión En el modo de ángulo en grados:
sec(Lista1) ⇒ lista
Devuelve la secante de Expr1 o una lista de las secantes de todos los

elementos de Lista1.
utilizar ó, G oôpara sobrescribir el modo de ángulo temporalmente.
sec /() Tecla μ

sec/(Expr1) ⇒ expresión En el modo de ángulo en grados:
sec/(Lista1) ⇒ lista
Devuelve el ángulo cuya secante es Expr1 o una lista de las secantes

inversas de todos los elementos de Lista1. En el modo de ángulo en grados centesimales:
Nota: Si desea insertar esta función con el teclado, escriba
arcsec(...). En el modo de ángulo en radianes:

sech()
Catálogo >
sech(Expr1) ⇒ expresión
sech(Lista1) ⇒ lista
Devuelve la secante hiperbólica de Expr1 o una lista de las secantes

hiperbólicas de los elementos de Lista1.
sechê()
Catálogo >
sech ê(Expr1) ⇒ expresión En el modo de ángulo en radianes y el modo complejo

sechê (Lista1) ⇒ lista rectangular:
Devuelve la secante hiperbólica inversa de Expr1 o una lista de las

secantes hiperbólicas inversas de todos los elementos de Lista1.
Nota: Si desea insertar esta función con el teclado, escriba
arcsech(...).
seq()
Catálogo >
seq(Expr, Var, Inferior, Superior[, Paso]) ⇒ lista

Incrementa el valor de Var desde Inferior hasta Superior utilizando
el valor indicado en Paso, calcula Expr y muestra el resultado en una
lista. El contenido original de Var permanece después de que seq() se
haya completado.
Var no puede ser una variable del sistema.
El valor predeterminado para Paso = 1.

Pulse Ctrl+Enter (Intro) /· (Macintosh®:
“+Enter) para calcular:

series()
Catálogo >
series(Expr1, Var, Orden [, Punto]) ⇒ expresión

series(Expr1, Var, Orden [, Punto]) | Var>Punto ⇒ expresión
series(Expr1, Var, Orden [, Punto]) | Var<Punto ⇒ expresión
Devuelve una representación en series de potencias truncadas

generalizadas de Expr1 desarrolladas a partir de Punto hasta el
grado Orden. Orden puede ser cualquier número racional. Las
potencias resultantes de (Var N Punto) pueden incluir exponentes
negativos y/o fraccionales. Los coeficientes de estas potencias pueden
incluir logaritmos de (Var N Punto) y otras funciones de Var que
estén dominadas por todas las potencias de (Var N Punto) con el
mismo signo en el exponente.
El valor predeterminado de Punto es 0. Punto puede ser ˆ o Nˆ,
en cuyo caso el desarrollo se produce a partir del grado Orden en 1/
(Var N Punto).
series(...) devuelve “series(...)” si no puede obtener una
representación concreta como, por ejemplo, en singularidades
esenciales como sin(1/z) en z=0, eN1/z en z=0 o ez en z = ˆ o Nˆ.
Si la serie o una de sus derivadas tiene un salto de discontinuidad en
Punto, el resultado puede contener subexpresiones en la forma
sign(…) o abs(…) para una variable de desarrollo real, o (-
1)floor(…angle(…)…) para una variable de desarrollo complejo, como
una que termine con “_”. Si piensa utilizar la serie sólo para los
valores de un lado de Punto, añada el apropiado de “| Var > Punto”,
“| Var < Punto”, “| “Var ‚ Punto” o “Var  Punto” para obtener
un resultado más simple.
series() puede ofrecer aproximaciones simbólicas a integrales
indefinidas y a integrales definidas para las que, de otro modo, no
sería posible obtener soluciones simbólicas.
series() se distribuye sobre los primeros argumentos de listas y
matrices.
series() es una versión generalizada de taylor().
Como se puede apreciar en el último ejemplo de la derecha es posible

reorganizar la presentación del flujo de rutinas de los resultados
generados por series(...) para que el término dominante no quede en
el extremo izquierdo.
Nota: Consulte también dominantTerm(), en la página 39.

setMode()
Catálogo >
setMode(ModoNombreEntero, AjusteEntero) ⇒ entero Muestra el valor aproximado de p con el ajuste predeterminado para
setMode(lista) ⇒ lista de enteros Mostrar dígitos y, a continuación, muestra p con un ajuste Fijo2.
Comprueba que se hayan recuperado los valores predeterminados
Válido sólo en una función o un programa. después de ejecutar el programa.
setMode(ModoNombreEntero, AjusteEntero) define
temporalmente el modoModoNombreEntero con la nueva
configuración AjusteEntero, y devuelve un entero que se
corresponde con la configuración original de dicho modo. El
cambio está limitado a la duración de la ejecución del programa o
la función.
ModoNombreEntero especifica el modo que se desea definir.
Debe ser uno de los enteros de modo de la tabla siguiente.
AjusteEntero especifica la nueva configuración del modo. Debe
ser uno de los enteros de configuración indicado en la lista
siguiente para el modo concreto que se desea definir.
setMode(list) permite cambiar diversos ajustes de configuración.
lista contiene pares de enteros de modo y de configuración.
setMode(lista) devuelve una lista similar cuyos pares de enteros
representan los modos y configuraciones originales.
Si guarda todos los valores de configuración con getMode(0) &
var, puede utilizar setMode(var) para restaurar temporalmente
la configuración hasta que finalice la ejecución de la función o el
programa. Consulte getMode(), en la página 53.
Nota: La configuración de modo actual se utiliza para las
subrutinas recuperadas. Si una subrutina cambia una
configuración de modo, se perderá el cambio cuando el control
pase de nuevo a la rutina utilizada para la recuperación.
Nota para introducir el ejemplo: En la aplicación
Calculadora de la unidad portátil, puede introducir definiciones
formadas por varias líneas si pulsa @ en lugar de· al
final de cada línea. En el teclado del ordenador, mantenga
pulsada la tecla Alt y pulse Enter (Intro).
Nombre del Modo

entero
Display Digits 1 1=Flotante, 2=Flotante1, 3=Flotante2, 4=Flotante3, 5=Flotante4, 6=Flotante5,

(Mostrar dígitos) 7=Flotante6, 8=Flotante7, 9=Flotante8, 10=Flotante9, 11=Flotante10, 12=Flotante11,
13=Flotante12, 14=Fijo0, 15=Fijo1, 16=Fijo2, 17=Fijo3, 18=Fijo4, 19=Fijo5, 20=Fijo6,
21=Fijo7, 22=Fijo8, 23=Fijo9, 24=Fijo10, 25=Fijo11, 26=Fijo12
Angle (Ángulo) 2 1=Radianes, 2=Grados, 3=Grados centesimales
Exponential Format 3 1=Normal, 2=Científico, 3=Ingeniería

(Formato
exponencial)
Real or Complex 4 1=Real, 2=Rectangular, 3=Polar

(Real o complejo)
Auto or 5 1=Auto, 2=Aproximado, 3=Exacto

Approximate (Auto
o aproximado)
Vector Format 6 1=Rectangular, 2=Cilíndrico, 3=Esférico

(Formato vectorial)
Base 7 1=Decimal, 2=Hex, 3=Binario

Nombre del Modo
entero
Unit System 8 1=SI, 2=Inglés/EE UU

(Sistema de
unidades)
shift()
Catálogo >
shift(Entero1[,númeroDeDesplazamientos]) ⇒ entero En modo base Bin:
Desplaza los bits de un entero binario. Entero1 se puede introducir

en cualquier base numérica; se convierte automáticamente a un
formato binario con signo de 64 bits. Si el módulo de Entero1 es
demasiado largo para este formato, se utiliza una operación de
En modo base Hex:
Si númeroDeDesplazamientos es positivo, el desplazamiento es
hacia la izquierda. Si númeroDeDesplazamientos es negativo, el
desplazamiento es hacia la derecha. El valor predeterminado es ë1
(desplazar un bit hacia la derecha).
En un desplazamiento hacia la derecha, el bit situado en el extremo
derecho se descarta y se inserta 0 o 1 para que coincida con el bit del Importante: Para introducir un número binario o
extremo izquierdo. En un desplazamiento hacia la izquierda, el bit hexadecimal, utilice siempre el prefijo 0b o 0h (cero, no la
situado en el extremo izquierdo se descarta y se inserta 0 en el bit del letra O).
extremo derecho.
Por ejemplo, en un desplazamiento hacia la derecha:
Cada bit se desplaza hacia la derecha.
0b0000000000000111101011000011010
Se inserta 0 si el bit del extremo izquierdo es 0,
o 1 si el bit del extremo izquierdo es 1.
generando:
0b00000000000000111101011000011010
El resultado se muestra en conformidad con el modo de base. Los
ceros iniciales no son visibles.
shift(Lista1 [,númeroDeDesplazamientos]) ⇒ lista En modo base Dec:
Devuelve una copia de Lista1 desplazada hacia la derecha o la

izquierda tantos elementos como indique
númeroDeDesplazamientos. No altera el contenido de Lista1.
(desplazar un elemento hacia la derecha).
Los elementos introducidos al principio o al final de lista por el
desplazamiento se sustituyen por el símbolo “undef”.
shift(Cadena1 [,númeroDeDesplazamientos]) ⇒ cadena
Devuelve una copia de Cadena1 desplazada hacia la derecha o la
izquierda tantos caracteres como indique
númeroDeDesplazamientos. No altera el contenido de Cadena1.
(desplazar un carácter hacia la derecha).
Los caracteres introducidos al principio o al final de la cadena por el
desplazamiento se sustituyen por un espacio.

sign()
Catálogo >
sign(Expr1) ⇒ expresión
sign(Lista1) ⇒ lista
sign(Matriz1) ⇒ matriz
Para Expr1 real o compleja, devuelve Expr1/abs(Expr1) cuando

Expr1ƒ 0.
Devuelve 1 si Expr1 es positivo. Si el modo de formato complejo es Real:

Devuelve ë1 si Expr1 es negativo.
sign(0) devuelve „1 si el modo de formato complejo es Real; en caso
contrario, se devuelve a sí mismo.
sign(0) representa la circunferencia de radio unidad de un dominio
complejo
Para una lista o una matriz, devuelve los signos de todos los
elementos.
simult()
Catálogo >
simult(Matrizcoeficientes, Vectorconstrucción[, Resolver para hallar X e Y:

Tol]) ⇒ matriz x + 2y = 1
3x + 4y = ë1
Devuelve un vector columna que contiene las soluciones de un
sistema de ecuaciones lineales.
Nota: Consulte también linSolve(), en la página 66.
Matrizcoeficientes debe ser una matriz cuadrada que contenga los La solución es x=ë3 e y=2.
coeficientes de las ecuaciones.
Vectorconstrucción debe tener el mismo número de filas (la misma Resolver:
dimensión) que Matrizcoeficientes y contener las constantes. ax + by = 1
cx + dy = 2
su valor absoluto es menor que Tol. Esta tolerancia se utiliza sólo si la
matriz tiene entradas de coma flotante y no contiene ninguna variable
simbólica que no tenga asignado un valor. De lo contrario se ignorará
el valor de Tol.
• Si define el modo Auto o Aproximado en Aproximado, los
cálculos se efectuarán utilizando la coma flotante aritmética.
5Eë14 ·max(dim(Matrizcoeficientes))
·rowNorm(Matrizcoeficientes)
simult(Matrizcoeficientes, Matrizconstrucción[, Resolver:
Tol]) ⇒ matriz x + 2y = 1
3x + 4y = ë1
Resuelve múltiples sistemas de ecuaciones lineales, donde cada
sistema tiene los mismos coeficientes de ecuacion pero distintas x + 2y = 2
constantes.
3x + 4y = ë3
Cada columna de Matrizconstrucción debe contener las constantes
de un sistema de ecuaciones. Cada columna de la matriz resultante
contiene la solución del sistema correspondiente.
Para el primer sistema, x=ë3 e y=2. Para el segundo sistema,

x=ë7 e y=9/2.

4sin Catálogo >
Expr 4sin
escriba @>sin.
Representa Expr en función de seno. Es un operador de conversión
de presentación, y únicamente se puede utilizar al final de la línea de
entrada.
4sin reduce todas las potencias del
cos(...) módulo 1Nsin(...)^2
para que las restantes potencias de sin(...) tengan exponentes en el
rango (0, 2). Por lo tanto, el resultado no estará en función de cos(...)
si y sólo si cos(...) se genera en la expresión dada sólo en las
potencias pares.
Nota: Este operador de conversión no es válido para los modos de
ángulo en grados o grados centesimales. Antes de utilizarlo,
asegúrese de que el modo ángulo está definido en radianes y que
Expr no contiene referencias explícitas a ángulos en grados o grados
centesimales.
sin() Tecla μ
sin(Expr1) ⇒ expresión En el modo de ángulo en grados:
sin(Lista1) ⇒ lista
sin(Expr1) devuelve el seno del argumento como una expresión.
sin(Lista1) devuelve una lista de los senos de todos los elementos de

Lista1.
utilizar ó,G o ô para sobrescribir el modo de ángulo temporalmente.
sin(Matrizcuadrada1) ⇒ Matrizcuadrada En el modo de ángulo en radianes:

Devuelve el seno de la matriz Matrizcuadrada1. El resultado no es
igual que calcular el seno de cada elemento. Para obtener más

sinê() Tecla μ
sinê(Expr1) ⇒ expresión En el modo de ángulo en grados:
sinê(Lista1) ⇒ lista
sinê(Expr1) devuelve el ángulo cuyo seno es Expr1 en forma de
expresión. En el modo de ángulo en grados centesimales:
sinê(Lista1) devuelve una lista de los senos inversos de cada
elemento de Lista1.
Nota: El resultado se muestra como un ángulo en grados, grados En el modo de ángulo en radianes:
escriba arcsin(...).
sinê(Matrizcuadrada1) ⇒ Matrizcuadrada En el modo de ángulo en radianes y el formato complejo
rectangular:
Devuelve el seno inverso de la matriz Matrizcuadrada1. El resultado
no es igual que calcular el seno inverso de cada elemento. Para
obtener más información sobre el método de cálculo, consulte cos().

mover el cursor.
sinh()
Catálogo >
sinh(Expr1) ⇒ expresión
sinh(Lista1) ⇒ lista
sinh (Expr1) devuelve el seno hiperbólico del argumento en forma de
expresión.
sinh (Lista1) devuelve una lista de los senos hiperbólicos de cada
elemento de Lista1.
sinh(Matrizcuadrada1) ⇒ Matrizcuadrada En el modo de ángulo en radianes:
Devuelve el seno hiperbólico de la matriz Matrizcuadrada1. El

resultado no es igual que calcular el seno hiperbólico de cada
consulte cos().
sinh ê()
Catálogo >
sinhê(Expr1) ⇒ expresión
sinhê(Lista1) ⇒ lista
sinhê(Expr1) devuelve el seno hiperbólico inverso del argumento en
forma de expresión.
sinhê(Lista1) devuelve una lista de los senos hiperbólicos inversos
de cada elemento de Lista1.
escriba arcsinh(...).

sinh ê()
Catálogo >
sinhê(Matrizcuadrada1) ⇒ Matrizcuadrada En el modo de ángulo en radianes:
Devuelve el seno hiperbólico inverso de la matriz Matrizcuadrada1.

El resultado no es igual que calcular el seno hiperbólico inverso de
cada elemento. Para obtener más información sobre el método de
cálculo, consulte cos().
SinReg
Catálogo >
SinReg X, Y [ , [Iteraciones] ,[ Periodo] [, Categoría, Incluir] ]
Calcula la regresión sinusoidal en las listas X e Y. El resumen de los

resultados se guarda en la variable stat.results. (Consulte la página
116).
Iteraciones es un valor opcional que especifica el número máximo de
veces (de 1 a 16) que se debe intentar la solución. Si se omite, se
utiliza 8. Por lo general, los valores más grandes ofrecen más
precisión aunque requieren más tiempo de ejecución, y viceversa.
Periodo especifica un periodo estimado. Si se omite, la diferencia
entre los valores de X deberá ser igual y estar en orden secuencial.
Si se especifica un Periodo, las diferencias entre los valores de x
pueden ser desiguales.
La salida de SinReg se expresa siempre en radianes, al margen de la
configuración de ángulo elegida.
160.
salida
stat.RegEqn Ecuación de regresión: a·sin(bx+c)+d

stat.d

solve()
Catálogo >
solve(Ecuación, Var) ⇒ Expresión booleana

solve(Ecuación, Var=Conjetura) ⇒ Expresión booleana
solve(Desigualdad, Var) ⇒ Expresión booleana
Devuelve posibles soluciones reales de una ecuación o una

desigualdad para Var. El objetivo es producir valores para todas las
posibles soluciones. No obstante, puede haber ecuaciones o
desigualdades cuyo número de soluciones sea infinito.
Las posibles soluciones pueden no ser soluciones finitas reales para
algunas combinaciones de valores para variables sin definir.
Para el ajuste Auto del modo Auto or Approximate (Auto o

Aproximado), el objetivo es producir soluciones exactas cuando
son concisas, y realizar búsquedas iterativas para hallar
aproximaciones aritméticas complementarias cuando no sea posible
producir soluciones exactas.
Debido a la simplificación del numerador y del denominador de una
fracción al dividir ambos por su máximo común divisor, puede haber
soluciones en uno de los límites laterales o también en ambos.
Para las desigualdades de tipo ‚, , < o >, las soluciones explícitas

son improbables a menos que la desigualdad sea lineal y contenga
sólo Var.
Para el modo Exacto, las partes que no se pueden resolver se

devuelven como una ecuación o una desigualdad implícita.
Utilice el operador “|” para restringir el intervalo de la solución y/o En el modo de ángulo en radianes:
cualquier otra variable que ocurra en la ecuación o la desigualdad.
Cuando se halla una solución en un intervalo, puede utilizar los
operadores de la desigualdad para excluir dicho intervalo de las
subsiguientes búsquedas.
Devuelve falso cuando no se encuentran soluciones reales.

Se devuelve verdadero si solve() puede determinar que cualquier
valor real finito de Var satisface la ecuación o la desigualdad.
Dado que solve() devuelve siempre un resultado booleano, puede

utilizar “and”, “or”, y “not” para combinar los resultados de solve()
entre sí o con otras expresiones booleanas.
Las soluciones pueden contener una nueva constante única sin definir En el modo de ángulo en radianes:
de la forma nj donde j es un entero comprendido entre 1 y 255. Tales
variables designan un número entero arbitrario.
En el modo Real, las potencias de fracción que tengan denominadores

impares designan sólo la rama real. En caso contrario, las expresiones
con múltiples ramas como las potencias de fracción, logaritmos y
funciones de trigonometría inversa designan sólo la rama principal.
Por lo tanto, solve() sólo produce soluciones que se corresponden
con una rama real o principal.
Nota: Consulte también cSolve(), cZeros(), nSolve() y zeros().

solve()
Catálogo >
solve(Ecuación1 and Ecuación2 [and … ], VarOConjetura1,

VarOConjetura2 [, … ]) ⇒ Expresión booleana
solve(Sistema de ecuaciones, VarOConjetura1,
VarOConjetura2 [, … ]) ⇒ Expresión booleana
Devuelve posibles soluciones reales para las ecuaciones algebraicas
simultáneas, donde cada VarOConjetura especifica una variable que
se desea resolver.
Puede separar las ecuaciones con el operador and, o introducir un
sistema de ecuaciones mediante una plantilla del catálogo. El
número de argumentos de VarOConjetura debe coincidir con el
número de ecuaciones. Opcionalmente se puede especificar un valor
inicial para una variable. Cada VarOConjetura debe tener la forma:
variable
–o–
Si todas las ecuaciones son polinómicas y NO se ha especificado
ningún valor inicial, solve() utiliza el método de eliminación léxica de
Gröbner/Buchberger para tratar de determinar todas las soluciones
reales.
Por ejemplo, suponga que tiene una circunferencia de radio r en el
origen y otra circunferencia de radio r centrada en el punto donde la
primera circunferencia corta el eje X positivo. Utilice solve() para
hallar las intersecciones.
Como se ve por el valor de r en el ejemplo de la derecha, las

ecuaciones polinómicas simultáneas pueden tener variables extra que
carezcan de valores, pero representen valores numéricos dados que
se podrían sustituir más adelante.
Puede incluir variables de soluciones que no aparezcan en las

ecuaciones. Por ejemplo, puede incluir z como la variable de solución
que amplíe el ejemplo anterior a dos cilindros paralelos de radio r que
se corten entre sí.
Las soluciones para el cilindro ilustran el modo en que las familias de
soluciones pueden contener constantes arbitrarias de la forma ck,
donde k sea un número sufijo entero de 1 a 255. Para ver todos los resultados, pulse £ y utilice ¡ y ¢ para
Para sistemas polinómicos, el tiempo de cálculo o el agotamiento de mover el cursor.
la memoria pueden depender del orden con el que aparecen las
variables de solución. Si la opción de memoria, o su paciencia, se
agota, pruebe a reorganizar las variables de las ecuaciones, la lista de
varOConjetura o ambos elementos.
Si no incluye ningún valor inicial y alguna de las ecuaciones es no
polinómica en cualquier variable pero todas las ecuaciones son
lineales en todas las variables de solución, solve() utiliza un método
de eliminación gaussiana para tratar de determinar todas las
soluciones reales.

variables de solución, solve() determina una solución como máximo
utilizando un método de iteración aproximada. Para ello, el número
de las variables de la solución debe ser igual al número de
ecuaciones, y todas las demás variables de las ecuaciones deben
simplificarse en números. Para ver todos los resultados, pulse £ y utilice ¡ y ¢ para
mover el cursor.

solve()
Catálogo >
Cada variable de solución comienza en su valor inicial proporcionado

si lo hubiera; de lo contrario, comenzará en 0,0.
Utilice valores iniciales para buscar una a una las posibles soluciones
adicionales. Por convergencia, es probable que un valor inicial esté
bastante próximo a la solución.
SortA
Catálogo >
SortA Lista1[, Lista2] [, Lista3] ...

SortA Vector1[, Vector2] [, Vector3] ...
Ordena los elementos del primer argumento en sentido ascendente.

Si incluye otros argumentos, ordena los elementos de cada uno de
forma que sus nuevas posiciones coincidan con las nuevas posiciones
de los elementos del primer argumento.
Todos los argumentos deben ser nombres de listas o vectores. Todos
los argumentos deben tener la misma dimensión.
Los elementos vacíos (sin valor) del primer argumento se trasladan a
la parte inferior. Para obtener más información sobre los elementos
SortD
Catálogo >
SortD Lista1[, Lista2] [, Lista3] ...

SortD Vector1[,Vector2] [,Vector3] ...
Idéntico a la función SortA, salvo en que SortD ordena los elementos

en sentido descendente.
Los elementos vacíos (sin valor) del primer argumento se trasladan a
la parte inferior. Para obtener más información sobre los elementos

4Sphere Catálogo >
Vector 4Sphere Pulse Ctrl+Enter (Intro) /· (Macintosh®:

Nota: Si desea insertar este operador con el teclado del ordenador, “+Enter) para calcular:
escriba @>Sphere.
Muestra el vector fila o columna en forma esférica [r q f].
Vector debe tener una dimensión 3 y puede ser un vector fila o
columna.
Nota: 4Sphere es una orden para un formato de presentación, no
una función de conversión. Puede utilizarse sólo al final de una línea
de entrada.
Pulse ·
(ρ,θ,φ)
φ
sqrt()
Catálogo >
sqrt(Expr1) ⇒ expresión
sqrt(Lista1) ⇒ lista
Devuelve la raíz cuadrada del argumento.
Para una lista, devuelve las raíces cuadradas de todos los elementos
de Lista1.
Nota: Consulte también Plantilla de raíz cuadrada, en la página 1.

stat.results
Catálogo >
stat.results
Muestra los resultados de un cálculo estadístico.
Los resultados aparecen como un conjunto de pares formados por el
nombre y su correspondiente valor. Los nombres específicos que
aparecen dependen de la última función u orden estadística
calculada.
Puede copiar un nombre o valor y pegarlo en otras ubicaciones.
Nota: Al definir variables, procure no elegir los mismos nombres que

utiliza para los análisis estadísticos, ya que puede generarse una
condición de error. Los nombres de variables utilizados para los
análisis estadísticos se indican en la tabla siguiente.
stat.a stat.dfDenom stat.MedianY stat.Q3Y stat.SSCol

stat.AdjR² stat.dfBlock stat.MEPred stat.r stat.SSX
stat.b stat.dfCol stat.MinX stat.r² stat.SSY
stat.b0 stat.dfError stat.MinY stat.RegEqn stat.SSError
stat.b1 stat.dfInteract stat.MS stat.Resid stat.SSInteract
stat.b2 stat.dfReg stat.MSBlock stat.ResidTrans stat.SSReg
stat.b3 stat.dfNumer stat.MSCol stat.sx stat.SSRow
stat.b4 stat.dfRow stat.MSError stat.sy stat.tList
stat.b5 stat.DW stat.MSInteract stat.sx1 stat.UpperPred
stat.b6 stat.e stat.MSReg stat.UpperVal
stat.sx2
stat.b7 stat.ExpMatrix stat.MSRow stat.v
stat.Gx
stat.b8 stat.F stat.n stat.v1
stat.b9 stat.FBlock stat.Ç stat.Gx²
stat.v2
stat.b10 stat.Fcol stat.Ç1 stat.Gxy
stat.vDiff
stat.bList
stat.FInteract stat.Ç2 stat.Gy
stat.vList
stat.c²
stat.FreqReg stat.ÇDiff stat.Gy²
stat.XReg
stat.c stat.s
stat.Frow stat.PList stat.XVal
stat.CLower stat.SE
stat.Leverage stat.PVal stat.XValList
stat.CLowerList stat.SEList
stat.LowerPred stat.PValBlock stat.w
stat.CompList stat.SEPred
stat.PValCol
stat.CompMatrix stat.LowerVal
stat.m stat.PValInteract stat.sResid y
stat.
stat.CookDist
stat.CUpper stat.MaxX stat.PValRow stat.SEslope
stat.sp
y
stat. List
stat.MaxY stat.Q1X stat.YReg
stat.CUpperList stat.SS
stat.ME stat.Q1Y
stat.d stat.SSBlock
stat.MedianX stat.Q3X
Nota: Cada vez que la aplicación Listas y Hojas de cálculo calcula un resultado estadístico, copia las variables de grupo “stat .” en
un grupo “stat#.”, donde # es un número que se incrementa automáticamente. Esto permite mantener los resultados anteriores
mientras se efectúan múltiples cálculos.

stat.values
Catálogo >
stat.values Consulte el ejemplo stat.results.

Muestra la matriz de los valores calculados para la última función u
orden estadística calculada.
A diferencia de stat.results, stat.values omite los nombres
asociados con los valores.
Puede copiar un valor y pegarlo en otras ubicaciones.
stDevPop()
Catálogo >
stDevPop(Lista[, Listafrecuencia]) ⇒ expresión En el modo de ángulo en radianes y auto:
Devuelve la desviación estándar de población de los elementos de

Lista.
Nota: Lista debe tener dos elementos como mínimo. Se desestiman
los elementos vacíos (sin valor). Para obtener más información sobre
los elementos vacíos, consulte la página 160.
stDevPop(Matriz1[, Matrizfrecuencia]) ⇒ matriz

Devuelve un vector fila de las desviaciones estándar de población de
las columnas de Matriz1.
Nota: Matriz1 debe tener dos filas como mínimo. Se desestiman los
elementos vacíos (sin valor). Para obtener más información sobre los
elementos vacíos, consulte la página 160.
stDevSamp()
Catálogo >
stDevSamp(Lista[, Listafrecuencia]) ⇒ expresión

Devuelve la desviación estándar de la muestra de los elementos de
Lista.
Nota: Lista debe tener dos elementos como mínimo. Se desestiman
los elementos vacíos (sin valor). Para obtener más información sobre
los elementos vacíos, consulte la página 160.

stDevSamp()
Catálogo >
stDevSamp(Matriz1[, Matrizfrecuencia]) ⇒ matriz

Devuelve un vector fila de las desviaciones estándar de la muestra de
Nota: Matriz1 debe tener dos filas como mínimo. Se desestiman los
elementos vacíos (sin valor). Para obtener más información sobre los
elementos vacíos, consulte la página 160..
Stop
Catálogo >
Stop
Orden de programación: Finaliza el programa.
Stop es una orden no admitida en las funciones.

@
Enter (Intro).
Store Consulte & (store), en la página 158.
string()
Catálogo >
string(Expr) ⇒ cadena
Simplifica y devuelve el resultado de Expr como una cadena de
caracteres.
subMat()
Catálogo >
subMat(Matriz1[, Filainicial] [, Columnainicial] [, Filafinal] [,

Columnafinal])
⇒ matriz
Devuelve la submatriz especificada de Matriz1.
Valores predeterminados: Filainicial= 1, Columnainicial= 1,
Filafinal= última fila, Columnafinal= última columna
Sum (Sigma) Consulte G(), en la página 151.

sum()
Catálogo >
sum(Lista[, Inicio[, Fin]]) ⇒ expresión

Devuelve la suma de los elementos de Lista.
Inicio y Fin son opcionales. Permiten especificar un rango de
elementos.
Todo argumento vacío genera un resultado sin valor. Se desestiman
los elementos vacíos (sin valor) de Lista. Para obtener más
sum(Matriz1[, Inicio[, Fin]]) ⇒ matriz
Devuelve un vector fila que contiene las sumas de los elementos de
Inicio y Fin son opcionales. Permiten especificar un rango de
elementos.
Todo argumento vacío genera un resultado sin valor. Se desestiman
los elementos vacíos (sin valor) de Matriz1. Para obtener más
sumIf()
Catálogo >
sumIf(Lista,Criterios[, ListaSuma]) ⇒ valor

Devuelve la suma acumulada de todos los elementos de Lista que
cumplen los Criterios especificados. Opcionalmente es posible
especificar una lista alternativa, ListaSuma, que facilite los
elementos que se van a acumular.
Lista puede ser una expresión, lista o matriz. ListaSuma, si se
especifica, debe ser de la misma dimensión que Lista.
Los criterios pueden ser:
• Un valor, una expresión o una cadena. Por ejemplo, 34 cuenta
sólo los elementos de Lista que se simplifican al valor 34.
• Una expresión booleana que contenga el símbolo ? como lugar
donde introducir cada elemento. Por ejemplo, ?<10 acumula sólo
los elementos de Lista que son menores de 10.
Cuando un elemento de Lista cumple los Criterios, se añade a la
suma acumulada. No obstante, si se incluye ListaSuma, el elemento
correspondiente de ListaSuma se añade a la suma.
En la aplicación Listas y Hojas de cálculo puede utilizarse un rango de
celdas en lugar de Lista y ListaSuma.
información sobre los elementos vacíos, consulte la página 160
Nota: Consulte también countIf(), en la página 26.
sumSeq() Consulte G(), en la página 151.
system()
Catálogo >
system(Ecua1 [, Ecua2 [, Ecua3 [, ...]]])

system(Expr1 [, Expr2 [, Expr3 [, ...]]])
Devuelve un sistema de ecuaciones en forma de lista. También puede

crear el sistema utilizando una plantilla.
Nota: Consulte también Sistema de ecuaciones, en la página 3.

T
T (transponer)
Catálogo >
Matriz1T ⇒ matriz
Devuelve la matriz transpuesta conjugada de Matriz1.
escriba @t.
tan() Tecla μ
tan(Expr1) ⇒ expresión En el modo de ángulo en grados:
tan(Lista1) ⇒ lista
tan(Expr1) devuelve la tangente del argumento como una expresión.
tan(Lista1) devuelve una lista de las tangentes de todos los

elementos de Lista1.
utilizar ó, G o ôpara sobrescribir el ajuste de ángulo temporalmente.
tan(Matrizcuadrada1) ⇒ Matrizcuadrada En el modo de ángulo en radianes:
Devuelve la tangente de la matriz Matricuadrada1. El resultado no

es igual que calcular la tangente de cada elemento. Para obtener más

tanê() Tecla μ
tanê(Expr1) ⇒ expresión En el modo de ángulo en grados:
tanê(Lista1) ⇒ lista
tanê(Expr1) devuelve el ángulo cuya tangente es Expr1 como una
expresión.
tanê(Lista1) devuelve una lista de las tangentes inversas de cada
elemento de Lista1.
escriba arctan(...).
tanê(Matrizcuadrada1) ⇒ Matrizcuadrada En el modo de ángulo en radianes:
Devuelve la tangente inversa de la matriz Matrizcuadrada1. El
resultado no es igual que calcular la tangente inversa de cada
consulte cos().
tangentLine()
Catálogo >
tangentLine(Expr1,Var,Punto)⇒ expresión
tangentLine(Expr1,Var=Punto) ⇒ expresión
Devuelve la recta tangente a la curva representada por Expr1 en el

punto especificado en Var=Punto.
Asegúrese de que la variable independiente no esté definida. Por
ejemplo, si f1(x):=5 y x:=3, entonces tangentLine(f1(x),x,2) devuelve
“falso”.
tanh()
Catálogo >
tanh(Expr1) ⇒ expresión
tanh(Lista1) ⇒ lista
tanh(Expr1) devuelve la tangente hiperbólica del argumento como
una expresión.
tanh(Lista1) devuelve una lista de las tangentes hiperbólicas de cada
elemento de Lista1.
tanh(Matrizcuadrada1) ⇒ Matrizcuadrada En el modo de ángulo en radianes:
Devuelve la tangente hiperbólica de la matriz Matrizcuadrada1.

El resultado no es igual que calcular la tangente hiperbólica de cada
consulte cos().

tanh ê()
Catálogo >
tanhê(Expr1) ⇒ expresión En el formato complejo rectangular:

tanhê(Lista1) ⇒ lista
tanhê(Expr1) devuelve la tangente hiperbólica inversa del
argumento como una expresión.
tanhê(Lista1) devuelve una lista de las tangentes hiperbólicas
inversas de cada elemento de Lista1.
escriba arctanh(...).
tanhê(Matrizcuadrada1) ⇒ Matrizcuadrada En el modo de ángulo en radianes y formato complejo
rectangular:
Devuelve la tangente hiperbólica inversa de la matriz
Matrizcuadrada1. El resultado no es igual que calcular la tangente
hiperbólica inversa de cada elemento. Para obtener más información
sobre el método de cálculo, consulte cos().

mover el cursor.
taylor()
Catálogo >
taylor(Expr1, Var, Orden[, Punto]) ⇒ expresión

Devuelve el polinomio de Taylor solicitado. El polinomio incluye
términos distintos de cero cuyos grados sean números enteros
comprendidos entre cero y Orden en (Var menos Punto). taylor() se
devuelve a sí mismo si no hay series de potencias truncadas de este
orden, o si requiere exponentes negativos o fraccionales. Utilice la
sustitución, la multiplicación temporal por una potencia de (Var
menos Punto) o ambos para determinar series de potencias más
generales.
Punto aplica cero de forma predeterminada y es el punto de
desarrollo.
Como se puede apreciar en el último ejemplo de la derecha es posible
reorganizar la presentación del flujo de rutinas de los resultados
generados por taylor(...) para que el término dominante no quede en
el extremo izquierdo.
tCdf()
Catálogo >
tCdf(Extremoinferior,Extremosuperior,df) ⇒ número si
Calcula de probabilidad de distribución de t de Student entre
Extremoinferior y Extremosuperior para los grados de libertad gl
especificados.
Para P(X  Extremosuperior), defina Extremoinferior = .ˆ.

tCollect()
Catálogo >
tCollect(Expr1) ⇒ expresión
Devuelve una expresión en la que los productos y potencias enteros
de senos y cosenos se convierten a una combinación lineal de senos y
cosenos de varios ángulos, sumas de ángulos y diferencias de
ángulos. La transformación convierte los polinomios trigonométricos
en combinaciones lineales de sus periodos.
En ocasiones, tCollect() permitirá alcanzar los objetivos cuando falle
la simplificación trigonométrica predeterminada. tCollect() tiende a
invertir las transformaciones efectuadas por tExpand(). Puede que la
aplicación de tExpand() a un resultado de tCollect(), o viceversa, en
dos pasos independientes permita simplificar una expresión.
tExpand()
Catálogo >
tExpand(Expr1) ⇒ expresión
Devuelve una expresión en la que se desarrollan los senos y los
cosenos de ángulos de múltiples enteros, sumas de ángulos y
diferencias de ángulos. Debido a la identidad de
(sin(x))2+(cos(x))2=1, hay muchos resultados equivalentes posibles.
Por lo tanto, un resultado puede ser distinto de otro ya publicado.
En ocasiones, tExpand() permitirá alcanzar los objetivos cuando falle
la simplificación trigonométrica predeterminada. tExpand() tiende a
invertir las transformaciones efectuadas por tCollect(). Puede que la
aplicación de tCollect() a un resultado de tExpand(), o viceversa, en
dos pasos independientes permita simplificar una expresión.
Nota: La conversión en grados mediante p/180 interfiere con la
capacidad de tExpand() para reconocer formas desarrollables. Para
obtener los mejores resultados se aconseja utilizar tExpand() en el
modo de ángulo en radianes.
Text
Catálogo >
Text cadenaSolicitud [, MostrEtiqueta] Defina un programa que se interrumpa para mostrar cada uno
de los cinco números aleatorios en un cuadro de diálogo.
Orden de programación: Interrumpe el programa y muestra la cadena Utilice la plantilla Prgm...EndPrgm y complete cada línea
de caracteres cadenaSolicitud en un cuadro de diálogo.
pulsando la tecla @ en lugar de · . En el teclado del
La ejecución del programa sigue su curso cuando el usuario
ordenador, mantenga pulsada la tecla Alt y pulse Intro.
selecciona Aceptar. Seleccione Cancelar para detener el
programa. Define text_demo()=Prgm
El argumento opcional etiqueta puede ser cualquier expresión. For i,1,5
strinfo:=”Número aleatorio“ & string(rand(i))
• Si MostrEtiqueta se omite o se calcula en 1, el mensaje de texto Text strinfo
se añade al historial de Calculadora. Next
• Si MostrEtiqueta se calcula en 0, el mensaje de texto no se EndPrgm
añade al historial. Ejecute el programa:
Si el programa necesita que el usuario introduzca una respuesta text_demo()
escrita, consulte la función Request, en la página 99, o la función
Ejemplo de un cuadro de diálogo:
RequestStr, en la página 100.
Nota: Esta orden se puede utilizar en un programa definido por el
usuario, pero no en una función.
Then Consulte If, en la página 56.

tInterval
Catálogo >
TInterval Lista[,Frec[,NivelC]]

TInterval v,Sx,n[,NivelC]
Calcula un intervalo t de confianza. El resumen de los resultados se
160.
salida
stat.CLower, stat.CUpper Intervalo de confianza para una media de población desconocida
stat.x Media de muestra de la secuencia de datos a partir de la distribución aleatoria normal
stat.ME Margen de error
stat.sx Desviación estándar de la muestra
stat.n Longitud de la secuencia de datos con media de la muestra
tInterval_2Samp
Catálogo >
tInterval_2Samp
Lista1,Lista2[,Frec1[,Frec2[,NivelC[,Sondeado]]]]
tInterval_2Samp v1,sx1,n1,v2,sx2,n2[,NivelC[,Sondeado]]
Calcula el intervalo t de confianza de dos muestras. El resumen de los
resultados se guarda en la variable stat.results. (Consulte la página
116.)
Sondeado = 1 varianzas de sondeo; Sondeado = 0 sin varianzas de
sondeo.
160.
salida
stat.CLower, stat.CUpper Intervalo de confianza que contiene la probabilidad del nivel de confianza de la distribución
stat.x1-x2 Media de la muestra de las sucesiones de datos derivadas de una distribución aleatoria normal
stat.x1, stat.x2 Media de la muestra de las sucesiones de datos derivadas de una distribución aleatoria normal

salida
stat.sx1, stat.sx2 Desviaciones estándar de la muestra para Lista 1 y Lista 2
stat.n1, stat.n2 Número de muestras en las secuencias de datos
stat.sp Desviación estándar sondeada. Calculada cuando Sondeado = YES.
tmpCnv()
Catálogo >
tmpCnv(Expr_¡Unidadtiempo, _¡Unidadtiempo2)
⇒ expresión _¡Unidadtiempo2
Convierte un valor de temperatura especificado por Expr de una
unidad a otra. Las unidades de temperatura válidas son:
_¡C Celsius
_¡F Fahrenheit Nota: Puede utilizar el catálogo para seleccionar unidades de
_¡K Kelvin
temperatura.
_¡R Rankine
Para escribir ¡, selecciónelo en la lista de símbolos del catálogo.
para escribir _ , pulse /_.

Por ejemplo, 100_¡C se convierte en 212_¡F.
Para convertir un rango de temperaturas, es preferible utilizar
@tmpCnv().
@tmpCnv()
Catálogo >
@tmpCnv(Expr_¡Unidadtiempo, _¡Unidadtiempo2) Para escribir @, selecciónelo en la lista de símbolos del catálogo.

⇒ expresión _¡Unidadtiempo2
escriba deltaTmpCnv(...).
Convierte un rango de temperaturas (la diferencia entre dos valores
de temperatura) especificado por Expr de una unidad a otra. Las
unidades de temperatura válidas son:
_¡C Celsius
_¡F Fahrenheit Nota: Puede utilizar el catálogo para seleccionar unidades de
_¡K Kelvin temperatura.
_¡R Rankine
Para introducir ¡, selecciónelo en la paleta de símbolos del catálogo,

o escriba @d.
para escribir _ , pulse /_.

1_¡C y 1_¡K tienen la misma magnitud, al igual que 1_¡F y 1_¡R. No
obstante, 1_¡C es 9/5 la magnitud de 1_¡F.
Por ejemplo, un rango de 100_¡C (de 0_¡C a 100_¡C) es equivalente

a un rango de 180_¡F.
Para convertir un valor de temperatura concreto en lugar de un rango,
utilice tmpCnv().

tPdf()
Catálogo >
tPdf(XVal,gl) ⇒ número si XVal es un número, lista si XVal es

una lista
Calcula la función de densidad de probabilidad (pdf) para la
distribución de t de Student para un valor x especificado para los
grados de libertad gl especificados.
trace()
Catálogo >
trace(Matrizcuadrada) ⇒ expresión
Devuelve la traza (suma de todos los elementos de la diagonal
principal) de Matrizcuadrada.
Try Catálogo >

Try
Bloque1
Else
Bloque2
EndTry
Ejecuta Bloque1 a menos que se genere un error. La ejecución del
programa se transfiere a Bloque2 si se produce un error en Bloque1.
La variable del sistema errCode contiene el número de error que
permite al programa ejecutar la recuperación tras el error. Para ver la
lista de códigos de error, consulte “Códigos y mensajes de
error”, en la página 166.
Bloque1 y Bloque2 pueden ser una sentencia sencilla o una serie de
sentencias separadas por el carácter “:”.
@
Enter (Intro).

Try Catálogo >
Ejemplo 2 Definir eigenvals(a,b)=Prgm

© Program eigenvals(A,B) muestra valores propios de A·B
Para ver las órdenes Try, ClrErr y PassErr en funcionamiento, Try
introduzca el programa eigenvals() que se muestra a la derecha. Disp "A= ",a
Ejecute el programa activando cada una de las siguientes Disp "B= ",b
expresiones. 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
Nota: Consulte también ClrErr, en la página 19, y PassErr, en la

página86.
tTest
Catálogo >
tTest m0,Lista[,Frec[,Hipótesis]]
tTest m0,x,sx,n,[Hipótesis]
Efectúa un test de hipótesis para una media de población
desconocida m cuando se desconoce la desviación estándar de
población s. El resumen de los resultados se guarda en la variable
stat.results. (Consulte la página 116.)
Prueba H0: m = m0, frente a una de las alternativas siguientes:
Para Ha: m < m0, defina Hipótesis<0

Para Ha: m ƒ m0 (predeterminado), defina Hipótesis=0
Para Ha: m > m0, defina Hipótesis>0

160.
salida
stat.t (x N m0) / (stdev / sqrt(n))
stat.x Media de muestra de la sucesión de datos de Lista
stat.sx Desviación estándar de la sucesión de datos
stat.n Tamaño de la muestra

tTest_2Samp
Catálogo >
tTest_2Samp
Lista1,Lista2[,Frec1[,Frec2[,Hipótesis[,Sondeado]]]]
tTest_2Samp v1,sx1,n1,v2,sx2,n2[,Hipótesis[,Sondeado]]
Calcula un test t de dos muestras. El resumen de los resultados se
Prueba H0: m1 = m2, frente a una de las alternativas siguientes:
Para Ha: m1< m2, defina Hipótesis<0

Para Ha: m1ƒ m2 (predeterminado), defina Hipótesis=0
Para Ha: m1> m2, defina Hipótesis>0
Sondeado = 1 sondea las varianzas

Sondeado = 0 no sondea las varianzas
160.
salida
stat.t Valor normal estándar calculado para la diferencia de las medias
stat.df Grados de libertad para la estadística de t
stat.x1, stat.x2 Media de la muestra de las sucesiones de datos en Lista 1 y Lista 2
stat.sx1, stat.sx2 Desviaciones estándar de la muestra de las sucesiones de datos en Lista 1 y Lista 2
stat.sp Desviación estándar sondeada. Calculada cuando Sondeado = 1.
tvmFV()
Catálogo >
tvmFV(N,I,PV,Pmt,[PpY],[CpY],[PmtAt]) ⇒ valor
Función financiera que calcula el valor futuro del dinero.
Nota: Los argumentos utilizados en las funciones de TVM se
describen en la tabla de argumentos de TVM, en la página 129.
Consulte también amortTbl(), en la página 7.
tvmI()
Catálogo >
tvmI(N,PV,Pmt,FV,[PpY],[CpY],[PmtAt]) ⇒ valor
Función financiera que calcula la tasa de interés anual.

tvmN()
Catálogo >
tvmN(I,PV,Pmt,FV,[PpY],[CpY],[PmtAt]) ⇒ valor
Función financiera que calcula el número de periodos de pago.
tvmPmt()
Catálogo >
tvmPmt(N,I,PV,FV,[PpY],[CpY],[PmtAt]) ⇒ valor
Función financiera que calcula la cantidad de cada pago.
tvmPV()
Catálogo >
tvmPV(N,I,Pmt,FV,[PpY],[CpY],[PmtAt]) ⇒ valor
Función financiera que calcula el valor presente del dinero.
Argumento Descripción Tipo de datos

de TVM*
N Número de periodos de pago número real
I Tasa de interés anual número real
PV Valor presente número real
Pmt Cantidad del pago número real
FV Valor futuro número real
PpY Pagos por año, predeterminado = 1 entero > 0
CpY Periodos compuestos por año, predeterminado = 1 entero > 0
PmtAt Pago adeudado al final o al principio de cada periodo predeterminado = final entero (0 = final, 1 =
principio)
* Estos nombres de argumento de valor temporal del dinero son similares a los nombres de variables de TVM (como tvm.pv y
tvm.pmt) que utiliza la herramienta Resolver finanzas de la aplicación Calculadora. No obstante, las funciones financieras no
almacenan sus valores de argumento o resultado en las variables de TVM.

TwoVar
Catálogo >
TwoVar X, Y[, [Frec] [, Categoría, Incluir]]
Calcula estadísticas de dos variables. El resumen de los resultados se

ser enteros | 0.
Categoría genera un dato sin valor para el elemento correspondiente
de todas las listas. Un elemento vacío en cualquiera de las listas
desde X1 hasta X20 genera un dato sin valor para el elemento
correspondiente de todas las listas. Para obtener más información
sobre los elementos vacíos, consulte la página 160.
salida
stat.v Media de los valores de x
Gx
stat.G Suma de los valores de x
Gx2
stat.G Suma de los valores de x2
stat.sx Desviación estándar de la muestra x
sx
stat.s Desviación estándar de población x
stat.n Número de puntos de datos
stat.w Media de los valores de y
Gy
stat.G Suma de los valores de y
Gy
stat.G 2 Suma de los valores de y2
stat.sy Desviación estándar de la muestra y
sy
stat.s Desviación estándar de población de y
Gxy
stat.G Suma de los valores de x·y

salida
stat.MinY Mínimo de valores de y
stat.Q1Y Primer cuartil de y
stat.MedY Mediana de y
stat.Q3Y Tercer cuartil de y
stat.MaxY Máximo de valores de y
v)2
G(x-v
stat.G Suma de cuadrados de desviaciones con respecto a la media de x
G(y-w
stat.G w) 2 Suma de cuadrados de desviaciones con respecto a la media de y
U
unitV()
Catálogo >
unitV(Vector1) ⇒ vector
Devuelve un vector fila o un vector columna, dependiendo de la
forma de Vector1.
Vector1 debe ser una matriz de una sola línea o de una sola columna.

mover el cursor.
unLock
Catálogo >
unLock Var1[, Var2] [, Var3] ...

unLock Var.
Desbloquea las variables o el grupo de variables especificado. No es

posible borrar ni modificar las variables bloqueadas.
Consulte Lock, en la página 68, y getLockInfo(), en la página53.

V
varPop()
Catálogo >
varPop(Lista[, Listafrecuencia]) ⇒ expresión

Devuelve la varianza de población de Lista.
Nota: Lista debe contener dos elementos como mínimo.
Si un elemento de cualquier lista está vacío (sin valor) se

desestimarán tanto el elemento en cuestión como el elemento
correspondiente en todas las demás listas. Para obtener más
varSamp()
Catálogo >
varSamp(Lista[, Listafrecuencia]) ⇒ expresión

Devuelve la varianza de la muestra de Lista.
Nota: Lista debe contener dos elementos como mínimo.
Si un elemento de cualquier lista está vacío (sin valor) se

correspondiente en todas las demás listas. Para obtener más
varSamp(Matriz1[, Matrizfrecuencia]) ⇒ matriz

Devuelve un vector fila que contiene la varianza de la muestra de
cada columna de Matriz1.
Nota: Matriz1 debe contener dos filas como mínimo.
Si un elemento de cualquier matriz está vacío (sin valor) se

correspondiente en todas las demás matrices. Para obtener más
W
when()
Catálogo >
when(Condición, Resultadoverdadero [, Resultadofalso][,

Resultadodesconocido])
⇒ expresión
Devuelve Resultadoverdadero, Resultadofalso o
Resultadodesconocido, dependiendo de que Condición sea
verdadero, falso o desconocido. Devuelve la entrada si el número de
argumentos es insuficiente para especificar el resultado correcto.
Omita tanto Resultadofalso como Reasultadodesconocido para
que la expresión se defina sólo en la región donde Condición sea
verdadero (true).
Utilice undef Resultadofalso para definir una expresión cuya
representación gráfica sea sobre un único intervalo.

when()
Catálogo >
when() resulta útil para definir funciones recursivas.
While
Catálogo >
While Condición
Bloque
EndWhile
Ejecuta las sentencias de Bloque siempre que Condición sea
verdadero.
Bloque puede ser una sentencia sencilla o una sucesión de sentencias
@
Enter (Intro).
“With”
|
Consulte (“con”), en la página 157.
X
xor
Catálogo >
ExprBooleana1 xor ExprBooleana2 ⇒ Expresión booleana

Devuelve “true” si ExpBooleana1 es verdadero y ExprBooleana2 es
falso, o viceversa.
Devuelve “false” si ambos argumentos son verdaderos o si ambos
son falsos. Devuelve una expresión booleana simplificada si no es
posible resolver como verdadero o falso uno cualquiera de los
argumentos.
Nota: Consulte or, en la página 85.

xor
Catálogo >
Entero1 xor Entero2 ⇒ entero En modo base Hex:

Importante: Cero, no la letra O.
Compara bit a bit dos números enteros mediante una operación xor.
Internamente, ambos enteros se convierten en números binarios con
signo de 64 bits. Cuando se comparan los bits correspondientes, el
resultado es 1 si cualquiera de ellos (pero no los dos) es 1; el
resultado será 0 si los dos bits son 0 o los dos bits son 1. El valor En modo base Bin:
obtenido representa el resultado de los bits y aparece conforme al
modo base especificado.
Los números enteros se pueden introducir en cualquier base. Para una contar el prefijo 0b). Una entrada hexadecimal puede tener
entrada binaria o hexadecimal es necesario utilizar el prefijo 0b o 0h, hasta 16 dígitos.
Nota: Consulte or, en la página 85.
Z
zeros()
Catálogo >
zeros(Expr, Var) ⇒ lista

zeros(Expr, Var=Conjetura) ⇒ lista
Devuelve una lista de los posibles valores reales para Var que
generan Expr=0. zeros() lo consigue calculando
exp4list(solve(Expr=0, Var), Var).
Para fines concretos es posible que el formato de resultado de zeros()

sea más conveniente que el de solve(). No obstante, el formato de
resultado de zeros() no puede expresar soluciones implícitas que
requieran desigualdades, o soluciones en las que no intervenga Var.
Nota: Consulte también cSolve(), cZeros() y solve().
zeros({Expr1, Expr2},
{VarOConjetura1, VarOConjetura2 [, … ]}) ⇒ matriz
Devuelve los posibles ceros reales para las expresiones algebraicas
simultáneas, donde cada VarOConjetura especifica una incógnita
cuyo valor se desea hallar.
Cada VarOConjetura debe tener la forma:
variable
–o–

zeros()
Catálogo >
Si todas las expresiones son polinomios y NO se ha especificado

ningún valor inicial, zeros() utiliza el método de eliminación léxica de
Gröbner/Buchberger para tratar de determinar todos los ceros reales.
Por ejemplo, suponga que tiene una circunferencia de radio r en el
origen y otra circunferencia de radio r centrada en el punto donde la
primera circunferencia corta el eje X positivo. Utilice zeros() para
hallar las intersecciones.
Como se ve por el valor de r en el ejemplo de la derecha, las

expresiones polinómicas simultáneas pueden tener variables extra
que carezcan de valores, pero representen valores numéricos dados
que se podrían sustituir más adelante.
Cada fila de la matriz resultante representa un cero alternativo, con
los componentes ordenados igual que en la lista de VarOConjetura.
Para extraer una fila, indexe la matriz por [fila].
Extraer fila 2:
Puede incluir incógnitas que no aparezcan en las expresiones. Por

ejemplo, puede incluir z como una incógnita que amplíe el ejemplo
anterior a dos cilindros paralelos de radio r que se corten entre sí. Los
ceros para el cilindro ilustran el modo en que las familias de ceros
pueden contener constantes arbitrarias de la forma ck, donde k sea
un sufijo entero de 1 a 255.
Para sistemas de polinomios, el tiempo de cálculo o el agotamiento

de la memoria pueden depender del orden con que el aparecen las
incógnitas. Si la opción de memoria inicial, o su paciencia, se agota,
pruebe a reorganizar las variables de las expresiones, la lista de
VarOConjetura o ambos elementos.
Si no incluye ningún valor inicial y alguna de las expresiones no es
polinómica en cualquier variable pero todas las expresiones son
lineales en todas las incógnitas, zeros() utiliza un método de
eliminación gaussiana para tratar de determinar todos los ceros
reales.

incógnitas, zeros() determina un cero como máximo utilizando un
método de iteración aproximada. Para ello, el número de las variables
de la solución debe ser igual al número de expresiones, y todas las
demás variables de las expresiones deben simplificarse en números.
Cada incógnita comienza en su valor inicial, si lo hubiera; de lo
contrario, comenzará en 0,0.
Utilice valores iniciales para buscar uno a uno los ceros adicionales.
Por convergencia, es probable que uno de los valores iniciales esté
bastante próximo a cero.

zInterval
Catálogo >
zInterval s,Lista[,Frec[,NivelC]]

zInterval s,v,n [,NivelC]

Calcula un intervalo z de confianza. El resumen de los resultados se
160.
salida
stat.CLower, stat.CUpper Intervalo de confianza para una media de población desconocida
stat.x Media de muestra de la secuencia de datos a partir de la distribución aleatoria normal
stat.sx Desviación estándar de la muestra
stat.n Longitud de la secuencia de datos con media de la muestra
stat.s Desviación estándar de población conocida para la sucesión de datos de Lista
zInterval_1Prop
Catálogo >
zInterval_1Prop x,n [,NivelC]
Calcula un intervalo z de confianza de una proporción. El resumen de

los resultados se guarda en la variable stat.results. (Consulte la
página 116.)
x es un entero no negativo.
Para obtener información sobre el efecto de los elementos vacíos en
una lista, consulte “Elementos vacíos (sin valor)” en la página 160.
salida
stat.Ç Proporción de éxitos calculada
stat.n Número de muestras en las sucesiones de datos

zInterval_2Prop
Catálogo >
zInterval_2Prop x1,n1,x2,n2[,NivelC]
Calcula un intervalo z de confianza de dos proporciones. El resumen

de los resultados se guarda en la variable stat.results. (Consulte la
página 116.)
x1 y x2 son enteros no negativos.
160.
salida
stat.ÇDiff Diferencia entre proporciones calculada
stat.Ç1 Primera proporción estimada de la muestra
stat.Ç2 Segunda proporción estimada de la muestra
stat.n1 Tamaño de la muestra en la sucesión de datos uno
stat.n2 Tamaño de la muestra en la sucesión de datos dos
zInterval_2Samp
Catálogo >
zInterval_2Samp s1,s2
,Lista1,Lista2[,Frec1[,Frec2,[NivelC]]]

zInterval_2Samp s1,s2,v1,n1,v2,n2[,NivelC]
Calcula un intervalo z de confianza de dos muestras. El resumen de
los resultados se guarda en la variable stat.results. (Consulte la
página 116.)
160.
salida
stat.x1-x2 Media de la muestra de las sucesiones de datos derivadas de una distribución aleatoria normal
stat.x1, stat.x2 Media de la muestra de las sucesiones de datos derivadas de una distribución aleatoria normal
stat.sx1, stat.sx2 Desviaciones estándar de la muestra para Lista 1 y Lista 2
stat.n1, stat.n2 Número de muestras en las sucesiones de datos

salida
stat.r1, stat.r2 Desviaciones estándar de población conocida para las sucesiones de datos de Lista 1 y Lista 2
zTest
Catálogo >
zTest m0,s,Lista,[Frec[,Hipótesis]]
zTest m0,s,v,n[,Hipótesis]
Realiza un test z con la frecuencia indicada en Listafrecuencia.
(Consulte la página 116.)
Prueba H0: m = m0, frente a una de las alternativas siguientes:
Para Ha: m < m0, defina Hipótesis<0

Para Ha: m ƒ m0 (predeterminado), defina Hipótesis=0
Para Ha: m > m0, defina Hipótesis>0

160.
salida
stat.z (x N m0) / (s / sqrt(n))
stat.P Value Probabilidad mínima a la que se puede rechazar la hipótesis nula
stat.x Media de muestra de la sucesión de datos de Lista
stat.sx Desviación estándar de la sucesión de datos. Resultado sólo para entrada de Datos.
zTest_1Prop
Catálogo >
zTest_1Prop p0,x,n[,Hipótesis]
Realiza un test z para una proporción. El resumen de los resultados se

x es un entero no negativo.
Prueba H0: p = p0 frente a una de las alternativas siguientes:
Para Ha: p > p0, defina Hipótesis>0

Para Ha: p ƒ p0 (predeterminado), defina Hipótesis=0
Para Ha: p < p0, defina Hipótesis<0

160.

salida
stat.p0 Proporción de población hipotética
stat.z Valor normal estándar calculado para la proporción
stat.Ç Proporción de la muestra estimada
zTest_2Prop
Catálogo >
zTest_2Prop x1,n1,x2,n2[,Hipótesis]
Calcula un test z de dos proporciones. El resumen de los resultados se

x1 y x2 son enteros no negativos.
Prueba H0: p1 = p2 frente a una de las alternativas siguientes:
Para Ha: p1 > p2, defina Hipótesis>0

Para Ha: p1 ƒ p2 (predeterminado), defina Hipótesis=0
Para Ha: p < p0, defina Hipótesis<0

160.
salida
stat.z Valor normal estándar calculado para la diferencia de las proporciones
stat.Ç1 Primera proporción estimada de la muestra
stat.Ç2 Segunda proporción estimada de la muestra
stat.Ç Proporción de la muestra sondeada estimada
stat.n1, stat.n2 Número de muestras tomadas en los intentos 1 y 2

zTest_2Samp
Catálogo >
zTest_2Samp s1,s2 ,Lista1,Lista2[,Frec1[,Frec2[,Hipótesis]]]

zTest_2Samp s1,s2,v1,n1,v2,n2[,Hipótesis]
Calcula un test z de dos muestras. El resumen de los resultados se
Prueba H0: m1 = m2, frente a una de las alternativas siguientes:
Para Ha: m1 < m2, defina Hipótesis<0

Para Ha: m1 ƒ m2 (predeterminado), defina Hipótesis=0
Para Ha: m1 > m2, Hipótesis>0

160.
salida
stat.z Valor normal estándar calculado para la diferencia de las medias
stat.x1, stat.x2 Medias de la muestra de las sucesiones de datos en Lista1 y Lista2
stat.sx1, stat.sx2 Desviaciones estándar de las muestras en las sucesiones de datos de Lista1 y Lista2

Símbolos
+ (suma) Tecla +
Expr1 + Expr2 ⇒ expresión
Devuelve la suma de dos argumentos.
Lista1 + Lista2 ⇒ lista

Matriz1 + Matriz2 ⇒ matriz
Devuelve una lista (o una matriz) con las sumas correspondientes de
los elementos contenidos en Lista1 y Lista2 (o Matriz1 y Matriz2).
Las dimensiones de los argumentos deben ser iguales.
Expr + Lista1 ⇒ lista

Lista1 + Expr ⇒ lista
Devuelve una lista con las sumas de Expr y cada elemento de Lista1.
Expr + Matriz1 ⇒ matriz

Matriz1 + Expr ⇒ matriz
Devuelve una matriz con Expr sumado a cada elemento de la
diagonal de Matriz1. Matriz1 debe ser cuadrada.
Nota: Utilice .+ (punto más) para sumar una expresión a cada
elemento.
N(resta) Tecla -
Expr1 N Expr2 ⇒ expresión
Devuelve Expr1 menos Expr2.
Lista1 N Lista2 ⇒ lista

Matriz1 N Matriz2 ⇒ matriz
Resta cada elemento de Lista2 (o Matriz2) del elemento
correspondiente de Lista1 (o Matriz1), y devuelve el resultado.
Las dimensiones de los argumentos deben ser iguales.
Expr N Lista1 ⇒ lista
Lista1 N Expr ⇒ lista
Resta cada elemento de Lista1 de Expr o resta Exprde cada
elemento de Lista1, y devuelve una lista de resultados.

N(resta) Tecla -
Expr N Matriz1 ⇒ matriz
Matriz1 N Expr ⇒ matriz
Expr N Matriz1 devuelve una matriz de Expr veces la matriz de

identidad menos Matriz1. Matriz1 debe ser cuadrada.
Matriz1 N Expr devuelve una matriz de Expr veces la matriz de

identidad restada de Matriz1. Matriz1 debe ser cuadrada.
Nota: Utilice .N (punto menos) para restar una expresión de cada
elemento.
·(multiplicación) Tecla r
Expr1 ·Expr2 ⇒ expresión
Devuelve el producto de dos argumentos.
Lista1·Lista2 ⇒ lista
Devuelve una lista con los productos correspondientes de los
elementos de Lista1 y Lista2.
Las dimensiones de las listas deben ser iguales.
Matriz1 ·Matriz2 ⇒ matriz

Devuelve la matriz producto de Matriz1 y Matriz2.
El número de las columnas de Matriz1 debe ser igual que el número
de filas de Matriz2.
Expr ·Lista1 ⇒ lista

Lista1 ·Expr ⇒ lista
Devuelve una lista con los productos de Expr y cada elemento de
Lista1.
Expr ·Matriz1 ⇒ matriz

Matriz1 ·Expr ⇒ matriz
Devuelve una matriz con los productos de Expr y cada elemento de
Matriz1.
Nota: Utilice .·(punto multiplicación) para multiplicar una

expresión por cada elemento.
à (división)
Tecla p
Expr1 à Expr2 ⇒ expresión
Devuelve el cociente de Expr1 dividido por Expr2.
Nota: Consulte también Plantilla de fracción, en la página 1.

à (división)
p
Tecla
Lista1 à Lista2 ⇒ lista
Devuelve una lista con los cocientes de Lista1 dividido por Lista2.
Las dimensiones de las listas deben ser iguales.
Expr à Lista1 ⇒ lista
Lista1 à Expr ⇒ lista
Devuelve una lista con los cocientes de Expr dividido por Lista1
o Lista1 dividido por Expr.
Matriz1 à Expr ⇒ matriz
Devuelve una matriz con los cocientes de Matriz1àExpr.

Nota: Utilice . / (punto división) para dividir una expresión por cada
elemento.
^ (potencia) l
Tecla
Expr1 ^ Expr2 ⇒ expresión
Lista1 ^ Lista2 ⇒ lista
Devuelve el primer argumento elevado al segundo argumento.
Nota: Consulte también Plantilla de exponente, en la página 1.
Para una lista, devuelve los elementos de Lista1 elevados a los

elementos correspondiente de Lista2.
En el dominio real, las potencias de fracción que tengan exponentes
fraccionarios con denominadores impares utilizan las ramas reales
frente a las ramas principales del modo complejo.
Expr ^ Lista1 ⇒ lista
Devuelve Expr elevado a los elementos de Lista1.
Lista1 ^ Expr ⇒ lista

Devuelve los elementos de Lista1 elevados a Expr.
Matrizcuadrada1 ^ entero ⇒ matriz

DevuelveMatrizcuadrada1 elevada a entero.
Matrizcuadrada1 debe ser una matriz cuadrada.
Si entero = ë1, calcula la matriz inversa.
Si entero < ë1, calcula la matriz inversa elevada al correspondiente
exponente positivo.

x2 (cuadrado) Tecla q
Expr12 ⇒ expresión
Devuelve el cuadrado de un argumento.
Lista12 ⇒ lista
Devuelve una lista con los cuadrados de los elementos de Lista1.
Matrizcuadrada12 ⇒ matriz
Devuelve la matriz cuadrada de Matrizcuadrada1. El resultado no es
igual que calcular el cuadrado de cada elemento. Utilice .^2 para
calcular el cuadrado de cada elemento.
.+ (punto suma) Teclas ^+

Matriz1 .+ Matriz2 ⇒ matriz
Expr .+ Matriz1 ⇒ matriz
Matriz1 .+ Matriz2 devuelve una matriz que es la suma de cada par
de elementos de Matriz1 y Matriz2.
Expr .+ Matriz1 devuelve una matriz que es la suma de Expr y cada
elemento de Matriz1.
.. (punto resta) Teclas ^-

Matriz1 .N Matriz2 ⇒ matriz
Expr .NMatriz1 ⇒ matriz
Matriz1 .NMatriz2 devuelve una matriz que es la diferencia entre

cada par de elementos correspondientes de Matriz1 y Matriz2.
Expr .NMatriz1 devuelve una matriz que es la diferencia entre Expr
y cada elemento de Matriz1.
.·(punto multiplic.) Teclas ^r

Matriz1 .· Matriz2 ⇒ matriz
Expr .·Matriz1 ⇒ matriz
Matriz1 .· Matriz2 devuelve una matriz que es el producto de cada

par de elementos correspondiente de Matriz1 y Matriz2.
Expr .· Matriz1 devuelve una matriz de los productos de Expr y

cada elemento de Matriz1.

. / (punto división) Teclas ^p
Matriz1 . / Matriz2 ⇒ matriz
Expr . / Matriz1 ⇒ matriz
Matriz1 ./ Matriz2 devuelve una matriz que es el cociente de cada
par de elementos correspondientes de Matriz1 y Matriz2.
Expr ./ Matriz1 devuelve una matriz que es el cociente de Expr y
cada elemento de Matriz1.
.^ (punto de potencia) Teclas ^l

Matriz1 .^ Matriz2 ⇒ matriz
Expr . ^ Matriz1 ⇒ matriz
Matriz1 .^ Matriz2 devuelve una matriz en la que cada elemento de
Matriz2 es el exponente del elemento correspondiente de Matriz1.
Expr .^ Matriz1 devuelve una matriz en la que cada elemento de

Matriz1 es el exponente para Expr.
ë(negación) Tecla v
ëExpr1 ⇒ expresión
ëLista1 ⇒ lista
ëMatriz1 ⇒ matriz
Devuelve el opuesto de un argumento.
Para una lista o una matriz, devuelve los opuestos de todos los
elementos.
En modo base Bin:
Si el argumento es un entero binario o hexadecimal, la negación es el
Importante: Cero, no la letra O.
complemento a dos.

mover el cursor.
% (porcentaje) Teclas /k
Expr1 % ⇒ expresión
Lista1 % ⇒ lista Pulse Ctrl+Enter (Intro) /· (Macintosh®:
Matriz1 % ⇒ matriz “+Enter) para calcular:
Devuelve
Para una lista o una matriz, devuelve una lista o una matriz en la que
cada elemento está dividido por 100. Pulse Ctrl+Enter (Intro) /· (Macintosh®:

= (igual) Tecla =
Expr1 = Expr2 ⇒ Expresión booleana Función de ejemplo que utiliza símbolos matemáticos: =, ƒ, <,
Lista1 = Lista2 ⇒ Lista booleana {, >, ‚
Matriz1 = Matriz2 ⇒ Matriz booleana
Devuelve “true” si se determina que Expr1 es igual que Expr2.
Devuelve “false” si se determina que Expr1 no es igual que Expr2.
Cualquier otro resultado devuelve una forma simplificada de la
ecuación.
Para las listas y las matrices devuelve una lista o una matriz cuyos
elementos son el resultado de la comparación de los elementos
correspondientes.
@
Enter (Intro).
Resultado de representar gráficamente g(x)
ƒ (no igual) Teclas /=

Expr1 ƒ Expr2 ⇒ Expresión booleana Consulte el ejemplo “=” (igual).
Lista1 ƒ Lista2 ⇒ Lista booleana
Matriz1 ƒ Matriz2 ⇒ Matriz booleana
Devuelve “true” si se determina que Expr1 no es igual que Expr2.
Devuelve “false” si se determina que Expr1 es igual que Expr2.
ecuación.
Para las listas y las matrices, devuelve una lista o una matriz cuyos
correspondientes.
escriba /=

< (menor que) Teclas /=
Expr1 < Expr2 ⇒ Expresión booleana Consulte el ejemplo “=” (igual).
Lista1 < Lista2 ⇒ Lista booleana
Matriz1 < Matriz2 ⇒ Matriz booleana
Devuelve “true” si se determina que Expr1 es menor que Expr2.
Devuelve “false” si se determina que Expr1 es mayor o igual que
Expr2.
ecuación.
correspondientes.
{ (menor o igual que) Teclas /=

Expr1 { Expr2 ⇒ Expresión booleana Consulte el ejemplo “=” (igual).
Lista1 { Lista2 ⇒ Lista booleana
Matriz1 { Matriz2 ⇒ Matriz booleana
Devuelve “true” si se determina que Expr1 es menor o igual que
Expr2.
Devuelve “false” si se determina que Expr1 es mayor que Expr2.
ecuación.
correspondientes.
escriba <=
> (mayor que) Teclas /=

Expr1 > Expr2 ⇒ Expresión booleana Consulte el ejemplo “=” (igual).
Lista1 > Lista2 ⇒ Lista booleana
Matriz1 > Matriz2 ⇒ Matriz booleana
Devuelve “true” si se determina que Expr1 es mayor que Expr2.
Devuelve “false” si se determina que Expr1 es menor o igual que
Expr2.
ecuación.
correspondientes.

| (mayor o igual que) Teclas /=
Expr1 | Expr2 ⇒ Expresión booleana Consulte el ejemplo “=” (igual).
Lista1 | Lista2 ⇒ Lista booleana
Matriz1 | Matriz2 ⇒ Matriz booleana
Devuelve “true” si se determina que Expr1 es mayor o igual que
Expr2.
Devuelve “false” si se determina que Expr1 es menor que Expr2.
ecuación.
correspondientes.
escriba >=
! (factorial) Tecla º
Expr1! ⇒ expresión
Lista1! ⇒ lista
Matriz1! ⇒ matriz
Devuelve el factorial del argumento.
Para una lista o matriz, devuelva una lista o una matriz con los
factoriales de los elementos.
& (añadir) Teclas /k

Cadena1 & Cadena2 ⇒ cadena
Devuelve una cadena de texto que es Cadena2 añadida a Cadena1.

d() (derivada)
Catálogo >
d(Expr1, Var [,Orden]) ⇒ expresión

d(Lista1,Var [,Orden]) ⇒ lista
d(Matriz1,Var [,Orden]) ⇒ matriz
Devuelve la primera derivada del primer argumento con respecto a la
variable Var.
Orden, si se incluye, debe ser un número entero. Si la orden es menor
que cero, el resultado será una antiderivada.
escriba derivative(...).
d() no sigue el mecanismo de cálculo normal que simplifica al
máximo sus argumentos y aplica luego la definición de función a
dichos argumentos simplificados. En su lugar, d() realiza los pasos
siguientes:
1. Simplifica el segundo argumento sólo hasta el extremo en que
no se genera una no variable.
2. Simplifica el primer argumento sólo hasta el extremo en que se
recupera cualquier valor almacenado para la variable
determinada por el paso 1.
3. Determina la derivada simbólica del resultado del paso 2 con
respecto a la variable del paso 1.
Si la variable del paso 1 tiene un valor almacenado o un valor
especificado por un operador "con" (|), sustituye dicho valor por el
resultado obtenido en el paso 3.
Nota: Consulte también Primera derivada, en la página 5;
Segunda derivada, en la página 5; o bien
Derivada enésima, en la página 5.
‰() (integral) Catálogo >
‰(Expr1, Var[, Inferior, Superior]) ⇒ expresión

‰(Expr1, Var[, Constante]) ⇒ expresión
Devuelve la integral de Expr1 con respecto a la variable Var de
Inferior a Superior.
Nota: Consulte también Plantilla de integral definida o
indefinida, en la página 5.
escriba integral(...).
Devuelve una antiderivada si se omiten Inferior y Superior. Se omite
una constante de integración simbólica a menos que se facilite el
argumento de Constante.
Todas las antiderivadas válidas se pueden diferenciar en una

constante numérica. Una constante de ese tipo debe ser distinguible,
especialmente cuando la antiderivada contiene logaritmos o
funciones trigonométricas inversas. Y lo que es más, las expresiones
de constantes definidas a trozos se suelen añadir para hacer que una
antiderivada sea válida en un intervalo más grande que la fórmula
habitual.

‰() (integral) Catálogo >
‰() se devuelve a sí mismo para trozos de Expr1 que no se pueden

determinar como una combinación finita explícita de sus funciones
integradas y de operadores.
Cuando se facilitan los valores para Inferior y Superior, se intenta
localizar cualquier discontinuidad o derivada discontinua en el
intervalo definido por Inferior < Var < Superior y subdividir el
intervalo en dichos lugares.
Para el ajuste Auto del modo Auto or Approximate, la
integración numérica se utiliza en los lugares aplicables cuando no es
posible determinar una antiderivada o un extremo.
Para el ajuste Aproximado, se intenta primero la integración
numérica, siempre que sea aplicable. Se intenta conseguir una
antiderivada sólo cuando no es posible aplicar la integración
numérica o la misma falla. “+Enter) para calcular:
‰() se puede anidar para generar integrales múltiples. Los límites de la

integración pueden depender de las variables de integración que
quedan fuera de las mismas.
Nota: Consulte también nInt(), en la página 80.
‡() (raíz cuadrada) Teclas /q

‡ (Expr1) ⇒ expresión
‡ (Lista1) ⇒ lista
Devuelve la raíz cuadrada del argumento.
Para una lista, devuelve las raíces cuadradas de todos los elementos
de Lista1.
escriba sqrt(...)
Nota: Consulte también Plantilla de raíz cuadrada, en la página 1.

Π() (prodSeq) Catálogo >
Π(Expr1, Var, Inferior, Superior) ⇒ expresión

escriba prodSeq(...).
Calcula Expr1 para cada valor de Var de Inferior a Superior, y
devuelve el producto de los resultados.
Nota: Consulte también Plantilla de producto (Π), en la página 4.
Π(Expr1, Var, Inferior, InferiorN1) ⇒ 1

Π(Expr1, Var, Inferior, Superior)
⇒ 1/Π(Expr1, Var, Superior+1, InferiorN1) si Superior <
InferiorN1
Las fórmulas de producto utilizadas se basan en la referencia
siguiente:
Ronald L. Graham, Donald E. Knuth y Oren Patashnik. Concrete
Mathematics: A Foundation for Computer Science. Reading,
Massachusetts: Addison-Wesley, 1994.
G() (sumSeq) Catálogo >
G(Expr1, Var, Inferior, Superior) ⇒ expresión

escriba sumSeq(...).
Calcula Expr1 para cada valor de Var de Inferior a Superior, y
devuelve la suma de los resultados.
Nota: Consulte también Plantilla de suma, en la página 4.

G() (sumSeq) Catálogo >
G(Expr1, Var, Inferior, InferiorN1) ⇒ 0

G(Expr1, Var, Inferior, Superior)
⇒ ëG(Expr1, Var, Superior+1, InferiorN1) si Superior <
InferiorN1
Las fórmulas de sumatorio utilizadas se basan en la referencia
siguiente:
Ronald L. Graham, Donald E. Knuth y Oren Patashnik. Concrete
Mathematics: A Foundation for Computer Science. Reading,
Massachusetts: Addison-Wesley, 1994.
GInt() Catálogo >
GInt(NPmt1, NPmt2, N, I, PV ,[Pmt], [FV], [PpY], [CpY],

[PmtAt], [redondValor]) ⇒ valor
GInt(NPmt1,NPmt2,amortTable) ⇒ valor
Función de amortización que calcula la suma de los intereses durante
un rango de pagos especificado.
NPmt1 y NPmt2 define los límites inicial y final del rango de los
pagos.
N, I, PV, Pmt, FV, PpY, CpY y PmtAt se describen en la tabla de los
FV=0.
predeterminado = 2.
GInt(NPmt1,NPmt2,amortTable) calcula la suma de los intereses
basada en la tabla de amortización amortTable. El argumento
amortTable debe ser una matriz en la forma descrita en la sección
amortTbl(), en la página 7.
Nota: Consulte también GPrn(), a continuación, y Bal(), en la

página 13.

GPrn() Catálogo >
GPrn(NPmt1, NPmt2, N, I, PV, [Pmt], [FV], [PpY], [CpY],

[PmtAt], [redondValor]) ⇒ valor
GPrn(NPmt1,NPmt2,amortTable) ⇒ valor
Función de amortización que calcula la suma de principal durante un
rango de pagos especificado.
NPmt1 y NPmt2 define los límites inicial y final del rango de los
pagos.
N, I, PV, Pmt, FV, PpY, CpY y PmtAt se describen en la tabla de los
FV=0.
predeterminado = 2.
GPrn(NPmt1,NPmt2,amortTable) calcula la suma de los pagos de
principal según la tabla de amortización amortTable. El argumento
amortTable debe ser una matriz en la forma descrita en la sección
amortTbl(), en la página 7.
Nota: Consulte también GInt(), anterior, y Bal(), en la página 13.
# (dirección) Teclas /k
# NombreCadenavar
Se refiere a la variable cuyo nombre es NombreCadenavar. Permite

utilizar cadenas para crear nombres de variable desde el interior de Crea o hace referencia a la variable xyz .
una función.
Devuelve el valor de la variable (r) cuyo nombre se encuentra

almacenado en la variable s1.
í (notación científica) Tecla i

exponente Ede mantisa
Permite introducir un número en notación científica. El número se
interpreta como mantisa × 10exponente.
Sugerencia: Si desea introducir una potencia de 10 sin generar un
resultado de valor decimal, utilice 10^entero.
escriba @E. por ejemplo, escriba 2.3@E4 para introducir 2.3E4.

g
(grado centesimal) Tecla ¹
Expr1g ⇒ expresión En el modo de ángulo en grados, grados centesimales o
radianes:
Lista1g ⇒ lista
Matriz1g ⇒ matriz
Esta función es un medio de especificar un ángulo en grados
centesimales cuando se trabaja en el modo de ángulo en grados o
radianes.
En el modo de ángulo en radianes, multiplica Expr1 por p/200.
En el modo de ángulo en grados, multiplica Expr1 por g/100.
En el modo de ángulo en grados centesimales, devuelve Expr1 sin
cambios.
Nota: Si desea insertar este símbolo con el teclado del ordenador,
escriba @g.
ô(radián) Tecla ¹
Expr1ô ⇒ expresión En el modo de ángulo en grados, grados centesimales o
Lista1ô ⇒ lista radianes:
Matriz1ô ⇒ matriz
Esta función es un medio de especificar un ángulo en radianes cuando
se trabaja en el modo de ángulo en grados o grados centesimales.
En el modo de ángulo en grados, multiplica el argumento por 180/p.
En el modo de ángulo en radianes, devuelve el argumento sin
cambios.
En el modo de ángulo en grados centesimales, multiplica el
argumento por 200/p.
Sugerencia: Utilice ôsi desea forzar los radianes en una definición de

función al margen del modo que estuviera activo cuando se utilice la
función.
escriba @r.
¡ (grado) Tecla ¹
Expr1¡ ⇒ expresión En el modo de ángulo en grados, grados centesimales o
Lista1¡ ⇒ lista radianes:
Matriz1¡ ⇒ matriz
Esta función es un medio de especificar un ángulo en grados cuando
se trabaja en modo de ángulo en grados centesimales o radianes.
En el modo de ángulo en radianes, multiplica el argumento por p/
180.
En el modo de ángulo en grados, devuelve el argumento sin cambios.
En el modo de ángulo en grados centesimales, multiplica el
argumento por 10/9.
escriba @d.

¡, ', '' (grados/minutos/segundos) Teclas /k
gg¡mm'ss.ss'' ⇒ expresión En el modo de ángulo en grados:
gg Número positivo o negativo

mm Número no negativo
ss.ss Número no negativo
Devuelve gg+(mm/60)+(ss.ss/3600).
Este formato de entrada en base -60 permite:
• Introducir un ángulo en grados/minutos/segundos sin tener en
cuenta el modo de ángulo actual.
• Introduce la hora en formato de horas/minutos/segundos.
Nota: A continuación del valor de ss.ss introduzca dos apóstrofos
(''), no un símbolo de comillas (").
 (ángulo) Teclas /k
[Radio,q_Ángulo] ⇒ vector En el modo de ángulo en radianes y el formato de vector
(entrada polar) definido en:
rectangular
[Radio,q_Ángulo,Z_Coordenada] ⇒ vector
(entrada cilíndrica)
[Radio,q_Ángulo,q_Ángulo] ⇒ vector
(entrada esférica)
Devuelve las coordenadas como un vector dependiente de la cilíndrico
configuración de modo elegida para el formato del vector:
rectangular, cilíndrico o esférico.
escriba @<.
esférico
(Magnitud  Ángulo) ⇒ complexValue En el modo de ángulo en radianes y formato complejo

(entrada polar) rectangular:
Introduce un valor complejo en formato polar (rq). El Ángulo se

interpreta según el modo de ángulo actual.

' (primo) Tecla º

variable '
variable ''
Introduce un símbolo de número primo en una ecuación diferencial.
Un símbolo de un número primo denota una ecuación diferencial de
primer grado, dos símbolos identifican una de segundo grado, y así.

_ (carácter de subrayado como elemento vacío) Consulte “Elementos vacíos (sin valor)” , en la página 160.
_ (carácter de subrayado como designador de

unidad)
Teclas /_
Expr_Unidad
Designa las unidades para una Expr. Todos los nombres de unidades
deben comenzar por un signo de subrayado. Nota: Busque en el catálogo el símbolo de conversión, 4. Haga
Puede utilizar unidades predefinidas para crear las suyas propias.

clic en , y luego en Math Operators (Operadores
Para ver una lista de unidades predefinidas, abra el Catálogo y
matemáticos).
muestre la ficha Unidades de conversión. Puede seleccionar los
nombres de las unidades del catálogo o escribirlos directamente.
Variable_ Suponiendo que z esté sin definir:
Si una Variable no tiene un valor, se considerará que representa un
número complejo. De forma predeterminada, si la variable carece del
símbolo _ , se considerará como un valor real.
Si la Variable tiene un valor, se ignorará el signo _ y la Variable
conservará su tipo de datos original.
Nota: Es posible guardar un número complejo en una variables sin
utilizar _ . No obstante y para obtener los mejores resultados en los
cálculos, como cSolve() y cZeros(), se aconseja utilizar _.
4 (convertir) Teclas /k
Expr_Unidad1 4 _Unidad2 ⇒ Expr_Unidad2
Convierte una expresión de una unidad a otra.
El carácter de subrayado, _, designa las unidades. Las unidades
deben ser de la misma categoría, por ejemplo, Longitud o Área.
Para ver una lista de unidades predefinidas, abra el Catálogo y
muestre la ficha Unidades de conversión:
• Puede seleccionar un nombre de unidad de la lista.
• También puede seleccionar el operador de conversión, 4, en la
parte superior de la lista.
Si lo desea puede escribir los nombres manualmente. Para escribir
“_” con la unidad portátil, pulse /_.
Nota: Para convertir las unidades de temperatura, utilice tmpCnv() y
@tmpCnv(). El operador de conversión 4 no es válido para las
unidades de temperatura.
10^()
Catálogo >
10^ (Expr1) ⇒ expresión

10^ (Lista1) ⇒ lista
Devuelve el número 10 elevado al argumento.
Para una lista, devuelve 10 elevado a los elementos de Lista1.
10^(Matrizcuadrada1) ⇒ Matrizcuadrada
Devuelve el valor de 10 elevado a Matrizcuadrada1. El resultado no
es igual que calcular el valor de 10 elevado a cada elemento. Para
obtener más información sobre el método de cálculo, consulte cos().

^ê (inverso de un valor)
Catálogo >
Expr1 ^ê ⇒ expresión
Lista1 ^ê ⇒ lista
Devuelve el inverso del valor del argumento.
Para una lista, devuelve el inverso de los valores de los elementos de
Lista1.
Matrizcuadrada1 ^ê ⇒ Matrizcuadrada
Devuelve el inverso de Matrizcuadrada1.
Matrizcuadrada1 debe ser una matriz cuadrada no singular.
| (“with”) Teclas /k
Expr | ExpBooleana1 [and ExpBooleana2]...
El símbolo “with” (|) se utiliza como un operador binario. El operando
situado a la izquierda de | es una expresión. El operando situado a la
derecha de | especifica una o más relaciones que tienen como
finalidad afectar la simplificación de la expresión. Las distintas
relaciones situadas después de | deben unirse mediante un operador
lógico “and”.
El operador “con” permite tres tipos de funcionamiento básicos:
sustituciones, limitación de intervalos y exclusiones.
Las sustituciones adoptan la forma de una igualdad, como x=3 o
y=sin(x). Para aumentar su eficacia, el extremo izquierdo debería ser
una variable sencilla. Expr | Variable = valor sustituirá a valor en
cada ocurrencia de Variable en Expr.
La limitación de intervalos toma la forma de una o más desigualdades

unidas mediante operadores lógicos “and”. También permiten
realizar simplificaciones que, de otro modo, serían no válidas o no
calculables.
Las exclusiones utilizan los operadores relacionales “no igual que” (/

= o ƒ) para excluir un valor específico de una consideración. Sirven
principalmente para excluir una solución exacta cuando se utiliza
cSolve(), cZeros(), fMax(), fMin(), solve(), zeros(), y así.

& (almacenar) Tecla /h
Expr & Var
Lista & Var
Matriz & Var
Expr & Función(Param1,...)
Lista & Función(Param1,...)
Matriz & Función(Param1,...)
Si la variable Var no existe, la crea y la inicializa para Expr, Lista o
Matriz.
Si la variable Var ya existe y no está bloqueada ni protegida, sustituye
su contenido por el de Expr, Lista o Matriz.
Sugerencia: Si pretende realizar cálculos simbólicos utilizando
variables no definidas, procure no guardar nada en las variables de
una sola letra que use con más frecuencia, como a, b, c, x, y, z, y así.
escriba =: como método abreviado. Por ejemplo, escriba pi/
4 =: myvar.
:= (asignar) Teclas /t
Var := Expr
Var := Lista
Var := Matriz
Función(Param1,...) := Expr
Función(Param1,...) := Lista
Función(Param1,...) := Matriz
Si la variable Var no existe, crea Var y la inicializa para Expr, Lista o
Matriz.
Si la variable Var ya existe y no está bloqueada ni protegida, sustituye
su contenido por el de Expr, Lista o Matriz.
Sugerencia: Si pretende realizar cálculos simbólicos utilizando
variables no definidas, procure no guardar nada en las variables de
una sola letra que use con más frecuencia, como a, b, c, x, y, z, y así.
© (comentario) Teclas /k
© [texto]
© procesa el contenido de texto como una línea de comentarios y

permite anotar las funciones y programas creados por el usuario.
© puede estar al principio o en cualquier lugar de la línea. Cualquier
contenido situado a la derecha de ©, y hasta el final de la línea, es un
comentario.
Enter (Intro).

0b, 0h Teclas 0B, Teclas 0H
0b NúmeroBinario En modo base Dec:
Identifica un número como binario o hexadecimal, respectivamente.

Para introducir un número binario o hex, introduzca el prefijo 0b o 0h
sea cual sea el modo de la base. Si no se indica un prefijo, el número En modo base Bin:
se considera como decimal (base 10).
Los resultados se muestran conforme al modo de la base.
En modo base Hex:

Elementos vacíos (sin valor)
Al analizar datos reales puede que no siempre se disponga de un conjunto de datos completo.
TI-Nspire™ CAS permite utilizar elementos de datos vacíos, o sin valor, para que pueda
continuar con el siguiente conjunto de datos completo en lugar de tener que comenzar de
nuevo o descartar los casos no completos.
Encontrará un ejemplo de datos que contienen elementos vacíos en el capítulo Listas y Hojas
de cálculo, bajo el apartado “Representación gráfica de los datos de una hoja de cálculo”.
La función delVoid() permite eliminar elementos vacíos de una lista. La función isVoid() permite
comprobar la existencia de un elemento vacío. Para obtener más información, consulte
delVoid(), en la página 35, e isVoid(), en la página 60.
Nota: Para introducir un elemento vacío manualmente en una expresión matemática, escriba
“_” o la palabra clave void. Cuando se calcula la expresión, la palabra clave void se convierte
automáticamente en el símbolo “_”. Para escribir “_” en la unidad portátil, pulse / _.
Cálculos que incluyen elementos sin valor

La mayoría de los cálculos que incluyen una entrada sin valor generan
un resultado sin valor. Consulte los casos especiales, a continuación.
Listas de argumentos que contienen elementos sin valor

Las funciones y órdenes siguientes desestiman (omiten) los elementos
sin valor que se encuentran en las listas de argumentos.
count, countIf, cumulativeSum, freqTable4list, frequency,
max, mean, median, product, stDevPop, stDevSamp, sum,
sumIf, varPop y varSamp, así como los cálculos de regresiones,
OneVar, TwoVar y estadística FiveNumSummary, intervalos de
confianza y tests estadísticos
SortA y SortD desplazan todos los elementos sin valor del primer
argumento a la parte inferior.

Listas de argumentos que contienen elementos sin valor(continued)
En las regresiones, un elemento sin valor en una lista X o Y introduce
un elemento sin valor para el elemento correspondiente del residuo.
Una categoría omitida en una regresión introduce un elemento sin

valor para el elemento correspondiente del residuo.
Una frecuencia de 0 en las regresiones introduce un elemento sin

valor para el elemento correspondiente del residuo.

Métodos abreviados para introducir expresiones
matemáticas
Los métodos abreviados permiten introducir elementos o expresiones matemáticas
escribiéndolos directamente con el teclado en lugar de seleccionarlos en el catálogo o la paleta
de símbolos. Por ejemplo, para introducir la expresión ‡6, puede escribir sqrt(6) en la línea de
entrada. Cuando pulse ·, la expresión sqrt(6) aparecerá como ‡6. Algunos métodos
abreviados pueden introducirse tanto con la unidad portátil como con el teclado del
ordenador, mientras que para otros es preferible utilizar el teclado del ordenador.
Con el teclado de la unidad portátil o el ordenador
Para introducir: Escriba:
p pi
q theta
ˆ infinity
 <=
‚ >=
ƒ /=
& (operador de =:
almacenamiento)
| | (valor absoluto) abs(...)
‡() sqrt(...)
d() derivative(...)
‰() integral(...)
G() (plantilla de suma) sumSeq(...)
Π() (plantilla de producto) prodSeq(...)
sinê(), cosê(), ... arcsin(...), arccos(...), ...
@List() deltaList(...)
@tmpCnv() deltaTmpCnv(...)
Con el teclado del ordenador
c1, c2, ... (constantes) @c1, @c2, ...
n1, n2,
... (constantes @n1, @n2, ...
enteras)
i (constante imaginaria) @i

e (log natural base e) @e
í(notación científica) @E
T @t
(transponer)
ô (radianes) @r
¡ (grados) @d
g @g
(grados centesimales)
(ángulo) @<
4 (conversión) @>
4Decimal, 4approxFraction(), y así. @>Decimal, @>approxFraction(), y así.

Jerarquía de EOS™ (Sistema operativo de
ecuaciones)
En esta sección se describe el sistema operativo de ecuaciones (Equation Operating System,
EOS™) que utiliza el programa de tecnología para el aprendizaje de matemáticas y ciencias
TI-Nspire™ CAS. Este sistema permite introducir tanto los números como las variables o las
funciones mediante una serie de pulsaciones de tecla sencillas y directas. EOS™ calcula las
expresiones y las ecuaciones aplicando un método de agrupamiento en paréntesis y según el
orden de prioridad que se indica a continuación.
Orden de los cálculos
Nivel Operador
1 Paréntesis ( ), corchetes [ ], llaves { }
2 Dirección (#)
3 Funciones
4 Postoperadores: grados-minutos-segundos (-,',"), factorial (!), porcentaje (%),

Q
radián ( RS), subíndice ([ ]), transponer (T)
5 Exponenciación, operador de potencia (^)
6 Negación ( ) L
7 Concatenación de cadenas (&)
8 Multiplicación (†), división (/)
9 Suma (+), resta (-)
10 Relaciones de igualdad: igual (=), no igual que (ƒ o /=),

menos que (<), menos o igual que ( o <=), mayor que (>), mayor o igual que (‚ o >=)
11 Operador lógico not
12 Operador lógico and
13 Operador lógico or, operador lógico exclusivo xor
14 Operador de restricción "con" (|)
15 Guardar (")
Paréntesis, corchetes y llaves

Todas las operaciones entre paréntesis, corchetes o llaves se calculan en primer lugar. Por
ejemplo, en la expresión 4(1+2), EOS™ calcula primero la parte encerrada entre paréntesis, 1+2,
y luego multiplica el resultado, 3, por 4..
El número de paréntesis, corchetes y llaves de apertura y cierre debe ser igual en toda la
expresión o ecuación. En caso contrario, aparecerá un mensaje de error indicando el elemento
que falta. Por ejemplo, (1+2)/(3+4 hará aparecer el mensaje de error "Falta paréntesis de cierre
)".

Nota: Dado que TI-Nspire™ CAS permite al usuario definir sus propias funciones, considerará
que un nombre de variable seguido de una expresión entre paréntesis es una "llamada a
función", no una multiplicación implícita. Por ejemplo a(b+c) es la función a calculada para b+c.
Para multiplicar la expresión b+c por la variable a, utilice la multiplicación explícita: a∗(b+c).
Dirección
El operador de dirección (#) convierte una cadena en un nombre de variable o de función. Por
ejemplo, #("x"&"y"&"z") crea el nombre de variable xyz. También permite crear y modificar
variables desde un programa. Por ejemplo, si 10"r y “r”"s1, entonces #s1=10.
Postoperadores
Se denomina postoperadores a los operadores que se escriben directamente detrás de un
argumento, como 5!, 25%, o 60¡15' 45". Los argumentos que van seguidos de un postoperador
se calculan en el cuarto nivel de prioridad. Por ejemplo, en la expresión 4^3!, 3! se calcula
primero. El resultado, 6, pasa a ser el exponente de 4 para generar 4096.
Exponenciación
La exponenciación (^) y la exponenciación elemento a elemento (.^) se calculan de derecha a
izquierda. Por ejemplo, la expresión 2^3^2 se calcula igual que 2^(3^2) para generar 512. Es
distinto de calcular (2^3)^2, cuyo resultado es 64.
Negación
Para introducir un número negativo, pulse v seguido del número. Las operaciones con
postoperadores y de exponenciación se efectúan antes que las de negación. Por ejemplo, el
resultado de Lx2 es un número negativo, y L92 =L81. Utilice paréntesis para elevar al cuadrado
un número negativo, por ejemplo, (L9)2 que genera 81.
Restricción (|)
El argumento incluido después del operador "con" (|) ofrece una serie de restricciones que
afectan al cálculo del argumento situado antes de dicho operador.

Códigos y mensajes de error
Cada error que se produce tiene un código que se asigna a la variable errCode. Los programas y
funciones definidos por el usuario permiten examinar la variable errCode para determinar la
causa de dicho error. Para ver un ejemplo de uso de errCode, consulte el Ejemplo 2 de la orden
Try, en la página 127.
Nota:Algunas condiciones de error son exclusivas para los productos TI-Nspire™ CAS, y otras
para los productos TI-Nspire™.
Código de Descripción
error
10 Una función no ha devuelto un valor.
20 Una comprobación no ha dado como resultado TRUE o FALSE.

Por lo general, no es posible comparar variables no definidas. Por ejemplo, el test “If a<b” generará este error si “a”
o “b” están sin definir cuando se ejecuta la sentencia “If”.
30 El argumento no puede ser un nombre de carpeta.
40 Error en el argumento
50 Error en el tipo de argumento

Si existen dos o más argumentos, todos deben pertenecer al mismo tipo.
60 El argumento debe ser una expresión booleana o un número entero.
70 El argumento debe ser un número decimal.
90 El argumento debe ser una lista.
100 El argumento debe ser una matriz.
130 El argumento debe ser una cadena.
140 El argumento debe ser un nombre de variable.

Asegúrese de que el nombre:
• no comience por un dígito
• no contenga espacios ni caracteres especiales
• no utilice subrayados ni puntos de forma incorrecta
• no supere la longitud máxima
Para obtener más detalles, consulte la sección Calculadora de la documentación.
160 El argumento debe ser una expresión.
165 Las pilas están demasiado bajas para enviar o recibir.

Instale pilas nuevas antes de enviar o recibir datos.
170 Extremo
Para definir el intervalo de búsqueda, el extremo inferior debe ser menor que el extremo superior.
180 Desvincular
Se ha pulsado la tecla d o c durante un cálculo largo o mientras se ejecutaba un programa.
190 Círculo vicioso
Este mensaje aparece para evitar que se agote la memoria durante la sustitución infinita de variables que se produce
al simplificar. Por ejemplo, a+1>a, donde a es una variable no definida, producirá este error.
200 Restricción no válida

Por ejemplo, solve(3x^2-4=0,x) | x<0 or x>5 puede generar este mensaje de error dado que la restricción aparece
separada por el operador “or”, no por “and”.
210 Tipo de datos no válido

El argumento pertenece a un tipo de datos erróneo.
220 Límite dependiente

error
230 Dimensión
Un índice de lista o de matriz no es válido. Por ejemplo, si la lista {1,2,3,4} se almacena en L1, entonces L1[5] es un
error de dimensión dado que L1 sólo contiene cuatro elementos.
235 Error de dimensión. No hay elementos suficientes en las listas.
240 Discordancia de dimensión

Si existen dos o más argumentos, todos deben tener el mismo tamaño. Por ejemplo, [1,2]+[1,2,3] es una
discordancia de dimensión dado que las listas contienen un número diferente de elementos.
250 División por cero
260 Error en el dominio

El argumento debe estar en un dominio determinado. Por ejemplo, rand(0) no es válido.
270 Nombre de variable duplicado
280 Else y ElseIf no son válidos fuera del bloque If..EndIf.
290 EndTry no encuentra la sentencia Else correspondiente
295 Iteración excesiva
300 Debe ser una lista o matriz de 2 o 3 elementos.
310 El primer argumento de nSolve debe ser una ecuación con una única variable. No puede incluir una variable sin
valor distinta de la variable a calcular.
320 El primer argumento de solve o de cSolve debe ser una ecuación o una desigualdad.
Por ejemplo, solve(3x^2-4,x) no es válido dado que el primer argumento no es una ecuación.
345 Unidades incompatibles
350 Índice fuera de rango
360 No válido como nombre de variable
380 Respuesta no definida

Puede que el cálculo anterior no haya creado una respuesta o que no se haya introducido ningún cálculo.
390 Asignación no válida
400 Valor asignado no válido
410 Orden no válida
430 No válido para la configuración de modo actual
435 Conjetura no válida
440 Multiplicación implícita no válida

Por ejemplo, x(x+1) no es válida; mientras que, x*(x+1) muestra la sintaxis correcta. Esto evita confundir la
multiplicación implícita con las llamadas a funciones.
450 No válido en la función o expresión actual

En las funciones definidas por el usuario, sólo son válidas determinadas órdenes.
490 Bloque no válido en Try..EndTry
510 Lista o matriz no válida
550 Resultados no válidos fuera de función o programa

Una serie de órdenes no es válida si no se aplica a una función o programa. Por ejemplo, Local no puede utilizarse a
menos que sea dentro de una función o un programa.
560 Resultados no válidos fuera de los bloques Loop..EndLoop, For..EndFor o While..EndWhile.

Por ejemplo, la orden Exit sólo es válida dentro de estos bloques de bucles.

error
565 Resultados no válidos fuera de programa
570 Nombre de ruta de acceso no válido

Por ejemplo, \var no es válido.
575 Complejo polar no válido
580 Referencia a programa no válida

No puede hacerse referencia a programas en funciones o expresiones como 1+p x, donde p es un programa.
600 Tabla no válida
605 Utilización de unidades no válida
610 Nombre de variable no válido en una sentencia Local
620 Nombre de variable o función no válido
630 Referencia a variable no válida
640 Sintaxis no válida para vector
650 Transmisión de conexiones

La transmisión entre dos unidades no ha finalizado. Asegúrese de que el cable está correctamente conectado a
ambas unidades.
665 La matriz no es diagonizable
670 Memoria insuficiente

1. Borre algunos datos del documento
2. Guarde y cierre este documento
Si los pasos 1 y 2 no solucionan el problema, retire las pilas y vuelva a colocarlas.
680 Falta paréntesis de apertura (
690 Falta paréntesis de cierre }
700 Faltan comillas “
710 Falta corchete de cierre ]
720 Falta llave de cierre }
730 Falta el comienzo o el final de un bloque
740 Falta Then en el bloque If..EndIf
750 El nombre no es una función o programa
765 No hay ninguna función seleccionada
780 No ha sido posible hallar la solución
800 Resultado no real

Por ejemplo, si el software está en el valor de configuración Real, ‡(-1) no es válido.
Para permitir cálculos complejos, cambie el ajuste de modo “Real o Complejo” a RECTANGULAR o POLAR.
830 Error por desbordamiento
850 No se encuentra el programa

En la ruta de acceso especificada durante la ejecución, no pudo encontrarse la referencia a un programa incluida en
otro programa.
855 La representación gráfica no admite el uso de funciones de tipo aleatorio.
860 Recursión excesiva

error
870 Nombre reservado o variable del sistema

No se puede aplicar el modelo mediana-media a un conjunto de datos.
920 No se encuentra el texto
930 Pocos argumentos

A la función o la orden le faltan uno o varios argumentos.
940 Demasiados argumentos

La expresión o la ecuación presenta demasiados argumentos y no puede calcularse.
950 Demasiados subíndices
955 Demasiadas variables no definidas
960 La variable no está definida

No se ha asignado valor a la variable. Utilice una de las órdenes siguientes:
• sto &
• :=
• Define
para asignar valores a las variables.
965 SO sin licencia
970 No están permitidas tantas referencias o cambios para la variable en uso
980 La variable está inaccesible o protegida
990 Nombre de variable no válido

Asegúrese de que el nombre no supere la longitud máxima admitida.
1000 Dominio de las variables de ventana
1010 Zoom
1020 Error interno
1030 Infracción de normas de memoria protegida
1040 Función no admitida Esta función requiere el sistema algebraico del ordenador (Computer Algebra System). Pruebe
con TI-Nspire CAS.
1045 Operador no admitido Este operador requiere el sistema algebraico del ordenador (Computer Algebra System).
Pruebe con TI-Nspire CAS.
1050 Función no admitida Este operador requiere el sistema algebraico del ordenador (Computer Algebra System). Pruebe
con TI-Nspire CAS.
1060 El argumento de entrada debe ser un número. Sólo se admiten entradas que contengan valores numéricos.
1070 El argumento de la función trigonométrica es demasiado grande para simplificarlo.
1080 Uso de Ans no admitido. Esta aplicación no admite el uso de Ans.
1090 La función no está definida. Utilice una de las órdenes siguientes:

• Define
• :=
• sto &
para definir una función.
1100 Cálculo no real

Por ejemplo, si el software está en el valor de configuración Real, ‡(-1) no es válido.
Para permitir cálculos complejos, cambie el ajuste de modo “Real o Complejo” a RECTANGULAR o POLAR.
1110 Extremos no válidos

error
1120 No hay cambios de signo
1130 El argumento no puede ser una lista o matriz.

El primer argumento debe ser una expresión polinómica del segundo argumento. Si el segundo argumento se omite,
el software intentará seleccionar un valor predeterminado.

Los dos primeros argumentos deben ser una expresión polinómica del tercer argumento. Si el tercer argumento se
omite, el software intentará seleccionar un valor predeterminado.
1160 El nombre de la ruta de acceso a la biblioteca no es válido

Escriba el nombre de la ruta de acceso en la forma xxx\yyy, donde:
• La parte xxx puede tener de 1 a 16 caracteres.
• la parte yyy puede tener de 1 a 15 caracteres.
Para obtener más detalles, consulte la sección Biblioteca de la documentación.
1170 El uso del nombre de la ruta de acceso a la biblioteca no es válido.

• No se puede asignar un valor a un nombre de ruta de acceso con Define, :=, o sto &.
• Un nombre de ruta de acceso no se puede declarar como una variable Local ni utilizar como parámetro en
una definición de función o programa.
1180 El nombre de la variable de biblioteca no es válido.

• no contiene un punto
• no comienza por un signo de subrayado
• no tiene más de 15 caracteres
1190 Documento de biblioteca no hallado:

• Asegúrese de que la biblioteca se encuentra en la carpeta MyLib.
• Actualice las bibliotecas.
1200 Variable de biblioteca no hallada:

• Asegúrese de que hay una variable de este tipo en el primer problema de la biblioteca.
• Asegúrese de que la variable de biblioteca está definida como LibPub o LibPriv.
• Actualice las bibliotecas.
1210 El nombre del método abreviado de acceso a la biblioteca no es válido.

• no contiene un punto
• no comienza por un signo de subrayado
• no tiene más de 16 caracteres
• no es un nombre reservado
1220 Error en el dominio:

Las funciones tangentLine y normalLine sólo admiten funciones de valor real.
1230 Error en el dominio.

Los modos de ángulo Grados o Grados centesimales no admiten el uso de operadores de conversión para valores
trigonométricos.

Utilice un sistema de ecuaciones lineales.
Ejemplo de un sistema de dos ecuaciones lineales con variables X e Y:
3x+7y=5
2y-5x=-1
1260 Error en el argumento:

El primer argumento de nfMin o nfMax debe ser una expresión con una única variable. No puede incluir una
variable sin valor distinta de la variable a calcular.

El orden de la derivada debe ser igual a 1 o 2.

error

Utiliza la forma desarrollada de un polinomio en una variable.

Utiliza un polinomio en una variable.

Los coeficientes del polinomio deben dar lugar a valores numéricos.
1310 Error en el argumento:

No es posible calcular una función para uno o más de sus argumentos.
171
172
Servicio y Soporte
Información sobre productos, servicios y garantías

de TI
Información sobre Para obtener más detalles acerca de los

productos y productos y servicios de TI, póngase en contacto
servicios de TI mediante correo electrónico o acceda a la
página inicial de calculadoras en la world wide
web.
dirección de correo electrónico:
ti-cares@ti.com
dirección de internet: education.ti.com
Información sobre Para obtener más detalles acerca de la duración
servicios y y las condiciones de la garantía o sobre el
garantías servicio de asistencia a productos, consulte la
declaración de garantía que se adjunta a este
producto o póngase en contacto con su
distribuidor o minorista de Texas Instruments.
Servicio y Soporte 173

174 Servicio y Soporte
Índice alfabético
Símbolos 4approxFraction( ) 11
!, factorial 148
", notación en segundos 155 A
#, dirección 153 abs( ), valor absoluto 7
#, operador de dirección 165 aleatorio
%, porcentaje 145 matriz, randMat( ) 96
&, almacenar 158 normal, randNorm( ) 96
&, añadir 148 número raíz, RandSeed 97
', notación en minutos 155 polinomio, randPoly( ) 96
', primo 155 almacenar
-, grados/minutos/segundos 155 símbolo, & 158
-, notación en grados 154 amortTbl( ), tabla de amortización
4, convertir unidades 156 7, 13
‰, integral 149 ampliar/concatenar, augment( ) 12
‡, raíz cuadrada 150 añadir, & 148
ƒ, no igual 146 and, expresión booleana 7
N, resta 141 angle( ), ángulo 8
P, división 142 ángulo, angle( ) 8
Π, producto 151 ANOVA de 2 variables, análisis de
Σ( ), suma 151 varianza de dos factores 9
*, multiplicar 142 ANOVA, análisis de varianza de un
+, suma 141 factor 8
.*,punto multiplicación 144 Ans, última respuesta 11
.+, punto suma 144 approx( ), aproximado 11, 12
.^, punto de potencia 145 aproximado, approx( ) 11, 12
.N, punto resta 144 aproxRacional( ) 11
.P, punto división 145 arccos() 11
:=, asignar 158 arccosh() 12
<, menor que 147 arccot() 12
=, igual 146 arccoth() 12
>, mayor que 147 arccsc() 12
@list( ), diferencia de lista 66 arccsch() 12
^, potencia 143 arcLen( ), longitud de arco 12
^/, inverso de un valor 157 arcocoseno, cos/( ) 23
_, designación de unidad 156 arcoseno, sin/( ) 110
{, menor o igual que 147 arcotangente, tan/( ) 121
|, con 157 arcsec() 12
|, mayor o igual que 148 arcsech() 12
©, comentario 158 arcsin() 12
arcsinh() 12
Números arctan() 12
arctanh() 12
0b, indicador binario 159
argumentos en funciones de TVM
0h, indicador hexadecimal 159
129
10^( ), potencia de diez 156
175
augment( ), ampliar/concatenar 12 centro-cadena, mid( ) 75
avgRC( ), tasa media de cambio 13 código de carácter, ord( ) 85
dentro, InString 58
B derecha, right( ) 100
desplazar, shift( ) 107
base e
dirección, # 153
plantilla 2
expresión a cadena, string( ) 118
4Base10, mostrar como entero
formatear 49
decimal 14
formato, format( ) 49
4Base16, mostrar como hexadecimal
izquierda, left( ) 61
15
rotar, rotate( ) 101
4Base2, mostrar como binario 14
utilizar para crear nombres de
biblioteca
variable 165
crear accesos directos a objetos
cálculos, orden 164
61
caracteres
binario
cadena, char( ) 17
indicador, 0b 159
código numérico, ord( ) 85
mostrar, 4Base2 14
Cdf( ) 46
binomCdf( ) 15
ceiling( ), techo 15
binomPdf( ) 15
centralDiff( ) 16
bloquear variables y grupos de
centro-cadena, mid( ) 75
variables 68
ceros, zeroes( ) 134
booleana, expresión
cFactor( ), factor complejo 16
and, and 7
char( ), cadena de caracteres 17
exclusiva or, xor 133
charPoly( ) 17
not, not 81
ciclo, Cycle 31
or, or 85
ClearAZ 19
borrar
ClrErr, borrar error 19
error, ClrErr 19
colAugment 19
variable, DelVar 35
colDim( ), dimensión de columna de
bucle final, EndLoop 72
matriz 19
bucle, Loop 72
colNorm( ), norma de columna de
matriz 19
C combinaciones, nCr( ) 78
c2 de 2 elementos 17 comDenom( ), común denominador
c2Cdf( ) 18 20
c2GOF 18 comentario, © 158
c2Pdf( ) 18 complejo
cadena ceros, cZeros( ) 31
dimensión, dim( ) 37 conjugado, conj( ) 20
longitud 37 factor, cFactor( ) 16
cadena de caracteres, char( ) 17 resolver, cSolve( ) 28
cadena de formato, format( ) 49 comprobar elemento sin valor,
cadenas isVoid( ) 60
añadir, & 148 común denominador, comDenom( )
cadena a expresión, expr( ) 44, 20
69 con, | 157
cadena de caracteres, char( ) 17
176
configuración de modo, getMode( ) count( ), contar elementos de una
53 lista 25
configuración, obtener actual 53 countif( ), contar elementos
conj( ), complejo conjugado 20 condicionales de una lista 26
constante cPolyRoots() 26
en solve( ) 112 crossP( ), producto vectorial 26
constantes csc( ), cosecante 27
en cSolve( ) 29 csc/( ), cosecante inversa 27
en cZeros( ) 32 csch( ), cosecante hiperbólica 27
en deSolve( ) 36 csch/( ), cosecante hiperbólica
en solve( ) 113 inversa 27
teclas de acceso 162 cSolve( ), resolver complejo 28
constructMat( ), matriz de cuando, when( ) 132
construcción 21 CubicReg, regresión cúbica 30
contar días entre fechas, dbd( ) 33 cumulativeSum( ), suma acumulada
contar elementos condicionales de 30
una lista, countif( ) 26 Cycle, ciclo 31
contar elementos de una lista, 4Cylind, mostrar como vector
count( ) 25 cilíndrico 31
convertir cZeros( ), ceros complejos 31
4Grad 55
4Rad 95 D
unidades 156
d ( ), primera derivada 149
coordenada
dbd( ), días entre fechas 33
polar, R4Pr( ) 95
4DD, mostrar como ángulo decimal
coordenada rectangular x, P4Rx( )
33
86
4Decimal, mostrar resultado como
coordenada rectangular y, P4Ry( )
decimal 33
86
decimal
copiar variable o función, CopyVar
mostrar como ángulo, 4DD 33
21
mostrar entero, 4Base10 14
copyright statement ii
Define (Definir) 34
corrMat( ), matriz de correlación 21
Define LibPriv 34
4cos, ver en función de coseno 22 Define LibPub 35
cos( ), coseno 22
Define, definir 34
cos/, arcocoseno 23
definir
coseno
función o programa privados 34
ver expresión en función de 22
función o programa públicos 35
coseno, cos( ) 22
modo, setMode( ) 106
cosh( ), coseno hiperbólico 24
definir, Define 34
cosh/( ), arcocoseno hiperbólico 24
deltaList() 35
cot( ), cotangente 24
deltaTmpCnv() 35
cot/( ), arcocotangente hiperbólica
DelVar, eliminar variable 35
25
delVoid( ), eliminar elementos sin
cotangente, cot( ) 24
valor 35
coth( ), cotangente hiperbólica 25
denominador 20
coth/( ), arcocotangente hiperbólica
25
177
densidad de probabilidad de t de e^( ), e elevado a una potencia 40
Student, tPdf( ) 126 ecuaciones simultáneas, simult( )
densidad de probabilidad, 108
normPdf( ) 81 eff ), convertir nominal en tasa
dentro de la cadena, inString( ) 58 efectiva 40
derecha, right( ) 100 eigVc( ), vector propio 40
derivada eigVl( ), valor propio 41
numérica, nDeriv( ) 79, 80 elementos sin valor 160
derivada implícita, Impdif( ) 58 elementos sin valor, eliminar 35
derivada o derivada enésima elementos vacíos (sin valor) 160
plantilla 5 eliminar
derivadas elementos sin valor de listas 35
derivada numérica, nDeriv( ) 79, else if, ElseIf 41
80 else, Else 56
derivadas numéricas, ElseIf, else if 41
nDerivative( ) 79 end
primera derivada, d ( ) 149 bucle, EndLoop 72
derivative() 35 función, EndFunc 51
desarrollar, expand( ) 43 if, EndIf 56
desarrollo trigonométrico, para, EndFor 48
tExpand( ) 123 end if, EndIf 56
desbloquear variables y grupos de EndTry, finalizar prueba 126
variables 131 EndWhile, mientras finaliza 133
deSolve( ), solución 36 entero, int( ) 58
desplazar, shift( ) 107 entrada, Input 58
desviación estándar, stdDev( ) 117, EOS (Sistema operativo de
132 ecuaciones) 164
det( ), determinante de matriz 37 errores y solución de problemas
diag( ), matriz diagonal 37 borrar error, ClrErr 19
días entre fechas, dbd( ) 33 pasar error, PassErr 86
dim( ), dimensión 37 estadística
dimensión, dim( ) 37 combinaciones, nCr( ) 78
dirección, # 153 de una variable, OneVar 84
Disp, mostrar datos 38 desviación estándar, stdDev( )
distribución acumulada normal 117, 132
inversa (invNorm( ) 59 factorial, ! 148
dividir entero, intDiv( ) 58 media, mean( ) 73
división, P 142 mediana, median( ) 74
dominantTerm( ), término normal aleatorio, randNorm( )
dominante 39 96
dotP( ), producto escalar 39 número raíz aleatorio, RandSeed
97
E resultado con dos variables,
TwoVar 130
e elevado a un exponente, e^( ) 42
variaciones, nPr( ) 82
e elevado a una potencia, e^( ) 40
varianza, variance( ) 132
E, exponente 153
estadística de una variable, OneVar
e, ver expresión en función de 42
84
178
etiqueta, Lbl 60 Func, función 51
exact( ), exactitud 42 Func, función programa 51
exactitud, exact( ) 42 función definida a trozos (2 partes)
exclusiva (exp booleana) or, xor 133 plantilla 2
Exit, salir 42 función definida a trozos (N partes)
4exp, ver en función de e 42 plantilla 2
exp( ), e elevado a un exponente 42 función end, EndFunc 51
exp4list( ), expresión a lista 43 funciones
expand( ), desarrollar 43 definidas por el usuario 34
exponente función programa, Func 51
plantilla 1 máximo, fMax( ) 47
exponente, E 153 mínimo, fMin( ) 48
expr( ), cadena a expresión 44, 69 parte, fpart( ) 49
ExpReg, regresión exponencial 44 funciones de distribución
expresiones binomCdf( ) 15
cadena a expresión, expr( ) 44, binomPdf( ) 15
69 c22way( ) 17
expresión a lista4list( ) 43 c2Cdf( ) 18
c2GOF( ) 18
F c2Pdf( ) 18
Invc2( ) 59
factor( ), factor 45
invNorm( ) 59
factor, factor( ) 45
invt( ) 59
factorial, ! 148
normCdf( ) 81
factorización QR, QR 92
normPdf( ) 81
Fill, rellenar matriz 46
poissCdf( ) 87
finalizar
poissPdf( ) 87
mientras, EndWhile 133
tCdf( ) 122
programa, EndPrgm 91
tPdf( ) 126
prueba, EndTry 126
funciones definidas por el usuario
floor( ), suelo 47
34
fMax( ), máximo de función 47
funciones financieras, tvmFV( ) 128
fMin( ), mínimo de función 48
funciones financieras, tvmI( ) 128
For 48
funciones financieras, tvmN( ) 129
For, para 48
funciones financieras, tvmPmt( )
forma de fila escalonada reducida,
129
rref( ) 103
funciones financieras, tvmPV( ) 129
forma de fila escalonada, ref( ) 98
funciones y programas definidos por
format( ), cadena de formato 49
el usuario 34, 35
fpart( ), parte de función 49
funciones y variables
fracción propia, propFrac 92
copiar 21
fracciones
plantilla 1
propFrac 92 G
fracciones mixtas, utilizar propFrac(› g, grados centesimales 154
with 92 gcd( ), máximo común divisor 52
freqTable( ) 50 geomCdf( ) 52
frequency( ) 50 geomPdf( ) 52
179
getDenom( ), obtener/devolver Input, entrada 58
denominador 52 inString( ), dentro de la cadena 58
getLangInfo( ), obtener/devolver int( ), entero 58
información de idioma 53 intDiv( ), dividir entero 58
getLockInfo( ), comprueba el estado integral
de bloqueo de una variable o numérica, nInt( ) 80
grupo de variables 53 integral definida
getMode( ), obtener configuración plantilla 5
de modo 53 integral indefinida
getNum( ), obtener/devolver plantilla 5
numerador 54 integral, ä 149
getVarInfo( ), obtener/devolver Invc2( ) 59
información de variables 54 inverso de un valor, ^/ 157
4GMS, mostrar como grados/ inverso, ^/ 157
minutos/segundos 38 invF( ) 59
Goto, ir a 55 invNorm( ), distribución acumulada
4, convertir ángulo a grados normal inversa) 59
centesimales 55 invt( ) 59
grupos, bloquear y desbloquear 68, iPart( ), parte entera 59
131 ir a, Goto 55
grupos, comprobar estado de irr( ), tasa interna de retorno
bloqueo 53 tasa interna de retorno, irr( ) 59
isPrime( ), probar si es primo 60
H isVoid( ), comprueba si el elemento
no tiene valor 60
hexadecimal
izquierda, left( ) 61
indicador, 0h 159
mostrar, 4Base16 15
hiperbólica L
arcotangente, tanh/( ) 122 Lbl, etiqueta 60
tangente, tanh( ) 121 lcm, mínimo común múltiplo 61
hiperbólico left( ), izquierda 61
arcocoseno, cosh/( ) 24 LibPriv 34
arcoseno, sinh/( ) 110 LibPub 35
coseno, cosh( ) 24 libShortcut( ), crea accesos directos a
seno, sinh( ) 110 objetos de biblioteca 61
limit( ) o lim( ), límite 62
I límite
lim( ) 62
identity( ), matriz identidad 56
limit( ) 62
idioma
plantilla 6
obtener información sobre
LinRegBx, regresión lineal 62
idioma 53
LinRegMx, regresión lineal 63
If, if 56
LinRegtIntervals, regresión lineal 64
if, If 56
linSolve() 66
ifFn( ) 57
list4mat( ), lista matriz 66
igual, = 146
lista a matriz, list4mat( ) 66
imag( ), parte imaginaria 57
lista, contar elementos 25
ImpDif( ), derivada implícita 58
180
lista, contar elementos condicionales aleatoria, randMat( ) 96
26 ampliar/concatenar, augment( )
listas 12
ampliar/concatenar, augment( ) descomposición inferior/superior
12 de matriz, LU 72
centro-cadena, mid( ) 75 determinantes, det( ) 37
diferencia, @list( ) 66 diagonales, diag( ) 37
diferencias en una lista, @list( ) dimensión de columna, colDim( )
66 19
elementos vacíos 160 dimensión de filas, rowDim( )
expresión a lista4list( ) 43 102
lista a matriz, list4mat( ) 66 dimensión, dim( ) 37
matriz a lista, mat4list( ) 73 dividir punto, .P 145
máximo, max( ) 73 factorización QR, QR 92
mínimo, min( ) 75 forma de fila escalonada
nueva, newList( ) 79 reducida, rref( ) 103
ordenar en sentido ascendente, forma de fila escalonada, ref( )
SortA 114 98
ordenar en sentido descendente, identidad, identity( ) 56
SortD 114 intercambiar filas, rowSwap( )
producto escalar, dotP( ) 39 102
producto vectorial, crossP( ) 26 lista a matriz, list4mat( ) 66
producto, product( ) 91 matriz a lista, mat4list( ) 73
suma acumulada, máximo, max( ) 73
cumulativeSum( ) 30 mínimo, min( ) 75
suma, sum( ) 119 multiplicación y suma de filas,
ln( ), logaritmo natural 67 mRowAdd( ) 76
LnReg, regresión logarítmica 67 multiplicar punto, .* 144
local, Local 68 norma de columna, colNorm( )
Local, variable local 68 19
Lock, bloquear variable o grupo de norma de fila, rowNorm( ) 102
variables 68 nueva, newMat( ) 79
logaritmo operación de fila, mRow( ) 76
plantilla 2 potencia de puntos, .^ 145
logaritmo natural, ln( ) 67 producto, product( ) 91
logaritmos 67 rellenar, Fill 46
Logistic, regresión logística 70 restar puntosN 144
LogisticD, regresión logística 71 submatriz, subMat( ) 118, 119
longitud de arco, arcLen( ) 12 suma acumulada,
longitud de la cadena 37 cumulativeSum( ) 30
Loop, bucle 72 suma de filas, rowAdd( ) 102
LU, descomposición inferior/superior suma, sum( ) 119
de matriz 72 sumar puntos, .+ 144
transponer, T 120
M valor propio, eigVl( ) 41
vector propio, eigVc( ) 40
mat4list( ), matriz a lista 73
matriz (1 Q 2)
matrices
plantilla 4
181
matriz (2 Q 1) hexadecimal, 4Base16 15
plantilla 4 vector cilíndrico, 4Cylind 31
matriz (2 Q 2) vector esférico, 4Sphere 115
plantilla 3 vector polar, 4Polar 87
matriz (m Q n) vector rectangular, 4Rect 97
plantilla 4 mostrar grados/minutos/segundos,
matriz a lista, mat4list( ) 73 4GMS 38
matriz de construcción, mostrar vector cilíndrico, 4Cylind 31
constructMat( ) 21 mRow( ), operación de fila de matriz
matriz de correlación, corrMat( ) 21 76
matriz identidad, identity( ) 56 mRowAdd( ), multiplicación y suma
max( ), máximo 73 de filas de matriz 76
máximo común divisor, gcd( ) 52 muestra aleatoria 97
máximo, max( ) 73 multiplicar, * 142
mayor o igual que, | 148 MultReg 76
mayor que, > 147 MultRegIntervals( ) 77
mean( ), media 73 MultRegTests( ) 77
media, mean( ) 73
median( ), mediana 74 N
mediana, median( ) 74
nCr( ), combinaciones 78
MedMed, regresión recta mediana a
nDerivative( ), derivada numérica
mediana 74
79
menor o igual que, { 147
negación, introducir números
menor que, < 147
negativos 165
métodos abreviados, teclado 162
newList( ), nueva lista 79
mid( ), centro-cadena 75
newMat( ), nueva matriz 79
mientras final, EndWhile 133
nfMax( ), máximo de función
mientras, While 133
numérica 79
min( ), mínimo 75
nfMin( ), mínimo de función
mínimo común múltiplo, lcm 61
numérica 80
mínimo, min( ) 75
nInt( ), integral numérica 80
mirr( ), tasa interna de retorno
no igual, ƒ 146
modificada 75
nom ), convertir nominal en tasa
mod( ), módulo 76
efectiva 80
modos
norm( ), norma de Frobenius 81
configurar, setMode( ) 106
norma de Frobenius, norm( ) 81
módulo, mod( ) 76
normalLine( ) 81
mostrar como vector esférico,
normCdf( ) 81
4Sphere 115 normPdf( ) 81
mostrar como vector rectangular,
not (exp booleana), not 81
4Rect 97 not, expresión booleana not 81
mostrar datos, Disp 38
notación en grado centesimal, g 154
mostrar en formato
notación en grados, - 154
ángulo decimal, 4DD 33
notación en grados/minutos/
binario, 4Base2 14
segundos 155
entero decimal, 4Base10 14
notación en minutos, ' 155
grados/minutos/segundos, 4GMS
notación en segundos, " 155
38
182
nPr( ), variaciones 82 plantillas
npv( ), valor presente neto 83 base e 2
nSolve( ), solución numérica 83 derivada o derivada enésima 5
nueva exponente 1
lista, newList( ) 79 fracción 1
matriz, newMat( ) 79 función definida a trozos (2
numérica partes) 2
derivada, nDerivative( ) 79 función definida a trozos (N
partes) 2
O integral definida 5
integral indefinida 5
objetos
límite 6
crear accesos directos a
logaritmo 2
biblioteca 61
matriz (1 Q 2) 4
obtener/devolver
matriz (2 Q 1) 4
denominador, getDenom( ) 52
matriz (2 Q 2) 3
información sobre variables,
matriz (m Q n) 4
getVarInfo( ) 53, 54
primera derivada 5
numerador, getNum( ) 54
producto (Π) 4
OneVar, estadística de una variable
raíz cuadrada 1
84
raíz enésima 1
operador de dirección (#) 165
segunda derivada 5
operadores
sistema de ecuaciones (2
orden de los cálculos 164
ecuaciones) 3
or (exp booleana), or 85
sistema de ecuaciones (N
or, expresión booleana or 85
ecuaciones) 3
ord( ), código de carácter numérico.
suma (G) 4
85
valor absoluto 3
orden Stop 118
poissCdf( ) 87
orden Text 123
poissPdf( ) 87
ordenar
en sentido ascendente, SortA
4Polar, mostrar como vector polar
87
114
polar
en sentido descendente, SortD
coordenada, R4Pq( ) 95
114
mostrar vector, 4Polar 87
polinomio de Taylor, taylor( ) 122
P polinomios
P4Rx( ), coordenada rectangular x aleatorio, randPoly( ) 96
86 evaluar, polyEval( ) 88
P4Ry( ), coordenada rectangular y polyCoef( ) 88
86 polyDegree( ) 88
para, For 48 polyEval( ), valor del polinomio 88
parte entera, iPart( ) 59 polyGcd( ) 89
parte imaginaria, imag( ) 57 PolyRoots() 90
pasar error, PassErr 86 porcentaje, % 145
PassErr, pasar error 86 potencia de diez, 10^( ) 156
Pdf( ) 49 potencia, ^ 143
piecewise( ) 87 PowerReg, regresión potencial 90
183
Prgm, definir programa 91 R4Pr( ), coordenada polar 95
primera derivada 4Rad, convertir a radianes 95
plantilla 5 radián, R 154
primo, ' 155 raíz cuadrada
probabilidad de distribución de t de plantilla 1
Student, tCdf( ) 122 raíz cuadrada, à( ) 115, 150
probabilidad de distribución normal, raíz enésima
normCdf( ) 81 plantilla 1
probar número primo, isPrime( ) 60 rand( ), número aleatorio 95
prodSeq() 91 randBin, número aleatorio 96
product( ), producto 91 randInt( ), entero aleatorio 96
producto randMat( ), matriz aleatoria 96
escalar, dotP( ) 39 randNorm( ), normal aleatorio 96
producto (Π) randPoly( ), polinomio aleatorio 96
plantilla 4 randSamp( ) 97
producto vectorial, crossP( ) 26 RandSeed, número raíz aleatorio 97
producto, Π( ) 151 real( ), real 97
producto, product( ) 91 real, real( ) 97
programación recopilación trigonométrica,
definir programa, Prgm 91 tCollect( ) 123
mostrar datos, Disp 38 4Rect, mostrar como vector
pasar error, PassErr 86 rectangular 97
programas recta normal, normalLine( ) 81
definir biblioteca privada 34 recta tangente, tangentLine( ) 121
definir biblioteca pública 35 redondeo, round( ) 102
programas y programación ref( ), forma de fila escalonada 98
borrar error, ClrErr 19 regresión cuadrática, QuadReg 93
finalizar programa, EndPrgm 91 regresión cuártica, QuartReg 94
finalizar prueba, EndTry 126 regresión cúbica, CubicReg 30
mostrar pantalla E/S, Disp 38 regresión exponencial, ExpReg 44
probar, Try 126 regresión lineal múltiple, test
propFrac, fracción propia 92 <Equation Variables>t 77
punto regresión lineal, LinRegAx 63
división, .P 145 regresión lineal, LinRegBx 62, 64
multiplicación, .* 144 regresión logarítmica, LnReg 67
potencia, .^ 145 regresión logística, Logistic 70
resta, .N 144 regresión logística, LogisticD 71
suma, .+ 144 regresión potencial, PowerReg 90,
99, 100, 123
Q regresión recta mediana a mediana,
MedMed 74
QR, factorización QR 92
regresión sinusoidal, SinReg 111
QuadReg, regresión cuadrática 93
regresiones
QuartReg, regresión cuártica 94
cuadrática, QuadReg 93
cuártica, QuartReg 94
R cúbicas, CubicReg 30
R, radián 154 exponenciales, ExpReg 44
R4Pq( ), coordenada polar 95 logarítmicas, LnReg 67
184
Logistic 70 sech( ), secante hiperbólica 104
logística, Logistic 71 sech/( ), secante hiperbólica inversa
MultReg 76 104
recta mediana a mediana, segunda derivada
MedMed 74 plantilla 5
regresión lineal, LinRegAx 63 seno
regresión lineal, LinRegBx 62, ver expresión en función de 109
64 seno, sin( ) 109
regresión potencial, PowerReg seq( ), sucesión 104
90, 99, 100, 123 series( ), series 105
sinusoidal, SinReg 111 series, series( ) 105
remain( ), resto 99 setMode( ), definir modo 106
Request 99 shift( ), desplazar 107
RequestStr 100 sign( ), signo 108
resolver, solve( ) 112 signo, sign( ) 108
respuesta (última), Ans 11 simult( ), ecuaciones simultáneas
resta, N 141 108
resto, remain( ) 99 4sin, ver en función de seno 109
resultado sin valor, comprobar 60
ver en función de coseno 22 sin( ), seno 109
ver en función de e 42 sin/( ), arcoseno 110
ver en función de seno 109 sinh( ), seno hiperbólico 110
resultado con dos variables, TwoVar sinh/( ), arcoseno hiperbólico 110
130 SinReg, regresión sinusoidal 111
resultados, estadísticos 116 ΣInt( ) 152
ResumenCincoNúmeros 47 sistema de ecuaciones (2 ecuaciones)
retroceder, Return 100 plantilla 3
Return, retroceder 100 sistema de ecuaciones (N
right( ), derecha 100 ecuaciones)
rotar, rotate( ) 101 plantilla 3
rotate( ), rotar 101 Sistema operativo de ecuaciones
round( ), redondeo 102 (EOS) 164
rowAdd( ), suma de filas de matriz solución
102 numérica, nSolve( ) 83
rowDim( ), dimensión de filas de solución, deSolve( ) 36
matriz 102 solve( ), resolver 112
rowNorm( ), norma de fila de matriz SortA, ordenar en sentido
102 ascendente 114
rowSwap( ), intercambiar filas de SortD, ordenar en sentido
matriz 102 descendente 114
rref( ), forma de fila escalonada 4Sphere, mostrar como vector
reducida 103 esférico 115
ΣPrn( ) 153
S sqrt( ), raíz cuadrada 115
stat.results 116
salir, Exit 42
stat.values 117
sec( ), secante 103
stdDevPop( ), desviación estándar de
sec/( ), secante inversa 103
población 117
185
stdDevSamp( ), desviación estándar Test t de regresión lineal
de la muestra 117 (LinRegTTest) 65
string( ), expresión a cadena 118 test t, tTest 127
subMat( ), submatriz 118, 119 Test Z 138
submatriz, subMat( ) 118, 119 Test_2S, test F de 2 muestras 51
subrayado, _ 156 tExpand( ), desarrollo
sucesión, seq( ) 104 trigonométrico 123
suelo, floor( ) 47 TInterval, intervalo t de confianza
sum( ), suma 119 124
suma (G) tInterval_2Samp, -intervalo t de
plantilla 4 confianza de dos muestras 124
suma acumulada, cumulativeSum( ) 4tmpCnv() 125
30 tmpCnv() 125
suma de pagos de intereses 152 tPdf( ), densidad de probabilidad de
suma de pagos de principal 153 -t de Student 126
suma, + 141 trace( ) 126
suma, Σ( ) 151 transponer, T 120
suma, sum( ) 119 Try, orden para gestión de errores
sumIf( ) 119 126
sumSeq() 119 tTest, test t 127
tTest_2Samp, test t de 2 muestras
T 128
TVM, argumentos 129
T, transponer 120
tvmFV( ) 128
tabla de amortización, amortTbl( )
tvmI( ) 128
7, 13
tvmN( ) 129
tan( ), tangente 120
tvmPmt( ) 129
tan/( ), arcotangente 121
tvmPV( ) 129
tangente, tan( ) 120
TwoVar, resultado con dos variables
tangentLine( ) 121
130
tanh( ), tangente hiperbólica 121
tanh/( ), arcotangente hiperbólica
122 U
tasa efectiva, eff( ) 40 unidad vectorial, unitV( ) 131
tasa interna de retorno modificada, unidades
mirr( ) 75 convertir 156
tasa media de cambio, avgRC( ) 13 unitV( ), unidad vectorial 131
tasa nominal, nom( ) 80 unLock, desbloquea una variable o
taylor( ), polinomio de Taylor 122 un grupo de variables 131
tCdf( ), probabilidad de distribución
de -t de Student 122 V
tCollect( ), recopilación
valor absoluto
trigonométrica 123
plantilla 3
techo, ceiling( ) 15, 16, 26
valor del polinomio, polyEval( ) 88
teclas de método abreviado 162
valor presente neto, npv( ) 83
término dominante,
valor propio, eigVl( ) 41
dominantTerm( ) 39
valor temporal del dinero, cantidad
Test F de 2 muestras 51
del pago 129
186
valor temporal del dinero, Interés zInterval_1Prop, intervalo z de
128 confianza de una proporción
valor temporal del dinero, número 136
de pagos 129 zInterval_2Prop, intervalo z de
valor temporal del dinero, Valor confianza de dos proporciones
futuro 128 137
valor temporal del dinero, valor zInterval_2Samp, intervalo z de
presente 129 confianza de dos muestras 137
valores de resultados, estadísticos zTest_1Prop, test z de una
117 proporción 138
variable local, Local 68 zTest_2Prop, test z de dos
variables proporciones 139
crear nombre de una cadena de zTest_2Samp, test z de dos muestras
caracteres 165 140
eliminar, DelVar 35
limpiar todas las letras 19
local, Local 68
variables y funciones
copiar 21
variables, bloquear y desbloquear
53, 68, 131
variaciones, nPr( ) 82
varianza, variance( ) 132
varPop( ) 132
varSamp( ), varianza de la muestra
132
vector propio, eigVc( ) 40
vectores
mostrar vector cilíndrico, 4Cylind
31
producto escalar, dotP( ) 39
producto vectorial, crossP( ) 26
unidades, unitV( ) 131
W
when( ), cuando 132
While, mientras 133
X
x2, cuadrado 144
xor, exclusiva booleana or 133
Z
zeroes( ), ceros 134
zInterval, z intervalo de confianza
136
187
188

Manual Ti Nspire CX Cas PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Manual Ti Nspire CX Cas PDF

Transféré par

Droits d'auteur :

Formats disponibles

Guía de Referencia

Este manual de instrucciones es válido para el software TI-Nspire

Plantilla de fracción Teclas /p

Nota: Consulte también / (división), en la página 142.

Plantilla de exponente Tecla l

Nota: Escriba el primer valor, pulse l , y escriba el exponente.

Nota: Consulte también ^ (potencia), en la página 143.

Plantilla de raíz cuadrada Teclas /q

Nota: Consulte también ‡() (raíz cuadrada), en la página

Plantilla de raíz enésima Teclas /l

Nota: Consulte también root(), en la página 101.

Guía de referencia de TI-Nspire™ CAS 1

Base el número e y exponente cualquiera

Plantilla de logaritmo Tecla /s

Calcula el logaritmo de la base que se indique. En el caso de la base

Plantilla de función definida a trozos (2 partes)

Permite crear expresiones y condiciones para una función definida a

Plantilla de función definida a trozos (N partes)

Permite crear expresiones y condiciones para una función definida a Ejemplo:

Nota: Consulte también piecewise(), en la página 87.

2 Guía de referencia de TI-Nspire™ CAS

Crea un sistema de dos ecuaciones . Para añadir una fila a un sistema

Plantilla de sistema de N ecuaciones

Permite crear un sistema de N ecuaciones . Solicita la introducción Ejemplo:

Nota: Consulte también system(), en la página 119.

Plantilla de valor absoluto

Permite introducir ángulos en formato gg°mm’ss.ss’’, donde gg es el

Crea una matriz de 2 por 2.

Guía de referencia de TI-Nspire™ CAS 3

La plantilla aparece tras la solicitud para especificar el número de filas Ejemplo:

Nota: Si la matriz que ha creado tiene gran cantidad de filas y

Plantilla de suma (G)

Nota: Consulte también G() (sumSeq), en la página 151.

Plantilla de producto (Π)

Nota: Consulte también Π() (prodSeq), en la página 151.

4 Guía de referencia de TI-Nspire™ CAS

Puede utilizar esta plantilla para calcular la derivada de primer orden

Plantilla de segunda derivada

Puede utilizar esta plantilla para calcular la derivada de segundo

Plantilla de derivada enésima

La plantilla de derivada enésima se puede utilizar para calcular la

Plantilla de integral definida

Nota: Consulte también ‰() integral(), en la página 149.

Plantilla de integral indefinida

Nota: Consulte también ‰() integral(), en la página 149.

Guía de referencia de TI-Nspire™ CAS 5

Utilice N o (N) para el límite izquierdo. Utilice + para el límite

6 Guía de referencia de TI-Nspire™ CAS

Calcula el valor absoluto de un argumento.

amortTbl(NPmt,N,I,PV, [Pmt], [FV], [PpY], [CpY], [PmtAt],

Función de amortización que genera una matriz como una tabla de

ExprBooleana1 and ExprBooleana2 ⇒ Expresión booleana

Guía de referencia de TI-Nspire™ CAS 7

Entero1 and Entero2 ⇒ entero En modo base Hex:

Compara bit a bit dos números enteros reales mediante una

angle(Expr1) ⇒ expresión En el modo de ángulo en grados:

En el modo de ángulo en radianes:

Devuelve una lista o matriz de ángulos de los elementos en Lista1 o

Realiza un análisis de varianza de un factor para comparar la media

stat.F Valor de la estadística F

stat.PVal Nivel de significancia mínimo al que se puede rechazar la hipótesis nula

stat.df Grados de libertad de los grupos

8 Guía de referencia de TI-Nspire™ CAS