@Carl Love That did not work in my Maple 2018.2 (and the OP has tagged his Question as Maple 2018), unless I increased Digits to 12 or higher. And then it worked without specificying the negative domain.

In my Maple 2019.0 it worked simply with fsolve(eval(p, params), E__fv)  and even at default Digits=10.

@digerdiga And how does that substantiate the notion (your words), "Maple2019 advertised for a big overhaul of simplifications like this"?

@digerdiga I see mention in the What's New for Maple 2019 of "several improvements" for simplify, with some specific areas mentioned including piecewise, radicals, GAMMA, and arctan. I don't see any specific mention of dilog or polylog.

On what are you basing your claim?

@digerdiga What, you mean all bugs and weaknesses? Why do you say that?

@mehdi jafari As always, provide a worksheet or complete code that reproduces the issue.

Upload and attach your worksheet. (Why type all that here, and not attach it?!)

It looks as if it's not finding Student:-Precalculus:-Distance when forming Matrix R. But only if we can see your worksheet can we know for sure.

@mmcdara One possible problem with using subs as you have done is that it replaces all stand-alone instances of L with beta/m.

And sometimes may not be what's wanted. In the following example it may be that standalone L is preferred over beta*m.

Download algsubs_subs.mw

Of course, no size fits all.

@love-algebra This works for your given (short, toy) example. If it doesn't work for your longer examples then, well, that's what happens when you don't supply them to us up front.

Download algsubs.mw

It would be easier to demonstrate if you attached your original data. If you use the ExportMatrix command then you can attach it as an (exported) text file. (You could zip it before attaching it. Use the Green up-arrow in the Mapleprimes editor to attach it to a Comment.

If your original data has structure (and I suspect it may) then you can use ArrayInterpolation. But the inputs to that command would not be as you have them. Rather, M1 and M2 would be the two 300-element Vectors of the "common" independent values, and M3 would be the 300x300 Matrix of dependent values.

If it the data is not structured then you could use the Interpolation package to create something from which to attain the interpolated values (utilizing your M4 and M5).

But, again, it's easier to get it right for you the first time if your upload the data. Or you could upload a worksheet that generated the original data, so we could reproduce it via computation.

Have you looked at the examples on the Help page with topic,
   examples/Interpolation_and_Smoothing
That has examples involving interpolation of the kind of structured (regularly spaced in both independent dimensions) data that a plot3d(...,x=a..b,y=c..d) call might generate. It also has examples for irregular independent data.

Your Mapleprimes Post has this link:

   https://www.ias.ac.in/describe/article/reso/024/06/0653-0659

But that seems to have a link to a wrong fulltext article (.pdf file).

Should your link be this instead?

   https://www.ias.ac.in/describe/article/reso/024/06/0661-0679

That links to the fulltext arcticle here.

I agree with Carl's remarks in general.

Naturally, exceptions of evalhf'd code being thread-safe can include procedures that write inplace to rtables, or escaping evalhf mode temporarily via eval.

The Grid package may be beneficial if the individual jobs are not (individually) quick. Using Grid may involve greater overhead per subtask than does using Threads. It might be that a list of parameter values could be passed along in clumps, to mitigate the overhead of firing up separate kernels under Grid.

It might be relevant to know whether the OP is doing symbolic or numeric integration. The former is generally thread-unsafe because it can make significant use of limit (which is quite thread-unsafe).

The fact that the OP's code is reportedly running OK under Threads some of the time is what makes me wonder about the ArrayTools scenario I outlined.

It's often beneficial to make sure that the serial implementation of one's code is well-optimized, before parallelizing. I see many cases where (say) numeric integration is performing suboptimally because of how it's being invoked. For example, successfully enabling evalhf-mode evaluation of the integrand, and avoiding discontinuity checks that might happen to be unnecessary, can sometimes bring about a 20-fold or better timing speedup that is often more significant than parallelization benefits. That's just an example, and I do not know how well optimized the OP's serial code may be.

@Rouben Rostamian  It's interesting that series fails on that example with the RootOf containing those powers of 2*n. It could be tricky to figure out the precise cause (I will submit a bug report). series_oddity.mw

Why would you ask such a question without attaching the code itself?!

Couldn't you coordinate with your fellow student so that you only ask any of your coursework questions onlt once?

See here for the duplicate of this one.

This is not the first time you've both asked the same question.

@radaar 

Your problems seem to be more about how to use a Linux commandline terminal for text-driven applications in general, not just Maple. Perhaps you'd be better off learning first how to use commandline Linux, rather than focusing on Maple.

None of this is especially related to data science. That's a pretty big area. Why can't you be more specific?