Download conv_arctrigh.mw

The fsolve command can have difficulty with the original because of the ill-behaviour numerically, alongside the fact that the expression is non-real-valued when K[1]<-1 or K[1]>1. This can be mitigated in several ways.

[edited] I am deliberately proceeding with ranges for K[1] that are wider than -1..1 on at least the positive side, simply because restricting the domain to within -1..1 is one way to mitigate the issue. It is of interest to see what happens when the user is not required to do such preliminary analysis to arrive at that approach.

restart;

ee:=-2*sqrt(-K[1]^2+1)*K[1]+4*K[1]^2-Pi-2*arctan(sqrt(-K[1]^2+1)/K[1]):

fsolve(ee,K[1]=0.5..2);
                          0.9832314847

fsolve(abs(ee),K[1]=0.5..20);
                          0.9832314847

# The next can return unevaluated (it varies with the range supplied).
fsolve(ee,K[1]=-2..2); 
fsolve(ee,K[1]=-2..20); 

These plots illustrate what's going on.

plot([Re,Im](ee),K[1]=-3..3,color=[red,blue],thickness=3,view=-20..20);
plot(abs(ee),K[1]=-3..3,color=[red,blue],thickness=3,view=0..20);

The difficulties with specifying the domain affect the Roots command as well.

Student:-Calculus1:-Roots(ee,K[1]=-1..1,numeric);
     [               -13                 -13              ]
     [-2.901814752 10   , -2.539955697 10   , 0.9832314847]

Student:-Calculus1:-Roots(abs(ee),K[1]=-2..2,numeric);
                         [0.9832314847]

# These next can return the empty list, it varies with range supplied
Student:-Calculus1:-Roots(ee,K[1]=-2..2,numeric);
                               []

Student:-Calculus1:-Roots(ee,K[1]=-2..20,numeric);
                               []

The solve command can be made to return a RootOf that can also produce the root your want (but is slower).

restart;
ee:=-2*sqrt(-K[1]^2+1)*K[1]+4*K[1]^2-Pi-2*arctan(sqrt(-K[1]^2+1)/K[1]):

evalf(allvalues([solve(ee,K[1])]));
Warning, solutions may have been lost

              [               -13]                
              [-2.147052793 10   ], [0.9832314847]

Shading of the polygon is done only when the interface renders it.

Maple consists of a executing kernel (computational engine) and an interface (the GUI say).

A plotting structure can be examined and manipulated by you using Maple language code which the kernel executes.

But it's only after the kernel sends the plotting structure off to the GUI (interface) that shading of the plotting structure gets done (when rendered for the output plotting device).

So AKAIK we never have access to the shaded polygon except through the plotting device (e.g. the rendered picture).

The contents of that Math Container is not a valid expression.

What were you hoping to accomplish?

The command you want is print, not display.

Did you attempt to copy&paste the output (or use an Equation Label) when constructing the operator that you assigned to eta? If so then that wouldn't work.

If you want to turn an expression (in q) into an operator (taking parameter q) then use the unapply command instead.

Download unit_test_a.mw

There may be some other funny busniness going on, with distinct locals in the Units names appearing in numerators and denominators. But that could be hard to reproduce without knowing exactly what you did when entering that construction of the operator. Anyway, the unapply approach would be needed regardless.

Or perhaps one of these, either of which could be used subsequently with eval.

sol1:=simplify(solve(3^665/2^x=y, {x}, real, allsolutions));

                              665 ln(3) + ln(1/y)
                 sol1 := {x = -------------------}
                                     ln(2)

eval(sol1, y=3/2);

                           665 ln(3) + ln(2/3)
                      {x = -------------------}
                                  ln(2)

sol2:=simplify(solve({y>1,y<2,3^665/2^x=y}, {x}, real, allsolutions));

                  {            []                    y <= 1
                  {
                  {       665 ln(3) - ln(y)
          sol2 := { [{x = -----------------}]        y < 2
                  {             ln(2)
                  {
                  {            []                    2 <= y

eval(sol2, y=3/2);

                        665 ln(3) - ln(3/2)
                  [{x = -------------------}]
                               ln(2)

eval(sol2, y=1/2);

                              []

eval(sol2, y=5/2);

                              []

One way is to plot either the real or the imaginary part, or both, using the Re and Im commands.

Below, the real part of u(x,t) is the red surface, and the imaginary part is the blue surface.

Download plot33_a.mw

Here's one way to manipulate the equation in question.

Download File_to_help_a.mw

It worked for me, using Maple 2015.2., after I got changed the double .xlsx.xlsx filename extension of your attachment to just .xlsx .

Let me repeat my first question from above, which you did yet not answer. Does it work when you reference the file explicitly, like say the following?

ExcelTools:-Import("C:/Users/Usman/Desktop/Employees.xlsx", 1,"A1:B101");

By the way, Maple 2015 is not the same as Maple 15. If you're going to mark your Questions with the version you're using then please keep that in mind, thanks.

I changed your last two lines to assign to A and B rather than a and b, since you were already using a[0],a[1], etc, and the collision of names seems unnecessary and not useful.

I suggest simplifying "coefficients" in A after collecting. But I'd agree than collecting (first) wrt y[n] is likely best.

Also, simplifying before applying allvalues seems to save time (and produce a better result perhaps). (The application of allvalues just resolves an inplicit RootOf of a quadratic. I did not look at calling solve with option explicit as possible alternative.)

[edited] I found some simpler forms from my earlier answer. Here's the earlier answer, but now with an example call to radnormal and simplify(..,size) which reduces the size about 8 times smaller than I had before.
 

Download simplif_ex3.mw

And here below are two other approaches.

The first of these next approaches is somewhat similar to what I did above.

The second of these next approaches eliminates only a[1],a[2],a[3] as a first step (as opposed to calling solve for all four variables), and then eliminates a[0] from the restrictions that ensue from the first step. That elimination of a[0] produces the pair of results (that previously came from calling allvalues on the quadratic RootOf). This approach gets a pair of formulas each of length 625, which is half the size of the other approaches results.

So now there are three pairs formulas for y[n+1]. Evaluation at random float values shows agreement (but in one of the pairs the agreement can flip partners).
simpl_alt1.mw

The smallest I see so far (using either length or LeafCount as the metric), is,

collect(EXPR,[Gr,Br],u->simplify(simplify(u),size));

where EXPR is the original (as converted to 1D by Preben). That result has length 2645 , without any assumptions, using Maple 2017.3.

simp_expr.mw

Download simp_ex.mw

Try it under the assumption that x>0 .

restart;

f:=(x,z)->ln(x^z);

                                      / z\
                     f := (x, z) -> ln\x /

simplify(f(x,2)) assuming x>0;

                            2 ln(x)

Now consider a value for x such as -1/3 . Notice that your expected formula doesn't produce the same result.

ln((-1/3)^2), 2*ln(-1/3);

                  -2 ln(3), -2 ln(3) + 2 I Pi

Your Question was, "Can a Data Table be used as an input in a procedure?"

If I understand the question properly, then my Answer is as follows. The name of the unique Array/rtable/Matrix/Vector associated with a particular DataTable can be the argument to a procedure call, as can the unique string identity of a particular DataTable.

Now on to your bullet points, which seem to be more about having an Array associated with a DataTable be returned from a procedure call:

Issue 3)

When your procedure BiPolyNum returns a copy of the Array ary then it is deliberately breaking any connection with the DataTable associated with ary.

Subsequent changes in the DataTable (made manually) will not be accompanied by any changes in the Array returned by BiPolyNum as copy(ary). And vice versa.

So, if you expect the returned Array and the DataTable to be associated, then don't use copy on the return value.

Issue 2)

This is the same as issue 3), except you're not using a procedure. But your copy(ary) is still not going to be associated with the DataTable. A DataTable is associated with only one rtable (Array, say). A copy of that Array won't be associated with the DataTable.

Issue 1)

I'll check whether I can reproduce the lag. You could submit a bug report. I suggest submitting a bug report in which you've inserted the DataTable by hand, via the Components palette, so that it's clear that the issue has nothing to do with the DocumentTools commands.