You are here: TI‑Nspire™ CX CAS Reference Guide > Symbols

Symbols

+ (add)	+ key
Expr1 + Expr2 ⇒ expression 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.
Expr + List1 ⇒ list List1 + Expr ⇒ list Returns a list containing the sums of Expr and each element in List1.
Expr + Matrix1 ⇒ matrix Matrix1 + Expr ⇒ matrix Returns a matrix with Expr 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
Expr1 − Expr2 ⇒ expression Returns Expr1 minus Expr2.
List1 −List2⇒ list Matrix1 −Matrix2 ⇒ matrix 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.
Expr − List1 ⇒ list List1 − Expr ⇒ list Subtracts each List1 element from Expr or subtracts Expr from each List1 element, and returns a list of the results.
Expr − Matrix1 ⇒ matrix Matrix1 − Expr ⇒ matrix Expr − Matrix1 returns a matrix of Expr times the identity matrix minus Matrix1. Matrix1 must be square. Matrix1 − Expr returns a matrix of Expr 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
Expr1•Expr2 ⇒ expression 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.
Expr •List1 ⇒ list List1•Expr ⇒ list Returns a list containing the products of Expr and each element in List1.
Expr •Matrix1 ⇒ matrix Matrix1•Expr ⇒ matrix Returns a matrix containing the products of Expr and each element in Matrix1. Note: Use .•(dot multiply) to multiply an expression by each element.

⁄ (divide)	p key
Expr1 ⁄ Expr2 ⇒ expression Returns the quotient of Expr1 divided by Expr2. Note: See also Fraction template, here.
List1 ⁄ List2 ⇒ list Returns a list containing the quotients of List1 divided by List2. Dimensions of the lists must be equal.
Expr ⁄ List1 ⇒ list List1 ⁄ Expr ⇒ list Returns a list containing the quotients of Expr divided by List1 orList1 divided by Expr.
Matrix1 ⁄ Expr ⇒ matrix Returns a matrix containing the quotients of Matrix1 ⁄ Expr. Matrix1 ⁄ Value ⇒ matrix Note: Use . ⁄ (dot divide) to divide an expression by each element.

^ (power)	l key
Expr1 ^ Expr2⇒ expression List1 ^ List2 ⇒ list Returns the first argument raised to the power of the second argument. Note: See also Exponent template, here. 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.
Expr ^ List1 ⇒ list Returns Expr raised to the power of the elements in List1.
List1 ^ Expr ⇒ list Returns the elements in List1 raised to the power of Expr.
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.

x2 (square)	q key
Expr12⇒ expression Returns the square of the argument. List12 ⇒ list Returns a list containing the squares of the elements in List1. squareMatrix12 ⇒ 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.

x2 (square)

q key

Expr12⇒ expression

Returns the square of the argument.

List12 ⇒ list

Returns a list containing the squares of the elements in List1.

squareMatrix12 ⇒ 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 Expr .+ Matrix1⇒ matrix Matrix1.+Matrix2 returns a matrix that is the sum of each pair of corresponding elements in Matrix1 and Matrix2. Expr .+ Matrix1 returns a matrix that is the sum of Expr and each element in Matrix1.

.+ (dot add)

^+ keys

Matrix1 .+ Matrix2 ⇒ matrix

Expr .+ Matrix1⇒ matrix

Matrix1.+Matrix2 returns a matrix that is the sum of each pair of corresponding elements in Matrix1 and Matrix2.

Expr .+ Matrix1 returns a matrix that is the sum of Expr and each element in Matrix1.

.⁻ (dot subt.)	^- keys
Matrix1 .− Matrix2⇒ matrix Expr .− Matrix1 ⇒matrix Matrix1.− Matrix2 returns a matrix that is the difference between each pair of corresponding elements in Matrix1 and Matrix2. Expr .− Matrix1 returns a matrix that is the difference of Expr and each element in Matrix1. .

.⁻ (dot subt.)

^- keys

Matrix1 .− Matrix2⇒ matrix

Expr .− Matrix1 ⇒matrix

Matrix1.− Matrix2 returns a matrix that is the difference between each pair of corresponding elements in Matrix1 and Matrix2.

Expr .− Matrix1 returns a matrix that is the difference of Expr and each element in Matrix1.

.•(dot mult.)	^r keys
Matrix1 .• Matrix2⇒ matrix Expr .• Matrix1 ⇒ matrix Matrix1.• Matrix2 returns a matrix that is the product of each pair of corresponding elements in Matrix1 and Matrix2. Expr .• Matrix1 returns a matrix containing the products of Expr and each element in Matrix1.

.•(dot mult.)

^r keys

Matrix1 .• Matrix2⇒ matrix

Expr .• Matrix1 ⇒ matrix

Matrix1.• Matrix2 returns a matrix that is the product of each pair of corresponding elements in Matrix1 and Matrix2.

Expr .• Matrix1 returns a matrix containing the products of Expr and each element in Matrix1.

. ⁄ (dot divide)	^p keys
Matrix1. ⁄ Matrix2 ⇒ matrix Expr . ⁄ Matrix1⇒ matrix Matrix1 . ⁄ Matrix2 returns a matrix that is the quotient of each pair of corresponding elements in Matrix1 and Matrix2. Expr . ⁄ Matrix1 returns a matrix that is the quotient of Expr and each element in Matrix1.

. ⁄ (dot divide)

^p keys

Matrix1. ⁄ Matrix2 ⇒ matrix

Expr . ⁄ Matrix1⇒ matrix

Matrix1 . ⁄ Matrix2 returns a matrix that is the quotient of each pair of corresponding elements in Matrix1 and Matrix2.

Expr . ⁄ Matrix1 returns a matrix that is the quotient of Expr and each element in Matrix1.

.^ (dot power)	^l keys
Matrix1 .^ Matrix2 ⇒ matrix Expr . ^ Matrix1⇒ matrix Matrix1.^ Matrix2 returns a matrix where each element in Matrix2 is the exponent for the corresponding element in Matrix1. Expr .^ Matrix1 returns a matrix where each element in Matrix1 is the exponent for Expr.

.^ (dot power)

^l keys

Matrix1 .^ Matrix2 ⇒ matrix

Expr . ^ Matrix1⇒ matrix

Matrix1.^ Matrix2 returns a matrix where each element in Matrix2 is the exponent for the corresponding element in Matrix1.

Expr .^ Matrix1 returns a matrix where each element in Matrix1 is the exponent for Expr.

− (negate)	v key
− Expr1 ⇒ expression −List1 ⇒ list −Matrix1 ⇒ matrix 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 and then use 7 and 8 to move the cursor.

− (negate)

v key

− Expr1 ⇒ expression

−List1 ⇒ list

−Matrix1 ⇒ matrix

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 and then use 7 and 8 to move the cursor.

% (percent)	/k keys
Expr1% ⇒ expression List1% ⇒ list Matrix1% ⇒ matrix Returns For a list or matrix, returns a list or matrix with each element divided by 100.	Note: To force an approximate result, Handheld: Press / ·. Windows®: Press Ctrl+Enter. Macintosh®: Press “+Enter. iPad®: Hold enter, and select .

% (percent)

/k keys

Expr1% ⇒ expression

List1% ⇒ list

Matrix1% ⇒ matrix

Returns

For a list or matrix, returns a list or matrix with each element divided by 100.

Note: To force an approximate result,

Handheld: Press / ·.
Windows®: Press Ctrl+Enter.
Macintosh®: Press “+Enter.
iPad®: Hold enter, and select .

= (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. Note for entering the example: For instructions on entering multi-line program and function definitions, refer to the Calculator section of your product guidebook.	Example function that uses math test symbols: =, ≠, <, ≤, >, ≥ Result of graphing g(x)

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

Note for entering the example: For instructions on entering multi-line program and function definitions, refer to the Calculator section of your product guidebook.

Example function that uses math test symbols: =, ≠, <, ≤, >, ≥

Result of graphing g(x)

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

≠ (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. Anything else returns a simplified form of the equation. For lists and matrices, returns comparisons element by element.	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.

Anything else returns a simplified form of the equation.

For lists and matrices, returns comparisons element by element.

See “=” (equal) example.

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

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

≥ (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 =>

⇒ (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 =>

⇔ (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 <=>

⇔ (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
Expr1! ⇒ expression 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.

! (factorial)

º key

Expr1! ⇒ expression

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.

& (append)

/k keys

String1 & String2 ⇒ string

Returns a text string that is String2 appended to String1.

d() (derivative)

Catalog >

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

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

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

Returns the first derivative of the first argument with respect to variable Var.

Order, if included, must be an integer. If the order is less than zero, the result will be an anti-derivative.

Note: You can insert this function from the keyboard by typing derivative(...).

d() does not follow the normal evaluation mechanism of fully simplifying its arguments and then applying the function definition to these fully simplified arguments. Instead, d() performs the following steps:

Simplify the second argument only to the extent that it does not lead to a non-variable.

Simplify the first argument only to the extent that it does recall any stored value for the variable determined by step 1.

Determine the symbolic derivative of the result of step 2 with respect to the variable from step 1.

If the variable from step 1 has a stored value or a value specified by the constraint (“|”) operator, substitute that value into the result from step 3.

Note: See also First derivative, here; Second derivative, here; or Nth derivative, here.

∫() (integral)	Catalog >
∫(Expr1, Var[,Lower,Upper]) ⇒ expression ∫(Expr1,Var[,Constant]) ⇒ expression Returns the integral of Expr1 with respect to the variable Var from Lower to Upper. Note: See also Definite or Indefinite integral template, here. Note: You can insert this function from the keyboard by typing integral(...).
If Lower and Upper are omitted, returns an anti-derivative. A symbolic constant of integration is omitted unless you provide the Constant argument.
Equally valid anti-derivatives might differ by a numeric constant. Such a constant might be disguised—particularly when an anti-derivative contains logarithms or inverse trigonometric functions. Moreover, piecewise constant expressions are sometimes added to make an anti-derivative valid over a larger interval than the usual formula.
∫() returns itself for pieces of Expr1 that it cannot determine as an explicit finite combination of its built-in functions and operators. When you provide Lower and Upper, an attempt is made to locate any discontinuities or discontinuous derivatives in the interval Lower < Var < Upper and to subdivide the interval at those places.
For the Auto setting of the Auto or Approximate mode, numerical integration is used where applicable when an anti-derivative or a limit cannot be determined.
For the Approximate setting, numerical integration is tried first, if applicable. Anti-derivatives are sought only where such numerical integration is inapplicable or fails.	Note: To force an approximate result, Handheld: Press / ·. Windows®: Press Ctrl+Enter. Macintosh®: Press “+Enter. iPad®: Hold enter, and select .
∫() can be nested to do multiple integrals. Integration limits can depend on integration variables outside them. Note: See also nInt(), here.

√() (square root)	/q keys
√(Expr1) ⇒ expression √(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, here.

√() (square root)

/q keys

√(Expr1) ⇒ expression

√(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, here.

Π() (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 (Π), here.
Π(Expr1, Var, Low, Low−1) ⇒ 1 Π(Expr1, Var, Low, High) ⇒ 1/Π(Expr1, Var, High+1, Low−1) if High < Low−1 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.

Π() (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 (Π), here.

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

Π(Expr1, Var, Low, High) ⇒ 1/Π(Expr1, Var, High+1, Low−1) if High < Low−1

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, here.
Σ(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.

Σ() (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, here.

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

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

•

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

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

Σ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, here.

•

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

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

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

# (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 × 10exponent. Hint: If you want to enter a power of 10 without causing a decimal value result, use 10^integer. Note: You can insert this operator from the computer keyboard by typing @E. for example, type 2.3@E4 to enter 2.3E4.

E (scientific notation)

i key

mantissaEexponent

Enters a number in scientific notation. The number is interpreted as mantissa × 10exponent.

Hint: If you want to enter a power of 10 without causing a decimal value result, use 10^integer.

Note: You can insert this operator from the computer keyboard by typing @E. for example, type 2.3@E4 to enter 2.3E4.

g (gradian)	¹ key
Expr1g ⇒ expression List1g ⇒ list Matrix1g ⇒ 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:

g (gradian)

¹ key

Expr1g ⇒ expression

List1g ⇒ list

Matrix1g ⇒ 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:

r(radian)	¹ key
Expr1r ⇒expression List1r ⇒ list Matrix1r ⇒ 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/π. Hint: Use r 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.	In Degree, Gradian or Radian angle mode:

r(radian)

¹ key

Expr1r ⇒expression

List1r ⇒ list

Matrix1r ⇒ 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/π.

Hint: Use r 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.

In Degree, Gradian or Radian angle mode:

° (degree)	¹ key
Expr1° ⇒expression 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: Note: To force an approximate result, Handheld: Press / ·. Windows®: Press Ctrl+Enter. Macintosh®: Press “+Enter. iPad®: Hold enter, and select .

° (degree)

¹ key

Expr1° ⇒expression

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:

Note: To force an approximate result,

Handheld: Press / ·.
Windows®: Press Ctrl+Enter.
Macintosh®: Press “+Enter.
iPad®: Hold enter, and select .

°, ', '' (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:

∠ (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: Note: To force an approximate result, Handheld: Press / ·. Windows®: Press Ctrl+Enter. Macintosh®: Press “+Enter. iPad®: Hold enter, and select .

∠ (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:

Note: To force an approximate result,

Handheld: Press / ·.
Windows®: Press Ctrl+Enter.
Macintosh®: Press “+Enter.
iPad®: Hold enter, and select .

' (prime)	º key
variable ' variable ' ' Enters a prime symbol in a differential equation. A single prime symbol denotes a 1st-order differential equation, two prime symbols denote a 2nd-order, and so on.

' (prime)

º key

variable '
variable ' '

Enters a prime symbol in a differential equation. A single prime symbol denotes a 1st-order differential equation, two prime symbols denote a 2nd-order, and so on.

_ (underscore as an empty element)	See “Empty (Void) Elements,” here.

_ (underscore as unit designator)

/_ keys

Expr_Unit

Designates the units for an Expr. All unit names must begin with an underscore.

You can use pre-defined units or create your own units. For a list of pre-defined units, open the Catalog and display the Unit Conversions tab. You can select unit names from the Catalog or type the unit names directly.

Note: You can find the conversion symbol, ►, in the Catalog. Click , and then click Math Operators.

Variable_

When Variable has no value, it is treated as though it represents a complex number. By default, without the _ , the variable is treated as real.

If Variable has a value, the _ is ignored and Variable retains its original data type.

Note: You can store a complex number to a variable without
using _ . However, for best results in calculations such as cSolve() and cZeros(), the _ is recommended.

Assuming z is undefined:

► (convert)

/k keys

Expr_Unit1►_Unit2 ⇒ Expr_Unit2

Converts an expression from one unit to another.

The _ underscore character designates the units. The units must be in the same category, such as Length or Area.

For a list of pre-defined units, open the Catalog and display the Unit Conversions tab:

•

You can select a unit name from the list.

•

You can select the conversion operator, ►, from the top of the list.

You can also type unit names manually. To type “_” when typing unit names on the handheld, press /_.

Note: To convert temperature units, use tmpCnv() and ΔtmpCnv(). The ► conversion operator does not handle temperature units.

10^()

Catalog >

10^ (Expr1) ⇒ expression

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

Expr1 ^⁻¹ ⇒ expression

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

•

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. They are used primarily to exclude an exact solution when using cSolve(), cZeros(), fMax(), fMin(), solve(), zeros(), and so on.

→ (store)

/h key

Expr → 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 Expr, List, or Matrix.

If the variable Var already exists and is not locked or protected, replaces its contents with Expr, List, or Matrix.

Hint: If you plan to do symbolic computations using undefined variables, avoid storing anything into commonly used, one-letter variables such as a, b, c, x, y, z, and so on.

Note: You can insert this operator from the keyboard by typing =: as a shortcut. For example, type pi/4 =: myvar.

:= (assign)

/t keys

Var := Expr

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 Expr, List, or Matrix.

If Var already exists and is not locked or protected, replaces its contents with Expr, List, or Matrix.

Hint: If you plan to do symbolic computations using undefined variables, avoid storing anything into commonly used, one-letter variables such as a, b, c, x, y, z, and so on.

/k keys

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

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 Dec base mode:

In Bin base mode:

In Hex base mode: