Skip to content

Adams-Bashforth solvers are a family of explicit solvers that perform a single right-hand-side evaluation per time step and achieve high-order accuracy by storing the derivative at several previous time steps. This makes them computationally efficient at the cost of some memory.

Adams-Bashforth methods are multi-step solvers and thus require not only an initial condition, but also the solution at the first few time points depending on the order of the method. For example, AB3 requires the solution at times \(t_0, t_0+k, t_0+2k\) where \(t_0\) is the initial time and \(k\) is the temporal step-size.

This implementation assumes that you only have the solution at \(t_0\) and accepts another time-integrator as a seed. For example, we may use RK4 (a single step method). You must also decide the step-size of the single-step method such that the step-size of the Adams-Bashforth solver is an integer multiple.

For example, 

    solver = AB5(RK4(), seed_steps_per_step=2)
Will use the initial condition and RK4 to take 8 time times steps each at half the step size. This will generate solutions at times \(t_0, t_0 + k/2, t_0 + k, t0+ 3k/2, ..., t_0 + 4k\). It will then sub-sample these as necessary to use as appropriate seed steps.

It is important to ensure that the order of the seed method and the number of seed steps per step are at least as accurate as the order of the Adams-Bashforth method. For example 

solver = AB5(RK4(), seed_steps_per_step=1)
would not give a fifth order method because RK4 will generate seed steps up to fourth order accuracy. In contrast 
solver = AB5(RK4(), seed_steps_per_step=2)
will generate seed steps to eighth order accuracy, relative to the step size of the Adams-Bashforth solver.

adams_bashforth

A module containing Adams-Bashforth solvers of several orders.

AdamsBashforthAbstract

Bases: TimeIntegrator

An abstract class for Adams-Bashforth (AB) solvers. All AB solvers will inherit these methods.

Source code in src/odeiter/adams_bashforth.py 
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
class AdamsBashforthAbstract(TimeIntegrator):
    """
    An abstract class for Adams-Bashforth (AB) solvers.
    All AB solvers will inherit these methods.
    """

    def __init__(self, seed: TimeIntegrator, seed_steps_per_step: int):
        """
        Parameters:
            seed: another time integrator used to take the first few steps.
            seed_steps_per_step: the number of seed steps taking per step
                of the AB integrator.
        """
        self.seed = seed
        self.seed_steps_per_step = seed_steps_per_step
        self.seed_steps = self.order - 1

    @abstractproperty
    def name(self) -> str:
        """
        Returns:
            The name of the method
        """
        ...

    @abstractproperty
    def order(self) -> int:
        """
        Returns:
            The order of the method
        """
        ...

    @abstractproperty
    def fs_coeffs(self) -> list[float]:
        """
        Returns:
            The interpolation coefficients of the method.
        """
        ...

    def update(
        self, u: np.ndarray[float], fs: np.ndarray[float], delta_t: float
    ) -> np.ndarray[float]:
        """
        Compute the next time step. You probably want `solution_generator` instead.

        Parameters:
            u: The solution at the current time-step.
            fs: the right-hand-side at several previous time-steps.
            delta_t: the temporal step-size.

        Returns:
            The solution at the next time step.
        """
        return u + delta_t * sum(c * f for c, f in zip(self.fs_coeffs[::-1], fs))

    def solution_generator(
        self,
        u0: np.ndarray[float],
        rhs: Callable[[float, np.ndarray[float]], np.ndarray[float]],
        time: TimeDomain,
    ) -> Generator[np.ndarray[float], None, None]:
        """Create a generator that yields the solution for each time in `time`.

        Parameters:
            u0: The initial condition of the system.
                Must be the same size as the system.
            rhs: The right-hand-side as a function with signature `rhs(t, u) -> u'`.
            time: The discretized time domain from.

        Returns:
            A generator that yields the solution at each time in `time.array`.
        """
        seed_steps = self.order - 1
        seed_time = TimeRay(
            time.start,
            time.spacing / self.seed_steps_per_step,
        )
        t = time.start
        fs = deque(maxlen=self.order)
        for u in islice(
            self.seed.solution_generator(u0, rhs, seed_time),
            0,
            self.seed_steps_per_step * seed_steps + 1,
            self.seed_steps_per_step,
        ):
            yield u
            fs.append(rhs(t, u))
            t += time.spacing

        for t in time.array[seed_steps:-1]:
            u = self.update(u, fs, time.spacing)
            yield u
            fs.append(rhs(t + time.spacing, u))

__init__(seed, seed_steps_per_step)

Parameters:

Name Type Description Default
seed TimeIntegrator

another time integrator used to take the first few steps.

 required
seed_steps_per_step int

the number of seed steps taking per step of the AB integrator.

 required
Source code in src/odeiter/adams_bashforth.py 
17
18
19
20
21
22
23
24
25
26
def __init__(self, seed: TimeIntegrator, seed_steps_per_step: int):
    """
    Parameters:
        seed: another time integrator used to take the first few steps.
        seed_steps_per_step: the number of seed steps taking per step
            of the AB integrator.
    """
    self.seed = seed
    self.seed_steps_per_step = seed_steps_per_step
    self.seed_steps = self.order - 1

name()

Returns:

Type Description
str

The name of the method
Source code in src/odeiter/adams_bashforth.py 
28
29
30
31
32
33
34
@abstractproperty
def name(self) -> str:
    """
    Returns:
        The name of the method
    """
    ...

order()

Returns:

Type Description
int

The order of the method
Source code in src/odeiter/adams_bashforth.py 
36
37
38
39
40
41
42
@abstractproperty
def order(self) -> int:
    """
    Returns:
        The order of the method
    """
    ...

fs_coeffs()

Returns:

Type Description
list[float]

The interpolation coefficients of the method.
Source code in src/odeiter/adams_bashforth.py 
44
45
46
47
48
49
50
@abstractproperty
def fs_coeffs(self) -> list[float]:
    """
    Returns:
        The interpolation coefficients of the method.
    """
    ...

update(u, fs, delta_t)

Compute the next time step. You probably want solution_generator instead.

Parameters:

Name Type Description Default
u ndarray[float]

The solution at the current time-step.

 required
fs ndarray[float]

the right-hand-side at several previous time-steps.

 required
delta_t float

the temporal step-size.

 required

Returns:

Type Description
ndarray[float]

The solution at the next time step.
Source code in src/odeiter/adams_bashforth.py 
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
def update(
    self, u: np.ndarray[float], fs: np.ndarray[float], delta_t: float
) -> np.ndarray[float]:
    """
    Compute the next time step. You probably want `solution_generator` instead.

    Parameters:
        u: The solution at the current time-step.
        fs: the right-hand-side at several previous time-steps.
        delta_t: the temporal step-size.

    Returns:
        The solution at the next time step.
    """
    return u + delta_t * sum(c * f for c, f in zip(self.fs_coeffs[::-1], fs))

solution_generator(u0, rhs, time)

Create a generator that yields the solution for each time in time.

Parameters:

Name Type Description Default
u0 ndarray[float]

The initial condition of the system. Must be the same size as the system.

 required
rhs Callable[[float, ndarray[float]], ndarray[float]]

The right-hand-side as a function with signature rhs(t, u) -> u'.

 required
time TimeDomain

The discretized time domain from.

 required

Returns:

Type Description
None

A generator that yields the solution at each time in time.array.
Source code in src/odeiter/adams_bashforth.py 
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
def solution_generator(
    self,
    u0: np.ndarray[float],
    rhs: Callable[[float, np.ndarray[float]], np.ndarray[float]],
    time: TimeDomain,
) -> Generator[np.ndarray[float], None, None]:
    """Create a generator that yields the solution for each time in `time`.

    Parameters:
        u0: The initial condition of the system.
            Must be the same size as the system.
        rhs: The right-hand-side as a function with signature `rhs(t, u) -> u'`.
        time: The discretized time domain from.

    Returns:
        A generator that yields the solution at each time in `time.array`.
    """
    seed_steps = self.order - 1
    seed_time = TimeRay(
        time.start,
        time.spacing / self.seed_steps_per_step,
    )
    t = time.start
    fs = deque(maxlen=self.order)
    for u in islice(
        self.seed.solution_generator(u0, rhs, seed_time),
        0,
        self.seed_steps_per_step * seed_steps + 1,
        self.seed_steps_per_step,
    ):
        yield u
        fs.append(rhs(t, u))
        t += time.spacing

    for t in time.array[seed_steps:-1]:
        u = self.update(u, fs, time.spacing)
        yield u
        fs.append(rhs(t + time.spacing, u))

AB2

Bases: AdamsBashforthAbstract

Adams-Bashforth 2.

Source code in src/odeiter/adams_bashforth.py 
108
109
110
111
112
113
114
115
116
117
118
119
120
121
class AB2(AdamsBashforthAbstract):
    """Adams-Bashforth 2."""

    @property
    def order(self):
        return 2

    @property
    def name(self):
        return f"AB2 (seed: {self.seed.name})"

    @property
    def fs_coeffs(self) -> list[float]:
        return [3 / 2, -1 / 2]

AB3

Bases: AdamsBashforthAbstract

Adams-Bashforth 3.

Source code in src/odeiter/adams_bashforth.py 
124
125
126
127
128
129
130
131
132
133
134
135
136
137
class AB3(AdamsBashforthAbstract):
    """Adams-Bashforth 3."""

    @property
    def order(self):
        return 3

    @property
    def name(self):
        return f"AB3 (seed: {self.seed.name})"

    @property
    def fs_coeffs(self) -> list[float]:
        return [23 / 12, -16 / 12, 5 / 12]

AB4

Bases: AdamsBashforthAbstract

Adams-Bashforth 4.

Source code in src/odeiter/adams_bashforth.py 
140
141
142
143
144
145
146
147
148
149
150
151
152
153
class AB4(AdamsBashforthAbstract):
    """Adams-Bashforth 4."""

    @property
    def order(self):
        return 4

    @property
    def name(self):
        return f"AB4 (seed: {self.seed.name})"

    @property
    def fs_coeffs(self) -> list[float]:
        return [55 / 24, -59 / 24, 37 / 24, -9 / 24]

AB5

Bases: AdamsBashforthAbstract

Adams-Bashforth 5.

Source code in src/odeiter/adams_bashforth.py 
156
157
158
159
160
161
162
163
164
165
166
167
168
169
class AB5(AdamsBashforthAbstract):
    """Adams-Bashforth 5."""

    @property
    def order(self):
        return 5

    @property
    def name(self):
        return f"AB5 (seed: {self.seed.name})"

    @property
    def fs_coeffs(self) -> list[float]:
        return [1901 / 720, -2774 / 720, 2616 / 720, -1274 / 720, 251 / 720]