steppyngstounes.scaledStepper¶
Classes
- class steppyngstounes.scaledStepper.ScaledStepper(start, stop, size=None, minStep=None, inclusive=False, record=False, growFactor=1.2, shrinkFactor=0.5)¶
Bases:
Stepper
Adaptive stepper that adjusts the step by fixed factors.
Calculates a new step as
\[\Delta_{n+1} = f_\text{grow} \Delta_n\]where \(\Delta_n\) is the step size for step \(n\) and \(f_\text{grow}\) is the factor by which to grow the step size.
On failure, retries with
\[\Delta_{n} = f_\text{shrink} \Delta_n\]where \(f_\text{shrink}\) is the factor by which to shrink the step size.
- Parameters:
start (float) – Beginning of range to step over.
stop (float) – Finish of range to step over.
size (float) – Suggested step size to try (default None).
minStep (float) –
Smallest step to allow (default (stop - start) * eps).
inclusive (bool) – Whether to include an evaluation at start (default False)
record (bool) – Whether to keep history of steps, errors, values, etc. (default False).
growFactor (float) – Growth factor \(f_\text{grow}\) (default 1.2).
shrinkFactor (float) – Shrinkage factor \(f_\text{shrink}\) (default 0.5).
Examples
>>> import numpy as np >>> from steppyngstounes import ScaledStepper
We’ll demonstrate using an artificial function that changes abruptly, but smoothly, with time,
\[\tanh\frac{\frac{t}{t_\mathrm{max}} - \frac{1}{2}} {2 w}\]where \(t\) is the elapsed time, \(t_\mathrm{max}\) is total time desired, and \(w\) is a measure of the step width.
>>> totaltime = 1000. >>> width = 0.01
The scaled “error” will be a measure of how much the solution has changed since the last step, | new - old | / errorscale).
>>> errorscale = 1e-2
Iterate over the stepper from start to stop (inclusive of calculating a value at start).
>>> old = -1. >>> stepper = ScaledStepper(start=0., stop=totaltime, inclusive=True, ... record=True) >>> for step in stepper: ... new = np.tanh((step.end / totaltime - 0.5) / (2 * width)) ... ... error = abs(new - old) / errorscale ... ... if step.succeeded(value=new, error=error): ... old = new
>>> s = "{} succesful steps in {} attempts" >>> print(s.format(stepper.successes.sum(), ... len(stepper.steps))) 296 succesful steps in 377 attempts
>>> steps = stepper.steps[stepper.successes] >>> ix = steps.argsort() >>> values = stepper.values[stepper.successes][ix] >>> errors = abs(values[1:] - values[:-1]) / errorscale
Check that the post hoc error satisfies the desired tolerance.
>>> print(max(errors) < 1.) True
(
Source code
,png
,hires.png
,pdf
)- property errors¶
ndarray of the “error” at each step attempt.
The user-determined “error” scalar value (positive and normalized to 1) at each step attempt is passed to
Stepper
viasucceeded()
.
- next()¶
Return the next step.
Note
Legacy Python 2.7 support.
- Return type:
- Raises:
StopIteration – If there are no further steps to take
- property sizes¶
ndarray of the step size at each step attempt.
- property steps¶
ndarray of values of the control variable attempted so far.
- succeeded(step, value=None, error=None)¶
Test if step was successful.
Stores data about the last step.
- Parameters:
step (
Step
) – The step to test.value (float, optional) – User-determined scalar value that characterizes the last step. Whether this parameter is required depends on which
Stepper
is being used. (default None).error (float, optional) – User-determined error (positive and normalized to 1) from the last step. Whether this parameter is required depends on which
Stepper
is being used. (default None).
- Returns:
Whether step was successful.
- Return type:
bool
- property successes¶
ndarray of whether the step was successful at each step attempt.
- property values¶
ndarray of the “value” at each step attempt.
The user-determined scalar value at each step attempt is passed to
Stepper
viasucceeded()
.