restart;

expr := exp(I*x);

eq := expr = evalc(expr);

eval( eq, x=I);

convert(%, exp);

cos(I);

sin(I);

I*sin(I);

restart;

eq := a[n]=b*c[n]/d^2*(e+f[n])/g;

teq := c[n]*(e+f[n])=__u:

eval(isolate(simplify(eq,{teq}),__u),(rhs=lhs)(teq));

restart;

kernelopts(version);

U := proc(x, u)
  if not x::complexcons then return 'procname'(x,u);
  else x*u; end if;
end proc:
`print/U` := proc(x) x; end proc:

pp := U(p,Unit(m));

qq := U(q,Unit(s));

expr1 := pp*qq;

Now a substitution (evaluation at a point).

eval(expr1, [p=4, q=3]);

expr2 := 7*Unit(cm*s) + pp*qq;

Now another substituion at a point.

eval(expr2, [p=5.5, q=2.1]);

combine(%,units);

The combining of units can be made mostly automatic.
(You don't have to make this happen automatically.)

with(Units:-Simple):

eval(expr2, [p=5.5, q=2.1]);

restart;

implicitdiff({2*x*y^3+3*x^2*y=1},{x(y)},{x},y,notation=Diff)[1];

lhs(%)=sign(numer(rhs(%)))
       *expand(numer(rhs(%))/sign(numer(rhs(%))))/expand(denom(rhs(%)));

restart;

Here f is an expression that depends on t. There
are no operators in play here.

f := sin(x(t));

diff(f, t);

restart;

Here f is an operator. It is not an expression that
depends on t.

f := t -> sin(x(t));

But f(t) is an expression that depends on t, after
applying the operator f to t.

f(t);

diff(f(t), t);

If you really want you could construct a new
operator from that.

unapply(%, t);

Alternatively we can directly construct a new
operator which returns the derivative (wrt t) of
what f returns.

D(f);

We can also apply that new operator to t. This
produces an expression that depends on t.

D(f)(t);

We could now also convert that expression
from D form to active diff form.

convert(%, diff);

restart;

bracket:=proc(ee::{list,set},
              {left::{truefalse,identical("{","[","(")}:=true,
               right::{truefalse,identical("}","]",")")}:=true})
  local i; uses Typesetting;
  mrow(piecewise(member(left,{true,"{"}),mo("{"),
                 left="[",mo("["),left="(",mo("("),mo("")),
       mtable(seq(mtr(mtd(Typeset(EV(ee[i])))),i=1..nops(ee))),
       piecewise(member(right,{true,"}"}), mo("}"),
                 right="]",mo("]"),right=")",mo(")"),mo("")));
end proc:

sys:=[x+y-z = 3, x-y-z = 5, -x-y-z = 7];

bracket(sys);

bracket(sys, left=false);

bracket(sys, right=false);

bracket(sys, left="[", right="]");

bracket(sys, left=false, right="]");

bracket(sys, left="[", right=false);

bracket(sys, left="(", right=")");

bracket(sys, left=false, right=")");

bracket(sys, left="(", right=false);

bracket(sys, right="]");

restart;

r:=rand(0...5.):

y:=[seq(r(), n=1..10)]:

#
# Kitonum's good suggestion.
#
[seq(`if`(y[n]>0 and y[n]<1,[n,y[n]],NULL), n=1..nops(y))];

#
# This is slightly less efficient since it creates list [$nops(y)]
#
map(i->`if`(y[i]>0 and y[i]<1,[i,y[i]],NULL), [$nops(y)]);

#
# This inefficiently creates all [i,y[i]] even if not needed.
# It also creates list [$nops(y)]
#
select(u->u[2]>0 and u[2]<1, map(i->[i,y[i]], [$nops(y)]));

#
# Using a loop, which is not awful but more to code.
#
L:='L': # L will become a table
for i from 1 to nops(y) do
  if y[i]>0 and y[i]<1 then
    L[i] := [i,y[i]];
  end if;
end do:
convert(L, list);

#
# This is a bad way to do it, by repeatedly
# augmenting the list.
#
L:=[]:
for i from 1 to nops(y) do
  if y[i]>0 and y[i]<1 then
    L := [op(L), [i,y[i]]];
  end if;
end do:
L;

restart;

r:=rand(0...5.):

y:=[seq(r(), n=1..10^5)]:

str:=time[real]():

[seq(`if`(y[n]>0 and y[n]<1,[n,y[n]],NULL), n=1..nops(y))]:

(time[real]()-str)*'seconds';
nops(%%);

restart;

r:=rand(0...5.):

y:=[seq(r(), n=1..10^5)]:

#
# This is slightly less efficient since it creates list [$nops(y)]
#
str:=time[real]():

map(i->`if`(y[i]>0 and y[i]<1,[i,y[i]],NULL), [$nops(y)]):

(time[real]()-str)*'seconds';
nops(%%);

restart;

r:=rand(0...5.):

y:=[seq(r(), n=1..10^5)]:

#
# This inefficiently creates all [i,y[i]] even if not needed.
# It also creates list [$nops(y)]
#
str:=time[real]():

select(u->u[2]>0 and u[2]<1, map(i->[i,y[i]], [$nops(y)])):

(time[real]()-str)*'seconds';
nops(%%);

restart;

r:=rand(0...5.):

y:=[seq(r(), n=1..10^5)]:

str:=time[real]():

L:='L': # L will become a table
for i from 1 to nops(y) do
  if y[i]>0 and y[i]<1 then
    L[i] := [i,y[i]];
  end if;
end do:
convert(L, list):

(time[real]()-str)*'seconds';
nops(%%);

restart;

r:=rand(0...5.):

y:=[seq(r(), n=1..10^5)]:

#
# This is a bad way to do it, by repeatedly
# augmenting the list.
#
str:=time[real]():

L:=[]:
for i from 1 to nops(y) do
  if y[i]>0 and y[i]<1 then
    L := [op(L), [i,y[i]]];
  end if;
end do:
L:

(time[real]()-str)*'seconds';
nops(%%);

restart;

r:=rand(1.0..5.0):

y:=[seq(r(), n=1..10^5)]:
y:=[y[1..floor(nops(y)/3)][],0.4,y[floor(nops(y)/3)+1..-1][]]:

str:=time[real]():

[seq(`if`(y[n]>0 and y[n]<1,[n,y[n]],NULL), n=1..nops(y))];

(time[real]()-str)*'seconds';

restart;

r:=rand(1.0..5.0):

y:=[seq(r(), n=1..10^5)]:
y:=[y[1..floor(nops(y)/3)][],0.4,y[floor(nops(y)/3)+1..-1][]]:

str:=time[real]():

L:='L': # L will become a table
for i from 1 to nops(y) do
  if y[i]>0 and y[i]<1 then
    L[i] := [i,y[i]];
    break;
  end if;
end do:
convert(L, list);

(time[real]()-str)*'seconds';

restart;

r:=rand(1.0..5.0):

y:=[seq(r(), n=1..10^5)]:
y:=[y[1..floor(nops(y)/3)][],0.4,y[floor(nops(y)/3)+1..-1][]]:

#
# If we only want the first successful element then
# the table is not necessary.
#
str:=time[real]():

for i from 1 to nops(y) do
  if y[i]>0 and y[i]<1 then
    ans := [i,y[i]];
    break;
  end if;
end do:
ans;

(time[real]()-str)*'seconds';

restart;

r:=rand(1.0..5.0):

y:=[seq(r(), n=1..10^5)]:
y:=[y[1..floor(nops(y)/3)][],0.4,y[floor(nops(y)/3)+1..-1][]]:

str:=time[real]():

(e->[e,y[e]])(ListTools:-SelectFirst(e->e>0 and e<1, y, 'output'=':-indices'));

(time[real]()-str)*'seconds';