It is, of course, trivial to scale the results below by the appropriate 1/2^k , simply by multiplying the generated Matrix by that factor. Or you can scale the two Matrix arguments passed into the procedure Gen.

Download block_band_matrix.mw

Using Maple 2015.2,

convert(hypergeom([a, b], [c], 1), StandardFunctions);

                   GAMMA(c) GAMMA(c - a - b)
                   -------------------------
                   GAMMA(c - a) GAMMA(c - b)

convert( hypergeom([a, b], [c], 1), GAMMA_related );

                   GAMMA(c) GAMMA(c - a - b)
                   -------------------------
                   GAMMA(c - a) GAMMA(c - b)

Also,

restart;

kernelopts(version);

    Maple 2015.2, X86 64 LINUX, Dec 20 2015, Build ID 1097895

 simplify( hypergeom([a, b], [c], 1) );

              GAMMA(c) GAMMA(c - a - b)
              -------------------------
              GAMMA(c - a) GAMMA(c - b)

restart;

kernelopts(version);

    Maple 18.02, X86 64 LINUX, Oct 20 2014, Build ID 991181

simplify( hypergeom([a, b], [c], 1) );

              GAMMA(c) GAMMA(c - a - b)
              -------------------------
              GAMMA(c - a) GAMMA(c - b)

I don't understand why some of your Questions are marked as Maple version 2015, and some with version 18, and some with 2018.

If you expression attains it maximum at the end-point x=100, for each R, then could you not just divide by the value there? I mean, divide the original expression by the expression evaluated at x=100.

Let's pretend that your example would not have that behaviour, and that the maximum value is attained at a different numeric x for each different numeric R.

More generally, you can construct a procedure that admits the value val for the parameter name nm, and then optimizes w.r.t. x=1..100. And this procedure could be made to return unevaluated if its first argument val is not a numeric value. And then you could plot the original expression divided by a call to that maximizing procedure.

The plot3d command would pass in different values for val.

The procedure could attempt to remember the return value for given values of val, since plot3d will pump in the same val several times (as it computes for both different x and different R, say).
 

Download Cara_thing.mw

I'm not really sure what your goal is.

Is it something like this?

Download collect_numer.mw

If that's right, then it would be slightly more efficient to do it as follows, and thereby call `denom` only once.

temp := denom(f):
collect(numer(f),[k,GAMMA],u->u/temp);

Download string_subs.mw

I see three Sections in the uploaded Document, because the file is corrupted starting in the third Section.

Beton_Notat_og_opgaveark_ac.zip

I don't see anything past that point, as meaningful data.

On the other hand, the Standard GUI itself fails to recover and save as usable anything but the first two sections. Even when it claims (via file manager popup) that it's attempting to recover from the corrupt file, the Standard GUI still fails to close off the XML tags open at the end of the incomplete third section, and thus fails to recover all possible from that section in usable way. I find that to be disappointing behavior (and I've submitted several bugs reports about it).

There have been several dozen related reports over the years. It's not clear whether the primary trigger of the bug is the Danish language pack extension, or the inlining of several large images/canvases in the Documents. 

I may be able to address usefully only your first point.

When a Code Edit Region is collapsed a snippet is displayed, almost like a title of sorts. That's taken from the first line of the Region. If the first line is empty then so can that snippet be...

I've learned not to leave the first line of a Code Edit Region empty.

If you know the component's identity then you can toggle its `visible` property with the SetProperty command of the DocumentTools package.

If an Embedded Component (of which Code Edit Regions are one sort, under the hood) is toggled visible=false and you don't know its identity then the situation is a little tricky. On Sept 19, 2018 someone asked a Question about that. I answered with code which can be used/modified to return the identities of all components of a given sort.

I'm away from a computer for a few days, and copying the link to that other thread is hard, sorry.

For the followup example, even though combine (alone) is enough to handle the expression for t<1, I'll use combine@factor@expand below since it produces a terse form (with combined exponent) for either case t<1 and t>1.

restart;

expr := ((1-t)^2)^q;

                                    q
                          /       2\ 
                          \(1 - t) / 

combine(factor(expand(expr))) assuming t < 1;

                                 (2 q)
                          (1 - t)     

combine(factor(expand(expr))) assuming t > 1;

                                 (2 q)
                          (t - 1)

It also happens to fix up the inadvertantly expanded result from calling simplify under the assumption t>0, which the OP did. That is not fixed by wrapping with combine alone. (Here, combine@factor is enough.)

alt := simplify(expr) assuming t > 1;

                                      q
                        /           2\ 
                        \1 - 2 t + t / 

combine(factor(expand(alt))) assuming t > 1;

                                 (2 q)
                          (t - 1)

I have a mild fondness for uniform approaches. (Not that this solves all other examples, of course!)

restart;

kernelopts(version);

    Maple 2018.0, X86 64 LINUX, Mar 9 2018, Build ID 1298750

sum(1/(1+x)^t, t=1..infinity, formal);

                               1
                               -
                               x

See also the Help page for topic updates,Maple2016,AdvancedMath and on that page the link to the bookmark #SymbolicSummation .

An unadorned and unmatched, literal, single right-quote is not valid syntax in the plaintext Maple language.

What you're asking for cannot be done with a literal single right-quote in plaintext 1D Maple Notation, unless it is wrapped in either a set of quotation marks or a set of left-quotes (aka name quotes).

And even such a quoted, literal, single right-quote were entered you'd still have to set things up to interpret it as a derivative. Which could be tricky if you want the notation to work automatically for any arbitrary function name, and not just f.

restart;

cc := arctan(sin(phi)/cos(phi))-arccos(cos(phi)):

simplify( cc ) assuming phi>0, phi<Pi/2;

                   0

simplify(evalc(convert( cc, ln ))) assuming phi>Pi/2, phi<Pi;

                  -Pi

simplify(expand( eval(cc,phi=x+2*n*Pi) )) assuming n::posint, x>0, x<Pi/2;

                   0

# non-constant
convert(simplify(evalc(convert( cc, ln ))),tan) assuming phi>Pi, phi<3*Pi/2;

          -Pi + arccot(cot(2 phi))

dd := arctan(sin(phi),cos(phi))-arccos(cos(phi)):

simplify( dd ) assuming phi>0, phi<Pi;

                   0

simplify(expand( eval(dd,phi=x+2*n*Pi) )) assuming n::posint, x>0, x<Pi;

                   0

eval(cc, phi=5*Pi/4);

                   Pi
                - ----
                   2

restart;
A:=45*Unit(cm): B := 5.3*Unit(m):
C:=A+B;
          C := 45 [cm] + 5.3 [m]

C:=simplify(C);
           C := 5.750000000 [m]

Units:-Standard:-round( C );
                6 [m]

restart;
with(Units:-Standard, round):
A:=45*Unit(cm): B := 5.3*Unit(m):
C:=A+B;
          C := 45 [cm] + 5.3 [m]

C:=simplify(C);
           C := 5.750000000 [m]

round(C);
                6 [m]

restart;
with(Units:-Standard):
A:=45*Unit(cm): B := 5.3*Unit(m):
C:=A+B;
           C := 5.750000000 [m]

round(C);
                6 [m]

Another difference is that Units:-Standard:-round will not automatically "combine" units to the base SI units. In the following example it will not turn cm into meters, where round(0.054) becomes zero.

restart;
C :=  5.4*Unit(cm);
                C := 5.4 [cm]

simplify( round( C ) );
                     0

Units:-Standard:-round( C );
                   5 [cm]

combine( round( C ), units );
                  1/20 [m]

So which approach you choose could depend on whether you want rounding in terms of the original unit or the base SI unit.

It is an initially known constant in Maple, as a stand-in for Euler's constant (also known as the Euler-Mascheroni constant).

See the help page for Topic initialconstants.

evalf(gamma);

                   0.5772156649

Download some_log10.mw

The fine structure constant is not a derived constant in the ScientificConstants package.

Using rhs on a particular indexed position where you think an equation might lie -- when that position might vary -- is not a great idea. (It is common, inferior use of results from dsolve numeric, with listprocedure output.)

Download const_derive.mw