Making a wild guess. When Maple says

"Error, (in Bits:-GetBits) argument 1, the number, must be a nonnegative integer"

maybe it means that the first argument should be a non-negative integer, Now I have actually tried this with positive and negative integer arguments; GetBits() handles either. However, if the first argument is a float, then I get the above Error Message. Since you can't be bothered to post the code which leads to the above error message, I cannot check further - but I'm betting that you are prociding a float as first argument.

If you are not, then post the code which leads to the above error so I can debug properly

is probably to use the dismantle() command, as in

f:=x^2*exp(3/2)*sin(Pi/3-1/x);
dismantle(f);

although you do have to read the output of the dsimantle() command quite carefully to appreciate the details

You have been unfortunate enough to generate somethiing called an ill-conditioned polynomial. The final stage of your calculation, the computation of the determinant, produces a polynomial in P of degree 18, for which you require the roots. Unfortunately, in an ill-conditioned polynomial the roots vary a lot if any of the coefficients vary by even a tiny amount. This (rather counter-intuitive) phenomenon was first(?) reported by a guy called Wilkinson, who illustrated it with what (at first sight) seems to be a really "innocuous" polynomial. See the article at

https://en.wikipedia.org/wiki/Wilkinson%27s_polynomial

This will probably put you off believing the results of any polynomial roots calculation forever! However all is not lost,yet. One way to get around this problem is to avoid floating point numbers at all costs. Just don't use floats! One can achieve this by converting all of your parameter values to exact rationals. Consider the simple case of 1/3: it is an exact rational, but this is not the same as 0.33333333 or 0.333333333333333333 or 0.333333333333333333333333333333. You may claim that you are not using anything parameters with recurring decimals, but when you write Ec := 0.380e12, whihc will be stored as a floating point number, are you expecting it to be stroed (and used) as

0.380000000000000000000000000000000e-12 or maybe
0.3800000000000000000000000000000000000000000000000000000000000000000000000000000e-12, or maybe even
0.3800000000000000000000000000000000000010000000000000000000000000000000000000000e-12

because when such a number is used in the computation of coefficients of an ill-conditioned polynomial this is (probably) going to make a difference

By coverting all parameters to exact rational fractions in Maple, all subsequent calculations will then be carried out using a combination of integers and exact rationals, completely avoiding the issue of their representation as floating point numbers. The Maple woiksheet for doing this is attached later: unsurprisingly, this gives consistent results, irrespective of the number of digits requested for the final calculation step.

Comparing this calculation with that returned by Matlab is difficult  (for me!). There are (at least) two symbolic calculators which can be used within Matlab. Once upon a time, Matlab used a "stripped-down" version of Maple as its symbolic toolbox: but Maple and Matlab had an argument, and Matlab swiched to using a different engine called muPad, I believe) for symbolic calculations. Your "Matlab" code only functions with the muPad engine. My Matlab installation is set up to use Maple as the symbolic calculation engine for the simple reason that having paid for Maple and Matlab, I could find no reason to pay even more for the "Matlab symbolic toolbox" (aka muPad). Since I can use Matlab with Maple as the symbolic engine - why bother.

For your specific Matlab code there are only a few 'symbolic' commands - 'solve', 'diff'', and 'subs' being the obvious ones. The functionality of these commands in MAple and MuPad is similar but their syntax is (slightly) different. Hence if I try to run your "Matlab" code, I just get numerous syntax errors. I could probably rewrite your "Matlab" code to do all of the symbolic calculations in Maple, but since this is the same as using Maple directly - what would be the point? Hence I cannot really comment on the best way to use muPad to deal with the roots of ill-conditioned polynomials. That is probably a question for a Matlba forum - not this one

##############################################

Code for Maple calculation

Download illCon.mw

Assumes that "sensitivity" wrt each parameter is as defined in Rouben Rostamian's response to the OP' previous post

Download sens.mw

It isn't clear what "data" you want to write. You have two main options

1. Generate a plot of the solution surface (over ranges you specify) and then use Maple's exportplot() command
2. Generate a Matrix of the solution at specified x,y values, and output this using Maple's ExportMatrix() command

It seems as if you may want the latter. See the attached

Download pdExport.mw

Can confirm the problem, but I'm not sure why it happens. Obvious suggestion is that it is something to do with the "CONCATENATE" formula. Maple usually doesn't mind cell values defined by formulae in Excel - at least when they produce numeric values.

Workarounds

1. Import only the first couple of columns of data and do the concatenation in Maple, as in

restart;
L:= ExcelTools:-Import("C:/Users/TomLeslie/Desktop/Book1.xls",1, "A3:B8"):
M:= Matrix( op([1,1],L),
                    3,
                    (i,j)->`if`( j<3,
                                   L[i,j],
                                   cat(L[i,1], ",", L[i,2])
                                 )
                 );
V:=Vector[column]( op([1,1],L), i->cat(L[i,1], ",", L[i,2]) );

depending on whether you want an n*3 matrix, or just a vector of the concatenated data.

2. Export the data from the Excel file as "plain vanilla csv", then use Maple's standard "import" function, with target = matrix, then select the relevant data, as in

L:=Import("C:/Users/TomLeslie/Desktop/Book1.csv", output=Matrix);
M:=Matrix( L[2..6,1...3]);
M:=Vector[column]( L[2..6,3]);

again depending on whether you want an n*3 matrix, or just a vector of the concatenated data.

Read comments in the file.

You will have to change the 'destination' string to something appropriate for your machine

Download exportXL.mw

it depends on the nature of the calculations being performed.

So far as I can tell the intel i7-6500U has two cores, with two threads per core, so if you execute the Maple command

kernelopts(numcpus);

the answer ought to be 4 (=numberOfCores*numberOfThreads), For comparison, I'm running an intel i7-3770K which has 4 cores and two threads/core, so in my case

kernelopts(numcpus);

returns 8.

As a general rule, when executng a Maple worksheet, only one thread will be used - so (in your case) you will only be using a maximum of 25% of your processor's capabilities (or for my machine 12.5%).

So can more of of the processor capabilities be utilised? Yes! But it depends on whether or not the calculation you are performing can be parallelized. Some calculations can be, and some can't. Maple will not decide this for you - you just have to know and program appropriately!

If calculations can be parallelized then your best option is probably the Threads:-Task() sub-package. The Parallel Programming chapter in Maple's ProgrammingGuide.pdf is a useful introduction. If you don't have the pdf then ?ProgrammingGuide,Chapter15 at the Maple prompt will give more or less the same info. Careful reading is recommended

The following works (ie no errors) in Maple 2017

restart;
int(int(sin(x^2*y), x = 1 .. Pi), y = 1 .. Pi);
int(int(sin(x^2*y), x = 1 .. evalf(Pi)), y = 1 .. evalf(Pi));

However the second command above fails in Maple 2015 with the error message

Error, (in type/laurent) too many levels of recursion

A simple change to

restart;
int(int(sin(x^2*y), x = 1 .. Pi), y = 1 .. Pi);
evalf(%);

and it will work in Maple 2015 also

that what you want is to obtain an expression of the form A+B*t, where A and B are not dependent on the variable't'. In order to achieve this, the function psi1(t) has to be defined. As a 'toy' example. if I make psi1() a simple quadratic in 't', and assume that you want the Taylor series expansion about t=0, then the following code will achieve what you want

restart:
psi1:= z->3*z^2+2*z+1:
fun:= sin(phi2)*sin(psi1(t))*lk*m1*diff(psi1(t), t, t)+sin(phi2)*diff(psi1(t), t)^2*cos(psi1(t))*lk*m1;
taylor( fun, t=0, 2);
convert(%, polynom);

You can redefine the function psi1() to be more or less anything well-behaved, and expand the Taylor series about values other than t=0, should you so desire with trivial amendments to the above

You *ought* to be able to get this plot using the syntax in your original post, but as you have discovered -you can't, and I don't understand why!

I suppose (to be fair), I should point that the help page 'Plot with Units' only refers to plotting with functions or procedures - not points.

I tried several variations, none of which "worked", so I eventually decided that the simplest (?!) way is to extract values and units from your data, then plot the values, and add the units to the axes. This is painful, but for what it is worth, the following ought to work

restart;
my_scaled_points := [ [  1.0*Unit('kg'), 2.0*Unit('hour') ],
                                       [ 21.0*Unit('kg'), 7.0*Unit('hour') ]
                                    ];
getV:= z -> [ seq( map( j -> op(1,j), k ), k in z ) ]:
getU:= z -> map( j -> op(2,j), z[1] ):
plot( getV( my_scaled_points ), # get values
         style = point,
         symbol = solidcircle,
         symbolsize = 24,
         useunits = getU( my_scaled_points ) # get units
     );

There really ought to be a better way, and I hope someone can provide it.

You may want to do z-transforms from the basic definition for teacjing/learning purposes, which is fine. On the other hand if you just wnat to know the answers, then the optimum strategey is probably to use Maple's in-built ztrans() function. For y0ur two examples the code would be

   restart;
   ztrans( 1, n, z );
   ztrans( exp(a*k*Ta), k, z );
#
# Get the above in "standard" form
#
   expr:= simplify(normal(%));

becuase with Maples built-in routines

Optimization:-Maximize(x*y+y*z, [ x*y=1, y^2+z^2=1]);

returns

[1.49999999999997780, [x = 1.41421356249703, y = .707106781124551, z = .707106781248575]]

and

Optimization:-Minimize(x*y+y*z, [ x*y=1, y^2+z^2=1]);

returns

[.499999999989945598, [x = 1.41421339391716, y = .707106865409386, z = -.707106696967656]]

Below has fixes for your original code

Download 2DLfixed.mws

Still think that the following (slightly revised version of the one I posted for your earlier question) is better

Download letrot2.mw

The attached shows how I *might* do this if I was dealing only with individual (and combinations of) non-curved letters.

Can't (at the moment) think of a 'simple' way to extend this approach to include 'curvy' letters such as 'D', 'O', etc:-(

This was created (and works) in Maple2017, but I can't think of any reason why it wouldn't work in Maple7; it only uses pretty basic commands from the plottools() and plots() package

letrot.mw