Online Help

The procedures andmap, ormap, and xormap determine whether a predicate p returns true for all, some, or an odd number of operands respectively of an expression expr.

For a table , Vector , Matrix , or Array , p is applied to each entry.

If expr is atomic, andmap(p, expr, ...), ormap(p, expr, ...), and xormap(p, expr, ...) are equivalent to p(expr, ... ).

In general, andmap(p, expr, ...) returns true if p(opnd, ...) is true for all operands opnd of expr, returns false if any call to p returns false, and returns FAIL when calls to p lead to at least one FAIL result and no false results.

Similarly, ormap(p, expr, ...) returns false if p(opnd, ...) is false for all operands opnd of expr, true when any call to p returns true, and FAIL when calls to p lead to at least one FAIL result and no true results.

Invoking xormap(p, expr, ...) returns true if p(opnd, ...) is true for an odd number of operands opnd of expr and all other calls to p yield false. If any call to p returns FAIL, then xormap returns FAIL.

Each of andmap, ormap, and xormap have short-circuit ("McCarthy") semantics, which means that an answer is returned as soon as it cannot change. The predicate only evaluates the operands of the expression expr until the result can be determined (false for andmap, true for ormap, and FAIL for xormap). The order in which the operands are examined, and thus which are examined, is not specified. You should not rely on side effects of the predicate p.

Since strings are atomic expressions in Maple, you cannot map a procedure over a string using andmap, ormap, or xormap. However, the StringTools package contains the exports AndMap and OrMap that provide this functionality.

The andmap and ormap commands are thread safe as of Maple 15, provided that evaluating the expression p is thread safe.

The xormap command is thread safe as of Maple 2021, provided that evaluating the expression p is thread safe.

For more information on thread safety, see index/threadsafe .

$\mathrm{andmap}\left(\mathrm{type}\,\left[1\,2\,3\,4\,5\right]\,'\mathrm{integer}'\right)$

$\mathrm{true}$

$\mathrm{ormap}\left(\mathrm{type}\,\left[1\,2\,3\,4\,5\right]\,'\mathrm{integer}'\right)$

$\mathrm{true}$

$\mathrm{xormap}\left(\mathrm{type}\,\left[1\,2\,3\,4\,5\right]\,'\mathrm{integer}'\right)$

$\mathrm{true}$

$\mathrm{andmap}\left(\mathrm{type}\,\left[1\,2\,3\,4\,5\right]\,'\mathrm{even}'\right)$

$\mathrm{false}$

$\mathrm{ormap}\left(\mathrm{type}\,\left[1\,2\,3\,4\,5\right]\,'\mathrm{even}'\right)$

$\mathrm{true}$

$\mathrm{xormap}\left(\mathrm{type}\,\left[1\,2\,3\,4\,5\right]\,'\mathrm{even}'\right)$

$\mathrm{false}$

$\mathrm{andmap}\left(\mathrm{isprime}\,\left[2\,3\,5\,7\right]\right)$

$\mathrm{true}$

$\mathrm{andmap}\left(\mathrm{isprime}\,\left[2\,3\,5\,8\right]\right)$

$\mathrm{false}$

$\mathrm{ormap}\left(\mathrm{isprime}\,\left\{2\,3\,5\,8\right\}\right)$

$\mathrm{true}$

$t≔\mathrm{table}\left(\left[a=1\,b=2\,c=3\right]\right)\:$

$\mathrm{andmap}\left(\mathrm{type}\,\mathrm{eval}\left(t\,1\right)\,'\mathrm{integer}'\right)$

$\mathrm{true}$

$\mathrm{andmap}\left(\mathrm{type}\,\mathrm{eval}\left(t\,1\right)\,'\mathrm{even}'\right)$

$\mathrm{false}$

$\mathrm{ormap}\left(\mathrm{type}\,\mathrm{eval}\left(t\,1\right)\,'\mathrm{even}'\right)$

$\mathrm{true}$

$e≔\mathrm{expand}\left(\mathrm{Int}\left(\mathrm{randpoly}\left(x\right)\,x\right)\right)$

$e≔-7\int x^5\ⅆx+22\int x^4\ⅆx-55\int x^3\ⅆx-94\int x^2\ⅆx+87\int x\ⅆx-56\int 1\ⅆx$

$\mathrm{andmap}\left(\mathrm{hastype}\,e\,'\mathrm{specfunc}\left(\mathrm{anything}\,\mathrm{Int}\right)'\right)$

$\mathrm{true}$

RecordSlots := proc( r::record )
if not type( [ args[ 2 .. nargs ] ], 'list( symbol )' ) then
error "arguments after the first must be of type `symbol'"
end if;
andmap( e -> member( cat( e ), r, e ), [ args[ 2 .. nargs ] ] )
end proc:

$r≔\mathrm{Record}\left('a'=2\,'b'=3\,'c'=\mathrm{Array}\left(1..5\right)\right)$

$r≔\mathrm{Record}\left(a=2\,b=3\,c=\left[\begin{array}{ccccc}0& 0& 0& 0& 0\end{array}\right]\right)$

$\mathrm{RecordSlots}\left(r\,'a'\,'b'\,'c'\right)$

$\mathrm{true}$

$a,b,c$

$2,3,\left[\begin{array}{ccccc}0& 0& 0& 0& 0\end{array}\right]$

$\mathrm{andmap}\left(a\mapsto \mathrm{`if`}\left(a<0\&comma;\mathrm{FAIL}\&comma;a\mathbf{mod}7=0\right)\&comma;\left[7\&comma;14\right]\right)$

$\mathrm{true}$

$\mathrm{andmap}\left(a\mapsto \mathrm{`if`}\left(a<0\&comma;\mathrm{FAIL}\&comma;a\mathbf{mod}7=0\right)\&comma;\left[7\&comma;14\&comma;-7\right]\right)$

$\mathrm{FAIL}$

$\mathrm{andmap}\left(a\mapsto \mathrm{`if`}\left(a<0\&comma;\mathrm{FAIL}\&comma;a\mathbf{mod}7=0\right)\&comma;\left[7\&comma;14\&comma;-7\&comma;3\right]\right)$

$\mathrm{false}$

$\mathrm{ormap}\left(a\mapsto \mathrm{`if`}\left(a<0\&comma;\mathrm{FAIL}\&comma;a\mathbf{mod}7=0\right)\&comma;\left[7\&comma;14\&comma;-7\right]\right)$

$\mathrm{true}$

$\mathrm{ormap}\left(a\mapsto \mathrm{`if`}\left(a<0\&comma;\mathrm{FAIL}\&comma;a\mathbf{mod}7=0\right)\&comma;\left[1\&comma;3\right]\right)$

$\mathrm{false}$

$\mathrm{ormap}\left(a\mapsto \mathrm{`if`}\left(a<0\&comma;\mathrm{FAIL}\&comma;a\mathbf{mod}7=0\right)\&comma;\left[1\&comma;3\&comma;-5\right]\right)$

$\mathrm{FAIL}$

$\mathrm{xormap}\left(a\mapsto \mathrm{`if`}\left(a<0\&comma;\mathrm{FAIL}\&comma;a\mathbf{mod}7=0\right)\&comma;\left[7\&comma;14\&comma;-7\right]\right)$

$\mathrm{FAIL}$

$\mathrm{xormap}\left(a\mapsto \mathrm{`if`}\left(a<0\&comma;\mathrm{FAIL}\&comma;a\mathbf{mod}7=0\right)\&comma;\left[1\&comma;3\right]\right)$

$\mathrm{false}$

$\mathrm{xormap}\left(a\mapsto \mathrm{`if`}\left(a<0\&comma;\mathrm{FAIL}\&comma;a\mathbf{mod}7=0\right)\&comma;\left[1\&comma;3\&comma;7\right]\right)$

$\mathrm{true}$

$\mathrm{xormap}\left(a\mapsto \mathrm{`if`}\left(a<0\&comma;\mathrm{FAIL}\&comma;a\mathbf{mod}7=0\right)\&comma;\left[1\&comma;3\&comma;7\&comma;-5\right]\right)$

$\mathrm{FAIL}$

The andmap and ormap commands were updated in Maple 2017.

The xormap command was introduced in Maple 2021.

For more information on Maple 2021 changes, see Updates in Maple 2021 .