manual ti nspire cx cas

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.

ii

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.

LicenciaSírvase ver la licencia completa instalada en C:\Program Files\TI Education\TI-Nspire CAS.

© 2006-2009 Texas Instruments Incorporated

iii

ÍndiceInformación importante

Plantillas de expresiónPlantilla de fracción .....................................1Plantilla de exponente ................................1Plantilla de raíz cuadrada ............................1Plantilla de raíz enésima .............................1Plantilla de base e ........................................2Plantilla de logaritmo ..................................2Plantilla de función definida a trozos (2 partes) ...........................................2Plantilla de función definida a trozos (N partes) ..........................................2Plantilla de sistema de 2 ecuaciones ...........3Plantilla de sistema de N ecuaciones ..........3Plantilla de valor absoluto ..........................3Plantilla de gg°mm’ss.ss’’ .............................3Plantilla de matriz (2 x 2) ............................3Plantilla de matriz (1 x 2) ............................4Plantilla de matriz (2 x 1) ............................4Plantilla de matriz (m x n) ...........................4Plantilla de suma (G) ....................................4Plantilla de producto (Π) .............................4Plantilla de primera derivada ......................5Plantilla de segunda derivada .....................5Plantilla de derivada enésima .....................5Plantilla de integral definida ......................5Plantilla de integral indefinida ...................5Plantilla de límite .........................................6

Listado alfabético

Aabs() ..............................................................7amortTbl() ....................................................7and ................................................................7angle() ..........................................................8ANOVA .........................................................8ANOVA de 2 variables .................................9Ans ..............................................................11approx() ......................................................114approxFraction() .......................................11aproxRational() ..........................................11arccos() ........................................................11arccosh() .....................................................12arccot() ........................................................12arccoth() .....................................................12arccsc() ........................................................12arccsch() ......................................................12arcLen() .......................................................12arcsec() ........................................................12arcsech() ......................................................12arcsin() ........................................................12arcsinh() ......................................................12arctan() .......................................................12arctanh() .....................................................12augment() ...................................................12avgRC() .......................................................13

Bbal() ............................................................ 134Base2 ......................................................... 144Base10 ....................................................... 144Base16 ....................................................... 15binomCdf() ................................................. 15binomPdf() ................................................. 15

Cceiling() ...................................................... 15centralDiff() ............................................... 16cFactor() ..................................................... 16char() .......................................................... 17charPoly() ................................................... 17c2 de 2 elementos ...................................... 17c2Cdf() ........................................................ 18c2GOF ......................................................... 18c2Pdf() ........................................................ 18ClearAZ ....................................................... 19ClrErr .......................................................... 19colAugment() ............................................. 19colDim() ...................................................... 19colNorm() ................................................... 19comDenom() .............................................. 20conj() .......................................................... 20constructMat() ........................................... 21CopyVar ...................................................... 21corrMat() .................................................... 214cos ............................................................. 22cos() ............................................................ 22cosê() .......................................................... 23cosh() .......................................................... 24coshê() ........................................................ 24cot() ............................................................ 24cotê() .......................................................... 25coth() .......................................................... 25cothê() ........................................................ 25count() ........................................................ 25countif() ..................................................... 26cPolyRoots() ............................................... 26crossP() ....................................................... 26csc() ............................................................. 27cscê() ........................................................... 27csch() ........................................................... 27cschê() ......................................................... 27cSolve() ....................................................... 28CubicReg .................................................... 30cumulativeSum() ........................................ 30Cycle ........................................................... 314Cylind ........................................................ 31cZeros() ....................................................... 31

Ddbd() ........................................................... 334DD ............................................................. 334Decimal ..................................................... 33Define (Definir) .......................................... 34Define LibPriv ............................................ 34Define LibPub ............................................ 35

iv

deltaList() ....................................................35deltaTmpCnv() ............................................35DelVar .........................................................35delVoid() .....................................................35derivative() .................................................35deSolve() .....................................................36det() ............................................................37diag() ...........................................................37dim() ............................................................37Disp .............................................................384DMS ...........................................................38dominantTerm() .........................................39dotP() ..........................................................39

Ee^() ..............................................................40eff() .............................................................40eigVc() .........................................................40eigVl() .........................................................41Else ..............................................................41ElseIf ............................................................41EndFor .........................................................41EndFunc ......................................................41EndIf ............................................................41EndLoop ......................................................41EndPrgm .....................................................41EndTry .........................................................41EndWhile ....................................................42exact() .........................................................42Exit ..............................................................424exp .............................................................42exp() ............................................................42exp4lista() ....................................................43expand() ......................................................43expr() ...........................................................44ExpReg ........................................................44

Ffactor() ........................................................45FCdf() ..........................................................46Fill ................................................................46FiveNumSummary ......................................47floor() ..........................................................47fMax() .........................................................47fMin() ..........................................................48For ...............................................................48format() ......................................................49fPart() ..........................................................49FPdf() ..........................................................49freqTable4list() ............................................50frequency() .................................................50Func .............................................................51FTest_2Samp ..............................................51

Ggcd() ............................................................52geomCdf() ...................................................52geomPdf() ...................................................52getDenom() ................................................52getLangInfo() .............................................53getLockInfo() ..............................................53getMode() ...................................................53getNum() ....................................................54

getVarInfo() ............................................... 54Goto ............................................................ 554Grad ........................................................... 55

Iidentity() ..................................................... 56If .................................................................. 56ifFn() ........................................................... 57imag() ......................................................... 57impDif() ...................................................... 58Indirection .................................................. 58inString() .................................................... 58int() ............................................................. 58intDiv() ........................................................ 58integral ....................................................... 58invc2() ......................................................... 59invF() .......................................................... 59invNorm() ................................................... 59invt() ........................................................... 59iPart() .......................................................... 59irr() .............................................................. 59isPrime() ...................................................... 60isVoid() ....................................................... 60

LLbl ............................................................... 60lcm() ............................................................ 61left() ............................................................ 61libShortcut() ............................................... 61limit() o lim() .............................................. 62LinRegBx ..................................................... 62LinRegMx ................................................... 63LinRegtIntervals ......................................... 64LinRegTTest (Test t de regresión lineal) ......................................... 65linSolve() ..................................................... 66@List() .......................................................... 66list4mat() ..................................................... 664ln ................................................................ 67ln() .............................................................. 67LnReg .......................................................... 67Local ........................................................... 68Lock ............................................................ 68log() ............................................................ 694logbase ...................................................... 69Logistic ....................................................... 70LogisticD ..................................................... 71Loop ............................................................ 72LU ................................................................ 72

Mmat4list() ..................................................... 73max() ........................................................... 73mean() ........................................................ 73median() ..................................................... 74MedMed ..................................................... 74mid() ........................................................... 75min() ........................................................... 75mirr() ........................................................... 75mod() .......................................................... 76mRow() ....................................................... 76mRowAdd() ................................................ 76MultReg ...................................................... 76

v

MultRegIntervals ........................................77MultRegTests ..............................................77

NnCr() ............................................................78nDerivative() ...............................................79newList() .....................................................79newMat() ....................................................79nfMax() .......................................................79nfMin() ........................................................80nInt() ...........................................................80nom() ..........................................................80norm() .........................................................81normalLine() ...............................................81normCdf() ...................................................81normPdf() ...................................................81not ..............................................................81nPr() ............................................................82npv() ............................................................83nSolve() .......................................................83

OOneVar .......................................................84or .................................................................85ord() ............................................................85

PP4Rx() ...........................................................86P4Ry() ...........................................................86PassErr .........................................................86piecewise() ..................................................87poissCdf() ....................................................87poissPdf() ....................................................874Polar ..........................................................87polyCoeffs() ................................................88polyDegree() ..............................................88polyEval() ....................................................88polyGcd() ....................................................89polyQuotient() ...........................................89polyRemainder() ........................................89polyRoots() .................................................90PowerReg ...................................................90Prgm ...........................................................91prodSeq() ....................................................91Product (PI) .................................................91product() .....................................................91propFrac() ...................................................92

QQR ...............................................................92QuadReg .....................................................93QuartReg ....................................................94

RR4Pq() ..........................................................95R4Pr() ...........................................................954Rad .............................................................95rand() ..........................................................95randBin() .....................................................96randInt() .....................................................96randMat() ...................................................96randNorm() .................................................96randPoly() ...................................................96

randSamp() ................................................ 97RandSeed ................................................... 97real() ........................................................... 974Rect ........................................................... 97ref() ............................................................. 98remain() ...................................................... 99Request ...................................................... 99RequestStr ................................................ 100Return ...................................................... 100right() ....................................................... 100root() ........................................................ 101rotate() ..................................................... 101round() ..................................................... 102rowAdd() .................................................. 102rowDim() .................................................. 102rowNorm() ............................................... 102rowSwap() ................................................ 102rref() ......................................................... 103

Ssec() .......................................................... 103sec/() ......................................................... 103sech() ........................................................ 104sechê() ...................................................... 104seq() .......................................................... 104series() ...................................................... 105setMode() ................................................. 106shift() ........................................................ 107sign() ......................................................... 108simult() ..................................................... 1084sin ............................................................ 109sin() ........................................................... 109sinê() ......................................................... 110sinh() ......................................................... 110sinhê() ....................................................... 110SinReg ...................................................... 111solve() ....................................................... 112SortA ........................................................ 114SortD ........................................................ 1144Sphere ..................................................... 115sqrt() ......................................................... 115stat.results ................................................ 116stat.values ................................................ 117stDevPop() ................................................ 117stDevSamp() ............................................. 117Stop .......................................................... 118Store ......................................................... 118string() ...................................................... 118subMat() ................................................... 118Sum (Sigma) ............................................. 118sum() ......................................................... 119sumIf() ...................................................... 119sumSeq() ................................................... 119system() .................................................... 119

TT (transponer) .......................................... 120tan() .......................................................... 120tanê() ........................................................ 121tangentLine() ........................................... 121tanh() ........................................................ 121tanhê() ...................................................... 122taylor() ...................................................... 122

vi

tCdf() .........................................................122tCollect() ...................................................123tExpand() ..................................................123Text ...........................................................123Then ..........................................................123tInterval ....................................................124tInterval_2Samp .......................................124tmpCnv() ...................................................125@tmpCnv() .................................................125tPdf() .........................................................126trace() ........................................................126Try .............................................................126tTest ..........................................................127tTest_2Samp .............................................128tvmFV() .....................................................128tvmI() .........................................................128tvmN() .......................................................129tvmPmt() ...................................................129tvmPV() .....................................................129TwoVar .....................................................130

UunitV() .......................................................131unLock ......................................................131

VvarPop() ....................................................132varSamp() ..................................................132

Wwhen() .......................................................132While .........................................................133“With” ......................................................133

Xxor .............................................................133

Zzeros() .......................................................134zInterval ....................................................136zInterval_1Prop ........................................136zInterval_2Prop ........................................137zInterval_2Samp .......................................137zTest ..........................................................138zTest_1Prop ..............................................138zTest_2Prop ..............................................139zTest_2Samp .............................................140

Símbolos+ (suma) ....................................................141N(resta) ......................................................141·(multiplicación) ......................................142à (división) ................................................142^ (potencia) ..............................................143x2 (cuadrado) ............................................144.+ (punto suma) ........................................144.. (punto resta) .........................................144.·(punto multiplic.) ..................................144. / (punto división) ....................................145.^ (punto de potencia) .............................145

ë(negación) .............................................. 145% (porcentaje) ......................................... 145= (igual) .................................................... 146ƒ (no igual) ............................................... 146< (menor que) .......................................... 147{ (menor o igual que) .............................. 147> (mayor que) ........................................... 147| (mayor o igual que) .............................. 148! (factorial) ............................................... 148& (añadir) ................................................. 148d() (derivada) ........................................... 149‰() (integral) .............................................. 149‡() (raíz cuadrada) ................................... 150Π() (prodSeq) ............................................ 151G() (sumSeq) ............................................. 151GInt() ......................................................... 152GPrn() ........................................................ 153# (dirección) ............................................. 153í (notación científica) .............................. 153g (grado centesimal) ................................ 154ô(radián) ................................................... 154¡ (grado) ................................................... 154¡, ', '' (grados/minutos/segundos) ........... 155 (ángulo) ................................................ 155' (primo) .................................................... 155_ (carácter de subrayado como elemento vacío) ....................................... 156_ (carácter de subrayado como designador de unidad) ............................ 1564 (convertir) .............................................. 15610^() .......................................................... 156^ê (inverso de un valor) ........................... 157| (“with”) .................................................. 157& (almacenar) .......................................... 158:= (asignar) ............................................... 158© (comentario) ......................................... 1580b, 0h ........................................................ 159

Elementos vacíos (sin valor)Cálculos que incluyen elementos sin valor .................................................... 160Listas de argumentos que contienen elementos sin valor .................................. 160

Métodos abreviados para introducir expresiones matemáticas

Jerarquía de EOS™ (Sistema operativo de ecuaciones)

Códigos y mensajes de error

Información sobre productos, servicios y garantías de TI

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

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ónLas 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

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

Ejemplo:

Plantilla de exponente Tecla l

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.

Ejemplo:

Plantilla de raíz cuadrada Teclas /q

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

Ejemplo:

Plantilla de raíz enésima Teclas /l

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

Ejemplo:

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

Plantilla de base e Teclas u

Base el número e y exponente cualquiera

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

Ejemplo:

Plantilla de logaritmo Tecla /s

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.

Ejemplo:

Plantilla de función definida a trozos (2 partes)Catálogo >

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.

Ejemplo:

Plantilla de función definida a trozos (N partes)Catálogo >

Permite crear expresiones y condiciones para una función definida a trozos con N-partes. Solicita la introducción del número de partes, N.

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

Ejemplo:Consulte el ejemplo de la plantilla definida a trozos (2 partes).


Plantilla de sistema de 2 ecuacionesCatálogo >

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.

Ejemplo:

Plantilla de sistema de N ecuacionesCatálogo >

Permite crear un sistema de N ecuaciones . Solicita la introducción del número de ecuaciones, N.

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

Ejemplo:Consulte el ejemplo de Plantilla de sistema de ecuaciones (2 ecuaciones).

Plantilla de valor absolutoCatálogo >

Nota: Consulte también abs(), en la página 7.

Ejemplo:

Plantilla de gg°mm’ss.ss’’Catálogo >

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.

Ejemplo:

Plantilla de matriz (2 x 2)Catálogo >

Crea una matriz de 2 por 2.

Ejemplo:



.

Ejemplo:


Ejemplo:

Plantilla de matriz (m x n)Catálogo >

La plantilla aparece tras la solicitud para especificar el número de filas y columnas.

Nota: Si la matriz que ha creado tiene gran cantidad de filas y columnas puede tardar unos minutos en aparecer.

Ejemplo:

Plantilla de suma (G)Catálogo >

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

Ejemplo:

Plantilla de producto (Π)Catálogo >

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

Ejemplo:


Plantilla de primera derivadaCatálogo >

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.

Ejemplo:

Plantilla de segunda derivadaCatálogo >

Puede utilizar esta plantilla para calcular la derivada de segundo orden en un punto.


Ejemplo:

Plantilla de derivada enésimaCatálogo >

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


Ejemplo:

Plantilla de integral definidaCatálogo >

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

Ejemplo:

Plantilla de integral indefinidaCatálogo >

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

Ejemplo:


Plantilla de límiteCatálogo >

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.

Ejemplo:


Listado alfabéticoLos 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) ⇒ listaabs(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.

andCatálogo >

ExprBooleana1 and ExprBooleana2 ⇒ Expresión booleanaListaBooleana1 and ListaBooleana2 ⇒ Lista booleanaMatrizBooleana1 and MatrizBooleana2 ⇒ Matriz booleana

Muestra el resultado verdadero o falso o una forma simplificada de la entrada original.


Entero1 and Entero2 ⇒ entero

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 correspondientes, el resultado es 1 si ambos bits son 1; en caso contrario, el resultado será 0. El valor 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 entrada binaria o hexadecimal es necesario utilizar el prefijo 0b o 0h, 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 formato binario con signo de 64 bits, se utiliza una operación de módulo simétrico para llevar el valor al rango apropiado.

En modo base Hex:

Importante: Cero, no la letra O.

En modo base Bin:

En modo base Dec:

Nota: Una entrada binaria puede tener hasta 64 dígitos (sin contar el prefijo 0b). Una entrada hexadecimal puede tener hasta 16 dígitos.

angle()Catálogo >

angle(Expr1) ⇒ expresión

Devuelve el ángulo del argumento, interpretando el argumento como un número complejo.


En el modo de ángulo en grados:

En el modo de ángulo en grados centesimales:

En el modo de ángulo en radianes:

angle(Lista1) ⇒ listaangle(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.

ANOVACatá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 salida

Descripción

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

andCatálogo >


Salidas: Estudio conjunto

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 variablesCatá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,…}

Variable de salida

Descripción

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

Variable de salida

Descripción


Salidas para la variable COLUMNA

Salidas para la variable FILA

Salidas para INTERACCIÓN

Salida para ERROR

Variable de salida

Descripción

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

Variable de salida

Descripción

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

Variable de salida

Descripción

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

Variable de salida

Descripción




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) ⇒ listaapprox(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ónLista 4approxFraction([Tol]) ⇒ listaMatriz 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ónaproxRational(Lista[, Tol]) ⇒ listaaproxRational(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.


B

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ónavgRC(Expr1, Var [=Valor] [, Lista1]) ⇒ listaavgRC(Lista1, Var [=Valor] [, Paso]) ⇒ listaavgRC(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.

bal()Catálogo >

bal(NPmt,N,I,PV ,[Pmt], [FV], [PpY], [CpY], [PmtAt], [redondValor]) ⇒ valorbal(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.






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.

augment()Catálogo >


4Base2 Catálogo >

Entero1 4Base2 ⇒ entero

Nota: Si desea insertar esta función con el teclado del ordenador, escriba @>Base2.

Convierte Entero1 en un número binario. Los números binarios o hexadecimales llevan siempre un prefijo 0b o 0h, respectivamente.

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úmeroBinario0h NúmeroHexadecimal

Cero, no la letra O, seguido de b o h.

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.





C

4Base16 Catálogo >


Nota: Si desea insertar este operador con el teclado del ordenador, escriba @>Base16.

Convierte Entero1 en un número hexadecimal. Los números binarios o hexadecimales llevan siempre un prefijo 0b o 0h, respectivamente.




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 formato binario con signo de 64 bits, 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.

binomCdf()Catálogo >

binomCdf(n,p) ⇒ númerobinomCdf(n,p,Extremoinferior,Extremosuperior) ⇒ número si Extremoinferior y Extremosuperior son números, lista si Extremoinferior y Extremosuperior son listasbinomCdf(n,p,Extremosuperior) para P(0XExtremosuperior) ⇒ 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úmerobinomPdf(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.

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) ⇒ listaceiling(Matriz1) ⇒ matriz

Devuelve una lista o una matriz con los correspondientes menores enteros.


centralDiff()Catálogo >

centralDiff(Expr1,Var [=Valor][,Paso]) ⇒ expresióncentralDiff(Expr1,Var [,Paso])|Var=Valor ⇒ expresióncentralDiff(Expr1,Var [=Valor][,Lista]) ⇒ listacentralDiff(Lista1,Var [=Valor][,Paso]) ⇒ listacentralDiff(Matriz1,Var [=Valor][,Paso]) ⇒ matriz

Devuelve la derivada numérica utilizando la fórmula de cociente de diferencia central.

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.

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óncFactor(Lista1[,Var]) ⇒ listacFactor(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ómicacharPoly(Matrizcuadrada,Expr) ⇒ expresión polinómicacharPoly(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 ObsMatrizchi22way 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.

Variable de salida

Descripción

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 >

c2Cdf(Extremoinferior,Extremosuperior,gl) ⇒ número si Extremoinferior y Extremosuperior son números, lista si Extremoinferior y Extremosuperior son listas

chi2Cdf(Extremoinferior,Extremosuperior,gl) ⇒ número si Extremoinferior y Extremosuperior son números, lista si Extremoinferior y Extremosuperior son listas

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.

Para obtener más información sobre el efecto de los elementos vacíos en una lista, consulte “Elementos vacíos (sin valor)” en la página 160.

c2GOF Catálogo >

c2GOF obsLista,expLista,glchi2GOF 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).


Variable de salida

Descripción

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 >

c2Pdf(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.



ClearAZCatá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.

ClrErrCatálogo >

ClrErr

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).

Para ver un ejemplo de ClrErr, consulte el ejemplo 2 de la orden Try, en la página 127.

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óncomDenom(Lista1[,Var]) ⇒ listacomDenom(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ónconj(Lista1) ⇒ listaconj(Matriz1) ⇒ matriz

Muestra el complejo conjugado del argumento.



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.

CopyVarCatálogo >

CopyVar Var1, Var2CopyVar 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

Nota: Si desea insertar este operador con el teclado del ordenador, 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óncos(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.





cos(Matrizcuadrada1) ⇒ Matrizcuadrada

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óncosê(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.

Nota: Si desea insertar esta función con el teclado del ordenador, escriba arccos(...).




cosê(Matrizcuadrada1) ⇒ Matrizcuadrada

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.

En el modo de ángulo en radianes y formato complejo rectangular:


cos() Tecla μ


cosh()Catálogo >

cosh(Expr1) ⇒ expresióncosh(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

Devuelve el coseno hiperbólico de la matriz Matrizcuadrada1. El resultado no es igual que calcular el coseno hiperbólico de cada elemento. Para obtener más información sobre el método de cálculo, consulte cos().



coshê() Catálogo >

coshê(Expr1) ⇒ expresióncoshê(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.

Nota: Si desea insertar esta función con el teclado del ordenador, escriba arccosh(...).

coshê(Matrizcuadrada1) ⇒ Matrizcuadrada

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().




cot() Tecla μ

cot(Expr1) ⇒ expresióncot(Lista1) ⇒ lista

Devuelve la cotangente de Expr1 o una lista de las cotangentes 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.





cotê() Tecla μ

cotê(Expr1) ⇒ expresióncotê(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.

Nota: Si desea insertar esta función con el teclado del ordenador, escriba arccot(...).




coth()Catálogo >

coth(Expr1) ⇒ expresióncoth(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óncothê(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.

Nota: Si desea insertar esta función con el teclado del ordenador, 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 información sobre los elementos vacíos consulte la página 160.

En el último ejemplo, sólo se han contado los valores 1/2 y 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.

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.

• 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 celdas en lugar de Lista.

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(), en la página 50.

Cuenta el número de elementos que son iguales a 3.

Cuenta el número de elementos que son iguales a “def”.

Cuenta el número de elementos que son iguales a x; en este ejemplo se supone que la variable x está sin definir.

Cuenta 1 y 3.

Cuenta 3, 5 y 7.

Cuenta 1, 3, 7 y 9.

cPolyRoots()Catálogo >

cPolyRoots(Poli,Var) ⇒ listacPolyRoots(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óncsc(Lista1) ⇒ lista

Devuelve la cosecante de Expr1 o una lista de las cosecantes de todos los elementos de Lista1.




cscê() Tecla μ

cscê(Expr1) ⇒ expresióncscê(Lista1) ⇒ lista

Devuelve el ángulo cuya cosecante es Expr1 o una lista de las cosecantes inversas de todos los elementos de Lista1.


Nota: Si desea insertar esta función con el teclado del ordenador, escriba arccsc(...).




csch()Catálogo >

csch(Expr1) ⇒ expresióncsch(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óncschê(Lista1) ⇒ listaDevuelve la cosecante hiperbólica inversa de Expr1 o una lista de las cosecantes hiperbólicas inversas de todos los elementos de Lista1.

Nota: Si desea insertar esta función con el teclado del ordenador, escriba arccsch(...).


cSolve()Catálogo >

cSolve(Ecuación, Var) ⇒ Expresión boolenacSolve(Equación, Var=Conjetura) ⇒ Expresión booleanacSolve(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 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.

En modo Mostrar dígitos como Fijo 2:


Si utiliza var_, la variable será tratada como un número complejo.

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 real:

z_ tratado como complejo:

cSolve(Ecuación1 and Ecuación2 [and …],

VarOConjetura1, VarOConjetura2 [, … ])

⇒ Expresión booleanacSolve(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 ningún valor inicial, cSolve() utiliza el método de eliminación léxica de Gröbner/Buchberger para tratar de determinar todas las soluciones complejas.

Nota: Los ejemplos siguientes utilizan un carácter de subrayado

(pulse /_) para que las variables se puedan considerar como números complejos.


Las soluciones complejas pueden incluir tanto números reales como no reales, tal y como se indica en el ejemplo de la derecha.


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.


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 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.


cSolve()Catálogo >


CubicRegCatá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.


Variable de salida

Descripción

stat.RegEqn Ecuación de regresión: a·x3+b·x2+c·x+d

stat.a, stat.b, stat.c, stat.d

Coeficientes de regresión

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 restricciones de Frec, Lista Categoría e Incluir Categoría

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


CycleCatálogo >

Cycle

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).



Listado de función que suma los enteros de 1 a 100 omitiendo 50.

4Cylind Catálogo >

Vector 4Cylind

Nota: Si desea insertar este operador con el teclado del ordenador, 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

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().

En modo Mostrar dígitos como Fijo 3:


Nota: Si Expr 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. Si utiliza var_ , la variable será tratada como un número 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.

z tratado como real:

z_ tratado como complejo:

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.

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 expresiones son polinomios y NO se ha especificado 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 complejos.

Nota: Los ejemplos siguientes utilizan un carácter de

subrayado _ (pulse /_) para que las variables se puedan considerar como números 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.

cZeros()Catálogo >


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 ⇒ valorLista1 4DD ⇒ listMatriz1 4DD ⇒ matriz

Nota: Si desea insertar este operador con el teclado del ordenador, 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.




4Decimal Catálogo >

Expresión1 4Decimal ⇒ expresiónLista1 4Decimal ⇒ expresiónMatriz1 4Decimal ⇒ expresión

Nota: Si desea insertar este operador con el teclado del ordenador, 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).



Nota: Consulte también Define LibPriv, en la página 34 y Define LibPub, en la página 35.

Define LibPrivCatá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 LibPubCatá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.

DelVarCatá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(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) ⇒ matrizdiag(Matrizfila) ⇒ matrizdiag(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.

deSolve()Catálogo >


DispCatá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.



4DMS Catálogo >

Expr 4DMSList 4DMSMatriz 4DMS

Nota: Si desea insertar este operador con el teclado del ordenador, 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óndominantTerm(Expr1, Var [, Punto]) | Var>Punto

⇒ expresióndominantTerm(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

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 = [x1, x2, … , xn], entonces:

x12 + x2

2 + … + xn2 = 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.

En el formato complejo rectangular:



eigVl()Catálogo >

eigVl(Matrizcuadrada) ⇒ lista

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.

En el modo de formato complejo rectangular:


Else Consulte If, en la página 56.

ElseIfCatálogo >

If ExprBooleana1 Then Bloque1

ElseIf ExprBooleana2 Then Bloque2 ©

ElseIf ExprBooleanaN Then BloqueN

EndIf ©



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ónexact(Lista1 [, Tolerancia]) ⇒ listaexact(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).

ExitCatálogo >

Exit

Sale del bloque For, While o Loop actual.

Exit no está admitido fuera de las tres estructuras de bucle (For, While o Loop).



Listado de funciones:

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.

Nota: Si desea insertar este operador con el teclado del ordenador, 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(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 información sobre el método de cálculo, consulte cos().


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ónexpand(Lista1 [,Var]) ⇒ listaexpand(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.

exp() Tecla u


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.

ExpRegCatá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).







expand()Catálogo >


F

Variable de salida

Descripción

stat.RegEqn Ecuación de regresión: a·(b)x

stat.a, stat.b Coeficientes de regresión

stat.r2 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

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 restricciones de Frec, Lista Categoría e Incluir Categoría


factor()Catálogo >

factor(Expr1[, Var]) ⇒ expresiónfactor(Lista1[,Var]) ⇒ listafactor(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.


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.

FillCatá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.

factor()Catálogo >


FiveNumSummaryCatá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 stat.results. (Consulte la página 116).

X representa una lista que contiene los datos.

Frec es una lista opcional de valores de frecuencia. Cada elemento 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.

Variable de salida

Descripción

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) ⇒ listafloor(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 booleanafMax(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.


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 booleanafMin(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().

ForCatálogo >

For Var, Inferior, Superior [, Paso] BloqueEndFor

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.

Bloque puede ser una sentencia sencilla o una serie de sentencias separadas por el carácter “:”.



fMax()Catálogo >


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ónfPart(Lista1) ⇒ listafPart(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.

Nota: Si desea insertar esta función con el teclado del ordenador, 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.

Cada elemento del resultado se corresponde con el número de elementos de Lista1 comprendidos en el rango. Expresado en términos de la función countIf(), el resultado es { countIf(list, ?{b(1)), countIf(list, b(1)<?{b(2)), …, countIf(list, b(n-1)<?{b(n)), countIf(list, b(n)>?)}.

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.

Explicación del resultado:2 elementos de Datalist que son {2.54 elementos de Datalist que son >2.5 y {4.53 elementos de Datalist que son >4.5El elemento “hello” es una cadena y no se puede incluir en ninguno de los rangos definidos.


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>0Para Ha: s1 ƒ s2 (predeterminado), defina Hipótesis =0Para Ha: s1 < s2, defina Hipótesis<0


Variable de salida

Descripción

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 stat.x2_bar

Medias de la muestra de las sucesiones de datos en Lista 1 y Lista 2

stat.n1, stat.n2 Tamaño de las muestras

FuncCatálogo >

FuncBloque

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.



Definir una función a trozos:

Resultado de representar gráficamente g(x)


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 Extremoinferior y Extremosuperior son números, lista si Extremoinferior y Extremosuperior son listas

geomCdf(p,Extremosuperior) para P(1XExtremosuperior)⇒ 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) ⇒ valorgetMode(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 delentero

Configuración de enteros

Display Digits (Mostrar dígitos)

1 1=Flotante, 2=Flotante1, 3=Flotante2, 4=Flotante3, 5=Flotante4, 6=Flotante5, 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 (Formato exponencial)

3 1=Normal, 2=Científico, 3=Ingeniería

Real or Complex (Real o complejo)

4 1=Real, 2=Rectangular, 3=Polar

Auto or Approximate (Auto o aproximado)

5 1=Auto, 2=Aproximado, 3=Exacto

Vector Format (Formato vectorial)

6 1=Rectangular, 2=Cilíndrico, 3=Esférico

Base 7 1=Decimal, 2=Hex, 3=Binario

Unit System (Sistema de unidades)

8 1=SI, 2=Inglés/EE UU

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 cadenagetVarInfo(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.

Nombre del modo

Modo delentero



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.

GotoCatá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.



4Grad Catálogo >

Expr1 4Grad ⇒ expresión

Convierte Expr1 a grados centesimales.

Nota: Si desea insertar este operador con el teclado del ordenador, escriba @>Grad.



getVarInfo()Catálogo >


I

identity()Catálogo >

identity(Entero) ⇒ matriz

Devuelve la matriz identidad de dimensión Entero.

Entero debe ser un número entero positivo.

IfCatálogo >

If Declarac ExprBooleanaIf ExprBooleana Then

BloqueEndIf

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.

Bloque puede ser una sentencia sencilla o una serie de sentencias separadas por el carácter “:”.



If ExprBooleana Then Bloque1Else Bloque2EndIf

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 ExprBooleana1 Then Bloque1

ElseIf ExprBooleana2 Then Bloque2

© ElseIf ExprBooleanaN Then

BloqueNEndIf

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 siguientes:

• ExprBooleana puede verificar un valor, lista o matriz únicos. • Si un elemento de ExprBooleana verifica la condición, devuelve

el elemento correspondiente de Valor_Si_verd.• Si un elemento de ExprBooleana no verifica la condición,

devuelve el elemento correspondiente de Valor_Si_falso. Si se omite Valor_Si_falso, devuelve un valor sin definir.

• 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.

• Si el argumento segundo, tercero o cuarto de la función ifFn() es 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 tener las mismas dimensiones, y el resultado tendrá también la misma dimensión.

Al ser 1 menor que 2.5 su valor correspondiente en Valor_Si_verd, el 5, se copia.

Al ser 2 menor que 2.5 su valor correspondiente en Valor_Si_verd, el 6, se copia.

Al ser 3 mayor que 2.5 su valor correspondiente en Valor_Si_falso, el 10, se copia.

Valor_Si_verd es un valor sencillo y corresponde a cualquier posición seleccionada.

Valor_Si_falso está sin especificar. Se utilizar Undef (sin definir).

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.

Nota: Se considera que todas las variables no definidas son variables reales. Consulte también real(), en la página 97.

IfCatá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) ⇒ enteroint(Lista1) ⇒ listaint(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) ⇒ enterointDiv(Lista1, Lista2) ⇒ listaintDiv(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.

imag()Catálogo >


invc2() Catálogo >

invc2(Á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) ⇒ enteroiPart(Lista1) ⇒ listaiPart(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.


L

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, isPrime(Número) muestra un mensaje de error.

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.



Función para hallar el siguiente primo tras un número especificado:

isVoid()Catálogo >

isVoid(Var) ⇒ Expresión booleana constanteisVoid(Expr) ⇒ Expresión booleana constanteisVoid(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.

LblCatá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:




lcm()Catálogo >

lcm(Número1, Número2) ⇒ expresiónlcm(Lista1, Lista2) ⇒ listalcm(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, CadenaNombreAccesoDirecto[, EtiquetaBibliotecaPriv]) ⇒ lista de variables

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.

En este ejemplo se supone la existencia de un documento de biblioteca llamado linalg2 almacenado y actualizado correctamente y que contiene objetos definidos como clearmat, gauss1 y gauss2.


limit() o lim()Catálogo >

limit(Expr1, Var, Punto [,Dirección]) ⇒ expresiónlimit(Lista1, Var, Punto [, Dirección]) ⇒ listalimit(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.

LinRegBxCatá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 frecuencia Frec. El resumen de los resultados se guarda en la variable stat.results. (Consulte la página 116).

Todas las listas, salvo Incluir, han de tener la misma dimensión.







Variable de salida

Descripción

stat.RegEqn Ecuación de regresión: a+b·x


stat.r2 Coeficiente de determinación

stat.r Coeficiente de correlació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ías

stat.YReg Lista de puntos de datos en la Lista Y modificada utilizada realmente en la regresión basada en las restricciones de Frec, Lista Categoría e Incluir Categorías


LinRegMxCatá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 frecuencia Frec. El resumen de los resultados se guarda en la variable stat.results. (Consulte la página 116).




Categoría es una lista de códigos categoría para los correspondientes datos de X e Y..



Variable de salida

Descripción

stat.RegEqn Ecuación de regresión: m·x+b

stat.m, stat.b Coeficientes de regresión






Sólo para tipo de pendiente



LinRegtIntervalsCatá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.

El resumen de los resultados se guarda en la variable stat.results. (Consulte la página 116).

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.

Variable de salida

Descripción

stat.RegEqn Ecuación de regresión: a+b·x


stat.df Grados de libertad




Variable de salida

Descripción

[stat.CLower, stat.CUpper]

Intervalo de confianza para la pendiente.

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

Variable de salida

Descripción


Sólo para el tipo de respuesta

Variable de salida

Descripción

[stat.CLower, stat.CUpper]

Intervalo de confianza para la respuesta media


stat.SE Error estándar de la respuesta media

[stat.LowerPred, stat.UpperPred]

Intervalo de predicción para una única observación

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.



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=0Para Ha: b<0 y r<0, defina Hipótesis<0Para Ha: b>0 y r>0, defina Hipótesis>0



Variable de salida

Descripción

stat.RegEqn Ecuación de regresión: a + b·x

stat.t t Test estadístico para significancia





stat.s Error estándar para la recta

stat.SESlope Error estándar de la pendiente




linSolve()Catálogo >

linSolve( SistemaEcuaLineales, Var1, Var2, ...) ⇒ listalinSolve(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

Nota: Si desea insertar esta función con el teclado del ordenador, 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.

Nota: Si desea insertar esta función con el teclado del ordenador, escriba list@>mat(...).

Variable de salida

Descripción


4ln Catálogo >

Expr 4ln ⇒ expresión

Hace que Expr se convierta en una expresión que contiene sólo logaritmos naturales (ln).

Nota: Si desea insertar este operador con el teclado del ordenador, escriba @>ln.

ln() Teclas /u

ln(Expr1) ⇒ expresiónln(Lista1) ⇒ lista

Devuelve el logaritmo natural del argumento.

Para una lista, devuelve los logaritmos naturales de los elementos.Si el modo de formato complejo es Real:

Si el modo de formato complejo es Rectangular:

ln(Matrizcuadrada1) ⇒ Matrizcuadrada

Devuelve el logaritmo natural de la matriz Matrizcuadrada1. El resultado no es igual que calcular el logaritmo natural de cada elemento. Para obtener más información sobre el método de cálculo, consulte cos().




LnRegCatá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).








Variable de salida

Descripción

stat.RegEqn Ecuación de regresión: a+b·ln(x)



stat.r Coeficiente de correlación para los datos transformados (ln(x), y)

stat.Resid Residuos asociados al modelo logarítmico





LocalCatá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.



LockCatá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ónlog(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

Devuelve el logaritmo base Expr de la matriz Matrizcuadrada1. El resultado no es igual que calcular el logaritmo base -Expr de cada elemento. Para obtener más información sobre el método de cálculo, consulte cos().


Si se omite el argumento base, la utilizada será 10.



4logbase Catálogo >

Expr 4logbase(Expr1) ⇒ expresión

Simplifica la Expresión de entrada a una expresión que utiliza base Expr1.

Nota: Si desea insertar este operador con el teclado del ordenador, escriba @>logbase(...).


LogisticCatá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 variable stat.results. (Consulte la página 116).







Variable de salida

Descripción

stat.RegEqn Ecuación de regresión: c/(1+a·e-bx)

stat.a, stat.b, stat.c Coeficientes de regresión






LogisticDCatá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 stat.results. (Consulte la página 116).



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.





Variable de salida

Descripción

stat.RegEqn Ecuación de regresión: c/(1+a·e-bx)+d)





stat.YReg Lista de puntos de datos en la Lista Y modificada utilizada realmente en la regresión basada en restricciones de Frec, Lista Categoría e Incluir Categorías



LoopCatálogo >

LoopBloque

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 “:”.



LUCatá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 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.

Nota: Si desea insertar esta función con el teclado del ordenador, escriba mat@>list(...).

max()Catálogo >

max(Expr1, Expr2) ⇒ expresiónmax(Lista1, Lista2) ⇒ listamax(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

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.


En el formato de vector rectangualr:


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.

Cada elemento de Matrizfrecuencia cuenta el número de ocurrencias consecutivas del elemento correspondiente en 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 vacíos, consulte la página 160.

MedMedCatá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 variable stat.results. (Consulte la página 116).







Variable de salida

Descripción

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ónmin(Lista1, Lista2) ⇒ listamin(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ónmod(Lista1, Lista2) ⇒ listamod(Matriz1, Matriz2) ⇒ matriz

Devuelve el primer argumento módulo del segundo argumento según estas definiciones:

mod(x,0) = xmod(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

MultRegCatá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 stat.results. (Consulte la página 116).



Variable de salida

Descripción

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

stat.yLista yLista = b0+b1·x1+ ...



Salidas

MultRegIntervalsCatá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.




Variable de salida

Descripción


stat.y 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,stat.UpperrPred

Intervalo de predicción para una única observación

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,...}


MultRegTestsCatá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.



Variable de salida

Descripción


stat.F Test estadístico F general


N

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

stat.yLista 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

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!)

Variable de salida

Descripción


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.

Cuando se especifica, valor sobrescribe cualquier otra asignación de 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) ⇒ valornfMax(Expr, Var, Extremoinferior) ⇒ valornfMax(Expr, Var, Extremoinferior, Extremosuperior) ⇒ valornfMax(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().

nCr()Catálogo >


nfMin()Catálogo >

nfMin(Expr, Var) ⇒ valornfMin(Expr, Var, Extremoinferior) ⇒ valornfMin(Expr, Var, Extremoinferior, Extremosuperior) ⇒ valornfMin(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ónnorm(Vector) ⇒ expresión

Devuelve la norma de Frobenius.

normalLine()Catálogo >

normalLine(Expr1,Var,Punto) ⇒ expresiónnormalLine(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úmero si Extremoinferior y Extremosuperior son números, lista si Extremoinferior y Extremosuperior son listas

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.

notCatálogo >

not ExprBooleana ⇒ Expresión booleana

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


not Entero1 ⇒ entero

Devuelve el complemento a uno para un número entero real. 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 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).


En modo base Hex:

En modo base Bin:

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.

notCatálogo >



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_cadenanSolve(Ecuación,Var[=Conjetura],Extremoinferior)⇒ número o error_cadena

nSolve(Ecuación,Var[=Conjetura],Extremoinferior,Extremosuperior) ⇒ número o error_cadenanSolve(Ecuación,Var[=Conjetura]) | Extremoinferior<Var<Extremosuperior⇒ número o error_cadena

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.

Nota: Si hay varias soluciones, puede utilizar una conjetura que le ayude a hallar una solución concreta.

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

OneVarCatá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. El resumen de los resultados se guarda en la variable stat.results. (Consulte la página 116.)


Los argumentos de X son listas de datos.

Frec es una lista opcional de valores de frecuencia. Cada elemento 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 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.

Variable de salida

Descripción

stat.v Media de los valores de x

stat.Gx Suma de los valores de x

stat.Gx2 Suma de los valores de x2

stat.sx Desviación estándar de la muestra x

stat.ssssx 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


orCatá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.



Entero1 or Entero2 ⇒ entero

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 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 el resultado de los bits, y aparece conforme al modo base especificado.



Nota: Consulte xor.

En modo base Hex:


En modo base Bin:


ord()Catálogo >

ord(Cadena) ⇒ enteroord(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ónP4Rx(rLista, qLista) ⇒ listaP4Rx(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.

Nota: Si desea insertar esta función con el teclado del ordenador, escriba P@>Rx(...).


P4Ry() Catálogo >

P4Ry(rExpr, qExpr) ⇒ expresiónP4Ry(rLista, qLista) ⇒ listaP4Ry(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.

Nota: Si desea insertar esta función con el teclado del ordenador, escriba P@>Ry(...).


PassErrCatálogo >

PassErr

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.



Para ver un ejemplo de PassErr, consulte el Ejemplo 2 de la orden Try, en la página 127.


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 Extremoinferior y Extremosuperior son números, lista si Extremoinferior y Extremosuperior son listas

poissCdf(l,Extremosuperior) (para P(0XExtremosuperior) ⇒ 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

Nota: Si desea insertar este operador con el teclado del ordenador, 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

Muestra complexVector en formato polar.

• El modo de ángulo en grados devuelve (rq).

• 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 (rq).





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.

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.

Constantes polinómicas

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ónpolyEval(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) ⇒ listapolyRoots(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.

PowerRegCatá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 variable stat.results. (Consulte la página 116).







Variable de salida

Descripción

stat.RegEqn Ecuación de regresión: a·(x)b



stat.r Coeficiente de correlación para los datos transformados (ln(x), ln(y))

stat.Resid Residuos asociados con el modelo potencial






PrgmCatálogo >

Prgm BloqueEndPrgm

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.



Calcular el valor de GCD y mostrar resultados intermedios.

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.



Q

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.

QRCatálogo >

QR Matriz, qMatriz, rMatriz[,Tol]

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.

Opcionalmente, cualquier elemento de la 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 el valor de Tol se omite o no se utiliza, la tolerancia predeterminada se calculará como:5Eë14 ·max(dim(Matriz)) ·rowNorm(Matriz)

El número de coma flotante (9.) en m1 hace que los resultados se calculen en formato de coma flotante.


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.

QuadRegCatá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 guarda en la variable stat.results. (Consulte la página 116).







Variable de salida

Descripción

stat.RegEqn Ecuación de regresión: a·x2+b·x+c

stat.a, stat.b, stat.c Coeficientes de regresión





QRCatálogo >



QuartRegCatá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 frecuencia Frec. El resumen de los resultados se guarda en la variable stat.results. (Consulte la página 116).







Variable de salida

Descripción

stat.RegEqn Ecuación de regresión: a·x4+b·x3+c· x2+d·x+e

stat.a, stat.b, stat.c, stat.d, stat.e








R

R4Pq() Catálogo >

R4Pq (Exprx, Expry) ⇒ expresiónR4Pq (Listax, Listay) ⇒ listaR4Pq (Matrizx, Matrizy) ⇒ matriz

Devuelve la coordenada q equivalente del par de argumentos (x,y).


Nota: Si desea insertar esta función con el teclado del ordenador, escriba R@>Ptheta(...).




R4Pr() Catálogo >

R4Pr (Exprx, Expry) ⇒ expresiónR4Pr (Listax, Listay) ⇒ listaR4Pr (Matrizx, Matrizy) ⇒ matriz

Devuelve la coordenada r equivalente del par de argumentos (x,y).

Nota: Si desea insertar esta función con el teclado del ordenador, escriba R@>Pr(...).


4Rad Catálogo >

Expr14Rad ⇒ expresión

Convierte el argumento a radianes.

Nota: Si desea insertar este operador con el teclado del ordenador, escriba @>Rad.



rand()Catálogo >

rand() ⇒ expresión 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.

Define el número raíz aleatorio.


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ónrandNorm(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.

RandSeedCatá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.

Nota: Se considera que todas las variables no definidas son variables 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

Nota: Si desea insertar este operador con el teclado del ordenador, 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.


complexValue 4Rect

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 (rq).




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.



• Si el valor de Tol se omite o no se utiliza, la tolerancia predeterminada se calculará como: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.

4Rect Catálogo >


remain()Catálogo >

remain(Expr1, Expr2) ⇒ expresiónremain(Lista1, Lista2) ⇒ listaremain(Matriz1, Matriz2) ⇒ matriz

Devuelve el resto del primer argumento con respecto al segundo argumento, según se define en las identidades:

remain(x,0) xremain(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.

RequestCatálogo >

Request cadenaSolicitud, var[, MostrEtiqueta] Request cadenaSolicitud, func(arg1, ...argn) [, MostrEtiqueta]

Orden de programación: Interrumpe el programa y abre un cuadro de diálogo que muestra el mensaje cadenaSolicitud y un cuadro de entrada para que el usuario escriba la respuesta.

Cuando el usuario escribe la respuesta y hace clic en Aceptar, el 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.

Defina un programa:Define request_demo()=PrgmRequest “Radio: ”,rDisp “Área = “,pi*r2

EndPrgm

Ejecute el programa y escriba una respuesta:request_demo()

Resultado después de seleccionar Aceptar:Radio: 6/2Área= 28,2743

El argumento func() permite a un programa almacenar la respuesta del usuario como una definición de función. Esta sintaxis funciona si el usuario ha ejecutado la orden:

Define func(arg1, ...argn) = respuesta del usuario

El programa puede utilizar luego la función definida func(). El argumento cadenaSolicitud sirve para indicar al usuario que 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.

Defina un programa:Define polynomial()=PrgmRequest "Introducir un polinomio en x:",p(x)Disp "Las raíces reales son:",polyRoots(p(x),x)

EndPrgm

Ejecute el programa y escriba una respuesta:polynomial()

Resultado después de seleccionar Aceptar:Introducir un polinomio en x: x^3+3x+1Las raíces reales son: {-0,322185}


RequestStrCatálogo >

RequestStr cadenaSolicitud, var[, MostrEtiqueta]

Orden de programación: Funciona igual que la primera sintaxis de la orden Request, salvo en que la respuesta del usuario se interpreta siempre como una cadena. Por su parte, la orden Request interpreta la respuesta como una expresión, a menos que el usuario la encierre entre comillas (““).

Nota: La orden RequestStr se puede utilizar en un programa definido por el usuario, pero no en una función.

Nota: Consulte también Request, en la página 99.

Defina un programa:Define requestStr_demo()=PrgmRequestStr “Su nombre:”,nombre,0Disp “La respuesta tiene “,dim(name),”

caracteres”.EndPrgm

Ejecute el programa y escriba una respuesta:requestStr_demo()

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.

ReturnCatá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.



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) ⇒ rootroot(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

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.

En modo base Bin:


Si númeroDeRotaciones es positivo, la rotación es hacia la izquierda. 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:

En modo base Hex:

Cada bit se rota hacia la derecha.

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.

Importante: Para introducir un número binario o hexadecimal, utilice siempre el prefijo 0b o 0h (cero, no la letra O).

rotate(Lista1[,númeroDeRotaciones]) ⇒ lista

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. Si númeroDeRotaciones es negativo, la rotación es hacia la derecha. El valor predeterminado es ë1 (rotar un elemento hacia la derecha).

En modo base Dec:

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. Si númeroDeRotaciones es negativo, la rotación es hacia la derecha. 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í.


S

rref()Catálogo >

rref(Matriz1[, Tol]) ⇒ matriz

Devuelve una forma de fila escalonada reducida de Matriz1.

Opcionalmente, cualquier elemento de la 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 el valor de Tol se omite o no se utiliza, la tolerancia predeterminada se calculará como:5Eë14 ·max(dim(Matriz1)) ·rowNorm(Matriz1)

Nota: Consulte también ref(), en la página 98.

sec() Tecla μ

sec(Expr1) ⇒ expresiónsec(Lista1) ⇒ lista

Devuelve la secante de Expr1 o una lista de las secantes 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.


sec/() Tecla μ

sec/(Expr1) ⇒ expresiónsec/(Lista1) ⇒ lista

Devuelve el ángulo cuya secante es Expr1 o una lista de las secantes inversas de todos los elementos de Lista1.


Nota: Si desea insertar esta función con el teclado, escriba arcsec(...).





sech()Catálogo >

sech(Expr1) ⇒ expresiónsech(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ónsechê (Lista1) ⇒ lista

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(...).

En el modo de ángulo en radianes y el modo complejo rectangular:

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ónseries(Expr1, Var, Orden [, Punto]) | Var>Punto ⇒ expresiónseries(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) ⇒ enterosetMode(lista) ⇒ lista de enteros

Válido sólo en una función o un 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).

Muestra el valor aproximado de p con el ajuste predeterminado para Mostrar dígitos y, a continuación, muestra p con un ajuste Fijo2. Comprueba que se hayan recuperado los valores predeterminados después de ejecutar el programa.

Nombre del modo

Modo delentero


Display Digits (Mostrar dígitos)

1 1=Flotante, 2=Flotante1, 3=Flotante2, 4=Flotante3, 5=Flotante4, 6=Flotante5, 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 (Formato exponencial)

3 1=Normal, 2=Científico, 3=Ingeniería

Real or Complex (Real o complejo)

4 1=Real, 2=Rectangular, 3=Polar

Auto or Approximate (Auto o aproximado)

5 1=Auto, 2=Aproximado, 3=Exacto

Vector Format (Formato vectorial)

6 1=Rectangular, 2=Cilíndrico, 3=Esférico

Base 7 1=Decimal, 2=Hex, 3=Binario


Unit System (Sistema de unidades)

8 1=SI, 2=Inglés/EE UU

shift()Catálogo >

shift(Entero1[,númeroDeDesplazamientos]) ⇒ entero

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 módulo simétrico para llevar el valor al rango apropiado. Para obtener más información, consulte 4Base2, en la página 14.

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 extremo izquierdo. En un desplazamiento hacia la izquierda, el bit situado en el extremo izquierdo se descarta y se inserta 0 en el bit del 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.

En modo base Bin:

En modo base Hex:

Importante: Para introducir un número binario o hexadecimal, utilice siempre el prefijo 0b o 0h (cero, no la letra O).

shift(Lista1 [,númeroDeDesplazamientos]) ⇒ lista

Devuelve una copia de Lista1 desplazada hacia la derecha o la izquierda tantos elementos como indique númeroDeDesplazamientos. No altera el contenido de Lista1.

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 elemento hacia la derecha).

Los elementos introducidos al principio o al final de lista por el desplazamiento se sustituyen por el símbolo “undef”.

En modo base Dec:

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.

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 carácter hacia la derecha).

Los caracteres introducidos al principio o al final de la cadena por el desplazamiento se sustituyen por un espacio.

Nombre del modo

Modo delentero



sign()Catálogo >

sign(Expr1) ⇒ expresiónsign(Lista1) ⇒ listasign(Matriz1) ⇒ matriz

Para Expr1 real o compleja, devuelve Expr1/abs(Expr1) cuando Expr1ƒ 0.

Devuelve 1 si Expr1 es positivo.

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.

Si el modo de formato complejo es Real:

simult()Catálogo >

simult(Matrizcoeficientes, Vectorconstrucción[, Tol]) ⇒ matriz

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 coeficientes de las ecuaciones.

Vectorconstrucción debe tener el mismo número de filas (la misma dimensión) que Matrizcoeficientes y contener las constantes.

Opcionalmente, cualquier elemento de la 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.

• Si define el modo Auto o Aproximado en Aproximado, los cálculos se efectuarán utilizando la coma flotante aritmética.

• Si el valor de Tol se omite o no se utiliza, la tolerancia predeterminada se calculará como:5Eë14 ·max(dim(Matrizcoeficientes))

·rowNorm(Matrizcoeficientes)

Resolver para hallar X e Y:x + 2y = 13x + 4y = ë1

La solución es x=ë3 e y=2.

Resolver:ax + by = 1cx + dy = 2

simult(Matrizcoeficientes, Matrizconstrucción[, Tol]) ⇒ matriz

Resuelve múltiples sistemas de ecuaciones lineales, donde cada sistema tiene los mismos coeficientes de ecuacion pero distintas constantes.

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.

Resolver: x + 2y = 1

3x + 4y = ë1

x + 2y = 23x + 4y = ë3

Para el primer sistema, x=ë3 e y=2. Para el segundo sistema, x=ë7 e y=9/2.


4sin Catálogo >

Expr 4sin

Nota: Si desea insertar este operador con el teclado del ordenador, 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ónsin(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.

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.




sin(Matrizcuadrada1) ⇒ Matrizcuadrada

Devuelve el seno de la matriz Matrizcuadrada1. El resultado no es igual que calcular el seno de cada elemento. Para obtener más información sobre el método de cálculo, consulte cos().




sinê() Tecla μ

sinê(Expr1) ⇒ expresiónsinê(Lista1) ⇒ lista

sinê(Expr1) devuelve el ángulo cuyo seno es Expr1 en forma de expresión.

sinê(Lista1) devuelve una lista de los senos inversos de cada elemento de Lista1.


Nota: Si desea insertar esta función con el teclado del ordenador, escriba arcsin(...).




sinê(Matrizcuadrada1) ⇒ Matrizcuadrada

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().


En el modo de ángulo en radianes y el formato complejo rectangular:


sinh()Catálogo >

sinh(Expr1) ⇒ expresiónsinh(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

Devuelve el seno hiperbólico de la matriz Matrizcuadrada1. El resultado no es igual que calcular el seno hiperbólico de cada elemento. Para obtener más información sobre el método de cálculo, consulte cos().



sinhê() Catálogo >

sinhê(Expr1) ⇒ expresiónsinhê(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.

Nota: Si desea insertar esta función con el teclado del ordenador, escriba arcsinh(...).


sinhê(Matrizcuadrada1) ⇒ Matrizcuadrada

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().



SinRegCatá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.


Variable de salida

Descripción

stat.RegEqn Ecuación de regresión: a·sin(bx+c)+d







sinhê() Catálogo >


solve()Catálogo >

solve(Ecuación, Var) ⇒ Expresión booleanasolve(Ecuación, Var=Conjetura) ⇒ Expresión booleanasolve(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 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 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(Ecuación1 and Ecuación2 [and … ], VarOConjetura1,

VarOConjetura2 [, … ]) ⇒ Expresión booleanasolve(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:



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 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 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.

Si el sistema no es polinómico en todas sus variables ni lineal en sus 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.

SortACatá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 vacíos, consulte la página 160.

SortDCatá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 vacíos, consulte la página 160.

solve()Catálogo >


4Sphere Catálogo >

Vector 4Sphere

Nota: Si desea insertar este operador con el teclado del ordenador, 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ónsqrt(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.

X

Y

Z

(ρ ,θ ,φ)

θ

φ

ρ


stat.resultsCatá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.

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.astat.AdjR²stat.bstat.b0stat.b1stat.b2stat.b3stat.b4stat.b5stat.b6stat.b7stat.b8stat.b9stat.b10stat.bListstat.c² stat.cstat.CLowerstat.CLowerListstat.CompListstat.CompMatrixstat.CookDiststat.CUpperstat.CUpperListstat.d

stat.dfDenomstat.dfBlockstat.dfColstat.dfErrorstat.dfInteractstat.dfRegstat.dfNumerstat.dfRowstat.DWstat.estat.ExpMatrixstat.Fstat.FBlockstat.Fcolstat.FInteractstat.FreqRegstat.Frowstat.Leveragestat.LowerPredstat.LowerValstat.mstat.MaxXstat.MaxYstat.MEstat.MedianX

stat.MedianYstat.MEPredstat.MinXstat.MinYstat.MSstat.MSBlockstat.MSColstat.MSErrorstat.MSInteractstat.MSRegstat.MSRowstat.nstat.Çstat.Ç1stat.Ç2stat.ÇDiffstat.PListstat.PValstat.PValBlockstat.PValColstat.PValInteractstat.PValRowstat.Q1Xstat.Q1Ystat.Q3X

stat.Q3Ystat.rstat.r²stat.RegEqnstat.Residstat.ResidTransstat.sxstat.systat.sx1stat.sx2stat.Gxstat.Gx²stat.Gxystat.Gystat.Gy²stat.sstat.SEstat.SEListstat.SEPredstat.sResidstat.SEslopestat.spstat.SSstat.SSBlock

stat.SSColstat.SSXstat.SSYstat.SSErrorstat.SSInteractstat.SSRegstat.SSRowstat.tListstat.UpperPredstat.UpperValstat.v stat.v1stat.v2stat.vDiffstat.vListstat.XRegstat.XValstat.XValListstat.w

stat.ystat.yListstat.YReg


stat.valuesCatálogo >

stat.values

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.

Consulte el ejemplo stat.results.

stDevPop()Catálogo >

stDevPop(Lista[, Listafrecuencia]) ⇒ expresión

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.

En el modo de ángulo en radianes y auto:

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(Matriz1[, Matrizfrecuencia]) ⇒ matriz

Devuelve un vector fila de las desviaciones estándar de la muestra 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..

StopCatálogo >

Stop

Orden de programación: Finaliza el programa.

Stop es una orden no admitida en las funciones.



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.

stDevSamp()Catálogo >


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 información sobre los elementos vacíos, consulte la página 160.

sum(Matriz1[, Inicio[, Fin]]) ⇒ matriz

Devuelve un vector fila que contiene las sumas de los elementos de las columnas de Matriz1.

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 información sobre los elementos vacíos, consulte la página 160.

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.

Se desestiman los elementos vacíos (sin valor). Para obtener más 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.

Nota: Si desea insertar este operador con el teclado del ordenador, escriba @t.

tan() Tecla μ

tan(Expr1) ⇒ expresióntan(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.

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 ajuste de ángulo temporalmente.




tan(Matrizcuadrada1) ⇒ Matrizcuadrada

Devuelve la tangente de la matriz Matricuadrada1. El resultado no es igual que calcular la tangente de cada elemento. Para obtener más información sobre el método de cálculo, consulte cos().




tanê() Tecla μ

tanê(Expr1) ⇒ expresióntanê(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.


Nota: Si desea insertar esta función con el teclado del ordenador, escriba arctan(...).




tanê(Matrizcuadrada1) ⇒ Matrizcuadrada

Devuelve la tangente inversa de la matriz Matrizcuadrada1. El resultado no es igual que calcular la tangente inversa de cada elemento. Para obtener más información sobre el método de cálculo, consulte cos().



tangentLine()Catálogo >

tangentLine(Expr1,Var,Punto) ⇒ expresióntangentLine(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óntanh(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

Devuelve la tangente hiperbólica de la matriz Matrizcuadrada1. El resultado no es igual que calcular la tangente hiperbólica de cada elemento. Para obtener más información sobre el método de cálculo, consulte cos().




tanhê() Catálogo >

tanhê(Expr1) ⇒ expresióntanhê(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.

Nota: Si desea insertar esta función con el teclado del ordenador, escriba arctanh(...).

En el formato complejo rectangular:

tanhê(Matrizcuadrada1) ⇒ Matrizcuadrada

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().




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 Extremoinferior y Extremosuperior son números, lista si Extremoinferior y Extremosuperior son listas

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.

TextCatálogo >

Text cadenaSolicitud [, MostrEtiqueta]

Orden de programación: Interrumpe el programa y muestra la cadena de caracteres cadenaSolicitud en un cuadro de diálogo.

La ejecución del programa sigue su curso cuando el usuario selecciona Aceptar. Seleccione Cancelar para detener el programa.

El argumento opcional etiqueta puede ser cualquier expresión.

• Si MostrEtiqueta se omite o se calcula en 1, el mensaje de texto se añade al historial de Calculadora.

• Si MostrEtiqueta se calcula en 0, el mensaje de texto no se añade al historial.

Si el programa necesita que el usuario introduzca una respuesta escrita, consulte la función Request, en la página 99, o la función 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.

Defina un programa que se interrumpa para mostrar cada uno de los cinco números aleatorios en un cuadro de diálogo.Utilice la plantilla Prgm...EndPrgm y complete cada línea

pulsando la tecla @ en lugar de ·. En el teclado del ordenador, mantenga pulsada la tecla Alt y pulse Intro.

Define text_demo()=PrgmFor i,1,5

strinfo:=”Número aleatorio“ & string(rand(i))Text strinfo

NextEndPrgm

Ejecute el programa:text_demo()

Ejemplo de un cuadro de diálogo:

Then Consulte If, en la página 56.


tIntervalCatálogo >

TInterval Lista[,Frec[,NivelC]]


TInterval v,Sx,n[,NivelC]


Calcula un intervalo t de confianza. El resumen de los resultados se guarda en la variable stat.results. (Consulte la página 116).


Variable de salida

Descripción

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_2SampCatá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.


Variable de salida

Descripción

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


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

_¡K Kelvin

_¡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().

Nota: Puede utilizar el catálogo para seleccionar unidades de temperatura.

@tmpCnv()Catálogo >

@tmpCnv(Expr_¡Unidadtiempo, _¡Unidadtiempo2)

⇒ expresión _¡Unidadtiempo2

Nota: Si desea insertar esta función con el teclado del ordenador, 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 _¡K Kelvin _¡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().

Para escribir @, selecciónelo en la lista de símbolos del catálogo.

Nota: Puede utilizar el catálogo para seleccionar unidades de temperatura.

Variable de salida

Descripción


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 Bloque1Else Bloque2EndTry

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 “:”.




Ejemplo 2

Para ver las órdenes Try, ClrErr y PassErr en funcionamiento, introduzca el programa eigenvals() que se muestra a la derecha. Ejecute el programa activando cada una de las siguientes expresiones.

Nota: Consulte también ClrErr, en la página 19, y PassErr, en la página86.

Definir eigenvals(a,b)=Prgm© Program eigenvals(A,B) muestra valores propios de A·BTry

Disp "A= ",aDisp "B= ",bDisp " "Disp "Eigenvalues of A·B are:",eigVl(a*b)

ElseIf errCode=230 Then

Disp "Error: Product of A·B must be a square matrix"ClrErr

ElsePassErr

EndIfEndTryEndPrgm

tTestCatá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<0Para Ha: m ƒ m0 (predeterminado), defina Hipótesis=0Para Ha: m > m0, defina Hipótesis>0


Variable de salida

Descripción

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

Try Catálogo >


tTest_2SampCatá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 guarda en la variable stat.results. (Consulte la página 116.)

Prueba H0: m1 = m2, frente a una de las alternativas siguientes:

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

Sondeado = 1 sondea las varianzasSondeado = 0 no sondea las varianzas


Variable de salida

Descripción

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.



* 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.

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 de TVM*

Descripción Tipo de datos

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)


TwoVarCatálogo >

TwoVar X, Y[, [Frec] [, Categoría, Incluir]]

Calcula estadísticas de dos variables. El resumen de los resultados se guarda en la variable stat.results. (Consulte la página 116).






Un elemento vacío (sin valor) en cualquiera de las listas X, Frec o 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.

Variable de salida

Descripción

stat.v Media de los valores de x

stat.GGGGx Suma de los valores de x

stat.GGGGx2 Suma de los valores de x2

stat.sx Desviación estándar de la muestra x

stat.ssssx Desviación estándar de población x

stat.n Número de puntos de datos

stat.w Media de los valores de y

stat.GGGGy Suma de los valores de y

stat.GGGGy2 Suma de los valores de y2

stat.sy Desviación estándar de la muestra y

stat.ssssy Desviación estándar de población de y

stat.GGGGxy Suma de los valores de x·y








U

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

stat.GGGG(x-vvvv)2 Suma de cuadrados de desviaciones con respecto a la media de x

stat.GGGG(y-wwww)2 Suma de cuadrados de desviaciones con respecto a la media de y

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.


unLockCatá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.

Variable de salida

Descripción


V

W

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 información sobre los elementos vacíos, consulte la página 160.

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 desestimarán tanto el elemento en cuestión como el elemento correspondiente en todas las demás listas. Para obtener más información sobre los elementos vacíos, consulte la página 160.

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 desestimarán tanto el elemento en cuestión como el elemento correspondiente en todas las demás matrices. Para obtener más información sobre los elementos vacíos, consulte la página 160.

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.


X

when() resulta útil para definir funciones recursivas.

WhileCatálogo >

While CondiciónBloque

EndWhile

Ejecuta las sentencias de Bloque siempre que Condición sea verdadero.

Bloque puede ser una sentencia sencilla o una sucesión de sentencias separadas por el carácter “:”.



“With”Consulte | (“con”), en la página 157.

xorCatá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.

when()Catálogo >


Z

Entero1 xor Entero2 ⇒ entero

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 obtenido representa el resultado de los bits y aparece conforme al modo base especificado.



Nota: Consulte or, en la página 85.

En modo base Hex:Importante: Cero, no la letra O.

En modo base Bin:


zeros()Catálogo >

zeros(Expr, Var) ⇒ listazeros(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.

Opcionalmente se puede especificar un valor inicial para una variable. Cada VarOConjetura debe tener la forma:



xorCatá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.

Si el sistema no es polinómico en todas sus variables ni lineal en sus 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.

zeros()Catálogo >


zIntervalCatálogo >

zInterval s,Lista[,Frec[,NivelC]]


zInterval s,v,n [,NivelC]


Calcula un intervalo z de confianza. El resumen de los resultados se guarda en la variable stat.results. (Consulte la página 116.)


Variable de salida

Descripción

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_1PropCatá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.

Variable de salida

Descripción


stat.Ç Proporción de éxitos calculada


stat.n Número de muestras en las sucesiones de datos


zInterval_2PropCatá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.


Variable de salida

Descripción


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_2SampCatá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.)


Variable de salida

Descripció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

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


stat.r1, stat.r2 Desviaciones estándar de población conocida para las sucesiones de datos de Lista 1 y Lista 2

zTestCatá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. 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<0Para Ha: m ƒ m0 (predeterminado), defina Hipótesis=0Para Ha: m > m0, defina Hipótesis>0


Variable de salida

Descripción

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_1PropCatálogo >

zTest_1Prop p0,x,n[,Hipótesis]

Realiza un test z para 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.

Prueba H0: p = p0 frente a una de las alternativas siguientes:

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


Variable de salida

Descripción


Variable de salida

Descripción

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_2PropCatálogo >

zTest_2Prop x1,n1,x2,n2[,Hipótesis]

Calcula un test z 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.

Prueba H0: p1 = p2 frente a una de las alternativas siguientes:

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


Variable de salida

Descripción

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_2SampCatá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 guarda en la variable stat.results. (Consulte la página 116.)

Prueba H0: m1 = m2, frente a una de las alternativas siguientes:

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


Variable de salida

Descripción

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 ⇒ listaMatriz1 + 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 ⇒ listaLista1 + Expr ⇒ lista

Devuelve una lista con las sumas de Expr y cada elemento de Lista1.

Expr + Matriz1 ⇒ matrizMatriz1 + 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 ⇒ listaMatriz1 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 ⇒ listaLista1 N Expr ⇒ lista

Resta cada elemento de Lista1 de Expr o resta Exprde cada elemento de Lista1, y devuelve una lista de resultados.


Expr N Matriz1 ⇒ matrizMatriz1 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) Teclar

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 ⇒ listaLista1 ·Expr ⇒ lista

Devuelve una lista con los productos de Expr y cada elemento de Lista1.

Expr ·Matriz1 ⇒ matrizMatriz1 ·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)Teclap

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.

N(resta) 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 ⇒ listaLista1 à 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) Teclal

Expr1 ^ Expr2 ⇒ expresiónLista1 ^ 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.

à (división)Teclap


x2 (cuadrado) Tecla q

Expr12 ⇒ expresiónDevuelve 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 ⇒ matrizExpr .+ 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 ⇒ matrizExpr .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 ⇒ matrizExpr .·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 ⇒ matrizExpr . / 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 ⇒ matrizExpr . ^ 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.

Si el argumento es un entero binario o hexadecimal, la negación es el complemento a dos.

En modo base Bin:


% (porcentaje) Teclas / k

Expr1 % ⇒ expresiónLista1 % ⇒ listaMatriz1 % ⇒ matriz

Devuelve

Para una lista o una matriz, devuelve una lista o una matriz en la que cada elemento está dividido por 100.







= (igual) Tecla =

Expr1 = Expr2 ⇒ Expresión booleanaLista1 = Lista2 ⇒ Lista booleanaMatriz1 = 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.



Función de ejemplo que utiliza símbolos matemáticos: =, ƒ, <, {, >, ‚

Resultado de representar gráficamente g(x)

ƒ (no igual) Teclas / =

Expr1 ƒ Expr2 ⇒ Expresión booleanaLista1 ƒ Lista2 ⇒ Lista booleanaMatriz1 ƒ 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.


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.

Nota: Si desea insertar este operador con el teclado del ordenador, escriba /=

Consulte el ejemplo “=” (igual).


< (menor que) Teclas /=

Expr1 < Expr2 ⇒ Expresión booleanaLista1 < Lista2 ⇒ Lista booleanaMatriz1 < 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.




{ (menor o igual que) Teclas /=

Expr1 { Expr2 ⇒ Expresión booleanaLista1 { Lista2 ⇒ Lista booleanaMatriz1 { 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.



Nota: Si desea insertar este operador con el teclado del ordenador, escriba <=


> (mayor que) Teclas /=

Expr1 > Expr2 ⇒ Expresión booleanaLista1 > Lista2 ⇒ Lista booleanaMatriz1 > 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.





| (mayor o igual que) Teclas /=

Expr1 | Expr2 ⇒ Expresión booleanaLista1 | Lista2 ⇒ Lista booleanaMatriz1 | 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.



Nota: Si desea insertar este operador con el teclado del ordenador, escriba >=


! (factorial) Tecla º

Expr1! ⇒ expresiónLista1! ⇒ listaMatriz1! ⇒ 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.

Nota: Si desea insertar esta función con el teclado del ordenador, 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.

Nota: Si desea insertar esta función con el teclado del ordenador, 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.


‰() 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.



‰() 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.Nota: Si desea insertar esta función con el teclado del ordenador, escriba sqrt(...)

Nota: Consulte también Plantilla de raíz cuadrada, en la página 1.

‰() (integral) Catálogo >


Π() (prodSeq) Catálogo >

Π(Expr1, Var, Inferior, Superior) ⇒ expresión

Nota: Si desea insertar esta función con el teclado del ordenador, 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

Nota: Si desea insertar esta función con el teclado del ordenador, 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(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]) ⇒ valorGInt(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 argumentos para TVM, en la página 129.





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.

G() (sumSeq) Catálogo >


GPrn() Catálogo >

GPrn(NPmt1, NPmt2, N, I, PV, [Pmt], [FV], [PpY], [CpY], [PmtAt], [redondValor]) ⇒ valorGPrn(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 argumentos para TVM, en la página 129.





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 una función.

Crea o hace referencia a la variable xyz .

Devuelve el valor de la variable (r) cuyo nombre se encuentra almacenado en la variable s1.

í (notación científica) Tecla iexponente 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.

Nota: Si desea insertar este operador con el teclado del ordenador, escriba @E. por ejemplo, escriba 2.3@E4 para introducir 2.3E4.


g (grado centesimal) Tecla ¹

Expr1g ⇒ expresiónLista1g ⇒ listaMatriz1g ⇒ 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.

En el modo de ángulo en grados, grados centesimales o radianes:

ô(radián) Tecla ¹

Expr1ô ⇒ expresiónLista1ô ⇒ listaMatriz1ô ⇒ 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.

Nota: Si desea insertar este símbolo con el teclado del ordenador, escriba @r.


¡ (grado) Tecla ¹

Expr1¡ ⇒ expresiónLista1¡ ⇒ listaMatriz1¡ ⇒ 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.

Nota: Si desea insertar este símbolo con el teclado del ordenador, escriba @d.






¡, ', '' (grados/minutos/segundos) Teclas /k

gg¡mm'ss.ss'' ⇒ expresión

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 (entrada polar)

[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 configuración de modo elegida para el formato del vector: rectangular, cilíndrico o esférico.

Nota: Si desea insertar este símbolo con el teclado del ordenador, escriba @<.

En el modo de ángulo en radianes y el formato de vector definido en:rectangular

cilíndrico

esférico

(Magnitud Ángulo) ⇒ complexValue(entrada polar)

Introduce un valor complejo en formato polar (rq). 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.

Puede utilizar unidades predefinidas para crear las suyas propias. Para ver una lista de unidades predefinidas, abra el Catálogo y muestre la ficha Unidades de conversión. Puede seleccionar los nombres de las unidades del catálogo o escribirlos directamente.

Nota: Busque en el catálogo el símbolo de conversión, 4. Haga

clic en , y luego en Math Operators (Operadores matemáticos).

Variable_

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 _.

Suponiendo que z esté sin definir:

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ón10^ (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ónLista1 ^ê ⇒ 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 /kExpr | 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í.

Nota: Si desea insertar este operador con el teclado del ordenador, escriba =: como método abreviado. Por ejemplo, escriba pi/4 =: myvar.

:= (asignar) Teclas /tVar := ExprVar := ListaVar := MatrizFunció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.




0b, 0h Teclas 0B, Teclas 0H0b NúmeroBinario0h NúmeroHexadecimal

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 se considera como decimal (base 10).

Los resultados se muestran conforme al modo de la base.

En modo base Dec:

En modo base Bin:

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.


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.

Listas de argumentos que contienen elementos sin valor(continued)


Métodos abreviados para introducir expresiones matemáticasLos 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

Con el teclado del ordenador

Para introducir: Escriba:

p pi

q theta

ˆ̂̂̂ infinity

<=

‚ >=

ƒ /=

& (operador de almacenamiento)

=:

| | (valor absoluto) abs(...)

‡‡‡‡() sqrt(...)

d() derivative(...)

‰‰‰‰() integral(...)

GGGG() (plantilla de suma) sumSeq(...)

Π() (plantilla de producto) prodSeq(...)

sinê(), cosê(), ... arcsin(...), arccos(...), ...

@List() deltaList(...)

@tmpCnv() deltaTmpCnv(...)


c1, c2, ... (constantes) @c1, @c2, ...

n1, n2, ... (constantes enteras)

@n1, @n2, ...

i (constante imaginaria) @i


e (log natural base e) @e

íííí(notación científica) @E

T (transponer) @t

ôôôô (radianes) @r

¡¡¡¡ (grados) @d

g (grados centesimales) @g

(á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

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 )".

Nivel Operador

1 Paréntesis ( ), corchetes [ ], llaves { }

2 Dirección (#)

3 Funciones

4 Postoperadores: grados-minutos-segundos (-,',"), factorial (!), porcentaje (%),

radián (QQQQRS), 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 (")


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 errorCada 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 error

Descripción

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áximaPara 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 ExtremoPara 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 viciosoEste 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álidaPor 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álidoEl argumento pertenece a un tipo de datos erróneo.

220 Límite dependiente


230 DimensiónUn í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ónSi 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 dominioEl 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 definidaPuede 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álidaPor 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 programaUna 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.

Código de error

Descripción


565 Resultados no válidos fuera de programa

570 Nombre de ruta de acceso no válidoPor ejemplo, \var no es válido.

575 Complejo polar no válido

580 Referencia a programa no válidaNo 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 conexionesLa 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 insuficiente1. Borre algunos datos del documento2. Guarde y cierre este documentoSi 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 realPor 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 programaEn 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

Código de error

Descripción


870 Nombre reservado o variable del sistema

900 Error en el argumentoNo se puede aplicar el modelo mediana-media a un conjunto de datos.

920 No se encuentra el texto

930 Pocos argumentosA la función o la orden le faltan uno o varios argumentos.

940 Demasiados argumentosLa 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á definidaNo se ha asignado valor a la variable. Utilice una de las órdenes siguientes:

• sto & • :=• Definepara 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álidoAsegú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 realPor 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

Código de error

Descripción


1120 No hay cambios de signo

1130 El argumento no puede ser una lista o matriz.

1140 Error en el argumentoEl 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.

1150 Error en el argumentoLos 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álidoEscriba 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.Asegúrese de que el nombre:• no contiene un punto• no comienza por un signo de subrayado• no tiene más de 15 caracteresPara obtener más detalles, consulte la sección Biblioteca de la documentación.

1190 Documento de biblioteca no hallado:• Asegúrese de que la biblioteca se encuentra en la carpeta MyLib.• Actualice las bibliotecas.Para obtener más detalles, consulte la sección Biblioteca de la documentación.

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.Para obtener más detalles, consulte la sección Biblioteca de la documentación.

1210 El nombre del método abreviado de acceso a la biblioteca no es válido.Asegúrese de que el nombre:• no contiene un punto• no comienza por un signo de subrayado• no tiene más de 16 caracteres• no es un nombre reservadoPara obtener más detalles, consulte la sección Biblioteca de la documentación.

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.

1250 Error en el argumentoUtilice un sistema de ecuaciones lineales. Ejemplo de un sistema de dos ecuaciones lineales con variables X e Y:3x+7y=52y-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.

1270 Error en el argumentoEl orden de la derivada debe ser igual a 1 o 2.

Código de error

Descripción

171

1280 Error en el argumentoUtiliza la forma desarrollada de un polinomio en una variable.

1290 Error en el argumentoUtiliza un polinomio en una variable.

1300 Error en el argumentoLos 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.

Código de error

Descripción

Servicio y Soporte 173

Servicio y Soporte

Información sobre productos, servicios y garantías de TI

Información sobre productos y servicios de TI

Para obtener más detalles acerca de los productos y servicios de TI, póngase en contacto mediante correo electrónico o acceda a la página inicial de calculadoras en la world wide web.

dirección de correo electrónico: [email protected]

dirección de internet: education.ti.com

Información sobre servicios y garantías

Para obtener más detalles acerca de la duración y las condiciones de la garantía o sobre el 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.

mailto:[email protected]

http://education.ti.com

174 Servicio y Soporte

175

Índice alfabético

Símbolos!, factorial 148", notación en segundos 155#, dirección 153#, operador de dirección 165%, porcentaje 145&, almacenar 158&, añadir 148', notación en minutos 155', primo 155-, grados/minutos/segundos 155-, notación en grados 1544, convertir unidades 156‰, integral 149‡, raíz cuadrada 150ƒ, no igual 146N, resta 141P, división 142Π, producto 151Σ( ), suma 151*, multiplicar 142+, suma 141.*,punto multiplicación 144.+, punto suma 144.^, punto de potencia 145.N, punto resta 144.P, punto división 145:=, asignar 158<, menor que 147=, igual 146>, mayor que 147@list( ), diferencia de lista 66^, potencia 143^/, inverso de un valor 157_, designación de unidad 156{, menor o igual que 147|, con 157|, mayor o igual que 148©, comentario 158

Números0b, indicador binario 1590h, indicador hexadecimal 15910^( ), potencia de diez 156

4approxFraction( ) 11

Aabs( ), valor absoluto 7aleatorio

matriz, randMat( ) 96normal, randNorm( ) 96número raíz, RandSeed 97polinomio, randPoly( ) 96

almacenarsímbolo, & 158

amortTbl( ), tabla de amortización7, 13

ampliar/concatenar, augment( ) 12añadir, & 148and, expresión booleana 7angle( ), ángulo 8ángulo, angle( ) 8ANOVA de 2 variables, análisis de

varianza de dos factores 9ANOVA, análisis de varianza de un

factor 8Ans, última respuesta 11approx( ), aproximado 11, 12aproximado, approx( ) 11, 12aproxRacional( ) 11arccos() 11arccosh() 12arccot() 12arccoth() 12arccsc() 12arccsch() 12arcLen( ), longitud de arco 12arcocoseno, cos/( ) 23arcoseno, sin/( ) 110arcotangente, tan/( ) 121arcsec() 12arcsech() 12arcsin() 12arcsinh() 12arctan() 12arctanh() 12argumentos en funciones de TVM

129

176

augment( ), ampliar/concatenar 12avgRC( ), tasa media de cambio 13

Bbase e

plantilla 24Base10, mostrar como entero

decimal 144Base16, mostrar como hexadecimal

154Base2, mostrar como binario 14biblioteca

crear accesos directos a objetos61

binarioindicador, 0b 159mostrar, 4Base2 14

binomCdf( ) 15binomPdf( ) 15bloquear variables y grupos de

variables 68booleana, expresión

and, and 7exclusiva or, xor 133not, not 81or, or 85

borrarerror, ClrErr 19variable, DelVar 35

bucle final, EndLoop 72bucle, Loop 72

Cc2 de 2 elementos 17c2Cdf( ) 18c2GOF 18c2Pdf( ) 18cadena

dimensión, dim( ) 37longitud 37

cadena de caracteres, char( ) 17cadena de formato, format( ) 49cadenas

añadir, & 148cadena a expresión, expr( ) 44,

69cadena de caracteres, char( ) 17

centro-cadena, mid( ) 75código de carácter, ord( ) 85dentro, InString 58derecha, right( ) 100desplazar, shift( ) 107dirección, # 153expresión a cadena, string( ) 118formatear 49formato, format( ) 49izquierda, left( ) 61rotar, rotate( ) 101utilizar para crear nombres de

variable 165cálculos, orden 164caracteres

cadena, char( ) 17código numérico, ord( ) 85

Cdf( ) 46ceiling( ), techo 15centralDiff( ) 16centro-cadena, mid( ) 75ceros, zeroes( ) 134cFactor( ), factor complejo 16char( ), cadena de caracteres 17charPoly( ) 17ciclo, Cycle 31ClearAZ 19ClrErr, borrar error 19colAugment 19colDim( ), dimensión de columna de

matriz 19colNorm( ), norma de columna de

matriz 19combinaciones, nCr( ) 78comDenom( ), común denominador

20comentario, © 158complejo

ceros, cZeros( ) 31conjugado, conj( ) 20factor, cFactor( ) 16resolver, cSolve( ) 28

comprobar elemento sin valor, isVoid( ) 60

común denominador, comDenom( )20

con, | 157

177

configuración de modo, getMode( )53

configuración, obtener actual 53conj( ), complejo conjugado 20constante

en solve( ) 112constantes

en cSolve( ) 29en cZeros( ) 32en deSolve( ) 36en solve( ) 113teclas de acceso 162

constructMat( ), matriz de construcción 21

contar días entre fechas, dbd( ) 33contar elementos condicionales de

una lista, countif( ) 26contar elementos de una lista,

count( ) 25convertir

4Grad 554Rad 95unidades 156

coordenadapolar, R4Pr( ) 95

coordenada rectangular x, P4Rx( )86

coordenada rectangular y, P4Ry( )86

copiar variable o función, CopyVar21

copyright statement iicorrMat( ), matriz de correlación 214cos, ver en función de coseno 22cos( ), coseno 22cos/, arcocoseno 23coseno

ver expresión en función de 22coseno, cos( ) 22cosh( ), coseno hiperbólico 24cosh/( ), arcocoseno hiperbólico 24cot( ), cotangente 24cot/( ), arcocotangente hiperbólica

25cotangente, cot( ) 24coth( ), cotangente hiperbólica 25coth/( ), arcocotangente hiperbólica

25

count( ), contar elementos de una lista 25

countif( ), contar elementos condicionales de una lista 26

cPolyRoots() 26crossP( ), producto vectorial 26csc( ), cosecante 27csc/( ), cosecante inversa 27csch( ), cosecante hiperbólica 27csch/( ), cosecante hiperbólica

inversa 27cSolve( ), resolver complejo 28cuando, when( ) 132CubicReg, regresión cúbica 30cumulativeSum( ), suma acumulada

30Cycle, ciclo 314Cylind, mostrar como vector

cilíndrico 31cZeros( ), ceros complejos 31

Dd ( ), primera derivada 149dbd( ), días entre fechas 334DD, mostrar como ángulo decimal

334Decimal, mostrar resultado como

decimal 33decimal

mostrar como ángulo, 4DD 33mostrar entero, 4Base10 14

Define (Definir) 34Define LibPriv 34Define LibPub 35Define, definir 34definir

función o programa privados 34función o programa públicos 35modo, setMode( ) 106

definir, Define 34deltaList() 35deltaTmpCnv() 35DelVar, eliminar variable 35delVoid( ), eliminar elementos sin

valor 35denominador 20

178

densidad de probabilidad de t de Student, tPdf( ) 126

densidad de probabilidad, normPdf( ) 81

dentro de la cadena, inString( ) 58derecha, right( ) 100derivada

numérica, nDeriv( ) 79, 80derivada implícita, Impdif( ) 58derivada o derivada enésima

plantilla 5derivadas

derivada numérica, nDeriv( ) 79, 80

derivadas numéricas, nDerivative( ) 79

primera derivada, d ( ) 149derivative() 35desarrollar, expand( ) 43desarrollo trigonométrico,

tExpand( ) 123desbloquear variables y grupos de

variables 131deSolve( ), solución 36desplazar, shift( ) 107desviación estándar, stdDev( ) 117,

132det( ), determinante de matriz 37diag( ), matriz diagonal 37días entre fechas, dbd( ) 33dim( ), dimensión 37dimensión, dim( ) 37dirección, # 153Disp, mostrar datos 38distribución acumulada normal

inversa (invNorm( ) 59dividir entero, intDiv( ) 58división, P 142dominantTerm( ), término

dominante 39dotP( ), producto escalar 39

Ee elevado a un exponente, e^( ) 42e elevado a una potencia, e^( ) 40E, exponente 153e, ver expresión en función de 42

e^( ), e elevado a una potencia 40ecuaciones simultáneas, simult( )

108eff ), convertir nominal en tasa

efectiva 40eigVc( ), vector propio 40eigVl( ), valor propio 41elementos sin valor 160elementos sin valor, eliminar 35elementos vacíos (sin valor) 160eliminar

elementos sin valor de listas 35else if, ElseIf 41else, Else 56ElseIf, else if 41end

bucle, EndLoop 72función, EndFunc 51if, EndIf 56para, EndFor 48

end if, EndIf 56EndTry, finalizar prueba 126EndWhile, mientras finaliza 133entero, int( ) 58entrada, Input 58EOS (Sistema operativo de

ecuaciones) 164errores y solución de problemas

borrar error, ClrErr 19pasar error, PassErr 86

estadísticacombinaciones, nCr( ) 78de una variable, OneVar 84desviación estándar, stdDev( )

117, 132factorial, ! 148media, mean( ) 73mediana, median( ) 74normal aleatorio, randNorm( )

96número raíz aleatorio, RandSeed

97resultado con dos variables,

TwoVar 130variaciones, nPr( ) 82varianza, variance( ) 132

estadística de una variable, OneVar84

179

etiqueta, Lbl 60exact( ), exactitud 42exactitud, exact( ) 42exclusiva (exp booleana) or, xor 133Exit, salir 424exp, ver en función de e 42exp( ), e elevado a un exponente 42exp4list( ), expresión a lista 43expand( ), desarrollar 43exponente

plantilla 1exponente, E 153expr( ), cadena a expresión 44, 69ExpReg, regresión exponencial 44expresiones

cadena a expresión, expr( ) 44, 69

expresión a lista4list( ) 43

Ffactor( ), factor 45factor, factor( ) 45factorial, ! 148factorización QR, QR 92Fill, rellenar matriz 46finalizar

mientras, EndWhile 133programa, EndPrgm 91prueba, EndTry 126

floor( ), suelo 47fMax( ), máximo de función 47fMin( ), mínimo de función 48For 48For, para 48forma de fila escalonada reducida,

rref( ) 103forma de fila escalonada, ref( ) 98format( ), cadena de formato 49fpart( ), parte de función 49fracción propia, propFrac 92fracciones

plantilla 1propFrac 92

fracciones mixtas, utilizar propFrac(› with 92

freqTable( ) 50frequency( ) 50

Func, función 51Func, función programa 51función definida a trozos (2 partes)

plantilla 2función definida a trozos (N partes)

plantilla 2función end, EndFunc 51funciones

definidas por el usuario 34función programa, Func 51máximo, fMax( ) 47mínimo, fMin( ) 48parte, fpart( ) 49

funciones de distribuciónbinomCdf( ) 15binomPdf( ) 15c22way( ) 17c2Cdf( ) 18c2GOF( ) 18c2Pdf( ) 18Invc2( ) 59invNorm( ) 59invt( ) 59normCdf( ) 81normPdf( ) 81poissCdf( ) 87poissPdf( ) 87tCdf( ) 122tPdf( ) 126

funciones definidas por el usuario34

funciones financieras, tvmFV( ) 128funciones financieras, tvmI( ) 128funciones financieras, tvmN( ) 129funciones financieras, tvmPmt( )

129funciones financieras, tvmPV( ) 129funciones y programas definidos por

el usuario 34, 35funciones y variables

copiar 21

Gg, grados centesimales 154gcd( ), máximo común divisor 52geomCdf( ) 52geomPdf( ) 52

180

getDenom( ), obtener/devolver denominador 52

getLangInfo( ), obtener/devolver información de idioma 53

getLockInfo( ), comprueba el estado de bloqueo de una variable o grupo de variables 53

getMode( ), obtener configuración de modo 53

getNum( ), obtener/devolver numerador 54

getVarInfo( ), obtener/devolver información de variables 54

4GMS, mostrar como grados/minutos/segundos 38

Goto, ir a 554, convertir ángulo a grados

centesimales 55grupos, bloquear y desbloquear 68,

131grupos, comprobar estado de

bloqueo 53

Hhexadecimal

indicador, 0h 159mostrar, 4Base16 15

hiperbólicaarcotangente, tanh/( ) 122tangente, tanh( ) 121

hiperbólicoarcocoseno, cosh/( ) 24arcoseno, sinh/( ) 110coseno, cosh( ) 24seno, sinh( ) 110

Iidentity( ), matriz identidad 56idioma

obtener información sobre idioma 53

If, if 56if, If 56ifFn( ) 57igual, = 146imag( ), parte imaginaria 57ImpDif( ), derivada implícita 58

Input, entrada 58inString( ), dentro de la cadena 58int( ), entero 58intDiv( ), dividir entero 58integral

numérica, nInt( ) 80integral definida

plantilla 5integral indefinida

plantilla 5integral, ä 149Invc2( ) 59inverso de un valor, ^/ 157inverso, ^/ 157invF( ) 59invNorm( ), distribución acumulada

normal inversa) 59invt( ) 59iPart( ), parte entera 59ir a, Goto 55irr( ), tasa interna de retorno

tasa interna de retorno, irr( ) 59isPrime( ), probar si es primo 60isVoid( ), comprueba si el elemento

no tiene valor 60izquierda, left( ) 61

LLbl, etiqueta 60lcm, mínimo común múltiplo 61left( ), izquierda 61LibPriv 34LibPub 35libShortcut( ), crea accesos directos a

objetos de biblioteca 61limit( ) o lim( ), límite 62límite

lim( ) 62limit( ) 62plantilla 6

LinRegBx, regresión lineal 62LinRegMx, regresión lineal 63LinRegtIntervals, regresión lineal 64linSolve() 66list4mat( ), lista matriz 66lista a matriz, list4mat( ) 66lista, contar elementos 25

181

lista, contar elementos condicionales26

listasampliar/concatenar, augment( )

12centro-cadena, mid( ) 75diferencia, @list( ) 66diferencias en una lista, @list( )

66elementos vacíos 160expresión a lista4list( ) 43lista a matriz, list4mat( ) 66matriz a lista, mat4list( ) 73máximo, max( ) 73mínimo, min( ) 75nueva, newList( ) 79ordenar en sentido ascendente,

SortA 114ordenar en sentido descendente,

SortD 114producto escalar, dotP( ) 39producto vectorial, crossP( ) 26producto, product( ) 91suma acumulada,

cumulativeSum( ) 30suma, sum( ) 119

ln( ), logaritmo natural 67LnReg, regresión logarítmica 67local, Local 68Local, variable local 68Lock, bloquear variable o grupo de

variables 68logaritmo

plantilla 2logaritmo natural, ln( ) 67logaritmos 67Logistic, regresión logística 70LogisticD, regresión logística 71longitud de arco, arcLen( ) 12longitud de la cadena 37Loop, bucle 72LU, descomposición inferior/superior

de matriz 72

Mmat4list( ), matriz a lista 73matrices

aleatoria, randMat( ) 96ampliar/concatenar, augment( )

12descomposición inferior/superior

de matriz, LU 72determinantes, det( ) 37diagonales, diag( ) 37dimensión de columna, colDim( )

19dimensión de filas, rowDim( )

102dimensión, dim( ) 37dividir punto, .P 145factorización QR, QR 92forma de fila escalonada

reducida, rref( ) 103forma de fila escalonada, ref( )

98identidad, identity( ) 56intercambiar filas, rowSwap( )

102lista a matriz, list4mat( ) 66matriz a lista, mat4list( ) 73máximo, max( ) 73mínimo, min( ) 75multiplicación y suma de filas,

mRowAdd( ) 76multiplicar punto, .* 144norma de columna, colNorm( )

19norma de fila, rowNorm( ) 102nueva, newMat( ) 79operación de fila, mRow( ) 76potencia de puntos, .^ 145producto, product( ) 91rellenar, Fill 46restar puntosN 144submatriz, subMat( ) 118, 119suma acumulada,

cumulativeSum( ) 30suma de filas, rowAdd( ) 102suma, sum( ) 119sumar puntos, .+ 144transponer, T 120valor propio, eigVl( ) 41vector propio, eigVc( ) 40

matriz (1 Q 2)plantilla 4

182



matriz (m Q n)plantilla 4

matriz a lista, mat4list( ) 73matriz de construcción,

constructMat( ) 21matriz de correlación, corrMat( ) 21matriz identidad, identity( ) 56max( ), máximo 73máximo común divisor, gcd( ) 52máximo, max( ) 73mayor o igual que, | 148mayor que, > 147mean( ), media 73media, mean( ) 73median( ), mediana 74mediana, median( ) 74MedMed, regresión recta mediana a

mediana 74menor o igual que, { 147menor que, < 147métodos abreviados, teclado 162mid( ), centro-cadena 75mientras final, EndWhile 133mientras, While 133min( ), mínimo 75mínimo común múltiplo, lcm 61mínimo, min( ) 75mirr( ), tasa interna de retorno

modificada 75mod( ), módulo 76modos

configurar, setMode( ) 106módulo, mod( ) 76mostrar como vector esférico,

4Sphere 115mostrar como vector rectangular,

4Rect 97mostrar datos, Disp 38mostrar en formato

ángulo decimal, 4DD 33binario, 4Base2 14entero decimal, 4Base10 14grados/minutos/segundos, 4GMS

38

hexadecimal, 4Base16 15vector cilíndrico, 4Cylind 31vector esférico, 4Sphere 115vector polar, 4Polar 87vector rectangular, 4Rect 97

mostrar grados/minutos/segundos, 4GMS 38

mostrar vector cilíndrico, 4Cylind 31mRow( ), operación de fila de matriz

76mRowAdd( ), multiplicación y suma

de filas de matriz 76muestra aleatoria 97multiplicar, * 142MultReg 76MultRegIntervals( ) 77MultRegTests( ) 77

NnCr( ), combinaciones 78nDerivative( ), derivada numérica

79negación, introducir números

negativos 165newList( ), nueva lista 79newMat( ), nueva matriz 79nfMax( ), máximo de función

numérica 79nfMin( ), mínimo de función

numérica 80nInt( ), integral numérica 80no igual, ƒ 146nom ), convertir nominal en tasa

efectiva 80norm( ), norma de Frobenius 81norma de Frobenius, norm( ) 81normalLine( ) 81normCdf( ) 81normPdf( ) 81not (exp booleana), not 81not, expresión booleana not 81notación en grado centesimal, g 154notación en grados, - 154notación en grados/minutos/

segundos 155notación en minutos, ' 155notación en segundos, " 155

183

nPr( ), variaciones 82npv( ), valor presente neto 83nSolve( ), solución numérica 83nueva

lista, newList( ) 79matriz, newMat( ) 79

numéricaderivada, nDerivative( ) 79

Oobjetos

crear accesos directos a biblioteca 61

obtener/devolverdenominador, getDenom( ) 52información sobre variables,

getVarInfo( ) 53, 54numerador, getNum( ) 54

OneVar, estadística de una variable84

operador de dirección (#) 165operadores

orden de los cálculos 164or (exp booleana), or 85or, expresión booleana or 85ord( ), código de carácter numérico.

85orden Stop 118orden Text 123ordenar

en sentido ascendente, SortA114

en sentido descendente, SortD114

PP4Rx( ), coordenada rectangular x

86P4Ry( ), coordenada rectangular y

86para, For 48parte entera, iPart( ) 59parte imaginaria, imag( ) 57pasar error, PassErr 86PassErr, pasar error 86Pdf( ) 49piecewise( ) 87

plantillasbase e 2derivada o derivada enésima 5exponente 1fracción 1función definida a trozos (2

partes) 2función definida a trozos (N

partes) 2integral definida 5integral indefinida 5límite 6logaritmo 2matriz (1 Q 2) 4matriz (2 Q 1) 4matriz (2 Q 2) 3matriz (m Q n) 4primera derivada 5producto (Π) 4raíz cuadrada 1raíz enésima 1segunda derivada 5sistema de ecuaciones (2

ecuaciones) 3sistema de ecuaciones (N

ecuaciones) 3suma (G) 4valor absoluto 3

poissCdf( ) 87poissPdf( ) 874Polar, mostrar como vector polar

87polar

coordenada, R4Pq( ) 95mostrar vector, 4Polar 87

polinomio de Taylor, taylor( ) 122polinomios

aleatorio, randPoly( ) 96evaluar, polyEval( ) 88

polyCoef( ) 88polyDegree( ) 88polyEval( ), valor del polinomio 88polyGcd( ) 89PolyRoots() 90porcentaje, % 145potencia de diez, 10^( ) 156potencia, ^ 143PowerReg, regresión potencial 90

184

Prgm, definir programa 91primera derivada

plantilla 5primo, ' 155probabilidad de distribución de t de

Student, tCdf( ) 122probabilidad de distribución normal,

normCdf( ) 81probar número primo, isPrime( ) 60prodSeq() 91product( ), producto 91producto

escalar, dotP( ) 39producto (Π)

plantilla 4producto vectorial, crossP( ) 26producto, Π( ) 151producto, product( ) 91programación

definir programa, Prgm 91mostrar datos, Disp 38pasar error, PassErr 86

programasdefinir biblioteca privada 34definir biblioteca pública 35

programas y programaciónborrar error, ClrErr 19finalizar programa, EndPrgm 91finalizar prueba, EndTry 126mostrar pantalla E/S, Disp 38probar, Try 126

propFrac, fracción propia 92punto

división, .P 145multiplicación, .* 144potencia, .^ 145resta, .N 144suma, .+ 144

QQR, factorización QR 92QuadReg, regresión cuadrática 93QuartReg, regresión cuártica 94

RR, radián 154R4Pq( ), coordenada polar 95

R4Pr( ), coordenada polar 954Rad, convertir a radianes 95radián, R 154raíz cuadrada

plantilla 1raíz cuadrada, à( ) 115, 150raíz enésima

plantilla 1rand( ), número aleatorio 95randBin, número aleatorio 96randInt( ), entero aleatorio 96randMat( ), matriz aleatoria 96randNorm( ), normal aleatorio 96randPoly( ), polinomio aleatorio 96randSamp( ) 97RandSeed, número raíz aleatorio 97real( ), real 97real, real( ) 97recopilación trigonométrica,

tCollect( ) 1234Rect, mostrar como vector

rectangular 97recta normal, normalLine( ) 81recta tangente, tangentLine( ) 121redondeo, round( ) 102ref( ), forma de fila escalonada 98regresión cuadrática, QuadReg 93regresión cuártica, QuartReg 94regresión cúbica, CubicReg 30regresión exponencial, ExpReg 44regresión lineal múltiple, test

<Equation Variables>t 77regresión lineal, LinRegAx 63regresión lineal, LinRegBx 62, 64regresión logarítmica, LnReg 67regresión logística, Logistic 70regresión logística, LogisticD 71regresión potencial, PowerReg 90,

99, 100, 123regresión recta mediana a mediana,

MedMed 74regresión sinusoidal, SinReg 111regresiones

cuadrática, QuadReg 93cuártica, QuartReg 94cúbicas, CubicReg 30exponenciales, ExpReg 44logarítmicas, LnReg 67

185

Logistic 70logística, Logistic 71MultReg 76recta mediana a mediana,

MedMed 74regresión lineal, LinRegAx 63regresión lineal, LinRegBx 62,

64regresión potencial, PowerReg

90, 99, 100, 123sinusoidal, SinReg 111

remain( ), resto 99Request 99RequestStr 100resolver, solve( ) 112respuesta (última), Ans 11resta, N 141resto, remain( ) 99resultado

ver en función de coseno 22ver en función de e 42ver en función de seno 109

resultado con dos variables, TwoVar130

resultados, estadísticos 116ResumenCincoNúmeros 47retroceder, Return 100Return, retroceder 100right( ), derecha 100rotar, rotate( ) 101rotate( ), rotar 101round( ), redondeo 102rowAdd( ), suma de filas de matriz

102rowDim( ), dimensión de filas de

matriz 102rowNorm( ), norma de fila de matriz

102rowSwap( ), intercambiar filas de

matriz 102rref( ), forma de fila escalonada

reducida 103

Ssalir, Exit 42sec( ), secante 103sec/( ), secante inversa 103

sech( ), secante hiperbólica 104sech/( ), secante hiperbólica inversa

104segunda derivada

plantilla 5seno

ver expresión en función de 109seno, sin( ) 109seq( ), sucesión 104series( ), series 105series, series( ) 105setMode( ), definir modo 106shift( ), desplazar 107sign( ), signo 108signo, sign( ) 108simult( ), ecuaciones simultáneas

1084sin, ver en función de seno 109sin valor, comprobar 60sin( ), seno 109sin/( ), arcoseno 110sinh( ), seno hiperbólico 110sinh/( ), arcoseno hiperbólico 110SinReg, regresión sinusoidal 111ΣInt( ) 152sistema de ecuaciones (2 ecuaciones)

plantilla 3sistema de ecuaciones (N

ecuaciones)plantilla 3

Sistema operativo de ecuaciones (EOS) 164

soluciónnumérica, nSolve( ) 83

solución, deSolve( ) 36solve( ), resolver 112SortA, ordenar en sentido

ascendente 114SortD, ordenar en sentido

descendente 1144Sphere, mostrar como vector

esférico 115ΣPrn( ) 153sqrt( ), raíz cuadrada 115stat.results 116stat.values 117stdDevPop( ), desviación estándar de

población 117

186

stdDevSamp( ), desviación estándar de la muestra 117

string( ), expresión a cadena 118subMat( ), submatriz 118, 119submatriz, subMat( ) 118, 119subrayado, _ 156sucesión, seq( ) 104suelo, floor( ) 47sum( ), suma 119suma (G)

plantilla 4suma acumulada, cumulativeSum( )

30suma de pagos de intereses 152suma de pagos de principal 153suma, + 141suma, Σ( ) 151suma, sum( ) 119sumIf( ) 119sumSeq() 119

TT, transponer 120tabla de amortización, amortTbl( )

7, 13tan( ), tangente 120tan/( ), arcotangente 121tangente, tan( ) 120tangentLine( ) 121tanh( ), tangente hiperbólica 121tanh/( ), arcotangente hiperbólica

122tasa efectiva, eff( ) 40tasa interna de retorno modificada,

mirr( ) 75tasa media de cambio, avgRC( ) 13tasa nominal, nom( ) 80taylor( ), polinomio de Taylor 122tCdf( ), probabilidad de distribución

de -t de Student 122tCollect( ), recopilación

trigonométrica 123techo, ceiling( ) 15, 16, 26teclas de método abreviado 162término dominante,

dominantTerm( ) 39Test F de 2 muestras 51

Test t de regresión lineal (LinRegTTest) 65

test t, tTest 127Test Z 138Test_2S, test F de 2 muestras 51tExpand( ), desarrollo

trigonométrico 123TInterval, intervalo t de confianza

124tInterval_2Samp, -intervalo t de

confianza de dos muestras 1244tmpCnv() 125tmpCnv() 125tPdf( ), densidad de probabilidad de

-t de Student 126trace( ) 126transponer, T 120Try, orden para gestión de errores

126tTest, test t 127tTest_2Samp, test t de 2 muestras

128TVM, argumentos 129tvmFV( ) 128tvmI( ) 128tvmN( ) 129tvmPmt( ) 129tvmPV( ) 129TwoVar, resultado con dos variables

130

Uunidad vectorial, unitV( ) 131unidades

convertir 156unitV( ), unidad vectorial 131unLock, desbloquea una variable o

un grupo de variables 131

Vvalor absoluto

plantilla 3valor del polinomio, polyEval( ) 88valor presente neto, npv( ) 83valor propio, eigVl( ) 41valor temporal del dinero, cantidad

del pago 129

187

valor temporal del dinero, Interés128

valor temporal del dinero, número de pagos 129

valor temporal del dinero, Valor futuro 128

valor temporal del dinero, valor presente 129

valores de resultados, estadísticos117

variable local, Local 68variables

crear nombre de una cadena de caracteres 165

eliminar, DelVar 35limpiar todas las letras 19local, Local 68

variables y funcionescopiar 21

variables, bloquear y desbloquear53, 68, 131

variaciones, nPr( ) 82varianza, variance( ) 132varPop( ) 132varSamp( ), varianza de la muestra

132vector propio, eigVc( ) 40vectores

mostrar vector cilíndrico, 4Cylind31

producto escalar, dotP( ) 39producto vectorial, crossP( ) 26unidades, unitV( ) 131

Wwhen( ), cuando 132While, mientras 133

Xx2, cuadrado 144xor, exclusiva booleana or 133

Zzeroes( ), ceros 134zInterval, z intervalo de confianza

136

zInterval_1Prop, intervalo z de confianza de una proporción136

zInterval_2Prop, intervalo z de confianza de dos proporciones137

zInterval_2Samp, intervalo z de confianza de dos muestras 137

zTest_1Prop, test z de una proporción 138

zTest_2Prop, test z de dos proporciones 139

zTest_2Samp, test z de dos muestras140

manual ti nspire cx cas

Documents