गैर वर्दी घनत्व

Question

के साथ यादृच्छिक संख्या उत्पन्न करें क्या किसी को पता है कि गैर-वर्दी घनत्व के साथ यादृच्छिक संख्या कैसे उत्पन्न करें?

Answer 1

एक मानचित्रण समारोह के माध्यम से एक समान घनत्व RNG का प्रयोग करें, और उसके परिणाम को पारित अपने वांछित घनत्व वितरण में बदलने के लिए।

Answer 2

लागू होने पर सबसे आसान समाधान: C++11 random facilities या Boost से उपयोग करें, जिनमें आपके लिए बहुत सारे गैर-वर्दी वितरण हैं।

Answer 3

प्रश्न में अपनी टिप्पणी में:

1/sqrt(2*pi) * e^(-x^2) 

केवल चर x है। एक्स में एक समान घनत्व होगा। तो बस एक अच्छी यादृच्छिक संख्या चुनें, फिर उसे उस समीकरण में चिपकाएं।

Answer 4

आपको यह बताना चाहिए कि आपको किस वितरण की आवश्यकता है। असल में, आप इच्छित संभाव्यता कार्य के विपरीत का उपयोग करते हैं। उदाहरण के लिए, सामान्य वितरण प्राप्त करने का सबसे आम तरीका Box-Muller transform है।

यहाँ बॉक्स मुलर के लिए कोड सिर्फ विचार प्राप्त करने के लिए है:

float box_muller(float m, float s) /* normal random variate generator */ 
{      /* mean m, standard deviation s */ 
    float x1, x2, w, y1; 
    static float y2; 
    static int use_last = 0; 

    if (use_last)    /* use value from previous call */ 
    { 
     y1 = y2; 
     use_last = 0; 
    } 
    else 
    { 
     do { 
      x1 = 2.0 * ranf() - 1.0; 
      x2 = 2.0 * ranf() - 1.0; 
      w = x1 * x1 + x2 * x2; 
     } while (w >= 1.0); 

     w = sqrt((-2.0 * log(w))/w); 
     y1 = x1 * w; 
     y2 = x2 * w; 
     use_last = 1; 
    } 

    return(m + y1 * s); 
} 

Answer 5

इस वर्ग के एक मैट्रिक्स के रूप में एक वितरण लेता है (प्रत्येक पंक्ति एक नंबर और इसकी आवृत्ति की एक जोड़ी है) और यादृच्छिक संख्या उत्पन्न करता है । तो आपके पास हो सकता है मुख्य विधि को देखें और चलाएं।

public class RandomGenerator { 
    HashMap<Integer,Range> mappa = new HashMap<Integer,Range>(); 
    Random random = new Random(); 
    int max; 




    public static void main(String as[]){ 
     int[][] matrice = new int[3][2]; 
     //number 5 occurs 5 times 
     matrice[0][0] = 5 ; 
     matrice[0][1] = 5 ; 
     //number 18 occurs 18 times 
     matrice[1][0] = 18 ; 
     matrice[1][1] = 18 ; 
     //number 77 occurs 77 times 
     matrice[2][0] = 77 ; 
     matrice[2][1] = 77 ; 

     RandomGenerator randomGenerator = new RandomGenerator(matrice); 


     for (int i = 0; i < 100; i++) { 
      System.out.println(randomGenerator.getNext()); 
     } 
    } 





    public int getNext(){ 
     int percentile = random.nextInt(max); 
     Range r =mappa.get(percentile); 
     return r.getValMax(); 
    } 

    public HashMap<Integer, Range> getMappa() { 
     return mappa; 
    } 

    public void setMappa(HashMap<Integer, Range> mappa) { 
     this.mappa = mappa; 
    } 

    public RandomGenerator(int[][] distribuzioneOriginale){ 
     ArrayList<Range> listaRange = new ArrayList<Range>(); 
     int previous = 0; 
     int totaleOccorrenze = 0; 
     for (int riga = 0; riga < distribuzioneOriginale.length; riga++) { 

      Range r = new Range(); 
      r.setValMin(previous); 
      r.setValMax(distribuzioneOriginale[riga][0]); 
      r.setOccorrenze(distribuzioneOriginale[riga][1]); 
      totaleOccorrenze += distribuzioneOriginale[riga][1]; 
      previous = distribuzioneOriginale[riga][0]; 

      listaRange.add(r); 
     } 



     int indice = 0; 
     for (int iRange = 0; iRange < listaRange.size(); iRange++) { 
      Range r = listaRange.get(iRange); 

      int perc = (int) (1000* (r.getOccorrenze()/(double) totaleOccorrenze) ) ; 

      for (int i = 0; i < perc; i++) { 
       mappa.put(i + indice , r); 
      } 
      indice += perc; 
     } 

     max = indice; 

    } 



    class Range{ 
     int valMin; 
     int valMax; 
     int occorrenze; 


     public int getValMin() { 
      return valMin; 
     } 
     public void setValMin(int valMin) { 
      this.valMin = valMin; 
     } 
     public int getValMax() { 
      return valMax; 
     } 
     public void setValMax(int valMax) { 
      this.valMax = valMax; 
     } 
     public int getOccorrenze() { 
      return occorrenze; 
     } 
     public void setOccorrenze(int occorrenze) { 
      this.occorrenze = occorrenze; 
     } 

    } 
}