समय जटिलता को सत्यापित करने के लिए यूनिट परीक्षण

Question

क्या कोई कोड की समय/स्थान जटिलता को सत्यापित करने के लिए यूनिट परीक्षण का उपयोग करता है?

धन्यवाद

ह्यूगो

Answer 1

एक पूरी तरह से अच्छा बिंदु आप को लाने है यही कारण है कि। निश्चित रूप से आप इसके लिए यूनिट परीक्षण का उपयोग करें।

एक इकाई परीक्षण मुख्य रूप से आपके कोड के परिणाम का परीक्षण करने का एक "तरीका" है। आप परीक्षण करते हैं कि ऐसा करने के लिए क्या किया जाता है और यह विफल रहता है जब यह विफल हो जाता है।

समय और स्थान दो चर है जो अत्यधिक महत्वपूर्ण हैं और आप तेजी से गति और कम स्थान लागत "चाहते हैं" लेकिन वास्तव में प्रोग्राम विपरीत है, तो आपको एक बग मिला, यह यूनिट परीक्षण के लिए है, बग ढूंढें और उन्हें हल करें।

समय लगता है, तुम्हें पता है हो सकता है कि यह कैसे हल करने के लिए के लिए एक इकाई परीक्षण के कुछ छद्म कोड है, लेकिन इस परीक्षण के एक काफी अच्छा तरीका है:

Unit_Test_To_See_If_X_Takes_More_Than_Y_Seconds(int max_milli_seconds) 
{ 
    int current_millis = getMillis(); 

    do_operations_on_objects_and_functions(); 

    int millis_after_executions = getMillis(); 

    int elapes_millis = millis_after_execution - current_millis; 

    if (elapsed_millis > max_milli_seconds) 
     Assert(ERROR); 

} 

इसके अलावा जब आप इसके बारे में सोचते हैं, आप कर सकते हैं बहुत सारे परीक्षण हैं? नहीं आप नहीं कर सकते यदि आप परिणामों के लिए परीक्षण नहीं करते हैं और एक बग विकसित होता है, तो इसका मतलब यह है कि यह अस्तित्व में नहीं है क्योंकि आपने इसे नहीं देखा है, सभी परिणामों के लिए परीक्षण करना अच्छा होता है, भले ही आप "बेवकूफ" चीजों का परीक्षण करें। या आपने इसके लिए परीक्षण नहीं किया? :)

Answer 2

संभावित समाधान फिलिप के फ़ंक्शन के साथ 1 पुनरावृत्ति, फिर 100, फिर 1000, फिर 10000 (आदि) के साथ परीक्षण करना होगा और समय जटिलता निर्धारित करने के लिए ग्राफ पर परिणाम प्लॉट करना होगा। या प्रत्येक रन के बीच उच्चतम कारक अंतर प्राप्त करने के लिए गणित का उपयोग करें। मुझे यकीन नहीं है कि आप अंतरिक्ष का परीक्षण कैसे करेंगे।

मुझे नहीं लगता कि आउटपुट एक साधारण पास होगा या असफल होगा जब तक कि कोई मौजूदा एल्गोरिदम उच्चतम कारक (एन^2 आदि) प्राप्त करने के लिए न हो और इसके विरुद्ध तुलना करें।

Answer 3

मुझे एक समान समस्या थी जब मैं एल्गोरिदम ट्यून कर रहा था। मैंने जो किया वह लूप करना था और फिर लूपों और बड़े-ओ मान की संख्या से विभाजित था। फिर, मैंने इसे "क्यू" या "गुणवत्ता मान" कहा। दिलचस्प बात यह है कि मूल्य अपेक्षाकृत कम या ज्यादा स्थिर था, और खराब मानकों के लिए थोड़ा अधिक था। मुद्दा यह है कि, यदि आप बड़े-ओ की परिभाषा को देखते हैं, तो आपको मुख्य के बगल में "कम प्रभावशाली" गणना का माप मिलता है। वे अक्सर स्थिर होते हैं या कम जटिलता होती है। मेरे मामले में, यह थोड़ा रैखिक था लेकिन अभी भी इसके बारे में सोचना नहीं था।

मेरा सुझाव है कि इस तरह के गुणवत्ता-मूल्यों की गणना करें। फिर आप देख सकते हैं कि अचानक उठाया गया है जो आपके अंतिम परिवर्तनों का साइड इफेक्ट इंगित करता है जो आपकी जटिलता धारणा को तोड़ देता है।

Answer 4

जबकि समय पहलू फिलिप और जोश के उत्तर में बहुत अच्छी तरह से कवर किया गया है, अंतरिक्ष समस्या अधिक जटिल है, क्योंकि प्रश्न में कोड किसी भी स्मृति और संसाधनों को पूरा करने के लिए उपयोग किया जा रहा है। इस प्रकार मुझे लगता है कि अंतरिक्ष जटिलता निर्धारित करने के लिए यूनिट परीक्षण विशेष रूप से उपयोगी नहीं है। आपको या तो जांच की आवश्यकता होगी, या कुछ अन्य मॉनिटर आपके कैड के परीक्षण के साथ असीम रूप से चल रहे हैं।

मैं कहूंगा कि परीक्षण किए जा रहे कोड में कुछ इन-सीटू लॉग/निशान प्रदान करना सबसे आसान समाधान होगा, संभवतः रिलीज बिल्ड से हटा दिया जाएगा।