किसी प्रोजेक्ट की चक्रवात जटिलता की गणना कैसे करें (वर्ग/फ़ंक्शन नहीं)?

Question

संपूर्ण जावा प्रोजेक्ट के cyclomatic complexity की गणना कैसे करें? मेरे पास हर विधि के लिए जटिलताएं हैं, लेकिन उन्हें एक संख्यात्मक मीट्रिक में कैसे एकत्रित करें? कोई विचार या मौजूदा तरीकों?

मैं एक उपकरण की तलाश नहीं कर रहा हूं, लेकिन एक एल्गोरिदम के लिए।

सरल औसत शायद ही काम करता है क्योंकि 1 -complexity विधियां हैं, जो वास्तव में कम जटिलता नहीं हैं, लेकिन कोड बेस (ज्यादातर मामलों में) के लिए कम महत्व के हैं।

TCC = Sum(CC) - Count(CC) + 1 
TCC: Total CC 
Sum(CC): Sum of CC of all functions 
Count(CC): Number of functions 

स्रोत:: http://www.aivosto.com/project/help/pm-complexity.html

लेकिन शायद यह भी सीमित है

Answer 1

मुझे लगता है कि सूत्र पाया।

एक और विचार प्रोग्राम के कॉल ग्राफ़ को प्रोग्राम के रूप में और कॉल ग्राफ़ के सीसी की गणना करने पर विचार करना होगा। नोड्स को उनके सीसी द्वारा भारित किया जाएगा। (मुझे पता नहीं है कि यह व्यवहार्य है, यह सिर्फ एक विचार है)

Answer 2

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

public class Cyclomatic 
{ 
    public static int max = Integer.MIN_VALUE; 

    static void a() 
    { 
     b(); 
     int temp = Thread.currentThread().getStackTrace().length; 
     if (temp > max) 
      max = temp; 
    } 

    static void b() 
    { 
     c(); 
     int temp = Thread.currentThread().getStackTrace().length; 
     if (temp > max) 
      max = temp; 
    } 

    static void c() 
    { 
     int temp = Thread.currentThread().getStackTrace().length; 
     if (temp > max) 
      max = temp; 
    } 

    public static void main(String[] args) 
    { 
     a(); 
     System.out.println(max); 
    } 
} 

आउटपुट:

5 

Answer 3

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

हो सकता है कि कुछ इस तरह:

public double evaluateCyclomaticComplexity(List<MethodStat> methodStats) { 
    int bad = 0; 
    for (MethodStat methodStat : methodStats) 
     if (methodStat.getCyclomaticComplexity() >= 6) 
      bad++; 

    double denominator = Math.sqrt(methodStats.size()); 
    return bad * 100.0/denominator; 
} 

छोटी संख्या यहां लौट आए, बेहतर। वास्तव में खराब प्रोजेक्ट, यह 100 से अधिक कुछ वापस कर देगा।

denominator फ़ंक्शन का प्रतिनिधित्व करना चाहिए कि कोड बेस बढ़ने के साथ जटिलता बढ़ने के साथ आप कितनी तेजी से ठीक हैं। आम तौर पर, आप चाहते हैं कि सीसी प्रति कार्य कम हो क्योंकि कोड बढ़ता जा रहा है ताकि यह बनाए रखा जा सके, इसलिए परियोजना आकार बढ़ने के साथ धीमी गति से बढ़ने वाला कुछ सबसे अच्छा होगा।

इसका परीक्षण करें, इसे ट्वीक करें, आदि। आखिरकार, कोड मेट्रिक्स को सही होने के लिए मुश्किल है, जिसे मैं ओपन सोर्स सॉफ़्टवेयर पर कई जर्नल पेपर पढ़ने के बाद प्रमाणित कर सकता हूं जो "रखरखाव" का प्रतिनिधित्व करने के लिए संख्याओं का उपयोग करते हैं। यदि हम उस पर पर्याप्त समय बिताते हैं तो हम यहां कुछ भी कर सकते हैं, तो काफी सुधार किया जा सकता है।