MaplePrimes Questions

Can the AI Assistant in the Maple 2026 GUI be configured to use Anthropic's Claude Max plans, local AIs (e.g., via LM Studio), or other providers?

I am only occasionally using Maple versions with the new ribon user interface and noticed about 2 weeks ago that I cannot interrupt for loops under these interfaces. For example this one

for i to 1000 do
    i^i;
end do

I re-run the code today (after installing windows updates) and could interrupt before the screen was filled with output but not after executing the code a second time (without restart).

Is that reproducible on other installations?

Are there other commands that cannot be interrupted? 
If that is known, are there workarounds?

Update:
I have restarted Maple and have two worksheets open with the same code. I can repeatedly interrupt in one worksheet but not in other

Could anyone tell me what type of matrix normalisation this is and it it built into Maple? I found this in a paper and Google AI said this is the process of normailsation being used.

restart

with(LinearAlgebra):

J:=Matrix([[ 1 , 0 , 0 ],
        [ 0 , 1 , 0 ],
        [ 0 , 0 , -1 ]]);

Matrix(3, 3, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = -1})

(1)

Matrix N has already been scaled, so the rows are of equal magnitude  x^2 + y^2 - z^2= k

N:=Matrix(3, 3, [[4, -3, 2], [-1/2*sqrt(70), -3/10*sqrt(70), 1/5*sqrt(70)], [1/11*sqrt(77), 6/11*sqrt(77), 2/11*sqrt(77)]])

Matrix(3, 3, {(1, 1) = 4, (1, 2) = -3, (1, 3) = 2, (2, 1) = -(1/2)*sqrt(70), (2, 2) = -(3/10)*sqrt(70), (2, 3) = (1/5)*sqrt(70), (3, 1) = (1/11)*sqrt(77), (3, 2) = (6/11)*sqrt(77), (3, 3) = (2/11)*sqrt(77)})

(2)

 

for i to 3 do
add(N[i,j]^2,j=1..2)-N[i,3]^2;
end do

21

 

21

 

21

(3)

Normalisation process to produce C

A:=N.J.N^%T

Matrix(3, 3, {(1, 1) = 21, (1, 2) = -(3/2)*sqrt(70), (1, 3) = -(18/11)*sqrt(77), (2, 1) = -(3/2)*sqrt(70), (2, 2) = 21, (2, 3) = -(27/110)*sqrt(70)*sqrt(77), (3, 1) = -(18/11)*sqrt(77), (3, 2) = -(27/110)*sqrt(70)*sqrt(77), (3, 3) = 21})

(4)

dA:=DiagonalMatrix(1/~(sqrt~(abs(Diagonal((A))))));

Matrix(3, 3, {(1, 1) = (1/21)*sqrt(21), (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = (1/21)*sqrt(21), (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = (1/21)*sqrt(21)})

(5)

C:=(dA.A.dA);

Matrix(3, 3, {(1, 1) = 1, (1, 2) = -(1/14)*sqrt(70), (1, 3) = -(6/77)*sqrt(77), (2, 1) = -(1/14)*sqrt(70), (2, 2) = 1, (2, 3) = -(9/770)*sqrt(70)*sqrt(77), (3, 1) = -(6/77)*sqrt(77), (3, 2) = -(9/770)*sqrt(70)*sqrt(77), (3, 3) = 1})

(6)

evalf(C)

Matrix(3, 3, {(1, 1) = 1., (1, 2) = -.5976143047, (1, 3) = -.6837634587, (2, 1) = -.5976143047, (2, 2) = 1., (2, 3) = -.8581163304, (3, 1) = -.6837634587, (3, 2) = -.8581163304, (3, 3) = 1.})

(7)
 

 

Download 2026-08-14_Q_What_Type_of_Matrix_Normalisation.mw

I notice that Maple transactions journal does not publish any new issue ever since March this year. Based on the previous recording it is supposed to publish issue each season. When is it going to promote a new issue? My research is supposed to publish there and I believe I have made some interesting progress and it is of interest to the community.

Newbie here.  If L=[1/2, 1/3, 1/4], how can I display the unevaluated sum of the numerical terms in the list?  I don't want to use sigma notation. 

If L=[x,y,z], I can just do `+`(op(L)) to get x+y+z.  I can't make this work with numbers instead of variables.   Maple evaluates and gives me 13/12.  I want 1/2+1/3+1/4.

For the purpose of practicing with Maple, I have worked on a definite integral in the attached file. I found it on the Internet. According to a side calculation, it can only be calculated using famous special functions or series expansions. That is why I am only interested in the numerical evaluation here. According to auxiliary calculations, it can only be computed using famous special functions or a series expansion. It is known that the series expansion of the antiderivative converges very rapidly. Therefore, for comparison purposes, I calculated the values ​​for integration limits of 10 and 100 instead of infinity. In the first graph, the two result curves appear to coincide perfectly. Is there a way to zoom in locally - like using a magnifying glass - to make the difference in the ordinate values ​​visible?

restart

int(sinh((Pi-a)*x)/(cosh(Pi*x)*sinh(a*x)), x = -100 .. 100)

int(sinh((Pi-a)*x)/(cosh(Pi*x)*sinh(a*x)), x = -100 .. 100)

(1)

plot([int(sinh((Pi-a)*x)/(cosh(Pi*x)*sinh(a*x)), x = -100 .. 100), int(sinh((Pi-a)*x)/(cosh(Pi*x)*sinh(a*x)), x = -10 .. 10)], a = 0 .. 3.2, y = 0 .. 100)

 

plot(int(sinh((Pi-a)*x)/(cosh(Pi*x)*sinh(a*x)), x = -10 .. 10), a = 0 .. 3.2, y = 0 .. 100)

 

NULL

Download testint3.mw

Hello,

I found this sample code that determine the time to do matrix multiplications using cpus and gpus. I was surprised that the speedup factor was less than one.  I also did a similar speed test using python pytorch code on the same computer. The speedup factor was remarkable. Please find my mistakes, thanks.

MAPLE CODE:

kernelopts(version);
with(LinearAlgebra);
with(CUDA);
n := 4000;
M1 := RandomMatrix(n, n, datatype = float[8]);
M2 := RandomMatrix(n, n, datatype = float[8]);
printf("CUDA enabled? %a\n", IsEnabled());
tNoCUDA := time[real](M1 . M2);
printf("Time without CUDA: %.3f seconds\n", tNoCUDA);
prevSetting := Enable(true);
printf("Previous CUDA setting: %a\n", prevSetting);
printf("CUDA enabled now? %a\n", IsEnabled());
tCUDA := time[real](M1 . M2);
printf("Time with CUDA: %.3f seconds\n", tCUDA);
printf("Speedup factor: %.2f\n", evalf(tNoCUDA/tCUDA));
props := Properties();
printf("CUDA Device Properties:\n");
props;
Enable(false);
printf("CUDA enabled after disabling? %a\n", IsEnabled());

 

RESULTS:

  Maple 2026.0, X86 64 WINDOWS, Mar 05 2026, Build ID 2001916

CUDA enabled? false
Time without CUDA: 0.288 seconds
Previous CUDA setting: false
CUDA enabled now? true
Time with CUDA: 0.439 seconds
Speedup factor: 0.66
CUDA Device Properties:

[TABLE(["Clock Rate" = 2692000, "Resisters Per Block" = 65536, 

  "ID" = 0, "Texture Alignment" = 512, 

  "Max Grid Size" = [2147483647, 65535, 65535], 

  "Memory Pitch" = 2147483647, "Major" = 12, 

  "MultiProcessor Count" = 36, "Shared Memory Per Block" = 49152, 

  "Minor" = 0, "Name" = "NVIDIA GeForce RTX 5060 Ti", 

  "Max Threads Dimensions" = [1024, 1024, 64], "Warp Size" = 32, 

  "Total Global Memory" = 4294967295, 

  "Max Threads Per Block" = 1024, "Device Overlap" = 1, 

  "Total Constant Memory" = 65536, 

  "Kernel Exec Timeout Enabled" = true])]


CUDA enabled after disabling? false
 

Hello:

For educational purposes, I want to define the zeta function on a plot using textplot, so I write

textplot([2,3,Zeta(sigma+i*t)=Sum(1/n^(sigma+i*t),n=1..infinity)]...

But the characters "sigma+it" show up as "it+sigma" rather than "sigma+it" which is how most people would naturally read it.

Is there any way that I can convince textplot to order the output the way I set it?

I've tried single quotes, i.e. 'sigma+it' but that doesn't work.

Thank you.

I learned about automatic differentiation from an AI. Could you please tell me, what does Maple have for working with dual numbers in this regard? 
(I am experiencing some minor internet issues, so my response to your reply may be significantly delayed.)

I am trying to add this to my type list in a package, but cannot get it to work.

TypeTools:-AddType(_L3DP, set(satisfies(s -> type(s, [algebraic $ 3])),'Vector[column](3, algebraic)'));

when I test with this I get an error.

 type({[7,8,9],<1,2,3>},:-_L3DP);
Error, testing against an invalid type

or this 

type({[7,8,9],<1,2,3>},set(satisfies(s -> type(s, [algebraic $ 3])),'Vector[column](3, algebraic)'));
Error, testing against an invalid type

How do I vectorize a Maple graph—that is, export it in PDF quality—and add X and Y axis labels along with annotations?

By "annotations," I mean something like "green curve = 39T" written directly on the figure.

I need a more complete comand. After the comand, eu can ajust how I liked.

Given is a list of equations where the lhs is a name and the rhs an expression (i.e. list(name=algebraic).

I want to pass that list to a procedure and then assign locally the names to the values on the rhs. Similar to passing options in Maple commands (e.g. plot option numpoints=n).

The below, the example throws an error

restart;
foo := proc(params) 
local names; 
names := lhs~(params)[]; 
#local op(names);
print([names]):
assign(params); 
print(b, c, d); end proc;

foo([b = 2, c = 3, d = 4]);
foo([b = 2, c = 3, d = 4]); #  error because the assignement was done to global names

How to fix that and/or avoid assignements to global names

This the part of a procedure I have for removing common factors from matrices and vectors used in a projective geometry setting.
How can a get it to work so it handles polynomial denominators? Such as 

x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2

restart

 

ReduceM:= proc(C::{Matrix, :-_ProjM3})
            local i, tgdc, dnm, V1, Ml, SV1, ns, M, r;
            option overload;
            if C::'Matrix' then
                M := LinearAlgebra:-Copy(C);
            elif C::{':-_ProjM3'} then
                M := LinearAlgebra:-Copy(C[1]);
            end if;
            V1 := convert(M, list);
            SV1 := convert(M, set) minus {0};
            ns := nops(SV1);
            dnm := frontend(lcm, [seq(denom(SV1[i]), i = 1 .. ns)]);
            Ml := simplify(dnm *~ M);
            V1 := convert(Ml, list);
            tgdc := SV1[1];
            if tgdc = 0 then
                tgdc := 1;
            end if;
            for i from 2 to ns do
                tgdc := frontend(gcd, [tgdc, SV1[i]]);
            end do;
            r := `if`(C::'Matrix', simplify(factor~(Ml /~ tgdc)),
                <[simplify(factor~(Ml /~ tgdc))]>);
            return r;
        end proc:

 

 

A:=Matrix(3, 3, [[(x__2 - x__1)*(-y__2 + y__3) + (-y__1 + y__2)*(-x__3 + x__2), (x__2 - x__1)*(-y__1 + y__3) + (-y__1 + y__2)*(-x__3 + x__1), (x__2 - x__1)*(-y__1 + y__2) + (-y__1 + y__2)*(-x__2 + x__1)], [(x__3 - x__1)*(-y__2 + y__3) + (-y__1 + y__3)*(-x__3 + x__2), (x__3 - x__1)*(-y__1 + y__3) + (-y__1 + y__3)*(-x__3 + x__1), (x__3 - x__1)*(-y__1 + y__2) + (-y__1 + y__3)*(-x__2 + x__1)], [x__1*(-y__2 + y__3) + y__1*(-x__3 + x__2) - x__2*y__3 + x__3*y__2, (-y__1 + y__3)*x__1 + y__1*(-x__3 + x__1) - x__1*y__3 + x__3*y__1, (-y__1 + y__2)*x__1 + y__1*(-x__2 + x__1) - x__1*y__2 + x__2*y__1]])

Matrix(3, 3, {(1, 1) = (x__2-x__1)*(-y__2+y__3)+(-y__1+y__2)*(-x__3+x__2), (1, 2) = (x__2-x__1)*(-y__1+y__3)+(-y__1+y__2)*(-x__3+x__1), (1, 3) = (x__2-x__1)*(-y__1+y__2)+(-y__1+y__2)*(-x__2+x__1), (2, 1) = (x__3-x__1)*(-y__2+y__3)+(-y__1+y__3)*(-x__3+x__2), (2, 2) = (x__3-x__1)*(-y__1+y__3)+(-y__1+y__3)*(-x__3+x__1), (2, 3) = (x__3-x__1)*(-y__1+y__2)+(-y__1+y__3)*(-x__2+x__1), (3, 1) = x__1*(-y__2+y__3)+y__1*(-x__3+x__2)-x__2*y__3+x__3*y__2, (3, 2) = (-y__1+y__3)*x__1+y__1*(-x__3+x__1)-x__1*y__3+x__3*y__1, (3, 3) = (-y__1+y__2)*x__1+y__1*(-x__2+x__1)-x__1*y__2+x__2*y__1})

(1)

ReduceM(A)

Matrix(3, 3, {(1, 1) = 1, (1, 2) = 1, (1, 3) = 0, (2, 1) = 1, (2, 2) = 0, (2, 3) = -1, (3, 1) = -1, (3, 2) = 0, (3, 3) = 0})

(2)

B:=Matrix(3, 3, [[-(y__1 - y__3)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2) + (y__1 - y__2)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2), -(y__1 - y__3)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2), -(y__1 - y__2)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2)], [(-x__3 + x__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2) - (-x__2 + x__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2), (-x__3 + x__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2), (-x__2 + x__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2)], [-(x__1*y__3 - x__3*y__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2) + (x__1*y__2 - x__2*y__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2) - 1, -(x__1*y__3 - x__3*y__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2), -(x__1*y__2 - x__2*y__1)/(x__1*y__2 - x__1*y__3 - x__2*y__1 + x__2*y__3 + x__3*y__1 - x__3*y__2)]])

Matrix(3, 3, {(1, 1) = -(y__1-y__3)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)+(y__1-y__2)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2), (1, 2) = -(y__1-y__3)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2), (1, 3) = -(y__1-y__2)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2), (2, 1) = (-x__3+x__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)-(-x__2+x__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2), (2, 2) = (-x__3+x__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2), (2, 3) = (-x__2+x__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2), (3, 1) = -(x__1*y__3-x__3*y__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)+(x__1*y__2-x__2*y__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)-1, (3, 2) = -(x__1*y__3-x__3*y__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2), (3, 3) = -(x__1*y__2-x__2*y__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)})

(3)

ReduceM(B)

Error, (in gcd/Freeze) arguments should be polynomials

 

B*denom(B[1,1])

Matrix(3, 3, {(1, 1) = (x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)*(-(y__1-y__3)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)+(y__1-y__2)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)), (1, 2) = -y__1+y__3, (1, 3) = -y__1+y__2, (2, 1) = (x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)*((-x__3+x__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)-(-x__2+x__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)), (2, 2) = -x__3+x__1, (2, 3) = -x__2+x__1, (3, 1) = (x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)*(-(x__1*y__3-x__3*y__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)+(x__1*y__2-x__2*y__1)/(x__1*y__2-x__1*y__3-x__2*y__1+x__2*y__3+x__3*y__1-x__3*y__2)-1), (3, 2) = -x__1*y__3+x__3*y__1, (3, 3) = -x__1*y__2+x__2*y__1})

(4)

simplify( (4) );

Matrix(3, 3, {(1, 1) = -y__2+y__3, (1, 2) = -y__1+y__3, (1, 3) = -y__1+y__2, (2, 1) = -x__3+x__2, (2, 2) = -x__3+x__1, (2, 3) = -x__2+x__1, (3, 1) = -x__2*y__3+x__3*y__2, (3, 2) = -x__1*y__3+x__3*y__1, (3, 3) = -x__1*y__2+x__2*y__1})

(5)
 

 

Download 2026-08-03_Q_Remove_Common_Factors_from_Matrix.mw

I have two lists. I would like to confirm that one is a permutation of the other. Which Maple procedure does this?

Edit:
So surprising answer is Maple has no builtin one command to establish the fact.

Does GuessRecurrence require at least 7 terms in its input list?

1 2 3 4 5 6 7 Last Page 1 of 2467