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

x2 (square)	q key
Value12⇒ value 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

Value12⇒ value

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

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

− Value1 ⇒ value

−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
Value1% ⇒ value List1% ⇒ list Matrix1% ⇒ matrix Returns For a list or matrix, returns a list or matrix with each element divided by 100.

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

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

& (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, here or Second derivative, here.
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().

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, here or Second derivative, here.

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

∫() (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(), here, and Definiteintegral template, here.

∫() (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(), here, and Definiteintegral template, here.

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

√() (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, 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)	1 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)

1 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)	1 key
Value1r ⇒value 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)

1 key

Value1r ⇒value

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

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

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

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

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

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

^-1 (reciprocal)	Catalog >
Value1 ^-1 ⇒ value List1 ^-1 ⇒ list Returns the reciprocal of the argument. For a list, returns the reciprocals of the elements in List1.
squareMatrix1 ^-1 ⇒ squareMatrix Returns the inverse of squareMatrix1. squareMatrix1 must be a non-singular square matrix.

^-1 (reciprocal)

Catalog >

Value1 ^-1 ⇒ value

List1 ^-1 ⇒ list

Returns the reciprocal of the argument.

For a list, returns the reciprocals of the elements in List1.

squareMatrix1 ^-1 ⇒ 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.

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

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

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: