I would guess that this is related to the bug discussed in this thread. An interesting difference is that that error was "invalid character in short integer encoding 70 F".

It's hard to diagnose without seeing your code. Please upload it. But it's probably not anything wrong that you are doing; rather it's a bug in Maple. You may be able to work around the bug by changing the value of Digits. In the other case, Digits:= 20 worked.

Simply use allvalues(%). This will divide the right side of the expression into two parts, one for each solution of the quadratic. After that, you'll need to work with the parts separately.

@verdin Ahh, I see. I think that what you want is the ?debugger. In particular, see ?stopat.

You can work with the RootOf symbolically. But, from your title, I think that your goal is to find where the gradient of f is 0. To do that, you should solve all three derivatives for 0 simultaneously:

solve({D[1](f)(a,b,c), D[2](f)(a,b,c), D[3](f)(a,b,c)}, {a,b,c});

Or, to generalize the number of variables:

V:= [a,b,c]:
solve({'D[k](f)(V[])' $ 'k'= 1..nops(V)}, {V[]});

Use command readstat("...") or readline(-1). This will wait for user input before continuing. You can ignore the content of the input if you want.

Note that your sequence has 11 elements, not 10. There are several ways to do what you want.

for j to 11 do  i:= -0.5+(j-1)*0.1; array1[j]:= sin(i) end do:

array1:= Vector(11, j-> sin(-0.5+(j-1)*0.1)):

array1:= <seq(sin(i), i= -0.5..0.5, 0.1)>:

To omit the zero, it is easiest to start with the first array and then exclude the middle index. You need 10 elements.

array2:= array1[[1..5, 7..11]]:

array2:= array1[[1..5, -5..-1]]:

They are not equal. What makes you think that they are? There are three plus/minus signs that switch among the four roots.

Sorry, I didn't read your post carefully at first, specifically the x in the example call Test(f(x)), until Markiyan pointed out my error. So, here's my corrected Answer.  The original answer is below.

Test:= (f::patfunc(anything,nothing))-> subsop(1= 10, f):

Test(f(x));
                             f(10)

The (anything,nothing) typespec is to restrict Test to functions of one argument. That can be easily changed if you want.
Test(f(x,y));
Error, invalid input: Test expects its 1st argument, f, to be of type patfunc(anything, nothing), but received f(x, y)

If you want the following to return f(g(10)) instead, I can change it. Let me know.
Test(f(g(x)));
                             f(10)

My erroneous original answer:

You do it just the way that you just did it:

Test:= proc(f) f(10) end proc:
Test(g);
                             g(10)
Test(sin);
                            sin(10)
Test(x-> x^2);
                              100

(You can include return in your procedure if you want. I omitted it because it is superfluous in the last statement of a procedure.)

Tables are what Maple calls a "mutable" data structure. This is a difficult concept to understand.  Most data structures (such as lists and sets) are not mutable. Mutable data structures cannot be compared for equality or membership by any of the standard commands. They would have to be checked elementwise or with verify. The equality and membership tests will check for identity of tables though. Another option for comparisons is to convert tables to lists.

Here are several examples. Please study these very carefully and let me know if you have any questions. I emphasize again that this is a difficult concept to learn.

Download Mutable.mw

Change product to mul in your expression. The commands add, mul, and seq are alike in that they don't evaluate their arguments until the index values are substituted; whereas their analogs sum, product, and $ act like the vast majority of Maple commands by evaluating their arguments before they are even passed to the command. In your case, the attempt to evaluate k[j], etc., before j has been assigned a value causes the error.

UnionClosure:= proc(T::set(set))
local R,Iter,k,T1;
     #Next line doesn't change the output, but potentially reduces iterations by a factor of 4.
     T1:= T minus {`union`(T[]), {}};
    Iter:= combinat:-subsets(T1);
     for k while not Iter['finished'] do  R[k]:= `union`(Iter['nextvalue']()[])  end do;
    {entries}(R, 'nolist')
end proc:

Example:
UnionClosure({{1},{1,2},{3}});
           {{}, {1}, {3}, {1, 2}, {1, 3}, {1, 2, 3}}

In order for your operation to be well defined, there can be no repeats among the first elements within each list of ordered pairs. Given that, here's an example of how to do your operation. We convert the lists to tables, add the tables (essentially), and convert the result back into a list of ordered pairs.

Download ListTableList.mw

You have entered the following equation with mod:

As far as I know, there is no provision in Maple for non-integer moduli. (I hope that someone will correct me if I am wrong about that or confirm that I am right.) Maple allows you to enter the expression because it is symbolic, and thus there's a chance that the expression will become integer when values are supplied for w and v. But that's not going to happen here. The above equation causes lengthy modp expressions to be carried through your computation. This is not the direct cause of your fsolve error, but after you correct the situation pointed out by Preben, you will eventually get an error because of the mod.

Your attached file is missing. But attemping to answer anyway, I get the different series:

series(exp(1/z), z=1);
                          3               2   13               3
exp(1) - exp(1) (z - 1) + - exp(1) (z - 1)  - -- exp(1) (z - 1) 
                          2                   6                 

     73               4   167               5    /       6\
   + -- exp(1) (z - 1)  - --- exp(1) (z - 1)  + O\(z - 1) /
     24                   40                               

series(exp(z), z=1);
                          1               2   1               3
exp(1) + exp(1) (z - 1) + - exp(1) (z - 1)  + - exp(1) (z - 1) 
                          2                   6                

     1                4    1                5    /       6\
   + -- exp(1) (z - 1)  + --- exp(1) (z - 1)  + O\(z - 1) /
     24                   120                              

The data matrix for most simple plots p (including the ones here) is op([1,1], p). We can take both the x and y coordinates from the first plot and take just the y coordinate column ([..,2]) from the other two. We paste the columns together with the Matrix constructor `<|>` (which is not often used in this prefix form). Putting that all together, we get the 50 x 4 Matrix via

M:= `<|>`(op([1,1], p1), map(p-> op([1,1], p)[..,2]^%T, [p2,p3])[]);

Then you can right click on it and select Export, or use ExportMatrix(...).

Note that if you use 50 points on the interval 0..1, then the spacing is 1/49, so you're not going to get nice round x values like you show in your example.