scipy interpolację numpy tablicy

Question

I mieć tablicę przeglądową, która jest zdefiniowana w następujący sposób:

 | <1 2 3 4 5+ 
-------|---------------------------- 
<10000 | 3.6 6.5 9.1 11.5 13.8 
20000 | 3.9 7.3 10.0 13.1 15.9 
20000+ | 4.5 9.2 12.2 14.8 18.2 


TR_ua1 = np.array([ [3.6, 6.5, 9.1, 11.5, 13.8], 
        [3.9, 7.3, 10.0, 13.1, 15.9], 
        [4.5, 9.2, 12.2, 14.8, 18.2] ]) 

• Elementy nagłówek wiersza są (HH) < 1,2,3,4,5+
• nagłówek kolumny (inc) elementy < 10000, 20000, 20001+

użytkownik będzie wejście przykładu wartość (1.3, 25000) (0,2, 50000) itd. scipy.interpolate() powinien interpolować, aby określić prawidłową wartość.

Obecnie jedyny sposób, w jaki mogę to zrobić, to kilka przykładów: if/elifs, jak to przedstawiono poniżej. Jestem prawie pewien, że jest lepszy, bardziej wydajny sposób prowadzenia tej

Oto co mam do tej pory:

import numpy as np 
from scipy import interpolate 

if (ua == 1): 
    if (inc <= low_inc): # low_inc = 10,000 
     if (hh <= 1): 
     return TR_ua1[0][0] 
     elif (hh >= 1 & hh < 2): 
     return interpolate((1, 2), (TR_ua1[0][1], TR_ua1[0][2])) 

Answer 1

EDIT: Aktualizacja rzeczy, aby odzwierciedlić swoje wyjaśnienia powyżej. Twoje pytanie jest teraz bardziej przejrzyste, dzięki!

Zasadniczo chcesz tylko interpolować tablicę 2D w dowolnym punkcie.

scipy.ndimage.map_coordinates to, co chcesz ....

Jak rozumiem pytanie, masz tablicę 2D wartości „Z”, które waha się od jakiegoś Xmin do Xmax oraz Ymin do Ymax w każdym kierunku.

Wszystko poza tymi ograniczającymi współrzędnymi, które chcesz zwrócić wartości z krawędzi tablicy.

map_coordinates ma kilka opcji obsługi punktów poza granicami siatki, ale żadna z nich nie robi dokładnie tego, co chcesz. Zamiast tego możemy po prostu ustawić wszystko poza granicami, aby leżeć na krawędzi i jak zwykle używać współrzędnych map.

Tak więc, aby korzystać map_coordinates, trzeba włączyć swoje rzeczywiste coodinates:

 | <1 2 3 4 5+ 
-------|---------------------------- 
<10000 | 3.6 6.5 9.1 11.5 13.8 
20000 | 3.9 7.3 10.0 13.1 15.9 
20000+ | 4.5 9.2 12.2 14.8 18.2 

Do indeksu współrzędne:

 | 0  1 2 3 4 
-------|---------------------------- 
    0 | 3.6 6.5 9.1 11.5 13.8 
    1 | 3.9 7.3 10.0 13.1 15.9 
    2 | 4.5 9.2 12.2 14.8 18.2 

pamiętać, że granice zachowują się inaczej w każdym kierunku ... W kierunek x, rzeczy zachowują się gładko, ale w kierunku y, pytasz o "twardą" przerwę, gdzie y = 20000 -> 3.9, ale y = 20000.000001 -> 4.5.

Jako przykład:

import numpy as np 
from scipy.ndimage import map_coordinates 

#-- Setup --------------------------- 
z = np.array([ [3.6, 6.5, 9.1, 11.5, 13.8], 
       [3.9, 7.3, 10.0, 13.1, 15.9], 
       [4.5, 9.2, 12.2, 14.8, 18.2] ]) 
ny, nx = z.shape 
xmin, xmax = 1, 5 
ymin, ymax = 10000, 20000 

# Points we want to interpolate at 
x1, y1 = 1.3, 25000 
x2, y2 = 0.2, 50000 
x3, y3 = 2.5, 15000 

# To make our lives easier down the road, let's 
# turn these into arrays of x & y coords 
xi = np.array([x1, x2, x3], dtype=np.float) 
yi = np.array([y1, y2, y3], dtype=np.float) 

# Now, we'll set points outside the boundaries to lie along an edge 
xi[xi > xmax] = xmax 
xi[xi < xmin] = xmin 

# To deal with the "hard" break, we'll have to treat y differently, 
# so we're ust setting the min here... 
yi[yi < ymin] = ymin 

# We need to convert these to (float) indicies 
# (xi should range from 0 to (nx - 1), etc) 
xi = (nx - 1) * (xi - xmin)/(xmax - xmin) 

# Deal with the "hard" break in the y-direction 
yi = (ny - 2) * (yi - ymin)/(ymax - ymin) 
yi[yi > 1] = 2.0 

# Now we actually interpolate 
# map_coordinates does cubic interpolation by default, 
# use "order=1" to preform bilinear interpolation instead... 
z1, z2, z3 = map_coordinates(z, [yi, xi]) 

# Display the results 
for X, Y, Z in zip((x1, x2, x3), (y1, y2, y3), (z1, z2, z3)): 
    print X, ',', Y, '-->', Z 

Daje:

1.3 , 25000 --> 5.1807375 
0.2 , 50000 --> 4.5 
2.5 , 15000 --> 8.12252371652 

Mam nadzieję, że pomaga ...