आत्मविश्वास अंतराल निर्धारित करने के लिए अपाचे कॉमन्स मैथ का उपयोग

Question

मेरे पास बेंचमार्क डेटा का एक सेट है जिसके लिए मैं अपाचे मैथ कॉमन्स का उपयोग करके सारांश आंकड़ों की गणना करता हूं। अब मैं अंकगणितीय माध्यमों के लिए आत्मविश्वास अंतराल की गणना करने के लिए पैकेज का उपयोग करना चाहता हूं। चलने का समय माप।

क्या यह संभव है? मुझे आश्वस्त है कि पैकेज इसका समर्थन करता है, हालांकि मुझे कहां से शुरू करना है, इस बारे में एक नुकसान है।

private double getConfidenceIntervalWidth(StatisticalSummary statistics, double significance) { 
    TDistribution tDist = new TDistribution(statistics.getN() - 1); 
    double a = tDist.inverseCumulativeProbability(1.0 - significance/2); 
    return a * statistics.getStandardDeviation()/Math.sqrt(statistics.getN()); 
} 

Answer 1

Apache Commons मठ विश्वास के अंतराल के निर्माण के लिए प्रत्यक्ष समर्थन नहीं है:

यह समाधान मैं ब्रेंट Worden के सुझाव की मदद से का उपयोग कर समाप्त हो गया है। हालांकि, इसमें उनकी गणना करने के लिए आवश्यक सब कुछ है।

सबसे पहले, नमूना आंकड़ों में अपने डेटा को सारांशित करने के लिए SummaryStatistics, या कुछ अन्य StatisticalSummary कार्यान्वयन का उपयोग करें।

अगला, अपने वांछित आत्मविश्वास के स्तर के महत्वपूर्ण मूल्यों की गणना करने के लिए TDistribution का उपयोग करें। स्वतंत्रता की डिग्री सारांश आंकड़ों 'n संपत्ति से अनुमानित किया जा सकता है।

अंतिम, अपने निचले और ऊपरी आत्मविश्वास सीमा की गणना करने के सारांश आँकड़े और वितरण से टी महत्वपूर्ण मान से mean, variance, और n संपत्ति मूल्यों का उपयोग करें।

Answer 2

यदि आप अभी भी मानक संस्करण का उपयोग करके जावा में द्विपक्षीय गणना करना चाहते हैं तो आप नीचे की तरह निम्न वर्ग का उपयोग कर सकते हैं।

calling sample BinomialConfidenceCalc.calcBin(13, 100,95.0D); 

public class BinomialConfidenceCalc { 

    public static double binP(double N,double p,double x1,double x2){ 
     double q = p/(1-p); 
     double k = 0.0; 
     double v = 1.0; 
     double s = 0.0; 
     double tot = 0.0; 

     while(k<=N){      
      tot += v; 
      if(k >= x1 && k <= x2){     
       s += v; 
      }  
      if(tot > Math.pow(10,30)){      
       s = s/Math.pow(10,30); 
       tot = tot/Math.pow(10,30); 
       v = v/Math.pow(10,30); 
      } 
      k += 1; 
      v = v*q*(N+1-k)/k; 

     } 
     return s/tot; 
    } 


    public static double[] calcBin(double vx,double vN,Double vCL){ 

     double vTU = (100 - vCL)/2; 
     double vTL = vTU; 
     double dl = 0.0; 
     double vP = vx/vN; 
     if(vx==0){    
      dl = 0.0; 
     } 
     else{ 
      double v = vP/2; 
      double vsL = 0; 
      double vsH = vP; 
      double p = vTL/100; 

      while((vsH-vsL) > Math.pow(10,-5)){ 
       if(binP(vN, v, vx, vN) > p){ 
        vsH = v; 
        v = (vsL+v)/2; 
       }else{ 
        vsL = v; 
        v = (v+vsH)/2; 
       } 
      } 
      dl = v;        
     } 

     double ul = 0.0; 
     if(vx==vN){    
      ul = 1.0; 
     } 
     else{ 

      double v = (1+vP)/2; 
      double vsL =vP; 
      double vsH = 1; 
      double p = vTU/100; 
      while((vsH-vsL) > Math.pow(10,-5)){ 
       if(binP(vN, v, 0, vx) < p){ 
        vsH = v; 
        v = (vsL+v)/2; 
       } 
       else{ 
        vsL = v; 
        v = (v+vsH)/2; 
       } 
      } 
      ul = v; 
     } 
     double dlUl[] = new double[]{dl,ul}; 
     return dlUl; 
    } 



}