# Poisson Twister Generator by Cumulative Frequency Technology

^{1}

^{2}

^{*}

## Abstract

**:**

## 1. Introduction

namespace P060102 { class cP060102 { static uint gc = 0; //quantity of uniform generation static void Main(string[] args) { int w = 16; //bit width of uniform integer variable long N = 1L << w; //random variable quantity Console.WriteLine(“w = {0} N = {1}”, w, N); double Alpha = 2.0; Console.WriteLine(“Alpha = {0:F2}”, Alpha); Random G = new Random(); //uniform generator p int wX = 200; int[] nuK = new int[wX]; //Knuth frequency for (int i = 0; i < wX; i++) nuK[i] = 0; int maxK = 0; //distribution length for (int i = 0; i < N; i++) { int k = KnuthPoisson(Alpha, N, G); nuK[k]++; //Knuth frequency if (k > maxK) maxK = k; //distribution length } Console.WriteLine(“maxK = {0}”, maxK); double[] pEta = new double[wX]; //probability long[] nuEta = new long[wX]; //Poisson frequency int cEta = PoissonP(Alpha, N, pEta, nuEta); VerifyProbability(N, cEta, pEta, nuEta); Console.WriteLine(“cEta = {0} ”, cEta); long snuEta = 0; //sum of Poisson frequency double spEta = 0.0; //sum of Poisson probability int snuK = 0; //sum of Knuth frequency double spK = 0.0; //sum of Knuth probability Console.Write(“Eta pK nuK”); Console.Write(“ pEta nuEta”); Console.WriteLine(“ nuK − nuEta”); int nEta = cEta > maxK ? cEta : maxK; for (int i = 0; i <= nEta; i++) //frequency tabling { double pK = (double)nuK[i]/(double)N; int dnu = (int)(nuK[i] − nuEta[i]); Console.Write(“{0,2} {2,12:F10} {1,10}”, i, nuK[i], pK); Console.Write(“ {0,12:F10} {1,10}”, pEta[i], nuEta[i]); Console.WriteLine(“ {0,8}”, dnu); snuK += nuK[i]; //sum of Knuth frequency spK += pK; //sum of Knuth probability snuEta += nuEta[i]; //sum of Poisson frequency spEta += pEta[i]; //sum of Poisson probability } Console.Write(“sum spK snuK”); Console.WriteLine(“ spEta snuEta”); Console.Write(“ {0,12:F10} {1,10}”, spK, snuK); Console.WriteLine(“ {0,12:F10} {1,10}”, spEta, snuEta); Console.WriteLine(“gc = {0}”, gc); Console.ReadKey(); //result viewing } //-------------------------------------------------------------- static int KnuthPoisson(double Lam, long N, Random G) { double L = Math.Exp(-Lam); double p = 1.0; double dN = (double)N; int k = 0; do { k++; long z = (long)G.Next(); //uniform variable z = z & (N − 1); double u = (double)z/dN; p = p * u; gc++; //global number of uniform generation } while (p > L); return k − 1; } //-------------------------------------------------------------- static int PoissonP(double alpha, long N, double[] pEta, long[] nuEta) { double emAlpha = Math.Exp(-alpha); double spEta = 0.0; //probability sum long snuEta = 0L; //frequency sum pEta [0] = 1.0 * emAlpha; //Poisson probability p(0) spEta += pEta[0]; //probability sum nuEta[0] = (long)Math.Round(pEta[0] * (double)N); snuEta += nuEta[0]; //frequency sum double r = alpha; //Tailor first summand pEta[1] = r * emAlpha; //Poisson probability p(1) spEta += pEta[1]; //probability sum nuEta[1] = (long)Math.Round(pEta[1] * (double)N); snuEta += nuEta[1]; //frequency sum int Eta = 2; //random variable value do { r *= alpha/(double)Eta; //regular summand of exp double p = r * emAlpha; //probability p(Eta) long nu = (long)Math.Round(p * (double)N); long sd = snuEta + nu; if (nu == 0L || sd > N) break; //the tail pEta[Eta] = p; //probability p(Eta) spEta += p; //probability sum nuEta[Eta] = nu; //frequency nu(Eta) snuEta += nu; //frequency sum Eta++; //next random variable Eta } while (snuEta < N); long d = N − snuEta; //tailing frequencies if (d == 0L) return Eta − 1; double d1N = (1.0 − spEta)/(double)d; do { pEta[Eta] = d1N; //the tail event probability nuEta[Eta] = 1; //one-part event snuEta++; //frequency sum Eta++; } while (snuEta < N); return Eta − 1; } //-------------------------------------------------------------- static void VerifyProbability(long N, int cEta, double[] pEta, long[] nuEta) { double dN = (double)N; for (int i = 0; i <= cEta; i++) pEta[i] = (double)nuEta[i]/dN; } //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ } }

w = 16 N = 65536 Alpha = 2.00 maxK = 12 cEta = 10 Eta pK nuK pEta nuEta nuK − nuEta 0 0.1352539063 8864 0.1353302002 8869 −5 1 0.2691345215 17638 0.2706756592 17739 −101 2 0.2699890137 17694 0.2706756592 17739 −45 3 0.1814422607 11891 0.1804504395 11826 65 4 0.0910491943 5967 0.0902252197 5913 54 5 0.0361175537 2367 0.0360870361 2365 2 6 0.0125427246 822 0.0120239258 788 34 7 0.0032806396 215 0.0034332275 225 −10 8 0.0008850098 58 0.0008544922 56 2 9 0.0002441406 16 0.0001983643 13 3 10 0.0000457764 3 0.0000457764 3 0 11 0.0000000000 0 0.0000000000 0 0 12 0.0000152588 1 0.0000000000 0 1 sum spK snuk spEta snuEta 1.0000000000 65536 1.0000000000 65536 gc = 197025

## 2. Theory

- The probability of events in the time interval $\left(t,t+\tau \right]$ does not depend on its origin t:$${P}_{\eta -k}\left(\left(t,t+\tau \right]\right)={P}_{\eta -k}\left(\left(0,\tau \right]\right).$$
- The probability of one event in the time interval $\left(0,\tau \right]$ depends linearly on the length of the interval $\tau $ with given intensity $\lambda $; and the probability $o\left(\tau \right)$ of observing other events is negligible:$${P}_{1}\left(\left(0,\tau \right]\right)={P}_{1}\left(\tau \right)=\lambda \xb7\tau +o\left(\tau \right).$$

using nsDeonYuliTwist32D; //complete twister generator //of integer uniform numbers namespace P060202 { class cP060202 { static void Main(string[] args) { int w = 32; //bit width of uniform integer variable long N = 1L << w; //random variable quantity Console.WriteLine(“w = {0} N = {1}”, w, N); double Alpha = 2.0; Console.WriteLine(“Alpha = {0:F2}”, Alpha); int wX = 200; double[] pEta = new double[wX]; //Poisson probability long[] nuEta = new long[wX]; //Poisson frequency long[] cnuEta = new long[wX]; //cumulative frequency int cEta = PoissonDY(Alpha, pEta, nuEta, cnuEta, N); VerifyProbability(N, cEta, pEta, nuEta, cnuEta); Console.WriteLine(“cEta = {0}”, cEta); cDeonYuliTwist32D DYG = new cDeonYuliTwist32D(); DYG.SetW(w); //set bit width of uniform variable DYG.Start(); //start uniform generator long[] nuDYG = new long[wX];//frequencies of generator for (int i = 0; i < wX; i++) nuDYG[i] = 0; for (long j = 0; j < N; j++) { long z = DYG.Next(); //uniform variable int Eta = SearchEta(z, cnuEta, cEta); nuDYG[Eta]++; //uniform variable counter } double spEta = 0.0; //sum of Poisson probability long snuEta = 0; //sum of Poisson frequency long snuDYG = 0; //sum of variables by generator Console.Write(“Eta pEta nuEta”); Console.WriteLine(“ cnuEta nuDYG”); for (int Eta = 0; Eta <= cEta; Eta++) { Console.WriteLine( “{0,2} {1,12:F10} {2,10} {3,10} {4,10}”, Eta, pEta[Eta], nuEta[Eta], cnuEta[Eta], nuDYG[Eta]); spEta += pEta[Eta]; snuEta += nuEta[Eta]; snuDYG += nuDYG[Eta]; } Console.Write(“Sum spEta snuEta”); Console.WriteLine(“ snuDYG”); Console.Write(“ {0,12:F10} {1,10}”, spEta, snuEta); Console.WriteLine(“ {0,10}”, snuDYG); Console.ReadKey(); //result viewing } //-------------------------------------------------------------- static int PoissonDY (double alpha, double[] pEta, long[] nuEta, long[] cnuEta, long N) { double emAlpha = Math.Exp(−alpha); double spEta = 0.0; //sum of probability long snuEta = 0L; //sum of frequency pEta[0] = 1.0 * emAlpha; //Poisson probability p(0) spEta += pEta[0]; //sum of probability nuEta[0] = (long)Math.Round(pEta[0] * (double)N); snuEta += nuEta[0]; //sum of frequency cnuEta[0] = snuEta; //cumulative frequency cnu(0) double r = alpha; //Tailor first summand pEta[1] = r * emAlpha; //Poisson probability p(1) spEta += pEta[1]; //sum of probability nuEta[1] = (long)Math.Round(pEta[1] * (double)N); snuEta += nuEta[1]; //sum of frequency cnuEta[1] = snuEta; //cumulative frequency cnu(1) int Eta = 2; //random variable do { r *= alpha/(double)Eta; //regular summand of exp double p = r * emAlpha; //probability p(Eta) long nu = (long)Math.Round(p * (double)N); long sd = snuEta + nu; if (nu == 0L || sd > N) break; //the tail pEta[Eta] = p; //probability p(Eta) spEta += p; //sum of probability nuEta[Eta] = nu; //frequency nu(Eta) snuEta += nu; //sum of frequency cnuEta[Eta] = snuEta; //cumulative frequency Eta++; //next random variablecлeдyющaя Eta } while (snuEta < N); Eta--; long d = N − snuEta; //tailing frequencies if (d == 0L) return Eta; double d1N = (1.0 − spEta)/(double)d; do { Eta++; pEta[Eta] = d1N; //probability of a tail event nuEta[Eta] = 1; //one-frequency event snuEta++; //sum of frequency cnuEta[Eta] = snuEta; //cumulative frequency } while (snuEta < N); return Eta; } //-------------------------------------------------------------- static void VerifyProbability (long N, int cEta, double[] pEta, long[] nuEta, long[] cnuEta) { double dN = (double)N; for (int i = 0; i <= cEta; i++) pEta[i] = (double)nuEta[i]/dN; } //-------------------------------------------------------------- static int SearchEta (long z, long[] cnuEta, int cEta) { int Eta = 0; for (; Eta <= cEta; Eta++) if (z < cnuEta[Eta]) break; return Eta; } //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ } }

w = 32 N = 4294967296 Alpha = 2.00 cEta = 16 Eta pEta nuEta cnuEta nuDYG 0 0.1353352831 581260615 581260615 581260615 1 0.2706705665 1162521231 1743781846 1162521231 2 0.2706705665 1162521231 2906303077 1162521231 3 0.1804470443 775014154 3681317231 775014154 4 0.0902235222 387507077 4068824308 387507077 5 0.0360894089 155002831 4223827139 155002831 6 0.0120298029 51667610 4275494749 51667610 7 0.0034370865 14762174 4290256923 14762174 8 0.0008592717 3690544 4293947467 3690544 9 0.0001909493 820121 4294767588 820121 10 0.0000381898 164024 4294931612 164024 11 0.0000069437 29823 4294961435 29823 12 0.0000011572 4970 4294966405 4970 13 0.0000001781 765 4294967170 765 14 0.0000000254 109 4294967279 109 15 0.0000000035 15 4294967294 15 16 0.0000000005 2 4294967296 2 Sum spEta snuEta snuDYG 1.000000000 4294967296 4294967296

## 3. Construction and Results

using nsDeonYuliTwist32D; //complete twister generator //of integer uniform numbers namespace nsDeonYuliCPoissonTwist32D { class cDeonYuliCPoissonTwist32D : cDeonYuliTwist32D { public long N; //quantity of uniform events public double dN; //quantity of uniform events public double Alpha = 2.0; //Alpha parameter double emAlpha; //exp(−Alpha) public int cEta; //maximal Eta public double[] pC; //probability distribution public long[] nuC; //frequency distribution public long[] cnuC; //cumulative frequencies //-------------------------------------------------------------- public cDeonYuliCPoissonTwist32D () {} //-------------------------------------------------------------- public void CStart(double alpha) { Alpha = alpha; //Alpha parameter base.Start(); //uniform twister generator CStartInside(); } //-------------------------------------------------------------- public void CTimeStart(double alpha) { Alpha = alpha; //Alpha parameter base.TimeStart(); //uniform twister generator CStartInside(); } //-------------------------------------------------------------- void CStartInside() { int wX = 200; pC = new double[wX]; //probability distribution nuC = new long[wX]; //frequency distribution cnuC = new long[wX]; //cumulative frequencies emAlpha = Math.Exp(−Alpha); //exp(−Alpha) N = (long)N1 + 1L; //quantity of uniform events dN = (double)N; //quantity of uniform events cEta = CPoissonDY(); //probability and frequency CVerifyProbability(); //probability verification } //-------------------------------------------------------------- public int CNext() { uint z =base.Next(); //uniform random variable return CSearchEta(z); //Poisson random variable } //-------------------------------------------------------------- int CPoissonDY() { double spC = 0.0; //probability sum long snuC = 0L; //frequency sum pC[0] = 1.0 * emAlpha; //Poisson probability p(0) spC += pC[0]; //probability sum nuC[0] = (long)Math.Round(pC[0] * dN);//frequency nu(0) snuC += nuC[0]; //frequency sum cnuC[0] = snuC; //cumulative frequency cnu(0) double r = Alpha; //Tailor first summand pC[1] = r * emAlpha; //Poisson probability p(1) spC += pC[1]; //probability sum nuC[1] = (long)Math.Round(pC[1] * dN);//frequency nu(1) snuC += nuC[1]; //frequency sum cnuC[1] = snuC; //cumulative frequency cnu(1) int Eta = 2; //random variable do { r *= Alpha/(double)Eta; //regular summand of exp double p = r * emAlpha; //probability p(Eta) long nu = (long)Math.Round(p * dN); if (nu == 0L) break; //a tail zero frequencies long sd = snuC + nu; if (nu == 0L || sd > N) break; //the tail pC[Eta] = p; //probability p(Eta) spC += p; //probability sum nuC[Eta] = nu; //frquency nu(Eta) snuC += nu; //frequency sum cnuC[Eta] = snuC; //cumulative frequency Eta++; //the next random variable Eta } while (snuC < N); Eta--; long d = N − snuC; //a tail frequencies if (d == 0L) return Eta; double d1N = (1.0 − spC)/(double)d; do { Eta++; pC[Eta] = d1N; //a tail event probability nuC[Eta] = 1; //one-frequency event snuC++; //frequency sum cnuC[Eta] = snuC; //cumulative frequency } while (snuC < N); return Eta; } //-------------------------------------------------------------- void CVerifyProbability() { for (int i = 0; i <= cEta; i++) pC[i] = (double)nuC[i]/dN; } //-------------------------------------------------------------- int CSearchEta(uint z) { int Eta = 0; for (; Eta <= cEta; Eta++) if (z < cnuC[Eta]) break; return Eta; } //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ } }

using nsDeonYuliCPoissonTwist32D; //Poisson twister generator //by technology of cumulative frequencies namespace P060302 { class cP060302 { static void Main(string[] args) { cDeonYuliCPoissonTwist32D PT = new cDeonYuliCPoissonTwist32D(); int w = 7; //bit width of uniform random variable PT.SetW(w); //set bit width of uniform variable double Alpha = 2.0; //Alpha parameter PT.CStart(Alpha); //start generator // PT.CTimeStart(Alpha);//start generator using time value Console.WriteLine(“w = {0} N = {1}”, PT.w, PT.N); Console.WriteLine(“Alpha = {0:F2}”, Alpha); Console.WriteLine(“cEta = {0}”, PT.cEta); int wX = 200; int[] nuG = new int[wX]; //frequencies of generator for (int i = 0; i< wX; i++) nuG[i] = 0; for (int i = 0, j = 1; i< PT.N; i++, j++) { int Eta = PT.CNext(); //Poisson variable Console.Write(“{0,5}”, Eta); if (j % 8 == 0) Console.WriteLine(); nuG[Eta]++; //counter of random variable } Console.WriteLine(); double spEta = 0.0; //Poisson probability sum long snuEta = 0; //Poisson frequency sum int snuG = 0; //frequency sum by generator Console.Write(“Eta pC nuC”); Console.WriteLine(“ cnuC nuDYG”); for (int Eta = 0; Eta<= PT.cEta; Eta++) { Console.WriteLine( “{0,2} {1,12:F10} {2,8} {3,8} {4,8}”, Eta, PT.pC[Eta], PT.nuC[Eta], PT.cnuC[Eta], nuG[Eta]); spEta += PT.pC[Eta]; snuEta += PT.nuC[Eta]; snuG += nuG[Eta]; } Console.Write(“Sum spC snuC”); Console.WriteLine(“ snuDYG”); Console.WriteLine( “ {0,12:F10} {1,8} {2,8}”, spEta, snuEta, snuG); Console.ReadKey(); //result viewing } } }

w = 7 N = 128 Alpha = 2.00 cEta = 6 1 6 3 1 3 1 1 2 2 1 0 2 0 2 3 3 3 2 1 4 2 3 0 0 0 4 2 1 3 0 1 2 1 1 5 2 0 1 2 3 3 2 1 4 1 3 4 0 0 4 2 1 2 0 1 1 1 1 4 2 5 1 2 2 2 2 1 3 1 2 4 5 5 3 2 1 2 5 1 1 1 0 3 2 4 1 2 2 2 2 1 3 1 2 3 4 4 3 2 0 2 4 0 1 1 0 3 1 4 1 2 2 2 1 0 3 1 2 3 3 3 3 2 0 2 3 0 1 Eta pC nuC cnuC nuDYG 0 0.1328125000 17 17 17 1 0.2734375000 35 52 35 2 0.2734375000 35 87 35 3 0.1796875000 23 110 23 4 0.0937500000 12 122 12 5 0.0390625000 5 127 5 6 0.0078125000 1 128 1 sum spC snuC snuDYG 1.0000000000 128 128

## 4. Discussion

using nsDeonYuliCPoissonTwist32D; //Poisson twister generator //by technology of cumulative frequencies namespace P060402 { class cP060402 { static void Main(string[] args) { cDeonYuliCPoissonTwist32D PT = new cDeonYuliCPoissonTwist32D(); PT.SetW(32); //bit width of random variable double Alpha = 2.0; //Alpha parameter PT.CStart(Alpha); //start generator Console.WriteLine(“w = {0} N = {1}”, PT.w, PT.N); Console.WriteLine(“Alpha = {0:F2}”, Alpha); double p1 = 1.0/(double)PT.N; //event probability double m = 0.0; //mathematical expectation double D = 0.0; //dispersion for (long i = 0; i< PT.N; i++) { int Eta = PT.CNext(); //random variable m += Eta * p1; //mathematical expectation D += Eta * Eta * p1; //dispersion } D = D − m * m; Console.WriteLine(“m = {0:F10}”, m); Console.WriteLine(“D = {0:F10}”, D); Console.ReadKey(); //result viewing } } }

w = 32 N = 4294967296 Alpha = 2.00 m = 2.0000000014 D = 2.0000000116

## 5. Conclusions

## Author Contributions

## Funding

## Acknowledgments

## Conflicts of Interest

## References

- Feller, W. An Introduction to Probability Theory and Its Applications, 3rd ed.; John Wiley & Sons: Hoboken, NJ, USA, 2008. [Google Scholar]
- Gnedenko, B. Theory of Probability, 6th ed.; CRC Press: Boca Raton, FL, USA, 1998; p. 520. [Google Scholar]
- Zhang, H.; Li, B. Characterizations of discrete compound poisson distribution. Commun. Stat.-Theory Method.
**2016**, 45, 6789–6802. [Google Scholar] [CrossRef] - Guerriero, V. Power low distribution: method of multi-scale inferential statistics. J. Mod. Math. Front.
**2012**, 1, 21–28. [Google Scholar] - Arkani, M.; Khalafi, H.; Vosoughi, N. A flexible multichannel digital random pulse generator based on FPGA. J. Nucl. Sci. Tech.
**2013**, 3, 109–116. [Google Scholar] [CrossRef] - Rasoanaivo, A.N.; Horowitz, W.A. Medium-induced radiation beyond the Poisson approximation. J. Phys. Conf.
**2017**, 878. [Google Scholar] [CrossRef] - Veiga, A.; Spinelli, E. A pulse generator with Poisson-exponential distribution for emulation of radioactive decay events. In Proceedings of the IEEE 7th Latin American Symposium on Circuits & Systems (LASCAS), Florianopolis, Brazil, 28 February–2 March 2016; pp. 31–34. [Google Scholar] [CrossRef]
- Kirkpatrick, J.M.; Young, B.M. Poisson statistical methods for the analysis of low-count gamma spectra. IEEE Trans. Nucl. Sci.
**2009**, 56, 1278–1282. [Google Scholar] [CrossRef] - Marsaglia, G.; Tsang, W.W.; Wang, J. Fast generation of discrete random variables. J. Stat. Software
**2004**, 11, 1–11. [Google Scholar] [CrossRef] - Kumari, S.; Valarmathi, M.; Prince, S. Generation of pseudorandom binary sequence using shot noise for optical encryption. In Proceedings of the International Conference on Communication and Signal Processing (ICCSP), Melmaruvathur, India, 6–8 April 2016; pp. 0119–0122. [Google Scholar] [CrossRef]
- Hosamo, M. A Study of the Source Traffic Generator Using Poisson Distribution for ABR Service. Model. Simul. Eng.
**2012**, 2012, 1–6. [Google Scholar] [CrossRef] [Green Version] - Zhang, H.; Liu, Y.; Li, B. Notes on discrete compound poisson model with applications to risk theory. Insur. Math. Econ.
**2014**, 59, 325–336. [Google Scholar] [CrossRef] - Shanmugam, R. Informatics about fear to report rapes using bumped-up poisson model. Am. J. Biostat.
**2013**, 3, 17–29. [Google Scholar] [CrossRef] - Menyaev, Y.A.; Nedosekin, D.A.; Sarimollaoglu, M.; Juratli, M.A.; Galanzha, E.I.; Tuchin, V.V.; Zharov, V.P. Optical clearing in photoacoustic flow cytometry. Biomed. Optic. Express
**2013**, 4, 3030–3041. [Google Scholar] [CrossRef] [PubMed] [Green Version] - Menyaev, Y.A.; Carey, K.A.; Nedosekin, D.A.; Sarimollaoglu, M.; Galanzha, E.I.; Stumhofer, J.S.; Zharov, V.P. Preclinical photoacoustic models: application for ultrasensitive single cell malaria diagnosis in large vein and artery. Biomed. Optic. Express
**2016**, 7, 3643–3658. [Google Scholar] [CrossRef] [PubMed] [Green Version] - Juratli, M.A.; Menyaev, Y.A.; Sarimollaoglu, M.; Melerzanov, A.V.; Nedosekin, D.A.; Culp, W.C.; Suen, J.Y.; Galanzha, E.I.; Zharov, V.P. Noninvasive label-free detection of circulating white and red blood clots in deep vessels with a focused photoacoustic prob. Biomed. Opt. Express
**2018**, 9, 5667–5677. [Google Scholar] [CrossRef] [PubMed] - Sitek, A.; Celler, A.M. Limitations of Poisson statistics in describing radioactive decay. Phys. Med.
**2015**, 31, 1105–1107. [Google Scholar] [CrossRef] [PubMed] - Menyaev, Y.A.; Zharov, V.P. Experience in development of therapeutic photomatrix equipment. Biomed. Eng.
**2006**, 40, 57–63. [Google Scholar] [CrossRef] - Menyaev, Y.A.; Zharov, V.P. Experience in the use of therapeutic photomatrix equipment. Biomed. Eng.
**2006**, 40, 144–147. [Google Scholar] [CrossRef] - Knuth, D.E. Art of Computer Programming, Volume 2: Seminumerical Algorithms, 3rd ed.; Addison-Wesle: Boston, MA, USA, 2014; p. 784. [Google Scholar]
- Knuth, D.E. Art of Computer Programming, Volume 4A: Combinatorial Algorithms, Part 1, 1st ed.; Addison-Wesley: Boston, MA, USA, 2011; p. 912. [Google Scholar]
- Wikipedia. Poisson Distribution. Available online: https://en.wikipedia.org/wiki/Poisson_distribution (accessed on 26 May 2019).
- Kolmogorov, A.N.; Fomin, S.V. Elements of the Theory of Functions and Functional Analysis; Dover Publication: Mineola, NY, USA, 1974; p. 128. [Google Scholar]
- Deon, A.F.; Menyaev, Y.A. The Complete Set Simulation of Stochastic Sequences without Repeated and Skipped Elements. J. Univers. Comput. Sci.
**2016**, 22, 1023–1047. [Google Scholar] [CrossRef] - Deon, A.F.; Menyaev, Y.A. Parametrical tuning of twisting generators. J. Comput. Sci.
**2016**, 12, 363–378. [Google Scholar] [CrossRef] - Deon, A.F.; Menyaev, Y.A. Twister generator of arbitrary uniform sequences. J. Univers. Comput. Sci.
**2017**, 23, 353–384. [Google Scholar] [CrossRef] - Deon, A.F.; Menyaev, Y.A. Uniform twister plane generator. J. Comput. Sci.
**2018**, 14, 260–272. [Google Scholar] [CrossRef] - Wikipedia. Diehard Tests. Available online: https://en.wikipedia.org/wiki/Diehard_tests (accessed on 26 May 2019).
- The Marsaglia Random Number CDROM Including the Diehard Battery of Tests of Randomness. Available online: https://stat.fsu.edu/pub/diehard/ (accessed on 26 May 2019).
- Runs Test for Detecting Non-randomness. Available online: https://www.itl.nist.gov/div898/handbook/eda/section3/eda35d.htm (accessed on 26 May 2019).
- Sample 33092: Wald-Wolfowitz (or Runs) Test for Randomness. Available online: https://support.sas.com/kb/33/092.html (accessed on 26 May 2019).
- Alhakim, A.; Hooper, W. A non-parametric test for several independent samples. J. Nonparametric Stat.
**2008**, 20, 253–261. [Google Scholar] [CrossRef]

© 2019 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

Deon, A.F.; Menyaev, Y.A.
Poisson Twister Generator by Cumulative Frequency Technology. *Algorithms* **2019**, *12*, 114.
https://doi.org/10.3390/a12060114

**AMA Style**

Deon AF, Menyaev YA.
Poisson Twister Generator by Cumulative Frequency Technology. *Algorithms*. 2019; 12(6):114.
https://doi.org/10.3390/a12060114

**Chicago/Turabian Style**

Deon, Aleksei F., and Yulian A. Menyaev.
2019. "Poisson Twister Generator by Cumulative Frequency Technology" *Algorithms* 12, no. 6: 114.
https://doi.org/10.3390/a12060114