You seem to be concerned with prime factors. Is that right? (I'm supposing so. You didn't use that specific word. But you mentioned ifactor.)

For a given k, do you want to do this for all of the prime factors of k, or just some of them, or just one of them? (If you have a large number of examples, etc, then you might want an especially efficient approach that scales well. I don't know how you intend to use the information.)

If you want them all, and want to look up those values repeatedly, then you could turn the results from ifactors into a table.

Below, the procedure p scans the list g until it finds the entry (here, sublist) whose own first entry equals b. Then it stops and returns the second entry of that, ie. the corresponding multiplicity. I'm presuming that you will be calling it only for a b that you know is a present (you could adjust if you need a graceful fail, otherwise, or other sanity checking).

Download facst.mw

But if your situation is that you want to test only a small number of factors for a number (that is, say,relatively expensive to factor completely) then you might wish to avoid ifactors altogether. I don't know your situation.

The Help page for the Play command of the AudioTools package has an example like that.

That example is preceded closely by a statement that one must insert a Speaker component.

How's this?

Styrkelære2regneopgaver_ac1.mw

(There might be a missing input just after the line with the text "indersiden af beholderen har vi", in subsection "Opgave 12".)

@Tycho Brahe You can download the installer for the Maple 2022.2 update here.

It helps to use another range.

Download ellipse_rng.mw

It's not entirely clear to me what you mean.

But you could use add, or a do-loop, as follows.

Download simple_sum.mw

You recently mentioned that SMTLIB was not working properly on your Windows 10 machine. 

The command SMTLIB:-Satisfiable gets called on your example(s), returning false on my Maple 2023.0 for Linux.

I suspect that you might be seeing that FAIL result in consequence. Here is the trace of that command for the last example.

Download Unable_to_prove_ac.mw

It's because you misspelled Cl as CL in your call to solve.

By the way, you don't have to specify the variables, in this case.

There may be more than just one single solution.

Download Chem_ac.mw

Why use the heavyweight implicitplot3d construction, in order to produce a plane along x=y?

G1 := plots:-tubeplot([4*t, -1, t], t = -10 .. 10, radius = 0.2, color = blue):
G2 := plots:-tubeplot([1, t, t^2], t = -15 .. 15, radius = 0.2, color = blue):
G3 := plot3d([x, x, z], x = -40 .. 40, z = -400 .. 700,
             color = gray, transparency = 0.7, glossiness = 0):
Line:=(q,t)->[4*q+(1-4*q)*t,-1+(1-4*q)*t,q+(16*q^2-q)*t]:
F:=Q->plots:-display(
        plottools:-line(Line(Q,-1.5),Line(Q,+2.5),color=red,thickness=5),
        plot3d([4*q+y+1,y,q+(y+1)*(16*q^2-q)/(1-4*q)],
               q=-4..Q, y=(-2.5+6*q)..(1.5-10*q),
               style=patchcontour, lightmodel=light4, axes=framed)):
plots:-animate(F, [q], q=-4..4, frames=50, lightmodel=light1,
               background=[G1,G2,G3]);

Naturally, you can adjust the ranges, color, transparency, and style, to taste.

Here's something (much more than the Maple 2022.2 GUI recovers.) I suggest that you check it over for missing parts.

alle-maple_3_ac1.mw

Here is one way to deal with the extra "characters".

Does the following get all the valid data? (I didn't try to find a more efficient way. I don't know whether you have to make this scale well for huge examples.)

some_import.mw

If that import suffices, do you also need to know how to separate the headers from the numeric data? That's quite straightforward (compared to the character removal step, IMO). You could also search for the first numeric row, or the row with "X:","Y:", etc. Note that not all the header sections have the same number of rows, eg. only some have "PlateletFunction".

Those uneval quotes around the type specification of the procedure's parameter are misplaced.

Try it instead as,

  f1 := proc(A::RandomVariable)
     Mean(A)
  end proc:

Type_RandomVariable_ac.mw

The type is not evaluated in the procedure's parameter's specification (including when invoked), though it is within a procedure's body.

An example where quoting the type may be needed in the procedure's body:

restart;
p := proc( M::Matrix(square) )
  if type(M, 'Matrix(square)') then
    print("1st passed");
  end if;
  if type(M, Matrix(square)) then
    print("2nd passed");
  end if;
end proc:

p(Matrix(2));
                          "1st passed"
Error, (in Matrix) dimension parameters are required for this form of initializer

[edited] For the sake of clarity I'll add that the absence of evaluation does not come from the double-colon syntax per se. See this Help page. So, revising that example's syntax, the behavior is similar.

restart;
p := proc( M::Matrix(square) )
  if M::'Matrix(square)' then
    print("1st passed");
  end if;
  if M::Matrix(square) then
    print("2nd passed");
  end if;
end proc:

p(Matrix(2));

                          "1st passed"
Error, (in Matrix) dimension parameters are required for this form of initializer

Does this suffice? (Add checks for other kinds of terms, etc, if needed.)

F := [x^2-z^2, x*y+y*z, x*z-y*z, y^2+y*z,w^2]:

# make it harder
sort~(F, order=plex(z,y,x));

   [-z^2+x^2, z*y+y*x, -z*y+z*x, z*y+y^2, w^2]

map(proc(u) local uu:=sort(u,':-order'=':-plex'(x,y,z));
            if uu::`+` then op(1,uu)=-op(2,uu);
            else uu=0; end if; end proc, F);

   [x^2 = z^2, x*y = -y*z, x*z = y*z, y^2 = -y*z, w^2 = 0]

You didn't say whether it was ok to have such an in-place effect on the terms in F, so I presume it's ok.

You could alternatively sort all of F up front, together in one call, wrt the desired ordering. Then map the conditional, op, etc.

I deliberately sorted otherwise, at the start, so that the problem would be harder -- by having the terms in the sums be stored out-of-order. The point is that you don't want to rely on the good fortune that they might just happen to already appear in your desired order.

e1:= -(b*(b^2 - 4*a*c)^(1/2) - 4*a*c + b^2)/(2*a*(b^2 - 4*a*c)^(1/2)):

evala(e1);

   -1/2*((-4*a*c+b^2)^(1/2)+b)/a

simplify_exA.mw

A more involved way, which happens to use simplify,

   simplify(expand(rationalize(e1)))

You asked about a "general" way. The presence of the radical in the denominator is key, in the given example. The evala command is often useful in such cases -- sometimes more directly so than rationalize.

Maple performs the following, a kind of canonicalization,

cot(90 - alpha/2);

   -cot(-90+1/2*alpha)

However,

eq := x = -sin(alpha)*(L + (e + r)/tan(-Pi/4 + alpha/2))/2 + sin(alpha)*L:

simplify(eq);

   x = 1/2*((e+r)*tan(1/4*Pi+1/2*alpha)+L)*sin(alpha)