Use

uu := pds:-value(u(x,t));

This returns a procedure you can give x and t values to. For example,

uu(0.0001,0.1);

gives

value.mw

Here's one way

plot(t,'title'=InertForm:-Typeset(the_title),size=[300,300]);

You can use SimilarityTransformation directly without using Eq 29. For the second paper, I don't know about prolongations, which seem to be done with Eta_k. I'm guessing by choosing the arbitrary functions appropriately you can get what you want.

Download Lie.mw

There are 510 paths, which agrees with the formula in your linked page. The approach, which works for any paths, not just Hamiltonian ones, here uses "multiplication" of modified adjacency matrices in a similar fashion to this post. However in this case I track the vertices using the Bits package, with one bit per vertex, and kill a walk whenever it revisits a vertex, and I hard coded the modified matrix multiplication rather than use LinearAlgebra:-Generic. (I'm short on time or I would describe the algorithm in more detail.)

The code can output the vertices visited (coded as an integer) but not their order, which is useless in this case, where all paths visit the same vertices. (For a DAG this would be enough to reconstruct the paths.)

Download Paths.mw

Paths:=proc(G0::Graph,V1,V2,{minlength::posint := 1, maxlength::posint := GraphTheory:-NumberOfVertices(G0)-1, output_paths::truefalse := false})
	uses GraphTheory;
	local k, A, Adj, B, n, i, j, SetBit, verts, v1, v2, row, col, mrow, V, s, vec, paths, nrows, G, VerticesG,
		terminals_done, terminals, outdegs, killarcs, new_terminals;
	G := CopyGraph(G0);
	VerticesG := Vertices(G);
	n := NumberOfVertices(G);
	# output table records number of paths (output_paths = false) or Vectors of paths as coded integers (output_paths = true)  
	paths := table('sparse'):
	if _params['V1'] = NULL and _params['V2'] = NULL then
		verts := false;
	elif _params['V1'] = NULL or _params['V2'] = NULL then
	     error "must be zero or two vertices specified"
	else
		if not member(V1,VerticesG,'v1') then error "Vertex %1 not in graph",V1 end if;
		if not member(V2,VerticesG,'v2') then error "Vertex %1 not in graph",V2 end if;
		verts:=true;
	end if;
	# if we are looking for paths between vertices on a digraph, remove extraneous pieces of the graph
	if verts and IsDirected(G) then
		if OutDegree(G, V1) = 0 then error "start vertex has no departures" end if;
		if InDegree(G, V2) = 0 then error "end vertex has no arrivals" end if;
		userinfo(2, procname, "pruning extra vertices from digraph");
		terminals_done:={V1}; # can't delete V1
		do 
			outdegs:=map2(OutDegree, G, VerticesG); # includes isolated vertices
			terminals := {remove(`=`, VerticesG[[ListTools:-SearchAll(0, outdegs)]], V2)[]};
			new_terminals := terminals minus terminals_done;
			if nops(new_terminals) = 0 then break end if;
			killarcs := map(t -> seq([i, t], i in Arrivals(G, t)), new_terminals);
   			DeleteArc(G, killarcs);
			terminals_done := terminals_done union terminals;
  		end do;
  		terminals_done := terminals_done minus {V1};
  		# and delete departures from last vertex so Matrix is zero at the end
  		if OutDegree(G, V2) = 1 then
  			DeleteArc(G, [V2, Departures(G,V2)[]])
  		elif OutDegree(G, V2) > 1 then
  			DeleteArc(G, [seq([V2, i], i in Departures(G,V2))])
  		end if;
  		# update graph, n, v1, v2, VerticesG
		G := DeleteVertex(G, terminals_done);
		userinfo(2, procname, "%1 extra vertices deleted", nops(terminals_done));
		VerticesG := Vertices(G);
		n := NumberOfVertices(G);
		member(V1,VerticesG,'v1');
		member(V2,VerticesG,'v2');
	end if;
	# set up adjacency matrices.
	Adj:=AdjacencyMatrix(G);
	SetBit := p -> integermul2exp(1, p - 1);
	A := Matrix(n, n, (i, j) -> if Adj[i, j] = 1 then SetBit(j); else 0; end if);
	if verts then # for B we only need the row corresponding to the first vertex
		nrows:=1;
		B :=Matrix(1, n, 'storage' = 'sparse', order = 'C_order');
		for j to n do
    			if Adj[v1, j] = 1 then B[1, j] := Vector([Bits:-Or(SetBit(v1), SetBit(j))]); end if;
    		end do;
    		if not output_paths then
    			paths[1]:= Adj[v1, v2];		
    		elif minlength = 1 then
    			paths[1] := B[1, v2] # 0 or a vector
    		end if  			
    	else
    		nrows := n;
		B := Matrix(nrows, n, 'storage' = 'sparse', order = 'C_order');
		for i to n do
			for j to n do
    				if Adj[i, j] = 1 then B[i, j] := Vector([Bits:-Or(SetBit(i), SetBit(j))]); end if;
    			end do
    		end do;
    		if not output_paths then
    			paths[1] := add(Adj);
    		elif minlength = 1 then
    			paths[1] := Vector([entries(B,'nolist')]);
    		end if
    	end if;
	# do the matrix multiplications and collect the paths of each length
	for k from 2 to n-1 do   
		for row to nrows do # rows of B diving down ...
			mrow := B[row]; # (save row so can do in-place)
			for col to n do # ... cols of A
				V := Vector():
				s := 0;
				for i, vec in mrow do
					if A[i, col] <> 0 then
						for j to numelems(vec) do
							if Bits:-And(vec[j], A[i,col]) = 0 then # not a repeat vertex
								s := s+1;
								V(s) := Bits:-Or(vec[j], A[i,col]); # add the vertex
							end if
						end do
					end if
				end do:
				if numelems(V) = 0 then
					B[row,col] := 0;
				else	 
					B[row,col] := V;
				end if;
			end do
		end do;
		if andmap(`=`,B,0) then break end if;
		if verts then
			if not output_paths then
				paths[k] := ifelse(B[1, v2] = 0, 0, numelems(B[1, v2]));
			elif k >= minlength and k <= maxlength then
				paths[k] := B[1,v2];
			end if;
		else
			if not output_paths then
				s := 0;
				for i, vec in B do
					s + numelems(vec)
				end do;
				paths[k] := s;
			elif k >= minlength and k <= maxlength then
				paths[k] := Vector([entries(B,'nolist')]);
			end if;	
		end if;
	end do;
	eval(paths)
end proc;

Here's one way.

results2 := Matrix(map2(eval, [N, tbo, two], [seq(results)]));

PrimesQuestion.mw

The following URL finds my Orbitals package

https://www.maplesoft.com/Applications/Detail.aspx?id=4865

but substituting your ID doesn't find anything, suggesting that the ID is no longer valid or the application is not there.

It is much easier to use a code edit region. But you can do it your intended way with EvalString instead of Run. GetVariable returns the variable to Maple. Here are both ways:

python.mw

As the help page for try says, the "too many levels of recursion" error is one of the few that can't be caught.

The paper doesn't make much sense.

Download S-test.mw

It is one of the HTML symbols. If you enter it in 1D as `≃` then select the output, right-click and choose comtext panel, one of the options is add to favourites.

With inttrans, I can often get an answer by assuming positive, even though this might not be the case. One can then check if it makes sense; not sure about that in this case. I didn't see any intermittent issues.

Download fourier.mw

[Updated. I've realised C simplifies to zero, so it can be simplified further. There are different cases for zero or positive A, and zero, positive or negative B.

Download Q_solve2.mw

Older:

Q_solve.mw

Download f-p-second.mw

I don't know about (24) - perhaps the paper has a typo in the ode (missing m?).

For (25) and (26), I corrected typos in magenta and the tests are verified.

I don't know about (30) or (31).

There seem to be typos in (40) and (41) but that doesn't solve the problems.

ode-17.mw

You didn't provide explanation about the Weierstraa cases (what is f3?). Maple has the WeierstrassP and WeierstrassPPrime.

The <> constructors are useful here:

ga_zero := <IdentityMatrix(2), ZeroMatrix(2); ZeroMatrix(2), -IdentityMatrix(2) >;

or

ga_zero := <<IdentityMatrix(2) | ZeroMatrix(2)>, <ZeroMatrix(2) | -IdentityMatrix(2)>>;