You can now make an assignment with a Vector on the left-hand side and a Vector of the same size on the right-hand side.  This is element-wise assignment.

<x,y,z>:=<2,5,3>:

x;

$2$

y;

$5$

z;

$3$

The sort command was overhauled in Maple 2025 adding a new general sorting algorithm and introducing several new options.  For full examples, see sort.  Some of the new features include the following:

Support indexed names using lexorder and lexorder[n] sorting methods.  Previously these would lead to errors.

sort([b,c,c[1],a,a[1],a[a],a[2],a[1,2]],'lexorder');

$\left[a\&comma;a_1\&comma;a_{1,2}\&comma;a_2\&comma;a_a\&comma;b\&comma;c\&comma;c_1\right]$

sort([ [ 1, b[2], 1], [2,b,2], [3,b[1],3] ], 'lexorder'[2]);

$\left[\left[2\&comma;b\&comma;2\right]\&comma;\left[3\&comma;b_1\&comma;3\right]\&comma;\left[1\&comma;b_2\&comma;1\right]\right]$

New ascending and descending options have been added:

sort([3,1,2],'ascending'=true);

$\left[1\&comma;2\&comma;3\right]$

sort([3,1,2],'ascending'=false);

$\left[3\&comma;2\&comma;1\right]$

sort([3,1,2],'descending'=true);

$\left[3\&comma;2\&comma;1\right]$

sort([3,1,2],'descending'=false);

$\left[1\&comma;2\&comma;3\right]$

The new option, pass, allows pass-through of additional arguments to comparison function.

This example uses the pass option to allow a third argument to the comparison procedure.  Here, the {0,undefined} set will be passed as the third argument in each call to ecmp.

ecmp := proc(a,b,exclude)
   if a in exclude then
       false;
   elif b in exclude then
       true;
   else
       a <= b;
   end if;
end proc:

sort( [3,undefined,1,0,2], ecmp, 'pass'={0,undefined});

$\left[1\&comma;2\&comma;3\&comma;0\&comma;\mathrm{undefined}\right]$

Support was added to handle datatype-specific complex[8] and complex(sfloat) rtables when using key sort.

Here the key function is applied first, computing the modulus of each element, then the list is sorted by those values.

A := Array( [ 1+I, .5+2*I, I-.9], datatype=complex[8] );

$A≔\left[\begin{array}{ccc}1.+\mathrm{I}& 0.500000000000000+2.\mathrm{I}& \mathrm{-0.900000000000000}+\mathrm{I}\end{array}\right]$

sort( A, 'key'=(x->abs(x)) );

$\left[\begin{array}{ccc}\mathrm{-0.900000000000000}+\mathrm{I}& 1.+\mathrm{I}& 0.500000000000000+2.\mathrm{I}\end{array}\right]$

map(abs,A);

$\left[\begin{array}{ccc}1.41421356237310& 2.06155281280883& 1.34536240470737\end{array}\right]$

A new comparison algorithm, general, has been added that is especially useful when comparing mixed types.  The elements are sorted in the following way:

numeric values are sorted in ascending numerical order

symbols and strings are sorted in lexorder (ASCII order)

indexed names and unevaluated functions are sorted first by the name part, then, if both objects being compared have an index, then the index or argument sequence

lists, sets, and rtables are compared element-wise as long as there are still elements in the container.  The shorter container is considered less-than if it entirely matches the first n-elements of the other container.  Multi-dimension rtables are scanned in memory order, which is column-major by default.

specialized types are sorted by their id-classification, or objectid

sort( [ f(x,-3.1), f(x,2) ] );

$\left[f\left(2\&comma;2\right)\&comma;f\left(2\&comma;\mathrm{-3.1}\right)\right]$

sort( [ f(x,-3.1), f(x,2) ], 'general' );

$\left[f\left(2\&comma;\mathrm{-3.1}\right)\&comma;f\left(2\&comma;2\right)\right]$

Both key=keyFunc and a comparison function are now allowed simultaneously in the same call to sort.

Here the key function is applied first, computing the degree of each element, then the list is sorted by those degrees.

sort([x^2,x,x^5],'numeric',key=(x->degree(x)));

$\left[4\&comma;2\&comma;32\right]$

sort([x^2,x,x^5],'numeric',key=degree,descending);

$\left[4\&comma;2\&comma;32\right]$

Basic support for sorting of quantities with mixed units was added.

sort( [ 1*Unit(m),3*Unit(ft),30*Unit(cm)] );

$\left[30⟦\mathrm{cm}⟧\&comma;3⟦\mathrm{ft}⟧\&comma;⟦m⟧\right]$

We noticed that sort is often accidentally called with a set as an argument.  Given that sets are already in a fixed order that can not be changed, this could lead to surprises in user code.  As a result, when a non-default sort algorithm is specified, we now return a sorted list instead of an unsorted set in this case, and introduced a new option, kernelopts(sortsetoutput), to allow enabling of the previous behavior.  For details see Calling sort on a Set.

myset := {b[1],a[1],a};

$\mathrm{myset}≔\left\{a\&comma;a_1\&comma;b_1\right\}$

sort(myset);

$\left\{a\&comma;a_1\&comma;b_1\right\}$

sort(myset,'lexorder');

$\left[a\&comma;a_1\&comma;b_1\right]$

The efficiency of sort has been improved when using custom comparison functions. For example, the following call is now twice as fast as Maple 2024.

N := 10^4:

data := LinearAlgebra:-RandomVector(N):

CodeTools:-Usage(sort(data,(a,b)->a>b)):

memory used=6.02MiB, alloc change=0 bytes, cpu time=54.00ms, real time=54.00ms, gc time=0ns

In order to make the various options and capabilities of sort more clear, the documentation has been updated and reorganized.  Additionally the description of sorting of algebraic objects like polynomials has been separated onto its own page, independent of the topic of sorting of data inside lists and arrays.

The new MathML:-FromLatex command converts a LaTeX expression to MathML, and optionally further processes it into a Maple expression.

L := "\\cos (2\\theta) = \\cos^2 \\theta - \\sin^2 \\theta":

mml := MathML:-FromLatex(L);

$\mathrm{mml}≔''$ \cos \&\#x00028;2\mathrm{\&\#x003B8;}\&\#x00029;\&\#x0003D;{\cos }^2\mathrm{\&\#x003B8;}\&\#x02212;{\sin }^2\mathrm{\&\#x003B8;}$''$

mml := MathML:-FromLatex(L,output='maple');

$\mathrm{mml}≔\cos \left(2\mathrm{\theta }\right)={\cos \left(\mathrm{\theta }\right)}^2-{\sin \left(\mathrm{\theta }\right)}^2$

The ArrayTools:-Remove command has been updated to understand empty range endpoints.

In Maple, you can use shorthand Array indexing syntax.  For example, A[5..] means all the entries starting with 5 and going to the end of the data.  The ArrayTools:-Remove command now supports this syntax.

A := Array(1..10,i->i);

$A≔\left[\begin{array}{cccccccccc}1& 2& 3& 4& 5& 6& 7& 8& 9& 10\end{array}\right]$

ArrayTools:-Remove(A,5..);

$\left[\begin{array}{cccc}1& 2& 3& 4\end{array}\right]$

As of Maple 2025, the sum command has special evaluation rules.  Thus, unevaluation quotes are no longer necessary when summing over certain indexed expressions.  For example, previous versions of Maple required single quotes around v[k] in this example.  This is no longer necessary.

v := Vector([1,2,3,4,5]);

$v≔\left[\begin{array}{c}1\\ 2\\ 3\\ 4\\ 5\end{array}\right]$

sum(v[k],k=1..5);

$15$

The StringTools:-DecodeEntities command now understands a wider list of entity names.

StringTools:-DecodeEntities("&varepsilon;");

$''\epsilon ''$