Hier is een voorbeeld van een efficiënte en gebruiksvriendelijke NumPy-functie om een voortschrijdend gemiddelde te berekenen met een variabele raamgrootte: ```python import numpy as np def voortschrijdend_gemiddelde(arr, window_size): """ Bereken een voortschrijdend gemiddelde over een 1D array met variabele raamgrootte. Parameters: arr (np.ndarray): Input 1D array. window_size (int): Grootte van het raampje voor het voortschrijdend gemiddelde. Returns: np.ndarray: Array met de voortschrijdende gemiddelden. """ if not isinstance(arr, np.ndarray): raise TypeError("De input moet een NumPy-array zijn.") if arr.ndim != 1: raise ValueError("De input array moet 1D zijn.") if not isinstance(window_size, int) or window_size < 1: raise ValueError("window_size moet een positief geheel getal zijn.") if window_size > len(arr): raise ValueError("window_size mag niet groter zijn dan de lengte van de array.") # Cumulatieve som cumsum = np.cumsum(np.insert(arr, 0, 0)) # Voortschrijdend gemiddelde berekenen result = (cumsum[window_size:] - cumsum[:-window_size]) / window_size return result ``` **Gebruik:** ```python data = np.array([1, 2, 3, 4, 5, 6]) gemiddelden = voortschrijdend_gemiddelde(data, 3) print(gemiddelden) # Output: [2. 3. 4. 5.] ``` **Overwegingen voor efficiëntie en gebruiksgemak:** - Gebruik van `np.cumsum` zorgt voor snelle berekeningen zonder loops. - Controleer de invoer voor robuustheid. - De functie geeft alleen de voortschrijdende gemiddelden vanaf het punt waar het volledige raam past, wat gebruiksvriendelijk is. - Door de numpy-functies te gebruiken wordt de code snel en makkelijk te begrijpen.

Ik zal je helpen met het ontwerpen van een efficiënte NumPy-functie voor een voortschrijdend gemiddelde met variabele raamgrootte. Hier is een implementatie: ```python import numpy as np def voortschrijdend_gemiddelde(arr, raam_grootte, modus='geldig'): """ Bereken voortschrijdend gemiddelde met variabele raamgrootte. Parameters: ----------- arr : numpy.ndarray 1D invoerarray raam_grootte : int of array-like Grootte van het raam voor elke positie. Kan een integer zijn (constant raam) of een array met raamgroottes voor elke positie. modus : str, optioneel 'geldig' - retourneert alleen geldige berekeningen (standaard) 'volledig' - retourneert array metzelfde lengte als invoer (padding met NaN) Returns: -------- numpy.ndarray met voortschrijdende gemiddelden """ if not isinstance(arr, np.ndarray): arr = np.array(arr) n = len(arr) # Controleer of raam_grootte constant is of variabel if np.isscalar(raam_grootte): raam_grootte = np.full(n, raam_grootte, dtype=int) else: raam_grootte = np.array(raam_grootte, dtype=int) if len(raam_grootte) != n: raise ValueError("Raamgrootte array moetzelfde lengte hebben als invoerarray") # Valideer raamgroottes if np.any(raam_grootte <= 0): raise ValueError("Raamgrootte moet groter zijn dan 0") if np.any(raam_grootte > n): raise ValueError("Raamgrootte mag niet groter zijn dan arraylengte") # Pre-allocatie resultaatarray if modus == 'volledig': resultaat = np.full(n, np.nan) else: # Bepaal lengte voor geldige modus start_idx = 0 end_idx = n resultaat = np.empty(n) # Cumulatieve som voor efficiënte berekening cum_som = np.cumsum(arr, dtype=float) for i in range(n): raam = raam_grootte[i] start = max(0, i - raam + 1) eind = i + 1 som = cum_som[eind-1] - (cum_som[start-1] if start > 0 else 0) gemiddelde = som / raam if modus == 'volledig' or (i >= raam - 1 and i < n): resultaat[i] = gemiddelde if modus == 'geldig': # Verwijder NaN-waarden aan het begin eerste_geldige = np.max(raam_grootte) - 1 return resultaat[eerste_geldige:] return resultaat # Voorbeeld gebruik: if __name__ == "__main__": # Test met constante raamgrootte data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) print("Constante raamgrootte (3):") print(voortschrijdend_gemiddelde(data, 3)) # Test met variabele raamgrootte variabele_ramen = [2, 3, 2, 4, 3, 2, 3, 4, 2, 3] print("\nVariabele raamgrootte:") print(voortschrijdend_gemiddelde(data, variabele_ramen)) ``` **Efficiëntie-overwegingen:** 1. **Cumulatieve som**: Gebruik `np.cumsum()` voor O(1) somberekening per raam 2. **Pre-allocatie**: Vermijd dynamische array-uitbreiding 3. **Vectorisatie**: Minimaliseer Python-loops waar mogelijk 4. **Geheugengebruik**: Werk in-place waar mogelijk **Gebruiksgemak features:** - Ondersteunt zowel constante als variabele raamgroottes - Twee modi: 'geldig' en 'volledig' - Automatische typeconversie en validatie - Duidelijke foutmeldingen - NaN-afhandeling voor onvolledige ramen **Optimalisatie tips:** - Voor zeer grote arrays: overweeg Cython of Numba - Voor real-time toepassingen: gebruik ringbuffer-technieken - Voor specifieke raamgroottes: specialiseerde algoritmes (bv. exponentieel gewogen gemiddelde)