Pandas: 단계 크기가 있는 롤링 창

'표준' 함수를 사용하는 경우 벡터화되므로 v 빠릅니다( ts.rolling(5).max().dropna()[::2] ).

IIUC 여기에서 절약은 시간의 일부(예: n번째 값마다)만 함수를 적용함으로써 얻을 수 있습니다. 그러나 그것이 실질적인 차이를 만드는 경우가 있습니까?

이 작업을 수행할 수 있지만 이것이 중요한 사용 사례를 보고 싶습니다. 이렇게 하면 '입력과 동일한 크기 반환' API도 중단됩니다. 나는 이것이 실제로 구현하기 어렵다고 생각하지 않지만 (구현에 많은 변경 사항이 포함되지만). 우리는 한계 창을 사용합니다(IOW, 창을 계산하고 진행하면서 떠나는 점을 줄이고 얻는 점을 추가함). 따라서 여전히 모든 것을 계산해야하지만 출력하지 않을 것입니다.

답장해주셔서 감사합니다!

IIUC 여기에서 절약은 시간의 일부(예: n번째 값마다)만 함수를 적용함으로써 얻을 수 있습니다. 그러나 그것이 실질적인 차이를 만드는 경우가 있습니까?

내 사용 사례는 일부 대형 시계열 데이터 프레임(400개 열, 5-25Hz에서 데이터 시간)에 대해 집계 함수(최대값뿐만 아니라)를 실행하는 것입니다. 또한 과거에 최대 20kHz의 데이터로 유사한 작업(센서 데이터에 대한 기능 엔지니어링)을 수행했습니다. 30초 창을 5초 단계로 실행하면 처리량을 크게 절약할 수 있습니다. 예를 들어 25Hz에서 5초 단계로 실행하면 작업의 1/125에 불과하므로 1분 또는 2시간 만에 실행하는 차이가 있습니다.

분명히 numpy로 돌아갈 수 있지만 이를 수행하기 위한 더 높은 수준의 API가 있으면 좋을 것입니다. 다른 사람들도 유용하다고 생각할 경우를 대비하여 제안할 가치가 있다고 생각했습니다. 저를 위한 기능을 구축할 것이라고는 생각하지 않습니다!

먼저 더 높은 주파수 간격으로 리샘플링을 시도한 다음 롤링을 시도할 수 있습니다.

뭔가

df = df.resample('30초')
df.rolling(..).max() (또는 어떤 기능이든)

@jreback님 , 제안 감사합니다.

이것은 내 데이터에서 max 를 실행하는 경우 작동합니다(resample에는 축소 기능이 필요합니다. 그렇지 않으면 기본값은 mean , 맞습니까?):

df.resample('1s').max().rolling(30).max()

그러나 30초의 데이터에 대해 축소 기능을 실행한 다음 1초 앞으로 이동하고 다음 30초의 데이터에 대해 실행하고 싶습니다. 위의 방법은 1초의 데이터에 함수를 적용한 다음 다른 첫 번째 함수의 30개 결과에 대한 함수입니다.

다음은 간단한 예입니다. 피크 대 피크 계산을 실행하면 두 번 실행되지 않습니다(분명히).

# 10 minutes of data at 5Hz
n = 5 * 60 * 10
rng = pandas.date_range('1/1/2017', periods=n, freq='200ms')
np.random.seed(0)
d = np.cumsum(np.random.randn(n), axis=0)
s = pandas.Series(d, index=rng)

# Peak to peak
def p2p(d):
    return d.max() - d.min()

def p2p_arr(d):
    return d.max(axis=1) - d.min(axis=1)

def rolling_with_step(s, window, step, func):
    # See https://ga7g08.github.io/2015/01/30/Applying-python-functions-in-moving-windows/
    vert_idx_list = np.arange(0, s.size - window, step)
    hori_idx_list = np.arange(window)
    A, B = np.meshgrid(hori_idx_list, vert_idx_list)
    idx_array = A + B
    x_array = s.values[idx_array]
    idx = s.index[vert_idx_list + int(window/2.)]
    d = func(x_array)
    return pandas.Series(d, index=idx)

# Plot data
ax = s.plot(figsize=(12, 8), legend=True, label='Data')

# Plot resample then rolling (obviously does not work)
s.resample('1s').apply(p2p).rolling(window=30, center=True).apply(p2p).plot(ax=ax, label='1s p2p, roll 30 p2p', legend=True)

# Plot rolling window with step
rolling_with_step(s, window=30 * 5, step=5, func=p2p_arr).plot(ax=ax, label='Roll 30, step 1s', legend=True)

@alexlouden 귀하의 원래 설명에서 나는 다음과 같이 생각합니다.

df.resample('5s').max().rolling('30s').mean() (또는 모든 감소)가 원하는 것과 더 일치합니다.

IOW, 5s bin에 있는 모든 것을 가져 와서 단일 지점으로 줄인 다음 해당 bin을 롤오버하십시오. 이 일반적인 아이디어는 짧은 시간 규모로 요약할 수 있는 많은 데이터가 있지만 실제로는 더 높은 수준에서 이를 롤링하기를 원한다는 것입니다.

@jreback님 , 실제로 5초마다 30초 분량의 데이터에 대해 함수를 실행하고 싶습니다. 이전 예제에서 rolling_with_step 함수를 참조하십시오. 최대/평균의 추가 단계는 내 사용 사례에서 작동하지 않습니다.

@jreback , 아직 이 토론에서 나오지 않은 단계 기능이 실제로 필요합니다. @alexlouden 이 설명한 모든 것을 두 번째로 하고 있지만 더 많은 사용 사례를 추가하고 싶습니다.

약 3~10밀리초로 샘플링된 입력 데이터로 시계열 분석을 수행한다고 가정합니다. 우리는 주파수 영역 기능에 관심이 있습니다. 그것들을 구성하는 첫 번째 단계는 Nyquist 주파수를 찾는 것입니다. 도메인 지식으로 10Hz(100ms마다 한 번)임을 알고 있다고 가정합니다. 즉, 기능이 입력 신호를 잘 캡처해야 하는 경우 데이터의 주파수가 최소 20Hz(50ms마다 한 번)여야 합니다. 그보다 낮은 주파수로 리샘플링할 수 없습니다. 궁극적으로 우리가 수행하는 계산은 다음과 같습니다.

df.resample('50ms').mean().rolling(window=32).aggregate(power_spectrum_coeff)

여기에서 8의 배수로 창 크기를 선택했으며 32를 선택하면 창 크기가 1.6초가 됩니다. 집계 함수는 첫 번째 평균 성분 없이 단면 주파수 도메인 계수를 반환합니다(fft 함수는 대칭이고 0번째 요소에 평균 값이 있음). 다음은 샘플 집계 함수입니다.

def power_spectrum_coeff():
    def power_spectrum_coeff_(x):
        return np.fft.fft(x)[1 : int(len(x) / 2 + 1)]

    power_spectrum_coeff_.__name__ = 'power_spectrum_coeff'
    return power_spectrum_coeff_

이제, 예를 들어 매 0.4초 또는 매 0.8초의 슬라이딩 윈도우에서 이것을 반복하고 싶습니다. 계산을 낭비하고 대신 50ms마다 FFT를 계산한 다음 나중에 슬라이싱하는 것은 의미가 없습니다. 또한 400ms까지 리샘플링하는 것은 옵션이 아닙니다. 400ms는 Nyquist 주파수보다 훨씬 낮은 2.5Hz에 불과하고 그렇게 하면 기능에서 모든 정보가 손실되기 때문입니다.

이것은 많은 시계열 관련 과학 실험에 응용되는 주파수 영역 기능이었습니다. 그러나 표준 편차와 같은 더 간단한 시간 영역 집계 함수도 리샘플링으로 효과적으로 지원할 수 없습니다.

나는 이것이 실제로 구현하기 어렵다고 생각하지 않지만 (구현에 많은 변경 사항이 포함되지만). 우리는 한계 창을 사용합니다(IOW, 창을 계산하고 진행하면서 떠나는 포인트를 삭제하고 얻는 포인트를 추가합니다). 따라서 여전히 모든 것을 계산해야하지만 출력하지 않을 것입니다.

'step' 매개변수를 갖고 이를 사용하여 실제 계산을 줄일 수 있는 것은 Pandas의 미래 목표여야 합니다. 단계 매개변수가 더 적은 수의 포인트만 반환하는 경우 출력을 어떻게든 슬라이스할 수 있으므로 수행할 가치가 없습니다. 아마도 이 작업과 관련된 작업을 고려할 때 이러한 요구 사항이 있는 모든 프로젝트에서 Numpy를 사용하도록 권장할 수 있습니다.

@Murmuria 이를 수행하기 위해 풀 리퀘스트를 제출할 수 있습니다. 사실 그렇게 어렵지 않습니다.

rolling() 에서 step 매개변수에 대한 요청을 두 번째로 하는 동안 rolling() 에서 base 매개변수를 사용하여 원하는 결과를 얻을 수 있음을 지적하고 싶습니다 resample() , 단계 크기가 창 크기의 정수 분수인 경우 . @alexlouden 의 예 사용:

pandas.concat([
    s.resample('30s', label='left', loffset=pandas.Timedelta(15, unit='s'), base=i).agg(p2p) 
    for i in range(30)
]).sort_index().plot(ax=ax, label='Solution with resample()', legend=True, style='k:')

우리는 동일한 결과를 얻습니다(선이 양쪽에서 30초 연장됨).

이는 집계 유형에 따라 여전히 다소 낭비입니다. @alexlouden 의 예에서와 같은 피크 대 피크 계산의 특정 경우에 대해 p2p_arr() 는 계열을 2차원 행렬로 재정렬한 다음 max() 대한 단일 호출을 사용하기 때문에 거의 200배 빠릅니다. min() .

롤링의 단계 매개변수를 사용하면 날짜/시간 인덱스 없이 이 기능을 사용할 수도 있습니다. 이미 작업 중인 사람이 있습니까?

위의 @alexlouden 은 다음과 같이 말했습니다.

분명히 numpy로 돌아갈 수 있지만 이를 수행하기 위한 더 높은 수준의 API가 있으면 좋을 것입니다.

@alexlouden 이나 아는 사람이 numpy로 이 작업을 수행하는 방법에 대한 통찰력을 공유할 수 있습니까? 지금까지의 연구에서 numpy에서도 이것을 수행하는 것이 사소한 일이 아닌 것 같습니다. 사실, 여기에 대한 미해결 문제가 있습니다. https://github.com/numpy/numpy/issues/7753

감사 해요

안녕하세요 @tsando - 위에서 사용한 rolling_with_step 기능이 작동하지 않습니까?

@alexlouden 감사합니다. 방금 그 기능을 확인했는데 여전히 팬더에 의존하는 것 같습니다(시리즈를 입력으로 사용하고 시리즈 인덱스도 사용). 나는 이것에 대해 순전히 numpy 접근 방식이 있는지 궁금합니다. 내가 언급한 스레드에서 https://github.com/numpy/numpy/issues/7753 그들은 numpy strides를 사용하는 함수를 제안하지만 창 및 단계 입력을 이해하고 변환하기가 어렵습니다.

@tsando 여기 내가 위에 링크한 블로그 게시물 하고 사이트 를 다시

위의 내 기능은 Pandas와 함께 작동하도록 그의 마지막 예제를 변환하는 것입니다. numpy를 직접 사용하려면 다음과 같이 할 수 있습니다. https://gist.github.com/alexlouden/e42f1d96982f7f005e62ebb737dcd987

도움이 되었기를 바랍니다!

@alexlouden 감사합니다! 방금 (13, 1313) 모양의 배열에서 시도했지만 다음 오류가 발생했습니다.

"이것은 할 수 있지만 이것이 중요한 사용 사례를보고 싶습니다."

팬더를 사용하여 작업한 프로젝트가 무엇이든 간에 이 기능을 거의 항상 놓쳤습니다. 이 기능은 가끔씩만 적용을 계산해야 할 때마다 유용하지만 여전히 각 창 내에서 좋은 해상도가 필요합니다.

저도 이 기능에 동의하고 지지합니다

시계열을 다룰 때 거의 매번 필요로 하는 이 기능은 시각화와 분석 모두를 위한 시계열 기능을 생성하는 데 훨씬 더 나은 제어를 제공할 수 있습니다. 이 아이디어를 적극 지원하십시오!

이 기능에 동의하고 지원합니다.

이것은 좋은 창 해상도를 유지하면서 계산 시간을 줄이는 데 매우 도움이 될 것입니다.

특정 대상에 따라 추가로 조정할 수 있는 솔루션 코드를 제공합니다.

def average_smoothing(signal, kernel_size, stride):
    sample = []
    start = 0
    end = kernel_size
    while end <= len(signal):
        start = start + stride
        end = end + stride
        sample.append(np.mean(signal[start:end]))
    return np.array(sample)

이 기능에 동의하고 지원합니다. 지금 스톱모션으로 보고 있습니다.

TB의 데이터가 있는 경우 계산 및 다운샘플링은 옵션이 아닙니다.

제가 하는 일에도 많은 도움이 될 것입니다. 로컬 조건을 이해하기 위해 겹치지 않는 창에 대한 다양한 통계가 필요한 TB의 데이터가 있습니다. 현재 "수정"은 데이터 프레임과 수율의 통계를 슬라이스하는 생성기를 만드는 것입니다. 이 기능이 있으면 매우 유용할 것입니다.

이 기능은 시계열이 관련될 때 실제로 있어야 합니다!

동의합니다. 확실히 이 기능이 추가되어야 합니다. 주가 간의 실행 창 상관 관계를 수행하려고 하고 이에 대한 고유한 기능을 만들어야 합니다.

그런 기본 기능이 아직 없다는 것이 믿기지 않습니다!
이 문제는 언제 해결됩니까?
감사 해요

'추가 토론'에 기여하려면:
내 사용 사례는 1초의 해상도로 한 달의 데이터에 대해 시간당 하나의 최소/최대/중앙값을 계산하는 것입니다. 그것은 에너지 사용 데이터이며 리샘플링으로 잃을 1-2 초의 피크가 있습니다. 그 외에는 예를 들어 5초/1분으로 리샘플링해도 하루에 필요한 24개의 창을 계산할 수 있는 것보다 버려야 하는 하루에 4k/1k 창을 계산해야 한다는 사실이 변경되지 않습니다. .

groupby aso를 사용하여 이 문제를 해결할 수 있지만 롤링 구현(정렬이 포함된 250만 시간 창의 경우 2초)만큼 직관적이지도 빠르지도 않은 것 같습니다. 놀랍도록 빠르고 유용하지만 그 힘을 최대한 활용하려면 보폭 주장이 필요합니다.

문제를 살펴보았습니다. 이것은 상대적으로 사소하지만 코드가 구현되는 방식으로 볼 때 모든 롤링 루틴을 수동으로 편집하는 데 누군가가 필요하다고 생각합니다. 그들 중 누구도 인덱서 클래스에 의해 주어진 창 경계를 존중하지 않습니다. 그렇다면 이 요청과 #11704 모두 매우 쉽게 해결할 수 있습니다. 어쨌든, 나는 물건을 정리하는 데 시간을 보내고 싶은 사람에게 관리할 수 있다고 생각합니다. 나는 문제를 해결하는 방법을 보여주기 위해 반쯤 구운 PR을 시작했습니다.

달리기:

import numpy as np
import pandas as pd

data = pd.Series(
    np.arange(100),
    index=pd.date_range('2020/05/12 12:00:00', '2020/05/12 12:00:10', periods=100))

print('1s rolling window every 2s')
print(data.rolling('1s', step='2s').apply(np.mean))

data.sort_index(ascending=False, inplace=True)

print('1s rolling window every 500ms (and reversed)')
print(data.rolling('1s', step='500ms').apply(np.mean))

수익률

1s rolling window every 2s
2020-05-12 12:00:00.000000000     4.5
2020-05-12 12:00:02.020202020    24.5
2020-05-12 12:00:04.040404040    44.5
2020-05-12 12:00:06.060606060    64.5
2020-05-12 12:00:08.080808080    84.5
dtype: float64
1s rolling window every 500ms (and reversed)
2020-05-12 12:00:10.000000000    94.5
2020-05-12 12:00:09.494949494    89.5
2020-05-12 12:00:08.989898989    84.5
2020-05-12 12:00:08.484848484    79.5
2020-05-12 12:00:07.979797979    74.5
2020-05-12 12:00:07.474747474    69.5
2020-05-12 12:00:06.969696969    64.5
2020-05-12 12:00:06.464646464    59.5
2020-05-12 12:00:05.959595959    54.5
2020-05-12 12:00:05.454545454    49.5
2020-05-12 12:00:04.949494949    44.5
2020-05-12 12:00:04.444444444    39.5
2020-05-12 12:00:03.939393939    34.5
2020-05-12 12:00:03.434343434    29.5
2020-05-12 12:00:02.929292929    24.5
2020-05-12 12:00:02.424242424    19.5
2020-05-12 12:00:01.919191919    14.5
2020-05-12 12:00:01.414141414     9.5
2020-05-12 12:00:00.909090909     4.5
dtype: float64

구현 세부 정보는 PR(또는 여기: https://github.com/anthonytw/pandas/tree/rolling-window-step)을 참조하십시오.

끝내는 데 더 많은 시간을 할애하고 싶었지만 불행히도 모든 롤링 기능을 재작업하는 힘든 작업을 처리할 시간이 남아 있지 않습니다. 이 문제를 해결하고자 하는 모든 사람에게 인덱서 클래스에 의해 생성된 창 경계를 적용하고 롤링_*_고정/변수 기능을 통합하는 것이 좋습니다. 시작 및 끝 경계를 사용하면 비균일 샘플링된 데이터로 특별한 작업을 수행하는 함수가 있는 경우(이 경우 특정 함수가 뉘앙스를 더 잘 처리할 수 있으므로 플래그 또는 무언가를 설정).

get_window_bounds() 접근 방식을 사용하는 사용자 지정 창에서도 작동합니까?

안녕하세요, 두 번째 제안도 부탁드립니다. 이것은 정말 유용한 기능이 될 것입니다.

'표준' 함수를 사용하는 경우 벡터화되므로 v 빠릅니다( ts.rolling(5).max().dropna()[::2] ).

IIUC 여기에서 절약은 시간의 일부(예: n번째 값마다)만 함수를 적용함으로써 얻을 수 있습니다. 그러나 그것이 실질적인 차이를 만드는 경우가 있습니까?

여기에 그러한 예가 있습니다. https://stackoverflow.com/questions/63729190/pandas-resample-daily-data-to-annual-data-with-overlap-and-offset

N 번째마다 365 번째가됩니다. 창 크기는 프로그램 수명 동안 가변적이며 단계는 창 크기의 정수 비율이 되도록 보장되지 않습니다.

기본적으로 지금까지 이 문제에 대해 찾은 모든 솔루션에서 불가능한 "보고 있는 연도의 일 수"만큼 설정된 창 크기가 필요합니다.

나는 또한 다음과 같은 맥락에서 비슷한 필요가 있습니다(실제적이고 전문적인 필요에 따라 조정됨).

• 타임스탬프 열과 불규칙한 이벤트를 나타내는 값 열이 있는 시간순 데이터 프레임이 있습니다. 개가 내 창문 아래로 지나갈 때의 타임 스탬프와 그녀가 통과하는 데 몇 초가 걸렸는지처럼. 주어진 날에 6개의 이벤트를 가질 수 있고 다음 2일 동안 이벤트가 전혀 없을 수 있습니다.
• 30일마다 롤링되는 365일의 롤링 기간으로 메트릭(예: 개가 내 창문 앞에서 보낸 평균 시간)을 계산하고 싶습니다.

내가 이해하는 한 dataframe.rolling() API를 사용하면 365일 기간을 지정할 수 있지만 다음 평균을 계산하기 위해 30일의 값(일정하지 않은 행 수)을 건너뛸 필요는 없습니다. 365일 값 선택.

분명히, 내가 기대하는 결과 데이터 프레임은 초기 '개 이벤트' 데이터 프레임보다 (훨씬) 적은 수의 행을 가질 것입니다.

간단한 예를 통해 이 요청에 대해 더 명확하게 이해하기만 하면 됩니다.

이 시리즈가 있는 경우:

In [1]: s = pd.Series(range(5))

In [2]: s
Out[2]:
0    0
1    1
2    2
3    3
4    4
dtype: int64

그리고 우리는의 창 크기가 2 와의 스텝 크기 1 . 0 인덱스에 있는 이 첫 번째 창을 평가하고, 1 인덱스에 있는 창을 건너뛰고, 2 인덱스에 있는 창을 평가합니까?

In [3]: s.rolling(2, step=1, min_periods=0).max()

Out[3]:
0    0.0
1    NaN # step over this observation
2    2.0
3    NaN # step over this observation
4    4.0
dtype: float64

마찬가지로 이 시간 기반 시리즈가 있는 경우

In [1]: s = pd.Series(range(5), index=pd.DatetimeIndex(['2020-01-01', '2020-01-02', '2020-01-03', '2020-01-06', '2020-01-09']))

In [2]: s
Out[2]:
2020-01-01    0
2020-01-02    1
2020-01-03    2
2020-01-06    3
2020-01-09    4
dtype: int64

그리고 우리는의 창 크기가 '3D' 와의 스텝 크기 '3D' . 이것이 올바른 결과가 될까요?

In [3]: s.rolling('3D', step='3D', min_periods=0).max()

Out[3]:
2020-01-01    0.0       # evaluate this window
2020-01-02    NaN    # step over this observation (2020-01-01 + 3 days > 2020-01-02)
2020-01-03    NaN    # step over this observation (2020-01-01 + 3 days > 2020-01-03)
2020-01-06    3.0      # evaluate this window ("snap back" to this observation)
2020-01-09    4.0      # evaluate this window (2020-01-06 + 3 days = 2020-01-09)
dtype: float64

@mroeschke wrt 첫 번째 예([3]), 결과는 내가 예상한 것과

인덱싱의 경우 단계 크기 = 1이 현재 동작입니다. 즉, 창의 데이터를 사용하여 관심 기능을 계산하고 창을 1만큼 이동한 다음 반복합니다. 이 예에서는 창의 데이터를 사용하여 관심 기능을 계산한 다음 60,000개의 인덱스로 이동한 다음 반복하려고 합니다.

당시에도 비슷한 발언. 이 경우 이러한 유형의 창을 구현하는 올바른 방법에 대해 약간의 불일치가 있을 수 있지만 제 생각에는 "가장 좋은"(TM) 방법은 시간 t0부터 시작하여 범위(t0-window , t0], 기능을 계산한 다음 단계 크기만큼 이동합니다. 요소의 최소 수보다 적은 창은 버립니다(구성 가능, 기본값은 1). 이 예는 후행 창에 대한 것이지만 수정할 수 있습니다. 모든 창 구성에 맞게.. 큰 간격에서 시간을 낭비하는 단점이 있지만 간격을 지능적으로 처리 할 수 ​​있으며 순진하게 계산하더라도 (나처럼 게으르므로) 나는 아직이 문제를 실제로 보지 못했습니다. , 간격은 일반적으로 실제 데이터에서 중요할 만큼 충분히 크지 않기 때문에 YMMV.

어쩌면 그것이 더 명확합니까? 위의 예제 + 코드를 보면 더 잘 설명될 수 있습니다.

@anthonytw의 설명에 감사드립니다. 실제로 step 를 "단계별"로 해석해야 하는 것 같습니다.

NaN의 경우 출력 결과에서 자동으로 NaN을 삭제하려는 감정을 이해하지만 https://github.com/pandas-dev/pandas/issues/15354#issuecomment -278676420 by @jreback 에서 언급했듯이 출력이 입력과 동일한 길이를 갖도록 하기 위한 API 일관성 고려 사항. NaN을 유지하려는 사용자가 있을 수 있으며(아마도?) rolling(..., step=...).func() 작업 후에도 dropna 를 계속 사용할 수 있습니다.

@mroeschke 예외가 있어야 한다고 생각합니다. 문서에 명시적으로 메모하고 동작이 기본값이 아닌 한 정크로 가득 찬 벡터를 반환하지 않아도 아무도 부정적인 영향을 받지 않습니다. NaN을 유지하는 것은 목적의 절반을 무효화합니다. 한 가지 목적은 값비싼 계산을 수행하는 횟수를 제한하는 것입니다. 다른 목표는 기능 세트를 관리 가능한 것으로 최소화하는 것입니다. 내가 제공한 그 예는 실제 사례이며 환자 모니터링 응용 프로그램에서 실제로 처리해야 하는 데이터만큼 많지 않습니다. 필요한 공간의 60000배를 할당한 다음 어레이를 검색하여 NaN을 삭제해야 합니까? 계산하려는 각 기능에 대해?

한 번의 계산으로 값 배열이 생성될 수 있습니다. ECG 파형으로 무엇을 하고 싶습니까? 물론 전력 스펙트럼을 계산합니다! 따라서 1개의 전체 PSD 벡터(150,000개 요소)에 180만 번(2TB의 데이터)을 위한 충분한 공간을 할당한 다음 내가 관심 있는 조각(34MB)을 얻기 위해 필터링해야 합니다. 모든 시리즈. 모든 환자를 위해. 램을 더 사야 할 것 같아요!

일부 기능의 경우 NaN이 의미 있는 출력이 될 수 있다는 점도 언급할 가치가 있습니다. 이 경우 의미 있는 NaN과 데이터를 채우는 정크 NaN의 차이를 더 이상 구분할 수 없습니다.

API를 유지하려는 욕구를 이해하지만, 이것은 기존 코드를 깨뜨리는 기능이 아니며(이전에는 존재하지 않았던 새로운 기능이기 때문에), 기능을 감안할 때 누군가가 이를 산출할 것으로 기대할 이유가 없습니다. 같은 크기의 출력 그리고 그렇게 하는 경우에도 문서의 단계 크기에 대한 메모로 충분할 것입니다. 단점은 "일관된" API를 갖는 것의 이점보다 훨씬 큽니다(이전에 존재하지 않았던 기능의 경우 주의하십시오). 이 방법으로 진행하지 않으면 기능이 손상될 것입니다. 이 경우에는 구현할 가치가 거의 없습니다(내 경험상 공간 비용이 거의 항상 더 큰 요소임).