Here's an improvement on my earlier Answer. It's pretty fast.

Download invbinom2.mw

The first thing to realize is that in Maple it's refered to as "plotting" rather than "graphing". And each is a "plot" rather than a "graph".

You could start with the Plotting Guide, which may help you figure out which sort of "plot" you want. It is in the Help system of your Maple. Here's an online link.

Here is something, for somewhat smaller p=0.003 and r=1.965 .

Download negativebinomial.mw

So perhaps there is an issue with the Sum and a non-integer upper limit. But perhaps a continous root-finder is a not great choice.

[edit] I originally typo'd that as "a great choice", which negated my whole point. Sigh.

It sounds like you may have inadvertantly downloaded the older first version of the DirectSearch package from the Application Center, which has only the older .hdb format of its Help Database file.

If so then you have a few choices:

1) Manually remove the files you added from the 1st version, and download version 2 from the Application Center. That contains the .help format Help Database file for its version of the DirectSearch package (which is also improved).

2) Manually remove the files you added from the 1st version, and download and install version 2 as a "toolbox" package from the MapleCloud. That contains the newer .help format Help Database file for its version of the DirectSearch package (which is also improved).

3) Remove the files you added from the 1st version, and install DirectSearch version 2 from the MapleCloud directly from within Maple 2018 GUI (required Maple version). You do this using the "cloud" icon at the top-right of the GUI's top icon Toolbar. (Also see View->Toolbar which should be checked in the main menu.)

4) Keep version 1 of the DirectSearch package and migrate its .hdb format Help Database file to the newer .help format using HelpTools commands.

I would recommend choice 3) if you have Maple 2018, or 2) if your Maple version is older.

Important: After installing the later version you may need to completely close all open instances of the Maple GUI, and relaunch, in order for the newly added help pages to be accessible.

This is very similar to your earlier Questions in this theme. But it's easier than before, if now you want to collect powers of r.

Download yet_another.mw

You can do that using the printf command.

Eg.,

for x in [1,2,3,4] do
printf("%a ",x);
end do:

I don't know a huge amount about the PolyhedralSets package (except that it seems to be slightly complicated for the simple tasks for which I sometimes try to use it).

But if you are good with floating-point data then how about ComputationalGeometry:-ConvexHull instead, which is new to Maple 2018 and seems to use qhull.

It sounds to me as if you might prefer float results for your float data, in which case using PolyhedralSets (which requires rationals) is going to involve much slower exact arithmetic done by the Maple kernel. In contrast qhull will work using compiled external code on hardware floats.

Download int_ac.mw

I am guessing that you want the indexed names, eg, AE[i] rather than the name `AE[i]` .

In other words, I suppose that you want to index into the names, rather than append `[i]` to the names. (You originally wrote "append" in your Question, but I suspect that you want it mutable wrt i.)

Download fcnindex.mw

You could also do this example with,
  map(u->sign(u)*`?[]`(sign(u)*u,[i]),GST);
or,
  subsindets(GST,name,u->u[i]);
or,
  map(u->sign(u)*(sign(u)*u)[i],GST);

And if you're going to be doing this kind of change many times (for a variety of polynomials of subsets of these names),
  R:=map(u->u=u[i],indets(GST,name));  # once
  eval(GST,R);  # or similar

Download numerictripleint.mw

For the first term in A2 did you mean lambda^2*P[o](z)*(1+r^2) instead of P[o](z)*(1+r^2) ?

Download somesimplification.mw

Compare what you have done, with these choices for the tickmarks option:

tickmarks = [tickList, tickList, default]

tickmarks = [tickList, tickList, [0=0,1=1]]

tickmarks = [tickList, tickList, [op(map(rhs=rhs,rtable_elems(B))), 0=0]]

(The last two of those should give the same effect, for your B. I mentioned the last once only in case you later start putting in other values within B and want it to pick them up automatically.)

restart;

fseqn := (Se, f) -> Se^(f+1):

Vector(5, j->fseqn(2.1, j));

                      [  4.41   ]
                      [         ]
                      [  9.261  ]
                      [         ]
                      [ 19.4481 ]
                      [         ]
                      [40.84101 ]
                      [         ]
                      [85.766121]

Please try working with methods suggested for your earlier, very similar Questions, before asking even more on this theme.

Download another.mw

It's interesting that this works:

int(diff(f(x,y),x)*g(x)+f(x,y)*diff(g(x),x), x);

                          f(x, y) g(x)

For your goal, could you get dsolve to do it for you?

de := diff(K(x,y),x) = diff(f(x,y),x)*g(x,y)+f(x,y)*diff(g(x,y),x):

raw := dsolve({de}):

raw[1];

           {K(x, y) = _F1(y), f(x, y) = 0, g(x, y) = g(x, y)}

raw[2];

   /                                                K(x, y) + _F1(y) \
  { K(x, y) = K(x, y), f(x, y) = f(x, y), g(x, y) = ----------------  }
   \                                                    f(x, y)      /

solve(raw[2], K(x,y));

                  {K(x, y) = g(x, y) f(x, y) - _F1(y)}