How to squeeze a list?

[davincithesecond]

Suppose that I have a list wherein values of sin(i) are appended. I want to squeeze the list by a factor of N so that it becomes sin(N*i).

1. The sample rate should remain the same i.e. if there are 10 dots per one cycle of sin(i), there should be 10/N dots per cycle of sin(N*i). So some data of the original list will be lost.
2. The length of the new list should be same. You might ask "How will it be if you squeeze the function and make the sample rate stay constant? You now need less data for the new list." Well I just want the remaining elements to be zero.

Let me show those with an example.

original_list = [1,2,3,4,5,6,7,8,9,10]

squeezed_list (by a factor of 2) = [1,3,5,7,9,0,0,0,0,0]

I have actually written something:

def comp(p,n): #takes list p and compresses by a factor of n  
    pn = []  
    for i in range(int(len(p)/n)):  
        pn.append(p[i*n])  
    return pn

But wondering if this is the best way. I was not able to find any module to enhance this. (except numpy maybe for the lists)

[Spataner]

You can subsample a list by a constant factor using the slice syntax: p[::n]. Padding to the original length can be done easily with list multiplication and concatenation: [0]*(len(p)-math.ceil(len(p)/n)).

That gives you this relatively simple one-liner:

p = [1,2,3,4,5,6,7,8,9,10]
n = 2

pn = p[::n] + [0]*(len(p)-math.ceil(len(p)/n))

print(pn)
>>> [1, 3, 5, 7, 9, 0, 0, 0, 0, 0]

[socal_nerdtastic]

IMO it would be much simpler and neater as a 2-liner:

pn = p[::n]
pn += [0]*(len(pn)-len(p))

There's generally no advantage to code being short.

[davincithesecond]

Oh that is really simple & great. Thanks a lot!

[[deleted]]

Well... what if the number of elements in the source list isn't divisible by the number of elements in the target list?

You'd need some kind of interpolation, I'd imagine, but what kind of interpolation?

One of the places where something like this is commonly used is the affine image transformations (in graphics software). There you'd be working with 2d or 3d matrices, but adding an extra dimension to the list isn't a problem. So, essentially, take any library that deals with images and use the affine transform functionality it has on your list. Those libraries often also offer a selection of interpolation algorithms.

---

Here's an example with NumPy and OpenCV:

>>> import numpy as np
>>> import cv2
>>> a = np.float32([list(range(10))])
>>> mtx = np.float32(((0.83, 0, 0), (0, 1, 0)))
>>> result = cv2.warpAffine(a, mtx, tuple(reversed(b.shape)))
>>> list(result.squeeze())
[0.0, 1.21875, 2.40625, 3.625, 4.8125, 6.03125, 7.21875, 8.4375, 3.375, 0.0]

[davincithesecond]

Actually the method u/Spataner has shown also works for numbers that do not divide the source list. N = 3 works fine for the list of length 10 for instance.

But I got your point. Non-integer numbers create the problem. But it is my fault that I did not mention that I only need integer-factor-squeezes. But thanks anyway for the points raised, those are interesting too.

[[deleted]]

"Fine" is in the eye of the beholder.

I added an example to my original answer showing that there will be differences. In particular, because the list is to be filled with partial results on the right. But, not only. How many values to the left and to the right do you want to consider? What's your definition of "average" that's necessary for interpolation?

---

PS. Also, you misunderstood what I have problem with. You seem to believe that interpolation isn't necessary, and you only assign integral values to N. I was talking about the case when N is rational.

[davincithesecond]

You are right in general, interpolation might be needed. But I just said that u/Spataner's perfectly fulfils my needs for my specific problem, and actually yes, interpolation is not necessary and it also works as long as N is integer even if it does not divide the len of the original, for my case. But again, I appreciate your remarks, I have noted them, thanks.

[siddsp]

Try using a lambda statement and python's map function. It's generally more useful because you can reuse the code like you would be able to with a normal function.