एफएफटी के समान परिणाम नहीं हैं

Question

मेरे पास पाइथन और MATLAB दोनों में जटिल संख्याओं के साथ एक वेक्टर है (here पाया जा सकता है)। मैं

ifft(<vector>) 

MATLAB में

साथ और

np.fft.ifft(<vector>) 

अजगर में

साथ ifft -transformation की गणना कर रहा हूँ। मेरी समस्या यह है कि मुझे इसके दो अलग-अलग परिणाम मिलते हैं, यानी जबकि पाइथन में वेक्टर जटिल है, यह MATLAB में नहीं है। जबकि MATLAB में कुछ घटक शून्य हैं, कोई भी पायथन में नहीं है। ऐसा क्यों है? fft -वर्तन इरादे के रूप में काम करता है। न्यूनतम मान लगभग 1e-10 पर हैं, यानी बहुत कम नहीं है।

Answer 1

असल में, वे वही हैं लेकिन पायथन बेहद उच्च परिशुद्धता के साथ काल्पनिक हिस्सा दिखा रहा है। काल्पनिक घटकों को 10^{-12} की परिमाण के साथ मूल्यों के साथ दिखाया जा रहा है।

यहाँ मैं MATLAB में आपकी समस्या को फिर से संगठित करने लिखा है:

format long g; 
data = importdata('data.txt'); 
out = ifft(data); 

format long g; एक स्वरूपण विकल्प है कि आप और अधिक महत्वपूर्ण अंक जहां हम दशमलव स्थानों सहित 15 महत्वपूर्ण अंक दिखाने से पता चलता है।

>> out(1:10) 

ans = 

     -6.08077329443768 
     -5.90538963023573 
     -5.72145198564976 
     -5.53037208039314 
     -5.33360059559345 
     -5.13261402212083 
     -4.92890104744583 
     -4.72394865937531 
     -4.51922820694745 
     -4.31618153490126 

numpy के लिए, यह ध्यान रखें कि जटिल संख्याओं j पत्र, नहीं i साथ में पढ़ा जाता है:

जब मैं व्युत्क्रम FFT उत्पादन के पहले 10 तत्वों दिखाने के लिए, यह मैं क्या मिलता है। इसलिए जब आप अपने पाठ में लोड करते हैं, तो आप सभी i वर्णों को j में बदलना चाहिए। एक बार जब आप ऐसा करते हैं, आप सामान्य रूप में डेटा में लोड कर सकते हैं:

In [15]: import numpy as np 

In [16]: with open('data.txt', 'r') as f: 
    ....:  lines = map(lambda x: x.replace('i', 'j'), f) 
    ....:  data = np.loadtxt(lines, dtype=np.complex) 

जब आप फ़ाइल को खोलने, map करने के लिए कॉल इस प्रकार फ़ाइल की सामग्री को ले जाएगा और j में प्रत्येक i चरित्र को बदलने और एक वापसी स्ट्रिंग्स की सूची जहां इस सूची में प्रत्येक तत्व आपकी टेक्स्ट फ़ाइल में i के साथ j के साथ एक जटिल संख्या है। हम इन स्ट्रिंग्स को जटिल संख्याओं की एक सरणी में बदलने के लिए numpy.loadtxt फ़ंक्शन को कॉल करेंगे।

अब जब मैं IFFT लेने के लिए और के रूप में हम MATLAB संस्करण के साथ देखा उल्टा परिणाम के पहले 10 तत्व प्रदर्शित, हम पाते हैं:

In [20]: out = np.fft.ifft(data) 

In [21]: out[:10] 
Out[21]: 
array([-6.08077329 +0.00000000e+00j, -5.90538963 +8.25472974e-12j, 
     -5.72145199 +3.56159535e-12j, -5.53037208 -1.21875843e-11j, 
     -5.33360060 +1.77529105e-11j, -5.13261402 -1.58326676e-11j, 
     -4.92890105 -6.13731196e-12j, -4.72394866 +5.46673985e-12j, 
     -4.51922821 -2.59774424e-11j, -4.31618154 -1.77484689e-11j]) 

आप देख सकते हैं असली हिस्सा ही लेकिन है काल्पनिक हिस्सा अभी भी मौजूद है। हालांकि, ध्यान दें कि काल्पनिक घटकों की मात्रा कितनी छोटी है। इस मामले में MATLAB ने काल्पनिक घटकों को प्रदर्शित नहीं करना चुना क्योंकि उनके परिमाण बहुत छोटे हैं। दरअसल, MATLAB में ifft कॉल से लौटा गया डेटा प्रकार वास्तविक है इसलिए ifft के बाद शायद कुछ पोस्ट-प्रोसेसिंग इन काल्पनिक घटकों को त्यागने के लिए बुलाया गया था। numpy वही काम नहीं करता है लेकिन आप इन घटकों को बहुत छोटे और महत्वहीन मान सकते हैं।

---

कुल मिलाकर, अजगर और MATLAB में दोनों ifft कॉल मूलतः एक ही हैं, लेकिन काल्पनिक घटक अर्थ में अलग है कि अजगर/numpy रिटर्न उन काल्पनिक घटक भले ही वे नगण्य हैं, जहां में ifft कॉल के रूप में MATLAB नहीं करता है। यह भी ध्यान रखें कि आपको यह सुनिश्चित करने की आवश्यकता है कि काल्पनिक चर j के साथ प्रतिस्थापित किया गया है और आप i का उपयोग अपनी मूल पाठ फ़ाइल में नहीं कर सकते हैं। यदि आप को के लिए जानते हैं कि आउटपुट प्रकार वास्तविक होना चाहिए, तो आप पर पर कॉल करके काल्पनिक घटकों को भी छोड़ सकते हैं यदि आप चाहें तो परिणाम।