मैं इंटेल एमकेएल का उपयोग कर एफएफटी और आईएफएफटी को लागू करने की कोशिश कर रहा हूं। वास्तविक इनपुट पर FFT ठीक काम करता है और मुझे वापस मिलने वाला आउटपुट ऐरे सही है। आईएफएफटी के लिए समान आउटपुट सरणी का उपयोग करने पर लौटाए गए मानों को सरणी के आकार से गुणा किया जाता है और यह सभी आकारों के लिए सही होता है। मैं समझ नहीं पा रहा हूं कि ऐसा क्यों हो रहा है। कोड इस प्रकार है:

size_t size;
std::cout << "enter the size of input and output array: ";
std::cin >> size;
float *inp = NULL;
MKL_Complex8 *op = NULL;
MKL_LONG status;

 
// Allocate memory for the arrays.
inp = (float*) mkl_malloc(size*sizeof(float), 64);
op = (MKL_Complex8*) mkl_malloc((size/2+1)*sizeof(MKL_Complex8), 64);
//Initialize values of input
for (size_t i = 0; i < size; i++){
    if(i < 8)
        inp[i] = -std::rand()%10;
    else if(i ==8)
        inp[i] = 0;
    else
        inp[i] = std::rand()%10;
}

std::cout << "The input array is: " << std::endl;
for (size_t i = 0; i < size; i++){
    std::cout << inp[i] << ", ";
}
std::cout << std::endl;

//Specify descriptor values.

DFTI_DESCRIPTOR_HANDLE hand = NULL;

status = DftiCreateDescriptor(&hand, DFTI_SINGLE, DFTI_REAL, 1, (MKL_LONG) size);
status = DftiSetValue(hand, DFTI_PLACEMENT, DFTI_NOT_INPLACE);
status = DftiSetValue(hand, DFTI_CONJUGATE_EVEN_STORAGE, DFTI_COMPLEX_COMPLEX);
status = DftiSetValue(hand, DFTI_PACKED_FORMAT, DFTI_CCE_FORMAT);
status = DftiCommitDescriptor(hand);
status = DftiComputeForward(hand, inp, op);


status = DftiComputeBackward(hand, op, inp);

std::cout << "\nThe output of iFFT is: " << std::endl;
for (size_t i = 0; i < size; i++){
    std::cout << inp[i] << ", ";
}
std::cout << std::endl;

DftiFreeDescriptor(&hand);
free(inp);
free(op);

return 0;
}

आईएफएफटी के बाद अलग-अलग सरणी तत्वों को आकार से विभाजित करना एक क्रूड वर्कअराउंड होगा, लेकिन यह समझाने में विफल रहता है कि यह पहली जगह क्यों हो रहा है। वास्तविक कारण को समझना और उसे ठीक करना बेहतर होगा। यह वास्तविक कोड से पहले इन परिवर्तनों को लागू करने का एक परीक्षण है और मैं वास्तव में यह समझना चाहूंगा कि ऐसा क्यों हो रहा है। धन्यवाद।

2
Dewan Arun Singh 13 सितंबर 2020, 10:34

1 उत्तर

सबसे बढ़िया उत्तर

अलग-अलग सामान्यीकरण कारकों के साथ एफएफटी/आईएफएफटी की परिभाषा के लिए अलग-अलग परंपराएं मौजूद हैं: एफएफटी पक्ष में 1/एन सामान्यीकरण, या आईएफएफटी पक्ष में 1/एन सामान्यीकरण, या दोनों तरफ 1/वर्ग (एन) सामान्यीकरण, या बिल्कुल भी सामान्यीकरण नहीं .

सामान्यीकरण कारक के बिना, एफएफटी/आईएफएफटी के बाद, आपको एफएफटी आकार से प्रभावी रूप से गुणा मिलता है।

जैसा कि क्रिस लुएंगो ने एक टिप्पणी में उल्लेख किया है, यह संभावना है कि एमकेएल ने बिना किसी सामान्यीकरण के बिल्डिंग ब्लॉक्स प्रदान करने का विकल्प चुना ताकि दो बार सामान्यीकरण करके दंडित न किया जा सके।

Intel MKL के संदर्भ में, 2 पैरामीटर DFTI_FORWARD_SCALE और DFTI_BACKWARD_SCALE मौजूद हैं जिन्हें DftiSetValue() का उपयोग करके सेट किया जा सकता है। एक-आयामी ट्रांसफ़ॉर्म के लिए, आप फॉरवर्ड ट्रांसफ़ॉर्म स्केल को 1 और बैकवर्ड ट्रांसफ़ॉर्म स्केल को 1/n के रूप में उपयोग कर सकते हैं, जहाँ 'n' 1-D ट्रांसफ़ॉर्म का आकार है। (अधिक जानकारी के लिए देखें MKL के लिए Intel प्रलेखन)

0
Dewan Arun Singh 16 सितंबर 2020, 08:00