ಆರ್‌ಎನ್‌ಜಿಯನ್ನು ಆಶೀರ್ವದಿಸಿ ಅಥವಾ ನ್ಯಾಯೋಚಿತತೆಗಾಗಿ ಆರ್‌ಎನ್‌ಜಿಯನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ

ಆಟದ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ, ನೀವು ಆಗಾಗ್ಗೆ ಯಾದೃಚ್ಛಿಕತೆಯೊಂದಿಗೆ ಏನನ್ನಾದರೂ ಕಟ್ಟಬೇಕಾಗುತ್ತದೆ: ಯೂನಿಟಿ ಇದಕ್ಕಾಗಿ ತನ್ನದೇ ಆದ ಯಾದೃಚ್ಛಿಕತೆಯನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ಅದರೊಂದಿಗೆ ಸಮಾನಾಂತರವಾಗಿ System.Random ಇದೆ. ಒಂದಾನೊಂದು ಕಾಲದಲ್ಲಿ, ಒಂದು ಯೋಜನೆಯಲ್ಲಿ, ಎರಡೂ ವಿಭಿನ್ನವಾಗಿ ಕೆಲಸ ಮಾಡಬಹುದೆಂಬ ಅನಿಸಿಕೆ ನನಗೆ ಸಿಕ್ಕಿತು (ಆದರೂ ಅವರು ಸಮ ವಿತರಣೆಯನ್ನು ಹೊಂದಿರಬೇಕು).

ನಂತರ ಅವರು ವಿವರಗಳಿಗೆ ಹೋಗಲಿಲ್ಲ - System.Random ಗೆ ಪರಿವರ್ತನೆಯು ಎಲ್ಲಾ ಸಮಸ್ಯೆಗಳನ್ನು ಸರಿಪಡಿಸಿದರೆ ಸಾಕು. ಈಗ ನಾವು ಅದನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ನೋಡಲು ಮತ್ತು ಸ್ವಲ್ಪ ಸಂಶೋಧನೆ ನಡೆಸಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ: "ಪಕ್ಷಪಾತ" ಅಥವಾ ಊಹಿಸಬಹುದಾದ RNG ಗಳು ಹೇಗೆ, ಮತ್ತು ಯಾವುದನ್ನು ಆರಿಸಬೇಕು. ಇದಲ್ಲದೆ, ಅವರ “ಪ್ರಾಮಾಣಿಕತೆ” ಬಗ್ಗೆ ನಾನು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ ಸಂಘರ್ಷದ ಅಭಿಪ್ರಾಯಗಳನ್ನು ಕೇಳಿದ್ದೇನೆ - ನಿಜವಾದ ಫಲಿತಾಂಶಗಳು ಘೋಷಿತ ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ ಹೇಗೆ ಹೋಲಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯಲು ಪ್ರಯತ್ನಿಸೋಣ.

ಸಂಕ್ಷಿಪ್ತ ಶೈಕ್ಷಣಿಕ ಕಾರ್ಯಕ್ರಮ ಅಥವಾ RNG ವಾಸ್ತವವಾಗಿ RNG ಆಗಿದೆ

ನೀವು ಈಗಾಗಲೇ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯ ಜನರೇಟರ್ಗಳೊಂದಿಗೆ ಪರಿಚಿತರಾಗಿದ್ದರೆ, ನೀವು ತಕ್ಷಣ "ಪರೀಕ್ಷೆ" ವಿಭಾಗಕ್ಕೆ ಹೋಗಬಹುದು.

ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳು (RN) ಎಂಟ್ರೊಪಿಯ ಮೂಲವಾದ ಕೆಲವು ಯಾದೃಚ್ಛಿಕ (ಅಸ್ತವ್ಯಸ್ತವಾಗಿರುವ) ಪ್ರಕ್ರಿಯೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಉತ್ಪತ್ತಿಯಾಗುವ ಸಂಖ್ಯೆಗಳ ಅನುಕ್ರಮವಾಗಿದೆ. ಅಂದರೆ, ಇದು ಒಂದು ಅನುಕ್ರಮವಾಗಿದ್ದು, ಅದರ ಅಂಶಗಳು ಯಾವುದೇ ಗಣಿತದ ಕಾನೂನಿನಿಂದ ಪರಸ್ಪರ ಸಂಬಂಧ ಹೊಂದಿಲ್ಲ - ಅವುಗಳಿಗೆ ಯಾವುದೇ ಕಾರಣ ಮತ್ತು ಪರಿಣಾಮದ ಸಂಬಂಧವಿಲ್ಲ.

ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯನ್ನು ರಚಿಸುವದನ್ನು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆ ಜನರೇಟರ್ (RNG) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಎಲ್ಲವೂ ಪ್ರಾಥಮಿಕವಾಗಿದೆ ಎಂದು ತೋರುತ್ತದೆ, ಆದರೆ ನಾವು ಸಿದ್ಧಾಂತದಿಂದ ಅಭ್ಯಾಸಕ್ಕೆ ಚಲಿಸಿದರೆ, ವಾಸ್ತವವಾಗಿ ಅಂತಹ ಅನುಕ್ರಮವನ್ನು ಉತ್ಪಾದಿಸಲು ಸಾಫ್ಟ್‌ವೇರ್ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಅಷ್ಟು ಸುಲಭವಲ್ಲ.

ಆಧುನಿಕ ಗ್ರಾಹಕ ಎಲೆಕ್ಟ್ರಾನಿಕ್ಸ್‌ನಲ್ಲಿ ಅದೇ ಅವ್ಯವಸ್ಥೆಯ ಅನುಪಸ್ಥಿತಿಯಲ್ಲಿ ಕಾರಣವಿದೆ. ಅದು ಇಲ್ಲದೆ, ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳು ಯಾದೃಚ್ಛಿಕವಾಗುವುದನ್ನು ನಿಲ್ಲಿಸುತ್ತವೆ ಮತ್ತು ಅವುಗಳ ಜನರೇಟರ್ ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ವಾದಗಳ ಸಾಮಾನ್ಯ ಕಾರ್ಯವಾಗಿ ಬದಲಾಗುತ್ತದೆ. ಐಟಿ ಕ್ಷೇತ್ರದಲ್ಲಿ ಹಲವಾರು ವಿಶೇಷತೆಗಳಿಗಾಗಿ, ಇದು ಗಂಭೀರ ಸಮಸ್ಯೆಯಾಗಿದೆ (ಉದಾಹರಣೆಗೆ, ಕ್ರಿಪ್ಟೋಗ್ರಫಿ), ಆದರೆ ಇತರರಿಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಸ್ವೀಕಾರಾರ್ಹ ಪರಿಹಾರವಿದೆ.

ನಿಜವಾದ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳಲ್ಲದಿದ್ದರೂ, ಅವುಗಳಿಗೆ ಸಾಧ್ಯವಾದಷ್ಟು ಹತ್ತಿರವಿರುವ - ಹುಸಿ-ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳು (PRN) ಎಂದು ಕರೆಯಲ್ಪಡುವ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಬರೆಯುವುದು ಅವಶ್ಯಕ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಸ್ಯೂಡೋರಾಂಡಮ್ ಸಂಖ್ಯೆ ಜನರೇಟರ್ (PRNG) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

PRNG ರಚಿಸಲು ಹಲವಾರು ಆಯ್ಕೆಗಳಿವೆ, ಆದರೆ ಈ ಕೆಳಗಿನವು ಎಲ್ಲರಿಗೂ ಪ್ರಸ್ತುತವಾಗಿರುತ್ತದೆ:

1. ಪ್ರಾಥಮಿಕ ಆರಂಭದ ಅವಶ್ಯಕತೆ.

   PRNG ಎಂಟ್ರೊಪಿಯ ಯಾವುದೇ ಮೂಲವನ್ನು ಹೊಂದಿಲ್ಲ, ಆದ್ದರಿಂದ ಅದನ್ನು ಬಳಸುವ ಮೊದಲು ಆರಂಭಿಕ ಸ್ಥಿತಿಯನ್ನು ನೀಡಬೇಕು. ಇದನ್ನು ಸಂಖ್ಯೆ (ಅಥವಾ ವೆಕ್ಟರ್) ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ ಮತ್ತು ಇದನ್ನು ಬೀಜ (ಯಾದೃಚ್ಛಿಕ ಬೀಜ) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಸಾಮಾನ್ಯವಾಗಿ, ಪ್ರೊಸೆಸರ್ ಗಡಿಯಾರ ಕೌಂಟರ್ ಅಥವಾ ಸಿಸ್ಟಮ್ ಸಮಯದ ಸಂಖ್ಯಾತ್ಮಕ ಸಮಾನತೆಯನ್ನು ಬೀಜವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

2. ಅನುಕ್ರಮ ಪುನರುತ್ಪಾದನೆ.

   PRNG ಸಂಪೂರ್ಣವಾಗಿ ನಿರ್ಣಾಯಕವಾಗಿದೆ, ಆದ್ದರಿಂದ ಪ್ರಾರಂಭದ ಸಮಯದಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಬೀಜವು ಸಂಖ್ಯೆಗಳ ಸಂಪೂರ್ಣ ಭವಿಷ್ಯದ ಅನುಕ್ರಮವನ್ನು ಅನನ್ಯವಾಗಿ ನಿರ್ಧರಿಸುತ್ತದೆ. ಇದರರ್ಥ ಒಂದೇ ಬೀಜದೊಂದಿಗೆ (ವಿವಿಧ ಸಮಯಗಳಲ್ಲಿ, ವಿಭಿನ್ನ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ, ವಿಭಿನ್ನ ಸಾಧನಗಳಲ್ಲಿ) ಪ್ರಾರಂಭಿಸಲಾದ ಪ್ರತ್ಯೇಕ PRNG ಒಂದೇ ಅನುಕ್ರಮವನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.

PRNG ಅನ್ನು ನಿರೂಪಿಸುವ ಸಂಭವನೀಯತೆಯ ವಿತರಣೆಯನ್ನು ಸಹ ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕು - ಅದು ಯಾವ ಸಂಖ್ಯೆಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ ಮತ್ತು ಯಾವ ಸಂಭವನೀಯತೆಯೊಂದಿಗೆ. ಹೆಚ್ಚಾಗಿ ಇದು ಸಾಮಾನ್ಯ ವಿತರಣೆ ಅಥವಾ ಏಕರೂಪದ ವಿತರಣೆಯಾಗಿದೆ.

ಸಾಮಾನ್ಯ ವಿತರಣೆ (ಎಡ) ಮತ್ತು ಏಕರೂಪದ ವಿತರಣೆ (ಬಲ)

ನಾವು 24 ಬದಿಗಳೊಂದಿಗೆ ನ್ಯಾಯೋಚಿತ ಡೈ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಹೇಳೋಣ. ನೀವು ಅದನ್ನು ಟಾಸ್ ಮಾಡಿದರೆ, ಒಂದನ್ನು ಪಡೆಯುವ ಸಂಭವನೀಯತೆಯು 1/24 ಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ (ಯಾವುದೇ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯುವ ಸಂಭವನೀಯತೆಯಂತೆಯೇ). ನೀವು ಅನೇಕ ಥ್ರೋಗಳನ್ನು ಮಾಡಿದರೆ ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ರೆಕಾರ್ಡ್ ಮಾಡಿದರೆ, ಎಲ್ಲಾ ಅಂಚುಗಳು ಸರಿಸುಮಾರು ಒಂದೇ ಆವರ್ತನದೊಂದಿಗೆ ಬೀಳುತ್ತವೆ ಎಂದು ನೀವು ಗಮನಿಸಬಹುದು. ಮೂಲಭೂತವಾಗಿ, ಈ ಡೈ ಅನ್ನು ಏಕರೂಪದ ವಿತರಣೆಯೊಂದಿಗೆ RNG ಎಂದು ಪರಿಗಣಿಸಬಹುದು.

ನೀವು ಈ 10 ದಾಳಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಎಸೆದು ಒಟ್ಟು ಅಂಕಗಳನ್ನು ಎಣಿಸಿದರೆ ಏನು? ಅದಕ್ಕೆ ಏಕರೂಪತೆ ಕಾಯ್ದುಕೊಳ್ಳುವುದೇ? ಸಂ. ಹೆಚ್ಚಾಗಿ, ಮೊತ್ತವು 125 ಪಾಯಿಂಟ್‌ಗಳಿಗೆ ಹತ್ತಿರದಲ್ಲಿದೆ, ಅಂದರೆ, ಕೆಲವು ಸರಾಸರಿ ಮೌಲ್ಯಕ್ಕೆ. ಮತ್ತು ಪರಿಣಾಮವಾಗಿ, ಥ್ರೋ ಮಾಡುವ ಮೊದಲು, ನೀವು ಭವಿಷ್ಯದ ಫಲಿತಾಂಶವನ್ನು ಸರಿಸುಮಾರು ಅಂದಾಜು ಮಾಡಬಹುದು.

ಕಾರಣವೆಂದರೆ ಸರಾಸರಿ ಸ್ಕೋರ್ ಪಡೆಯಲು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಸಂಯೋಜನೆಗಳು ಇವೆ. ಅದರಿಂದ ದೂರದಲ್ಲಿ, ಕಡಿಮೆ ಸಂಯೋಜನೆಗಳು - ಮತ್ತು, ಅದರ ಪ್ರಕಾರ, ನಷ್ಟದ ಸಂಭವನೀಯತೆ ಕಡಿಮೆ. ಈ ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸಿದರೆ, ಅದು ಅಸ್ಪಷ್ಟವಾಗಿ ಗಂಟೆಯ ಆಕಾರವನ್ನು ಹೋಲುತ್ತದೆ. ಆದ್ದರಿಂದ, ಕೆಲವು ವಿಸ್ತರಣೆಯೊಂದಿಗೆ, 10 ಡೈಸ್ಗಳ ವ್ಯವಸ್ಥೆಯನ್ನು ಸಾಮಾನ್ಯ ವಿತರಣೆಯೊಂದಿಗೆ RNG ಎಂದು ಕರೆಯಬಹುದು.

ಮತ್ತೊಂದು ಉದಾಹರಣೆ, ಈ ಬಾರಿ ಮಾತ್ರ ವಿಮಾನದಲ್ಲಿ - ಗುರಿಯತ್ತ ಗುಂಡು ಹಾರಿಸುವುದು. ಶೂಟರ್ RNG ಆಗಿದ್ದು ಅದು ಗ್ರಾಫ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾದ ಜೋಡಿ ಸಂಖ್ಯೆಗಳನ್ನು (x, y) ಉತ್ಪಾದಿಸುತ್ತದೆ.

ಎಡಭಾಗದಲ್ಲಿರುವ ಆಯ್ಕೆಯು ನಿಜ ಜೀವನಕ್ಕೆ ಹತ್ತಿರದಲ್ಲಿದೆ ಎಂದು ಒಪ್ಪಿಕೊಳ್ಳಿ - ಇದು ಸಾಮಾನ್ಯ ವಿತರಣೆಯೊಂದಿಗೆ RNG ಆಗಿದೆ. ಆದರೆ ನೀವು ಡಾರ್ಕ್ ಆಕಾಶದಲ್ಲಿ ನಕ್ಷತ್ರಗಳನ್ನು ಚದುರಿಸಲು ಬಯಸಿದರೆ, ಏಕರೂಪದ ವಿತರಣೆಯೊಂದಿಗೆ RNG ಬಳಸಿ ಪಡೆದ ಸರಿಯಾದ ಆಯ್ಕೆಯು ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿರುತ್ತದೆ. ಸಾಮಾನ್ಯವಾಗಿ, ಕೈಯಲ್ಲಿರುವ ಕೆಲಸವನ್ನು ಅವಲಂಬಿಸಿ ಜನರೇಟರ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿ.

ಈಗ PNG ಅನುಕ್ರಮದ ಎಂಟ್ರೊಪಿ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ. ಉದಾಹರಣೆಗೆ, ಈ ರೀತಿ ಪ್ರಾರಂಭವಾಗುವ ಒಂದು ಅನುಕ್ರಮವಿದೆ:

89, 93, 33, 32, 82, 21, 4, 42, 11, 8, 60, 95, 53, 30, 42, 19, 34, 35, 62, 23, 44, 38, 74, 36, 52 18, 58, 79, 65, 45, 99, 90, 82, 20, 41, 13, 88, 76, 82, 24, 5, 54, 72, 19, 80, 2, 74, 36, 71, 9, ...

ಮೊದಲ ನೋಟದಲ್ಲಿ ಈ ಸಂಖ್ಯೆಗಳು ಎಷ್ಟು ಯಾದೃಚ್ಛಿಕವಾಗಿವೆ? ವಿತರಣೆಯನ್ನು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸೋಣ.

ಇದು ಸಮವಸ್ತ್ರಕ್ಕೆ ಹತ್ತಿರವಾಗಿ ಕಾಣುತ್ತದೆ, ಆದರೆ ನೀವು ಎರಡು ಸಂಖ್ಯೆಗಳ ಅನುಕ್ರಮವನ್ನು ಓದಿದರೆ ಮತ್ತು ಅವುಗಳನ್ನು ಸಮತಲದಲ್ಲಿ ನಿರ್ದೇಶಾಂಕಗಳಾಗಿ ಅರ್ಥೈಸಿದರೆ, ನೀವು ಇದನ್ನು ಪಡೆಯುತ್ತೀರಿ:

ಮಾದರಿಗಳು ಸ್ಪಷ್ಟವಾಗಿ ಗೋಚರಿಸುತ್ತವೆ. ಮತ್ತು ಅನುಕ್ರಮದಲ್ಲಿನ ದತ್ತಾಂಶವು ಒಂದು ನಿರ್ದಿಷ್ಟ ರೀತಿಯಲ್ಲಿ (ಅಂದರೆ, ಇದು ಕಡಿಮೆ ಎಂಟ್ರೊಪಿಯನ್ನು ಹೊಂದಿದೆ) ಆದೇಶಿಸಿದ ಕಾರಣ, ಇದು "ಪಕ್ಷಪಾತ" ಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು. ಕನಿಷ್ಠ, ಅಂತಹ PRNG ಸಮತಲದಲ್ಲಿ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ತುಂಬಾ ಸೂಕ್ತವಲ್ಲ.

ಇನ್ನೊಂದು ಅನುಕ್ರಮ:

42, 72, 17, 0, 30, 0, 15, 9, 47, 19, 35, 86, 40, 54, 97, 42, 69, 19, 20, 88, 4, 3, 67, 27, 42 56, 17, 14, 20, 40, 80, 97, 1, 31, 69, 13, 88, 89, 76, 9, 4, 85, 17, 88, 70, 10, 42, 98, 96, 53, ...

ವಿಮಾನದಲ್ಲಿಯೂ ಸಹ ಇಲ್ಲಿ ಎಲ್ಲವೂ ಸರಿಯಾಗಿದೆ ಎಂದು ತೋರುತ್ತದೆ:

ಪರಿಮಾಣದಲ್ಲಿ ನೋಡೋಣ (ಒಂದು ಸಮಯದಲ್ಲಿ ಮೂರು ಸಂಖ್ಯೆಗಳನ್ನು ಓದಿ):

ಮತ್ತು ಮತ್ತೆ ಮಾದರಿಗಳು. ನಾಲ್ಕು ಆಯಾಮಗಳಲ್ಲಿ ದೃಶ್ಯೀಕರಣವನ್ನು ನಿರ್ಮಿಸಲು ಇನ್ನು ಮುಂದೆ ಸಾಧ್ಯವಿಲ್ಲ. ಆದರೆ ಮಾದರಿಗಳು ಈ ಆಯಾಮದಲ್ಲಿ ಮತ್ತು ದೊಡ್ಡದಾದವುಗಳಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರಬಹುದು.

ಗುಪ್ತ ಲಿಪಿಶಾಸ್ತ್ರದಲ್ಲಿ, PRNG ಗಳ ಮೇಲೆ ಅತ್ಯಂತ ಕಟ್ಟುನಿಟ್ಟಾದ ಅವಶ್ಯಕತೆಗಳನ್ನು ವಿಧಿಸಲಾಗುತ್ತದೆ, ಅಂತಹ ಪರಿಸ್ಥಿತಿಯು ವರ್ಗೀಯವಾಗಿ ಸ್ವೀಕಾರಾರ್ಹವಲ್ಲ. ಆದ್ದರಿಂದ, ಅವರ ಗುಣಮಟ್ಟವನ್ನು ನಿರ್ಣಯಿಸಲು ವಿಶೇಷ ಅಲ್ಗಾರಿದಮ್ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ, ಅದನ್ನು ನಾವು ಈಗ ಸ್ಪರ್ಶಿಸುವುದಿಲ್ಲ. ವಿಷಯವು ವಿಸ್ತಾರವಾಗಿದೆ ಮತ್ತು ಪ್ರತ್ಯೇಕ ಲೇಖನಕ್ಕೆ ಅರ್ಹವಾಗಿದೆ.

ಪರೀಕ್ಷೆ

ನಮಗೆ ಖಚಿತವಾಗಿ ಏನಾದರೂ ತಿಳಿದಿಲ್ಲದಿದ್ದರೆ, ಅದರೊಂದಿಗೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡುವುದು? ಯಾವ ಟ್ರಾಫಿಕ್ ಲೈಟ್ ಅದನ್ನು ಅನುಮತಿಸುತ್ತದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿಲ್ಲದಿದ್ದರೆ ರಸ್ತೆ ದಾಟಲು ಯೋಗ್ಯವಾಗಿದೆಯೇ? ಪರಿಣಾಮಗಳು ವಿಭಿನ್ನವಾಗಿರಬಹುದು.

ಯುನಿಟಿಯಲ್ಲಿನ ಕುಖ್ಯಾತ ಯಾದೃಚ್ಛಿಕತೆಗೆ ಅದೇ ಹೋಗುತ್ತದೆ. ದಸ್ತಾವೇಜನ್ನು ಅಗತ್ಯ ವಿವರಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸಿದರೆ ಒಳ್ಳೆಯದು, ಆದರೆ ಲೇಖನದ ಆರಂಭದಲ್ಲಿ ಉಲ್ಲೇಖಿಸಲಾದ ಕಥೆಯು ಅಪೇಕ್ಷಿತ ನಿಶ್ಚಿತಗಳ ಕೊರತೆಯಿಂದಾಗಿ ನಿಖರವಾಗಿ ಸಂಭವಿಸಿದೆ.

ಮತ್ತು ಉಪಕರಣವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿಲ್ಲದಿದ್ದರೆ, ಅದನ್ನು ಸರಿಯಾಗಿ ಬಳಸಲು ನಿಮಗೆ ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ. ಸಾಮಾನ್ಯವಾಗಿ, ಅಂತಿಮವಾಗಿ ವಿತರಣೆಯ ಬಗ್ಗೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಪ್ರಯೋಗವನ್ನು ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ನಡೆಸಲು ಸಮಯ ಬಂದಿದೆ.

ಪರಿಹಾರವು ಸರಳ ಮತ್ತು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ - ಅಂಕಿಅಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ, ವಸ್ತುನಿಷ್ಠ ಡೇಟಾವನ್ನು ಪಡೆದುಕೊಳ್ಳಿ ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ನೋಡಿ.

ಅಧ್ಯಯನದ ವಿಷಯ

ಯೂನಿಟಿಯಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳನ್ನು ರಚಿಸಲು ಹಲವಾರು ಮಾರ್ಗಗಳಿವೆ - ನಾವು ಐದು ಪರೀಕ್ಷಿಸಿದ್ದೇವೆ.

1. System.Random.Next(). ಮೌಲ್ಯಗಳ ನಿರ್ದಿಷ್ಟ ಶ್ರೇಣಿಯಲ್ಲಿ ಪೂರ್ಣಾಂಕಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.
2. System.Random.NextDouble(). [0 ರಿಂದ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಎರಡು ನಿಖರ ಸಂಖ್ಯೆಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ; 1)
3. UnityEngine.Random.Range(). ಮೌಲ್ಯಗಳ ನಿರ್ದಿಷ್ಟ ಶ್ರೇಣಿಯಲ್ಲಿ ಒಂದೇ ನಿಖರ ಸಂಖ್ಯೆಗಳನ್ನು (ಫ್ಲೋಟ್‌ಗಳು) ಉತ್ಪಾದಿಸುತ್ತದೆ.
4. UnityEngine.Random.value. [0 ರಿಂದ ಶ್ರೇಣಿಯಲ್ಲಿ ಒಂದೇ ನಿಖರ ಸಂಖ್ಯೆಗಳನ್ನು (ಫ್ಲೋಟ್‌ಗಳು) ಉತ್ಪಾದಿಸುತ್ತದೆ; 1)
5. Unity.Mathematics.Random.NextFloat(). ಹೊಸ Unity.Mathematics ಗ್ರಂಥಾಲಯದ ಭಾಗ. ಮೌಲ್ಯಗಳ ನಿರ್ದಿಷ್ಟ ಶ್ರೇಣಿಯಲ್ಲಿ ಒಂದೇ ನಿಖರ ಸಂಖ್ಯೆಗಳನ್ನು (ಫ್ಲೋಟ್‌ಗಳು) ಉತ್ಪಾದಿಸುತ್ತದೆ.

UnityEngine.Random.value (ಅಲ್ಲಿ ವಿತರಣೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿಲ್ಲ, ಆದರೆ UnityEngine.Random.Range() ಸಮವಸ್ತ್ರದೊಂದಿಗೆ ಸಾದೃಶ್ಯದ ಮೂಲಕ ಸಹ ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ) ಮತ್ತು Unity.Mathematics.Random ಹೊರತುಪಡಿಸಿ, ದಾಖಲಾತಿಯಲ್ಲಿ ಬಹುತೇಕ ಎಲ್ಲೆಡೆ ಏಕರೂಪದ ವಿತರಣೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ. .NextFloat() (ಆಧಾರದಲ್ಲಿ xorshift ಅಲ್ಗಾರಿದಮ್ ಇದೆ, ಅಂದರೆ ಮತ್ತೆ ನೀವು ಏಕರೂಪದ ವಿತರಣೆಗಾಗಿ ಕಾಯಬೇಕಾಗಿದೆ).

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳನ್ನು ದಾಖಲಾತಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದಂತೆ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ.

ವಿಧಾನ

ಪ್ರಸ್ತುತಪಡಿಸಿದ ಪ್ರತಿಯೊಂದು ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳ ಅನುಕ್ರಮಗಳನ್ನು ರಚಿಸುವ ಮತ್ತು ಹೆಚ್ಚಿನ ಪ್ರಕ್ರಿಯೆಗಾಗಿ ಫಲಿತಾಂಶಗಳನ್ನು ಉಳಿಸುವ ಸಣ್ಣ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಾವು ಬರೆದಿದ್ದೇವೆ.

ಪ್ರತಿ ಅನುಕ್ರಮದ ಉದ್ದವು 100 ಸಂಖ್ಯೆಗಳು.
ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳ ವ್ಯಾಪ್ತಿಯು [0, 100) ಆಗಿದೆ.

ಹಲವಾರು ಗುರಿ ವೇದಿಕೆಗಳಿಂದ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ:

• ವಿಂಡೋಸ್
  — ಯೂನಿಟಿ v2018.3.14f1, ಎಡಿಟರ್ ಮೋಡ್, ಮೊನೊ, .NET ಸ್ಟ್ಯಾಂಡರ್ಡ್ 2.0
• MacOS
  — ಯೂನಿಟಿ v2018.3.14f1, ಎಡಿಟರ್ ಮೋಡ್, ಮೊನೊ, .NET ಸ್ಟ್ಯಾಂಡರ್ಡ್ 2.0
  — ಯೂನಿಟಿ v5.6.4p4, ಎಡಿಟರ್ ಮೋಡ್, ಮೊನೊ, .NET ಸ್ಟ್ಯಾಂಡರ್ಡ್ 2.0
• ಆಂಡ್ರಾಯ್ಡ್
  — ಯೂನಿಟಿ v2018.3.14f1, ಬಿಲ್ಡ್ ಪರ್ ಡಿವೈಸ್, ಮೊನೊ, .NET ಸ್ಟ್ಯಾಂಡರ್ಡ್ 2.0
• ಐಒಎಸ್
  — ಯುನಿಟಿ v2018.3.14f1, ಬಿಲ್ಡ್ ಪರ್ ಡಿವೈಸ್, il2cpp, .NET ಸ್ಟ್ಯಾಂಡರ್ಡ್ 2.0

Реализация

ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳನ್ನು ರಚಿಸಲು ನಾವು ಹಲವಾರು ವಿಭಿನ್ನ ಮಾರ್ಗಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದಕ್ಕೂ, ನಾವು ಪ್ರತ್ಯೇಕ ಹೊದಿಕೆ ವರ್ಗವನ್ನು ಬರೆಯುತ್ತೇವೆ, ಅದು ಒದಗಿಸಬೇಕು:

1. ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿಸುವ ಸಾಧ್ಯತೆ [ನಿಮಿಷ/ಗರಿಷ್ಠ). ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಮೂಲಕ ಹೊಂದಿಸಲಾಗುವುದು.
2. MF ಅನ್ನು ಹಿಂದಿರುಗಿಸುವ ವಿಧಾನ. ಫ್ಲೋಟ್ ಅನ್ನು ಪ್ರಕಾರವಾಗಿ ಆಯ್ಕೆ ಮಾಡೋಣ, ಏಕೆಂದರೆ ಅದು ಹೆಚ್ಚು ಸಾಮಾನ್ಯವಾಗಿದೆ.
3. ಫಲಿತಾಂಶಗಳನ್ನು ಗುರುತಿಸಲು ಪೀಳಿಗೆಯ ವಿಧಾನದ ಹೆಸರು. ಅನುಕೂಲಕ್ಕಾಗಿ, ನಾವು ವರ್ಗದ ಪೂರ್ಣ ಹೆಸರು + MF ಅನ್ನು ಉತ್ಪಾದಿಸಲು ಬಳಸುವ ವಿಧಾನದ ಹೆಸರನ್ನು ಮೌಲ್ಯವಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.

ಮೊದಲಿಗೆ, IrandomGenerator ಇಂಟರ್ಫೇಸ್ ಪ್ರತಿನಿಧಿಸುವ ಅಮೂರ್ತತೆಯನ್ನು ಘೋಷಿಸೋಣ:

namespace RandomDistribution
{
    public interface IRandomGenerator
    {
        string Name { get; }

        float Generate();
    }
}

System.Random.Next() ನ ಅನುಷ್ಠಾನ

ಈ ವಿಧಾನವು ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಇದು ಪೂರ್ಣಾಂಕಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಆದರೆ ಫ್ಲೋಟ್ಗಳು ಅಗತ್ಯವಿದೆ. ನೀವು ಪೂರ್ಣಾಂಕವನ್ನು ಫ್ಲೋಟ್ ಎಂದು ಸರಳವಾಗಿ ಅರ್ಥೈಸಬಹುದು, ಅಥವಾ ನೀವು ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯನ್ನು ಹಲವಾರು ಆದೇಶಗಳ ಮೂಲಕ ವಿಸ್ತರಿಸಬಹುದು, ಮಧ್ಯಮ ಶ್ರೇಣಿಯ ಪ್ರತಿ ಪೀಳಿಗೆಯೊಂದಿಗೆ ಅವುಗಳನ್ನು ಸರಿದೂಗಿಸಬಹುದು. ಫಲಿತಾಂಶವು ನಿಖರತೆಯ ನಿರ್ದಿಷ್ಟ ಕ್ರಮದೊಂದಿಗೆ ಸ್ಥಿರ-ಬಿಂದುವಿನಂತೆಯೇ ಇರುತ್ತದೆ. ಇದು ನೈಜ ಫ್ಲೋಟ್ ಮೌಲ್ಯಕ್ಕೆ ಹತ್ತಿರವಾಗಿರುವುದರಿಂದ ನಾವು ಈ ಆಯ್ಕೆಯನ್ನು ಬಳಸುತ್ತೇವೆ.

using System;

namespace RandomDistribution
{
    public class SystemIntegerRandomGenerator : IRandomGenerator
    {
        private const int DefaultFactor = 100000;
        
        private readonly Random _generator = new Random();
        private readonly int _min;
        private readonly int _max;
        private readonly int _factor;


        public string Name => "System.Random.Next()";


        public SystemIntegerRandomGenerator(float min, float max, int factor = DefaultFactor)
        {
            _min = (int)min * factor;
            _max = (int)max * factor;
            _factor = factor;
        }


        public float Generate() => (float)_generator.Next(_min, _max) / _factor;
    }
}

System.Random.NextDouble() ನ ಅನುಷ್ಠಾನ

ಇಲ್ಲಿ ಮೌಲ್ಯಗಳ ಸ್ಥಿರ ಶ್ರೇಣಿ [0; 1) ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಒಂದಕ್ಕೆ ಅದನ್ನು ಪ್ರೊಜೆಕ್ಟ್ ಮಾಡಲು, ನಾವು ಸರಳ ಅಂಕಗಣಿತವನ್ನು ಬಳಸುತ್ತೇವೆ: X * (ಗರಿಷ್ಠ - ನಿಮಿಷ) + ನಿಮಿಷ.

using System;

namespace RandomDistribution
{
    public class SystemDoubleRandomGenerator : IRandomGenerator
    {
        private readonly Random _generator = new Random();
        private readonly double _factor;
        private readonly float _min;


        public string Name => "System.Random.NextDouble()";


        public SystemDoubleRandomGenerator(float min, float max)
        {
            _factor = max - min;
            _min = min;
        }


        public float Generate() => (float)(_generator.NextDouble() * _factor) + _min;
    }
}

UnityEngine.Random.Range() ಅನುಷ್ಠಾನ

UnityEngine.Random ಸ್ಥಿರ ವರ್ಗದ ಈ ವಿಧಾನವು ನಿಮಗೆ ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿಸಲು ಅನುಮತಿಸುತ್ತದೆ ಮತ್ತು ಫ್ಲೋಟ್ ಪ್ರಕಾರವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ನೀವು ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ರೂಪಾಂತರಗಳನ್ನು ಮಾಡಬೇಕಾಗಿಲ್ಲ.

using UnityEngine;

namespace RandomDistribution
{
    public class UnityRandomRangeGenerator : IRandomGenerator
    {
        private readonly float _min;
        private readonly float _max;


        public string Name => "UnityEngine.Random.Range()";


        public UnityRandomRangeGenerator(float min, float max)
        {
            _min = min;
            _max = max;
        }


        public float Generate() => Random.Range(_min, _max);
    }
}

UnityEngine.Random.value ನ ಅನುಷ್ಠಾನ

ಸ್ಥಿರ ವರ್ಗದ ಯುನಿಟಿಎಂಜಿನ್‌ನ ಮೌಲ್ಯದ ಆಸ್ತಿ. ರ್ಯಾಂಡಮ್ ಸ್ಥಿರ ಶ್ರೇಣಿಯ ಮೌಲ್ಯಗಳಿಂದ ಫ್ಲೋಟ್ ಪ್ರಕಾರವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ [0; 1) System.Random.NextDouble() ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ ಅದೇ ರೀತಿಯಲ್ಲಿ ಅದನ್ನು ನಿರ್ದಿಷ್ಟ ಶ್ರೇಣಿಯ ಮೇಲೆ ಯೋಜಿಸೋಣ.

using UnityEngine;

namespace RandomDistribution
{
    public class UnityRandomValueGenerator : IRandomGenerator
    {
        private readonly float _factor;
        private readonly float _min;


        public string Name => "UnityEngine.Random.value";


        public UnityRandomValueGenerator(float min, float max)
        {
            _factor = max - min;
            _min = min;
        }


        public float Generate() => (float)(Random.value * _factor) + _min;
    }
}

Unity.Mathematics.Random.NextFloat() ಅನುಷ್ಠಾನ

Unity.Mathematics.Random ವರ್ಗದ NextFloat() ವಿಧಾನವು ಫ್ಲೋಟ್ ಪ್ರಕಾರದ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಒಂದೇ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಯುನಿಟಿ.ಗಣಿತದ ಪ್ರತಿಯೊಂದು ನಿದರ್ಶನವನ್ನು ಕೆಲವು ಬೀಜಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಬೇಕಾಗುತ್ತದೆ - ಈ ರೀತಿಯಾಗಿ ನಾವು ಪುನರಾವರ್ತಿತ ಅನುಕ್ರಮಗಳನ್ನು ರಚಿಸುವುದನ್ನು ತಪ್ಪಿಸುತ್ತೇವೆ.

using Unity.Mathematics;

namespace RandomDistribution
{
    public class UnityMathematicsRandomValueGenerator : IRandomGenerator
    {
        private Random _generator;
        private readonly float _min;
        private readonly float _max;


        public string Name => "Unity.Mathematics.Random.NextFloat()";


        public UnityMathematicsRandomValueGenerator(float min, float max)
        {
            _min = min;
            _max = max;
            _generator = new Random();
            _generator.InitState(unchecked((uint)System.DateTime.Now.Ticks));
        }


        public float Generate() => _generator.NextFloat(_min, _max);
    }
}

ಮುಖ್ಯ ನಿಯಂತ್ರಕದ ಅಳವಡಿಕೆ

IrandomGenerator ನ ಹಲವಾರು ಅಳವಡಿಕೆಗಳು ಸಿದ್ಧವಾಗಿವೆ. ಮುಂದೆ, ನೀವು ಅನುಕ್ರಮಗಳನ್ನು ರಚಿಸಬೇಕು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗಾಗಿ ಪರಿಣಾಮವಾಗಿ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಉಳಿಸಬೇಕು. ಇದನ್ನು ಮಾಡಲು, ನಾವು ಯೂನಿಟಿಯಲ್ಲಿ ಒಂದು ದೃಶ್ಯ ಮತ್ತು ಸಣ್ಣ MainController ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ, ಅದು ಎಲ್ಲಾ ಅಗತ್ಯ ಕೆಲಸಗಳನ್ನು ಮಾಡುತ್ತದೆ ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ UI ನೊಂದಿಗೆ ಸಂವಹನಕ್ಕೆ ಜವಾಬ್ದಾರರಾಗಿರುತ್ತೇವೆ.

ಡೇಟಾಸೆಟ್‌ನ ಗಾತ್ರ ಮತ್ತು MF ಮೌಲ್ಯಗಳ ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿಸೋಣ ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ ಮತ್ತು ಕೆಲಸ ಮಾಡಲು ಸಿದ್ಧವಾಗಿರುವ ಜನರೇಟರ್‌ಗಳ ಶ್ರೇಣಿಯನ್ನು ಹಿಂತಿರುಗಿಸುವ ವಿಧಾನವನ್ನು ಸಹ ಪಡೆಯೋಣ.

namespace RandomDistribution
{
    public class MainController : MonoBehaviour
    {
        private const int DefaultDatasetSize = 100000;

        public float MinValue = 0f;
        public float MaxValue = 100f;

        ...

        private IRandomGenerator[] CreateRandomGenerators()
        {
            return new IRandomGenerator[]
            {
                new SystemIntegerRandomGenerator(MinValue, MaxValue),
                new SystemDoubleRandomGenerator(MinValue, MaxValue),
                new UnityRandomRangeGenerator(MinValue, MaxValue),
                new UnityRandomValueGenerator(MinValue, MaxValue),
                new UnityMathematicsRandomValueGenerator(MinValue, MaxValue)
            };
        }

        ...
    }
}

ಈಗ ಡೇಟಾಸೆಟ್ ಅನ್ನು ರಚಿಸೋಣ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಫಲಿತಾಂಶಗಳನ್ನು ಪಠ್ಯ ಸ್ಟ್ರೀಮ್‌ಗೆ (csv ಸ್ವರೂಪದಲ್ಲಿ) ದಾಖಲಿಸುವುದರೊಂದಿಗೆ ಡೇಟಾ ಉತ್ಪಾದನೆಯನ್ನು ಸಂಯೋಜಿಸಲಾಗುತ್ತದೆ. ಪ್ರತಿ IRandomGenerator ನ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು, ತನ್ನದೇ ಆದ ಪ್ರತ್ಯೇಕ ಕಾಲಮ್ ಅನ್ನು ಹಂಚಲಾಗುತ್ತದೆ ಮತ್ತು ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ಜನರೇಟರ್ ಹೆಸರನ್ನು ಹೊಂದಿರುತ್ತದೆ.

namespace RandomDistribution
{
    public class MainController : MonoBehaviour
    {
        ...
		
        private void GenerateCsvDataSet(TextWriter writer, int dataSetSize, params IRandomGenerator[] generators)
        {
            const char separator = ',';
            int lastIdx = generators.Length - 1;

            // write header
            for (int j = 0; j <= lastIdx; j++)
            {
                writer.Write(generators[j].Name);
                if (j != lastIdx)
                    writer.Write(separator);
            }
            writer.WriteLine();

            // write data
            for (int i = 0; i <= dataSetSize; i++)
            {
                for (int j = 0; j <= lastIdx; j++)
                {
                    writer.Write(generators[j].Generate());
                    if (j != lastIdx)
                        writer.Write(separator);
                }

                if (i != dataSetSize)
                    writer.WriteLine();
            }
        }

        ...
    }
}

GenerateCsvDataSet ವಿಧಾನಕ್ಕೆ ಕರೆ ಮಾಡುವುದು ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಫೈಲ್‌ಗೆ ಉಳಿಸುವುದು ಅಥವಾ ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಡೇಟಾವನ್ನು ತಕ್ಷಣವೇ ಅಂತಿಮ ಸಾಧನದಿಂದ ಸ್ವೀಕರಿಸುವ ಸರ್ವರ್‌ಗೆ ವರ್ಗಾಯಿಸುವುದು ಮಾತ್ರ ಉಳಿದಿದೆ.

namespace RandomDistribution
{
    public class MainController : MonoBehaviour
    {
        ...
		
        public void GenerateCsvDataSet(string path, int dataSetSize, params IRandomGenerator[] generators)
        {
            using (var writer = File.CreateText(path))
            {
                GenerateCsvDataSet(writer, dataSetSize, generators);
            }
        }


        public string GenerateCsvDataSet(int dataSetSize, params IRandomGenerator[] generators)
        {
            using (StringWriter writer = new StringWriter(CultureInfo.InvariantCulture))
            {
                GenerateCsvDataSet(writer, dataSetSize, generators);
                return writer.ToString();
            }
        }

        ...
    }
}

ಯೋಜನೆಯ ಮೂಲಗಳು ಇಲ್ಲಿವೆ ಗಿಟ್ಲಾಬ್.

ರೆಸೆಲ್ಯೂಟ್ಸ್

ಯಾವುದೇ ಪವಾಡ ಸಂಭವಿಸಲಿಲ್ಲ. ಅವರು ಏನನ್ನು ನಿರೀಕ್ಷಿಸಿದ್ದಾರೋ ಅದು ಅವರಿಗೆ ಸಿಕ್ಕಿತು - ಎಲ್ಲಾ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಪಿತೂರಿಗಳ ಸುಳಿವಿಲ್ಲದೇ ಸಮಾನ ವಿತರಣೆ. ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಿಗಾಗಿ ಪ್ರತ್ಯೇಕ ಗ್ರಾಫ್‌ಗಳನ್ನು ಹಾಕುವುದರಲ್ಲಿ ನನಗೆ ಅರ್ಥವಿಲ್ಲ - ಅವೆಲ್ಲವೂ ಸರಿಸುಮಾರು ಒಂದೇ ಫಲಿತಾಂಶಗಳನ್ನು ತೋರಿಸುತ್ತವೆ.

ವಾಸ್ತವವೆಂದರೆ:


ಎಲ್ಲಾ ಐದು ಪೀಳಿಗೆಯ ವಿಧಾನಗಳಿಂದ ಸಮತಲದಲ್ಲಿ ಅನುಕ್ರಮಗಳ ದೃಶ್ಯೀಕರಣ:


ಮತ್ತು 3D ನಲ್ಲಿ ದೃಶ್ಯೀಕರಣ. ಒಂದೇ ರೀತಿಯ ವಿಷಯದ ಗುಂಪನ್ನು ಉತ್ಪಾದಿಸದಿರಲು ನಾನು System.Random.Next() ಫಲಿತಾಂಶವನ್ನು ಮಾತ್ರ ಬಿಡುತ್ತೇನೆ.


UnityEngine.Random ನ ಸಾಮಾನ್ಯ ವಿತರಣೆಯ ಬಗ್ಗೆ ಪರಿಚಯದಲ್ಲಿ ಹೇಳಲಾದ ಕಥೆಯು ಪುನರಾವರ್ತನೆಯಾಗಲಿಲ್ಲ: ಒಂದೋ ಇದು ಆರಂಭದಲ್ಲಿ ತಪ್ಪಾಗಿದೆ, ಅಥವಾ ಇಂಜಿನ್‌ನಲ್ಲಿ ಏನಾದರೂ ಬದಲಾಗಿದೆ. ಆದರೆ ಈಗ ನಮಗೆ ಖಚಿತವಾಗಿದೆ.

ಮೂಲ: www.habr.com