पायथन

Question

में डेटा इंटरपोलेशन को कम करने के लिए डेटा स्टोरेज मेरे पास टेबल 1 के समान 20+ टेबल हैं। जहां सभी अक्षर वास्तविक मानों का प्रतिनिधित्व करते हैं।

Table 1: 
$/cars |<1 | 2 | 3 | 4+ 
<10,000 | a | b | c | d 
20,000 | e | f | g | h 
30,000 | i | j | k | l 
40,000+ | m | n | o | p 

उपयोगकर्ता इनपुट उदाहरण के लिए हो सकता है, (2.4, 24594) जो एफ, जी, जे, और के बीच एक मान है। इस पायिनियर इंटरपोलेशन की गणना करने के लिए मेरी पायथन फ़ंक्शन परिभाषा और छद्म कोड निम्नानुसार है।

def bilinear_interpolation(x_in, y_in, x_high, x_low, y_low, y_high): 
    # interpolate with respect to x 
    # interpolate with respect to y 
    # return result 

मैं तालिका 1 (एक फ़ाइल, एक dict, tuples, या सूची के dict की टपल) से डेटा कैसे संग्रहीत करना चाहिए, तो मैं द्विरेखीय प्रक्षेप सबसे अधिक कुशलता से और सही ढंग से प्रदर्शन कर सकते हैं?

Answer 1

यदि आप सबसे कम्प्यूटेशनल रूप से कुशल समाधान चाहते हैं तो मैं मानक लाइब्रेरी के बारे में सोच सकता हूं और सीमित नहीं हूं, तो मैं scipy/numpy की अनुशंसा करता हूं। सबसे पहले, एक .. डी सरणी को 2 डी numpy सरणी के रूप में स्टोर करें और फिर $ 4k-10k और 1-4 arrays दोनों को 1 डी numpy arrays के रूप में स्टोर करें। Scipy's interpolate.interp1d का उपयोग करें यदि दोनों 1 डी arrays monotonically बढ़ रहे हैं, या interpolate.bsplrep (bivariate spline प्रतिनिधित्व) यदि नहीं है और आपके उदाहरण सरणी आपके उदाहरण के रूप में छोटे हैं। या बस अपना खुद का लिखें और scipy से परेशान नहीं है। यहाँ कुछ उदाहरण हैं:

# this follows your pseudocode most closely, but it is *not* 
# the most efficient since it creates the interpolation 
# functions on each call to bilinterp 
from scipy import interpolate 
import numpy 
data = numpy.arange(0., 16.).reshape((4,4)) #2D array 
prices = numpy.arange(10000., 50000., 10000.) 
cars = numpy.arange(1., 5.) 
def bilinterp(price,car): 
    return interpolate.interp1d(cars, interpolate.interp1d(prices, a)(price))(car) 
print bilinterp(22000,2) 

पिछली बार मैं जाँच की (2007-ish से scipy का एक संस्करण) यह केवल होगा- इस 4x4 सरणी की तरह छोटे सरणियों के लिए x और y)

की सरणियों को बढ़ाने के लिए काम किया , मुझे लगता है कि आप इसका उपयोग करना चाहते हैं: http://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.bisplrep.html#scipy.interpolate.bisplrep जो अधिक रोचक आकार वाली सतहों को संभालेगा और फ़ंक्शन को केवल एक बार बनाया जाना चाहिए। बड़े सरणी के लिए, मुझे लगता है कि आप यह चाहते हैं (सुनिश्चित नहीं है कि इसमें इंटरप 1 डी के समान प्रतिबंध हैं): http://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.interp2d.html#scipy.interpolate.interp2d लेकिन दोनों को ऊपर दिए गए उदाहरण में तीन सरणी की तुलना में एक अलग और अधिक वर्बोज़ डेटा संरचना की आवश्यकता होती है।

Answer 2

बिलीनेर इंटरपोलेशन के बारे में कुछ खास नहीं है जो आपके उपयोग के मामले को विशेष रूप से विषम बनाता है; आपको बस दो लुकअप करना है (पूर्ण पंक्तियों/कॉलम की स्टोरेज इकाइयों के लिए) या चार लुकअप (सरणी प्रकार के भंडारण के लिए)। सबसे कुशल विधि आपके एक्सेस पैटर्न और डेटा की संरचना पर निर्भर करती है।

यदि आपका उदाहरण वास्तव में प्रतिनिधि है, तो 16 कुल प्रविष्टियों के साथ, आप इसे स्टोर कर सकते हैं, हालांकि आप चाहते हैं और यह किसी भी तरह के सौदा भार के लिए पर्याप्त तेज़ होगा।

Answer 3

मैं पहले कॉलम की एक क्रमबद्ध सूची रखूंगा, और मूल्यों को देखने के लिए मानक पुस्तकालय में bisect मॉड्यूल का उपयोग करूंगा - यह तुरंत-निचले और तुरंत उच्च सूचकांक प्राप्त करने का सबसे अच्छा तरीका है। हर दूसरे कॉलम को इस के समानांतर एक और सूची के रूप में रखा जा सकता है।