I used eval to substitute C1 and C2 into psi, which had square brackets around that I removed. Then the limit works. You should be usung LinearAlgebra rather than linalg.

limit.mw

I usually force the hardware type I want, here integer[8]. Then you get an explicit error about the overflow.

Note that tail recursion gives a massive speedup - as the documentation says: "During compilation, tail-recursive calls are detected and transformed into iteration. This means that tail-recursive procedures compile to very fast code."

Download fibonacci.mw

Eigenvalues are efficiently calculated for floating point matrices, and if you specify shape=symmetric then it will use an algorithm for symmetric matrices that returns real eigenvalues. (Calculating through eigenvalues is better than through the characteristic polynomial).
 

Download evals.mw

Not sure about types of matrices, normal, diagonalizable, large or small etc, but this might be useful. For general M,N there is unlikely to be a solution.

Download evs.mw

I'm guessing there are further rules to appear?

(I'm a liitle surprised my earlier code https://www.mapleprimes.com/questions/233777-Pythagorean-Puzzle#answer285102 works for these edge cases, since I didn't think about them at the time.)

Download OneOhm.mw

Not sure exactly what you want - here is a start.

Download Group.mw

Edit: here some of it in the older group package, if you have Maple earlier than version 17

oldgroup.mw

Download sum.mw

If you export as .rtf, you should be able to open it in Word, in a form that allows it to be modified.

Select all the font files (ctrl-A), and then the right-click menu has install or install for all users. (Double-clicking a single font file will install it.)

Not sure exactly what shape and size you want, but easiest to just declare b as an upper triangular matrix before generating the b[i,j] which go into it.You then get an error because you assigned a non zero entry for the lower triangular part. (Edit: I removed b[j,i]:=b[i,j] to fix that.) Probably you can fix this up to do what you want. (You should avoid using b for more than one purpose.)

bmatrix.mw

Yes, if typesetting is standard then you get the 2D output close to the version you see.

`Methods for first order ODEs:``--- Trying classification methods ---``trying a quadrature``<- quadrature successful`                         sol := y(x) = -cos(x) + _C1

Note that for the lprinted lines, each line is delimited with backquotes, so you could use this to insert linebreaks.

Well, I would just use view not to see the others, since you end up making another list otherwise. But I fixed your `if`; you want NULL to remove the list element (and there was something strange about the first "abs")

Download plotting.mw

II:=int(q*(ln((-(w+t)^2+(q+p)^2-I*n)/(-(w+t)^2+(q-p)^2-I*n))
    +ln((-(-w+t)^2+(q+p)^2-I*n)/(-(-w+t)^2+(q-p)^2-I*n))), q,'CauchyPrincipalValue'):
simplify(II) assuming positive;

The answer is very long and probably not useful. But don't you want some integration limits?

I modified my earlier version to include the resistances as the edge weights and modified it also to accept non-integer vertex labelling (as often used in SpecialGraphs).

Resistance:=proc(G::Graph,Vin,Vout)
  local dG,VertexIn,VertexOut,nV,nE,currents,voltages,VertexLabels,
    currInOut,nodeeqns,deviceeqns,arcs,k,i,v,x,ans,R,wG;
  uses GraphTheory;
  if IsDirected(G) then error "Must be an undirected graph" end if;
  nV:=NumberOfVertices(G);
  nE:=NumberOfEdges(G);
  # convert unweighted Graph to weighted Graph with unit weights
  if IsWeighted(G) then wG:=CopyGraph(G) else wG:=MakeWeighted(G) end if;
  R:=WeightMatrix(wG);
  # convert to graph with integer vertex names
  VertexLabels:=Vertices(wG);
  wG:=RelabelVertices(wG,[$(1..nV)]);
  if not member(Vin,VertexLabels,'VertexIn') then error "Vin is not a vertex of the Graph" end if;
  if not member(Vout,VertexLabels,'VertexOut') then error "Vout is not a vertex of the Graph" end if;
  if VertexIn=VertexOut then return 0 end if;
  VertexIn,VertexOut:={VertexIn,VertexOut}[]; # want VertexIn<VertexOut
  arcs:=map(convert,Edges(wG),list);
  dG:=Graph(Vertices(wG),arcs); # directed version required for signed incidence matrix
  # Define voltages per node. Current arrow direction for edge {j,k} is j->k (j<k)
  currents:=[seq(i[j],j=1..nE)];
  voltages:=[seq(v[j],j=1..nV)];
  # unit current in and out through VertexIn and VertexOut 
  currInOut:=Vector(nV,0);
  currInOut[VertexIn]:=1;
  currInOut[VertexOut]:=-1;
  # Node equations from incidence matrix - rows are vertices, columns are edges.
  # One of these equations is redundant, but solve can handle that
  nodeeqns:={LinearAlgebra:-GenerateEquations(IncidenceMatrix(dG,reverse),currents,currInOut)[]};
  # Device equations - Ohm's law
  deviceeqns:=table();
  for k to nops(arcs) do
    x:=arcs[k];
    deviceeqns[k]:=v[x[1]]-v[x[2]]=i[k]*R[x[]]
  end do;
  deviceeqns:=convert(deviceeqns,set);
  # Solve the equations
  ans:=solve(nodeeqns union deviceeqns,{currents[],voltages[]});
  eval(v[VertexIn]-v[VertexOut],ans)
end proc:

Download GraphResistance.mw

ODEPlotParams.mw

For each point on the grid it solves the ode, so increasing the grid resolution slows the plot down.