I would like to create a list which contains an initial point x = [x0 x1] and perturbed points y1 = [x0+h x1], y2 = [x0-h x1], y3 = [x0 x1+h], etc. I have tried this:
xs = [x]*5;
for i in range(len(x)):
if isinstance(h, float):
xs[2*i+1][i] -= h;
xs[2*i+2][i] += h;
But this appears to change the elements back and forth as it runs through the loop.
If I interpreted correctly what you wanted to do from your explanation and code:
def perturbate(x, h):
"""
Given an initial point x = [x0, x1, ..., xn]
Returns a list of points containing the original point and,
for every coordinate, "perturbations" of that point created
by adding and subtracting 'h' to the coordinate.
"""
# start with the original point plus
# 2 copies of it for every coordinate
points = [x[:] for i in range(len(x)*2 + 1)]
for coordinate_index in range(len(x)):
points[coordinate_index*2 + 1][coordinate_index] -= h
points[coordinate_index*2 + 2][coordinate_index] += h
return points
Which gives:
>>> perturbate([1.0,2.0], 1.0)
[[1.0, 2.0], [0.0, 2.0], [2.0, 2.0], [1.0, 1.0], [1.0, 3.0]]
So basically your code was almost correct (but not really clear, the generic-named variables don't help), except for the "results" inizialization: when you do [x] * 5, where x is a mutable object, you're creating a list of 5 times the same object. If you change a property of that object, it will change in all the indices, because they reference the same object!
>>> a = [[0,0]] * 5
>>> a
[[0, 0], [0, 0], [0, 0], [0, 0], [0, 0]]
>>> a[0][0] = 1
>>> a
[[1, 0], [1, 0], [1, 0], [1, 0], [1, 0]]
>>>
Also the hardcoded 5 assumes 2-dimensional points. But if we assume 2 dimensional points, than why using the len of the point instead of just using a surely simpler and clearer "hardcoded" implementation?
I submit that the accepted answer to this is needlessly complicated which makes it difficult to reason about and therefore more difficult to debug and maintain. It is also more complex since it needlessly prefills a list which it then has to iterate over.
An somewhat less complicated general solution like the above would be as follows:
def perturbate(x, h):
perturbations = [x] # initialize with original point first
for i, _ in enumerate(x): # no range(len())
shifted_down = x[:]
shifted_down[i] -= h
perturbations.append(shifted_down)
shifted_up = x[:]
shifted_up[i] += h
perturbations.append(shifted_up)
return perturbations
Aside from that, this general solution supporting up to n-dimensional points is far less readable than just spelling it out if you're working in 2D:
def perturbate(point, h):
x, y = point
return [[x, y], [x-h, y], [x+h, y], [x, y-h], [x, y+h]]
If this is all you need, this two-line function is infinitely more readable and understandable than either of the monstrosities above.
Remember:
