Decide on an interface for time-dependent operators

[adrn]

For example, having a translation that depends on time.

Examples:

• the standard Galilean transform (x' = x + vt)
• a rotation like in the restricted three-body problem, or with a rotating bar
• a reference frame pinned to an arbitrary (possibly interpolated) trajectory in phase-space

[nstarman]

I think the interface may always be the same for the user.

op = Operator(...)
op(t, x)

No-time base case

@dispatch
AbstractOperator.__call__(x): ...
@dispatch
AbstractOperator.__call__(t, x): return self(x)
...
@dispatch
AbstractOperator.__call__(psp): return self(psp.t, psp.q, psp.v)

A time-dependent operator.

@dispatch
TimeDepOperator.__call__(t, x): ...

The Q is do we build time dep into the fields of the Op or as a wrapper/separate structure from the time-independent op?

This example builds time dep into the fields.

AbstractOperator
    def __call__():
        # E.g. for field1=f(t) and field2=2
        static, dynamic = eqx.partition(self)  # {field2: 2}, {field1: f(t)}
        eval_d = map(eval(t), dynamic)  # {field1: fval}
        total = eqx.combine(static, eval_d)  # {field2: 2}, {field1: fval}
        ... # do the math

SomeOp:
    field1: Scalar | Callable[[time], Scalar]
    field2: Scalar | Callable[[time], Scalar]

[adrn]

What about:

AbstractOperator
    def _get_static(t):
        # E.g. for field1=f(t) and field2=2
        static, dynamic = eqx.partition(self)  # {field2: 2}, {field1: f(t)}
        eval_d = map(eval(t), dynamic)  # {field1: fval}
        return eqx.combine(static, eval_d)  # {field2: 2}, {field1: fval}

    def __call__(t, x, ...):
        static_self = self._get_static(t)
        return static_call(static_self, x)

Translate(AbstractOperator):  # (e.g.,)
    field1: Scalar | Callable[[time], Scalar]
    field2: Scalar | Callable[[time], Scalar]

@dispath
def static_call(Translate, x):
   # the actual implementation

Or , for speed, one could do:

SomeOp2 (e.g., Translate(AbstractOperator)):
    field1: Scalar | Callable[[time], Scalar]
    field2: Scalar | Callable[[time], Scalar]

    def __call__():
        static_self = {k: v(t) if callable(v) else v for k, v in {fields}.items()}
        ... # do the math.

[nstarman]

Or...

@dispatch
def operate(op, t, x):
    static, dynamic = eqx.partition(self)
    eval_d = map(eval(t), dynamic) 
    params = eqx.combine(static, eval_d)
    return operate(op, params, t, x)  # <- "static"

@dispatch
def operate(op, params, q):
    return op.operate_notime(params, q)

@dispatch
def operate(op, params, t, x):
    return op.operate_withtime(params, t, q)

@dispatch
def operate(AbstractOperator, params, psp):
    return operate(AbstractOperator, params, psp.t, psp.q)


class AbstractOperator:
     def __call__(*args, **kwargs):  operate(self, *args, *kwargs)

    @classmethod
    @abstractmethod
    def operate_notime(cls, params, x):
            return params["delta"] + x

    @classmethod
    @abstractmethod
    def operate_withtime(cls, params, t, x):
        return cls.operate(params, x)

# - - -

class Translate:
    delta: Scalar | Callable[[time], Scalar]

    @classmethod
    def operate_notime(cls, params, x):
        return params["delta"] + x
    
    @classmethod
    def operate_withtime(cls, params, t, x):
        return cls.operate_notime(params, x)

# speed boost 
@dispatch
def operate(op: Translate, t, x):
    return op.operate_notime({"delta": op.delta(t) if callable(op.delta) else op.delta}, x)

[adrn]

OK so in the new way of thinking about this:

op(t, x)  # time is used only to evaluate time-dependent fields of the operator
op(t, (t, x))  # time is both used for evaluating time-dep fields, and is treated as a coordinate

[adrn]

Another note (from our discussion) - the time taken at the op(t, x) level could actually be anything, not necessarily always a Quantity["time"] (e.g., a phase, or a dimensionless affine parameter)