TI-Nspire™ CX Reference Guide

TI-Nspire™ CX

Reference Guide

Learn more about TI Technology through the online help at education.ti.com/eguide.

Important Information

Except as otherwise expressly stated in the License that accompanies a program, Texas

Instruments makes no warranty, either express or implied, including but not limited to

any implied warranties of merchantability and fitness for a particular purpose,

regarding any programs or book materials and makes such materials available solely

on an "as-is" basis. In no event shall Texas Instruments be liable to anyone for special,

collateral, incidental, or consequential damages in connection with or arising out of the

purchase or use of these materials, and the sole and exclusive liability of Texas

Instruments, regardless of the form of action, shall not exceed the amount set forth in

the license for the program. Moreover, Texas Instruments shall not be liable for any

claim of any kind whatsoever against the use of these materials by any other party.

Contents

Expression Templates 1

Alphabetical Listing 7

107

109

116

119

133

152

164

165

167

168

Symbols 174

TI-Nspire™ CX II - Draw Commands 197

Graphics Programming

197

Graphics Screen

197

Default View and Settings

198

Graphics Screen Errors Messages

199

Invalid Commands While in Graphics Mode

199

200

201

204

206

207

209

211

iii

Empty (Void) Elements 212

Shortcuts for Entering Math Expressions 214

EOS™ (Equation Operating System) Hierarchy 216

TI-Nspire CX II - TI-Basic Programming Features 218

Auto-indentation in Programming Editor

218

Improved Error Messages for TI-Basic

218

Constants and Values 221

Error Codes and Messages 222

Warning Codes and Messages 230

General Information 232

Online Help

232

Contact TI Support

232

Service and Warranty Information

232

Index 233

Expression Templates

Expression templates give you an easy way to enter math expressions in standard

mathematical notation. When you insert a template, it appears on the entry line with

small blocks at positions where you can enter elements. A cursor shows which element

you can enter.

Position the cursor on each element, and type a value or expression for the element.

Fraction template

/p keys

Note: See also / (divide), page 176.

Example:

Exponent template

l key

Note: Type the first value, press l, and

then type the exponent. To return the cursor

to the baseline, press right arrow (¢).

Note: See also ^ (power), page 177.

Example:

Square root template

/q keys

Note: See also √() (square root), page

186.

Example:

Nth root template

/l keys

Note: See also root(), page 130.

Example:

Expression Templates 1

2 Expression Templates

Nth root template

/l keys

e exponent template

u keys

Natural exponential e raised to a power

Note: See also e^(), page 43.

Example:

Log template

/s key

Calculates log to a specified base. For a

default of base 10, omit the base.

Note: See also log(), page 87.

Example:

Piecewise template (2-piece)

Catalog >

Lets you create expressions and conditions

for a two-piece piecewise function. To add

a piece, click in the template and repeat the

template.

Note: See also piecewise(), page 111.

Example:

Piecewise template (N-piece)

Catalog >

Lets you create expressions and conditions

for an N-piece piecewise function. Prompts

for N.

Example:

See the example for Piecewise template (2-

piece).

Piecewise template (N-piece)

Catalog >

Note: See also piecewise(), page 111.

System of 2 equations template

Catalog >

Creates a system of two linear equations.

To add a row to an existing system, click in

the template and repeat the template.

Note: See also system(), page 151.

Example:

System of N equations template

Catalog >

Lets you create a system of N linear

equations. Prompts for N.

Note: See also system(), page 151.

Example:

See the example for System of equations

template (2-equation).

Absolute value template

Catalog >

Note: See also abs(), page 7.

Example:

Expression Templates 3

4 Expression Templates

dd°mm’ss.ss’’ template

Catalog >

Lets you enter angles in dd°mm’ss.ss’’

format, where dd is the number of decimal

degrees, mm is the number of minutes, and

ss.ss is the number of seconds.

Example:

Matrix template (2 x 2)

Catalog >

Creates a 2 x 2 matrix.

Example:

Matrix template (1 x 2)

Catalog >

Example:

Matrix template (2 x 1)

Catalog >

Example:

Matrix template (m x n)

Catalog >

The template appears after you are

prompted to specify the number of rows

and columns.

Example:

Matrix template (m x n)

Catalog >

Note: If you create a matrix with a large

number of rows and columns, it may take a

few moments to appear.

Sum template (Σ)

Catalog >

Note: See also Σ() (sumSeq), page 187.

Example:

Product template (Π)

Catalog >

Note: See also Π() (prodSeq), page 186.

Example:

First derivative template

Catalog >

The first derivative template can be used to

calculate first derivative at a point

numerically, using auto differentiation

methods.

Note: See also d() (derivative), page 185.

Example:

Second derivative template

Catalog >

Example:

Expression Templates 5

6 Expression Templates

Second derivative template

Catalog >

The second derivative template can be used

to calculate second derivative at a point

numerically, using auto differentiation

methods.

Note: See also d() (derivative), page 185.

Definite integral template

Catalog >

The definite integral template can be used

to calculate the definite integral

numerically, using the same method as nInt

().

Note: See also nInt(), page 102.

Example:

Alphabetical Listing

Items whose names are not alphabetic (such as +, !, and >) are listed at the end of this

section, page 174. Unless otherwise specified, all examples in this section were

performed in the default reset mode, and all variables are assumed to be undefined.

abs()

Catalog >

abs(Value1) ⇒ value

abs(List1) ⇒ list

abs(Matrix1) ⇒ matrix

Returns the absolute value of the

argument.

Note: See also Absolute value template,

page 3.

If the argument is a complex number,

returns the number’s modulus.

amortTbl()

Catalog >

amortTbl(NPmt,N,I,PV, [Pmt], [FV],

[PpY], [CpY], [PmtAt], [roundValue]) ⇒

matrix

Amortization function that returns a matrix

as an amortization table for a set of TVM

arguments.

NPmt is the number of payments to be

included in the table. The table starts with

the first payment.

N, I, PV, Pmt, FV, PpY, CpY, and PmtAt

are described in the table of TVM

arguments, page 162.

• If you omit Pmt, it defaults to

Pmt=tvmPmt

(N,I,PV,FV,PpY,CpY,PmtAt).

• If you omit FV, it defaults to FV=0.

• The defaults for PpY, CpY, and PmtAt

are the same as for the TVM functions.

roundValue specifies the number of

decimal places for rounding. Default=2.

Alphabetical Listing 7

8 Alphabetical Listing

amortTbl()

Catalog >

The columns in the result matrix are in this

order: Payment number, amount paid to

interest, amount paid to principal, and

balance.

The balance displayed in row n is the

balance after payment n.

You can use the output matrix as input for

the other amortization functions ΣInt() and

ΣPrn(), page 187, and bal(), page 15.

and

Catalog >

BooleanExpr1 and BooleanExpr2 ⇒

Boolean expression

BooleanList1 and BooleanList2 ⇒

Boolean list

BooleanMatrix1 and BooleanMatrix2 ⇒

Boolean matrix

Returns true or false or a simplified form of

the original entry.

Integer1 andInteger2 ⇒ integer

Compares two real integers bit-by-bit using

an and operation. Internally, both integers

are converted to signed, 64-bit binary

numbers. When corresponding bits are

compared, the result is 1 if both bits are 1;

otherwise, the result is 0. The returned

value represents the bit results, and is

displayed according to the Base mode.

You can enter the integers in any number

base. For a binary or hexadecimal entry, you

must use the 0b or 0h prefix, respectively.

Without a prefix, integers are treated as

decimal (base10).

In Hex base mode:

Important: Zero, not the letter O.

In Bin base mode:

In Dec base mode:

Note: A binary entry can have upto 64 digits

(not counting the 0bprefix). A hexadecimal

entry canhave up to 16 digits.

angle()

Catalog >

angle(Value1) ⇒ value

In Degree angle mode:

angle()

Catalog >

Returns the angle of the argument,

interpreting the argument as a complex

number.

In Gradian angle mode:

In Radian angle mode:

angle(List1) ⇒ list

angle(Matrix1) ⇒ matrix

Returns a list or matrix of angles of the

elements in List1 or Matrix1, interpreting

each element as a complex number that

represents a two-dimensional rectangular

coordinate point.

ANOVA

Catalog >

ANOVA List1,List2[,List3,...,List20][,Flag]

Performs a one-way analysis of variance for

comparing the means of two to 20

populations. A summary of results is stored

in the stat.results variable. (page 146)

Flag=0 for Data, Flag=1 for Stats

Output variable Description

stat.F Value of the F statistic

stat.PVal Smallest level of significance at which the null hypothesis canbe rejected

stat.df Degrees of freedom of the groups

stat.SS Sum of squares of the groups

stat.MS Mean squares for the groups

stat.dfError Degrees of freedom of the errors

stat.SSError Sum of squares of the errors

Alphabetical Listing 9

10 Alphabetical Listing

Output variable Description

stat.MSError Mean square for the errors

stat.sp Pooled standard deviation

stat.xbarlist Mean of the input of the lists

stat.CLowerList 95% confidence intervals for the mean of each input list

stat.CUpperList 95% confidence intervals for the meanof each input list

ANOVA2way

Catalog >

ANOVA2way List1,List2[,List3,…,List10]

[,levRow]

Computes a two-way analysis of variance for

comparing the means of two to 10

populations. A summary of results is stored

in the stat.results variable. (See page 146.)

LevRow=0 for Block

LevRow=2,3,...,Len-1, for Two Factor,

where Len=length(List1)=length(List2) = …

= length(List10) and Len/LevRow Î

{2,3,…}

Outputs: Block Design

Output variable Description

stat.F Fstatistic of the column factor

stat.PVal Smallest level of significance at which the null hypothesis canbe rejected

stat.df Degrees of freedom of the column factor

stat.SS Sum of squares of the column factor

stat.MS Mean squares for column factor

stat.FBlock F statistic for factor

stat.PValBlock Least probability at which the null hypothesis canbe rejected

stat.dfBlock Degrees of freedom for factor

stat.SSBlock Sum of squares for factor

stat.MSBlock Meansquares for factor

stat.dfError Degrees of freedom of the errors

Output variable Description

stat.SSError Sum of squares of the errors

stat.MSError Mean squares for the errors

stat.s Standard deviation of the error

COLUMN FACTOR Outputs

Output variable Description

stat.Fcol F statistic of the column factor

stat.PValCol Probability value of the column factor

stat.dfCol Degrees of freedom of the column factor

stat.SSCol Sum of squares of the column factor

stat.MSCol Mean squares for column factor

ROW FACTOR Outputs

Output variable Description

stat.FRow F statistic of the row factor

stat.PValRow Probability value of the row factor

stat.dfRow Degrees of freedom of the row factor

stat.SSRow Sum of squares of the row factor

stat.MSRow Mean squares for row factor

INTERACTION Outputs

Output variable Description

stat.FInteract F statistic of the interaction

stat.PValInteract Probability value of the interaction

stat.dfInteract Degrees of freedom of the interaction

stat.SSInteract Sum of squares of the interaction

stat.MSInteract Mean squares for interaction

ERROR Outputs

Alphabetical Listing 11

12 Alphabetical Listing

Output variable Description

stat.dfError Degrees of freedom of the errors

stat.SSError Sum of squares of the errors

stat.MSError Mean squares for the errors

s Standard deviation of the error

Ans

/v keys

Ans ⇒ value

Returns the result of the most recently

evaluated expression.

approx()

Catalog >

approx(Value1) ⇒ number

Returns the evaluation of the argument as

an expression containing decimal values,

when possible, regardless of the current

Auto or Approximate mode.

This is equivalent to entering the argument

and pressing /·.

approx(List1) ⇒ list

approx(Matrix1) ⇒ matrix

Returns a list or matrix where each

element has been evaluated to a decimal

value, when possible.

►approxFraction()

Catalog >

Value►approxFraction([Tol]) ⇒ value

List►approxFraction([Tol]) ⇒ list

Matrix►approxFraction([Tol]) ⇒ matrix

Returns the input as a fraction, using a

tolerance of Tol. If Tol is omitted, a

tolerance of 5.E-14 is used.

►approxFraction()

Catalog >

Note: You can insert this function from the

computer keyboard by typing

@>approxFraction(...).

approxRational()

Catalog >

approxRational(Value[, Tol]) ⇒ value

approxRational(List[, Tol]) ⇒ list

approxRational(Matrix[, Tol]) ⇒ matrix

Returns the argument as a fraction using a

tolerance of Tol. If Tol is omitted, a

tolerance of 5.E-14 is used.

arccos()

See cos⁻¹(), page 26.

arccosh()

See cosh⁻¹(), page 27.

arccot()

See cot⁻¹(), page 28.

arccoth()

See coth⁻¹(), page 29.

arccsc()

See csc⁻¹(), page 31.

arccsch()

See csch⁻¹(), page 32.

Alphabetical Listing 13

14 Alphabetical Listing

arcsec()

See sec⁻¹(), page 134.

arcsech()

See sech⁻¹(), page 134.

arcsin()

See sin⁻¹(), page 142.

arcsinh()

See sinh⁻¹(), page 143.

arctan()

See tan⁻¹(), page 153.

arctanh()

See tanh⁻¹(), page 154.

augment()

Catalog >

augment(List1, List2) ⇒ list

Returns a new list that is List2 appended to

the end of List1.

augment(Matrix1, Matrix2) ⇒ matrix

Returns a new matrix that is Matrix2

appended to Matrix1. When the “,”

character is used, the matrices must have

equal row dimensions, and Matrix2 is

appended to Matrix1 as new columns.

Does not alter Matrix1 or Matrix2.

avgRC()

Catalog >

avgRC(Expr1, Var [=Value] [, Step]) ⇒

expression

avgRC(Expr1, Var [=Value] [, List1]) ⇒

list

avgRC(List1, Var [=Value] [, Step]) ⇒

list

avgRC(Matrix1, Var [=Value] [, Step]) ⇒

matrix

Returns the forward-difference quotient

(average rate of change).

Expr1 can be a user-defined function name

(see Func).

When Value is specified, it overrides any

prior variable assignment or any current “|”

substitution for the variable.

Step is the step value. If Step is omitted, it

defaults to 0.001.

Note that the similar function centralDiff()

uses the central-difference quotient.

bal()

Catalog >

bal(NPmt,N,I,PV ,[Pmt], [FV], [PpY],

[CpY], [PmtAt], [roundValue]) ⇒ value

bal(NPmt,amortTable) ⇒ value

Amortization function that calculates

schedule balance after a specified payment.

N, I, PV, Pmt, FV, PpY, CpY, and PmtAt

are described in the table of TVM

arguments, page 162.

NPmt specifies the payment number after

which you want the data calculated.

N, I, PV, Pmt, FV, PpY, CpY, and PmtAt

are described in the table of TVM

arguments, page 162.

Alphabetical Listing 15

16 Alphabetical Listing

bal()

Catalog >

• If you omit Pmt, it defaults to

Pmt=tvmPmt

(N,I,PV,FV,PpY,CpY,PmtAt).

• If you omit FV, it defaults to FV=0.

• The defaults for PpY, CpY, and PmtAt

are the same as for the TVM functions.

roundValue specifies the number of

decimal places for rounding. Default=2.

bal(NPmt,amortTable) calculates the

balance after payment number NPmt,

based on amortization table amortTable.

The amortTable argument must be a

matrix in the form described under

amortTbl(), page 7.

Note: See also ΣInt() and ΣPrn(), page 187.

►Base2

Catalog >

Integer1 ►Base2 ⇒ integer

Note: You can insert this operator from the

computer keyboard by typing @>Base2.

Converts Integer1 to a binary number.

Binary or hexadecimal numbers always

have a 0b or 0h prefix, respectively. Use a

zero, not the letter O, followed by b or h.

0b binaryNumber

0h hexadecimalNumber

A binary number can have up to 64 digits. A

hexadecimal number can have up to 16.

Without a prefix, Integer1 is treated as

decimal (base10). The result is displayed in

binary, regardless of the Base mode.

Negative numbers are displayed in “two's

complement” form. For example,

⁻1is displayed as

0hFFFFFFFFFFFFFFFFin Hex base mode

0b111...111 (641’s)in Binary base mode

⁻2

is displayed as

0h8000000000000000in Hex base mode

0b100...000 (63 zeros)in Binary base mode

►Base2

Catalog >

If you enter a decimal integer that is

outside the range of a signed, 64-bit binary

form, a symmetric modulo operation is

used to bring the value into the appropriate

range. Consider the following examples of

values outside the range.

becomes ⁻2

and is displayed as

0h8000000000000000in Hex base mode

0b100...000 (63 zeros)in Binary base mode

becomes 0 and is displayed as

0h0in Hex base mode

0b0in Binary base mode

⁻2

− 1 becomes 2

− 1 and is displayed

0h7FFFFFFFFFFFFFFFin Hex base mode

0b111...111 (641’s)in Binary base mode

►Base10

Catalog >

Integer1 ►Base10 ⇒ integer

Note: You can insert this operator from the

computer keyboard by typing @>Base10.

Converts Integer1 to a decimal (base10)

number. A binary or hexadecimal entry

must always have a 0b or 0h prefix,

respectively.

0b binaryNumber

0h hexadecimalNumber

Zero, not the letter O, followed by b or h.

A binary number can have up to 64 digits. A

hexadecimal number can have up to 16.

Without a prefix, Integer1 is treated as

decimal. The result is displayed in decimal,

regardless of the Base mode.

►Base16

Catalog >

Integer1 ►Base16 ⇒ integer

Note: You can insert this operator from the

computer keyboard by typing @>Base16.

Alphabetical Listing 17

18 Alphabetical Listing

►Base16

Catalog >

Converts Integer1 to a hexadecimal

number. Binary or hexadecimal numbers

always have a 0b or 0h prefix, respectively.

0b binaryNumber

0h hexadecimalNumber

Zero, not the letter O, followed by b or h.

A binary number can have up to 64 digits. A

hexadecimal number can have up to 16.

Without a prefix, Integer1 is treated as

decimal (base10). The result is displayed in

hexadecimal, regardless of the Base mode.

If you enter a decimal integer that is too

large for a signed, 64-bit binary form, a

symmetric modulo operation is used to

bring the value into the appropriate range.

For more information, see ►Base2, page

16.

binomCdf()

Catalog >

binomCdf(n,p) ⇒ list

binomCdf(n,p,lowBound,upBound) ⇒

number if lowBound and upBound are

numbers, list if lowBound and upBound are

lists

binomCdf(n,p,upBound)for P(0≤X≤upBound)

⇒ number if upBound is a number, list if

upBound is a list

Computes a cumulative probability for the

discrete binomial distribution with n number

of trials and probability p of success on each

trial.

For P(X ≤ upBound), set lowBound=0

binomPdf()

Catalog >

binomPdf(n,p) ⇒ list

binomPdf(n,p,XVal) ⇒ number if XVal is a

number, list if XVal is a list

binomPdf()

Catalog >

Computes a probability for the discrete

binomial distribution with n number of trials

and probability p of success on each trial.

Catalog >

ceiling(Value1) ⇒ value

Returns the nearest integer that is ≥ the

argument.

The argument can be a real or a complex

number.

Note: See also floor().

ceiling(List1) ⇒ list

ceiling(Matrix1) ⇒ matrix

Returns a list or matrix of the ceiling of

each element.

centralDiff()

Catalog >

centralDiff(Expr1,Var [=Value][,Step]) ⇒

expression

centralDiff(Expr1,Var [,Step])|Var=Value

⇒ expression

centralDiff(Expr1,Var [=Value][,List]) ⇒

list

centralDiff(List1,Var [=Value][,Step]) ⇒

list

centralDiff(Matrix1,Var [=Value][,Step])

⇒ matrix

Returns the numerical derivative using the

central difference quotient formula.

When Value is specified, it overrides any

prior variable assignment or any current “|”

substitution for the variable.

Step is the step value. If Step is omitted, it

defaults to 0.001.

Alphabetical Listing 19

20 Alphabetical Listing

centralDiff()

Catalog >

When using List1 or Matrix1, the operation

gets mapped across the values in the list or

across the matrix elements.

Note: See also avgRC().

char()

Catalog >

char(Integer) ⇒ character

Returns a character string containing the

character numbered Integer from the

handheld character set. The valid range for

Integer is 0–65535.

2way

Catalog >

2way obsMatrix

chi22way obsMatrix

Computes a χ

test for association on the

two-way table of counts in the observed

matrix obsMatrix. A summary of results is

stored in the stat.results variable. (page

146)

For information on the effect of empty

elements in a matrix, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.χ

Chi square stat: sum (observed - expected)

/expected

stat.PVal Smallest level of significance at which the null hypothesis canbe rejected

stat.df Degrees of freedom for the chi square statistics

stat.ExpMat Matrix of expected elemental counttable, assuming null hypothesis

stat.CompMat Matrix of elemental chi square statistic contributions

Cdf()

Catalog >

Cdf(lowBound,upBound,df) ⇒ number if

lowBound and upBound are numbers, list if

lowBound and upBound are lists

Cdf()

Catalog >

chi2Cdf(lowBound,upBound,df) ⇒ number

if lowBound and upBound are numbers, list

if lowBound and upBound are lists

Computes the χ

distribution probability

between lowBound and upBound for the

specified degrees of freedom df.

For P(X ≤ upBound), set lowBound = 0.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

GOF

Catalog >

GOF obsList,expList,df

chi2GOF obsList,expList,df

Performs a test to confirm that sample data

is from a population that conforms to a

specified distribution. obsList is a list of

counts and must contain integers. A

summary of results is stored in the

stat.results variable. (See page 146.)

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.χ

Chi square stat: sum((observed- expected)

/expected

stat.PVal Smallest level of significance at which the null hypothesis canbe rejected

stat.df Degrees of freedom for the chi square statistics

stat.CompList Elemental chi square statistic contributions

Pdf()

Catalog >

Pdf(XVal,df) ⇒ number if XVal is a

number, list if XVal is a list

chi2Pdf(XVal,df) ⇒ number if XVal is a

number, list if XVal is a list

Alphabetical Listing 21

22 Alphabetical Listing

Pdf()

Catalog >

Computes the probability density function

(pdf) for the χ

distribution at a specified

XVal value for the specified degrees of

freedom df.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

ClearAZ

Catalog >

ClearAZ

Clears all single-character variables in the

current problem space.

If one or more of the variables are locked,

this command displays an error message

and deletes only the unlocked variables. See

unLock, page 164.

ClrErr

Catalog >

ClrErr

Clears the error status and sets system

variable errCode to zero.

The Else clause of the Try...Else...EndTry

block should use ClrErr or PassErr. If the

error is to be processed or ignored, use

ClrErr. If what to do with the error is not

known, use PassErr to send it to the next

error handler. If there are no more pending

Try...Else...EndTry error handlers, the error

dialog box will be displayed as normal.

Note: See also PassErr, page 110, and Try,

page 158.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product guidebook.

For an example of ClrErr, See Example 2

under the Try command, page 158.

colAugment()

Catalog >

colAugment(Matrix1, Matrix2) ⇒ matrix

Returns a new matrix that is Matrix2

appended to Matrix1. The matrices must

have equal column dimensions, and

Matrix2 is appended to Matrix1 as new

rows. Does not alter Matrix1 or Matrix2.

colDim()

Catalog >

colDim(Matrix) ⇒ expression

Returns the number of columns contained

in Matrix.

Note: See also rowDim().

colNorm()

Catalog >

colNorm(Matrix) ⇒ expression

Returns the maximum of the sums of the

absolute values of the elements in the

columns in Matrix.

Note: Undefined matrix elements are not

allowed. See also rowNorm().

conj()

Catalog >

conj(Value1) ⇒ value

conj(List1) ⇒ list

conj(Matrix1) ⇒ matrix

Returns the complex conjugate of the

argument.

Alphabetical Listing 23

24 Alphabetical Listing

constructMat()

Catalog >

constructMat

(Expr,Var1,Var2,numRows,numCols) ⇒

matrix

Returns a matrix based on the arguments.

Expr is an expression in variables Var1 and

Var2. Elements in the resulting matrix are

formed by evaluating Expr for each

incremented value of Var1 and Var2.

Var1 is automatically incremented from 1

through numRows. Within each row, Var2

is incremented from 1 through numCols.

CopyVar

Catalog >

CopyVar Var1, Var2

CopyVar Var1., Var2.

CopyVar Var1, Var2 copies the value of

variable Var1 to variable Var2, creating

Var2 if necessary. Variable Var1 must have

a value.

If Var1 is the name of an existing user-

defined function, copies the definition of

that function to function Var2. Function

Var1 must be defined.

Var1 must meet the variable-naming

requirements or must be an indirection

expression that simplifies to a variable

name meeting the requirements.

CopyVar Var1., Var2. copies all members

of the Var1. variable group to the Var2.

group, creating Var2. if necessary.

Var1. must be the name of an existing

variable group, such as the statistics stat.nn

results, or variables created using the

LibShortcut() function. If Var2. already

exists, this command replaces all members

that are common to both groups and adds

the members that do not already exist. If

one or more members of Var2. are locked,

all members of Var2. are left unchanged.

corrMat()

Catalog >

corrMat(List1,List2[,…[,List20]])

Computes the correlation matrix for the

augmented matrix [List1, List2, ..., List20].

cos()

µ key

cos(Value1) ⇒ value

cos(List1) ⇒ list

cos(Value1) returns the cosine of the

argument as a value.

cos(List1) returns a list of the cosines of all

elements in List1.

Note: The argument is interpreted as a

degree, gradian or radian angle, according

to the current angle mode setting. You can

use °,

, or

to override the angle mode

temporarily.

In Degree angle mode:

In Gradian angle mode:

In Radian angle mode:

cos(squareMatrix1) ⇒ squareMatrix

Returns the matrix cosine of

squareMatrix1. This is not the same as

calculating the cosine of each element.

When a scalar function f(A) operates on

squareMatrix1 (A), the result is calculated

by the algorithm:

Compute the eigenvalues (λ

) and

eigenvectors (V

) of A.

squareMatrix1 must be diagonalizable.

Also, it cannot have symbolic variables that

have not been assigned a value.

Form the matrices:

In Radian angle mode:

Alphabetical Listing 25

26 Alphabetical Listing

cos()

µ key

Then A = X B X⁻¹ and f(A) = X f(B) X⁻¹. For

example, cos(A) = X cos(B) X⁻¹ where:

cos(B) =

All computations are performed using

floating-point arithmetic.

cos⁻¹()

µ key

cos⁻¹(Value1) ⇒ value

cos⁻¹(List1) ⇒ list

cos⁻¹(Value1) returns the angle whose

cosine is Value1.

cos⁻¹(List1) returns a list of the inverse

cosines of each element of List1.

Note: The result is returned as a degree,

gradian or radian angle, according to the

current angle mode setting.

Note: You can insert this function from the

keyboard by typing arccos(...).

In Degree angle mode:

In Gradian angle mode:

In Radian angle mode:

cos⁻¹(squareMatrix1) ⇒ squareMatrix

Returns the matrix inverse cosine of

squareMatrix1. This is not the same as

calculating the inverse cosine of each

element. For information about the

calculation method, refer to cos().

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

In Radian angle mode and Rectangular

Complex Format:

To see the entire result,

press 5 andthen use 7and8 to move the

cursor.

cosh()

Catalog >

cosh(Value1) ⇒ value

cosh(List1) ⇒ list

cosh(Value1) returns the hyperbolic cosine

of the argument.

cosh(List1) returns a list of the hyperbolic

cosines of each element of List1.

In Degree angle mode:

cosh(squareMatrix1) ⇒ squareMatrix

Returns the matrix hyperbolic cosine of

squareMatrix1. This is not the same as

calculating the hyperbolic cosine of each

element. For information about the

calculation method, refer to cos().

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

In Radian angle mode:

cosh⁻¹()

Catalog >

cosh⁻¹(Value1) ⇒ value

cosh⁻¹(List1) ⇒ list

cosh⁻¹(Value1) returns the inverse

hyperbolic cosine of the argument.

cosh⁻¹(List1) returns a list of the inverse

hyperbolic cosines of each element of

List1.

Note: You can insert this function from the

keyboard by typing arccosh(...).

cosh⁻¹(squareMatrix1) ⇒ squareMatrix

Returns the matrix inverse hyperbolic

cosine of squareMatrix1. This is not the

same as calculating the inverse hyperbolic

cosine of each element. For information

about the calculation method, refer to cos

().

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

In Radian angle mode and In Rectangular

Complex Format:

To see the entire result,

press 5 andthen use 7and8 to move the

cursor.

Alphabetical Listing 27

28 Alphabetical Listing

cot()

µ key

cot(Value1) ⇒ value

cot(List1) ⇒ list

Returns the cotangent of Value1 or returns

a list of the cotangents of all elements in

List1.

Note: The argument is interpreted as a

degree, gradian or radian angle, according

to the current angle mode setting. You can

use °,

, or

to override the angle mode

temporarily.

In Degree angle mode:

In Gradian angle mode:

In Radian angle mode:

cot⁻¹()

µ key

cot⁻¹(Value1) ⇒ value

cot⁻¹(List1) ⇒ list

Returns the angle whose cotangent is

Value1 or returns a list containing the

inverse cotangents of each element of

List1.

Note: The result is returned as a degree,

gradian or radian angle, according to the

current angle mode setting.

Note: You can insert this function from the

keyboard by typing arccot(...).

In Degree angle mode:

In Gradian angle mode:

In Radian angle mode:

coth()

Catalog >

coth(Value1) ⇒ value

coth(List1) ⇒ list

Returns the hyperbolic cotangent of Value1

or returns a list of the hyperbolic

cotangents of all elements of List1.

coth⁻¹()

Catalog >

coth⁻¹(Value1) ⇒ value

coth⁻¹(List1) ⇒ list

Returns the inverse hyperbolic cotangent of

Value1 or returns a list containing the

inverse hyperbolic cotangents of each

element of List1.

Note: You can insert this function from the

keyboard by typing arccoth(...).

count()

Catalog >

count(Value1orList1 [,Value2orList2

[,...]]) ⇒ value

Returns the accumulated count of all

elements in the arguments that evaluate to

numeric values.

Each argument can be an expression, value,

list, or matrix. You can mix data types and

use arguments of various dimensions.

For a list, matrix, or range of cells, each

element is evaluated to determine if it

should be included in the count.

Within the Lists & Spreadsheet application,

you can use a range of cells in place of any

argument.

Empty (void) elements are ignored. For

more information on empty elements, see

page 212.

countif()

Catalog >

countif(List,Criteria) ⇒ value

Returns the accumulated count of all

elements in List that meet the specified

Criteria.

Criteria can be:

• A value, expression, or string. For

Counts the number of elements equal to 3.

Alphabetical Listing 29

30 Alphabetical Listing

countif()

Catalog >

example, 3 counts only those elements in

List that simplify to the value 3.

• A Boolean expression containing the

symbol ? as a placeholder for each

element. For example, ?<5 counts only

those elements in List that are less than

Within the Lists & Spreadsheet application,

you can use a range of cells in place of List.

Empty (void) elements in the list are

ignored. For more information on empty

elements, see page 212.

Note: See also sumIf(), page 150, and

frequency(), page 56.

Counts the number of elements equal to

“def.”

Counts 1 and 3.

Counts 3, 5, and7.

Counts 1, 3, 7, and 9.

cPolyRoots()

Catalog >

cPolyRoots(Poly,Var) ⇒ list

cPolyRoots(ListOfCoeffs) ⇒ list

The first syntax, cPolyRoots(Poly,Var),

returns a list of complex roots of

polynomial Poly with respect to variable

Var.

Poly must be a polynomial in expanded

form in one variable. Do not use

unexpanded forms such as y

•y+1 or

x•x+2•x+1

The second syntax, cPolyRoots

(ListOfCoeffs), returns a list of complex

roots for the coefficients in ListOfCoeffs.

Note: See also polyRoots(), page 113.

crossP()

Catalog >

crossP(List1, List2) ⇒ list

Returns the cross product of List1 and

List2 as a list.

crossP()

Catalog >

List1 and List2 must have equal

dimension, and the dimension must be

either 2 or 3.

crossP(Vector1, Vector2) ⇒ vector

Returns a row or column vector (depending

on the arguments) that is the cross product

of Vector1 and Vector2.

Both Vector1 and Vector2 must be row

vectors, or both must be column vectors.

Both vectors must have equal dimension,

and the dimension must be either 2or3.

csc()

µ key

csc(Value1) ⇒ value

csc(List1) ⇒ list

Returns the cosecant of Value1 or returns a

list containing the cosecants of all elements

in List1.

In Degree angle mode:

In Gradian angle mode:

In Radian angle mode:

csc⁻¹()

µ key

csc⁻¹(Value1) ⇒ value

csc⁻¹(List1) ⇒ list

Returns the angle whose cosecant is

Value1 or returns a list containing the

inverse cosecants of each element of List1.

Note: The result is returned as a degree,

gradian or radian angle, according to the

current angle mode setting.

Note: You can insert this function from the

keyboard by typing arccsc(...).

In Degree angle mode:

In Gradian angle mode:

In Radian angle mode:

Alphabetical Listing 31

32 Alphabetical Listing

csch()

Catalog >

csch(Value1) ⇒ value

csch(List1) ⇒ list

Returns the hyperbolic cosecant of Value1

or returns a list of the hyperbolic cosecants

of all elements of List1.

csch⁻¹()

Catalog >

csch⁻¹(Value) ⇒ value

csch⁻¹(List1) ⇒ list

Returns the inverse hyperbolic cosecant of

Value1 or returns a list containing the

inverse hyperbolic cosecants of each

element of List1.

Note: You can insert this function from the

keyboard by typing arccsch(...).

CubicReg

Catalog >

CubicReg X, Y[, [Freq] [, Category,

Include]]

Computes the cubic polynomial regression

y=a•x

+b•x

+c•x+d on lists X and Y with

frequency Freq. A summary of results is

stored in the stat.results variable. (See page

146.)

All the lists must have equal dimension

except for Include.

X and Y are lists of independent and

dependent variables.

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1. All elements must be

integers ≥ 0.

Category is a list of numeric or string

category codes for the corresponding X and

Y data.

CubicReg

Catalog >

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output

variable

Description

stat.RegEqn

Regression equation: a•x

+b•x

+c•x+d

stat.a, stat.b,

stat.c, stat.d

Regression coefficients

stat.R

Coefficientof determination

stat.Resid Residuals from the regression

stat.XReg

Listof data points in the modified X List actually used in the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.YReg

Listof data points in the modified Y List actually usedin the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.FreqReg

Listof frequencies corresponding to stat.XReg and stat.YReg

cumulativeSum()

Catalog >

cumulativeSum(List1) ⇒ list

Returns a list of the cumulative sums of the

elements in List1, starting at element1.

cumulativeSum(Matrix1) ⇒ matrix

Returns a matrix of the cumulative sums of

the elements in Matrix1. Each element is

the cumulative sum of the column from top

to bottom.

An empty (void) element in List1 or

Matrix1 produces a void element in the

resulting list or matrix. For more

information on empty elements, see page

212.

Alphabetical Listing 33

34 Alphabetical Listing

Cycle

Catalog >

Cycle

Transfers control immediately to the next

iteration of the current loop (For, While, or

Loop).

Cycle is not allowed outside the three

looping structures (For, While, or Loop).

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

Function listing that sums the integers from 1

to 100 skipping 50.

►Cylind

Catalog >

Vector ►Cylind

Note: You can insert this operator from the

computer keyboard by typing @>Cylind.

Displays the row or column vector in

cylindrical form [r,∠ θ, z].

Vector must have exactly three elements.

It can be either a row or a column.

dbd()

Catalog >

dbd(date1,date2) ⇒ value

Returns the number of days between date1

and date2 using the actual-day-count

method.

date1 and date2 can be numbers or lists of

numbers within the range of the dates on

the standard calendar. If both date1 and

date2 are lists, they must be the same

length.

date1 and date2 must be between the

years 1950 through 2049.

You can enter the dates in either of two

formats. The decimal placement

differentiates between the date formats.

MM.DDYY (format used commonly in the

United States)

DDMM.YY (format use commonly in

Europe)

►DD

Catalog >

Expr1 ►DD ⇒ valueList1

►DD ⇒ listMatrix1

►DD ⇒ matrix

Note: You can insert this operator from the

computer keyboard by typing @>DD.

Returns the decimal equivalent of the

argument expressed in degrees. The

argument is a number, list, or matrix that is

interpreted by the Angle mode setting in

gradians, radians or degrees.

In Degree angle mode:

In Gradian angle mode:

In Radian angle mode:

Alphabetical Listing 35

36 Alphabetical Listing

►Decimal

Catalog >

Number1 ►Decimal ⇒ value

List1 ►Decimal ⇒ value

Matrix1 ►Decimal ⇒ value

Note: You can insert this operator from the

computer keyboard by typing @>Decimal.

Displays the argument in decimal form.

This operator can be used only at the end of

the entry line.

Define

Catalog >

Define Var = Expression

Define Function(Param1, Param2, ...) =

Expression

Defines the variable Var or the user-

defined function Function.

Parameters, such as Param1, provide

placeholders for passing arguments to the

function. When calling a user-defined

function, you must supply arguments (for

example, values or variables) that

correspond to the parameters. When called,

the function evaluates Expression using

the supplied arguments.

Var and Function cannot be the name of a

system variable or built-in function or

command.

Note: This form of Define is equivalent to

executing the expression: expression →

Function(Param1,Param2).

Define Function(Param1, Param2, ...) =

Func

Block

EndFunc

Define Program(Param1, Param2, ...) =

Prgm

Block

EndPrgm

Define

Catalog >

In this form, the user-defined function or

program can execute a block of multiple

statements.

Block can be either a single statement or a

series of statements on separate lines.

Block also can include expressions and

instructions (such as If, Then, Else, and For).

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

Note: See also Define LibPriv, page 37, and

Define LibPub, page 37.

Define LibPriv

Catalog >

Define LibPriv Var = Expression

Define LibPriv Function(Param1, Param2,

...) = Expression

Define LibPriv Function(Param1, Param2,

...) = Func

Block

EndFunc

Define LibPriv Program(Param1, Param2,

...) = Prgm

Block

EndPrgm

Operates the same as Define, except defines

a private library variable, function, or

program. Private functions and programs do

not appear in the Catalog.

Note: See also Define, page 36, and Define

LibPub, page 37.

Define LibPub

Catalog >

Define LibPub Var = Expression

Define LibPub Function(Param1, Param2,

...) = Expression

Define LibPub Function(Param1, Param2,

Alphabetical Listing 37

38 Alphabetical Listing

Define LibPub

Catalog >

...) = Func

Block

EndFunc

Define LibPub Program(Param1, Param2,

...) = Prgm

Block

EndPrgm

Operates the same as Define, except defines

a public library variable, function, or

program. Public functions and programs

appear in the Catalog after the library has

been saved and refreshed.

Note: See also Define, page 36, and Define

LibPriv, page 37.

deltaList()

See ΔList(), page 83.

DelVar

Catalog >

DelVar Var1[, Var2] [, Var3] ...

DelVar Var.

Deletes the specified variable or variable

group from memory.

If one or more of the variables are locked,

this command displays an error message

and deletes only the unlocked variables. See

unLock, page 164.

DelVar

Catalog >

DelVar Var. deletes all members of the

Var. variable group (such as the statistics

stat.nn results or variables created using

the LibShortcut() function). The dot (.) in

this form of the DelVar command limits it

to deleting a variable group; the simple

variable Var is not affected.

delVoid()

Catalog >

delVoid(List1) ⇒ list

Returns a list that has the contents of List1

with all empty (void) elements removed.

For more information on empty elements,

see page 212.

det()

Catalog >

det(squareMatrix[, Tolerance]) ⇒

expression

Returns the determinant of squareMatrix.

Optionally, any matrix element is treated as

zero if its absolute value is less than

Tolerance. This tolerance is used only if the

matrix has floating-point entries and does

not contain any symbolic variables that

have not been assigned a value. Otherwise,

Tolerance is ignored.

• If you use /· or set the Auto or

Approximate mode to Approximate,

computations are done using floating-

point arithmetic.

• If Tolerance is omitted or not used, the

default tolerance is calculated as:

5E⁻14 •max(dim(squareMatrix))

•rowNorm(squareMatrix)

Alphabetical Listing 39

40 Alphabetical Listing

diag()

Catalog >

diag(List) ⇒ matrix

diag(rowMatrix) ⇒ matrix

diag(columnMatrix) ⇒ matrix

Returns a matrix with the values in the

argument list or matrix in its main

diagonal.

diag(squareMatrix) ⇒ rowMatrix

Returns a row matrix containing the

elements from the main diagonal of

squareMatrix.

squareMatrix must be square.

dim()

Catalog >

dim(List) ⇒ integer

Returns the dimension of List.

dim(Matrix) ⇒ list

Returns the dimensions of matrix as a two-

element list {rows, columns}.

dim(String) ⇒ integer

Returns the number of characters contained

in character string String.

Disp

Catalog >

Disp exprOrString1 [, exprOrString2] ...

Displays the arguments in the Calculator

history. The arguments are displayed in

succession, with thin spaces as separators.

Useful mainly in programs and functions to

ensure the display of intermediate

calculations.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

DispAt

Catalog >

DispAt int,expr1 [,expr2 ...] ...

DispAt allows you to specify the line

where the specified expression or string

will be displayed on the screen.

The line number can be specified as an

expression.

Please note that the line number is not

for the entire screen but for the area

immediately following the

command/program.

This command allows dashboard-like

output from programs where the value

of an expression or from a sensor

reading is updated on the same line.

DispAtand Disp can be used within the

same program.

Note: The maximum number is set to 8

since that matches a screen-full of lines

on the handheld screen - as long as the

lines don't have 2D math expressions.

The exact number of lines depends on

the content of the displayed

information.

Example

Illustrative examples:

Define z()=

Prgm

For n,1,3

DispAt 1,"N: ",n

Disp "Hello"

EndFor

EndPrgm

Output

z()

Iteration 1:

Line 1: N:1

Line 2: Hello

Iteration 2:

Line 1: N:2

Line 2: Hello

Line 3: Hello

Iteration 3:

Line 1: N:3

Alphabetical Listing 41

42 Alphabetical Listing

DispAt

Catalog >

Line 2: Hello

Line 3: Hello

Line 4: Hello

Define z1()=

Prgm

For n,1,3

DispAt 1,"N: ",n

EndFor

For n,1,4

Disp "Hello"

EndFor

EndPrgm

z1()

Line 1: N:3

Line 2: Hello

Line 3: Hello

Line 4: Hello

Line 5: Hello

Error conditions:

Error Message Description

DispAt line number must be between 1 and 8 Expression evaluates the line number

outside the range 1-8 (inclusive)

Too few arguments The function or command is missing one

or more arguments.

No arguments Same as current 'syntax error' dialog

Too many arguments Limit argument. Same error as Disp.

Invalid data type First argument must be a number.

Void: DispAt void "Hello World" Datatype error is thrown

for the void (if the callback is defined)

►DMS

Catalog >

Value ►DMS

List ►DMS

Matrix ►DMS

Note: You can insert this operator from the

computer keyboard by typing @>DMS.

In Degree angle mode:

►DMS

Catalog >

Interprets the argument as an angle and

displays the equivalent DMS

(DDDDDD°MM'SS.ss'') number. See °, ', ''

on page 191 for DMS (degree, minutes,

seconds) format.

Note: ►DMS will convert from radians to

degrees when used in radian mode. If the

input is followed by a degree symbol ° , no

conversion will occur. You can use ►DMS

only at the end of an entry line.

dotP()

Catalog >

dotP(List1, List2) ⇒ expression

Returns the “dot” product of two lists.

dotP(Vector1, Vector2) ⇒ expression

Returns the “dot” product of two vectors.

Both must be row vectors, or both must be

column vectors.

See Also: TI-Nspire™ CX II - Draw Commands

e^()

u key

e^(Value1) ⇒ value

Returns e raised to the Value1 power.

Note: See also e exponent template, page

Note: Pressing u to display e^( is different

from pressing the character E on the

keyboard.

Alphabetical Listing 43

44 Alphabetical Listing

e^()

u key

You can enter a complex number in re

polar form. However, use this form in

Radian angle mode only; it causes a

Domain error in Degree or Gradian angle

mode.

e^(List1) ⇒ list

Returns e raised to the power of each

element in List1.

e^(squareMatrix1) ⇒ squareMatrix

Returns the matrix exponential of

squareMatrix1. This is not the same as

calculating e raised to the power of each

element. For information about the

calculation method, refer to cos().

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

eff()

Catalog >

eff(nominalRate,CpY) ⇒ value

Financial function that converts the nominal

interest rate nominalRate to an annual

effective rate, given CpY as the number of

compounding periods per year.

nominalRate must be a real number, and

CpY must be a real number > 0.

Note: See also nom(), page 103.

eigVc()

Catalog >

eigVc(squareMatrix) ⇒ matrix

Returns a matrix containing the

eigenvectors for a real or complex

squareMatrix, where each column in the

result corresponds to an eigenvalue. Note

that an eigenvector is not unique; it may be

scaled by any constant factor. The

eigenvectors are normalized, meaning that:

if V = [x

, x

, … , x

]

In Rectangular Complex Format:

eigVc()

Catalog >

then x

+x

+ … +x

= 1

squareMatrix is first balanced with

similarity transformations until the row and

column norms are as close to the same

value as possible. The squareMatrix is then

reduced to upper Hessenberg form and the

eigenvectors are computed via a Schur

factorization.

To see the entire result,

press 5 andthen use 7and8 to move the

cursor.

eigVl()

Catalog >

eigVl(squareMatrix) ⇒ list

Returns a list of the eigenvalues of a real or

complex squareMatrix.

squareMatrix is first balanced with

similarity transformations until the row and

column norms are as close to the same

value as possible. The squareMatrix is then

reduced to upper Hessenberg form and the

eigenvalues are computed from the upper

Hessenberg matrix.

In Rectangular complex format mode:

To see the entire result,

press 5 andthen use 7and8 to move the

cursor.

Else

See If, page 68.

ElseIf

Catalog >

If BooleanExpr1 Then

Block1

ElseIf BooleanExpr2 Then

Block2

⋮

ElseIf BooleanExprN Then

BlockN

EndIf

⋮

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

Alphabetical Listing 45

46 Alphabetical Listing

EndFor

See For, page 54.

EndFunc

See Func, page 57.

EndIf

See If, page 68.

EndLoop

See Loop, page 90.

EndPrgm

See Prgm, page 114.

EndTry

See Try, page 158.

EndWhile

See While, page 167.

euler ()

Catalog >

euler(Expr, Var, depVar, {Var0, VarMax},

depVar0, VarStep [, eulerStep]) ⇒ matrix

euler(SystemOfExpr, Var, ListOfDepVars,

{Var0, VarMax}, ListOfDepVars0,

VarStep [, eulerStep]) ⇒ matrix

euler(ListOfExpr, Var, ListOfDepVars,

{Var0, VarMax},ListOfDepVars0,

VarStep [, eulerStep]) ⇒ matrix

Differential equation:

y'=0.001*y*(100-y) andy(0)=10

To see the entire result,

press 5 andthen use 7and8 to move the

cursor.

euler ()

Catalog >

Uses the Euler method to solve the system

with depVar(Var0)=depVar0 on the

interval [Var0,VarMax]. Returns a matrix

whose first row defines the Var output

values and whose second row defines the

value of the first solution component at the

corresponding Var values, and so on.

Expr is the right-hand side that defines the

ordinary differential equation (ODE).

SystemOfExpr is the system of right-hand

sides that define the system of ODEs

(corresponds to order of dependent

variables in ListOfDepVars).

ListOfExpr is a list of right-hand sides that

define the system of ODEs (corresponds to

the order of dependent variables in

ListOfDepVars).

Var is the independent variable.

ListOfDepVars is a list of dependent

variables.

{Var0, VarMax} is a two-element list that

tells the function to integrate from Var0 to

VarMax.

ListOfDepVars0 is a list of initial values

for dependent variables.

VarStep is a nonzero number such that sign

(VarStep) = sign(VarMax-Var0) and

solutions are returned at Var0+i•VarStep

for all i=0,1,2,… such that Var0+i•VarStep

is in [var0,VarMax] (there may not be a

solution value at VarMax).

eulerStep is a positive integer (defaults to

1) that defines the number of euler steps

between output values. The actual step size

used by the euler method is

VarStep⁄ eulerStep.

System of equations:

withy1(0)=2 and y2(0)=5

Alphabetical Listing 47

48 Alphabetical Listing

eval () Hub Menu

eval(Expr) ⇒ string

eval() is valid only in the TI-Innovator™Hub

Command argument of programming

commands Get, GetStr, and Send. The

software evaluates expression Expr and

replaces the eval() statement with the

result as a character string.

The argument Expr must simplify to a real

number.

Set the blue element of the RGB LED to half

intensity.

Reset the blue element to OFF.

eval() argument must simplify to a real

number.

Program to fade-in the redelement

Execute the program.

Although eval() does not display its result,

you can view the resulting Hub command

string after executing the command by

inspecting any of the following special

variables.

iostr.SendAns

iostr.GetAns

iostr.GetStrAns

Note: See also Get(page 59), GetStr(page

66), and Send(page 135).

Exit

Catalog >

Exit

Function listing:

Exit

Catalog >

Exits the current For, While, or Loop block.

Exit is not allowed outside the three looping

structures (For, While, or Loop).

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

exp()

u key

exp(Value1) ⇒ value

Returns e raised to the Value1 power.

Note: See also e exponent template, page

You can enter a complex number in re

polar form. However, use this form in

Radian angle mode only; it causes a

Domain error in Degree or Gradian angle

mode.

exp(List1) ⇒ list

Returns e raised to the power of each

element in List1.

exp(squareMatrix1) ⇒ squareMatrix

Returns the matrix exponential of

squareMatrix1. This is not the same as

calculating e raised to the power of each

element. For information about the

calculation method, refer to cos().

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

Alphabetical Listing 49

50 Alphabetical Listing

expr()

Catalog >

expr(String) ⇒ expression

Returns the character string contained in

String as an expression and immediately

executes it.

ExpReg

Catalog >

ExpReg X, Y [, [Freq] [, Category,

Include]]

Computes the exponential regression y = a•

(b)

on lists X and Y with frequency Freq. A

summary of results is stored in the

stat.results variable. (See page 146.)

All the lists must have equal dimension

except for Include.

X and Y are lists of independent and

dependent variables.

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1. All elements must be

integers ≥ 0.

Category is a list of numeric or string

category codes for the corresponding X and

Y data.

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output

variable

Description

stat.RegEqn

Regression equation: a•(b)

stat.a, stat.b Regression coefficients

stat.r

Coefficientof linear determination for transformed data

Output

variable

Description

stat.r Correlation coefficient for transformed data (x, ln(y))

stat.Resid Residuals associated with the exponentialmodel

stat.ResidTrans Residuals associated with linear fit of transformeddata

stat.XReg

Listof data points in the modified X List actually used in the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.YReg

Listof data points in the modified Y List actually usedin the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.FreqReg

Listof frequencies corresponding to stat.XReg and stat.YReg

factor()

Catalog >

factor(rationalNumber) returns the rational

number factored into primes. For

composite numbers, the computing time

grows exponentially with the number of

digits in the second-largest factor. For

example, factoring a 30-digit integer could

take more than a day, and factoring a 100-

digit number could take more than a

century.

To stop a calculation manually,

• Handheld: Hold down the c key and

press · repeatedly.

• Windows®: Hold down the F12 key and

press Enter repeatedly.

• Macintosh®: Hold down the F5 key and

press Enter repeatedly.

• iPad®: The app displays a prompt. You

can continue waiting or cancel.

If you merely want to determine if a

number is prime, use isPrime() instead. It is

much faster, particularly if rationalNumber

is not prime and if the second-largest factor

has more than five digits.

Alphabetical Listing 51

52 Alphabetical Listing

FCdf()

Catalog >

FCdf

(lowBound,upBound,dfNumer,dfDenom) ⇒

number if lowBound and upBound are

numbers, list if lowBound and upBound are

lists

FCdf

(lowBound,upBound,dfNumer,dfDenom) ⇒

number if lowBound and upBound are

numbers, list if lowBound and upBound are

lists

Computes the F distribution probability

between lowBound and upBound for the

specified dfNumer (degrees of freedom) and

dfDenom.

For P(X ≤ upBound), set lowBound = 0.

Fill

Catalog >

Fill Value, matrixVar ⇒ matrix

Replaces each element in variable

matrixVar with Value.

matrixVar must already exist.

Fill Value, listVar ⇒ list

Replaces each element in variable listVar

with Value.

listVar must already exist.

FiveNumSummary

Catalog >

FiveNumSummary X[,[Freq]

[,Category,Include]]

Provides an abbreviated version of the 1-

variable statistics on list X. Asummary of

results is stored in the stat.results variable.

(See page 146.)

X represents a list containing the data.

FiveNumSummary

Catalog >

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1.

Category is a list of numeric category codes

for the corresponding X data.

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

An empty (void) element in any of the lists

X, Freq, or Category results in a void for

the corresponding element of all those lists.

For more information on empty elements,

see page 212.

Output variable Description

stat.MinX Minimum of x values.

stat.Q

X 1st Quartile of x.

stat.MedianX Median of x.

stat.Q

X 3rd Quartile of x.

stat.MaxX Maximum of x values.

floor()

Catalog >

floor(Value1) ⇒ integer

Returns the greatest integer that is ≤ the

argument. This function is identical to int().

The argument can be a real or a complex

number.

floor(List1) ⇒ list

floor(Matrix1) ⇒ matrix

Returns a list or matrix of the floor of each

element.

Note: See also ceiling() and int().

Alphabetical Listing 53

54 Alphabetical Listing

For

Catalog >

For Var, Low, High [, Step]

Block

EndFor

Executes the statements in Block

iteratively for each value of Var, from Low

to High, in increments of Step.

Var must not be a system variable.

Step can be positive or negative. The

default value is 1.

Block can be either a single statement or a

series of statements separated with the “:”

character.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

format()

Catalog >

format(Value[, formatString]) ⇒ string

Returns Value as a character string based

on the format template.

formatString is a string and must be in the

form: “F[n]”, “S[n]”, “E[n]”, “G[n][c]”,

where [] indicate optional portions.

F[n]: Fixed format. n is the number of digits

to display after the decimal point.

S[n]: Scientific format. n is the number of

digits to display after the decimal point.

E[n]: Engineering format. n is the number

of digits after the first significant digit. The

exponent is adjusted to a multiple of three,

and the decimal point is moved to the right

by zero, one, or two digits.

format()

Catalog >

G[n][c]: Same as fixed format but also

separates digits to the left of the radix into

groups of three. c specifies the group

separator character and defaults to a

comma. If c is a period, the radix will be

shown as a comma.

[Rc]: Any of the above specifiers may be

suffixed with the Rc radix flag, where c is a

single character that specifies what to

substitute for the radix point.

fPart()

Catalog >

fPart(Expr1) ⇒ expression

fPart(List1) ⇒ list

fPart(Matrix1) ⇒ matrix

Returns the fractional part of the argument.

For a list or matrix, returns the fractional

parts of the elements.

The argument can be a real or a complex

number.

FPdf()

Catalog >

FPdf(XVal,dfNumer,dfDenom) ⇒ number

if XVal is a number, list if XVal is a list

Computes the F distribution probability at

XVal for the specified dfNumer (degrees of

freedom) and dfDenom.

freqTable►list()

Catalog >

freqTable►list(List1,freqIntegerList) ⇒

list

Returns a list containing the elements from

List1 expanded according to the

frequencies in freqIntegerList. This

function can be used for building a

frequency table for the Data & Statistics

application.

List1 can be any valid list.

Alphabetical Listing 55

56 Alphabetical Listing

freqTable►list()

Catalog >

freqIntegerList must have the same

dimension as List1 and must contain non-

negative integer elements only. Each

element specifies the number of times the

corresponding List1 element will be

repeated in the result list. A value of zero

excludes the corresponding List1 element.

Note: You can insert this function from the

computer keyboard by typing

freqTable@>list(...).

Empty (void) elements are ignored. For

more information on empty elements, see

page 212.

frequency()

Catalog >

frequency(List1,binsList) ⇒ list

Returns a list containing counts of the

elements in List1. The counts are based on

ranges (bins) that you define in binsList.

If binsList is {b(1), b(2), …, b(n)}, the

specified ranges are {?≤b(1), b(1)<?≤b

(2),…,b(n-1)<?≤b(n), b(n)>?}. The resulting

list is one element longer than binsList.

Each element of the result corresponds to

the number of elements from List1 that

are in the range of that bin. Expressed in

terms of the countIf() function, the result is

{countIf(list, ?≤b(1)), countIf(list, b(1)<?≤b

(2)), …, countIf(list, b(n-1)<?≤b(n)), countIf

(list, b(n)>?)}.

Elements of List1 that cannot be “placed in

a bin” are ignored. Empty (void) elements

are also ignored. For more information on

empty elements, see page 212.

Within the Lists & Spreadsheet application,

you can use a range of cells in place of both

arguments.

Note: See also countIf(), page 29.

Explanation of result:

2 elements from Datalist are ≤2.5

4 elements from Datalist are >2.5 and ≤4.5

3 elements from Datalist are >4.5

The element “hello” is a string and cannot be

placed inany of the defined bins.

FTest_2Samp

Catalog >

FTest_2Samp List1,List2[,Freq1[,Freq2

[,Hypoth]]]

FTest_2Samp List1,List2[,Freq1[,Freq2

[,Hypoth]]]

(Data list input)

FTest_2Samp sx1,n1,sx2,n2[,Hypoth]

(Summary stats input)

Performs a two-sample Ftest. A summary

of results is stored in the stat.results

variable. (See page 146.)

For H

: σ1 > σ2, set Hypoth>0

For H

: σ1 ≠ σ2 (default), set Hypoth =0

For H

: σ1 < σ2, set Hypoth<0

For information on the effect of empty

elements in a list, see Empty (Void)

Elements, page 212.

Output variable Description

stat.F CalculatedF statistic for the data sequence

stat.PVal Smallest level of significance at which the null hypothesis canbe rejected

stat.dfNumer numerator degrees of freedom = n1-1

stat.dfDenom denominator degrees of freedom = n2-1

stat.sx1, stat.sx2

Sample standard deviations of the data sequences in List1 and List2

stat.x1_bar

stat.x2_bar

Sample means of the data sequences in List1 and List2

stat.n1, stat.n2 Size of the samples

Func

Catalog >

Func

Block

EndFunc

Template for creating a user-defined

function.

Define a piecewise function:

Alphabetical Listing 57

58 Alphabetical Listing

Func

Catalog >

Block can be a single statement, a series

of statements separated with the “:”

character, or a series of statements on

separate lines. The function can use the

Return instruction to return a specific result.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

Resultof graphing g(x)

gcd()

Catalog >

gcd(Number1, Number2) ⇒ expression

Returns the greatest common divisor of the

two arguments. The gcd of two fractions is

the gcd of their numerators divided by the

lcm of their denominators.

In Auto or Approximate mode, the gcd of

fractional floating-point numbers is 1.0.

gcd(List1, List2) ⇒ list

Returns the greatest common divisors of

the corresponding elements in List1 and

List2.

gcd(Matrix1, Matrix2) ⇒ matrix

Returns the greatest common divisors of

the corresponding elements in Matrix1and

Matrix2.

geomCdf()

Catalog >

geomCdf(p,lowBound,upBound) ⇒ number

geomCdf()

Catalog >

if lowBound and upBound are numbers, list

if lowBound and upBound are lists

geomCdf(p,upBound)for P(1≤X≤upBound)

⇒ number if upBound is a number, list if

upBound is a list

Computes a cumulative geometric

probability from lowBound to upBound with

the specified probability of success p.

For P(X ≤ upBound), set lowBound = 1.

geomPdf()

Catalog >

geomPdf(p,XVal) ⇒ number if XVal is a

number, list if XVal is a list

Computes a probability at XVal, the number

of the trial on which the first success occurs,

for the discrete geometric distribution with

the specified probability of success p.

Get Hub Menu

Get [promptString,] var[,statusVar]

Get [promptString,] func(arg1, ...argn)

[,statusVar]

Programming command: Retrieves a value

from a connected TI-Innovator™Hub and

assigns the value to variable var.

The value must be requested:

• In advance, through a Send"READ..."

command.

—or—

• By embedding a "READ..." request as

the optional promptString argument.

This method lets you use a single

command to request the value and

retrieve it.

Example: Request the currentvalue of the

hub's built-in light-level sensor. Use Get to

retrieve the value and assign it to variable

lightval.

Embed the READ request within the Get

command.

Alphabetical Listing 59

60 Alphabetical Listing

Get Hub Menu

Implicit simplification takes place. For

example, a received string of "123" is

interpreted as a numeric value. To preserve

the string, use GetStr instead of Get.

If you include the optional argument

statusVar, it is assigned a value based on

the success of the operation. A value of

zero means that no data was received.

In the second syntax, the func() argument

allows a program to store the received

string as a function definition. This syntax

operates as if the program executed the

command:

Define func(arg1, ...argn) = received

string

The program can then use the defined

function func().

Note: You can use the Get command within

a user-defined program but not within a

function.

Note: See also GetStr, page 66 and Send,

page 135.

getDenom()

Catalog >

getDenom(Fraction1) ⇒ value

Transforms the argument into an

expression having a reduced common

denominator, and then returns its

denominator.

getKey()

Catalog >

getKey([0|1]) ⇒ returnString

Description:getKey() - allows a TI-Basic

program to get keyboard input -

handheld, desktop and emulator on

desktop.

Example:

getKey()

Catalog >

Example:

• keypressed := getKey() will return a

key or an empty string if no key has

been pressed. This call will return

immediately.

• keypressed := getKey(1) will wait till

a key is pressed. This call will pause

execution of the program till a key is

pressed.

Handling of key presses:

Handheld Device/Emulator

Key

Desktop Return Value

Esc Esc "esc"

Touchpad - Top click n/a "up"

On n/a "home"

Scratchapps n/a "scratchpad"

Touchpad - Left click n/a "left"

Touchpad - Center click n/a "center"

Touchpad - Right click n/a "right"

Doc n/a "doc"

Tab Tab "tab"

Touchpad - Bottom click Down Arrow "down"

Menu n/a "menu"

Ctrl Ctrl no return

Shift Shift no return

Var n/a "var"

Del n/a "del"

= = "="

trig n/a "trig"

0 through 9 0-9 "0" ... "9"

Alphabetical Listing 61

62 Alphabetical Listing

Handheld Device/Emulator

Key

Desktop Return Value

Templates n/a "template"

Catalog n/a "cat"

^ ^ "^"

X^2 n/a "square"

/ (division key) / "/"

* (multiply key) * "*"

e^x n/a "exp"

10^x n/a "10power"

+ + "+"

- - "-"

( ( "("

) ) ")"

. . "."

(-) n/a "-" (negate sign)

Enter Enter "enter"

ee n/a "E" (scientific notation E)

a - z a-z alpha = letter pressed (lower

case)

("a" - "z")

shift a-z shift a-z alpha = letter pressed

"A" - "Z"

Note: ctrl-shift works to lock

caps

?! n/a "?!"

pi n/a "pi"

Flag n/a no return

, , ","

Return n/a "return"

Handheld Device/Emulator

Key

Desktop Return Value

Space Space " " (space)

Inaccessible Special Character Keys like

@,!,^, etc.

The character is returned

n/a Function Keys No returned character

n/a Special desktop control keys No returned character

Inaccessible Other desktop keys that are

not available on the

calculator while getkey() is

waiting for a keystroke. ({,

},;, :, ...)

Same character you get in

Notes (not in a math box)

Note: It is important to note that the presence of getKey() in a program changes how

certain events are handled by the system. Some of these are described below.

Terminate program and Handle event - Exactly as if the user were to break out of program

by pressing the ON key

"Support" below means - System works as expected - program continues to run.

Event Device Desktop - TI-Nspire™

Student Software

Quick Poll Terminate program,

handle event

Same as the handheld (TI-

Nspire™ Student Software,

TI-Nspire™ Navigator™ NC

Teacher Software-only)

Remote file mgmt

(Incl. sending 'Exit Press 2

Test' file from another

handheld or desktop-

handheld)

Terminate program,

handle event

Same as the handheld.

(TI-Nspire™ Student

Software, TI-Nspire™

Navigator™ NC Teacher

Software-only)

End Class Terminate program,

handle event

Support

(TI-Nspire™ Student

Software, TI-Nspire™

Navigator™ NC Teacher

Software-only)

Event Device Desktop - TI-Nspire™ All

Versions

TI-Innovator™ Hub

connect/disconnect

Support - Can successfully

issue commands to the TI-

Innovator™ Hub. After you

Same as the handheld

Alphabetical Listing 63

64 Alphabetical Listing

exit the program the TI-

Innovator™ Hub is still

working with the

handheld.

getLangInfo()

Catalog >

getLangInfo() ⇒ string

Returns a string that corresponds to the

short name of the currently active

language. You can, for example, use it in a

program or function to determine the

current language.

English = “en”

Danish = “da”

German = “de”

Finnish = “fi”

French = “fr”

Italian = “it”

Dutch = “nl”

Belgian Dutch = “nl_BE”

Norwegian = “no”

Portuguese = “pt”

Spanish = “es”

Swedish = “sv”

getLockInfo()

Catalog >

getLockInfo(Var) ⇒ value

Returns the current locked/unlocked state

of variable Var.

value =0: Var is unlocked or does not exist.

value =1: Var is locked and cannot be

modified or deleted.

See Lock, page 86, and unLock, page 164.

getMode()

Catalog >

getMode(ModeNameInteger) ⇒ value

getMode(0) ⇒ list

getMode(ModeNameInteger) returns a

value representing the current setting of

the ModeNameInteger mode.

getMode(0) returns a list containing

number pairs. Each pair consists of a mode

integer and a setting integer.

For a listing of the modes and their

settings, refer to the table below.

If you save the settings with getMode(0) →

var, you can use setMode(var) in a function

or program to temporarily restore the

settings within the execution of the

function or program only. See setMode(),

page 137.

Mode

Name

Mode

Integer Setting Integers

Display

Digits

1=Float, 2=Float1, 3=Float2, 4=Float3, 5=Float4, 6=Float5,

7=Float6, 8=Float7, 9=Float8, 10=Float9, 11=Float10,

12=Float11, 13=Float12, 14=Fix0, 15=Fix1, 16=Fix2,

17=Fix3, 18=Fix4, 19=Fix5, 20=Fix6, 21=Fix7, 22=Fix8,

23=Fix9, 24=Fix10, 25=Fix11, 26=Fix12

Angle

1=Radian, 2=Degree, 3=Gradian

Exponential

Format

1=Normal, 2=Scientific, 3=Engineering

Real or

Complex

1=Real, 2=Rectangular, 3=Polar

Auto or

Approx.

1=Auto, 2=Approximate

Vector

Format

1=Rectangular, 2=Cylindrical, 3=Spherical

Base

1=Decimal, 2=Hex, 3=Binary

Alphabetical Listing 65

66 Alphabetical Listing

getNum()

Catalog >

getNum(Fraction1) ⇒ value

Transforms the argument into an

expression having a reduced common

denominator, and then returns its

numerator.

GetStr Hub Menu

GetStr [promptString,] var[, statusVar]

GetStr [promptString,] func(arg1, ...argn)

[,statusVar]

Programming command: Operates

identically to the Get command, except that

the retrieved value is always interpreted as

a string. By contrast, the Get command

interprets the response as an expression

unless it is enclosed in quotation marks ("").

Note: See also Get, page 59 and Send, page

135.

For examples, see Get.

getType()

Catalog >

getType(var) ⇒ string

Returns a string that indicates the data type

of variable var.

If var has not been defined, returns the

string "NONE".

getVarInfo()

Catalog >

getVarInfo() ⇒ matrix or string

getVarInfo(LibNameString) ⇒ matrix or

string

getVarInfo() returns a matrix of information

(variable name, type, library accessibility,

and locked/unlocked state) for all variables

and library objects defined in the current

problem.

If no variables are defined, getVarInfo()

returns the string "NONE".

getVarInfo(LibNameString)returns a matrix

of information for all library objects defined

in library LibNameString. LibNameString

must be a string (text enclosed in quotation

marks) or a string variable.

If the library LibNameString does not exist,

an error occurs.

Note the example, in which the result of

getVarInfo() is assigned to variable vs.

Attempting to display row 2 or row 3 of vs

returns an “Invalid list or matrix” error

because at least one of elements in those

rows (variable b, for example) revaluates to

a matrix.

This error could also occur when using Ans

to reevaluate a getVarInfo() result.

The system gives the above error because

the current version of the software does not

support a generalized matrix structure

where an element of a matrix can be either

a matrix or a list.

Alphabetical Listing 67

68 Alphabetical Listing

Goto

Catalog >

Goto labelName

Transfers control to the label labelName.

labelName must be defined in the same

function using a Lbl instruction.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

►Grad

Catalog >

Expr1►Grad ⇒ expression

Converts Expr1 to gradian angle measure.

Note: You can insert this operator from the

computer keyboard by typing @>Grad.

In Degree angle mode:

In Radian angle mode:

identity()

Catalog >

identity(Integer) ⇒ matrix

Returns the identity matrix with a

dimension of Integer.

Integer must be a positive integer.

Catalog >

If BooleanExpr

Statement

If BooleanExpr Then

Block

EndIf

Catalog >

If BooleanExpr evaluates to true, executes

the single statement Statement or the block

of statements Block before continuing

execution.

If BooleanExpr evaluates to false,

continues execution without executing the

statement or block of statements.

Block can be either a single statement or a

sequence of statements separated with the

“:” character.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

If BooleanExpr Then

Block1

Else

Block2

EndIf

If BooleanExpr evaluates to true, executes

Block1 and then skips Block2.

If BooleanExpr evaluates to false, skips

Block1 but executes Block2.

Block1 and Block2 can be a single

statement.

If BooleanExpr1 Then

Block1

ElseIf BooleanExpr2 Then

Block2

⋮

ElseIf BooleanExprN Then

BlockN

EndIf

Allows for branching. If BooleanExpr1

evaluates to true, executes Block1. If

BooleanExpr1 evaluates to false, evaluates

BooleanExpr2, and so on.

Alphabetical Listing 69

70 Alphabetical Listing

ifFn()

Catalog >

ifFn(BooleanExpr,Value_If_true [,Value_

If_false [,Value_If_unknown]]) ⇒

expression, list, or matrix

Evaluates the boolean expression

BooleanExpr (or each element from

BooleanExpr ) and produces a result based

on the following rules:

• BooleanExpr can test a single value, a

list, or a matrix.

• If an element of BooleanExpr evaluates

to true, returns the corresponding

element from Value_If_true.

• If an element of BooleanExpr evaluates

to false, returns the corresponding

element from Value_If_false. If you

omit Value_If_false, returns undef.

• If an element of BooleanExpr is neither

true nor false, returns the corresponding

element Value_If_unknown. If you omit

Value_If_unknown, returns undef.

• If the second, third, or fourth argument

of the ifFn() function is a single

expression, the Boolean test is applied to

every position in BooleanExpr.

Note: If the simplified BooleanExpr

statement involves a list or matrix, all other

list or matrix arguments must have the

same dimension(s), and the result will have

the same dimension(s).

Test value of 1 is less than2.5, so its

corresponding

Value_If_True elementof 5 is copied to

the result list.

Test value of 2 is less than2.5, so its

corresponding

Value_If_True elementof 6 is copied to

the result list.

Test value of 3 is not less than2.5, so its

corresponding Value_If_False element of

10 is copied to the result list.

Value_If_true is a single value and

corresponds to any selected position.

Value_If_false is not specified. Undef is

used.

One element selected from Value_If_true.

One element selected from Value_If_

unknown.

imag()

Catalog >

imag(Value1) ⇒ value

Returns the imaginary part of the

argument.

imag()

Catalog >

imag(List1) ⇒ list

Returns a list of the imaginary parts of the

elements.

imag(Matrix1) ⇒ matrix

Returns a matrix of the imaginary parts of

the elements.

Indirection

See #(), page 189.

inString()

Catalog >

inString(srcString, subString[, Start]) ⇒

integer

Returns the character position in string

srcString at which the first occurrence of

string subString begins.

Start, if included, specifies the character

position within srcString where the search

begins. Default = 1 (the first character of

srcString).

If srcString does not contain subString or

Start is > the length of srcString, returns

zero.

int()

Catalog >

int(Value) ⇒ integer

int(List1) ⇒ list

int(Matrix1) ⇒ matrix

Returns the greatest integer that is less

than or equal to the argument. This

function is identical to floor().

The argument can be a real or a complex

number.

For a list or matrix, returns the greatest

integer of each of the elements.

Alphabetical Listing 71

72 Alphabetical Listing

intDiv()

Catalog >

intDiv(Number1, Number2) ⇒ integer

intDiv(List1, List2) ⇒ list

intDiv(Matrix1, Matrix2) ⇒ matrix

Returns the signed integer part of

(Number1 ÷ Number2).

For lists and matrices, returns the signed

integer part of (argument1÷argument2)

for each element pair.

interpolate ()

Catalog >

interpolate(xValue, xList, yList,

yPrimeList) ⇒ list

This function does the following:

Given xList, yList=f(xList), and

yPrimeList=f'(xList) for some unknown

function f, a cubic interpolant is used to

approximate the function f at xValue. It is

assumed that xList is a list of

monotonically increasing or decreasing

numbers, but this function may return a

value even when it is not. This function

walks through xList looking for an interval

[xList[i], xList[i+1]] that contains xValue.

If it finds such an interval, it returns an

interpolated value for f(xValue); otherwise,

it returns undef.

xList, yList, and yPrimeList must be of

equal dimension ≥ 2 and contain

expressions that simplify to numbers.

xValue can be a number or a list of

numbers.

Differential equation:

y'=-3•y+6•t+5 and y(0)=5

To see the entire result,

press 5 andthen use 7and8 to move the

cursor.

Use the interpolate() function to calculate the

function values for the xvaluelist:

invχ

()

Catalog >

invχ

(Area,df)

invChi2(Area,df)

Computes the Inverse cumulative χ

(chi-

square) probability function specified by

degree of freedom, df for a given Area

under the curve.

invF()

Catalog >

invF(Area,dfNumer,dfDenom)

computes the Inverse cumulative F

distribution function specified by dfNumer

and dfDenom for a given Area under the

curve.

invBinom()

Catalog >

invBinom

(CumulativeProb,NumTrials,Prob,

OutputForm)⇒ scalar or matrix

Inverse binomial. Given the number of trials

(NumTrials) and the probability of success

of each trial (Prob), this function returns

the minimum number of successes, k, such

that the value, k, is greater than or equal to

the given cumulative probability

(CumulativeProb).

OutputForm=0, displays result as a scalar

(default).

OutputForm=1, displays result as a matrix.

Example: Mary and Kevinare playing a dice

game. Mary has to guess the maximum

number of times 6 shows upin 30 rolls. If the

number 6 shows upthat many times or less,

Mary wins. Furthermore, the smaller the

number thatshe guesses, the greater her

winnings. Whatis the smallestnumber Mary

can guess if she wants the probability of

winning to be greater than 77%?

invBinomN()

Catalog >

invBinomN(CumulativeProb,Prob,

NumSuccess,OutputForm)⇒ scalar or

matrix

Inverse binomial with respect to N. Given

the probability of success of each trial

(Prob), and the number of successes

(NumSuccess), this function returns the

minimum number of trials, N, such that the

value, N, is less than or equal to the given

cumulative probability (CumulativeProb).

OutputForm=0, displays result as a scalar

(default).

OutputForm=1, displays result as a matrix.

Example: Monique is practicing goal shots

for netball. She knows from experience that

her chance of making any one shot is 70%.

She plans to practice until she scores 50

goals. How many shots must she attemptto

ensure thatthe probability of making at least

50 goals is more than 0.99?

Alphabetical Listing 73

74 Alphabetical Listing

invNorm()

Catalog >

invNorm(Area[,μ[,σ]])

Computes the inverse cumulative normal

distribution function for a given Area under

the normal distribution curve specified by μ

and σ.

invt()

Catalog >

invt(Area,df)

Computes the inverse cumulative student-t

probability function specified by degree of

freedom, df for a given Area under the

curve.

iPart()

Catalog >

iPart(Number) ⇒ integer

iPart(List1) ⇒ list

iPart(Matrix1) ⇒ matrix

Returns the integer part of the argument.

For lists and matrices, returns the integer

part of each element.

The argument can be a real or a complex

number.

irr()

Catalog >

irr(CF0,CFList [,CFFreq]) ⇒ value

Financial function that calculates internal

rate of return of an investment.

CF0 is the initial cash flow at time 0; it

must be a real number.

CFList is a list of cash flow amounts after

the initial cash flow CF0.

irr()

Catalog >

CFFreq is an optional list in which each

element specifies the frequency of

occurrence for a grouped (consecutive) cash

flow amount, which is the corresponding

element of CFList. The default is 1; if you

enter values, they must be positive integers

< 10,000.

Note: See also mirr(), page 95.

isPrime()

Catalog >

isPrime(Number) ⇒ Boolean constant

expression

Returns true or false to indicate if number

is a whole number ≥2 that is evenly

divisible only by itself and 1.

If Number exceeds about 306 digits and has

no factors ≤1021, isPrime(Number) displays

an error message.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

Function to findthe next prime after a

specified number:

isVoid()

Catalog >

isVoid(Var) ⇒ Boolean constant

expression

isVoid(Expr) ⇒ Boolean constant

expression

isVoid(List) ⇒ list of Boolean constant

expressions

Returns true or false to indicate if the

argument is a void data type.

For more information on void elements, see

page 212.

Alphabetical Listing 75

76 Alphabetical Listing

Lbl

Catalog >

Lbl labelName

Defines a label with the name labelName

within a function.

You can use a Goto labelName instruction

to transfer control to the instruction

immediately following the label.

labelName must meet the same naming

requirements as a variable name.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

lcm()

Catalog >

lcm(Number1, Number2) ⇒ expression

lcm(List1, List2) ⇒ list

lcm(Matrix1, Matrix2) ⇒ matrix

Returns the least common multiple of the

two arguments. The lcm of two fractions is

the lcm of their numerators divided by the

gcd of their denominators. The lcm of

fractional floating-point numbers is their

product.

For two lists or matrices, returns the least

common multiples of the corresponding

elements.

left()

Catalog >

left(sourceString[, Num]) ⇒ string

Returns the leftmost Num characters

contained in character string sourceString.

If you omit Num, returns all of

sourceString.

left(List1[, Num]) ⇒ list

left()

Catalog >

Returns the leftmost Num elements

contained in List1.

If you omit Num, returns all of List1.

left(Comparison) ⇒ expression

Returns the left-hand side of an equation or

inequality.

libShortcut()

Catalog >

libShortcut(LibNameString,

ShortcutNameString

[, LibPrivFlag]) ⇒ list of variables

Creates a variable group in the current

problem that contains references to all the

objects in the specified library document

libNameString. Also adds the group

members to the Variables menu. You can

then refer to each object using its

ShortcutNameString.

Set LibPrivFlag=0 to exclude private

library objects (default)

Set LibPrivFlag=1 to include private

library objects

To copy a variable group, see CopyVar on

page 24.

To delete a variable group, see DelVar on

page 38.

This example assumes a properly stored and

refreshed library document named linalg2

that contains objects defined as clearmat,

gauss1, and gauss2.

LinRegBx

Catalog >

LinRegBx X,Y[,[Freq][,Category,Include]]

Computes the linear regression y = a+b•x on

lists X and Y with frequency Freq. A

summary of results is stored in the

stat.results variable. (See page 146.)

All the lists must have equal dimension

except for Include.

X and Y are lists of independent and

dependent variables.

Alphabetical Listing 77

78 Alphabetical Listing

LinRegBx

Catalog >

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1. All elements must be

integers ≥ 0.

Category is a list of numeric or string

category codes for the corresponding X and

Y data.

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output

variable

Description

stat.RegEqn

Regression Equation: a+b•x

stat.a, stat.b Regression coefficients

stat.r

Coefficientof determination

stat.r Correlation coefficient

stat.Resid Residuals from the regression

stat.XReg

Listof data points in the modified X List actually used in the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.YReg

Listof data points in the modified Y List actually usedin the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.FreqReg

Listof frequencies corresponding to stat.XReg and stat.YReg

LinRegMx

Catalog >

LinRegMx X,Y[,[Freq][,Category,Include]]

Computes the linear regression y = m•x+b on

lists X and Y with frequency Freq. A

summary of results is stored in the

stat.results variable. (See page 146.)

All the lists must have equal dimension

except for Include.

LinRegMx

Catalog >

X and Y are lists of independent and

dependent variables.

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1. All elements must be

integers ≥ 0.

Category is a list of numeric or string

category codes for the corresponding X and

Y data.

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output

variable

Description

stat.RegEqn

Regression Equation: y = m•x+b

stat.m,

stat.b

Regression coefficients

stat.r

Coefficientof determination

stat.r Correlation coefficient

stat.Resid Residuals from the regression

stat.XReg

Listof data points in the modified X List actually used in the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.YReg

Listof data points in the modified Y List actually usedin the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.FreqReg

Listof frequencies corresponding to stat.XReg and stat.YReg

LinRegtIntervals

Catalog >

LinRegtIntervals X,Y[,F[,0[,CLev]]]

For Slope. Computes a level C confidence

interval for the slope.

Alphabetical Listing 79

80 Alphabetical Listing

LinRegtIntervals

Catalog >

LinRegtIntervals X,Y[,F[,1,Xval[,CLev]]]

For Response. Computes a predicted y-value,

a level C prediction interval for a single

observation, and a level C confidence

interval for the mean response.

A summary of results is stored in the

stat.results variable. (See page 146.)

All the lists must have equal dimension.

X and Y are lists of independent and

dependent variables.

F is an optional list of frequency values.

Each element in F specifies the frequency of

occurrence for each corresponding X and Y

data point. The default value is 1. All

elements must be integers ≥ 0.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.RegEqn

Regression Equation: a+b•x

stat.a, stat.b Regression coefficients

stat.df Degrees of freedom

stat.r

Coefficientof determination

stat.r Correlation coefficient

stat.Resid Residuals from the regression

For Slope type only

Output variable Description

[stat.CLower, stat.CUpper] Confidence interval for the slope

stat.ME Confidence interval margin of error

stat.SESlope Standard error of slope

stat.s Standard error aboutthe line

For Response type only

Output variable Description

[stat.CLower, stat.CUpper] Confidence interval for the mean response

stat.ME Confidence interval margin of error

stat.SE Standard error of meanresponse

[stat.LowerPred,

stat.UpperPred]

Prediction interval for a single observation

stat.MEPred Prediction interval margin of error

stat.SEPred Standard error for prediction

stat.y

a + b•XVal

LinRegtTest

Catalog >

LinRegtTest X,Y[,Freq[,Hypoth]]

Computes a linear regression on the X and Y

lists and a t test on the value of slope β and

the correlation coefficient ρ for the equation

y=α+βx. It tests the null hypothesis H

:β=0

(equivalently, ρ=0) against one of three

alternative hypotheses.

All the lists must have equal dimension.

X and Y are lists of independent and

dependent variables.

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1. All elements must be

integers ≥ 0.

Hypoth is an optional value specifying one

of three alternative hypotheses against

which the null hypothesis (H

:β=ρ=0) will be

tested.

For H

: β≠0 and ρ≠0 (default), set Hypoth=0

For H

: β<0 and ρ<0, set Hypoth<0

For H

: β>0 and ρ>0, set Hypoth>0

A summary of results is stored in the

stat.results variable. (See page 146.)

Alphabetical Listing 81

82 Alphabetical Listing

LinRegtTest

Catalog >

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.RegEqn

Regression equation: a + b•x

stat.t

t-Statistic for significance test

stat.PVal Smallest level of significance at which the null hypothesis canbe rejected

stat.df Degrees of freedom

stat.a, stat.b Regression coefficients

stat.s Standard error aboutthe line

stat.SESlope Standard error of slope

stat.r

Coefficientof determination

stat.r Correlation coefficient

stat.Resid Residuals from the regression

linSolve()

Catalog >

linSolve(SystemOfLinearEqns, Var1,

Var2, ...) ⇒ list

linSolve(LinearEqn1 and LinearEqn2 and

..., Var1, Var2, ...) ⇒ list

linSolve({LinearEqn1, LinearEqn2, ...},

Var1, Var2, ...) ⇒ list

linSolve(SystemOfLinearEqns, {Var1,

Var2, ...}) ⇒ list

linSolve(LinearEqn1 and LinearEqn2 and

..., {Var1, Var2, ...}) ⇒ list

linSolve({LinearEqn1, LinearEgn2, ...},

{Var1, Var2, ...}) ⇒ list

Returns a list of solutions for the variables

Var1, Var2, ...

linSolve()

Catalog >

The first argument must evaluate to a

system of linear equations or a single linear

equation. Otherwise, an argument error

occurs.

For example, evaluating linSolve(x=1

and x=2,x) produces an “Argument

Error” result.

ΔList()

Catalog >

ΔList(List1) ⇒ list

Note: You can insert this function from the

keyboard by typing deltaList(...).

Returns a list containing the differences

between consecutive elements in List1.

Each element of List1 is subtracted from

the next element of List1. The resulting list

is always one element shorter than the

original List1.

list►mat()

Catalog >

list►mat(List [, elementsPerRow]) ⇒

matrix

Returns a matrix filled row-by-row with the

elements from List.

elementsPerRow, if included, specifies the

number of elements per row. Default is the

number of elements in List (one row).

If List does not fill the resulting matrix,

zeros are added.

Note: You can insert this function from the

computer keyboard by typing list@>mat

(...).

ln()

/u keys

ln(Value1) ⇒ value

ln(List1) ⇒ list

Alphabetical Listing 83

84 Alphabetical Listing

ln()

/u keys

Returns the natural logarithm of the

argument.

For a list, returns the natural logarithms of

the elements.

If complex format mode is Real:

If complex format mode is Rectangular:

ln(squareMatrix1) ⇒ squareMatrix

Returns the matrix natural logarithm of

squareMatrix1. This is not the same as

calculating the natural logarithm of each

element. For information about the

calculation method, refer to cos() on.

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

In Radian angle mode and Rectangular

complex format:

To see the entire result,

press 5 andthen use 7and8 to move the

cursor.

LnReg

Catalog >

LnReg X, Y[, [Freq] [, Category, Include]]

Computes the logarithmic regression y =

a+b•ln(x) on lists X and Y with frequency

Freq. A summary of results is stored in the

stat.results variable. (See page 146.)

All the lists must have equal dimension

except for Include.

X and Y are lists of independent and

dependent variables.

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1. All elements must be

integers ≥ 0.

LnReg

Catalog >

Category is a list of numeric or string

category codes for the corresponding X and

Y data.

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output

variable

Description

stat.RegEqn

Regression equation: a+b•ln(x)

stat.a, stat.b Regression coefficients

stat.r

Coefficientof linear determination for transformed data

stat.r Correlation coefficient for transformed data (ln(x), y)

stat.Resid Residuals associated with the logarithmic model

stat.ResidTrans Residuals associated with linear fit of transformeddata

stat.XReg

Listof data points in the modified X List actually used in the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.YReg

Listof data points in the modified Y List actually usedin the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.FreqReg

Listof frequencies corresponding to stat.XReg and stat.YReg

Alphabetical Listing 85

86 Alphabetical Listing

Local

Catalog >

Local Var1[, Var2] [, Var3] ...

Declares the specified vars as local

variables. Those variables exist only during

evaluation of a function and are deleted

when the function finishes execution.

Note: Local variables save memory because

they only exist temporarily. Also, they do

not disturb any existing global variable

values. Local variables must be used for For

loops and for temporarily saving values in a

multi-line function since modifications on

global variables are not allowed in a

function.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

Lock

Catalog >

LockVar1[, Var2] [, Var3] ...

LockVar.

Locks the specified variables or variable

group. Locked variables cannot be modified

or deleted.

You cannot lock or unlock the system

variable Ans, and you cannot lock the

system variable groups stat. or tvm.

Note: The Lock command clears the

Undo/Redo history when applied to

unlocked variables.

See unLock, page 164, and getLockInfo(),

page 64.

log()

/s keys

log(Value1[,Value2]) ⇒ value

log(List1[,Value2]) ⇒ list

Returns the base-Value2 logarithm of the

first argument.

Note: See also Log template, page 2.

For a list, returns the base-Value2

logarithm of the elements.

If the second argument is omitted, 10 is

used as the base.

If complex format mode is Real:

If complex format mode is Rectangular:

log(squareMatrix1[,Value]) ⇒

squareMatrix

Returns the matrix base-Value logarithm of

squareMatrix1. This is not the same as

calculating the base-Value logarithm of

each element. For information about the

calculation method, refer to cos().

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

If the base argument is omitted, 10 is used

as base.

In Radian angle mode and Rectangular

complex format:

To see the entire result,

press 5 andthen use 7and8 to move the

cursor.

Logistic

Catalog >

Logistic X, Y[, [Freq] [, Category, Include]]

Computes the logistic regression y = (c/

(1+a•e

-bx

)) on lists X and Y with frequency

Freq. A summary of results is stored in the

stat.results variable. (See page 146.)

All the lists must have equal dimension

except for Include.

Alphabetical Listing 87

88 Alphabetical Listing

Logistic

Catalog >

X and Y are lists of independent and

dependent variables.

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1. All elements must be

integers ≥ 0.

Category is a list of numeric or string

category codes for the corresponding X and

Y data.

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output

variable

Description

stat.RegEqn

Regression equation: c/(1+a•e

-bx

)

stat.a,

stat.b, stat.c

Regression coefficients

stat.Resid Residuals from the regression

stat.XReg

Listof data points in the modified X List actually used in the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.YReg

Listof data points in the modified Y List actually usedin the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.FreqReg

Listof frequencies corresponding to stat.XReg and stat.YReg

LogisticD

Catalog >

LogisticD X, Y [, [Iterations] , [Freq] [,

Category, Include] ]

Computes the logistic regression y = (c/

(1+a•e

-bx

)+d) on lists X and Y with frequency

Freq, using a specified number of

Iterations. A summary of results is stored in

the stat.results variable. (See page 146.)

LogisticD

Catalog >

All the lists must have equal dimension

except for Include.

X and Y are lists of independent and

dependent variables.

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1. All elements must be

integers ≥ 0.

Category is a list of numeric or string

category codes for the corresponding X and

Y data.

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output

variable

Description

stat.RegEqn

Regression equation: c/(1+a•e

-bx

)+d)

stat.a, stat.b,

stat.c, stat.d

Regression coefficients

stat.Resid Residuals from the regression

stat.XReg

Listof data points in the modified X List actually used in the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.YReg

Listof data points in the modified Y List actually usedin the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.FreqReg

Listof frequencies corresponding to stat.XReg and stat.YReg

Alphabetical Listing 89

90 Alphabetical Listing

Loop

Catalog >

Loop

Block

EndLoop

Repeatedly executes the statements in

Block. Note that the loop will be executed

endlessly, unless a Goto or Exit instruction

is executed within Block.

Block is a sequence of statements

separated with the “:” character.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

Catalog >

LU Matrix, lMatrix, uMatrix, pMatrix

[,Tol]

Calculates the Doolittle LU (lower-upper)

decomposition of a real or complex matrix.

The lower triangular matrix is stored in

lMatrix, the upper triangular matrix in

uMatrix, and the permutation matrix

(which describes the row swaps done

during the calculation) in pMatrix.

lMatrix•uMatrix = pMatrix•matrix

Optionally, any matrix element is treated as

zero if its absolute value is less than Tol.

This tolerance is used only if the matrix has

floating-point entries and does not contain

any symbolic variables that have not been

assigned a value. Otherwise, Tol is ignored.

• If you use /· or set the Auto or

Approximate mode to Approximate,

computations are done using floating-

point arithmetic.

• If Tol is omitted or not used, the default

tolerance is calculated as:

5E⁻14•max(dim(Matrix))•rowNorm

(Matrix)

Catalog >

The LU factorization algorithm uses partial

pivoting with row interchanges.

mat►list()

Catalog >

mat►list(Matrix) ⇒ list

Returns a list filled with the elements in

Matrix. The elements are copied from

Matrix row by row.

Note: You can insert this function from the

computer keyboard by typing mat@>list

(...).

max()

Catalog >

max(Value1, Value2) ⇒ expression

max(List1, List2) ⇒ list

max(Matrix1, Matrix2) ⇒ matrix

Returns the maximum of the two

arguments. If the arguments are two lists

or matrices, returns a list or matrix

containing the maximum value of each pair

of corresponding elements.

max(List) ⇒ expression

Returns the maximum element in list.

max(Matrix1) ⇒ matrix

Returns a row vector containing the

maximum element of each column in

Matrix1.

Empty (void) elements are ignored. For

more information on empty elements, see

page 212.

Note: See also min().

Alphabetical Listing 91

92 Alphabetical Listing

mean()

Catalog >

mean(List[, freqList]) ⇒ expression

Returns the mean of the elements in List.

Each freqList element counts the number

of consecutive occurrences of the

corresponding element in List.

mean(Matrix1[, freqMatrix]) ⇒ matrix

Returns a row vector of the means of all

the columns in Matrix1.

Each freqMatrix element counts the

number of consecutive occurrences of the

corresponding element in Matrix1.

Empty (void) elements are ignored. For

more information on empty elements, see

page 212.

In Rectangular vector format:

median()

Catalog >

median(List[, freqList]) ⇒ expression

Returns the median of the elements in List.

Each freqList element counts the number

of consecutive occurrences of the

corresponding element in List.

median(Matrix1[, freqMatrix]) ⇒ matrix

Returns a row vector containing the

medians of the columns in Matrix1.

Each freqMatrix element counts the

number of consecutive occurrences of the

corresponding element in Matrix1.

Notes:

• All entries in the list or matrix must

simplify to numbers.

• Empty (void) elements in the list or

matrix are ignored. For more information

on empty elements, see page 212.

MedMed

Catalog >

MedMed X,Y [, Freq] [, Category, Include]]

Computes the median-median line y =

(m•x+b) on lists X and Y with frequency

Freq. A summary of results is stored in the

stat.results variable. (See page 146.)

All the lists must have equal dimension

except for Include.

X and Y are lists of independent and

dependent variables.

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1. All elements must be

integers ≥ 0.

Category is a list of numeric or string

category codes for the corresponding X and

Y data.

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output

variable

Description

stat.RegEqn

Median-median line equation: m•x+b

stat.m,

stat.b

Model coefficients

stat.Resid Residuals from the median-median line

stat.XReg

Listof data points in the modified X List actually used in the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.YReg

Listof data points in the modified Y List actually usedin the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.FreqReg

Listof frequencies corresponding to stat.XReg and stat.YReg

Alphabetical Listing 93

94 Alphabetical Listing

mid()

Catalog >

mid(sourceString, Start[, Count]) ⇒

string

Returns Count characters from character

string sourceString, beginning with

character number Start.

If Count is omitted or is greater than the

dimension of sourceString, returns all

characters from sourceString, beginning

with character number Start.

Count must be ≥ 0. If Count = 0, returns an

empty string.

mid(sourceList, Start [, Count]) ⇒ list

Returns Count elements from sourceList,

beginning with element number Start.

If Count is omitted or is greater than the

dimension of sourceList, returns all

elements from sourceList, beginning with

element number Start.

Count must be ≥ 0. If Count = 0, returns an

empty list.

mid(sourceStringList, Start[, Count]) ⇒

list

Returns Count strings from the list of

strings sourceStringList, beginning with

element number Start.

min()

Catalog >

min(Value1, Value2) ⇒ expression

min(List1, List2) ⇒ list

min(Matrix1, Matrix2) ⇒ matrix

Returns the minimum of the two

arguments. If the arguments are two lists

or matrices, returns a list or matrix

containing the minimum value of each pair

of corresponding elements.

min(List) ⇒ expression

Returns the minimum element of List.

min()

Catalog >

min(Matrix1) ⇒ matrix

Returns a row vector containing the

minimum element of each column in

Matrix1.

Note: See also max().

mirr()

Catalog >

mirr

(financeRate,reinvestRate,CF0,CFList

[,CFFreq])

Financial function that returns the modified

internal rate of return of an investment.

financeRate is the interest rate that you

pay on the cash flow amounts.

reinvestRate is the interest rate at which

the cash flows are reinvested.

CF0 is the initial cash flow at time 0; it

must be a real number.

CFList is a list of cash flow amounts after

the initial cash flow CF0.

CFFreq is an optional list in which each

element specifies the frequency of

occurrence for a grouped (consecutive) cash

flow amount, which is the corresponding

element of CFList. The default is 1; if you

enter values, they must be positive integers

< 10,000.

Note: See also irr(), page 74.

mod()

Catalog >

mod(Value1, Value2) ⇒ expression

mod(List1, List2) ⇒ list

mod(Matrix1, Matrix2) ⇒ matrix

Returns the first argument modulo the

second argument as defined by the

identities:

Alphabetical Listing 95

96 Alphabetical Listing

mod()

Catalog >

mod(x,0) = x

mod(x,y) = x − y floor(x/y)

When the second argument is non-zero, the

result is periodic in that argument. The

result is either zero or has the same sign as

the second argument.

If the arguments are two lists or two

matrices, returns a list or matrix containing

the modulo of each pair of corresponding

elements.

Note: See also remain(), page 126

mRow()

Catalog >

mRow(Value, Matrix1, Index) ⇒ matrix

Returns a copy of Matrix1 with each

element in row Index of Matrix1 multiplied

by Value.

mRowAdd()

Catalog >

mRowAdd(Value, Matrix1, Index1, Index2)

⇒ matrix

Returns a copy of Matrix1 with each

element in row Index2 of Matrix1 replaced

with:

Value • row Index1 + row Index2

MultReg

Catalog >

MultReg Y, X1[,X2[,X3,…[,X10]]]

Calculates multiple linear regression of list Y

on lists X1, X2, …, X10. A summary of

results is stored in the stat.results variable.

(See page 146.)

All the lists must have equal dimension.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.RegEqn

Regression Equation: b0+b1•x1+b2•x2+ ...

stat.b0, stat.b1, ... Regression coefficients

stat.R

Coefficientof multiple determination

stat.yList yList= b0+b1•x1+ ...

stat.Resid Residuals from the regression

MultRegIntervals

Catalog >

MultRegIntervals Y, X1[, X2[, X3,…[,

X10]]], XValList[, CLevel]

Computes a predicted y-value, a level C

prediction interval for a single observation,

and a level C confidence interval for the

mean response.

A summary of results is stored in the

stat.results variable. (See page 146.)

All the lists must have equal dimension.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.RegEqn

Regression Equation: b0+b1•x1+b2•x2+ ...

stat.y A point estimate: y = b0 + b1 • xl + ... for XValList

stat.dfError Error degrees of freedom

stat.CLower, stat.CUpper Confidence interval for a meanresponse

stat.ME Confidence interval margin of error

stat.SE Standard error of meanresponse

stat.LowerPred,

stat.UpperrPred

Prediction interval for a single observation

stat.MEPred Prediction interval margin of error

stat.SEPred Standard error for prediction

stat.bList Listof regression coefficients, {b0,b1,b2,...}

stat.Resid Residuals from the regression

Alphabetical Listing 97

98 Alphabetical Listing

MultRegTests

Catalog >

MultRegTests Y, X1[, X2[, X3,…[, X10]]]

Multiple linear regression test computes a

multiple linear regression on the given data

and provides the global F test statistic and t

test statistics for the coefficients.

A summary of results is stored in the

stat.results variable. (See page 146.)

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Outputs

Output

variable

Description

stat.RegEqn

Regression Equation: b0+b1•x1+b2•x2+ ...

stat.F

Global F test statistic

stat.PVal

P-value associated with global F statistic

stat.R

Coefficientof multiple determination

stat.AdjR

Adjusted coefficient of multiple determination

stat.s Standard deviation of the error

stat.DW Durbin-Watson statistic; usedto determine whether first-order auto correlation is

present inthe model

stat.dfReg Regression degrees of freedom

stat.SSReg Regression sum of squares

stat.MSReg Regression mean square

stat.dfError Error degrees of freedom

stat.SSError Error sum of squares

stat.MSError Error mean square

stat.bList {b0,b1,...} List of coefficients

stat.tList Listof t statistics, one for each coefficient in the bList

stat.PList ListP-values for each t statistic

stat.SEList List of standard errors for coefficients in bList

stat.yList yList= b0+b1•x1+...

Output

variable

Description

stat.Resid Residuals from the regression

stat.sResid Standardized residuals; obtained by dividing a residual by its standard deviation

stat.CookDist Cook’s distance; measure of the influence of an observation based on the residual

and leverage

stat.Leverage Measure of how far the values of the independent variable are from their mean

values

nand

/= keys

BooleanExpr1 nand BooleanExpr2 returns

Boolean expression

BooleanList1 nand BooleanList2 returns

Boolean list

BooleanMatrix1 nand BooleanMatrix2

returns Boolean matrix

Returns the negation of a logical and

operation on the two arguments. Returns

true, false, or a simplified form of the

equation.

For lists and matrices, returns comparisons

element by element.

Integer1 nand Integer2 ⇒ integer

Compares two real integers bit-by-bit using

a nand operation. Internally, both integers

are converted to signed, 64-bit binary

numbers. When corresponding bits are

compared, the result is 0 if both bits are 1;

otherwise, the result is 1. The returned

value represents the bit results, and is

displayed according to the Base mode.

You can enter the integers in any number

base. For a binary or hexadecimal entry, you

must use the 0b or 0h prefix, respectively.

Without a prefix, integers are treated as

decimal (base10).

Alphabetical Listing 99

100 Alphabetical Listing

nCr()

Catalog >

nCr(Value1, Value2) ⇒ expression

For integer Value1 and Value2 with

Value1 ≥ Value2≥ 0, nCr() is the number of

combinations of Value1 things taken

Value2 at a time. (This is also known as a

binomial coefficient.)

nCr(Value, 0) ⇒ 1

nCr(Value, negInteger) ⇒ 0

nCr(Value, posInteger) ⇒ Value•

(Value−1) ... (Value−posInteger+1)/

posInteger!

nCr(Value, nonInteger) ⇒ expression! /

((Value−nonInteger)!•nonInteger!)

nCr(List1, List2) ⇒ list

Returns a list of combinations based on the

corresponding element pairs in the two

lists. The arguments must be the same size

list.

nCr(Matrix1, Matrix2) ⇒ matrix

Returns a matrix of combinations based on

the corresponding element pairs in the two

matrices. The arguments must be the same

size matrix.

nDerivative()

Catalog >

nDerivative(Expr1,Var=Value[,Order])

⇒ value

nDerivative(Expr1,Var[,Order])

|Var=Value ⇒ value

Returns the numerical derivative calculated

using auto differentiation methods.

When Value is specified, it overrides any

prior variable assignment or any current “|”

substitution for the variable.

If the variable Var does not contain a

numeric value, you must provide Value.

Order of the derivative must be 1 or 2.

nDerivative()

Catalog >

Note: The nDerivative() algorithm has a

limitiation: it works recursively through the

unsimplified expression, computing the

numeric value of the first derivative (and

second, if applicable) and the evaluation of

each subexpression, which may lead to an

unexpected result.

Consider the example on the right. The first

derivative of x•(x^2+x)^(1/3) at x=0 is equal

to 0. However, because the first derivative

of the subexpression (x^2+x)^(1/3) is

undefined at x=0, and this value is used to

calculate the derivative of the total

expression, nDerivative() reports the result

as undefined and displays a warning

message.

If you encounter this limitation, verify the

solution graphically. You can also try using

centralDiff().

newList()

Catalog >

newList(numElements) ⇒ list

Returns a list with a dimension of

numElements. Each element is zero.

newMat()

Catalog >

newMat(numRows, numColumns) ⇒

matrix

Returns a matrix of zeros with the

dimension numRows by numColumns.

nfMax()

Catalog >

nfMax(Expr, Var) ⇒ value

nfMax(Expr, Var, lowBound) ⇒ value

nfMax(Expr, Var, lowBound, upBound) ⇒

value

nfMax(Expr, Var) |

lowBound≤Var≤upBound ⇒ value

Alphabetical Listing 101

102 Alphabetical Listing

nfMax()

Catalog >

Returns a candidate numerical value of

variable Var where the local maximum of

Expr occurs.

If you supply lowBound and upBound, the

function looks in the closed interval

[lowBound,upBound] for the local

maximum.

nfMin()

Catalog >

nfMin(Expr, Var) ⇒ value

nfMin(Expr, Var, lowBound) ⇒ value

nfMin(Expr, Var, lowBound, upBound) ⇒

value

nfMin(Expr, Var) |

lowBound≤Var≤upBound ⇒ value

Returns a candidate numerical value of

variable Var where the local minimum of

Expr occurs.

If you supply lowBound and upBound, the

function looks in the closed interval

[lowBound,upBound] for the local

minimum.

nInt()

Catalog >

nInt(Expr1, Var, Lower, Upper) ⇒

expression

If the integrand Expr1 contains no variable

other than Var, and if Lower and Upper

are constants, positive ∞, or negative ∞,

then nInt() returns an approximation of ∫

(Expr1, Var, Lower, Upper). This

approximation is a weighted average of

some sample values of the integrand in the

interval Lower<Var<Upper.

The goal is six significant digits. The

adaptive algorithm terminates when it

seems likely that the goal has been

achieved, or when it seems unlikely that

additional samples will yield a worthwhile

improvement.

nInt()

Catalog >

A warning is displayed (“Questionable

accuracy”) when it seems that the goal has

not been achieved.

Nest nInt() to do multiple numeric

integration. Integration limits can depend

on integration variables outside them.

nom()

Catalog >

nom(effectiveRate,CpY) ⇒ value

Financial function that converts the annual

effective interest rate effectiveRate to a

nominal rate, given CpY as the number of

compounding periods per year.

effectiveRate must be a real number, and

CpY must be a real number > 0.

Note: See also eff(), page 44.

nor

/= keys

BooleanExpr1 nor BooleanExpr2 returns

Boolean expression

BooleanList1 nor BooleanList2 returns

Boolean list

BooleanMatrix1 nor BooleanMatrix2

returns Boolean matrix

Returns the negation of a logical or

operation on the two arguments. Returns

true, false, or a simplified form of the

equation.

For lists and matrices, returns comparisons

element by element.

Integer1 nor Integer2 ⇒ integer

Compares two real integers bit-by-bit using

a nor operation. Internally, both integers

are converted to signed, 64-bit binary

numbers. When corresponding bits are

compared, the result is 1 if both bits are 1;

otherwise, the result is 0. The returned

value represents the bit results, and is

displayed according to the Base mode.

Alphabetical Listing 103

104 Alphabetical Listing

nor

/= keys

You can enter the integers in any number

base. For a binary or hexadecimal entry, you

must use the 0b or 0h prefix, respectively.

Without a prefix, integers are treated as

decimal (base10).

norm()

Catalog >

norm(Matrix) ⇒ expression

norm(Vector) ⇒ expression

Returns the Frobenius norm.

normCdf()

Catalog >

normCdf(lowBound,upBound[,μ[,σ]]) ⇒

number if lowBound and upBound are

numbers, list if lowBound and upBound are

lists

Computes the normal distribution probability

between lowBound and upBound for the

specified μ (default=0) and σ (default=1).

For P(X ≤ upBound), set lowBound = ⁻9E999.

normPdf()

Catalog >

normPdf(XVal[,μ[,σ]]) ⇒ number if XVal is

a number, list if XVal is a list

Computes the probability density function

for the normal distribution at a specified

XVal value for the specified μ and σ.

not

Catalog >

not BooleanExpr ⇒ Boolean expression

Returns true, false, or a simplified form of

the argument.

not Integer1 ⇒ integer

In Hex base mode:

not

Catalog >

Returns the one’s complement of a real

integer. Internally, Integer1 is converted to

a signed, 64-bit binary number. The value of

each bit is flipped (0 becomes 1, and vice

versa) for the one’s complement. Results

are displayed according to the Base mode.

You can enter the integer in any number

base. For a binary or hexadecimal entry, you

must use the 0b or 0h prefix, respectively.

Without a prefix, the integer is treated as

decimal (base10).

If you enter a decimal integer that is too

large for a signed, 64-bit binary form, a

symmetric modulo operation is used to

bring the value into the appropriate range.

For more information, see ►Base2, page

16.

Important: Zero, not the letter O.

In Bin base mode:

To see the entire result,

press 5 andthen use 7and8 to move the

cursor.

Note: A binary entry can have upto 64 digits

(not counting the 0bprefix). A hexadecimal

entry canhave up to 16 digits.

nPr()

Catalog >

nPr(Value1, Value2) ⇒ expression

For integer Value1 and Value2 with

Value1 ≥ Value2 ≥ 0, nPr() is the number

of permutations of Value1 things taken

Value2 at a time.

nPr(Value, 0) ⇒ 1

nPr(Value, negInteger) ⇒ 1 / ((Value+1)•

(Value+2)...(Value−negInteger))

nPr(Value, posInteger) ⇒ Value•

(Value−1) ... (Value−posInteger+1)

nPr(Value, nonInteger) ⇒ Value! /

(Value−nonInteger)!

nPr(List1, List2) ⇒ list

Returns a list of permutations based on the

corresponding element pairs in the two

lists. The arguments must be the same size

list.

nPr(Matrix1, Matrix2) ⇒ matrix

Alphabetical Listing 105

106 Alphabetical Listing

nPr()

Catalog >

Returns a matrix of permutations based on

the corresponding element pairs in the two

matrices. The arguments must be the same

size matrix.

npv()

Catalog >

npv(InterestRate,CFO,CFList[,CFFreq])

Financial function that calculates net

present value; the sum of the present

values for the cash inflows and outflows. A

positive result for npv indicates a profitable

investment.

InterestRate is the rate by which to

discount the cash flows (the cost of money)

over one period.

CF0 is the initial cash flow at time 0; it

must be a real number.

CFList is a list of cash flow amounts after

the initial cash flow CF0.

CFFreq is a list in which each element

specifies the frequency of occurrence for a

grouped (consecutive) cash flow amount,

which is the corresponding element of

CFList. The default is 1; if you enter

values, they must be positive integers <

10,000.

nSolve()

Catalog >

nSolve(Equation,Var[=Guess]) ⇒ number

or error_string

nSolve(Equation,Var[=Guess],lowBound)

⇒ number or error_string

nSolve(Equation,Var

[=Guess],lowBound,upBound) ⇒ number

or error_string

nSolve(Equation,Var[=Guess]) |

lowBound≤Var≤upBound ⇒ number or

error_string

Note: If there are multiple solutions, you can

use a guess to help find a particular solution.

nSolve()

Catalog >

Iteratively searches for one approximate

real numeric solution to Equation for its

one variable. Specify the variable as:

variable

– or –

variable = real number

For example, x is valid and so is x=3.

nSolve() attempts to determine either one

point where the residual is zero or two

relatively close points where the residual

has opposite signs and the magnitude of

the residual is not excessive. If it cannot

achieve this using a modest number of

sample points, it returns the string “no

solution found.”

OneVar

Catalog >

OneVar [1,]X[,[Freq][,Category,Include]]

OneVar [n,]X1,X2[X3[,…[,X20]]]

Calculates 1-variable statistics on up to 20

lists. A summary of results is stored in the

stat.results variable. (See page 146.)

All the lists must have equal dimension

except for Include.

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1. All elements must be

integers ≥ 0.

Category is a list of numeric category codes

for the corresponding X values.

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

Alphabetical Listing 107

108 Alphabetical Listing

OneVar

Catalog >

An empty (void) element in any of the lists

X, Freq, or Category results in a void for

the corresponding element of all those lists.

An empty element in any of the lists X1

through X20 results in a void for the

corresponding element of all those lists. For

more information on empty elements, see

page 212.

Output variable Description

stat.v Mean of x values

stat.Σx

Sum of x values

stat.Σx

Sum of x

values

stat.sx Sample standard deviation of x

stat.σx

Population standard deviation of x

stat.n Number of data points

stat.MinX Minimum of x values

stat.Q

X 1st Quartile of x

stat.MedianX Median of x

stat.Q

X 3rd Quartile of x

stat.MaxX Maximum of x values

stat.SSX Sum of squares of deviations from the mean of x

Catalog >

BooleanExpr1 or BooleanExpr2 returns

Boolean expression

BooleanList1 or BooleanList2 returns

Boolean list

BooleanMatrix1 or BooleanMatrix2

returns Boolean matrix

Returns true or false or a simplified form of

the original entry.

Returns true if either or both expressions

simplify to true. Returns false only if both

expressions evaluate to false.

Note: See xor.

Catalog >

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

Integer1 or Integer2 ⇒ integer

Compares two real integers bit-by-bit using

an or operation. Internally, both integers

are converted to signed, 64-bit binary

numbers. When corresponding bits are

compared, the result is 1 if either bit is 1;

the result is 0 only if both bits are 0. The

returned value represents the bit results,

and is displayed according to the Base

mode.

You can enter the integers in any number

base. For a binary or hexadecimal entry, you

must use the 0b or 0h prefix, respectively.

Without a prefix, integers are treated as

decimal (base10).

If you enter a decimal integer that is too

large for a signed, 64-bit binary form, a

symmetric modulo operation is used to

bring the value into the appropriate range.

For more information, see ►Base2, page

16.

Note: See xor.

In Hex base mode:

Important: Zero, not the letter O.

In Bin base mode:

Note: A binary entry can have upto 64 digits

(not counting the 0bprefix). A hexadecimal

entry canhave up to 16 digits.

ord()

Catalog >

ord(String) ⇒ integer

ord(List1) ⇒ list

Returns the numeric code of the first

character in character string String, or a list

of the first characters of each list element.

P►Rx()

Catalog >

P►Rx(rExpr, θExpr) ⇒ expression

P►Rx(rList, θList) ⇒ list

P►Rx(rMatrix, θMatrix) ⇒ matrix

In Radian angle mode:

Alphabetical Listing 109

110 Alphabetical Listing

P►Rx()

Catalog >

Returns the equivalent x-coordinate of the

(r,θ) pair.

Note: The θ argument is interpreted as

either a degree, gradian or radian angle,

according to the current angle mode. If the

argument is an expression, you can use°,

to override the angle mode setting

temporarily.

Note: You can insert this function from the

computer keyboard by typing P@>Rx(...).

P►Ry()

Catalog >

P►Ry(rValue, θValue) ⇒ value

P►Ry(rList, θList) ⇒ list

P►Ry(rMatrix, θMatrix) ⇒ matrix

Returns the equivalent y-coordinate of the

(r,θ) pair.

Note: The θ argument is interpreted as

either a degree, radian or gradian angle,

according to the current angle mode.°

Note: You can insert this function from the

computer keyboard by typing P@>Ry(...).

In Radian angle mode:

PassErr

Catalog >

PassErr

Passes an error to the next level.

If system variable errCode is zero, PassErr

does not do anything.

The Else clause of the Try...Else...EndTry

block should use ClrErr or PassErr. If the

error is to be processed or ignored, use

ClrErr. If what to do with the error is not

known, use PassErr to send it to the next

error handler. If there are no more pending

Try...Else...EndTry error handlers, the error

dialog box will be displayed as normal.

Note: See also ClrErr, page 22, and Try, page

158.

For an example of PassErr, See Example 2

under the Try command, page 158.

PassErr

Catalog >

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product guidebook.

piecewise()

Catalog >

piecewise(Expr1[, Cond1[, Expr2 [, Cond2

[, … ]]]])

Returns definitions for a piecewise function

in the form of a list. You can also create

piecewise definitions by using a template.

Note: See also Piecewise template, page 2.

poissCdf()

Catalog >

poissCdf(λ,lowBound,upBound) ⇒ number

if lowBound and upBound are numbers, list

if lowBound and upBound are lists

poissCdf(λ,upBound)for P(0≤X≤upBound) ⇒

number if upBound is a number, list if

upBound is a list

Computes a cumulative probability for the

discrete Poisson distribution with specified

mean λ.

For P(X ≤ upBound), set lowBound=0

poissPdf()

Catalog >

poissPdf(λ,XVal) ⇒ number if XVal is a

number, list if XVal is a list

Computes a probability for the discrete

Poisson distribution with the specified mean

λ.

►Polar

Catalog >

Vector ►Polar

Alphabetical Listing 111

112 Alphabetical Listing

►Polar

Catalog >

Note: You can insert

this operator from the

computer keyboard by

typing @>Polar.

Displays vector in polar

form [r∠ θ]. The vector

must be of dimension 2

and can be a row or a

column.

Note: ►Polar is a

display-format

instruction, not a

conversion function.

You can use it only at

the end of an entry

line, and it does not

update ans.

Note: See also ►Rect,

page 123.

complexValue ►Polar

Displays

complexVector in

polar form.

• Degree angle mode

returns (r∠ θ).

• Radian angle mode

returns re

iθ

complexValue can

have any complex

form. However, an re

iθ

entry causes an error in

Degree angle mode.

Note: You must use the

parentheses for an

(r∠θ) polar entry.

In Radian angle mode:

In Gradian angle mode:

In Degree angle mode:

polyEval()

Catalog >

polyEval(List1, Expr1) ⇒ expression

polyEval(List1, List2) ⇒ expression

polyEval()

Catalog >

Interprets the first argument as the

coefficient of a descending-degree

polynomial, and returns the polynomial

evaluated for the value of the second

argument.

polyRoots()

Catalog >

polyRoots(Poly,Var) ⇒ list

polyRoots(ListOfCoeffs) ⇒ list

The first syntax, polyRoots(Poly,Var),

returns a list of real roots of polynomial

Poly with respect to variable Var. If no real

roots exist, returns an empty list: {}.

Poly must be a polynomial in expanded

form in one variable. Do not use

unexpanded forms such as y

•y+1 or

x•x+2•x+1

The second syntax, polyRoots

(ListOfCoeffs), returns a list of real roots

for the coefficients in ListOfCoeffs.

Note: See also cPolyRoots(), page 30.

PowerReg

Catalog >

PowerReg X,Y[, Freq][, Category, Include]]

Computes the power regressiony = (a•(x)

)

on lists X and Y with frequency Freq. A

summary of results is stored in the

stat.results variable. (See page 146.)

All the lists must have equal dimension

except for Include.

X and Y are lists of independent and

dependent variables.

Alphabetical Listing 113

114 Alphabetical Listing

PowerReg

Catalog >

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1. All elements must be

integers ≥ 0.

Category is a list of numeric or string

category codes for the corresponding X and

Y data.

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output

variable

Description

stat.RegEqn

Regression equation: a•(x)

stat.a, stat.b Regression coefficients

stat.r

Coefficientof linear determination for transformed data

stat.r Correlation coefficient for transformed data (ln(x), ln(y))

stat.Resid Residuals associated with the power model

stat.ResidTrans Residuals associated with linear fit of transformeddata

stat.XReg

Listof data points in the modified X List actually used in the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.YReg

Listof data points in the modified Y List actually usedin the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.FreqReg

Listof frequencies corresponding to stat.XReg and stat.YReg

Prgm

Catalog >

Prgm

Block

EndPrgm

Template for creating a user-defined

program. Must be used with the Define,

Define LibPub, or Define LibPriv command.

Calculate GCD anddisplay intermediate

results.

Prgm

Catalog >

Block can be a single statement, a series

of statements separated with the “:”

character, or a series of statements on

separate lines.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

prodSeq()

See Π (), page 186.

Product (PI)

See Π (), page 186.

product()

Catalog >

product(List[, Start[, End]]) ⇒ expression

Returns the product of the elements

contained in List. Start and End are

optional. They specify a range of elements.

product(Matrix1[, Start[, End]]) ⇒ matrix

Returns a row vector containing the

products of the elements in the columns of

Matrix1. Start and end are optional. They

specify a range of rows.

Empty (void) elements are ignored. For

more information on empty elements, see

page 212.

Alphabetical Listing 115

116 Alphabetical Listing

propFrac()

Catalog >

propFrac(Value1[, Var]) ⇒ value

propFrac(rational_number) returns

rational_number as the sum of an integer

and a fraction having the same sign and a

greater denominator magnitude than

numerator magnitude.

propFrac(rational_expression,Var) returns

the sum of proper ratios and a polynomial

with respect to Var. The degree of Var in

the denominator exceeds the degree of Var

in the numerator in each proper ratio.

Similar powers of Var are collected. The

terms and their factors are sorted with Var

as the main variable.

If Var is omitted, a proper fraction

expansion is done with respect to the most

main variable. The coefficients of the

polynomial part are then made proper with

respect to their most main variable first

and so on.

You can use the propFrac() function to

represent mixed fractions and demonstrate

addition and subtraction of mixed fractions.

Catalog >

QR Matrix, qMatrix, rMatrix[, Tol]

Calculates the Householder QR factorization

of a real or complex matrix. The resulting Q

and R matrices are stored to the specified

Matrix. The Q matrix is unitary. The R

matrix is upper triangular.

Optionally, any matrix element is treated as

zero if its absolute value is less than Tol.

This tolerance is used only if the matrix has

floating-point entries and does not contain

any symbolic variables that have not been

assigned a value. Otherwise, Tol is ignored.

The floating-point number (9.) inm1 causes

results to be calculated in floating-point

form.

Catalog >

• If you use /· or set the Auto or

Approximate mode to Approximate,

computations are done using floating-

point arithmetic.

• If Tol is omitted or not used, the default

tolerance is calculated as:

5E−14 •max(dim(Matrix)) •rowNorm

(Matrix)

The QR factorization is computed

numerically using Householder

transformations. The symbolic solution is

computed using Gram-Schmidt. The

columns in qMatName are the orthonormal

basis vectors that span the space defined by

matrix.

QuadReg

Catalog >

QuadReg X,Y[, Freq][, Category, Include]]

Computes the quadratic polynomial

regression y=a•x

+b•x+c on lists X and Y

with frequency Freq. A summary of results

is stored in the stat.results variable. (See

page 146.)

All the lists must have equal dimension

except for Include.

X and Y are lists of independent and

dependent variables.

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1. All elements must be

integers ≥ 0.

Category is a list of numeric or string

category codes for the corresponding X and

Y data.

Alphabetical Listing 117

118 Alphabetical Listing

QuadReg

Catalog >

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output

variable

Description

stat.RegEqn

Regression equation: a•x

+b•x+c

stat.a,

stat.b, stat.c

Regression coefficients

stat.R

Coefficientof determination

stat.Resid Residuals from the regression

stat.XReg

Listof data points in the modified X List actually used in the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.YReg

Listof data points in the modified Y List actually usedin the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.FreqReg

Listof frequencies corresponding to stat.XReg and stat.YReg

QuartReg

Catalog >

QuartReg X,Y[, Freq][, Category, Include]]

Computes the quartic polynomial regression

y = a•x

+b•x

+c• x

+d•x+e on lists X and Y

with frequency Freq. A summary of results

is stored in the stat.results variable. (See

page 146.)

All the lists must have equal dimension

except for Include.

X and Y are lists of independent and

dependent variables.

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1. All elements must be

integers ≥ 0.

QuartReg

Catalog >

Category is a list of numeric or string

category codes for the corresponding X and

Y data.

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.RegEqn

Regression equation: a•x

+b•x

+c• x

+d•x+e

stat.a, stat.b,

stat.c, stat.d,

stat.e

Regression coefficients

stat.R

Coefficientof determination

stat.Resid Residuals from the regression

stat.XReg

Listof data points in the modified X List actually used in the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.YReg

Listof data points in the modified Y List actually usedin the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.FreqReg

Listof frequencies corresponding to stat.XReg and stat.YReg

R►Pθ()

Catalog >

R►Pθ (xValue, yValue) ⇒ value

R►Pθ (xList, yList) ⇒ list

R►Pθ (xMatrix, yMatrix) ⇒ matrix

Returns the equivalent θ-coordinate of the

(x,y) pair arguments.

Note: The result is returned as a degree,

gradian or radian angle, according to the

current angle mode setting.

Note: You can insert this function from the

computer keyboard by typing R@>Ptheta

(...).

In Degree angle mode:

In Gradian angle mode:

In Radian angle mode:

Alphabetical Listing 119

120 Alphabetical Listing

R►Pθ()

Catalog >

R►Pr()

Catalog >

R►Pr (xValue, yValue) ⇒ value

R►Pr (xList, yList) ⇒ list

R►Pr (xMatrix, yMatrix) ⇒ matrix

Returns the equivalent r-coordinate of the

(x,y) pair arguments.

Note: You can insert this function from the

computer keyboard by typing R@>Pr(...).

In Radian angle mode:

►Rad

Catalog >

Value1►Rad

⇒

value

Converts the argument to radian angle

measure.

Note: You can insert this operator from the

computer keyboard by typing @>Rad.

In Degree angle mode:

In Gradian angle mode:

rand()

Catalog >

rand() ⇒ expression

rand(#Trials) ⇒ list

rand() returns a random value between 0

and 1.

rand(#Trials) returns a list containing

#Trials random values between 0 and 1.

Set the random-number seed.

randBin()

Catalog >

randBin(n, p) ⇒ expression

randBin(n, p, #Trials) ⇒ list

randBin()

Catalog >

randBin(n, p) returns a random real number

from a specified Binomial distribution.

randBin(n, p, #Trials) returns a list

containing #Trials random real numbers

from a specified Binomial distribution.

randInt()

Catalog >

randInt

(lowBound,upBound)

⇒ expression

randInt

(lowBound,upBound

,#Trials) ⇒ list

randInt

(lowBound,upBound)

returns a random

integer within the

range specified by

lowBound and

upBound integer

bounds.

randInt

(lowBound,upBound

,#Trials) returns a

list containing

#Trials random

integers within the

specified range.

randMat()

Catalog >

randMat(numRows, numColumns) ⇒

matrix

Returns a matrix of integers between -9

and 9 of the specified dimension.

Both arguments must simplify to integers.

Note: The values in this matrix will change

each time you press ·.

Alphabetical Listing 121

122 Alphabetical Listing

randNorm()

Catalog >

randNorm(μ, σ) ⇒ expression

randNorm(μ, σ, #Trials) ⇒ list

randNorm(μ, σ) returns a decimal number

from the specified normal distribution. It

could be any real number but will be heavily

concentrated in the interval [μ−3•σ, μ+3•σ].

randNorm(μ, σ, #Trials) returns a list

containing #Trials decimal numbers from

the specified normal distribution.

randPoly()

Catalog >

randPoly(Var, Order) ⇒ expression

Returns a polynomial in Var of the

specified Order. The coefficients are

random integers in the range −9 through 9.

The leading coefficient will not be zero.

Order must be 0–99.

randSamp()

Catalog >

randSamp(List,#Trials[,noRepl]) ⇒ list

Returns a list containing a random sample

of #Trials trials from List with an option

for sample replacement (noRepl=0), or no

sample replacement (noRepl=1). The

default is with sample replacement.

RandSeed

Catalog >

RandSeed Number

If Number = 0, sets the seeds to the factory

defaults for the random-number generator.

If Number ≠0, it is used to generate two

seeds, which are stored in system variables

seed1 andseed2.

real()

Catalog >

real(Value1) ⇒ value

real()

Catalog >

Returns the real part of the argument.

real(List1) ⇒ list

Returns the real parts of all elements.

real(Matrix1) ⇒ matrix

Returns the real parts of all elements.

►Rect

Catalog >

Vector ►Rect

Note: You can insert this operator from the

computer keyboard by typing @>Rect.

Displays Vector in rectangular form [x, y,

z]. The vector must be of dimension 2 or 3

and can be a row or a column.

Note: ►Rect is a display-format instruction,

not a conversion function. You can use it

only at the end of an entry line, and it does

not update ans.

Note: See also ►Polar, page 111.

complexValue ►Rect

Displays complexValue in rectangular form

a+bi. The complexValue can have any

complex form. However, an re

iθ

entry

causes an error in Degree angle mode.

Note: You must use parentheses for an

(r∠θ) polar entry.

In Radian angle mode:

In Gradian angle mode:

In Degree angle mode:

Note: To type ∠, select itfrom the symbol

listin the Catalog.

Alphabetical Listing 123

124 Alphabetical Listing

ref()

Catalog >

ref(Matrix1[, Tol]) ⇒ matrix

Returns the row echelon form of Matrix1.

Optionally, any matrix element is treated as

zero if its absolute value is less than Tol.

This tolerance is used only if the matrix has

floating-point entries and does not contain

any symbolic variables that have not been

assigned a value. Otherwise, Tol is ignored.

• If you use /· or set the Auto or

Approximate mode to Approximate,

computations are done using floating-

point arithmetic.

• If Tol is omitted or not used, the default

tolerance is calculated as:

5E−14 •max(dim(Matrix1)) •rowNorm

(Matrix1)

Avoid undefined elements in Matrix1. They

can lead to unexpected results.

For example, if a is undefined in the

following expression, a warning message

appears and the result is shown as:

The warning appears because the

generalized element 1/a would not be valid

for a=0.

You can avoid this by storing a value to a

beforehand or by using the constraint (“|”)

operator to substitute a value, as shown in

the following example.

Note: See also rref(), page 133.

RefreshProbeVars

Catalog >

RefreshProbeVars

Allows you to access sensor data from all

connected sensor probes in your TI-Basic

program.

StatusVar

Value

Status

statusVar

Normal (continue with the

program)

statusVar

The Vernier DataQuest™

application is in data collection

mode.

Note: The Vernier DataQuest™

application must be in meter

mode for this command to work.

statusVar

The Vernier DataQuest™

application is not launched.

statusVar

The Vernier DataQuest™

application is launched, but you

have not connected any probes.

Example

Define temp()=

Prgm

RefreshProbeVars status

If status=0 Then

Disp "ready"

For n,1,50

RefreshProbeVars status

temperature:=meter.temperature

Disp "Temperature:

",temperature

If temperature>30 Then

Disp "Too hot"

EndIf

samples

Wait 1

EndFor

Else

Disp "Not ready. Try again

later"

EndIf

EndPrgm

Note: This can also be used with TI-

Innovator™ Hub.

Alphabetical Listing 125

126 Alphabetical Listing

remain()

Catalog >

remain(Value1, Value2) ⇒ value

remain(List1, List2) ⇒ list

remain(Matrix1, Matrix2) ⇒ matrix

Returns the remainder of the first

argument with respect to the second

argument as defined by the identities:

remain(x,0)x

remain(x,y)x−y•iPart(x/y)

As a consequence, note that remain(−x,y) −

remain(x,y). The result is either zero or it

has the same sign as the first argument.

Note: See also mod(), page 95.

Request

Catalog >

Request promptString, var[,DispFlag

[,statusVar]]

Request promptString, func(arg1, ...argn)

[,DispFlag [,statusVar]]

Programming command: Pauses the

program and displays a dialog box

containing the message promptString and

an input box for the user’s response.

When the user types a response and clicks

OK, the contents of the input box are

assigned to variable var.

If the user clicks Cancel, the program

proceeds without accepting any input. The

program uses the previous value of var if

var was already defined.

The optional DispFlag argument can be

any expression.

• If DispFlag is omitted or evaluates to 1,

the prompt message and user’s response

are displayed in the Calculator history.

• If DispFlag evaluates to 0, the prompt

and response are not displayed in the

history.

Define a program:

Define request_demo()=Prgm

Request “Radius: ”,r

Disp “Area = “,pi*r

EndPrgm

Run the program and type a response:

request_demo()

Resultafter selecting OK:

Radius: 6/2

Area= 28.2743

Request

Catalog >

The optional statusVar argument gives the

program a way to determine how the user

dismissed the dialog box. Note that

statusVar requires the DispFlag argument.

• If the user clicked OK or pressed Enter or

Ctrl+Enter, variable statusVar is set to a

value of 1.

• Otherwise, variable statusVar is set to a

value of 0.

The func() argument allows a program to

store the user’s response as a function

definition. This syntax operates as if the

user executed the command:

Define func(arg1, ...argn) = user’s

response

The program can then use the defined

function func(). The promptString should

guide the user to enter an appropriate

user’sresponse that completes the

function definition.

Note: You can use the Request command

within a user-defined program but not

within a function.

To stop a program that contains a Request

command inside an infinite loop:

• Handheld: Hold down the c key and

press · repeatedly.

• Windows®: Hold down the F12 key and

press Enter repeatedly.

• Macintosh®: Hold down the F5 key and

press Enter repeatedly.

• iPad®: The app displays a prompt. You

can continue waiting or cancel.

Note: See also RequestStr, page 127.

Define a program:

Define polynomial()=Prgm

Request "Enter a polynomial in

x:",p(x)

Disp "Real roots are:",polyRoots

(p(x),x)

EndPrgm

Run the program and type a response:

polynomial()

Resultafter entering x^3+3x+1 and selecting

OK:

Real roots are: {-0.322185}

RequestStr

Catalog >

RequestStr promptString, var[, DispFlag]

Define a program:

Alphabetical Listing 127

128 Alphabetical Listing

RequestStr

Catalog >

Programming command: Operates

identically to the first syntax of the Request

command, except that the user’s response

is always interpreted as a string. By

contrast, the Request command interprets

the response as an expression unless the

user encloses it in quotation marks (““).

Note: You can use the RequestStr command

within a user-defined program but not

within a function.

To stop a program that contains a

RequestStr command inside an infinite loop:

• Handheld: Hold down the c key and

press · repeatedly.

• Windows®: Hold down the F12 key and

press Enter repeatedly.

• Macintosh®: Hold down the F5 key and

press Enter repeatedly.

• iPad®: The app displays a prompt. You

can continue waiting or cancel.

Note: See also Request, page 126.

Define requestStr_demo()=Prgm

RequestStr “Your name:”,name,0

Disp “Response has “,dim(name),”

characters.”

EndPrgm

Run the program and type a response:

requestStr_demo()

Resultafter selecting OK (Note that the

DispFlag argument of 0 omits the prompt

and response from the history):

requestStr_demo()

Response has 5 characters.

Return

Catalog >

Return [Expr]

Returns Expr as the result of the function.

Use within a Func...EndFunc block.

Note: Use Return without an argument

within a Prgm...EndPrgm block to exit a

program.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

right()

Catalog >

right(List1[, Num]) ⇒ list

right()

Catalog >

Returns the rightmost Num elements

contained in List1.

If you omit Num, returns all of List1.

right(sourceString[, Num]) ⇒ string

Returns the rightmost Num characters

contained in character string sourceString.

If you omit Num, returns all of

sourceString.

right(Comparison) ⇒ expression

Returns the right side of an equation or

inequality.

rk23 ()

Catalog >

rk23(Expr, Var, depVar, {Var0, VarMax},

depVar0, VarStep [, diftol]) ⇒ matrix

rk23(SystemOfExpr, Var, ListOfDepVars,

{Var0, VarMax}, ListOfDepVars0,

VarStep[, diftol]) ⇒ matrix

rk23(ListOfExpr, Var, ListOfDepVars,

{Var0, VarMax}, ListOfDepVars0,

VarStep[, diftol]) ⇒ matrix

Uses the Runge-Kutta method to solve the

system

with depVar(Var0)=depVar0 on the

interval [Var0,VarMax]. Returns a matrix

whose first row defines the Var output

values as defined by VarStep. The second

row defines the value of the first solution

component at the corresponding Var

values, and so on.

Expr is the right hand side that defines the

ordinary differential equation (ODE).

SystemOfExpr is a system of right-hand

sides that define the system of ODEs

(corresponds to order of dependent

variables in ListOfDepVars).

Differential equation:

y'=0.001*y*(100-y) andy(0)=10

To see the entire result,

press 5 andthen use 7and8 to move the

cursor.

Same equation with diftol set to 1.E−6

System of equations:

with y1(0)=2 and y2(0)=5

Alphabetical Listing 129

130 Alphabetical Listing

rk23 ()

Catalog >

ListOfExpr is a list of right-hand sides that

define the system of ODEs (corresponds to

order of dependent variables in

ListOfDepVars).

Var is the independent variable.

ListOfDepVars is a list of dependent

variables.

{Var0, VarMax} is a two-element list that

tells the function to integrate from Var0 to

VarMax.

ListOfDepVars0 is a list of initial values

for dependent variables.

If VarStep evaluates to a nonzero number:

sign(VarStep) = sign(VarMax-Var0) and

solutions are returned at Var0+i*VarStep

for all i=0,1,2,… such that Var0+i*VarStep

is in [var0,VarMax] (may not get a solution

value at VarMax).

if VarStep evaluates to zero, solutions are

returned at the "Runge-Kutta" Var values.

diftol is the error tolerance (defaults to

0.001).

root()

Catalog >

root(Value) ⇒ root

root(Value1, Value2) ⇒ root

root(Value) returns the square root of

Value.

root(Value1, Value2) returns the Value2

root of Value1. Value1 can be a real or

complex floating point constant or an

integer or complex rational constant.

Note: See also Nth root template, page 1.

rotate()

Catalog >

rotate(Integer1[,#ofRotations]) ⇒ integer

In Bin base mode:

rotate()

Catalog >

Rotates the bits in a binary integer. You can

enter Integer1 in any number base; it is

converted automatically to a signed, 64-bit

binary form. If the magnitude of Integer1 is

too large for this form, a symmetric modulo

operation brings it within the range. For

more information, see ►Base2, page 16.

To see the entire result,

press 5 andthen use 7and8 to move the

cursor.

If #ofRotations is positive, the rotation is to

the left. If #ofRotations is negative, the

rotation is to the right. The default is −1

(rotate right one bit).

For example, in a right rotation:

In Hex base mode:

Each bit rotates right.

0b00000000000001111010110000110101

Rightmost bit rotates to leftmost.

produces:

0b10000000000000111101011000011010

The result is displayed according to the

Base mode.

Important: To enter a binary or

hexadecimalnumber, always use the 0b or

0hprefix (zero, not the letter O).

rotate(List1[,#ofRotations]) ⇒ list

Returns a copy of List1 rotated right or left

by #of Rotations elements. Does not alter

List1.

If #ofRotations is positive, the rotation is to

the left. If #of Rotations is negative, the

rotation is to the right. The default is −1

(rotate right one element).

In Dec base mode:

rotate(String1[,#ofRotations]) ⇒ string

Returns a copy of String1 rotated right or

left by #ofRotations characters. Does not

alter String1.

If #ofRotations is positive, the rotation is to

the left. If #ofRotations is negative, the

rotation is to the right. The default is −1

(rotate right one character).

Alphabetical Listing 131

132 Alphabetical Listing

round()

Catalog >

round(Value1[, digits]) ⇒ value

Returns the argument rounded to the

specified number of digits after the decimal

point.

digits must be an integer in the range 0–

12. If digits is not included, returns the

argument rounded to 12 significant digits.

Note: Display digits mode may affect how

this is displayed.

round(List1[, digits]) ⇒ list

Returns a list of the elements rounded to

the specified number of digits.

round(Matrix1[, digits]) ⇒ matrix

Returns a matrix of the elements rounded

to the specified number of digits.

rowAdd()

Catalog >

rowAdd(Matrix1, rIndex1, rIndex2) ⇒

matrix

Returns a copy of Matrix1 with row

rIndex2 replaced by the sum of rows

rIndex1 and rIndex2.

rowDim()

Catalog >

rowDim(Matrix) ⇒ expression

Returns the number of rows in Matrix.

Note: See also colDim(), page 23.

rowNorm()

Catalog >

rowNorm(Matrix) ⇒ expression

Returns the maximum of the sums of the

absolute values of the elements in the rows

in Matrix.

Note: All matrix elements must simplify to

numbers. See also colNorm(), page 23.

rowSwap()

Catalog >

rowSwap(Matrix1, rIndex1, rIndex2) ⇒

matrix

Returns Matrix1 with rows rIndex1 and

rIndex2 exchanged.

rref()

Catalog >

rref(Matrix1[, Tol]) ⇒ matrix

Returns the reduced row echelon form of

Matrix1.

Optionally, any matrix element is treated as

zero if its absolute value is less than Tol.

This tolerance is used only if the matrix has

floating-point entries and does not contain

any symbolic variables that have not been

assigned a value. Otherwise, Tol is ignored.

• If you use /· or set the Auto or

Approximate mode to Approximate,

computations are done using floating-

point arithmetic.

• If Tol is omitted or not used, the default

tolerance is calculated as:

5E−14 •max(dim(Matrix1)) •rowNorm

(Matrix1)

Note: See also ref(), page 124.

sec()

µ key

sec(Value1) ⇒ value

sec(List1) ⇒ list

Returns the secant of Value1 or returns a

list containing the secants of all elements

in List1.

In Degree angle mode:

Alphabetical Listing 133

134 Alphabetical Listing

sec()

µ key

Note: The argument is interpreted as a

degree, gradian or radian angle, according

to the current angle mode setting. You can

use °,

, or

to override the angle mode

temporarily.

sec⁻¹()

µ key

sec⁻¹(Value1) ⇒ value

sec⁻¹(List1) ⇒ list

Returns the angle whose secant is Value1

or returns a list containing the inverse

secants of each element of List1.

Note: The result is returned as a degree,

gradian, or radian angle, according to the

current angle mode setting.

Note: You can insert this function from the

keyboard by typing arcsec(...).

In Degree angle mode:

In Gradian angle mode:

In Radian angle mode:

sech()

Catalog >

sech(Value1) ⇒ value

sech(List1) ⇒ list

Returns the hyperbolic secant of Value1 or

returns a list containing the hyperbolic

secants of the List1 elements.

sech⁻¹()

Catalog >

sech⁻¹(Value1) ⇒ value

sech⁻¹(List1) ⇒ list

Returns the inverse hyperbolic secant of

Value1 or returns a list containing the

inverse hyperbolic secants of each element

of List1.

Note: You can insert this function from the

keyboard by typing arcsech(...).

In Radian angle and Rectangular complex

mode:

Send Hub Menu

Send exprOrString1 [, exprOrString2] ...

Programming command: Sends one or

more TI-Innovator™Hub commands to a

connected hub.

exprOrString must be a valid

TI-Innovator™Hub Command. Typically,

exprOrString contains a "SET..." command

to control a device or a "READ..." command

to request data.

The arguments are sent to the hub in

succession.

Note: You can use the Send command

within a user-defined program but not

within a function.

Note: See also Get (page 59), GetStr (page

66), and eval() (page 48).

Example: Turn on the blue element of the

built-in RGB LED for 0.5 seconds.

Example: Request the currentvalue of the

hub's built-in light-level sensor. A Get

command retrieves the value and assigns it

to variable lightval.

Example: Send a calculated frequency to the

hub's built-in speaker. Use special variable

iostr.SendAns to show the hubcommand

withthe expression evaluated.

seq()

Catalog >

seq(Expr, Var, Low, High[, Step]) ⇒ list

Increments Var from Low through High by

an increment of Step, evaluates Expr, and

returns the results as a list. The original

contents of Var are still there after seq() is

completed.

The default value for Step = 1.

Note: To force an approximate result,

Handheld: Press / ·.

Windows®: Press Ctrl+Enter.

Macintosh®: Press “+Enter.

iPad®: Hold enter, and select .

Alphabetical Listing 135

136 Alphabetical Listing

seqGen()

Catalog >

seqGen(Expr, Var, depVar, {Var0,

VarMax}[, ListOfInitTerms

[, VarStep[, CeilingValue]]]) ⇒ list

Generates a list of terms for sequence

depVar(Var)=Expr as follows: Increments

independent variable Var from Var0

through VarMax by VarStep, evaluates

depVar(Var) for corresponding values of

Var using the Expr formula and

ListOfInitTerms, and returns the results as

a list.

seqGen(ListOrSystemOfExpr, Var,

ListOfDepVars, {Var0, VarMax} [

, MatrixOfInitTerms[, VarStep[,

CeilingValue]]]) ⇒ matrix

Generates a matrix of terms for a system

(or list) of sequences ListOfDepVars(Var)

=ListOrSystemOfExpr as follows:

Increments independent variable Var from

Var0 through VarMax by VarStep,

evaluates ListOfDepVars(Var) for

corresponding values of Var using

ListOrSystemOfExpr formula and

MatrixOfInitTerms, and returns the results

as a matrix.

The original contents of Var are unchanged

after seqGen() is completed.

The default value for VarStep = 1.

Generate the first 5 terms of the sequence u

(n) = u(n-1)

/2, with u(1)=2 andVarStep=1.

Example inwhich Var0=2:

System of two sequences:

Note: The Void (_) inthe initial term matrix

above is used to indicate thatthe initial term

for u1(n) is calculatedusing the explicit

sequence formula u1(n)=1/n.

seqn()

Catalog >

seqn(Expr(u, n[, ListOfInitTerms[, nMax[,

CeilingValue]]]) ⇒ list

Generates a list of terms for a sequence u

(n)=Expr(u, n) as follows: Increments n

from 1 through nMax by 1, evaluates u(n)

for corresponding values of n using the

Expr(u, n) formula and ListOfInitTerms,

and returns the results as a list.

seqn(Expr(n[, nMax[, CeilingValue]]) ⇒

list

Generate the first 6 terms of the sequence u

(n) = u(n-1)/2, with u(1)=2.

seqn()

Catalog >

Generates a list of terms for a non-

recursive sequence u(n)=Expr(n) as

follows: Increments n from 1 through nMax

by 1, evaluates u(n) for corresponding

values of n using the Expr(n) formula, and

returns the results as a list.

If nMax is missing, nMax is set to 2500

If nMax=0, nMax is set to 2500

Note: seqn() calls seqGen() with n0=1 and

nstep =1

setMode()

Catalog >

setMode(modeNameInteger,

settingInteger) ⇒ integer

setMode(list) ⇒ integer list

Valid only within a function or program.

setMode(modeNameInteger,

settingInteger) temporarily sets mode

modeNameInteger to the new setting

settingInteger, and returns an integer

corresponding to the original setting of that

mode. The change is limited to the duration

of the program/function’s execution.

modeNameInteger specifies which mode

you want to set. It must be one of the mode

integers from the table below.

settingInteger specifies the new setting for

the mode. It must be one of the setting

integers listed below for the specific mode

you are setting.

setMode(list) lets you change multiple

settings. list contains pairs of mode

integers and setting integers. setMode(list)

returns a similar list whose integer pairs

represent the original modes and settings.

If you have saved all mode settings with

getMode(0)→var, you can use setMode

(var) to restore those settings until the

function or program exits. See getMode(),

page 65.

Display approximate value of π using the

default setting for Display Digits, andthen

display π with a setting of Fix2. Check to see

that the default is restored after the

program executes.

Alphabetical Listing 137

138 Alphabetical Listing

setMode()

Catalog >

Note: The current mode settings are passed

to called subroutines. If any subroutine

changes a mode setting, the mode change

will be lost when control returns to the

calling routine.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

Mode

Name

Mode

Integer Setting Integers

Display

Digits

1=Float, 2=Float1, 3=Float2, 4=Float3, 5=Float4, 6=Float5,

7=Float6, 8=Float7, 9=Float8, 10=Float9, 11=Float10,

12=Float11, 13=Float12, 14=Fix0, 15=Fix1, 16=Fix2,

17=Fix3, 18=Fix4, 19=Fix5, 20=Fix6, 21=Fix7, 22=Fix8,

23=Fix9, 24=Fix10, 25=Fix11, 26=Fix12

Angle

1=Radian, 2=Degree, 3=Gradian

Exponential

Format

1=Normal, 2=Scientific, 3=Engineering

Real or

Complex

1=Real, 2=Rectangular, 3=Polar

Auto or

Approx.

1=Auto, 2=Approximate

Vector

Format

1=Rectangular, 2=Cylindrical, 3=Spherical

Base

1=Decimal, 2=Hex, 3=Binary

shift()

Catalog >

shift(Integer1[,#ofShifts]) ⇒ integer

Shifts the bits in a binary integer. You can

enter Integer1 in any number base; it is

converted automatically to a signed, 64-bit

binary form. If the magnitude of Integer1 is

too large for this form, a symmetric modulo

operation brings it within the range. For

more information, see ►Base2, page 16.

In Bin base mode:

In Hex base mode:

shift()

Catalog >

If #ofShifts is positive, the shift is to the

left. If #ofShifts is negative, the shift is to

the right. The default is −1 (shift right one

bit).

In a right shift, the rightmost bit is dropped

and 0 or 1 is inserted to match the leftmost

bit. In a left shift, the leftmost bit is

dropped and 0 is inserted as the rightmost

bit.

For example, in a right shift:

Each bit shifts right.

0b0000000000000111101011000011010

Inserts 0 if leftmost bit is 0,

or 1 if leftmost bit is 1.

produces:

0b00000000000000111101011000011010

The result is displayed according to the

Base mode. Leading zeros are not shown.

Important: To enter a binary or

hexadecimalnumber, always use the 0b or

0hprefix (zero, not the letter O).

shift(List1[,#ofShifts]) ⇒ list

Returns a copy of List1 shifted right or left

by #ofShifts elements. Does not alter List1.

If #ofShifts is positive, the shift is to the

left. If #ofShifts is negative, the shift is to

the right. The default is −1 (shift right one

element).

Elements introduced at the beginning or

end of list by the shift are set to the symbol

“undef”.

In Dec base mode:

shift(String1[,#ofShifts]) ⇒ string

Returns a copy of String1 shifted right or

left by #ofShifts characters. Does not alter

String1.

If #ofShifts is positive, the shift is to the

left. If #ofShifts is negative, the shift is to

the right. The default is −1 (shift right one

character).

Alphabetical Listing 139

140 Alphabetical Listing

shift()

Catalog >

Characters introduced at the beginning or

end of string by the shift are set to a space.

sign()

Catalog >

sign(Value1) ⇒ value

sign(List1) ⇒ list

sign(Matrix1) ⇒ matrix

For real and complex Value1, returns

Value1/abs(Value1) when Value1 ≠ 0.

Returns 1 if Value1is positive.Returns −1 if

Value1 is negative. sign(0) returns „1 if the

complex format mode is Real; otherwise, it

returns itself.

sign(0) represents the unit circle in the

complex domain.

For a list or matrix, returns the signs of all

the elements.

If complex format mode is Real:

simult()

Catalog >

simult(coeffMatrix, constVector[, Tol]) ⇒

matrix

Returns a column vector that contains the

solutions to a system of linear equations.

Note: See also linSolve(), page 82.

coeffMatrix must be a square matrix that

contains the coefficients of the equations.

constVector must have the same number

of rows (same dimension) as coeffMatrix

and contain the constants.

Optionally, any matrix element is treated as

zero if its absolute value is less than Tol.

This tolerance is used only if the matrix has

floating-point entries and does not contain

any symbolic variables that have not been

assigned a value. Otherwise, Tol is ignored.

• If you set the Auto or Approximate mode

to Approximate, computations are done

Solve for x and y:

x + 2y = 1

3x + 4y = −1

The solution is x=−3 and y=2.

Solve:

ax + by = 1

cx + dy = 2

simult()

Catalog >

using floating-point arithmetic.

• If Tol is omitted or not used, the default

tolerance is calculated as:

5E−14 •max(dim(coeffMatrix))

•rowNorm(coeffMatrix)

simult(coeffMatrix, constMatrix[, Tol]) ⇒

matrix

Solves multiple systems of linear equations,

where each system has the same equation

coefficients but different constants.

Each column in constMatrix must contain

the constants for a system of equations.

Each column in the resulting matrix

contains the solution for the corresponding

system.

Solve:

x + 2y = 1

3x + 4y = −1

x + 2y = 2

3x + 4y = −3

For the first system, x=−3 andy=2. For the

second system, x=−7 and y=9/2.

sin()

µ key

sin(Value1) ⇒ value

sin(List1) ⇒ list

sin(Value1) returns the sine of the

argument.

sin(List1) returns a list of the sines of all

elements in List1.

Note: The argument is interpreted as a

degree, gradian or radian angle, according

to the current angle mode. You can use°,

to override the angle mode setting

temporarily.

In Degree angle mode:

In Gradian angle mode:

In Radian angle mode:

sin(squareMatrix1) ⇒ squareMatrix

Returns the matrix sine of squareMatrix1.

This is not the same as calculating the sine

of each element. For information about the

calculation method, refer to cos().

In Radian angle mode:

Alphabetical Listing 141

142 Alphabetical Listing

sin()

µ key

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

sin⁻¹()

µ key

sin⁻¹(Value1) ⇒ value

sin⁻¹(List1) ⇒ list

sin⁻¹(Value1) returns the angle whose sine

is Value1.

sin⁻¹(List1) returns a list of the inverse

sines of each element of List1.

Note: The result is returned as a degree,

gradian or radian angle, according to the

current angle mode setting.

Note: You can insert this function from the

keyboard by typing arcsin(...).

In Degree angle mode:

In Gradian angle mode:

In Radian angle mode:

sin⁻¹(squareMatrix1) ⇒ squareMatrix

Returns the matrix inverse sine of

squareMatrix1. This is not the same as

calculating the inverse sine of each

element. For information about the

calculation method, refer to cos().

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

In Radian angle mode and Rectangular

complex formatmode:

sinh()

Catalog >

sinh(Numver1) ⇒ value

sinh(List1) ⇒ list

sinh (Value1) returns the hyperbolic sine of

the argument.

sinh (List1) returns a list of the hyperbolic

sines of each element of List1.

sinh()

Catalog >

sinh(squareMatrix1) ⇒ squareMatrix

Returns the matrix hyperbolic sine of

squareMatrix1. This is not the same as

calculating the hyperbolic sine of each

element. For information about the

calculation method, refer to cos().

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

In Radian angle mode:

sinh⁻¹()

Catalog >

sinh⁻¹(Value1) ⇒ value

sinh⁻¹(List1) ⇒ list

sinh⁻¹(Value1) returns the inverse

hyperbolic sine of the argument.

sinh⁻¹(List1) returns a list of the inverse

hyperbolic sines of each element of List1.

Note: You can insert this function from the

keyboard by typing arcsinh(...).

sinh⁻¹(squareMatrix1) ⇒ squareMatrix

Returns the matrix inverse hyperbolic sine

of squareMatrix1. This is not the same as

calculating the inverse hyperbolic sine of

each element. For information about the

calculation method, refer to cos().

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

In Radian angle mode:

SinReg

Catalog >

SinReg X, Y[, [Iterations],[Period][,

Category, Include]]

Computes the sinusoidal regression on lists

X and Y. A summary of results is stored in

the stat.results variable. (See page 146.)

All the lists must have equal dimension

except for Include.

Alphabetical Listing 143

144 Alphabetical Listing

SinReg

Catalog >

X and Y are lists of independent and

dependent variables.

Iterations is a value that specifies the

maximum number of times (1 through 16) a

solution will be attempted. If omitted, 8 is

used. Typically, larger values result in better

accuracy but longer execution times, and

vice versa.

Period specifies an estimated period. If

omitted, the difference between values in X

should be equal and in sequential order. If

you specify Period, the differences between

x values can be unequal.

Category is a list of numeric or string

category codes for the corresponding X and

Y data.

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

The output of SinReg is always in radians,

regardless of the angle mode setting.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output

variable

Description

stat.RegEqn

Regression Equation: a•sin(bx+c)+d

stat.a, stat.b,

stat.c, stat.d

Regression coefficients

stat.Resid Residuals from the regression

stat.XReg

Listof data points in the modified X List actually used in the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.YReg

Listof data points in the modified Y List actually usedin the regression basedon

restrictions of Freq, Category List, and Include Categories

stat.FreqReg

Listof frequencies corresponding to stat.XReg and stat.YReg

SortA

Catalog >

SortA List1[, List2] [, List3]...

SortA Vector1[, Vector2] [, Vector3]...

Sorts the elements of the first argument in

ascending order.

If you include additional arguments, sorts

the elements of each so that their new

positions match the new positions of the

elements in the first argument.

All arguments must be names of lists or

vectors. All arguments must have equal

dimensions.

Empty (void) elements within the first

argument move to the bottom. For more

information on empty elements, see page

212.

SortD

Catalog >

SortD List1[, List2][, List3]...

SortD Vector1[,Vector2][,Vector3]...

Identical to SortA, except SortD sorts the

elements in descending order.

Empty (void) elements within the first

argument move to the bottom. For more

information on empty elements, see page

212.

►Sphere

Catalog >

Vector►Sphere

Note: You can insert this operator from the

computer keyboard by typing @>Sphere.

Displays the row or column vector in

spherical form [ρ∠ θ∠φ].

Vector must be of dimension 3 and can be

either a row or a column vector.

Alphabetical Listing 145

146 Alphabetical Listing

►Sphere

Catalog >

Note: ►Sphere is a display-format

instruction, not a conversion function. You

can use it only at the end of an entry line.

sqrt()

Catalog >

sqrt(Value1) ⇒ value

sqrt(List1) ⇒ list

Returns the square root of the argument.

For a list, returns the square roots of all the

elements in List1.

Note: See also Square root template, page

stat.results

Catalog >

stat.results

Displays results from a statistics

calculation.

The results are displayed as a set of name-

value pairs. The specific names shown are

dependent on the most recently evaluated

statistics function or command.

You can copy a name or value and paste it

into other locations.

Note: Avoid defining variables that use the

same names as those used for statistical

analysis. In some cases, an error condition

could occur. Variable names used for

statistical analysis are listed in the table

below.

stat.a

stat.AdjR²

stat.b

stat.b0

stat.b1

stat.b2

stat.b3

stat.b4

stat.b5

stat.b6

stat.b7

stat.b8

stat.b9

stat.b10

stat.bList

stat.χ²

stat.c

stat.CLower

stat.CLowerList

stat.CompList

stat.CompMatrix

stat.CookDist

stat.CUpper

stat.CUpperList

stat.d

stat.dfDenom

stat.dfBlock

stat.dfCol

stat.dfError

stat.dfInteract

stat.dfReg

stat.dfNumer

stat.dfRow

stat.DW

stat.e

stat.ExpMatrix

stat.F

stat.FBlock

stat.Fcol

stat.FInteract

stat.FreqReg

stat.Frow

stat.Leverage

stat.LowerPred

stat.LowerVal

stat.m

stat.MaxX

stat.MaxY

stat.ME

stat.MedianX

stat.MedianY

stat.MEPred

stat.MinX

stat.MinY

stat.MS

stat.MSBlock

stat.MSCol

stat.MSError

stat.MSInteract

stat.MSReg

stat.MSRow

stat.n

Stat.Ç

stat.Ç1

stat.Ç2

stat.ÇDiff

stat.PList

stat.PVal

stat.PValBlock

stat.PValCol

stat.PValInteract

stat.PValRow

stat.Q1X

stat.Q1Y

stat.Q3X

stat.Q3Y

stat.r

stat.r²

stat.RegEqn

stat.Resid

stat.ResidTrans

stat.σx

stat.σy

stat.σx1

stat.σx2

stat.Σx

stat.Σx²

stat.Σxy

stat.Σy

stat.Σy²

stat.s

stat.SE

stat.SEList

stat.SEPred

stat.sResid

stat.SEslope

stat.sp

stat.SS

stat.SSBlock

stat.SSCol

stat.SSX

stat.SSY

stat.SSError

stat.SSInteract

stat.SSReg

stat.SSRow

stat.tList

stat.UpperPred

stat.UpperVal

stat.v

stat.v1

stat.v2

stat.vDiff

stat.vList

stat.XReg

stat.XVal

stat.XValList

stat.w

stat.y

stat.yList

stat.YReg

Note: Each time the Lists & Spreadsheet application calculates statistical results, it

copies the “stat.” group variables to a “stat#.” group, where # is a number that is

incremented automatically. This lets you maintain previous results while

performing multiple calculations.

stat.values

Catalog >

stat.values

Displays a matrix of the values calculated for

the most recently evaluated statistics

function or command.

Unlike stat.results, stat.values omits the

names associated with the values.

You can copy a value and paste it into other

locations.

See the stat.results example.

Alphabetical Listing 147

148 Alphabetical Listing

stDevPop()

Catalog >

stDevPop(List [, freqList]) ⇒ expression

Returns the population standard deviation

of the elements in List.

Each freqList element counts the number

of consecutive occurrences of the

corresponding element in List.

Note:List must have at least two elements.

Empty (void) elements are ignored. For

more information on empty elements, see

page 212.

In Radian angle and auto modes:

stDevPop(Matrix1[, freqMatrix]) ⇒

matrix

Returns a row vector of the population

standard deviations of the columns in

Matrix1.

Each freqMatrix element counts the

number of consecutive occurrences of the

corresponding element in Matrix1.

Note:Matrix1must have at least two rows.

Empty (void) elements are ignored. For

more information on empty elements, see

page 212.

stDevSamp()

Catalog >

stDevSamp(List[, freqList]) ⇒ expression

Returns the sample standard deviation of

the elements in List.

Each freqList element counts the number

of consecutive occurrences of the

corresponding element in List.

Note:List must have at least two elements.

Empty (void) elements are ignored. For

more information on empty elements, see

page 212.

stDevSamp()

Catalog >

stDevSamp(Matrix1[, freqMatrix]) ⇒

matrix

Returns a row vector of the sample

standard deviations of the columns in

Matrix1.

Each freqMatrix element counts the

number of consecutive occurrences of the

corresponding element in Matrix1.

Note:Matrix1must have at least two rows.

Empty (void) elements are ignored. For

more information on empty elements, see

page 212.

Stop

Catalog >

Stop

Programming command: Terminates the

program.

Stop is not allowed in functions.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

Store

See →(store), page 194.

string()

Catalog >

string(Expr) ⇒ string

Simplifies Expr and returns the result as a

character string.

Alphabetical Listing 149

150 Alphabetical Listing

subMat()

Catalog >

subMat(Matrix1[, startRow][, startCol][,

endRow][, endCol]) ⇒ matrix

Returns the specified submatrix of Matrix1.

Defaults: startRow=1, startCol=1,

endRow=last row, endCol=last column.

Sum (Sigma)

See Σ(), page 187.

sum()

Catalog >

sum(List[, Start[, End]]) ⇒ expression

Returns the sum of all elements in List.

Start and End are optional. They specify a

range of elements.

Any void argument produces a void result.

Empty (void) elements in List are ignored.

For more information on empty elements,

see page 212.

sum(Matrix1[, Start[, End]]) ⇒ matrix

Returns a row vector containing the sums

of all elements in the columns in Matrix1.

Start and End are optional. They specify a

range of rows.

Any void argument produces a void result.

Empty (void) elements in Matrix1 are

ignored. For more information on empty

elements, see page 212.

sumIf()

Catalog >

sumIf(List,Criteria[, SumList]) ⇒ value

Returns the accumulated sum of all

elements in List that meet the specified

Criteria. Optionally, you can specify an

alternate list, sumList, to supply the

elements to accumulate.

sumIf()

Catalog >

List can be an expression, list, or matrix.

SumList, if specified, must have the same

dimension(s) as List.

Criteria can be:

• A value, expression, or string. For

example, 34 accumulates only those

elements in List that simplify to the

value 34.

• A Boolean expression containing the

symbol ? as a placeholder for each

element. For example, ?<10 accumulates

only those elements in List that are less

than 10.

When a List element meets the Criteria,

the element is added to the accumulating

sum. If you include sumList, the

corresponding element from sumList is

added to the sum instead.

Within the Lists & Spreadsheet application,

you can use a range of cells in place of List

and sumList.

Empty (void) elements are ignored. For

more information on empty elements, see

page 212.

Note: See also countIf(), page 29.

sumSeq()

See Σ(), page 187.

system()

Catalog >

system(Value1[, Value2[, Value3[, ...]]])

Returns a system of equations, formatted as

a list. You can also create a system by using

a template.

Alphabetical Listing 151

152 Alphabetical Listing

T (transpose)

Catalog >

Matrix1T ⇒ matrix

Returns the complex conjugate transpose of

Matrix1.

Note: You can insert this operator from the

computer keyboard by typing @t.

tan()

µ key

tan(Value1) ⇒ value

tan(List1) ⇒ list

tan(Value1) returns the tangent of the

argument.

tan(List1) returns a list of the tangents of

all elements in List1.

Note: The argument is interpreted as a

degree, gradian or radian angle, according

to the current angle mode. You can use°,

to override the angle mode setting

temporarily.

In Degree angle mode:

In Gradian angle mode:

In Radian angle mode:

tan(squareMatrix1) ⇒ squareMatrix

Returns the matrix tangent of

squareMatrix1. This is not the same as

calculating the tangent of each element.

For information about the calculation

method, refer to cos().

In Radian angle mode:

tan()

µ key

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

tan⁻¹()

µ key

tan⁻¹(Value1) ⇒ value

tan⁻¹(List1) ⇒ list

tan⁻¹(Value1) returns the angle whose

tangent is Value1.

tan⁻¹(List1) returns a list of the inverse

tangents of each element of List1.

Note: The result is returned as a degree,

gradian or radian angle, according to the

current angle mode setting.

Note: You can insert this function from the

keyboard by typing arctan(...).

In Degree angle mode:

In Gradian angle mode:

In Radian angle mode:

tan⁻¹(squareMatrix1) ⇒ squareMatrix

Returns the matrix inverse tangent of

squareMatrix1. This is not the same as

calculating the inverse tangent of each

element. For information about the

calculation method, refer to cos().

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

In Radian angle mode:

tanh()

Catalog >

tanh(Value1) ⇒ value

tanh(List1) ⇒ list

tanh(Value1) returns the hyperbolic

tangent of the argument.

tanh(List1) returns a list of the hyperbolic

tangents of each element of List1.

tanh(squareMatrix1) ⇒ squareMatrix

In Radian angle mode:

Alphabetical Listing 153

154 Alphabetical Listing

tanh()

Catalog >

Returns the matrix hyperbolic tangent of

squareMatrix1. This is not the same as

calculating the hyperbolic tangent of each

element. For information about the

calculation method, refer to cos().

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

tanh⁻¹()

Catalog >

tanh⁻¹(Value1) ⇒ value

tanh⁻¹(List1) ⇒ list

tanh⁻¹(Value1) returns the inverse

hyperbolic tangent of the argument.

tanh⁻¹(List1) returns a list of the inverse

hyperbolic tangents of each element of

List1.

Note: You can insert this function from the

keyboard by typing arctanh(...).

In Rectangular complex format:

To see the entire result,

press 5 andthen use 7and8 to move the

cursor.

tanh⁻¹(squareMatrix1) ⇒ squareMatrix

Returns the matrix inverse hyperbolic

tangent of squareMatrix1. This is not the

same as calculating the inverse hyperbolic

tangent of each element. For information

about the calculation method, refer to cos

().

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

In Radian angle mode and Rectangular

complex format:

To see the entire result,

press 5 andthen use 7and8 to move the

cursor.

tCdf()

Catalog >

tCdf(lowBound,upBound,df) ⇒ number if

lowBound and upBound are numbers, list if

lowBound and upBound are lists

Computes the Student-t distribution

probability between lowBound and upBound

for the specified degrees of freedom df.

tCdf()

Catalog >

For P(X ≤ upBound), set lowBound = ⁻9E999.

Text

Catalog >

TextpromptString[, DispFlag]

Programming command: Pauses the

program and displays the character string

promptString in a dialog box.

When the user selects OK, program

execution continues.

The optional flag argument can be any

expression.

• If DispFlag is omitted or evaluates to 1,

the text message is added to the

Calculator history.

• If DispFlag evaluates to 0, the text

message is not added to the history.

If the program needs a typed response from

the user, refer to Request, page 126, or

RequestStr, page 127.

Note: You can use this command within a

user-defined program but not within a

function.

Define a program that pauses to display

each of five random numbers ina dialog

box.

Within the Prgm...EndPrgm template,

complete each line by pressing @ instead

of ·. On the computer keyboard, hold

down Alt andpress Enter.

Define text_demo()=Prgm

For i,1,5

strinfo:=”Random number “&

string(rand(i))

Text strinfo

EndFor

EndPrgm

Run the program:

text_demo()

Sample of one dialog box:

Then

See If, page 68.

tInterval

Catalog >

tInterval List[, Freq[, CLevel]]

(Data list input)

tInterval v, sx, n[, CLevel]

(Summary stats input)

Alphabetical Listing 155

156 Alphabetical Listing

tInterval

Catalog >

Computes a t confidence interval. A

summary of results is stored in the

stat.results variable. (See page 146.)

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.CLower, stat.CUpper Confidence interval for an unknownpopulation mean

stat.v Sample mean of the data sequence from the normal random distribution

stat.ME Marginof error

stat.df Degrees of freedom

stat.σx

Sample standard deviation

stat.n Length of the data sequence withsample mean

tInterval_2Samp

Catalog >

tInterval_2Samp List1,List2[,Freq1[,Freq2

[,CLevel[,Pooled]]]]

(Data list input)

tInterval_2Samp v1,sx1,n1,v2,sx2,n2

[,CLevel[,Pooled]]

(Summary stats input)

Computes a two-sample t confidence

interval. A summary of results is stored in

the stat.results variable. (See page 146.)

Pooled=1 pools variances; Pooled=0 does

not pool variances.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.CLower,

stat.CUpper

Confidence interval containing confidence levelprobability of distribution

stat.v1-v2 Sample means of the data sequences from the normal random

distribution

Output variable Description

stat.ME Margin of error

stat.df Degrees of freedom

stat.v1, stat.v2 Sample means of the data sequences from the normal random

distribution

stat.σx1, stat.σx2 Sample standard deviations for List 1 and List 2

stat.n1, stat.n2 Number of samples indata sequences

stat.sp

The pooledstandard deviation. Calculated when Pooled=YES

tPdf()

Catalog >

tPdf(XVal,df) ⇒ number if XVal is a

number, list if XVal is a list

Computes the probability density function

(pdf) for the Student-t distribution at a

specified x value with specified degrees of

freedom df.

trace()

Catalog >

trace(squareMatrix) ⇒ value

Returns the trace (sum of all the elements

on the main diagonal) of squareMatrix.

Alphabetical Listing 157

158 Alphabetical Listing

Try

Catalog >

Try

block1

Else

block2

EndTry

Executes block1 unless an error occurs.

Program execution transfers to block2 if an

error occurs in block1. System variable

errCode contains the error code to allow

the program to perform error recovery. For

a list of error codes, see “Error codes and

messages,” page 222.

block1 and block2 can be either a single

statement or a series of statements

separated with the “:” character.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

To see the commands Try, ClrErr, and

PassErr in operation, enter the eigenvals()

program shown at the right. Run the

program by executing each of the following

expressions.

Note: See also ClrErr, page 22, and PassErr,

page 110.

Define eigenvals(a,b)=Prgm

eigenvalues of A•B

Try

Disp "A= ",a

Disp "B= ",b

Disp " "

Disp "Eigenvalues of A•B are:",eigVl(a*b)

Else

If errCode=230 Then

Disp "Error: Product of A•B must be a

square matrix"

ClrErr

Else

PassErr

EndIf

EndTry

EndPrgm

tTest

Catalog >

tTest μ0,List[,Freq[,Hypoth]]

(Data list input)

tTest μ0,v,sx,n,[Hypoth]

(Summary stats input)

Performs a hypothesis test for a single

unknown population mean μ when the

population standard deviation σ is unknown.

A summary of results is stored in the

stat.results variable. (See page 146.)

Test H

: μ = μ0, against one of the

following:

For H

: μ < μ0, set Hypoth<0

For H

: μ ≠ μ0 (default), set Hypoth=0

For H

: μ > μ0, set Hypoth>0

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.t

(v − μ0) / (stdev / sqrt(n))

stat.PVal Smallest level of significance at which the null hypothesis canbe rejected

stat.df Degrees of freedom

stat.v

Sample mean of the data sequence in List

stat.sx Sample standard deviation of the data sequence

stat.n Size of the sample

tTest_2Samp

Catalog >

tTest_2Samp List1,List2[,Freq1[,Freq2

[,Hypoth[,Pooled]]]]

(Data list input)

tTest_2Samp v1,sx1,n1,v2,sx2,n2[,Hypoth

[,Pooled]]

(Summary stats input)

Alphabetical Listing 159

160 Alphabetical Listing

tTest_2Samp

Catalog >

Computes a two-sample t test. A summary

of results is stored in the stat.results

variable. (See page 146.)

Test H

: μ1 = μ2, against one of the

following:

For H

: μ1< μ2, set Hypoth<0

For H

: μ1≠ μ2 (default), set Hypoth=0

For H

: μ1> μ2, set Hypoth>0

Pooled=1 pools variances

Pooled=0 does not pool variances

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.t Standard normal value computed for the difference of means

stat.PVal Smallest level of significance at which the null hypothesis canbe rejected

stat.df Degrees of freedom for the t-statistic

stat.v1, stat.v2

Sample means of the data sequences in List 1 andList 2

stat.sx1, stat.sx2

Sample standard deviations of the data sequences in List 1 and List 2

stat.n1, stat.n2 Size of the samples

stat.sp

The pooledstandard deviation. Calculated when Pooled=1.

tvmFV()

Catalog >

tvmFV(N,I,PV,Pmt,[PpY],[CpY],[PmtAt])

⇒ value

Financial function that calculates the future

value of money.

Note: Arguments used in the TVM functions

are described in the table of TVM

arguments, page 162. See also amortTbl(),

page 7.

tvmI()

Catalog >

tvmI(N,PV,Pmt,FV,[PpY],[CpY],[PmtAt])

⇒ value

tvmI()

Catalog >

Financial function that calculates the

interest rate per year.

Note: Arguments used in the TVM functions

are described in the table of TVM

arguments, page 162. See also amortTbl(),

page 7.

tvmN()

Catalog >

tvmN(I,PV,Pmt,FV,[PpY],[CpY],[PmtAt])

⇒ value

Financial function that calculates the

number of payment periods.

Note: Arguments used in the TVM functions

are described in the table of TVM

arguments, page 162. See also amortTbl(),

page 7.

tvmPmt()

Catalog >

tvmPmt(N,I,PV,FV,[PpY],[CpY],[PmtAt])

⇒ value

Financial function that calculates the

amount of each payment.

Note: Arguments used in the TVM functions

are described in the table of TVM

arguments, page 162. See also amortTbl(),

page 7.

tvmPV()

Catalog >

tvmPV(N,I,Pmt,FV,[PpY],[CpY],[PmtAt])

⇒ value

Financial function that calculates the

present value.

Note: Arguments used in the TVM functions

are described in the table of TVM

arguments, page 162. See also amortTbl(),

page 7.

Alphabetical Listing 161

162 Alphabetical Listing

TVM

argument*

Description Data type

N Number of payment periods realnumber

I Annual interest rate realnumber

PV Present value realnumber

Pmt Payment amount realnumber

FV Future value realnumber

PpY Payments per year, default=1 integer > 0

CpY Compounding periods per year, default=1 integer > 0

PmtAt Paymentdue at the end or beginning of eachperiod,

default=end

integer (0=end,

1=beginning)

* These time-value-of-money argument names are similar to the TVM variable names

(such as tvm.pv and tvm.pmt) that are used by the Calculator application’s finance

solver. Financial functions, however, do not store their argument values or results to

the TVM variables.

TwoVar

Catalog >

TwoVar X, Y[, [Freq][, Category, Include]]

Calculates the TwoVar statistics. A summary

of results is stored in the stat.results

variable. (See page 146.)

All the lists must have equal dimension

except for Include.

X and Y are lists of independent and

dependent variables.

Freq is an optional list of frequency values.

Each element in Freq specifies the

frequency of occurrence for each

corresponding X and Y data point. The

default value is 1. All elements must be

integers ≥ 0.

Category is a list of numeric category codes

for the corresponding X and Y data.

Include is a list of one or more of the

category codes. Only those data items

whose category code is included in this list

are included in the calculation.

TwoVar

Catalog >

An empty (void) element in any of the lists

X, Freq, or Category results in a void for

the corresponding element of all those lists.

An empty element in any of the lists X1

through X20 results in a void for the

corresponding element of all those lists. For

more information on empty elements, see

page 212.

Output variable Description

stat.v Mean of x values

stat.Σx

Sum of x values

stat.Σx2

Sum of x2 values

stat.sx Sample standard deviation of x

stat.σx

Population standard deviation of x

stat.n Number of data points

stat.w Mean of y values

stat.Σy

Sum of y values

stat.Σy

Sum of y2 values

stat.sy Sample standard deviation of y

stat.σy

Population standard deviation of y

stat.Σxy Sum of x•y values

stat.r Correlation coefficient

stat.MinX Minimum of x values

stat.Q

X 1st Quartile of x

stat.MedianX Median of x

stat.Q

X 3rd Quartile of x

stat.MaxX Maximum of x values

stat.MinY Minimum of y values

stat.Q

Y 1stQuartile of y

stat.MedY Median of y

stat.Q

Y 3rd Quartile of y

Alphabetical Listing 163

164 Alphabetical Listing

Output variable Description

stat.MaxY Maximum of y values

stat.Σ(x-v)

Sum of squares of deviations from the mean of x

stat.Σ(y-w)

Sum of squares of deviations from the mean of y

unitV()

Catalog >

unitV(Vector1) ⇒ vector

Returns either a row- or column-unit vector,

depending on the form of Vector1.

Vector1 must be either a single-row matrix

or a single-column matrix.

unLock

Catalog >

unLock Var1[, Var2] [, Var3] ...

unLock Var.

Unlocks the specified variables or variable

group. Locked variables cannot be modified

or deleted.

See Lock, page 86, and getLockInfo(), page

64.

varPop()

Catalog >

varPop(List[, freqList]) ⇒ expression

Returns the population variance of List.

Each freqList element counts the number

of consecutive occurrences of the

corresponding element in List.

Note: List must contain at least two

elements.

varPop()

Catalog >

If an element in either list is empty (void),

that element is ignored, and the

corresponding element in the other list is

also ignored. For more information on

empty elements, see page 212.

varSamp()

Catalog >

varSamp(List[, freqList]) ⇒ expression

Returns the sample variance of List.

Each freqList element counts the number

of consecutive occurrences of the

corresponding element in List.

Note: List must contain at least two

elements.

If an element in either list is empty (void),

that element is ignored, and the

corresponding element in the other list is

also ignored. For more information on

empty elements, see page 212.

varSamp(Matrix1[, freqMatrix]) ⇒

matrix

Returns a row vector containing the sample

variance of each column in Matrix1.

Each freqMatrix element counts the

number of consecutive occurrences of the

corresponding element in Matrix1.

If an element in either matrix is empty

(void), that element is ignored, and the

corresponding element in the other matrix

is also ignored. For more information on

empty elements, see page 212.

Note: Matrix1 must contain at least two

rows.

Wait

Catalog >

Wait timeInSeconds

To wait4 seconds:

Wait 4

Alphabetical Listing 165

166 Alphabetical Listing

Wait

Catalog >

Suspends execution for a period of

timeInSeconds seconds.

Wait is particularly useful in a program that

needs a brief delay to allow requested data

to become available.

The argument timeInSeconds must be an

expression that simplifies to a decimal value

in the range 0 through 100. The command

rounds this value up to the nearest 0.1

seconds.

To cancel a Wait that is in progress,

• Handheld: Hold down the c key and

press · repeatedly.

• Windows®: Hold down the F12 key and

press Enter repeatedly.

• Macintosh®: Hold down the F5 key and

press Enter repeatedly.

• iPad®: The app displays a prompt. You can

continue waiting or cancel.

Note: You can use the Wait command within

a user-defined program but not within a

function.

To wait1/2 second:

Wait 0.5

To wait1.3 seconds using the variable

seccount:

seccount:=1.3

Wait seccount

This example switches a green LED on for

0.5 seconds and then switches it off.

Send "SET GREEN 1 ON"

Wait 0.5

Send "SET GREEN 1 OFF"

warnCodes ()

Catalog >

warnCodes(Expr1, StatusVar) ⇒

expression

Evaluates expression Expr1, returns the

result, and stores the codes of any

generated warnings in the StatusVar list

variable. If no warnings are generated, this

function assigns StatusVar an empty list.

Expr1 can be any valid TI-Nspire™ or

TI-Nspire™CAS math expression. You

cannot use a command or assignment as

Expr1.

StatusVar must be a valid variable name.

For a list of warning codes and associated

messages, see page 230.

when()

Catalog >

when(Condition, trueResult [, falseResult]

[, unknownResult]) ⇒ expression

Returns trueResult, falseResult, or

unknownResult, depending on whether

Condition is true, false, or unknown.

Returns the input if there are too few

arguments to specify the appropriate result.

Omit both falseResult and unknownResult

to make an expression defined only in the

region where Condition is true.

Use an undef falseResult to define an

expression that graphs only on an interval.

when() is helpful for defining recursive

functions.

While

Catalog >

While Condition

Block

EndWhile

Executes the statements in Block as long

as Condition is true.

Block can be either a single statement or a

sequence of statements separated with the

“:” character.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

xor

Catalog >

BooleanExpr1 xor BooleanExpr2 returns

Boolean expressionBooleanList1

xor BooleanList2 returns Boolean

listBooleanMatrix1

xor BooleanMatrix2 returns Boolean

Alphabetical Listing 167

168 Alphabetical Listing

xor

Catalog >

matrix

Returns true if BooleanExpr1 is true and

BooleanExpr2 is false, or vice versa.

Returns false if both arguments are true or

if both are false. Returns a simplified

Boolean expression if either of the

arguments cannot be resolved to true or

false.

Note: See or, page 108.

Integer1 xor Integer2⇒ integer

Compares two real integers bit-by-bit using

an xor operation. Internally, both integers

are converted to signed, 64-bit binary

numbers. When corresponding bits are

compared, the result is 1 if either bit (but

not both) is 1; the result is 0 if both bits are

0 or both bits are 1. The returned value

represents the bit results, and is displayed

according to the Base mode.

You can enter the integers in any number

base. For a binary or hexadecimal entry, you

must use the 0b or 0h prefix, respectively.

Without a prefix, integers are treated as

decimal (base10).

If you enter a decimal integer that is too

large for a signed, 64-bit binary form, a

symmetric modulo operation is used to

bring the value into the appropriate range.

For more information, see ►Base2, page

16.

Note: See or, page 108.

In Hex base mode:

Important: Zero, not the letter O.

In Bin base mode:

Note: A binary entry can have upto 64 digits

(not counting the 0bprefix). A hexadecimal

entry canhave up to 16 digits.

zInterval

Catalog >

zInterval σ,List[,Freq[,CLevel]]

(Data list input)

zInterval σ,v,n [,CLevel]

(Summary stats input)

zInterval

Catalog >

Computes a z confidence interval. A

summary of results is stored in the

stat.results variable. (See page 146.)

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.CLower, stat.CUpper Confidence interval for an unknownpopulation mean

stat.x Sample mean of the data sequence from the normal random distribution

stat.ME Marginof error

stat.sx Sample standard deviation

stat.n Length of the data sequence withsample mean

stat.σ Knownpopulation standard deviation for data sequence List

zInterval_1Prop

Catalog >

zInterval_1Prop x,n [,CLevel]

Computes a one-proportion z confidence

interval. A summary of results is stored in

the stat.results variable. (See page 146.)

x is a non-negative integer.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.CLower, stat.CUpper Confidence interval containing confidence level probability of distribution

stat.Ç The calculatedproportion of successes

stat.ME Margin of error

stat.n Number of samples in data sequence

zInterval_2Prop

Catalog >

zInterval_2Prop x1,n1,x2,n2[,CLevel]

Alphabetical Listing 169

170 Alphabetical Listing

zInterval_2Prop

Catalog >

Computes a two-proportion z confidence

interval. A summary of results is stored in

the stat.results variable. (See page 146.)

x1 and x2 are non-negative integers.

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.CLower, stat.CUpper Confidence interval containing confidence level probability of distribution

stat.Ç Diff The calculateddifference between proportions

stat.ME Margin of error

stat.Ç1 First sample proportion estimate

stat.Ç2 Secondsample proportion estimate

stat.n1 Sample size in data sequence one

stat.n2 Sample size in data sequence two

zInterval_2Samp

Catalog >

zInterval_2Samp σ

,σ

,List1,List2[,Freq1

[,Freq2,[CLevel]]]

(Data list input)

zInterval_2Samp σ

,σ

,v1,n1,v2,n2

[,CLevel]

(Summary stats input)

Computes a two-sample z confidence

interval. A summary of results is stored in

the stat.results variable. (See page 146.)

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.CLower,

stat.CUpper

Confidence interval containing confidence levelprobability of distribution

Output variable Description

stat.x1-x2 Sample means of the data sequences from the normal random

distribution

stat.ME Margin of error

stat.x1, stat.x2 Sample means of the data sequences from the normal random

distribution

stat.σx1, stat.σx2 Sample standard deviations for List 1 and List 2

stat.n1, stat.n2 Number of samples indata sequences

stat.r1, stat.r2

Knownpopulation standard deviations for data sequence List 1 and List

zTest

Catalog >

zTest μ0,σ,List,[Freq[,Hypoth]]

(Data list input)

zTest μ0,σ,v,n[,Hypoth]

(Summary stats input)

Performs a z test with frequency freqlist. A

summary of results is stored in the

stat.results variable. (See page 146.)

Test H

: μ = μ0, against one of the

following:

For H

: μ < μ0, set Hypoth<0

For H

: μ ≠ μ0 (default), set Hypoth=0

For H

: μ > μ0, set Hypoth>0

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.z

(x − μ0) / (σ / sqrt(n))

stat.P Value Least probability at which the null hypothesis canbe rejected

stat.x

Sample mean of the data sequence in List

stat.sx

Sample standard deviation of the data sequence. Only returned for Data input.

stat.n Size of the sample

Alphabetical Listing 171

172 Alphabetical Listing

zTest_1Prop

Catalog >

Output variable Description

stat.p0 Hypothesized population proportion

stat.z Standard normal value computed for the proportion

stat.PVal Smallest level of significance at which the null hypothesis canbe rejected

stat.Ç Estimated sample proportion

stat.n Size of the sample

zTest_2Prop

Catalog >

zTest_2Prop x1,n1,x2,n2[,Hypoth]

Computes a two-proportion z test. A

summary of results is stored in the

stat.results variable. (See page 146.)

x1 and x2 are non-negative integers.

Test H

: p1 = p2, against one of the

following:

For H

: p1 > p2, set Hypoth>0

For H

: p1 ≠ p2 (default), set Hypoth=0

For H

: p < p0, set Hypoth<0

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.z Standard normal value computed for the difference of proportions

stat.PVal Smallest level of significance at which the null hypothesis canbe rejected

stat.Ç1 First sample proportion estimate

stat.Ç2 Second sample proportion estimate

stat.Ç Pooled sample proportion estimate

stat.n1, stat.n2 Number of samples takenin trials 1 and 2

zTest_2Samp

Catalog >

zTest_2Samp σ

,σ

,List1,List2[,Freq1

zTest_2Samp

Catalog >

[,Freq2[,Hypoth]]]

(Data list input)

zTest_2Samp σ

,σ

,v1,n1,v2,n2[,Hypoth]

(Summary stats input)

Computes a two-sample z test. A summary

of results is stored in the stat.results

variable. (See page 146.)

Test H

: μ1 = μ2, against one of the

following:

For H

: μ1 < μ2, set Hypoth<0

For H

: μ1 ≠ μ2 (default), set Hypoth=0

For H

: μ1 > μ2, Hypoth>0

For information on the effect of empty

elements in a list, see “Empty (Void)

Elements,” page 212.

Output variable Description

stat.z Standard normal value computed for the difference of means

stat.PVal Smallest level of significance at which the null hypothesis canbe rejected

stat.x1, stat.x2

Sample means of the data sequences in List1 and List2

stat.sx1, stat.sx2

Sample standard deviations of the data sequences in List1 andList2

stat.n1, stat.n2 Size of the samples

Alphabetical Listing 173

174 Symbols

Symbols

+ (add)

+ key

Value1 + Value2 ⇒ value

Returns the sum of the two arguments.

List1 + List2 ⇒ list

Matrix1 + Matrix2 ⇒ matrix

Returns a list (or matrix) containing the

sums of corresponding elements in List1

and List2 (or Matrix1 and Matrix2).

Dimensions of the arguments must be

equal.

Value + List1 ⇒ list

List1 + Value ⇒ list

Returns a list containing the sums of Value

and each element in List1.

Value + Matrix1 ⇒ matrix

Matrix1 + Value ⇒ matrix

Returns a matrix with Value added to each

element on the diagonal of Matrix1.

Matrix1 must be square.

Note: Use .+ (dot plus) to add an expression

to each element.

− (subtract)

- key

Value1−Value2 ⇒ value

Returns Value1 minus Value2.

List1 −List2⇒ list

Matrix1 −Matrix2 ⇒ matrix

− (subtract)

- key

Subtracts each element in List2 (or

Matrix2) from the corresponding element

in List1 (or Matrix1), and returns the

results.

Dimensions of the arguments must be

equal.

Value − List1 ⇒ list

List1 − Value ⇒ list

Subtracts each List1 element from Value

or subtracts Value from each List1

element, and returns a list of the results.

Value − Matrix1 ⇒ matrix

Matrix1 − Value ⇒ matrix

Value − Matrix1 returns a matrix of Value

times the identity matrix minus

Matrix1.Matrix1 must be square.

Matrix1 − Value returns a matrix of Value

times the identity matrix subtracted from

Matrix1.Matrix1 must be square.

Note: Use .− (dot minus) to subtract an

expression from each element.

• (multiply)

r key

Value1•Value2 ⇒ value

Returns the product of the two arguments.

List1•List2 ⇒ list

Returns a list containing the products of the

corresponding elements in List1 and List2.

Dimensions of the lists must be equal.

Matrix1•Matrix2 ⇒ matrix

Returns the matrix product of Matrix1 and

Matrix2.

The number of columns in Matrix1 must

equal the number of rows in Matrix2.

Symbols 175

176 Symbols

• (multiply)

r key

Value •List1 ⇒ list

List1•Value ⇒ list

Returns a list containing the products of

Value and each element in List1.

Value •Matrix1 ⇒ matrix

Matrix1•Value ⇒ matrix

Returns a matrix containing the products of

Value and each element in Matrix1.

Note: Use .•(dot multiply) to multiply an

expression by each element.

⁄ (divide)

p key

Value1 ⁄ Value2 ⇒ value

Returns the quotient of Value1 divided by

Value2.

Note: See also Fraction template, page 1.

List1 ⁄ List2 ⇒ list

Returns a list containing the quotients of

List1 divided by List2.

Dimensions of the lists must be equal.

Value ⁄ List1 ⇒ list

List1 ⁄ Value ⇒ list

Returns a list containing the quotients of

Value divided by List1 or List1 divided by

Value.

Value ⁄ Matrix1 ⇒ matrix

Matrix1 ⁄ Value ⇒ matrix

Returns a matrix containing the quotients

of Matrix1 ⁄ Value.

Note: Use . ⁄ (dot divide) to divide an

expression by each element.

^ (power)

l key

Value1 ^ Value2⇒ value

List1 ^ List2 ⇒ list

Returns the first argument raised to the

power of the second argument.

Note: See also Exponent template, page 1.

For a list, returns the elements in List1

raised to the power of the corresponding

elements in List2.

In the real domain, fractional powers that

have reduced exponents with odd

denominators use the real branch versus

the principal branch for complex mode.

Value ^ List1 ⇒ list

Returns Value raised to the power of the

elements in List1.

List1 ^ Value ⇒ list

Returns the elements in List1 raised to the

power of Value.

squareMatrix1 ^ integer ⇒ matrix

Returns squareMatrix1 raised to the

integer power.

squareMatrix1 must be a square matrix.

If integer = −1, computes the inverse

matrix.

If integer < −1, computes the inverse

matrix to an appropriate positive power.

Symbols 177

178 Symbols

(square)

q key

Value1

⇒ value

Returns the square of the argument.

List1

⇒ list

Returns a list containing the squares of the

elements in List1.

squareMatrix1

⇒ matrix

Returns the matrix square of

squareMatrix1. This is not the same as

calculating the square of each element. Use

.^2 to calculate the square of each element.

.+ (dot add)

^+ keys

Matrix1 .+ Matrix2 ⇒ matrix

Value .+ Matrix1⇒ matrix

Matrix1.+Matrix2 returns a matrix that is

the sum of each pair of corresponding

elements in Matrix1 and Matrix2.

Value .+ Matrix1 returns a matrix that is

the sum of Value and each element in

Matrix1.

.⁻(dot subt.)

^- keys

Matrix1 .− Matrix2⇒ matrix

Value .− Matrix1 ⇒ matrix

Matrix1.− Matrix2 returns a matrix that is

the difference between each pair of

corresponding elements in Matrix1 and

Matrix2.

Value .− Matrix1 returns a matrix that is

the difference of Value and each element

in Matrix1.

.•(dot mult.)

^r keys

Matrix1 .• Matrix2⇒ matrix

Value .• Matrix1 ⇒ matrix

Matrix1.• Matrix2 returns a matrix that is

the product of each pair of corresponding

elements in Matrix1 and Matrix2.

Value .• Matrix1 returns a matrix

containing the products of Value and each

element in Matrix1.

. ⁄ (dot divide)

^p keys

Matrix1. ⁄ Matrix2 ⇒ matrix

Value . ⁄ Matrix1⇒ matrix

Matrix1 . ⁄ Matrix2 returns a matrix that is

the quotient of each pair of corresponding

elements in Matrix1 and Matrix2.

Value . ⁄ Matrix1 returns a matrix that is

the quotient of Value and each element in

Matrix1.

.^ (dot power)

^l keys

Matrix1 .^ Matrix2 ⇒ matrix

Value . ^ Matrix1⇒ matrix

Matrix1.^ Matrix2 returns a matrix where

each element in Matrix2 is the exponent

for the corresponding element in Matrix1.

Value .^ Matrix1 returns a matrix where

each element in Matrix1 is the exponent

for Value.

− (negate)

v key

−Value1 ⇒ value

−List1 ⇒ list

−Matrix1 ⇒ matrix

Symbols 179

180 Symbols

− (negate)

v key

Returns the negation of the argument.

For a list or matrix, returns all the elements

negated.

If the argument is a binary or hexadecimal

integer, the negation gives the two’s

complement.

In Bin base mode:

Important: Zero, not the letter O.

To see the entire result,

press 5 andthen use 7and8 to move the

cursor.

% (percent)

/k keys

Value1% ⇒ value

List1% ⇒ list

Matrix1% ⇒ matrix

Returns

For a list or matrix, returns a list or matrix

with each element divided by 100.

= (equal)

= key

Expr1=Expr2 ⇒ Boolean expression

List1=List2 ⇒ Boolean list

Matrix1=Matrix2 ⇒ Boolean matrix

Returns true if Expr1 is determined to be

equal to Expr2.

Returns false if Expr1 is determined to not

be equal to Expr2.

Anything else returns a simplified form of

the equation.

For lists and matrices, returns comparisons

element by element.

Example function that uses math test

symbols: =, ≠, <, ≤, >, ≥

Resultof graphing g(x)

= (equal)

= key

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

≠ (not equal)

/= keys

Expr1≠Expr2 ⇒ Boolean expression

List1≠List2 ⇒ Boolean list

Matrix1≠Matrix2 ⇒ Boolean matrix

Returns true if Expr1 is determined to be

not equal to Expr2.

Returns false if Expr1 is determined to be

equal to Expr2.

Anything else returns a simplified form of

the equation.

For lists and matrices, returns comparisons

element by element.

Note: You can insert this operator from the

keyboard by typing /=

See “=” (equal) example.

< (less than)

/= keys

Expr1<Expr2 ⇒ Boolean expression

List1<List2 ⇒ Boolean list

Matrix1<Matrix2 ⇒ Boolean matrix

Returns true if Expr1 is determined to be

less than Expr2.

Returns false if Expr1 is determined to be

greater than or equal to Expr2.

See “=” (equal) example.

Symbols 181

182 Symbols

< (less than)

/= keys

Anything else returns a simplified form of

the equation.

For lists and matrices, returns comparisons

element by element.

≤ (less or equal)

/= keys

Expr1≤Expr2 ⇒ Boolean expression

List1≤List2 ⇒ Boolean list

Matrix1 ≤Matrix2 ⇒ Boolean matrix

Returns true if Expr1 is determined to be

less than or equal to Expr2.

Returns false if Expr1 is determined to be

greater than Expr2.

Anything else returns a simplified form of

the equation.

For lists and matrices, returns comparisons

element by element.

Note: You can insert this operator from the

keyboard by typing <=

See “=” (equal) example.

> (greater than)

/= keys

Expr1>Expr2 ⇒ Boolean expression

List1>List2 ⇒ Boolean list

Matrix1>Matrix2 ⇒ Boolean matrix

Returns true if Expr1 is determined to be

greater than Expr2.

Returns false if Expr1 is determined to be

less than or equal to Expr2.

Anything else returns a simplified form of

the equation.

For lists and matrices, returns comparisons

element by element.

See “=” (equal) example.

≥ (greater or equal)

/= keys

Expr1≥Expr2 ⇒ Boolean expression

List1≥List2 ⇒ Boolean list

Matrix1 ≥Matrix2 ⇒ Boolean matrix

Returns true if Expr1 is determined to be

greater than or equal to Expr2.

Returns false if Expr1 is determined to be

less than Expr2.

Anything else returns a simplified form of

the equation.

For lists and matrices, returns comparisons

element by element.

Note: You can insert this operator from the

keyboard by typing >=

See “=” (equal) example.

⇒ (logical implication)

/= keys

BooleanExpr1 ⇒ BooleanExpr2 returns

Boolean expression

BooleanList1 ⇒ BooleanList2 returns

Boolean list

BooleanMatrix1 ⇒ BooleanMatrix2

returns Boolean matrix

Integer1 ⇒ Integer2 returns Integer

Evaluates the expression not <argument1>

or <argument2> and returns true, false, or a

simplified form of the equation.

For lists and matrices, returns comparisons

element by element.

Note: You can insert this operator from the

keyboard by typing =>

Symbols 183

184 Symbols

⇔ (logical double implication, XNOR)

/= keys

BooleanExpr1 ⇔ BooleanExpr2 returns

Boolean expression

BooleanList1 ⇔ BooleanList2 returns

Boolean list

BooleanMatrix1 ⇔ BooleanMatrix2

returns Boolean matrix

Integer1 ⇔ Integer2 returns Integer

Returns the negation of an XOR Boolean

operation on the two arguments. Returns

true, false, or a simplified form of the

equation.

For lists and matrices, returns comparisons

element by element.

Note: You can insert this operator from the

keyboard by typing <=>

! (factorial)

º key

Value1! ⇒ value

List1! ⇒ list

Matrix1! ⇒ matrix

Returns the factorial of the argument.

For a list or matrix, returns a list or matrix

of factorials of the elements.

& (append)

/k keys

String1 & String2 ⇒ string

Returns a text string that is String2

appended to String1.

d() (derivative)

Catalog >

d(Expr1, Var[, Order]) | Var=Value ⇒

value

d(Expr1, Var[, Order]) ⇒ value

d(List1, Var[, Order]) ⇒ list

d(Matrix1, Var[, Order]) ⇒ matrix

Except when using the first syntax, you

must store a numeric value in variable Var

before evaluating d(). Refer to the

examples.

d() can be used for calculating first and

second order derivative at a point

numerically, using auto differentiation

methods.

Order, if included, must be=1 or 2. The

default is 1.

Note: You can insert this function from the

keyboard by typing derivative(...).

Note: See also Firstderivative, page 5 or

Secondderivative, page 5.

Note: The d() algorithm has a limitation: it

works recursively through the unsimplified

expression, computing the numeric value of

the first derivative (and second, if

applicable) and the evaluation of each

subexpression, which may lead to an

unexpected result.

Consider the example on the right. The first

derivative of x•(x^2+x)^(1/3) at x=0 is equal

to 0. However, because the first derivative

of the subexpression (x^2+x)^(1/3) is

undefined at x=0, and this value is used to

calculate the derivative of the total

expression, d() reports the result as

undefined and displays a warning message.

If you encounter this limitation, verify the

solution graphically. You can also try using

centralDiff().

Symbols 185

186 Symbols

∫() (integral)

Catalog >

∫(Expr1, Var, Lower,Upper) ⇒ value

Returns the integral of Expr1 with respect

to the variable Var from Lower to Upper.

Can be used to calculate the definite

integral numerically, using the same

method as nInt().

Note: You can insert this function from the

keyboard by typing integral(...).

Note: See also nInt(), page 102, and

Definiteintegral template, page 6.

√() (square root)

/q keys

√(Value1) ⇒ value

√(List1) ⇒ list

Returns the square root of the argument.

For a list, returns the square roots of all the

elements in List1.

Note: You can insert this function from the

keyboard by typing sqrt(...)

Note: See also Square root template, page

Π() (prodSeq)

Catalog >

Π(Expr1, Var, Low, High) ⇒ expression

Note: You can insert this function from the

keyboard by typing prodSeq(...).

Evaluates Expr1 for each value of Var from

Low to High, and returns the product of the

results.

Note: See also Product template (Π), page

Π(Expr1, Var, Low, Low−1) ⇒ 1

Π(Expr1, Var, Low, High) ⇒ 1/Π(Expr1,

Var, High+1, Low−1) if High < Low−1

Π() (prodSeq)

Catalog >

The product formulas used are derived from

the following reference:

Ronald L. Graham, Donald E. Knuth, and

Oren Patashnik. Concrete Mathematics: A

Foundation for Computer Science.

Reading, Massachusetts: Addison-Wesley,

1994.

Σ() (sumSeq)

Catalog >

Σ(Expr1, Var, Low, High) ⇒ expression

Note: You can insert this function from the

keyboard by typing sumSeq(...).

Evaluates Expr1 for each value of Var from

Low to High, and returns the sum of the

results.

Note: See also Sum template, page 5.

Σ(Expr1, Var, Low, Low−1) ⇒ 0

Σ(Expr1, Var, Low, High) ⇒ μ

Σ(Expr1, Var, High+1, Low−1) if High <

Low−1

The summation formulas used are derived

from the following reference:

Ronald L. Graham, Donald E. Knuth, and

Oren Patashnik. Concrete Mathematics: A

Foundation for Computer Science.

Reading, Massachusetts: Addison-Wesley,

1994.

ΣInt()

Catalog >

ΣInt(NPmt1, NPmt2, N, I, PV ,[Pmt], [FV],

[PpY], [CpY], [PmtAt], [roundValue])

⇒ value

ΣInt(NPmt1,NPmt2,amortTable) ⇒ value

Symbols 187

188 Symbols

ΣInt()

Catalog >

Amortization function that calculates the

sum of the interest during a specified range

of payments.

NPmt1 and NPmt2 define the start and end

boundaries of the payment range.

N, I, PV, Pmt, FV, PpY, CpY, and PmtAt

are described in the table of TVM

arguments, page 162.

• If you omit Pmt, it defaults to

Pmt=tvmPmt

(N,I,PV,FV,PpY,CpY,PmtAt).

• If you omit FV, it defaults to FV=0.

• The defaults for PpY, CpY, and PmtAt

are the same as for the TVM functions.

roundValue specifies the number of

decimal places for rounding. Default=2.

ΣInt(NPmt1,NPmt2,amortTable) calculates

the sum of the interest based on

amortization table amortTable. The

amortTable argument must be a matrix in

the form described under amortTbl(), page

Note: See also ΣPrn(), below, and Bal(),

page 15.

ΣPrn()

Catalog >

ΣPrn(NPmt1, NPmt2, N, I, PV, [Pmt],

[FV], [PpY], [CpY], [PmtAt],

[roundValue]) ⇒ value

ΣPrn(NPmt1, NPmt2, amortTable) ⇒

value

Amortization function that calculates the

sum of the principal during a specified

range of payments.

NPmt1 and NPmt2 define the start and end

boundaries of the payment range.

N, I, PV, Pmt, FV, PpY, CpY, and PmtAt

are described in the table of TVM

arguments, page 162.

ΣPrn()

Catalog >

• If you omit Pmt, it defaults to

Pmt=tvmPmt

(N,I,PV,FV,PpY,CpY,PmtAt).

• If you omit FV, it defaults to FV=0.

• The defaults for PpY, CpY, and PmtAt

are the same as for the TVM functions.

roundValue specifies the number of

decimal places for rounding. Default=2.

ΣPrn(NPmt1,NPmt2,amortTable)

calculates the sum of the principal paid

based on amortization table amortTable.

The amortTable argument must be a

matrix in the form described under

amortTbl(), page 7.

Note: See also ΣInt(), above, and Bal(),

page 15.

# (indirection)

/k keys

# varNameString

Refers to the variable whose name is

varNameString. This lets you use strings to

create variable names from within a

function.

Creates or refers to the variable xyz .

Returns the value of the variable (r) whose

name is stored in variable s1.

E (scientific notation)

i key

mantissaEexponent

Enters a number in scientific notation. The

number is interpreted as

mantissa ×10

exponent

Hint: If you want to enter a power of 10

without causing a decimal value result, use

10^integer.

Symbols 189

190 Symbols

E (scientific notation)

i key

Note: You can insert this operator from the

computer keyboard by typing @E. for

example, type 2.3@E4 to enter 2.3E4.

(gradian)

¹ key

Expr1

⇒ expression

List1

⇒ list

Matrix1

⇒ matrix

This function gives you a way to specify a

gradian angle while in the Degree or Radian

mode.

In Radian angle mode, multiplies Expr1 by

π/200.

In Degree angle mode, multiplies Expr1 by

g/100.

In Gradian mode, returns Expr1 unchanged.

Note: You can insert this symbol from the

computer keyboard by typing @g.

In Degree, Gradian or Radian mode:

(radian)

¹ key

Value1

⇒ value

List1

⇒ list

Matrix1

⇒ matrix

This function gives you a way to specify a

radian angle while in Degree or Gradian

mode.

In Degree angle mode, multiplies the

argument by 180/π.

In Radian angle mode, returns the

argument unchanged.

In Gradian mode, multiplies the argument

by 200/π.

In Degree, Gradian or Radian angle mode:

(radian)

¹ key

Hint: Use

if you want to force radians in a

function definition regardless of the mode

that prevails when the function is used.

Note: You can insert this symbol from the

computer keyboard by typing @r.

° (degree)

¹ key

Value1° ⇒ value

List1° ⇒ list

Matrix1° ⇒ matrix

This function gives you a way to specify a

degree angle while in Gradian or Radian

mode.

In Radian angle mode, multiplies the

argument by π/180.

In Degree angle mode, returns the

argument unchanged.

In Gradian angle mode, multiplies the

argument by 10/9.

Note: You can insert this symbol from the

computer keyboard by typing @d.

In Degree, Gradian or Radian angle mode:

In Radian angle mode:

°, ', '' (degree/minute/second)

/k keys

dd°mm'ss.ss'' ⇒ expression

dd A positive or negative number

mm A non-negative number

ss.ss A non-negative number

Returns dd+(mm/60)+(ss.ss/3600).

This base-60 entry format lets you:

• Enter an angle in

degrees/minutes/seconds without regard

to the current angle mode.

• Enter time as hours/minutes/seconds.

Note: Follow ss.ss with two apostrophes

(''), not a quote symbol (").

In Degree angle mode:

Symbols 191

192 Symbols

∠ (angle)

/k keys

[Radius,∠ θ_Angle] ⇒ vector

(polar input)

[Radius,∠ θ_Angle,Z_Coordinate] ⇒

vector

(cylindrical input)

[Radius,∠ θ_Angle,∠ θ_Angle] ⇒ vector

(spherical input)

Returns coordinates as a vector depending

on the Vector Format mode setting:

rectangular, cylindrical, or spherical.

Note: You can insert this symbol from the

computer keyboard by typing@<.

In Radian mode and vector format set to:

rectangular

cylindrical

spherical

(Magnitude∠ Angle) ⇒ complexValue

(polar input)

Enters a complex value in (r∠ θ) polar

form. The Angle is interpreted according to

the current Angle mode setting.

In Radian angle mode and Rectangular

complex format:

_ (underscore as an empty element)

See “Empty (Void) Elements,”

page 212.

10^()

Catalog >

10^ (Value1) ⇒ value

10^ (List1) ⇒ list

Returns 10 raised to the power of the

argument.

For a list, returns 10 raised to the power of

the elements in List1.

10^()

Catalog >

10^(squareMatrix1) ⇒ squareMatrix

Returns 10 raised to the power of

squareMatrix1. This is not the same as

calculating 10 raised to the power of each

element. For information about the

calculation method, refer to cos().

squareMatrix1 must be diagonalizable. The

result always contains floating-point

numbers.

^⁻¹ (reciprocal)

Catalog >

Value1 ^⁻¹ ⇒ value

List1 ^⁻¹ ⇒ list

Returns the reciprocal of the argument.

For a list, returns the reciprocals of the

elements in List1.

squareMatrix1 ^⁻¹ ⇒ squareMatrix

Returns the inverse of squareMatrix1.

squareMatrix1 must be a non-singular

square matrix.

| (constraint operator)

/k keys

Expr | BooleanExpr1[and

BooleanExpr2]...

Expr | BooleanExpr1[orBooleanExpr2]...

The constraint (“|”) symbol serves as a

binary operator. The operand to the left of |

is an expression. The operand to the right of

| specifies one or more relations that are

intended to affect the simplification of the

expression. Multiple relations after | must

be joined by logical “and” or “or” operators.

The constraint operator provides three basic

types of functionality:

• Substitutions

• Interval constraints

Symbols 193

194 Symbols

| (constraint operator)

/k keys

• Exclusions

Substitutions are in the form of an equality,

such as x=3 or y=sin(x). To be most

effective, the left side should be a simple

variable. Expr | Variable = value will

substitute value for every occurrence of

Variable in Expr.

Interval constraints take the form of one or

more inequalities joined by logical “and” or

“or” operators. Interval constraints also

permit simplification that otherwise might

be invalid or not computable.

Exclusions use the “not equals” (/= or ≠)

relational operator to exclude a specific

value from consideration.

→ (store)

/h key

Value → Var

List → Var

Matrix → Var

Expr → Function(Param1,...)

List → Function(Param1,...)

Matrix → Function(Param1,...)

If the variable Var does not exist, creates it

and initializes it to Value, List, or Matrix.

If the variable Var already exists and is not

locked or protected, replaces its contents

with Value, List, or Matrix.

→ (store)

/h key

Note: You can insert this operator from the

keyboard by typing =: as a shortcut. For

example, type pi/4 =: myvar.

:= (assign)

/t keys

Var := Value

Var := List

Var := Matrix

Function(Param1,...) := Expr

Function(Param1,...) := List

Function(Param1,...) := Matrix

If variable Var does not exist, creates Var

and initializes it to Value, List, or Matrix.

If Var already exists and is not locked or

protected, replaces its contents with Value,

List, or Matrix.

/k keys

allowing you to annotate functions and

programs that you create.

end of the line, is the comment.

Note for entering the example: For

instructions on entering multi-line program

and function definitions, refer to the

Calculator section of your product

guidebook.

0b, 0h

0B keys, 0H keys

0b binaryNumber

0h hexadecimalNumber

In Dec base mode:

Symbols 195

196 Symbols

0b, 0h

0B keys, 0H keys

Denotes a binary or hexadecimal number,

respectively. To enter a binary or hex

number, you must enter the 0b or 0h prefix

regardless of the Base mode. Without a

prefix, a number is treated as decimal

(base10).

Results are displayed according to the Base

mode.

In Bin base mode:

In Hex base mode:

TI-Nspire™ CX II - Draw Commands

This is a supplemental document for the TI-Nspire™ Reference Guide and the TI-

Nspire™ CAS Reference Guide. All TI-Nspire™ CX II commands will be incorporated and

published in version 5.1 of the TI-Nspire™ Reference Guide and the TI-Nspire™ CAS

Reference Guide.

Graphics Programming

New commands have been added on TI-Nspire™ CX II Handhelds and TI-Nspire™

desktop applications for graphics programming.

The TI-Nspire™ CX II Handhelds will switch into this graphics mode while executing

graphics commands and switch back to the context in which the program was executed

after completion of the program.

The screen will display “Running…” in the top bar while the program is being executed.

It will show “Finished” when the program completes. Any key-press will transition the

system out of the graphics mode.

• The transition to graphics mode is triggered automatically when one of the Draw

(graphics) commands is encountered during execution of the TI Basic program.

• This transition will only happen when executing a program from calculator; in a

document or calculator in scratchpad.

• The transition out of graphics mode happens upon termination of the program.

• The graphics mode is only available on the TI-Nspire™ CX II Handhelds and the

desktop TI-Nspire™ CX II Handhelds view. This means it is not available in the

computer document view or PublishView (.tnsp) on the desktop nor on iOS.

- If a graphics command is encountered while executing a TI Basic program from

the incorrect context, an error message is displayed and the TI Basic program is

terminated.

Graphics Screen

The graphics screen will contain a header at the top of the screen that cannot be

written to by graphics commands.

The graphics screen drawing area will be cleared (color = 255,255,255) when the

graphics screen is initialized.

Graphics

Screen

Default

Height 212

Width 318

Color white: 255,255,255

TI-Nspire™ CX II - Draw Commands 197

198 TI-Nspire™ CX II - Draw Commands

Default View and Settings

• The status icons in the top bar (battery status, press-to-test status, network

indicator etc.) will not be visible while a graphics program is running.

• Default drawing color: Black (0,0,0)

• Default pen style - normal, smooth

- Thickness: 1 (thin), 2 (normal), 3 (thickest)

- Style: 1 (smooth), 2 (dotted), 3 (dashed)

• All drawing commands will use the current color and pen settings; either default

values or those which were set via TI-Basic commands.

• Text font is fixed and cannot be changed.

• Any output to the graphics screen will be drawn within a clipping window which is

the size of the graphics screen drawing area. Any drawn output that extends

outside of this clipped graphics screen drawing area will not be drawn. No error

message will be displayed.

• All x,y coordinates specified for drawing commands are defined such that 0,0 is at

the top left corner of the graphics screen drawing area.

- Exceptions:

- DrawText uses the coordinates as the bottom left corner of the bounding

box for the text.

- SetWindow uses the bottom left corner of the screen

• All parameters for the commands can be provided as expressions that evaluate to

a number which is then rounded to the nearest integer.

Graphics Screen Errors Messages

If the validation fails, an error message will display.

Error Message Description

View

Error

Syntax

If the syntax checker finds any syntax

errors, it displays an error message

and tries to position the cursor near

the first error so you can correct it.

Error

Too few arguments

The function or command is missing

one or more arguments

Error

Too many

arguments

The function or command contains

and excessive number of arguments

and cannot be evaluated.

Error

Invalid data type

An argument is of the wrong data

type.

Invalid Commands While in Graphics Mode

Some commands are not allowed once the program switches to graphics mode. If

these commands are encountered while in graphics mode and error will be displayed

and the program will be terminated.

Disallowed

Command

Error Message

Request Request cannot be executed in graphics mode

RequestStr RequestStr cannot be executed in graphics mode

Text Text cannot be executed in graphics mode

The commands that print text to the calculator - disp and dispAt - will be supported

commands in the graphics context. The text from these commands will be sent to the

Calculator screen (not on Graphics) and will be visible after the program exits and the

system switches back to the Calculator app

TI-Nspire™ CX II - Draw Commands 199

200 TI-Nspire™ CX II - Draw Commands

Clear

Catalog >

CXII

Clear x, y, width, height

Clears entire screen if no parameters are

specified.

If x, y, width and height are specified, the

rectangle defined by the parameters will be

cleared.

Clear

Clears entire screen

Clear 10,10,100,50

Clears a rectangle area with top

left corner on (10, 10) and with

width 100, height 50

DrawArc

Catalog >

CXII

DrawArc x, y, width, height, startAngle,

arcAngle

Draw an arc within the defined bounding

rectangle with the provided start and arc

angles.

x, y: upper left coordinate of bounding

rectangle

width, height: dimensions of bounding

rectangle

The "arc angle" defines the sweep of the

arc.

These parameters can be provided as

expressions that evaluate to a number which

is then rounded to the nearest integer.

DrawArc 20,20,100,100,0,90

DrawArc 50,50,100,100,0,180