Repository navigation
Expand file tree
/
Copy pathnp.random.gen.cs
More file actions
2029 lines (1969 loc) · 97.6 KB
/
Copy pathnp.random.gen.cs
File metadata and controls
2029 lines (1969 loc) · 97.6 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// Copyright (c) 2019 by the SciSharp Team
// Code generated by CodeMinion: https://github.com/SciSharp/CodeMinion
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using Python.Runtime;
using Python.Included;
using Numpy.Models;
namespace Numpy
{
public static partial class np
{
public static partial class random {
/// <summary>
/// Random values in a given shape.
///
/// Create an array of the given shape and populate it with
/// random samples from a uniform distribution
/// over [0, 1).
///
/// Notes
///
/// This is a convenience function. If you want an interface that
/// takes a shape-tuple as the first argument, refer to
/// np.random.random_sample .
/// </summary>
/// <param name="d1">
/// The dimensions of the returned array, should all be positive.
/// If no argument is given a single Python float is returned.
/// </param>
/// <param name="d0">
/// The dimensions of the returned array, should all be positive.
/// If no argument is given a single Python float is returned.
/// </param>
/// <returns>
/// Random values.
/// </returns>
public static NDarray rand(int? d1 = null, int? d0 = null)
=> NumPy.Instance.random_rand(d1:d1, d0:d0);
}
public static partial class random {
/// <summary>
/// Return a sample (or samples) from the “standard normal” distribution.
///
/// If positive, int_like or int-convertible arguments are provided,
/// randn generates an array of shape (d0, d1, ..., dn), filled
/// with random floats sampled from a univariate “normal” (Gaussian)
/// distribution of mean 0 and variance 1 (if any of the are
/// floats, they are first converted to integers by truncation). A single
/// float randomly sampled from the distribution is returned if no
/// argument is provided.
///
/// This is a convenience function. If you want an interface that takes a
/// tuple as the first argument, use numpy.random.standard_normal instead.
///
/// Notes
///
/// For random samples from , use:
///
/// sigma * np.random.randn(...) + mu
/// </summary>
/// <param name="d1">
/// The dimensions of the returned array, should be all positive.
/// If no argument is given a single Python float is returned.
/// </param>
/// <param name="d0">
/// The dimensions of the returned array, should be all positive.
/// If no argument is given a single Python float is returned.
/// </param>
/// <returns>
/// A (d0, d1, ..., dn)-shaped array of floating-point samples from
/// the standard normal distribution, or a single such float if
/// no parameters were supplied.
/// </returns>
public static NDarray randn(int? d1 = null, int? d0 = null)
=> NumPy.Instance.random_randn(d1:d1, d0:d0);
}
public static partial class random {
/// <summary>
/// Return random integers from low (inclusive) to high (exclusive).
///
/// Return random integers from the “discrete uniform” distribution of
/// the specified dtype in the “half-open” interval [low, high). If
/// high is None (the default), then results are from [0, low).
/// </summary>
/// <param name="low">
/// Lowest (signed) integer to be drawn from the distribution (unless
/// high=None, in which case this parameter is one above the
/// highest such integer).
/// </param>
/// <param name="high">
/// If provided, one above the largest (signed) integer to be drawn
/// from the distribution (see above for behavior if high=None).
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. Default is None, in which case a
/// single value is returned.
/// </param>
/// <param name="dtype">
/// Desired dtype of the result. All dtypes are determined by their
/// name, i.e., ‘int64’, ‘int’, etc, so byteorder is not available
/// and a specific precision may have different C types depending
/// on the platform. The default value is ‘np.int’.
/// </param>
/// <returns>
/// size-shaped array of random integers from the appropriate
/// distribution, or a single such random int if size not provided.
/// </returns>
public static NDarray<int> randint(int low, int? high = null, int[] size = null, Dtype dtype = null)
=> NumPy.Instance.random_randint(low, high:high, size:size, dtype:dtype);
}
public static partial class random {
/// <summary>
/// Random integers of type np.int between low and high, inclusive.
///
/// Return random integers of type np.int from the “discrete uniform”
/// distribution in the closed interval [low, high]. If high is
/// None (the default), then results are from [1, low]. The np.int
/// type translates to the C long type used by Python 2 for “short”
/// integers and its precision is platform dependent.
///
/// This function has been deprecated. Use randint instead.
///
/// Notes
///
/// To sample from N evenly spaced floating-point numbers between a and b,
/// use:
/// </summary>
/// <param name="low">
/// Lowest (signed) integer to be drawn from the distribution (unless
/// high=None, in which case this parameter is the highest such
/// integer).
/// </param>
/// <param name="high">
/// If provided, the largest (signed) integer to be drawn from the
/// distribution (see above for behavior if high=None).
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. Default is None, in which case a
/// single value is returned.
/// </param>
/// <returns>
/// size-shaped array of random integers from the appropriate
/// distribution, or a single such random int if size not provided.
/// </returns>
public static NDarray<int> random_integers(int low, int? high = null, int[] size = null)
=> NumPy.Instance.random_random_integers(low, high:high, size:size);
}
public static partial class random {
/// <summary>
/// Return random floats in the half-open interval [0.0, 1.0).
///
/// Results are from the “continuous uniform” distribution over the
/// stated interval. To sample multiply
/// the output of random_sample by (b-a) and add a:
/// </summary>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. Default is None, in which case a
/// single value is returned.
/// </param>
/// <returns>
/// Array of random floats of shape size (unless size=None, in which
/// case a single float is returned).
/// </returns>
public static NDarray<float> random_sample(int[] size = null)
=> NumPy.Instance.random_random_sample(size:size);
}
public static partial class random {
/// <summary>
/// Return random floats in the half-open interval [0.0, 1.0).
///
/// Results are from the “continuous uniform” distribution over the
/// stated interval. To sample multiply
/// the output of random_sample by (b-a) and add a:
/// </summary>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. Default is None, in which case a
/// single value is returned.
/// </param>
/// <returns>
/// Array of random floats of shape size (unless size=None, in which
/// case a single float is returned).
/// </returns>
public static NDarray<float> random_(int[] size = null)
=> NumPy.Instance.random_random(size:size);
}
public static partial class random {
/// <summary>
/// Return random floats in the half-open interval [0.0, 1.0).
///
/// Results are from the “continuous uniform” distribution over the
/// stated interval. To sample multiply
/// the output of random_sample by (b-a) and add a:
/// </summary>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. Default is None, in which case a
/// single value is returned.
/// </param>
/// <returns>
/// Array of random floats of shape size (unless size=None, in which
/// case a single float is returned).
/// </returns>
public static NDarray<float> ranf(int[] size = null)
=> NumPy.Instance.random_ranf(size:size);
}
public static partial class random {
/// <summary>
/// Return random floats in the half-open interval [0.0, 1.0).
///
/// Results are from the “continuous uniform” distribution over the
/// stated interval. To sample multiply
/// the output of random_sample by (b-a) and add a:
/// </summary>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. Default is None, in which case a
/// single value is returned.
/// </param>
/// <returns>
/// Array of random floats of shape size (unless size=None, in which
/// case a single float is returned).
/// </returns>
public static NDarray<float> sample(int[] size = null)
=> NumPy.Instance.random_sample(size:size);
}
public static partial class random {
/// <summary>
/// Generates a random sample from a given 1-D array
/// </summary>
/// <param name="a">
/// If an ndarray, a random sample is generated from its elements.
/// If an int, the random sample is generated as if a were np.arange(a)
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. Default is None, in which case a
/// single value is returned.
/// </param>
/// <param name="replace">
/// Whether the sample is with or without replacement
/// </param>
/// <param name="p">
/// The probabilities associated with each entry in a.
/// If not given the sample assumes a uniform distribution over all
/// entries in a.
/// </param>
/// <returns>
/// The generated random samples
/// </returns>
public static NDarray choice(NDarray a, int[] size = null, bool? replace = true, NDarray p = null)
=> NumPy.Instance.random_choice(a, size:size, replace:replace, p:p);
}
public static partial class random {
/// <summary>
/// Generates a random sample from a given 1-D array
/// </summary>
/// <param name="a">
/// If an ndarray, a random sample is generated from its elements.
/// If an int, the random sample is generated as if a were np.arange(a)
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. Default is None, in which case a
/// single value is returned.
/// </param>
/// <param name="replace">
/// Whether the sample is with or without replacement
/// </param>
/// <param name="p">
/// The probabilities associated with each entry in a.
/// If not given the sample assumes a uniform distribution over all
/// entries in a.
/// </param>
/// <returns>
/// The generated random samples
/// </returns>
public static NDarray choice(int a, int[] size = null, bool? replace = true, NDarray p = null)
=> NumPy.Instance.random_choice(a, size:size, replace:replace, p:p);
}
public static partial class random {
/// <summary>
/// Return random bytes.
/// </summary>
/// <param name="length">
/// Number of random bytes.
/// </param>
/// <returns>
/// String of length length.
/// </returns>
public static string bytes(int length)
=> NumPy.Instance.random_bytes(length);
}
public static partial class random {
/// <summary>
/// Modify a sequence in-place by shuffling its contents.
///
/// This function only shuffles the array along the first axis of a
/// multi-dimensional array. The order of sub-arrays is changed but
/// their contents remains the same.
/// </summary>
/// <param name="x">
/// The array or list to be shuffled.
/// </param>
public static void shuffle(NDarray x)
=> NumPy.Instance.random_shuffle(x);
}
public static partial class random {
/// <summary>
/// Randomly permute a sequence, or return a permuted range.
///
/// If x is a multi-dimensional array, it is only shuffled along its
/// first index.
/// </summary>
/// <param name="x">
/// If x is an integer, randomly permute np.arange(x).
/// If x is an array, make a copy and shuffle the elements
/// randomly.
/// </param>
/// <returns>
/// Permuted sequence or array range.
/// </returns>
public static NDarray permutation(NDarray x)
=> NumPy.Instance.random_permutation(x);
}
public static partial class random {
/// <summary>
/// Randomly permute a sequence, or return a permuted range.
///
/// If x is a multi-dimensional array, it is only shuffled along its
/// first index.
/// </summary>
/// <param name="x">
/// If x is an integer, randomly permute np.arange(x).
/// If x is an array, make a copy and shuffle the elements
/// randomly.
/// </param>
/// <returns>
/// Permuted sequence or array range.
/// </returns>
public static NDarray permutation(int x)
=> NumPy.Instance.random_permutation(x);
}
public static partial class random {
/// <summary>
/// Draw samples from a Beta distribution.
///
/// The Beta distribution is a special case of the Dirichlet distribution,
/// and is related to the Gamma distribution. It has the probability
/// distribution function
///
/// where the normalisation, B, is the beta function,
///
/// It is often seen in Bayesian inference and order statistics.
/// </summary>
/// <param name="a">
/// Alpha, positive (>0).
/// </param>
/// <param name="b">
/// Beta, positive (>0).
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. If size is None (default),
/// a single value is returned if a and b are both scalars.
/// Otherwise, np.broadcast(a, b).size samples are drawn.
/// </param>
/// <returns>
/// Drawn samples from the parameterized beta distribution.
/// </returns>
public static NDarray beta(NDarray<float> a, NDarray<float> b, int[] size = null)
=> NumPy.Instance.random_beta(a, b, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from a binomial distribution.
///
/// Samples are drawn from a binomial distribution with specified
/// parameters, n trials and p probability of success where
/// n an integer >= 0 and p is in the interval [0,1]. (n may be
/// input as a float, but it is truncated to an integer in use)
///
/// Notes
///
/// The probability density for the binomial distribution is
///
/// where is the number of trials, is the probability
/// of success, and is the number of successes.
///
/// When estimating the standard error of a proportion in a population by
/// using a random sample, the normal distribution works well unless the
/// product p*n <=5, where p = population proportion estimate, and n =
/// number of samples, in which case the binomial distribution is used
/// instead. For example, a sample of 15 people shows 4 who are left
/// handed, and 11 who are right handed. Then p = 4/15 = 27%. 0.27*15 = 4,
/// so the binomial distribution should be used in this case.
///
/// References
/// </summary>
/// <param name="n">
/// Parameter of the distribution, >= 0. Floats are also accepted,
/// but they will be truncated to integers.
/// </param>
/// <param name="p">
/// Parameter of the distribution, >= 0 and <=1.
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. If size is None (default),
/// a single value is returned if n and p are both scalars.
/// Otherwise, np.broadcast(n, p).size samples are drawn.
/// </param>
/// <returns>
/// Drawn samples from the parameterized binomial distribution, where
/// each sample is equal to the number of successes over the n trials.
/// </returns>
public static NDarray binomial(NDarray<int> n, NDarray<float> p, int[] size = null)
=> NumPy.Instance.random_binomial(n, p, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from a binomial distribution.
///
/// Samples are drawn from a binomial distribution with specified
/// parameters, n trials and p probability of success where
/// n an integer >= 0 and p is in the interval [0,1]. (n may be
/// input as a float, but it is truncated to an integer in use)
///
/// Notes
///
/// The probability density for the binomial distribution is
///
/// where is the number of trials, is the probability
/// of success, and is the number of successes.
///
/// When estimating the standard error of a proportion in a population by
/// using a random sample, the normal distribution works well unless the
/// product p*n <=5, where p = population proportion estimate, and n =
/// number of samples, in which case the binomial distribution is used
/// instead. For example, a sample of 15 people shows 4 who are left
/// handed, and 11 who are right handed. Then p = 4/15 = 27%. 0.27*15 = 4,
/// so the binomial distribution should be used in this case.
///
/// References
/// </summary>
/// <param name="n">
/// Parameter of the distribution, >= 0. Floats are also accepted,
/// but they will be truncated to integers.
/// </param>
/// <param name="p">
/// Parameter of the distribution, >= 0 and <=1.
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. If size is None (default),
/// a single value is returned if n and p are both scalars.
/// Otherwise, np.broadcast(n, p).size samples are drawn.
/// </param>
/// <returns>
/// Drawn samples from the parameterized binomial distribution, where
/// each sample is equal to the number of successes over the n trials.
/// </returns>
public static NDarray binomial(int n, NDarray<float> p, int[] size = null)
=> NumPy.Instance.random_binomial(n, p, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from a chi-square distribution.
///
/// When df independent random variables, each with standard normal
/// distributions (mean 0, variance 1), are squared and summed, the
/// resulting distribution is chi-square (see Notes). This distribution
/// is often used in hypothesis testing.
///
/// Notes
///
/// The variable obtained by summing the squares of df independent,
/// standard normally distributed random variables:
///
/// is chi-square distributed, denoted
///
/// The probability density function of the chi-squared distribution is
///
/// where is the gamma function,
///
/// References
/// </summary>
/// <param name="df">
/// Number of degrees of freedom, should be > 0.
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. If size is None (default),
/// a single value is returned if df is a scalar. Otherwise,
/// np.array(df).size samples are drawn.
/// </param>
/// <returns>
/// Drawn samples from the parameterized chi-square distribution.
/// </returns>
public static NDarray chisquare(NDarray<float> df, int[] size = null)
=> NumPy.Instance.random_chisquare(df, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from the Dirichlet distribution.
///
/// Draw size samples of dimension k from a Dirichlet distribution. A
/// Dirichlet-distributed random variable can be seen as a multivariate
/// generalization of a Beta distribution. Dirichlet pdf is the conjugate
/// prior of a multinomial in Bayesian inference.
///
/// Notes
///
/// Uses the following property for computation: for each dimension,
/// draw a random sample y_i from a standard gamma generator of shape
/// alpha_i, then
/// is
/// Dirichlet distributed.
///
/// References
/// </summary>
/// <param name="alpha">
/// Parameter of the distribution (k dimension for sample of
/// dimension k).
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. Default is None, in which case a
/// single value is returned.
/// </param>
/// <returns>
/// The drawn samples, of shape (size, alpha.ndim).
/// </returns>
public static NDarray dirichlet(NDarray alpha, int[] size = null)
=> NumPy.Instance.random_dirichlet(alpha, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from an exponential distribution.
///
/// Its probability density function is
///
/// for x > 0 and 0 elsewhere. is the scale parameter,
/// which is the inverse of the rate parameter .
/// The rate parameter is an alternative, widely used parameterization
/// of the exponential distribution [3].
///
/// The exponential distribution is a continuous analogue of the
/// geometric distribution. It describes many common situations, such as
/// the size of raindrops measured over many rainstorms [1], or the time
/// between page requests to Wikipedia [2].
///
/// References
/// </summary>
/// <param name="scale">
/// The scale parameter, .
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. If size is None (default),
/// a single value is returned if scale is a scalar. Otherwise,
/// np.array(scale).size samples are drawn.
/// </param>
/// <returns>
/// Drawn samples from the parameterized exponential distribution.
/// </returns>
public static NDarray exponential(NDarray<float> scale = null, int[] size = null)
=> NumPy.Instance.random_exponential(scale, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from an F distribution.
///
/// Samples are drawn from an F distribution with specified parameters,
/// dfnum (degrees of freedom in numerator) and dfden (degrees of
/// freedom in denominator), where both parameters should be greater than
/// zero.
///
/// The random variate of the F distribution (also known as the
/// Fisher distribution) is a continuous probability distribution
/// that arises in ANOVA tests, and is the ratio of two chi-square
/// variates.
///
/// Notes
///
/// The F statistic is used to compare in-group variances to between-group
/// variances. Calculating the distribution depends on the sampling, and
/// so it is a function of the respective degrees of freedom in the
/// problem. The variable dfnum is the number of samples minus one, the
/// between-groups degrees of freedom, while dfden is the within-groups
/// degrees of freedom, the sum of the number of samples in each group
/// minus the number of groups.
///
/// References
/// </summary>
/// <param name="dfnum">
/// Degrees of freedom in numerator, should be > 0.
/// </param>
/// <param name="dfden">
/// Degrees of freedom in denominator, should be > 0.
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. If size is None (default),
/// a single value is returned if dfnum and dfden are both scalars.
/// Otherwise, np.broadcast(dfnum, dfden).size samples are drawn.
/// </param>
/// <returns>
/// Drawn samples from the parameterized Fisher distribution.
/// </returns>
public static NDarray f(NDarray<float> dfnum, NDarray<float> dfden, int[] size = null)
=> NumPy.Instance.random_f(dfnum, dfden, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from a Gamma distribution.
///
/// Samples are drawn from a Gamma distribution with specified parameters,
/// shape (sometimes designated “k”) and scale (sometimes designated
/// “theta”), where both parameters are > 0.
///
/// Notes
///
/// The probability density for the Gamma distribution is
///
/// where is the shape and the scale,
/// and is the Gamma function.
///
/// The Gamma distribution is often used to model the times to failure of
/// electronic components, and arises naturally in processes for which the
/// waiting times between Poisson distributed events are relevant.
///
/// References
/// </summary>
/// <param name="shape">
/// The shape of the gamma distribution. Should be greater than zero.
/// </param>
/// <param name="scale">
/// The scale of the gamma distribution. Should be greater than zero.
/// Default is equal to 1.
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. If size is None (default),
/// a single value is returned if shape and scale are both scalars.
/// Otherwise, np.broadcast(shape, scale).size samples are drawn.
/// </param>
/// <returns>
/// Drawn samples from the parameterized gamma distribution.
/// </returns>
public static NDarray gamma(Shape shape, NDarray<float> scale = null, int[] size = null)
=> NumPy.Instance.random_gamma(shape, scale:scale, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from the geometric distribution.
///
/// Bernoulli trials are experiments with one of two outcomes:
/// success or failure (an example of such an experiment is flipping
/// a coin). The geometric distribution models the number of trials
/// that must be run in order to achieve success. It is therefore
/// supported on the positive integers, k = 1, 2, ....
///
/// The probability mass function of the geometric distribution is
///
/// where p is the probability of success of an individual trial.
/// </summary>
/// <param name="p">
/// The probability of success of an individual trial.
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. If size is None (default),
/// a single value is returned if p is a scalar. Otherwise,
/// np.array(p).size samples are drawn.
/// </param>
/// <returns>
/// Drawn samples from the parameterized geometric distribution.
/// </returns>
public static NDarray geometric(NDarray<float> p, int[] size = null)
=> NumPy.Instance.random_geometric(p, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from a Gumbel distribution.
///
/// Draw samples from a Gumbel distribution with specified location and
/// scale. For more information on the Gumbel distribution, see
/// Notes and References below.
///
/// Notes
///
/// The Gumbel (or Smallest Extreme Value (SEV) or the Smallest Extreme
/// Value Type I) distribution is one of a class of Generalized Extreme
/// Value (GEV) distributions used in modeling extreme value problems.
/// The Gumbel is a special case of the Extreme Value Type I distribution
/// for maximums from distributions with “exponential-like” tails.
///
/// The probability density for the Gumbel distribution is
///
/// where is the mode, a location parameter, and
/// is the scale parameter.
///
/// The Gumbel (named for German mathematician Emil Julius Gumbel) was used
/// very early in the hydrology literature, for modeling the occurrence of
/// flood events. It is also used for modeling maximum wind speed and
/// rainfall rates. It is a “fat-tailed” distribution - the probability of
/// an event in the tail of the distribution is larger than if one used a
/// Gaussian, hence the surprisingly frequent occurrence of 100-year
/// floods. Floods were initially modeled as a Gaussian process, which
/// underestimated the frequency of extreme events.
///
/// It is one of a class of extreme value distributions, the Generalized
/// Extreme Value (GEV) distributions, which also includes the Weibull and
/// Frechet.
///
/// The function has a mean of and a variance
/// of .
///
/// References
/// </summary>
/// <param name="loc">
/// The location of the mode of the distribution. Default is 0.
/// </param>
/// <param name="scale">
/// The scale parameter of the distribution. Default is 1.
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. If size is None (default),
/// a single value is returned if loc and scale are both scalars.
/// Otherwise, np.broadcast(loc, scale).size samples are drawn.
/// </param>
/// <returns>
/// Drawn samples from the parameterized Gumbel distribution.
/// </returns>
public static NDarray gumbel(NDarray<float> loc = null, NDarray<float> scale = null, int[] size = null)
=> NumPy.Instance.random_gumbel(loc:loc, scale:scale, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from a Hypergeometric distribution.
///
/// Samples are drawn from a hypergeometric distribution with specified
/// parameters, ngood (ways to make a good selection), nbad (ways to make
/// a bad selection), and nsample = number of items sampled, which is less
/// than or equal to the sum ngood + nbad.
///
/// Notes
///
/// The probability density for the Hypergeometric distribution is
///
/// where and
///
/// for P(x) the probability of x successes, g = ngood, b = nbad, and
/// n = number of samples.
///
/// Consider an urn with black and white marbles in it, ngood of them
/// black and nbad are white. If you draw nsample balls without
/// replacement, then the hypergeometric distribution describes the
/// distribution of black balls in the drawn sample.
///
/// Note that this distribution is very similar to the binomial
/// distribution, except that in this case, samples are drawn without
/// replacement, whereas in the Binomial case samples are drawn with
/// replacement (or the sample space is infinite). As the sample space
/// becomes large, this distribution approaches the binomial.
///
/// References
/// </summary>
/// <param name="ngood">
/// Number of ways to make a good selection. Must be nonnegative.
/// </param>
/// <param name="nbad">
/// Number of ways to make a bad selection. Must be nonnegative.
/// </param>
/// <param name="nsample">
/// Number of items sampled. Must be at least 1 and at most
/// ngood + nbad.
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. If size is None (default),
/// a single value is returned if ngood, nbad, and nsample
/// are all scalars. Otherwise, np.broadcast(ngood, nbad, nsample).size
/// samples are drawn.
/// </param>
/// <returns>
/// Drawn samples from the parameterized hypergeometric distribution.
/// </returns>
public static NDarray hypergeometric(NDarray<int> ngood, NDarray<int> nbad, NDarray<int> nsample, int[] size = null)
=> NumPy.Instance.random_hypergeometric(ngood, nbad, nsample, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from the Laplace or double exponential distribution with
/// specified location (or mean) and scale (decay).
///
/// The Laplace distribution is similar to the Gaussian/normal distribution,
/// but is sharper at the peak and has fatter tails. It represents the
/// difference between two independent, identically distributed exponential
/// random variables.
///
/// Notes
///
/// It has the probability density function
///
/// The first law of Laplace, from 1774, states that the frequency
/// of an error can be expressed as an exponential function of the
/// absolute magnitude of the error, which leads to the Laplace
/// distribution. For many problems in economics and health
/// sciences, this distribution seems to model the data better
/// than the standard Gaussian distribution.
///
/// References
/// </summary>
/// <param name="loc">
/// The position, , of the distribution peak. Default is 0.
/// </param>
/// <param name="scale">
/// , the exponential decay. Default is 1.
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. If size is None (default),
/// a single value is returned if loc and scale are both scalars.
/// Otherwise, np.broadcast(loc, scale).size samples are drawn.
/// </param>
/// <returns>
/// Drawn samples from the parameterized Laplace distribution.
/// </returns>
public static NDarray laplace(NDarray<float> loc = null, NDarray<float> scale = null, int[] size = null)
=> NumPy.Instance.random_laplace(loc:loc, scale:scale, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from a logistic distribution.
///
/// Samples are drawn from a logistic distribution with specified
/// parameters, loc (location or mean, also median), and scale (>0).
///
/// Notes
///
/// The probability density for the Logistic distribution is
///
/// where = location and = scale.
///
/// The Logistic distribution is used in Extreme Value problems where it
/// can act as a mixture of Gumbel distributions, in Epidemiology, and by
/// the World Chess Federation (FIDE) where it is used in the Elo ranking
/// system, assuming the performance of each player is a logistically
/// distributed random variable.
///
/// References
/// </summary>
/// <param name="loc">
/// Parameter of the distribution. Default is 0.
/// </param>
/// <param name="scale">
/// Parameter of the distribution. Should be greater than zero.
/// Default is 1.
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. If size is None (default),
/// a single value is returned if loc and scale are both scalars.
/// Otherwise, np.broadcast(loc, scale).size samples are drawn.
/// </param>
/// <returns>
/// Drawn samples from the parameterized logistic distribution.
/// </returns>
public static NDarray logistic(NDarray<float> loc = null, NDarray<float> scale = null, int[] size = null)
=> NumPy.Instance.random_logistic(loc:loc, scale:scale, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from a log-normal distribution.
///
/// Draw samples from a log-normal distribution with specified mean,
/// standard deviation, and array shape. Note that the mean and standard
/// deviation are not the values for the distribution itself, but of the
/// underlying normal distribution it is derived from.
///
/// Notes
///
/// A variable x has a log-normal distribution if log(x) is normally
/// distributed. The probability density function for the log-normal
/// distribution is:
///
/// where is the mean and is the standard
/// deviation of the normally distributed logarithm of the variable.
/// A log-normal distribution results if a random variable is the product
/// of a large number of independent, identically-distributed variables in
/// the same way that a normal distribution results if the variable is the
/// sum of a large number of independent, identically-distributed
/// variables.
///
/// References
/// </summary>
/// <param name="mean">
/// Mean value of the underlying normal distribution. Default is 0.
/// </param>
/// <param name="sigma">
/// Standard deviation of the underlying normal distribution. Should
/// be greater than zero. Default is 1.
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. If size is None (default),
/// a single value is returned if mean and sigma are both scalars.
/// Otherwise, np.broadcast(mean, sigma).size samples are drawn.
/// </param>
/// <returns>
/// Drawn samples from the parameterized log-normal distribution.
/// </returns>
public static NDarray lognormal(NDarray<float> mean = null, NDarray<float> sigma = null, int[] size = null)
=> NumPy.Instance.random_lognormal(mean:mean, sigma:sigma, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from a logarithmic series distribution.
///
/// Samples are drawn from a log series distribution with specified
/// shape parameter, 0 < p < 1.
///
/// Notes
///
/// The probability density for the Log Series distribution is
///
/// where p = probability.
///
/// The log series distribution is frequently used to represent species
/// richness and occurrence, first proposed by Fisher, Corbet, and
/// Williams in 1943 [2]. It may also be used to model the numbers of
/// occupants seen in cars [3].
///
/// References
/// </summary>
/// <param name="p">
/// Shape parameter for the distribution. Must be in the range (0, 1).
/// </param>
/// <param name="size">
/// Output shape. If the given shape is, e.g., (m, n, k), then
/// m * n * k samples are drawn. If size is None (default),
/// a single value is returned if p is a scalar. Otherwise,
/// np.array(p).size samples are drawn.
/// </param>
/// <returns>
/// Drawn samples from the parameterized logarithmic series distribution.
/// </returns>
public static NDarray logseries(NDarray<float> p, int[] size = null)
=> NumPy.Instance.random_logseries(p, size:size);
}
public static partial class random {
/// <summary>
/// Draw samples from a multinomial distribution.
///
/// The multinomial distribution is a multivariate generalisation of the
/// binomial distribution. Take an experiment with one of p
/// possible outcomes. An example of such an experiment is throwing a dice,