การกระจายแบบสุ่มถ่วงน้ำหนักอย่างต่อเนื่องเอนเอียงไปทางปลายด้านหนึ่ง

ฉันกำลังมีส่วนร่วมในระบบอนุภาคสำหรับเกมของเราและพัฒนารูปทรงอีซีแอล

การกระจายแบบสุ่มที่สม่ำเสมอของฉันตามเส้นหรือตามพื้นที่สี่เหลี่ยมผืนผ้าทำงานได้ดี - ไม่มีปัญหา

แต่ตอนนี้ฉันอยากได้อะไรที่เหมือนกับการไล่ระดับสี 1 มิติในการแจกแจงนี้ สิ่งนี้จะหมายถึงตัวอย่างเช่นค่าที่ต่ำกว่านั้นเป็นเรื่องธรรมดามากกว่าค่าที่สูง

ฉันไม่รู้ว่าคำศัพท์ทางคณิตศาสตร์ที่เหมาะสมสำหรับปัญหานี้คืออะไรดังนั้นทักษะการค้นหาของฉันจึงค่อนข้างไร้ประโยชน์กับคำนี้ ฉันต้องการบางสิ่งที่เรียบง่ายในการคำนวณเนื่องจากระบบอนุภาคต้องมีประสิทธิภาพ

ดูรูปนี้:

มันแสดงให้เห็นกระบวนการของการทำแผนที่ค่า (สุ่ม) กับเส้นโค้ง สมมติว่าคุณสร้างค่าสุ่มที่กระจายอย่างสม่ำเสมอ X ซึ่งมีค่าตั้งแต่ 0 ถึง 1 โดยการจับคู่ค่านี้กับเส้นโค้ง - หรืออีกนัยหนึ่งคือการใช้ f (X) แทน X - คุณสามารถบิดเบือนการกระจายของคุณในแบบที่คุณต้องการ .

ในภาพนี้เส้นโค้งแรกทำให้ค่าที่สูงกว่ามีแนวโน้มมากขึ้น ที่สองทำให้ค่าที่ต่ำกว่ามีแนวโน้มมากขึ้น และอันที่สามทำให้คลัสเตอร์ค่าอยู่ตรงกลาง สูตรที่แน่นอนของเส้นโค้งไม่สำคัญและสามารถเลือกได้ตามที่คุณต้องการ

ตัวอย่างเช่นเส้นโค้งแรกดูเหมือนบิตสแควร์รูทและสแควร์คล้ายสอง อันที่สามมีลักษณะคล้ายคิวบ์เพียงแปลเท่านั้น หากคุณคิดว่าสแควร์รูทช้าเกินไปเส้นโค้งแรกก็ดูเหมือน f (X) = 1- (1-X) ^ 2 - การผกผันของสแควร์ หรือไฮเปอร์โบล์: f (X) = 2X / (1 + X)

ในฐานะที่เป็นเส้นโค้งที่สี่แสดงให้เห็นว่าคุณสามารถใช้ตารางการค้นหาที่คำนวณล่วงหน้าได้ มันดูน่าเกลียดเหมือนเส้นโค้ง แต่อาจจะดีพอสำหรับระบบอนุภาค

เทคนิคทั่วไปนี้ง่ายและมีประสิทธิภาพมาก ไม่ว่าคุณต้องการการกระจายแบบใดลองจินตนาการถึงการทำแผนที่โค้งและคุณจะคิดสูตรในเวลาไม่นาน หรือหากเครื่องยนต์ของคุณมีโปรแกรมแก้ไขให้สร้างโปรแกรมแก้ไขภาพสำหรับเส้นโค้ง!

คำอธิบายที่ยาวกว่า:

หากคุณมีการแจกแจงความน่าจะเป็นที่ต้องการเช่นการไล่ระดับ @didito ที่ต้องการคุณสามารถอธิบายได้ว่าเป็นฟังก์ชั่น สมมุติว่าคุณต้องการการกระจายแบบสามเหลี่ยมโดยที่ความน่าจะเป็นที่ 0 คือ 0.0 และคุณต้องการเลือกตัวเลขสุ่มจาก 0 ถึง 1 เราอาจเขียนมันเป็น y = x

ขั้นตอนต่อไปคือการคำนวณอินทิกรัลของฟังก์ชันนี้ ในกรณีนี้มันเป็น2} ประเมินจาก 0 ถึง 1 นั่นคือ½ มันสมเหตุสมผล - มันคือสามเหลี่ยมที่มีฐาน 1 และสูง 1 ดังนั้นพื้นที่ของมันคือ½$\int x=\frac{1}{x^2}$

จากนั้นคุณเลือกจุดสุ่มอย่างสม่ำเสมอจาก 0 ถึงพื้นที่ (½ในตัวอย่างของเรา) ลองเรียกนี่ว่า z (เราเลือกอย่างสม่ำเสมอจากการแจกแจงสะสม )

ขั้นตอนต่อไปคือย้อนกลับไปหาค่า x (เราจะเรียกมันว่า x̂) ตรงกับพื้นที่ของ z เรากำลังหา , ประเมินจาก 0 ถึง x̂, เท่ากับ z เมื่อคุณแก้ปัญหาสำหรับคุณจะได้รับ{}$\int x=\frac{1}{x^2}$$\frac{1}{x̂^2}=z$$x̂ = \sqrt{2z}$

ในตัวอย่างนี้คุณเลือก Z จาก 0 ถึง½แล้วสุ่มหมายเลขที่ต้องการเป็น{} ง่ายขึ้นคุณสามารถเขียนเป็น - สิ่งที่ธุรกิจ eBusiness แนะนำ$\sqrt{2z}$$\sqrt{rand(0, 1)}$

คุณอาจได้ใกล้เคียงกับสิ่งที่คุณต้องการโดยใช้ระบบเลขชี้กำลัง

ทำให้ x ขึ้นอยู่กับสิ่งที่ต้องการ 1- (ค่า rnd ^) (สมมติว่า rnd อยู่ระหว่าง 0 ถึง 1) และคุณจะได้รับพฤติกรรมที่แตกต่างกันของการเอียงซ้ายไปขวาตามการใช้งานของคุณ มูลค่าที่สูงขึ้นจะทำให้คุณกระจายการบิดเบือนมากขึ้น

คุณสามารถใช้เครื่องมือสร้างกราฟออนไลน์เพื่อให้ได้แนวคิดคร่าวๆเกี่ยวกับพฤติกรรมของสมการที่แตกต่างกันซึ่งจะให้คุณก่อนที่จะวางลงไปหรือคุณเพียงแค่เล่นซอกับสมการในระบบอนุภาคของคุณโดยตรง

แก้ไข

สำหรับบางสิ่งบางอย่างเช่นระบบอนุภาคที่เวลา CPU ต่ออนุภาคมีความสำคัญมากการใช้ Math.Pow (หรือเทียบเท่าภาษา) โดยตรงอาจทำให้ประสิทธิภาพลดลง หากต้องการประสิทธิภาพเพิ่มขึ้นและไม่มีการเปลี่ยนแปลงค่าในเวลาทำงานให้ลองเปลี่ยนไปใช้ฟังก์ชันที่เทียบเท่าเช่น x * x แทนที่จะเป็น x ^ 2

(เลขชี้กำลังเศษส่วนอาจเป็นปัญหามากกว่า แต่มีบางคนที่มีภูมิหลังทางคณิตศาสตร์ที่แข็งแกร่งกว่าที่ฉันอาจคิดวิธีที่ดีในการสร้างฟังก์ชั่นการประมาณ)

คำที่คุณกำลังมองหาคือWeighted Random Numbersอัลกอริธึมส่วนใหญ่ที่ฉันเคยเห็นใช้ฟังก์ชั่นตรีโกณมิติ แต่ฉันคิดว่าฉันคิดหาวิธีที่จะมีประสิทธิภาพ:

สร้างตาราง / array / List (อะไรก็ตาม) ที่เก็บค่าตัวคูณสำหรับฟังก์ชันสุ่ม กรอกด้วยมือหรือเขียนโปรแกรม ...

randMulti= {.1,.1,.1,.1,.1,.1,.2,.2,.3,.3,.9,1,1,1,} 

... จากนั้นคูณrandomด้วยการสุ่มเลือกrandMultiและท้ายที่สุดด้วยค่าสูงสุดของการกระจาย ...

weightedRandom = math.random()*randMulti[Math.random(randMulti.length)]*maxValue

ฉันเชื่อว่าสิ่งนี้จะเร็วกว่าการใช้sqrtงานหรือฟังก์ชั่นการคำนวณที่ซับซ้อนมากขึ้นและจะอนุญาตให้ใช้รูปแบบการจัดกลุ่มที่กำหนดเองมากขึ้น

ฉันคิดว่าสิ่งที่คุณขอคือการกระจายทำได้โดยใช้ฟังก์ชันรากที่สอง

[position] = sqrt(rand(0, 1))

สิ่งนี้จะให้การแจกแจงในฟิลด์มิติเดียว[0, 1]ที่ความน่าจะเป็นสำหรับตำแหน่งเทียบเท่ากับตำแหน่งนั้นคือ "การแจกแจงแบบสามเหลี่ยม"

รุ่นที่ไม่มี squareroot สำรอง:

[position] = 1-abs(rand(0, 1)-rand(0, 1))

รากที่สองในการใช้งานที่ดีที่สุดเป็นเพียงคำสั่งการคูณและผลรวมเพียงไม่กี่ที่ไม่มีสาขา (ดู: http://en.wikipedia.org/wiki/Fast_inverse_square_root ) ฟังก์ชันใดในสองฟังก์ชันนี้ที่เร็วกว่าอาจแตกต่างกันไปขึ้นอยู่กับแพลตฟอร์มและตัวสร้างแบบสุ่ม ตัวอย่างเช่นบนแพลตฟอร์ม x86 มันจะใช้เวลาเพียงไม่กี่สาขาที่ไม่แน่นอนในตัวสร้างแบบสุ่มเพื่อทำให้วิธีที่สองช้าลง

เพียงใช้การแจกแจงแบบเบต้า:

• เบต้า (1,1) แบน
• เบต้า (1,2) เป็นเส้นไล่ระดับสี
• เบต้า (1,3) เป็นกำลังสอง

เป็นต้น

พารามิเตอร์รูปร่างสองรูปไม่จำเป็นต้องเป็นจำนวนเต็ม

ยิ่งง่ายขึ้นขึ้นอยู่กับความเร็วของเครื่องกำเนิดไฟฟ้าแบบสุ่มคุณสามารถสร้างค่าสองค่าและหาค่าเฉลี่ย

หรือยิ่งง่ายที่ X เป็นผลมาจาก RNG ที่แรก,double y = double(1/x); x = y*[maximum return value of rng];สิ่งนี้จะทำให้จำนวนน้ำหนักเพิ่มขึ้นเป็นเลขชี้กำลังแทนจำนวน

สร้างและเฉลี่ยค่ามากขึ้นเพื่อเพิ่มโอกาสในการรับค่าที่อยู่ใกล้กับศูนย์

แน่นอนว่าสิ่งนี้ใช้ได้เฉพาะกับการกระจายตัวแบบโค้งมาตรฐานหรือรุ่น "พับ" ของมัน * แต่ด้วยตัวกำเนิดที่รวดเร็วมันอาจเร็วและง่ายกว่าการใช้ฟังก์ชันคณิตศาสตร์ต่างๆเช่น sqrt

คุณสามารถค้นหาการวิจัยทุกประเภทเกี่ยวกับเรื่องนี้สำหรับเส้นโค้งระฆังลูกเต๋า อันที่จริงแล้ว Anydice.com เป็นเว็บไซต์ที่ดีซึ่งสร้างกราฟสำหรับวิธีการทอยลูกเต๋าแบบต่างๆ แม้ว่าคุณกำลังใช้ RNG แต่หลักฐานก็เหมือนกันกับผลลัพธ์ ดังนั้นจึงเป็นจุดที่ดีสำหรับการดูการกระจายก่อนที่จะเข้ารหัส

* นอกจากนี้คุณยังสามารถ "พับ" การกระจายผลลัพธ์ไปตามแกนได้โดยการเอาแกนและลบผลลัพธ์เฉลี่ยแล้วจึงเพิ่มแกน ตัวอย่างเช่นคุณต้องการให้ค่าที่ต่ำกว่าเป็นค่าทั่วไปและสมมติว่าคุณต้องการให้ 15 เป็นค่าต่ำสุดของคุณและ 35 เป็นค่าสูงสุดของคุณซึ่งเป็นช่วงที่ 20 ดังนั้นคุณจึงสร้างและเฉลี่ยค่าสองค่าด้วยกันด้วยช่วง 20 สองเท่าของช่วงที่คุณต้องการ) ซึ่งจะให้เสียงระฆังตรงกึ่งกลางที่ 20 (เราลบห้าตอนท้ายเพื่อเปลี่ยนช่วงจาก 20 เป็น 40, 15 ถึง 35) นำตัวเลขที่สร้างขึ้น X และ Y

หมายเลขสุดท้าย

z =(x+y)/2;// average them
If (z<20){z = (20-z)+20;}// fold if below axis
return z-5;// return value adjusted to desired range

ถ้าศูนย์คือค่าต่ำสุดของคุณให้ทำสิ่งนี้แทน

z= (x+y)/2;
If (z<20){z = 20-z;}
else {z = z - 20;}
return z;