Dyadic Scalar Functions

Classification of Dyadic Scalar Functions

Although they are listed alphabetically in this chapter, for convenient reference, the A+ dyadic scalar primitive functions can be grouped in five categories:

• the most common arithmetical functions: Add, Subtract, Multiply, Divide, Power;
• other computational functions: Residue, Log, Circle, Combine Symbols;
• selection functions: Max (greater of), Min (lesser of);
• comparison functions: Equal to, Not equal to, Less than, Less than or Equal to, Greater than, Greater than or Equal to;
• logical functions: And, Or.

Application, Conformability, and Result Shape

Common Error Reports

Multiple errors elicit but one report. Eight reports, including interrupt, are common to all dyadic primitive scalar functions, and each of these reports is issued only if none of the preceding ones apply:

• parse: this error class includes valence errors that result from three or more arguments in braces;
• value: an argument has no value;
• nondata: an argument is a function or some other nondata object;
• type: an argument is of an illicit type;
• rank: conformability rules are not satisfied and the ranks of the arguments differ;
• length: conformability rules are not satisfied because of a mismatch in a dimension of the arguments;
• wsfull: the workspace is currently not large enough for execution of the function; a bare left arrow (û), which dictates resumption of execution, causes the workspace to be enlarged if possible;
• interrupt (not an error): the user pressed c twice (once if A+ was started from a shell) while holding the Control key down.

Except where noted, the omission of the left argument results not in a valence error report, but in the invocation of a monadic function or an operator that shares the function symbol.

Function Definitions

Add y+x

The arguments and result are simple numeric arrays. For two nonempty arguments, the result is integer if both arguments are integer and all result elements lie inside the range of integer representation, and floating point otherwise. If exactly one argument is empty, the result is floating point if that argument is floating point, and otherwise its type is the type of the nonempty argument. If both are empty, then if one is floating point and the other integer the result is floating point, and otherwise its type is the type of the right argument.

y plus x. The result may include Inf or ¢Inf.

     ¢1 0 1 1e308+10 20 30 1e308
 9 20 31 Inf

And y^x

The arguments are simple arrays of restricted whole numbers. The result is an integer array.

Circle yÏx

The arguments and result are simple numeric arrays. Additionally, the left argument can also be symbolic. The result is always in floating point.

If none of the common errors listed above are reported, then:

• a domain error is reported if the absolute value of an element of the left argument is equal to or greater than 8, and also if the absolute value of the right argument is less than 1 for left argument -4 or greater than 1 for left arguments of 0, -1, -2, and -7.

   1 1 3 ¢3 Ï Ïß2 4 2 0  ã sin(pi/2), sin(pi/4), tan(pi/2), arctan(Inf)
 1 0.7071067812 1.633177873e+16 1.570796327

Combine Symbols yÖx

The arguments and result are simple arrays of symbols.

This function takes context names and unqualified names and produces qualified names. More generally, for each scalar pair y,x: if, as displayed, x has a dot (period) in it, then the value of yÖx is x, and y is ignored; otherwise, the result is the symbol that is displayed as y, followed by a dot, followed by x without its backquote.

     `c Ö `x `d.y `.z
 `c.x `d.y `.z
     `b.c `a Ö `x `y
 `b.c.x `a.y

Divide yßx

The arguments and result are simple numeric arrays. The result is always floating point.

y divided by x. Division of a positive number by zero yields Inf, a unique scalar, and division of a negative number by zero yields ¢Inf.

Equal to y=x

The arguments can be of any type. The result is boolean (integer type with values 0 and 1).

Greater than y>x

The arguments are simple numeric, character, or symbol arrays. The result is boolean (integer type with values 0 and 1).

Greater than or Equal to y¦x

The arguments are simple numeric, character, or symbol arrays. The result is boolean (integer type with values 0 and 1).

Less than y<x

The arguments are simple numeric, character, or symbol arrays. The result is boolean (integer type with values 0 and 1).

Less than or Equal to y¤x

The arguments are simple numeric, character, or symbol arrays. The result is boolean (integer type with values 0 and 1).

Log yðx

The arguments and result are simple numeric arrays. The result is always in floating point.

The logarithm of x to the base y.

     10ð.1 1 10 100 1000 1234.5 0
 ¢1 0 1 2 3 3.091491094 ¢Inf

Max yÓx

The arguments and result are simple numeric arrays. For two nonempty arguments, the result is integer if both arguments are integer, and floating point otherwise. If exactly one argument is empty, the result is floating point if that argument is floating point, and otherwise its type is the type of the nonempty argument. If both are empty, then if one is floating point and the other integer the result is floating point, and otherwise its type is the type of the right argument.

The greater of y and x. When this function is used in Reduction (Ó/), the name Max is appropriate.

     0 Ó 3 .5 ¢1 5 ¢.1
 3 .5 0 5 0

Min yÄx

The arguments and result are simple numeric arrays. For two nonempty arguments, the result is integer if both arguments are integer, and floating point otherwise. If exactly one argument is empty, the result is floating point if that argument is floating point, and otherwise its type is the type of the nonempty argument. If both are empty, then if one is floating point and the other integer the result is floating point, and otherwise its type is the type of the right argument.

The lesser of y and x. When this function is used in Reduction (Ä/), the name Min is appropriate.

     99.5 100 91.1 112 99 Ä 100
 99.5 100 91.1 100 99

Multiply y«x

The arguments and result are simple numeric arrays. For two nonempty arguments, the result is integer if both arguments are integer and all result elements lie inside the range of integer representation, and floating point otherwise. If exactly one argument is empty, the result is floating point if that argument is floating point, and otherwise its type is the type of the nonempty argument. If both are empty, then if one is floating point and the other integer the result is floating point, and otherwise its type is the type of the right argument.

y times x.

     10«0 1 2 3 1e308
 0 10 20 30 Inf

Not equal to y¨x

The arguments can be of any type. The result is boolean (integer type with values 0 and 1).

Or y©x

The arguments are simple numeric arrays of restricted whole numbers. The result is an integer array.

Power y*x

The arguments and result are simple numeric arrays. The result is always floating point.

y to the power x.  10*2 is exactly equal to 1e2 but in general there is a very slight (tolerable) difference between 10*N and 1eN, because logarithms are used except in this special case, whereas 1eN is exact.

     2*0 .5 1 2 3 4 5 6 7 8 1025
 1 1.414213562 2 4 8 16 32 64 128 256 Inf

Residue y|x

The arguments and result are simple numeric arrays. For two nonempty arguments, the result is integer if both arguments are integer, and floating point otherwise. If exactly one argument is empty, the result is floating point if that argument is floating point, and otherwise its type is the type of the nonempty argument. If both are empty, then if one is floating point and the other integer the result is floating point, and otherwise its type is the type of the right argument.

Subtract y-x

The arguments and result are simple numeric arrays. For two nonempty arguments, the result is integer if both arguments are integer and all result elements lie inside the range of integer representation, and floating point otherwise. If exactly one argument is empty, the result is floating point if that argument is floating point, and otherwise its type is the type of the nonempty argument. If both are empty, then if one is floating point and the other integer the result is floating point, and otherwise its type is the type of the right argument.

y minus x.