@Carl Love & @mmcdara Many thanks. Maybe such functionalities can be built into the underlying core so that Maple can sort rows of the rtable in-place.

@nm Thanks for your advice. But they behave differently. For example, 

ArrayTools:-SortBy(<4, 1, 1 | 0, 2, 5 | 7, 9, 8>, [.., 1]);
                           [1  2  9]
                           [       ]
                           [1  5  8]
                           [       ]
                           [4  0  7]

ArrayTools:-SortBy(<4, 1, 1 | 0, 2, 5 | 7, 9, 8>, 'column', [1, 3, 2]);
Error, (in ArrayTools:-SortBy) for 2-D rtable, expecting either list of indices or keyword column/row and index to specify what is to be sorted

while my purpose is: first sort the rows of the input 2-D array in specific order based on the elements in the specified column, then sort rows that have equal elements in the specified column based on the elements in the next specified column, and so forth. (Also, I hope that there will be a multidimensional analogue.)

@mmcdara Thanks for your test. I think that when working with Statistics, perharps using Sort@Trim is better (since they are in the same toolchain).
As for your last point, the reason is that you only measure the average time (instead of the total time). The MatLab code given in that Blog is: 

    tic
    for i=1:300
        y=mink(x,j*100);
    end
    minkResults(j)=toc;

 So “CodeTools:-Usage(..., 'interations' = 300)” should be changed to something like

to 5 do (*warm up the code to avoid its first-time costs*) od:
time[real]('(Statistics:-Sort@Statistics:-Trim)( … )' $ 3e2);

 Besides, though there exists a one-dimensional Statistics:-Sort function, is there a similar sortrows/sortcols in Maple?

@dharr Thanks. This is also useful, because the input data can contain any element.

@mmcdara Thanks. I think this function is just what I am seeking, although it appears to only handle numeric objects with real values.
Besides, in your worksheet, "the sorted 1000 smaller" runs much faster than "the 1000 smaller". Maybe there is some mistake?

@jalal For example, 

InertForm:-Display(InertForm:-Parse("2*sqrt(3)"), 'inert' = false);
subs("⋅" = " ", %);

Do you mean combinat:-randcomb([`+`, `*`, `-`], 1)? 

@Carl Love Thanks. I think that I know why `Iterator:-CartesianProduct` is not faster; later I find a bug in `Iterator:-CartesianProduct`. Below is the output from showstat(Iterator:-CartesianProduct::ModuleCopy): 

So by default the iterator is not compiled. However, even if I specify “'compile' = true” manually, the compiled iterator still runs slower (!) than your uncompiled `CP[6]`, which is really strange. 

@ecterrab I think that what the OP wants is a direct shortcut key for the overbar U+0305 (something like an overscript with long underlines).

@Carl Love In the main code, “It:-CartesianProduct(DigitSets())” is used. Suppose that DigitSets() is {0, 1, 2, 3}, {0, 1, 2, 3}. Is there any difference among 

Iterator:-CartesianProduct({0, 1, 2, 3}, {0, 1, 2, 3}):
Iterator:-MixedRadixGrayCode([3 + 1, 3 + 1]):
Iterator:-MultiSeq(<0, 0> .. <3, 3>):
Iterator:-MixedRadixTuples([3 + 1, 3 + 1]):
combinat:-cartprod([{0, 1, 2, 3}, {0, 1, 2, 3}]):

?

Strangely, the faster gmp_isprime is a "undocumented protected name". I'm not sure why it wasn't officially documented.

I also try to use a faster primes generator; in theory, the following program should be quite efficient: (Assume that one has installed the most recent Primesieve under E:\Primesieve\bin\.) 

A161786__3 := proc(m::nonnegint, n::posint := 1, b(*ase*)::And(posint, Non(1)) := 10, o(*ccurrence*)::posint := 4, ` $`)::'Vector'(prime):
    description "Dependency: primesieve winget package.":
	options hfloat:
	local p::string := ifelse(n = 1, "1", ssystem(cat("\"E:/Primesieve/bin/primesieve.exe\" ", n - 1, " -n -p"))[2]), vec := rtable(1 .. 0, datatype = integer[4], subtype = Vector[column]), numberDecompose := (radix, uintlen) -> (thisproc(args) := convert(['tmp' = 'd', [''irem'('tmp', radix, ''tmp'')' $ uintlen]], procedure, 'locals' = ['tmp'::posint], 'params' = ['d'::posint])), v::integer[0 .. b - 1], C(*ounter*);
	if b = 10 then
		to m do
			p := ssystem(cat("\"E:/Primesieve/bin/primesieve.exe\" 1 ", p, " -n -p"))[-1];
			if member(o, rhs~({StringTools:-CharacterFrequencies(p, 'digit')})) then
				vec ,= parse(p)
			fi
		od
	elif b = 2 then
		to m do
			p := ssystem(cat("\"E:/Primesieve/bin/primesieve.exe\" 1 ", p, " -n -p"))[-1];
			if member(o, rhs~({StringTools:-CharacterFrequencies(Bits:-String(parse(p)), 'binary')})) then
				vec ,= parse(p)
			fi
		od
	elif b = 16 then
		to m do
			p := ssystem(cat("\"E:/Primesieve/bin/primesieve.exe\" 1 ", p, " -n -p"))[-1];
			if member(o, rhs~({StringTools:-CharacterFrequencies(convert(parse(p), 'hex'), 'hdigit')})) then
				vec ,= parse(p)
			fi
		od
	elif b = 8 then
		to m do
			p := ssystem(cat("\"E:/Primesieve/bin/primesieve.exe\" 1 ", p, " -n -p"))[-1];
			if member(o, rhs~({StringTools:-CharacterFrequencies(sprintf("%o", parse(p)), 'octal')})) then
				vec ,= parse(p)
			fi
		od
	elif b = 4 then
		to m do
			p := ssystem(cat("\"E:/Primesieve/bin/primesieve.exe\" 1 ", p, " -n -p"))[-1];
			if member(o, rhs~({StringTools:-CharacterFrequencies(String(op(Bits:-Split(parse(p), 2))), "0123")})) then
				vec ,= parse(p)
			fi
		od
	elif b = 2**(local k := ilog2(b)) then
		if k < 8 then
			to m do
				p := ssystem(cat("\"E:/Primesieve/bin/primesieve.exe\" 1 ", p, " -n -p"))[-1];
				if member(o, rhs~({StringTools:-CharacterFrequencies(convert(Bits:-Split(parse(p), k) +~ 1, 'bytes'))})) then
					vec ,= parse(p)
				fi
			od
		else
			to m do
				p := ssystem(cat("\"E:/Primesieve/bin/primesieve.exe\" 1 ", p, " -n -p"))[-1];
				C := table('sparse');
				for v in Bits:-Split(parse(p), k) do
					++C[v]
				od;
				if member(o, {entries(C, 'nolist')}) then
					vec ,= parse(p)
				fi
			od
		fi
	elif b < 2**8 then
		to m do
			p := ssystem(cat("\"E:/Primesieve/bin/primesieve.exe\" 1 ", p, " -n -p"))[-1];
			if member(o, rhs~({StringTools:-CharacterFrequencies(convert(numberDecompose(b, evalhf['hfloat'](trunc(log[b](p)) + 1))(p) +~ 1, 'bytes'))})) then
				vec ,= parse(p)
			fi
		od
	else
		to m do
			C := table('sparse');
			p := ssystem(cat("\"E:/Primesieve/bin/primesieve.exe\" 1 ", p, " -n -p"))[-1];
			for v in numberDecompose(b, ilog[b](p) + 1)(p) do
				C[v]++
			od;
			if member(o, entries(C, 'output = Array')) then
				vec ,= parse(p)
			fi
		od
	fi;
	vec
end:

But unfortunately, the overhead of communication between Maple and Cmd (i.e., ssystem) appears to seriously weaken its advantage … I hope there will be a faster generator/iterator for prime numbers in a furture Maple release.

@Carl Love There is no problem in recent versions, but since `inttrans` is a "table-based package" (and the use of “inttrans:-invlaplace” is invalid in legacy Maple), for backward compatibility, I think that using “inttrans[':-invlaplace']” is somewhat better. 

Besides, the documentation of colondash is outdated. 
Member Selection Operator says that 

Using Packages also says that

Actually, those old packages are now compatible with the use of binary `:-` operator.
A few years ago, there used to be an option (Was this information helpful?—No: Tell us what we can do better.) at the bottom of the help page, yet today it disappears. 

@Carl Love Oops, I just found it and edited my reply. Thanks.

@Carl Love I believe that this is related. 

restart;
libname := subs(FileTools:-JoinPath([kernelopts(':-toolboxdir' = "Physics Updates"), "lib"]) = NULL, [(tmp := libname)])[]:
inttrans[':-invlaplace'](1/(s + a), s, t);
                           exp(-a t)

libname := tmp:
forget(inttrans[':-invlaplace']);
inttrans[':-invlaplace'](1/(s + a), s, t);
                            exp(a t)

In addition, 

> inttrans['invlaplace'](inttrans['laplace'](ln(t^2+1), t, s), s, t); # Maple 2023.1 
 = 
                              / 2    \
                          2 ln\t  + 1/

So Maple thinks that ㏑(t²＋1)＝2㏑(t² + 1)…? 

Additional examples: 
 

Download ilaplace.mw

(1) is correct, but (2), (3), (4), and (5) are wrong.
And for uknown reason, Maple cannot calculate (6), (7), (9), and (10).