Yes, it is possible, but the way that I would do it would differ depending on the purpose. Is the purpose simply to make a neater display of the final results? Or will the truncated results continue to be used within evalhf for further computation? And, if the latter, is it necessary that the truncation be to a value that is exactly representable in base-10 (which Maple's software floats use), or is a base-2 representation (as used by evalhf) okay?

If the purpose is to speed up the computations within evalhf, I can assure you that truncation will not help with that.

@vv When the OP says "all variable[s] tend to infinity," I think that they mean something akin to an asymptotic series.

@Magma It's not your fault. The help page is totally unclear about what 'r' and 'd' are for and whether either can be used without the other.

@Magma Anyone who's taken a first course of linear algebra should be able to tell you that the maximum number of linearly independent columns of an 8x16 matrix is 8, hence there's at least 16 - 8 = 8 columns that are dependent on those independent columns. So, your answer 7 is utterly wrong; no computation or any reading of your worksheet is needed to know this.

I like your questions (notice the vote-ups that they've received), and they're not too many. Please don't feel inhibited about asking them.

@radaar You asked:

• So if the number of terms in the array is small it is better to go with the code which I have written. is that so?

No, and I don't see how my Answer leads you to believe that. I merely said that your code was accurate, not that it was efficient. If the number of terms is small, use add; if it is large, use Threads:-Add. There is no reason in Maple to ever use a loop to repeatedly update a sum of independent terms if the number of them is known at runtime.

@radaar So, doing 10000 numeric double integrals in under 3 seconds is not fast enough for you?? Seems fast to me. You may able to get faster by finding the externally compiled code that this integral uses and calling it directly.

@Joe Riel 

Joe,

I noticed that you didn't address the issue of thread safety. Is that because you know that this type of integration is thread safe?

@opus64 Can you show an example equation that your command works on? It can't work in general because it has too many op commands. Try it on Sum(x[i], i= 1..9) = Sum(y[i], i= 1..9) to see what I mean.

Did you try my command? Why no comment? It's intended to work in more general cases.

@mmcdara I just added a little bit of significant content to my Answer above, so please reread it. It's the latter part of the fourth paragraph, starting with "The moral gulf...." I draw attention to this because I want to discourage this newer usage of the word spam because I want to avoid having rude-but-innocent people being labelled spammers, the label of a grievous offender. 

@DoingMath2018 You seem to have missed that my Answer, below, applies to mappings or operators rather than expressions.

@Stretto Okay, you do have a good point there. Since piecewise is a very weak part of Maple, I usually convert to Heaviside form. This can be done automatically, like this:

with(inttrans):
sinc:= x-> piecewise(x=0, 1, sin(Pi*x)/x/Pi):
SE:= unapply(convert(sinc(x)*exp(-x^2), Heaviside), x);
plot(abs(fourier(SE(x),x,s)), s= 0..5)

@acer Your workaround using :-D instead of D doesn't work in Maple 2019. It seems like :-D is inert on the operators overridden by VectorCalculus. And I can't figure out what the overridden D is supposed to do.

restart:
kernelopts(version);
   Maple 2019.0, X86 64 WINDOWS, Mar 9 2019, Build ID 1384062
with(VectorCalculus):
assume(x, real);
assume(y, real);
:-D[1]((x,y)-> x^2-y^2):
lprint(%);
D[1]((x, y) -> VectorCalculus:-`+`(x^2,VectorCalculus:-`-`(y^2)))

I suspect that this is just a formatting command for internal use by the GUI that slipped through the cracks. To test that, check what you get from 

lprint(%);

I know that you're in Japan, and it may be easier for things to "slip through the cracks" in a foreign-language GUI.

@Kitonum I was just about to post my simplify solution, but you beat me to it:

E:= unapply(add((a||i)^k, i= 1..3), k):
simplify(E~([$1..9]), {(E~([1,2,3])=~[1,2,3])[]});

      [1, 2, 3, 25/6, 6, 103/12, 221/18, 1265/72, 905/36]

I suspect that this may use significantly less computational effort than solve followed by eval, although I haven't tested that.

You may have already seen this help page. If not, I think that it may provide a little bit of information that will help you. It's

?ColorTools,ColorSpaces. It specifes the 9 predefined gamuts that Maple has. Each has a link to an external reference (all Wikipedia, I think). Hopefully that means that Maple follows the specs of those external references.