Same, this was eventually published, see https://www.researchgate.net/publication/320007623_Enhancements_to_modified_Chebyshev-Picard_iteration_efficiency_for_perturbed_orbit_propagation.

While the published paper contains the second-order vector/matrix formulation, it does not contain the first-order one (which is what I'm using here).

I added a URL to the citation.

Let's have an include for this.

The include is near the top, line 6 (like the other integrators).

So we generally distinguish the method (see methods.hpp) which is used to parameterize the integrator, from the parameters which are used when creating instances.

For instance for the ephemeris, the method is QuinlanTremaine1990Order12 and the instances are created with a step of 10 minutes.

It's clear that max_iterations and stopping_criterion are instance parameters, but I wonder if M and N would make sense as methods? WDYT?

The working matrices are fixed once M and N are chosen so it is convenient to make them part of the method and store the matrices in the class (of course, this could be done in other ways as well).

I see that all the methods in methods.hpp have fixed values, which makes sense for them but maybe less so here (where any M ≥ N is valid). One possibility is to have

struct ЧебышёвPicard {
  std::int64_t M;
  std::int64_t N;
};

(in methods.hpp)

alternatively one could have

template<std::int64_t M, std::int64_t N>
struct ЧебышёвPicard: not_constructible {};

(or am I misunderstanding?)

I think template<std::int64_t M, std::int64_t N>struct ЧебышёвPicard would be most consistent with the way the others work, assuming that various combinations of M and N are interesting (for AdamsBashforth we just went with 5 separate structs so that we don’t need to implement the computation of the coefficients, but that would probably get silly here).

Ok, added template<std::int64_t M, std::int64_t N>struct ЧебышёвPicard.

This enabled me to switch from UnboundedMatrix to FixedMatrix, which resulted in me finding and fixing a bug in the M > N case.

I am a bit unhappy that this is called ...Iterator and not ...Integrator. I realize that this technique is called "iteration", but really this class is an integrator in the sense of the Principia abstractions. Furthermore, "iterator" makes me think of STL iterators or other objects that are used to iterate over some collection.

(If we decide to change the name, let's do it last.)

Happy to change the name after everything else is resolved.

As mentioned above, some of the things in params should be passed to the instance, I think.

How does this work with NewInstance? As defined in FixedStepSizeIntegrator, it doesn't have any spare arguments to pass them (or am I misunderstanding something?)