The Putzer algorithm is an interesting and very remarkable (to me) simplification of the problem of taking $\exp(At)$ for any $t$. However, it does have some complex precomputation steps; that is, when it is ready, it can compute the exponential very quickly, using stored values of the helper matrices $M_i$ and pre-calculated helper functions $p_i(t)$, but these must all be calculated before hand, which is intensive, although I found a relatively quick way of solving the O.D.Es for the helper functions $p_i$. These objects I am introducing are just those found in the following: $$\exp(At)=\sum_{k=0}^{n-1}p_{k+1}(t)M_k$$ Where $A$ is $n\times n$.
Cayley-Hamilton finds another way to approach the problem: using the characteristic polynomial of $A$, $\chi_A$, we know $\exp(At)=\sum_{k=0}^{n-1}c_kA^k$. The $c_k$ are solved for by comparing coefficients in $\exp(\lambda t)=c_0+c_1\lambda+c_2\lambda^2+\cdots$ for every eigenvalue $\lambda$, BUT there is the case where some $\lambda$ are repeated due to multiplicity, say multiplicity $m$, whereupon one must take the first $m-1$ derivatives of $\exp(\lambda t)$ and compare them to the first $m-1$ derivatives of $c_0+c_1\lambda+c_2\lambda^2+\cdots$.
From a programmer's perspective, there are two cases where efficiency varies (that I can see). The first is when we know $A$ in advance, but might be asked to compute $\exp(At)$ for the purposes of, say, graphing a solution to the O.D.E $f'(t)=Af(t)$. In the live execution of finding $\exp(At)$, once all the auxiliary objects have been precomputed, one must sum the $M_k$ (easy) but also evaluate the $p_k$ functions at $t$, which involves more calls to the (scalar) exponential function and more matrix multiplication (the way I managed to do it, anyway). To me, this seems computationally fairly expensive. For Cayley-Hamilton, the eigenvalues must be found, (same), and then you can precompute the $A^k$. However, at least in the way Wikipedia presents it, you must individually find whole different sets of $c_k$ for every value of $t$, which involves solving a large system of linear equations, multiple calls to the exponential function, possibly multiple derivative operations must be done, yielding yet more equations to solve, and finally a simple sum is done at the end. In this first case, it is extremely unclear to me which is more efficient in terms of runtime.
In the second case, where we are just given $A$ and $t$ and are asked to compute $\exp(At)$ on the fly, the precomputation time must also be taken into account. In the precomputation stages for the Putzer one must find all eigenvalues and solve an O.D.E for the $p_k$, which is doable but the way I found to do it had many steps, albeit trivial ones, but is perhaps slow as a series computation. Secondly, one must calculate $(A-\lambda I)$ for every eigenvalue and then multiply these in a recurrence relation to generate the $M_k$. For Cayley-Hamilton, the precomputation work is lesser and is just a matter of finding eigenvalues and calculating $A^k$, however with all stages being considered in the runtime, I do not know which should be faster.
Two questions:
If I were, hypothetically, one of the geniuses at WolframAlpha (or equivalent), would I employ the Cayley-Hamilton method, the Putzer method, or something else entirely to find $\exp(At)$?
Much more realistically, if I am a school student tasked with solving some system of O.D.Es, say a $4$ variable homogeneous system where some $\exp(At)$ gives part of the solution, do I (with only a simple pocket calculator) use Putzer, or Cayley-Hamilton, if my teacher asks me to evaluate the solution for $1)$ several different points of $t$ or $2)$ just the one value of $t$?
I feel as if the algorithm wouldn't have been developed unless it improves upon something, but I can't tell if it is actually faster.