andmap - Maple Programming Help

andmap

determine whether a predicate is true of all operands of an expression

ormap

determine whether a predicate is true of some operands of an expression

 Calling Sequence andmap(p, expr, ...) ormap(p, expr, ...)

Parameters

 p - predicate returning either true or false expr - expression ... - (optional) other arguments to pass to p

Description

 • The procedures andmap and ormap determine whether a predicate p returns true or false for all or some operands of an expression expr.
 • If expr is atomic, both andmap(p, expr, ...) and ormap(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, and returns false otherwise.
 • Similarly, ormap(p, expr, ...) returns false if p(opnd, ...) is false for all operands opnd of expr, and returns true otherwise.
 • Both andmap and ormap have short-circuit ("McCarthy") semantics, which means that an answer is returned as soon as it can be determined. The predicate only evaluates at the operands of the expression expr until the result can be determined. The order in which the operands are examined is not specified. You should not rely on side effects of the predicate p.
 • For a table or array, p is applied to each entry of the table or array.
 • Since strings are atomic expressions in Maple, you cannot map a procedure over a string by using andmap and ormap. 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.

Examples

 > $\mathrm{andmap}\left(\mathrm{type},\left[1,2,3,4,5\right],'\mathrm{integer}'\right)$
 ${\mathrm{true}}$ (1)
 > $\mathrm{ormap}\left(\mathrm{type},\left[1,2,3,4,5\right],'\mathrm{integer}'\right)$
 ${\mathrm{true}}$ (2)
 > $\mathrm{andmap}\left(\mathrm{type},\left[1,2,3,4,5\right],'\mathrm{even}'\right)$
 ${\mathrm{false}}$ (3)
 > $\mathrm{ormap}\left(\mathrm{type},\left[1,2,3,4,5\right],'\mathrm{even}'\right)$
 ${\mathrm{true}}$ (4)
 > $\mathrm{andmap}\left(\mathrm{isprime},\left[2,3,5,7\right]\right)$
 ${\mathrm{true}}$ (5)
 > $\mathrm{andmap}\left(\mathrm{isprime},\left[2,3,5,8\right]\right)$
 ${\mathrm{false}}$ (6)
 > $\mathrm{ormap}\left(\mathrm{isprime},\left\{2,3,5,8\right\}\right)$
 ${\mathrm{true}}$ (7)
 > $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}}$ (8)
 > $\mathrm{andmap}\left(\mathrm{type},\mathrm{eval}\left(t,1\right),'\mathrm{even}'\right)$
 ${\mathrm{false}}$ (9)
 > $\mathrm{ormap}\left(\mathrm{type},\mathrm{eval}\left(t,1\right),'\mathrm{even}'\right)$
 ${\mathrm{true}}$ (10)
 > $e≔\mathrm{expand}\left({∫}\mathrm{randpoly}\left(x\right)\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}{ⅆ}x\right)$
 ${e}{:=}{-}{7}{}\left({∫}{{x}}^{{5}}\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}{ⅆ}{x}\right){+}{22}{}\left({∫}{{x}}^{{4}}\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}{ⅆ}{x}\right){-}{55}{}\left({∫}{{x}}^{{3}}\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}{ⅆ}{x}\right){-}{94}{}\left({∫}{{x}}^{{2}}\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}{ⅆ}{x}\right){+}{87}{}\left({∫}{x}\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}{ⅆ}{x}\right){-}{56}{}\left({∫}{1}\phantom{\rule[-0.0ex]{0.3em}{0.0ex}}{ⅆ}{x}\right)$ (11)
 > $\mathrm{andmap}\left(\mathrm{hastype},e,'\mathrm{specfunc}\left(\mathrm{anything},\mathrm{Int}\right)'\right)$
 ${\mathrm{true}}$ (12)

This examples illustrates a technique for quickly destructuring a record.

 > 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)$ (13)
 > $\mathrm{RecordSlots}\left(r,'a','b','c'\right)$
 ${\mathrm{true}}$ (14)
 > $a,b,c$
 ${2}{,}{3}{,}\left[\begin{array}{ccccc}{0}& {0}& {0}& {0}& {0}\end{array}\right]$ (15)