Change sign of elements with an odd sum of indices

Question

arr is a n-dimensional numpy array.

How to change sign of every element of arr with an odd sum of indices?

For example, arr[0, 1, 2] needs a sign change because it has a sum of indices 0 + 1 + 2 = 3, which is odd.

When I convert arr to a list, I notice that every second element in the list are elements that needs a sign change.

Another example:

Original array:

[[[ 0  1  2]
  [ 3  4  5]
  [ 6  7  8]]

 [[ 9 10 11]
  [12 13 14]
  [15 16 17]]

 [[18 19 20]
  [21 22 23]
  [24 25 26]]]

Array with signs changed:
[[[ 0  -1  2]
  [ -3  4  -5]
  [ 6  -7  8]]

 [[ -9 10 -11]
  [12 -13 14]
  [-15 16 -17]]

 [[18 -19 20]
  [-21 22 -23]
  [24 -25 26]]]

do you mean you want to multiply each element by either -1 or +1, with the +-1 forming a matrix like a checkerboard? — R zu, Mar 11 '18 at 21:07
matrix a=i,j [1,2,3, 4,5,6, 7,8,9] for example a[0][0]=1 a[1][2]=6 if sum of indexes is odd u have to multiple it by -1 so a[0][0]=1 will be -1 and a[1][2]=6 will be -6 — Pythonnosnake, Mar 11 '18 at 21:09
Reviewers please note the question has been clarified by a helpful editor. — Daniel F, Mar 12 '18 at 07:54

score 1 · Answer 1 · answered Mar 12 '18 at 07:53

np.negative is silghtly faster than multiplying (as it is a ufunc)

N = 5
arr = np.arange(N ** 3).reshape(N, N, N)
%timeit arr.ravel()[1::2] *= -1
%timeit np.negative(arr.ravel()[1::2], out = arr.ravel()[1::2])

The slowest run took 8.74 times longer than the fastest. This could mean that an intermediate result is being cached.
100000 loops, best of 3: 3.39 µs per loop
The slowest run took 5.57 times longer than the fastest. This could mean that an intermediate result is being cached.
100000 loops, best of 3: 3.12 µs per loop

N = 25
arr = np.arange(N ** 3).reshape(N, N, N)
%timeit arr.ravel()[1::2] *= -1
%timeit np.negative(arr.ravel()[1::2], out = arr.ravel()[1::2])

The slowest run took 7.03 times longer than the fastest. This could mean that an intermediate result is being cached.
100000 loops, best of 3: 10.8 µs per loop
The slowest run took 5.27 times longer than the fastest. This could mean that an intermediate result is being cached.
100000 loops, best of 3: 8.63 µs per loop

N = 101
arr = np.arange(N ** 3).reshape(N, N, N)
%timeit arr.ravel()[1::2] *= -1
%timeit np.negative(arr.ravel()[1::2], out = arr.ravel()[1::2])

1000 loops, best of 3: 663 µs per loop
1000 loops, best of 3: 512 µs per loop

R zu · Answer 2 · 2018-03-11T21:47:21.963

Greatly simplified by hpaulj's suggestion.

Program:

import numpy as np


def change_sign(arr):
    """Switch sign of every second element of arr in-place
    Note
    ----
    Modifies the input array (arr).
    """
    # arr.reshape(-1) makes a 1D view of arr
    #
    # [1::2] select every other element of arr,
    #   starting from the 1st element.
    #
    # *= -1 changes sign of selected elements.

    arr.reshape(-1)[1::2] *= -1
    return arr


def main():
    N = 3
    arr = np.arange(N ** 3).reshape(N, N, N)
    print("original array:")
    print(arr)
    print("change signs")
    print(change_sign(arr))


main()

Result:

original array:
[[[ 0  1  2]
  [ 3  4  5]
  [ 6  7  8]]

 [[ 9 10 11]
  [12 13 14]
  [15 16 17]]

 [[18 19 20]
  [21 22 23]
  [24 25 26]]]
change signs
[[[  0  -1   2]
  [ -3   4  -5]
  [  6  -7   8]]

 [[ -9  10 -11]
  [ 12 -13  14]
  [-15  16 -17]]

 [[ 18 -19  20]
  [-21  22 -23]
  [ 24 -25  26]]]

How about `arr.ravel()[1::2]*=-1`? negate every other element in the flattened view. — hpaulj, Mar 11 '18 at 21:39
or even `np.negative(arr.ravel()[1::2], out = arr.ravel()[1::2])` which might be faster but a little less readable — Daniel F, Mar 12 '18 at 07:43

Change sign of elements with an odd sum of indices

2 Answers2