एक सरणी

Question

बाहर स्ट्रेचिंग मैं नमूने है कि एक वक्र फार्म का एक वेक्टर मिल गया है। आइए कल्पना करें कि इसमें 1000 अंक हैं। अगर मैं इसे 1500 अंक भरने के लिए खींचना चाहता हूं, तो सबसे सरल एल्गोरिदम क्या है जो सभ्य परिणाम देता है? मैं कुछ ऐसा ढूंढ रहा हूं जो सी/सी ++ की कुछ पंक्तियां हैं।

मैं हमेशा वेक्टर के आकार को बढ़ाना चाहता हूं, और नया वेक्टर वर्तमान वेक्टर के आकार 1.1x से 50x तक कहीं भी हो सकता है।

धन्यवाद!

Answer 1

रैखिक और वर्गबद्ध इंटरपोलेशन के लिए यहां सी ++ है।
interp1(5.3, a, n) एक [5] + .3 * (एक [6] - एक [5]), .3 [5] से एक [6] के रास्ते है;
interp1array(a, 1000, b, 1500)a से b तक फैलाएगा।
interp2(5.3, a, n) 3 निकटतम बिंदुओं के माध्यम से एक पैराबोला खींचता है [4] एक [5] एक [6]: इंटरप 1 की तुलना में चिकना लेकिन फिर भी तेज़।
(splines चिकनी अभी तक 4 निकटतम अंक, का उपयोग करें;। यदि आप अजगर को पढ़ने, basic-spline-interpolation-in-a-few-lines-of-numpy देख

// linear, quadratic interpolation in arrays 
// from interpol.py denis 2010-07-23 July 

#include <stdio.h> 
#include <stdlib.h> 

    // linear interpolate x in an array 
// inline 
float interp1(float x, float a[], int n) 
{ 
    if(x <= 0) return a[0]; 
    if(x >= n - 1) return a[n-1]; 
    int j = int(x); 
    return a[j] + (x - j) * (a[j+1] - a[j]); 
} 

    // linear interpolate array a[] -> array b[] 
void inter1parray(float a[], int n, float b[], int m) 
{ 
    float step = float(n - 1)/(m - 1); 
    for(int j = 0; j < m; j ++){ 
     b[j] = interp1(j*step, a, n); 
    } 
} 

//.............................................................................. 
    // parabola through 3 points, -1 < x < 1 
float parabola(float x, float f_1, float f0, float f1) 
{ 
    if(x <= -1) return f_1; 
    if(x >= 1) return f1; 
    float l = f0 - x * (f_1 - f0); 
    float r = f0 + x * (f1 - f0); 
    return (l + r + x * (r - l))/2; 
} 

    // quadratic interpolate x in an array 
float interp2(float x, float a[], int n) 
{ 
    if(x <= .5 || x >= n - 1.5) 
     return interp1(x, a, n); 
    int j = int(x + .5); 
    float t = 2 * (x - j); // -1 .. 1 
    return parabola(t, (a[j-1] + a[j])/2, a[j], (a[j] + a[j+1])/2); 
} 

    // quadratic interpolate array a[] -> array b[] 
void interp2array(float a[], int n, float b[], int m) 
{ 
    float step = float(n - 1)/(m - 1); 
    for(int j = 0; j < m; j ++){ 
     b[j] = interp2(j*step, a, n); 
    } 
} 

int main(int argc, char* argv[]) 
{ 
     // a.out [n m] -- 
    int n = 10, m = 100; 
    int *ns[] = { &n, &m, 0 }, 
     **np = ns; 
    char* arg; 
    for(argv ++; (arg = *argv) && *np; argv ++, np ++) 
     **np = atoi(arg); 
    printf("n: %d m: %d\n", n, m); 

    float a[n], b[m]; 
    for(int j = 0; j < n; j ++){ 
     a[j] = j * j; 
    } 
    interp2array(a, n, b, m); // a[] -> b[] 

    for(int j = 0; j < m; j ++){ 
     printf("%.1f ", b[j]); 
    } 
    printf("\n"); 
} 

Answer 2

सबसे सरल एल्गोरिदम क्या है जो सभ्य परिणाम देता है?

Catmull-रोम splines। (च - मंजिल (च)) (यदि आप एक चिकनी वक्र चाहता हूँ)

http://www.mvps.org/directx/articles/catmull/
http://en.wikipedia.org/wiki/Cubic_Hermite_spline

के लिए प्रत्येक नए आइटम वर्ष सरणी में आंशिक स्थिति की गणना, उपयोग आंशिक भाग का उपयोग प्रक्षेप कारक के रूप में, और "पूर्णांक "(यानी फर्श (एफ)) भाग निकटतम तत्वों को खोजने के लिए।

यह माना जा रहा है कि आप डेटा पर काम कर रहे हैं जो गणितीय रूप से इंटरपोलेटेड (फ्लोट) हो सकता है। यदि डेटा को इंटरपोलेट नहीं किया जा सकता है (स्ट्रिंग्स), तो एकमात्र समाधान पुरानी सरणी के निकटतम उपलब्ध तत्व का उपयोग करना है।

यदि सरणी में अंक समान रूप से वितरित नहीं किए जाते हैं तो आपको कुछ tweaking की आवश्यकता होगी।

एक्स, वाई, जेड

हो जाता है

एक्स, औसत (एक्स, वाई:

Answer 3

सबसे आसान विकल्प मैं के बारे में सोच सकते हैं सिर्फ एक fn मतलब औसत अनुसार सरणी फैलता है, इसलिए है), वाई, औसत (y, z), z

आप अधिक डेटा बिंदुओं की जरूरत है, बस इसे कई बार वेक्टर पर चलाते हैं।