Smarter than Tarjan, perhaps, but slower:

Download GenericCyclesArraysVerticesOnly2.mw

I looked into this a while ago, and found Tarjan's backtracking algorithm is quite efficient, implementing the stack with Maple's DEQueue (not using the double ended feature). I just implemented it as stated; it may be able to be improved (perhaps the stack clearing). This doesn't use the cycle basis though.

Download Tarjan.mw

Code in startup code reproduced here (version that just counts is also there). 

# Tarjan outputs a table with all cycles of a graph, indexed by the size of the cycles
# for an undirected graph each cycle except the 2-cycles appears twice, once for each orientation.
Tarjan:=proc(G::GRAPHLN);
  local V,AA,backtrack,cycles,marked_stack,point_stack,mark,A,u,i;
#  
  backtrack:=proc(s,v)
    local f,u,w,g;
    f:=false;
    push_back(point_stack,v);
    mark[v]:=true;
    push_back(marked_stack,v);
    for w in A[v] do
      if w<s then
        A[v]:=A[v] minus {w};
      elif w=s then
        cycles[numelems(point_stack)][convert(point_stack,list)]:=NULL; #record cycle
        f:=true;
      elif not mark[w] then
        g:=procname(s,w);
        f:=f or g;
      end if; 
    end do;
    if f then
      while back(marked_stack)<>v do
        u:=pop_back(marked_stack);
        mark[u]:=false
      end do;
      pop_back(marked_stack);
      mark[v]:=false;
    end if;
    pop_back(point_stack);
    return f;
  end proc:
#
  V:=GraphTheory:-NumberOfVertices(G):
  AA:=op(4,G):
  cycles:=table():
  marked_stack:=DEQueue():
  point_stack:=DEQueue():
  mark:=Vector(V,'fill'=false): 
  for i to V do
    A:=copy(AA);
    backtrack(i,i);
    while not empty(marked_stack) do
      u:=pop_back(marked_stack);
      mark[u]:=false;
    end do;
  end do;
  map({indices},cycles,'nolist');
end proc;

Download maximize.mw

Download LinearSystem.mw

Here's one way.

Download cis.mw

Here are two suggestions.

Download Heaviside.mw

For me (2023.0, Windows 10), the second one hangs, but if I use the stop icon (after 250 s) it quickly ends and prints "done", and then I can continue to use Maple as normally.

Here's how I do least squares fits with numerical solutions from dsolve. I bypass the parameters facility of dsolve. I've only tested this on the derivative-free nonlinearsimplex method [but see below]. I use the matrix method call to NLPSolve; for the procedure method it seemed I had to hard-code the number of parameters in the internal procedure SS.

Edits: it seems to work with sqp, but the initial point had to be closer. Updated with streamlined version.

Download defit.mw

Download assign.mw

You can do the assign as you read a line by putting a line such as "splog=0.56" into a variable str, and then use

assign(parse(str));

In this case, the points of the polyhedron and its convex hull are the same, so ConvexHull in the ComputationalGeometry package works

Download volume.mw

If you work out the exact x range for the spacecurve it works, e,g, for the circle it is just x=-3..3. For the ellipse see the attached. Alternatively, you can just use numpoints=10000

SectionsConiquesTest.mw.

The T you used in ConvertIn(T) is not the same as the internal one. The easiest way to get around this is always to provide an irreducible polyomial to GF, then the variable you use there can be used.

Download GF.mw

CUDA only helps speed up numerical floating point matrix multilpication, which will not help your symbolic solution of polynomial equations. See ?CUDA,supported_routines

Download subs.mw

You need A[1] and A[2], not A__1 and A__2 (they look similar in the output). A__1 is just a name that appears as A with a subscript, but it is not related to the Array A.

plots.mw