1 #Region "Microsoft.VisualBasic::6aeedfb0ebb0e29fa88a78537d2104b0, Microsoft.VisualBasic.Core\Extensions\Math\Math.vb"
2
3     ' Author:
4     
5     '       asuka (amethyst.asuka@gcmodeller.org)
6     '       xie (genetics@smrucc.org)
7     '       xieguigang (xie.guigang@live.com)
8     
9     ' Copyright (c) 2018 GPL3 Licensed
10     
11     
12     ' GNU GENERAL PUBLIC LICENSE (GPL3)
13     
14     
15     ' This program is free software: you can redistribute it and/or modify
16     ' it under the terms of the GNU General Public License as published by
17     ' the Free Software Foundation, either version 3 of the License, or
18     ' (at your option) any later version.
19     
20     ' This program is distributed in the hope that it will be useful,
21     ' but WITHOUT ANY WARRANTY; without even the implied warranty of
22     ' MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23     ' GNU General Public License for more details.
24     
25     ' You should have received a copy of the GNU General Public License
26     ' along with this program. If not, see <http://www.gnu.org/licenses/>.
27
28
29
30     ' /********************************************************************************/
31
32     ' Summaries:
33
34     '     Module VBMath
35     
36     '         Function: (+7 Overloads) Abs, Acos, Asin, Atan, Atan2
37     '                   BigMul, (+2 Overloads) Ceiling, Cos, Cosh, Covariance
38     '                   Distance, (+2 Overloads) DivRem, (+6 Overloads) EuclideanDistance, Exp, Factorial
39     '                   FactorialSequence, (+2 Overloads) Floor, FormatNumeric, Hypot, IEEERemainder
40     '                   IsPowerOf2, (+2 Overloads) Log, Log10, Log2, LogN
41     '                   (+12 Overloads) Max, (+11 Overloads) Min, PoissonPDF, Pow, Pow2
42     '                   (+2 Overloads) ProductALL, (+3 Overloads) RangesAt, RMS, (+8 Overloads) Round, RSD
43     '                   (+4 Overloads) SD, (+2 Overloads) seq, (+7 Overloads) Sign, Sin, Sinh
44     '                   Sqrt, Sum, Tan, Tanh, (+2 Overloads) Truncate
45     '                   WeighedAverage
46     
47     
48     ' /********************************************************************************/
49
50 #End Region
51
52 Imports System.Runtime.CompilerServices
53 Imports System.Runtime.ConstrainedExecution
54 Imports System.Security
55 Imports Microsoft.VisualBasic.CommandLine.Reflection
56 Imports Microsoft.VisualBasic.ComponentModel.Ranges.Model
57 Imports Microsoft.VisualBasic.Language
58 Imports Microsoft.VisualBasic.Linq
59 Imports Microsoft.VisualBasic.Scripting.MetaData
60 Imports sys = System.Math
61
62 Namespace Math
63
64     ''' <summary>
65     ''' Provides constants and static methods for trigonometric, logarithmic, and other
66     ''' common mathematical functions.To browse the .NET Framework source code for this
67     ''' type, see the Reference Source.
68     ''' </summary>
69     <Package("VBMath", Publisher:="xie.guigang@gmail.com")>
70     Public Module VBMath
71
72         ''' <summary>
73         ''' Represents the ratio of the circumference of a circle to its diameter, specified
74         ''' by the constant, π.
75         ''' </summary>
76         Public Const PI# = sys.PI
77         ''' <summary>
78         ''' Represents the natural logarithmic base, specified by the constant, e.
79         ''' </summary>
80         Public Const E# = sys.E
81
82 #Region "Imports System.Math"
83
84         ''' <summary>
85         ''' Returns the smaller of two 8-bit unsigned integers.
86         ''' </summary>
87         ''' <param name="val1">The first of two 8-bit unsigned integers to compare.</param>
88         ''' <param name="val2">The second of two 8-bit unsigned integers to compare.</param>
89         ''' <returns>Parameter val1 or val2, whichever is smaller.</returns>
90         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
91         <MethodImpl(MethodImplOptions.AggressiveInlining)>
92         Public Function Min(val1 As Byte, val2 As ByteAs Byte
93             If val1 < val2 Then
94                 Return val1
95             Else
96                 Return val2
97             End If
98         End Function
99
100         ''' <summary>
101         ''' Returns the smaller of two 8-bit signed integers.
102         ''' </summary>
103         ''' <param name="val1">The first of two 8-bit signed integers to compare.</param>
104         ''' <param name="val2">The second of two 8-bit signed integers to compare.</param>
105         ''' <returns>Parameter val1 or val2, whichever is smaller.</returns>
106         <CLSCompliant(False)> <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
107         <MethodImpl(MethodImplOptions.AggressiveInlining)>
108         Public Function Min(val1 As SByte, val2 As SByteAs SByte
109             If val1 < val2 Then
110                 Return val1
111             Else
112                 Return val2
113             End If
114         End Function
115
116         ''' <summary>
117         ''' Returns the larger of two decimal numbers.
118         ''' </summary>
119         ''' <param name="val1">The first of two decimal numbers to compare.</param>
120         ''' <param name="val2">The second of two decimal numbers to compare.</param>
121         ''' <returns>Parameter val1 or val2, whichever is larger.</returns>
122         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
123         <MethodImpl(MethodImplOptions.AggressiveInlining)>
124         Public Function Max(val1 As Decimal, val2 As DecimalAs Decimal
125             If val1 > val2 Then
126                 Return val1
127             Else
128                 Return val2
129             End If
130         End Function
131
132         ''' <summary>
133         ''' Returns the larger of two double-precision floating-point numbers.
134         ''' </summary>
135         ''' <param name="val1">The first of two double-precision floating-point numbers to compare.</param>
136         ''' <param name="val2">The second of two double-precision floating-point numbers to compare.</param>
137         ''' <returns>Parameter val1 or val2, whichever is larger. If val1, val2, or both val1 and
138         ''' val2 are equal to System.Double.NaN, System.Double.NaN is returned.</returns>
139         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
140         <MethodImpl(MethodImplOptions.AggressiveInlining)>
141         Public Function Max(val1 As Double, val2 As DoubleAs Double
142             If val1 > val2 Then
143                 Return val1
144             Else
145                 Return val2
146             End If
147         End Function
148
149         ''' <summary>
150         ''' Returns the larger of two single-precision floating-point numbers.
151         ''' </summary>
152         ''' <param name="val1">The first of two single-precision floating-point numbers to compare.</param>
153         ''' <param name="val2">The second of two single-precision floating-point numbers to compare.</param>
154         ''' <returns>Parameter val1 or val2, whichever is larger. If val1, or val2, or both val1 and
155         ''' val2 are equal to System.Single.NaN, System.Single.NaN is returned.</returns>
156         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
157         <MethodImpl(MethodImplOptions.AggressiveInlining)>
158         Public Function Max(val1 As Single, val2 As SingleAs Single
159             If val1 > val2 Then
160                 Return val1
161             Else
162                 Return val2
163             End If
164         End Function
165
166         ''' <summary>
167         ''' Returns the larger of two 64-bit unsigned integers.
168         ''' </summary>
169         ''' <param name="val1">The first of two 64-bit unsigned integers to compare.</param>
170         ''' <param name="val2">The second of two 64-bit unsigned integers to compare.</param>
171         ''' <returns>Parameter val1 or val2, whichever is larger.</returns>
172         <CLSCompliant(False)> <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
173         <MethodImpl(MethodImplOptions.AggressiveInlining)>
174         Public Function Max(val1 As ULong, val2 As ULongAs ULong
175             If val1 > val2 Then
176                 Return val1
177             Else
178                 Return val2
179             End If
180         End Function
181
182         ''' <summary>
183         ''' Returns the larger of two 64-bit signed integers.
184         ''' </summary>
185         ''' <param name="val1">The first of two 64-bit signed integers to compare.</param>
186         ''' <param name="val2">The second of two 64-bit signed integers to compare.</param>
187         ''' <returns>Parameter val1 or val2, whichever is larger.</returns>
188         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
189         <MethodImpl(MethodImplOptions.AggressiveInlining)>
190         Public Function Max(val1 As Long, val2 As LongAs Long
191             If val1 > val2 Then
192                 Return val1
193             Else
194                 Return val2
195             End If
196         End Function
197
198         ''' <summary>
199         ''' Returns the larger of two 32-bit unsigned integers.
200         ''' </summary>
201         ''' <param name="val1">The first of two 32-bit unsigned integers to compare.</param>
202         ''' <param name="val2">The second of two 32-bit unsigned integers to compare.</param>
203         ''' <returns>Parameter val1 or val2, whichever is larger.</returns>
204         <CLSCompliant(False)> <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
205         <MethodImpl(MethodImplOptions.AggressiveInlining)>
206         Public Function Max(val1 As UInteger, val2 As UIntegerAs UInteger
207             If val1 > val2 Then
208                 Return val1
209             Else
210                 Return val2
211             End If
212         End Function
213         '
214         ' Summary:
215         '     Returns the larger of two 32-bit signed integers.
216         '
217         ' Parameters:
218         '   val1:
219         '     The first of two 32-bit signed integers to compare.
220         '
221         '   val2:
222         '     The second of two 32-bit signed integers to compare.
223         '
224         Returns:
225         '     Parameter val1 or val2, whichever is larger.
226         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
227         <MethodImpl(MethodImplOptions.AggressiveInlining)>
228         Public Function Max(val1 As Integer, val2 As IntegerAs Integer
229             If val1 > val2 Then
230                 Return val1
231             Else
232                 Return val2
233             End If
234         End Function
235         '
236         ' Summary:
237         '     Returns the larger of two 16-bit unsigned integers.
238         '
239         ' Parameters:
240         '   val1:
241         '     The first of two 16-bit unsigned integers to compare.
242         '
243         '   val2:
244         '     The second of two 16-bit unsigned integers to compare.
245         '
246         Returns:
247         '     Parameter val1 or val2, whichever is larger.
248         <CLSCompliant(False)> <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
249         <MethodImpl(MethodImplOptions.AggressiveInlining)>
250         Public Function Max(val1 As UShort, val2 As UShortAs UShort
251             If val1 > val2 Then
252                 Return val1
253             Else
254                 Return val2
255             End If
256         End Function
257         '
258         ' Summary:
259         '     Returns the larger of two 16-bit signed integers.
260         '
261         ' Parameters:
262         '   val1:
263         '     The first of two 16-bit signed integers to compare.
264         '
265         '   val2:
266         '     The second of two 16-bit signed integers to compare.
267         '
268         Returns:
269         '     Parameter val1 or val2, whichever is larger.
270         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
271         <MethodImpl(MethodImplOptions.AggressiveInlining)>
272         Public Function Max(val1 As Short, val2 As ShortAs Short
273             If val1 > val2 Then
274                 Return val1
275             Else
276                 Return val2
277             End If
278         End Function
279         '
280         ' Summary:
281         '     Returns the larger of two 8-bit unsigned integers.
282         '
283         ' Parameters:
284         '   val1:
285         '     The first of two 8-bit unsigned integers to compare.
286         '
287         '   val2:
288         '     The second of two 8-bit unsigned integers to compare.
289         '
290         Returns:
291         '     Parameter val1 or val2, whichever is larger.
292         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
293         <MethodImpl(MethodImplOptions.AggressiveInlining)>
294         Public Function Max(val1 As Byte, val2 As ByteAs Byte
295             If val1 > val2 Then
296                 Return val1
297             Else
298                 Return val2
299             End If
300         End Function
301         '
302         ' Summary:
303         '     Returns the larger of two 8-bit signed integers.
304         '
305         ' Parameters:
306         '   val1:
307         '     The first of two 8-bit signed integers to compare.
308         '
309         '   val2:
310         '     The second of two 8-bit signed integers to compare.
311         '
312         Returns:
313         '     Parameter val1 or val2, whichever is larger.
314         <CLSCompliant(False)> <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
315         <MethodImpl(MethodImplOptions.AggressiveInlining)>
316         Public Function Max(val1 As SByte, val2 As SByteAs SByte
317             If val1 > val2 Then
318                 Return val1
319             Else
320                 Return val2
321             End If
322         End Function
323         '
324         ' Summary:
325         '     Returns the absolute value of a System.Decimal number.
326         '
327         ' Parameters:
328         '   value:
329         '     A number that is greater than or equal to System.Decimal.MinValue, but less than
330         '     or equal to System.Decimal.MaxValue.
331         '
332         Returns:
333         '     A decimal number, x, such that 0 ≤ x ≤System.Decimal.MaxValue.
334         <MethodImpl(MethodImplOptions.AggressiveInlining)>
335         Public Function Abs(value As DecimalAs Decimal
336             If value < 0 Then
337                 Return -value
338             Else
339                 Return value
340             End If
341         End Function
342         '
343         ' Summary:
344         '     Returns the smaller of two 16-bit signed integers.
345         '
346         ' Parameters:
347         '   val1:
348         '     The first of two 16-bit signed integers to compare.
349         '
350         '   val2:
351         '     The second of two 16-bit signed integers to compare.
352         '
353         Returns:
354         '     Parameter val1 or val2, whichever is smaller.
355         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
356         <MethodImpl(MethodImplOptions.AggressiveInlining)>
357         Public Function Min(val1 As Short, val2 As ShortAs Short
358             If val1 < val2 Then
359                 Return val1
360             Else
361                 Return val2
362             End If
363         End Function
364         '
365         ' Summary:
366         '     Returns the smaller of two 16-bit unsigned integers.
367         '
368         ' Parameters:
369         '   val1:
370         '     The first of two 16-bit unsigned integers to compare.
371         '
372         '   val2:
373         '     The second of two 16-bit unsigned integers to compare.
374         '
375         Returns:
376         '     Parameter val1 or val2, whichever is smaller.
377         <CLSCompliant(False)> <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
378         <MethodImpl(MethodImplOptions.AggressiveInlining)>
379         Public Function Min(val1 As UShort, val2 As UShortAs UShort
380             If val1 < val2 Then
381                 Return val1
382             Else
383                 Return val2
384             End If
385         End Function
386         '
387         ' Summary:
388         '     Returns the smaller of two 32-bit signed integers.
389         '
390         ' Parameters:
391         '   val1:
392         '     The first of two 32-bit signed integers to compare.
393         '
394         '   val2:
395         '     The second of two 32-bit signed integers to compare.
396         '
397         Returns:
398         '     Parameter val1 or val2, whichever is smaller.
399         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
400         <MethodImpl(MethodImplOptions.AggressiveInlining)>
401         Public Function Min(val1 As Integer, val2 As IntegerAs Integer
402             If val1 < val2 Then
403                 Return val1
404             Else
405                 Return val2
406             End If
407         End Function
408         '
409         ' Summary:
410         '     Returns the smaller of two 32-bit unsigned integers.
411         '
412         ' Parameters:
413         '   val1:
414         '     The first of two 32-bit unsigned integers to compare.
415         '
416         '   val2:
417         '     The second of two 32-bit unsigned integers to compare.
418         '
419         Returns:
420         '     Parameter val1 or val2, whichever is smaller.
421         <CLSCompliant(False)> <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
422         <MethodImpl(MethodImplOptions.AggressiveInlining)>
423         Public Function Min(val1 As UInteger, val2 As UIntegerAs UInteger
424             If val1 < val2 Then
425                 Return val1
426             Else
427                 Return val2
428             End If
429         End Function
430         '
431         ' Summary:
432         '     Produces the full product of two 32-bit numbers.
433         '
434         ' Parameters:
435         '   a:
436         '     The first number to multiply.
437         '
438         '   b:
439         '     The second number to multiply.
440         '
441         Returns:
442         '     The number containing the product of the specified numbers.
443         <MethodImpl(MethodImplOptions.AggressiveInlining)>
444         Public Function BigMul(a As Integer, b As IntegerAs Long
445             Return sys.BigMul(a, b)
446         End Function
447         '
448         ' Summary:
449         '     Returns an integer that indicates the sign of a decimal number.
450         '
451         ' Parameters:
452         '   value:
453         '     A signed decimal number.
454         '
455         Returns:
456         '     A number that indicates the sign of value, as shown in the following table.Return
457         '     value Meaning -1 value is less than zero. 0 value is equal to zero. 1 value is
458         '     greater than zero.
459         <MethodImpl(MethodImplOptions.AggressiveInlining)>
460         Public Function Sign(value As DecimalAs Integer
461             If value > 0 Then
462                 Return 1
463             ElseIf value < 0 Then
464                 Return -1
465             Else
466                 Return 0
467             End If
468         End Function
469         '
470         ' Summary:
471         '     Returns an integer that indicates the sign of a double-precision floating-point
472         '     number.
473         '
474         ' Parameters:
475         '   value:
476         '     A signed number.
477         '
478         Returns:
479         '     A number that indicates the sign of value, as shown in the following table.Return
480         '     value Meaning -1 value is less than zero. 0 value is equal to zero. 1 value is
481         '     greater than zero.
482         '
483         ' Exceptions:
484         '   T:System.ArithmeticException:
485         '     value is equal to System.Double.NaN.
486         <MethodImpl(MethodImplOptions.AggressiveInlining)>
487         Public Function Sign(value As DoubleAs Integer
488             If value > 0 Then
489                 Return 1
490             ElseIf value < 0 Then
491                 Return -1
492             Else
493                 Return 0
494             End If
495         End Function
496         '
497         ' Summary:
498         '     Returns an integer that indicates the sign of a single-precision floating-point
499         '     number.
500         '
501         ' Parameters:
502         '   value:
503         '     A signed number.
504         '
505         Returns:
506         '     A number that indicates the sign of value, as shown in the following table.Return
507         '     value Meaning -1 value is less than zero. 0 value is equal to zero. 1 value is
508         '     greater than zero.
509         '
510         ' Exceptions:
511         '   T:System.ArithmeticException:
512         '     value is equal to System.Single.NaN.
513         <MethodImpl(MethodImplOptions.AggressiveInlining)>
514         Public Function Sign(value As SingleAs Integer
515             If value > 0 Then
516                 Return 1
517             ElseIf value < 0 Then
518                 Return -1
519             Else
520                 Return 0
521             End If
522         End Function
523         '
524         ' Summary:
525         '     Returns an integer that indicates the sign of a 64-bit signed integer.
526         '
527         ' Parameters:
528         '   value:
529         '     A signed number.
530         '
531         Returns:
532         '     A number that indicates the sign of value, as shown in the following table.Return
533         '     value Meaning -1 value is less than zero. 0 value is equal to zero. 1 value is
534         '     greater than zero.
535         <MethodImpl(MethodImplOptions.AggressiveInlining)>
536         Public Function Sign(value As LongAs Integer
537             If value > 0 Then
538                 Return 1
539             ElseIf value < 0 Then
540                 Return -1
541             Else
542                 Return 0
543             End If
544         End Function
545         '
546         ' Summary:
547         '     Returns an integer that indicates the sign of a 32-bit signed integer.
548         '
549         ' Parameters:
550         '   value:
551         '     A signed number.
552         '
553         Returns:
554         '     A number that indicates the sign of value, as shown in the following table.Return
555         '     value Meaning -1 value is less than zero. 0 value is equal to zero. 1 value is
556         '     greater than zero.
557         <MethodImpl(MethodImplOptions.AggressiveInlining)>
558         Public Function Sign(value As IntegerAs Integer
559             If value > 0 Then
560                 Return 1
561             ElseIf value < 0 Then
562                 Return -1
563             Else
564                 Return 0
565             End If
566         End Function
567
568         ''' <summary>
569         ''' Returns the absolute value of a double-precision floating-point number.
570         ''' </summary>
571         ''' <param name="value">A number that is greater than or equal to System.Double.MinValue, but less than
572         ''' or equal to System.Double.MaxValue.</param>
573         ''' <returns>A double-precision floating-point number, x, such that 0 ≤ x ≤System.Double.MaxValue.</returns>
574         <SecuritySafeCritical>
575         <MethodImpl(MethodImplOptions.AggressiveInlining)>
576         Public Function Abs(value As DoubleAs Double
577             If value < 0 Then
578                 Return -value
579             Else
580                 Return value
581             End If
582         End Function
583         '
584         ' Summary:
585         '     Returns an integer that indicates the sign of a 16-bit signed integer.
586         '
587         ' Parameters:
588         '   value:
589         '     A signed number.
590         '
591         Returns:
592         '     A number that indicates the sign of value, as shown in the following table.Return
593         '     value Meaning -1 value is less than zero. 0 value is equal to zero. 1 value is
594         '     greater than zero.
595         <MethodImpl(MethodImplOptions.AggressiveInlining)>
596         Public Function Sign(value As ShortAs Integer
597             If value < 0 Then
598                 Return -value
599             Else
600                 Return value
601             End If
602         End Function
603
604         Returns:
605         '     One of the values in the following table. (+Infinity denotes System.Double.PositiveInfinity,
606         '     -Infinity denotes System.Double.NegativeInfinity, and NaN denotes System.Double.NaN.)anewBaseReturn
607         '     valuea> 0(0 <newBase< 1) -or-(newBase> 1)lognewBase(a)a< 0(any value)NaN(any
608         '     value)newBase< 0NaNa != 1newBase = 0NaNa != 1newBase = +InfinityNaNa = NaN(any
609         '     value)NaN(any value)newBase = NaNNaN(any value)newBase = 1NaNa = 00 <newBase<
610         '     1 +Infinitya = 0newBase> 1-Infinitya = +Infinity0 <newBase< 1-Infinitya = +InfinitynewBase>
611         '     1+Infinitya = 1newBase = 00a = 1newBase = +Infinity0
612         ''' <summary>
613         ''' Returns the logarithm of a specified number in a specified base.
614         ''' </summary>
615         ''' <param name="a">The number whose logarithm is to be found.</param>
616         ''' <param name="newBase">The base of the logarithm.</param>
617         ''' <returns></returns>
618         <MethodImpl(MethodImplOptions.AggressiveInlining)>
619         Public Function Log(a#, newBase#) As Double
620             Return sys.Log(a, newBase)
621         End Function
622
623         ''' <summary>
624         ''' Returns the smaller of two decimal numbers.
625         ''' </summary>
626         ''' <param name="val1">The first of two decimal numbers to compare.</param>
627         ''' <param name="val2">The second of two decimal numbers to compare.</param>
628         ''' <returns>Parameter val1 or val2, whichever is smaller.</returns>
629         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
630         <MethodImpl(MethodImplOptions.AggressiveInlining)>
631         Public Function Min(val1 As Decimal, val2 As DecimalAs Decimal
632             If val1 < val2 Then
633                 Return val1
634             Else
635                 Return val2
636             End If
637         End Function
638         '
639         ' Summary:
640         '     Returns the smaller of two double-precision floating-point numbers.
641         '
642         ' Parameters:
643         '   val1:
644         '     The first of two double-precision floating-point numbers to compare.
645         '
646         '   val2:
647         '     The second of two double-precision floating-point numbers to compare.
648         '
649         Returns:
650         '     Parameter val1 or val2, whichever is smaller. If val1, val2, or both val1 and
651         '     val2 are equal to System.Double.NaN, System.Double.NaN is returned.
652         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
653         <MethodImpl(MethodImplOptions.AggressiveInlining)>
654         Public Function Min(val1 As Double, val2 As DoubleAs Double
655             If val1 < val2 Then
656                 Return val1
657             Else
658                 Return val2
659             End If
660         End Function
661
662         '
663         ' Summary:
664         '     Returns the smaller of two single-precision floating-point numbers.
665         '
666         ' Parameters:
667         '   val1:
668         '     The first of two single-precision floating-point numbers to compare.
669         '
670         '   val2:
671         '     The second of two single-precision floating-point numbers to compare.
672         '
673         Returns:
674         '     Parameter val1 or val2, whichever is smaller. If val1, val2, or both val1 and
675         '     val2 are equal to System.Single.NaN, System.Single.NaN is returned.
676         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
677         <MethodImpl(MethodImplOptions.AggressiveInlining)>
678         Public Function Min(val1 As Single, val2 As SingleAs Single
679             If val1 < val2 Then
680                 Return val1
681             Else
682                 Return val2
683             End If
684         End Function
685         '
686         ' Summary:
687         '     Returns the smaller of two 64-bit unsigned integers.
688         '
689         ' Parameters:
690         '   val1:
691         '     The first of two 64-bit unsigned integers to compare.
692         '
693         '   val2:
694         '     The second of two 64-bit unsigned integers to compare.
695         '
696         Returns:
697         '     Parameter val1 or val2, whichever is smaller.
698         <CLSCompliant(False)> <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
699         <MethodImpl(MethodImplOptions.AggressiveInlining)>
700         Public Function Min(val1 As ULong, val2 As ULongAs ULong
701             If val1 < val2 Then
702                 Return val1
703             Else
704                 Return val2
705             End If
706         End Function
707         '
708         ' Summary:
709         '     Returns the smaller of two 64-bit signed integers.
710         '
711         ' Parameters:
712         '   val1:
713         '     The first of two 64-bit signed integers to compare.
714         '
715         '   val2:
716         '     The second of two 64-bit signed integers to compare.
717         '
718         Returns:
719         '     Parameter val1 or val2, whichever is smaller.
720         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
721         <MethodImpl(MethodImplOptions.AggressiveInlining)>
722         Public Function Min(val1 As Long, val2 As LongAs Long
723             If val1 < val2 Then
724                 Return val1
725             Else
726                 Return val2
727             End If
728         End Function
729         '
730         ' Summary:
731         '     Returns an integer that indicates the sign of an 8-bit signed integer.
732         '
733         ' Parameters:
734         '   value:
735         '     A signed number.
736         '
737         Returns:
738         '     A number that indicates the sign of value, as shown in the following table.Return
739         '     value Meaning -1 value is less than zero. 0 value is equal to zero. 1 value is
740         '     greater than zero.
741         <CLSCompliant(False)>
742         <MethodImpl(MethodImplOptions.AggressiveInlining)>
743         Public Function Sign(value As SByteAs Integer
744             If value > 0 Then
745                 Return 1
746             ElseIf value < 0 Then
747                 Return -1
748             Else
749                 Return 0
750             End If
751         End Function
752
753         ''' <summary>
754         ''' Returns the absolute value of a single-precision floating-point number.
755         ''' </summary>
756         ''' <param name="value">A number that is greater than or equal to System.Single.MinValue, but less than
757         ''' or equal to System.Single.MaxValue.</param>
758         ''' <returns>
759         ''' A single-precision floating-point number, x, such that 0 ≤ x ≤System.Single.MaxValue.
760         ''' </returns>
761         <SecuritySafeCritical>
762         <MethodImpl(MethodImplOptions.AggressiveInlining)>
763         Public Function Abs(value As SingleAs Single
764             If value < 0 Then
765                 Return -value
766             Else
767                 Return value
768             End If
769         End Function
770
771         ''' <summary>
772         ''' Returns the absolute value of a 64-bit signed integer.
773         ''' </summary>
774         ''' <param name="value">
775         ''' A number that is greater than System.Int64.MinValue, but less than or equal to
776         ''' System.Int64.MaxValue.</param>
777         ''' <returns>A 64-bit signed integer, x, such that 0 ≤ x ≤System.Int64.MaxValue.</returns>
778         <MethodImpl(MethodImplOptions.AggressiveInlining)>
779         Public Function Abs(value As LongAs Long
780             If value < 0 Then
781                 Return -value
782             Else
783                 Return value
784             End If
785         End Function
786
787         ''' <summary>
788         ''' Returns the absolute value of a 32-bit signed integer.
789         ''' </summary>
790         ''' <param name="value">
791         ''' A number that is greater than System.Int32.MinValue, but less than or equal to
792         ''' System.Int32.MaxValue.
793         ''' </param>
794         ''' <returns>A 32-bit signed integer, x, such that 0 ≤ x ≤System.Int32.MaxValue.</returns>
795         <MethodImpl(MethodImplOptions.AggressiveInlining)>
796         Public Function Abs(value As IntegerAs Integer
797             If value < 0 Then
798                 Return -value
799             Else
800                 Return value
801             End If
802         End Function
803         '
804         ' Summary:
805         '     Returns the hyperbolic tangent of the specified angle.
806         '
807         ' Parameters:
808         '   value:
809         '     An angle, measured in radians.
810         '
811         Returns:
812         '     The hyperbolic tangent of value. If value is equal to System.Double.NegativeInfinity,
813         '     this method returns -1. If value is equal to System.Double.PositiveInfinity,
814         '     this method returns 1. If value is equal to System.Double.NaN, this method returns
815         '     System.Double.NaN.
816         <SecuritySafeCritical>
817         <MethodImpl(MethodImplOptions.AggressiveInlining)>
818         Public Function Tanh(value As DoubleAs Double
819             Return sys.Tanh(value)
820         End Function
821         '
822         ' Summary:
823         '     Returns the hyperbolic sine of the specified angle.
824         '
825         ' Parameters:
826         '   value:
827         '     An angle, measured in radians.
828         '
829         Returns:
830         '     The hyperbolic sine of value. If value is equal to System.Double.NegativeInfinity,
831         '     System.Double.PositiveInfinity, or System.Double.NaN, this method returns a System.Double
832         '     equal to value.
833         <SecuritySafeCritical>
834         <MethodImpl(MethodImplOptions.AggressiveInlining)>
835         Public Function Sinh(value As DoubleAs Double
836             Return sys.Sinh(value)
837         End Function
838         '
839         ' Summary:
840         '     Returns the tangent of the specified angle.
841         '
842         ' Parameters:
843         '   a:
844         '     An angle, measured in radians.
845         '
846         Returns:
847         '     The tangent of a. If a is equal to System.Double.NaN, System.Double.NegativeInfinity,
848         '     or System.Double.PositiveInfinity, this method returns System.Double.NaN.
849         <SecuritySafeCritical>
850         <MethodImpl(MethodImplOptions.AggressiveInlining)>
851         Public Function Tan(a As DoubleAs Double
852             Return sys.Tan(a)
853         End Function
854         '
855         ' Summary:
856         '     Returns the sine of the specified angle.
857         '
858         ' Parameters:
859         '   a:
860         '     An angle, measured in radians.
861         '
862         Returns:
863         '     The sine of a. If a is equal to System.Double.NaN, System.Double.NegativeInfinity,
864         '     or System.Double.PositiveInfinity, this method returns System.Double.NaN.
865         <SecuritySafeCritical>
866         <MethodImpl(MethodImplOptions.AggressiveInlining)>
867         Public Function Sin(a As DoubleAs Double
868             Return sys.Sin(a)
869         End Function
870         '
871         ' Summary:
872         '     Returns the largest integer less than or equal to the specified double-precision
873         '     floating-point number.
874         '
875         ' Parameters:
876         '   d:
877         '     A double-precision floating-point number.
878         '
879         Returns:
880         '     The largest integer less than or equal to d. If d is equal to System.Double.NaN,
881         '     System.Double.NegativeInfinity, or System.Double.PositiveInfinity, that value
882         '     is returned.
883         <SecuritySafeCritical>
884         <MethodImpl(MethodImplOptions.AggressiveInlining)>
885         Public Function Floor(d As DoubleAs Double
886             Return sys.Floor(d)
887         End Function
888
889
890         '
891         ' Summary:
892         '     Returns the largest integer less than or equal to the specified decimal number.
893         '
894         ' Parameters:
895         '   d:
896         '     A decimal number.
897         '
898         Returns:
899         '     The largest integer less than or equal to d. Note that the method returns an
900         '     integral value of type System.Math.
901         <MethodImpl(MethodImplOptions.AggressiveInlining)>
902         Public Function Floor(d As DecimalAs Decimal
903             Return sys.Floor(d)
904         End Function
905
906         '
907         ' Summary:
908         '     Rounds a double-precision floating-point value to the nearest integral value.
909         '
910         ' Parameters:
911         '   a:
912         '     A double-precision floating-point number to be rounded.
913         '
914         Returns:
915         '     The integer nearest a. If the fractional component of a is halfway between two
916         '     integers, one of which is even and the other odd, then the even number is returned.
917         '     Note that this method returns a System.Double instead of an integral type.
918         <SecuritySafeCritical>
919         <MethodImpl(MethodImplOptions.AggressiveInlining)>
920         Public Function Round(a As DoubleAs Double
921             Return sys.Round(a)
922         End Function
923         '
924         ' Summary:
925         '     Returns the hyperbolic cosine of the specified angle.
926         '
927         ' Parameters:
928         '   value:
929         '     An angle, measured in radians.
930         '
931         Returns:
932         '     The hyperbolic cosine of value. If value is equal to System.Double.NegativeInfinity
933         '     or System.Double.PositiveInfinity, System.Double.PositiveInfinity is returned.
934         '     If value is equal to System.Double.NaN, System.Double.NaN is returned.
935         <SecuritySafeCritical>
936         <MethodImpl(MethodImplOptions.AggressiveInlining)>
937         Public Function Cosh(value As DoubleAs Double
938             Return sys.Cosh(value)
939         End Function
940         '
941         ' Summary:
942         '     Returns the smallest integral value that is greater than or equal to the specified
943         '     double-precision floating-point number.
944         '
945         ' Parameters:
946         '   a:
947         '     A double-precision floating-point number.
948         '
949         Returns:
950         '     The smallest integral value that is greater than or equal to a. If a is equal
951         '     to System.Double.NaN, System.Double.NegativeInfinity, or System.Double.PositiveInfinity,
952         '     that value is returned. Note that this method returns a System.Double instead
953         '     of an integral type.
954         <SecuritySafeCritical>
955         <MethodImpl(MethodImplOptions.AggressiveInlining)>
956         Public Function Ceiling(a As DoubleAs Double
957             Return sys.Ceiling(a)
958         End Function
959         '
960         ' Summary:
961         '     Returns the smallest integral value that is greater than or equal to the specified
962         '     decimal number.
963         '
964         ' Parameters:
965         '   d:
966         '     A decimal number.
967         '
968         Returns:
969         '     The smallest integral value that is greater than or equal to d. Note that this
970         '     method returns a System.Decimal instead of an integral type.
971         <MethodImpl(MethodImplOptions.AggressiveInlining)>
972         Public Function Ceiling(d As DecimalAs Decimal
973             Return sys.Ceiling(d)
974         End Function
975         '
976         ' Summary:
977         '     Returns the angle whose tangent is the quotient of two specified numbers.
978         '
979         ' Parameters:
980         '   y:
981         '     The y coordinate of a point.
982         '
983         '   x:
984         '     The x coordinate of a point.
985         '
986         Returns:
987         '     An angle, θ, measured in radians, such that -π≤θ≤π, and tan(θ) = y / x, where
988         '     (x, y) is a point in the Cartesian plane. Observe the following: For (x, y) in
989         '     quadrant 1, 0 < θ < π/2.For (x, y) in quadrant 2, π/2 < θ≤π.For (x, y) in quadrant
990         '     3, -π < θ < -π/2.For (x, y) in quadrant 4, -π/2 < θ < 0.For points on the boundaries
991         '     of the quadrants, the return value is the following:If y is 0 and x is not negative,
992         '     θ = 0.If y is 0 and x is negative, θ = π.If y is positive and x is 0, θ = π/2.If
993         '     y is negative and x is 0, θ = -π/2.If y is 0 and x is 0, θ = 0. If x or y is
994         '     System.Double.NaN, or if x and y are either System.Double.PositiveInfinity or
995         '     System.Double.NegativeInfinity, the method returns System.Double.NaN.
996         <SecuritySafeCritical>
997         <MethodImpl(MethodImplOptions.AggressiveInlining)>
998         Public Function Atan2(y As Double, x As DoubleAs Double
999             Return sys.Atan2(y, x)
1000         End Function
1001         '
1002         ' Summary:
1003         '     Returns the angle whose tangent is the specified number.
1004         '
1005         ' Parameters:
1006         '   d:
1007         '     A number representing a tangent.
1008         '
1009         Returns:
1010         '     An angle, θ, measured in radians, such that -π/2 ≤θ≤π/2.-or- System.Double.NaN
1011         '     if d equals System.Double.NaN, -π/2 rounded to double precision (-1.5707963267949)
1012         '     if d equals System.Double.NegativeInfinity, or π/2 rounded to double precision
1013         '     (1.5707963267949) if d equals System.Double.PositiveInfinity.
1014         <SecuritySafeCritical>
1015         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1016         Public Function Atan(d As DoubleAs Double
1017             Return sys.Atan(d)
1018         End Function
1019         '
1020         ' Summary:
1021         '     Returns the angle whose sine is the specified number.
1022         '
1023         ' Parameters:
1024         '   d:
1025         '     A number representing a sine, where d must be greater than or equal to -1, but
1026         '     less than or equal to 1.
1027         '
1028         Returns:
1029         '     An angle, θ, measured in radians, such that -π/2 ≤θ≤π/2 -or- System.Double.NaN
1030         '     if d < -1 or d > 1 or d equals System.Double.NaN.
1031         <SecuritySafeCritical>
1032         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1033         Public Function Asin(d As DoubleAs Double
1034             Return sys.Asin(d)
1035         End Function
1036         '
1037         ' Summary:
1038         '     Returns the angle whose cosine is the specified number.
1039         '
1040         ' Parameters:
1041         '   d:
1042         '     A number representing a cosine, where d must be greater than or equal to -1,
1043         '     but less than or equal to 1.
1044         '
1045         Returns:
1046         '     An angle, θ, measured in radians, such that 0 ≤θ≤π-or- System.Double.NaN if d
1047         '     < -1 or d > 1 or d equals System.Double.NaN.
1048         <SecuritySafeCritical>
1049         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1050         Public Function Acos(d As DoubleAs Double
1051             Return sys.Acos(d)
1052         End Function
1053         '
1054         ' Summary:
1055         '     Returns the cosine of the specified angle.
1056         '
1057         ' Parameters:
1058         '   d:
1059         '     An angle, measured in radians.
1060         '
1061         Returns:
1062         '     The cosine of d. If d is equal to System.Double.NaN, System.Double.NegativeInfinity,
1063         '     or System.Double.PositiveInfinity, this method returns System.Double.NaN.
1064         <SecuritySafeCritical>
1065         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1066         Public Function Cos(d As DoubleAs Double
1067             Return sys.Cos(d)
1068         End Function
1069         '
1070         ' Summary:
1071         '     Calculates the quotient of two 32-bit signed integers and also returns the remainder
1072         '     in an output parameter.
1073         '
1074         ' Parameters:
1075         '   a:
1076         '     The dividend.
1077         '
1078         '   b:
1079         '     The divisor.
1080         '
1081         '   result:
1082         '     The remainder.
1083         '
1084         Returns:
1085         '     The quotient of the specified numbers.
1086         '
1087         ' Exceptions:
1088         '   T:System.DivideByZeroException:
1089         '     b is zero.
1090         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1091         Public Function DivRem(a As Integer, b As IntegerByRef result As IntegerAs Integer
1092             Return sys.DivRem(a, b, result)
1093         End Function
1094
1095         ''' <summary>
1096         ''' Rounds a double-precision floating-point value to a specified number of fractional
1097         ''' digits.
1098         ''' </summary>
1099         ''' <param name="value">A double-precision floating-point number to be rounded.</param>
1100         ''' <param name="digits">The number of fractional digits in the return value.</param>
1101         ''' <returns>The number nearest to value that contains a number of fractional digits equal
1102         ''' to digits.</returns>
1103         '''   
1104         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1105         Public Function Round(value As Double, digits As IntegerAs Double
1106             Return sys.Round(value, digits)
1107         End Function
1108         '
1109         ' Summary:
1110         '     Rounds a double-precision floating-point value to a specified number of fractional
1111         '     digits. A parameter specifies how to round the value if it is midway between
1112         '     two numbers.
1113         '
1114         ' Parameters:
1115         '   value:
1116         '     A double-precision floating-point number to be rounded.
1117         '
1118         '   digits:
1119         '     The number of fractional digits in the return value.
1120         '
1121         '   mode:
1122         '     Specification for how to round value if it is midway between two other numbers.
1123         '
1124         Returns:
1125         '     The number nearest to value that has a number of fractional digits equal to digits.
1126         '     If value has fewer fractional digits than digits, value is returned unchanged.
1127         '
1128         ' Exceptions:
1129         '   T:System.ArgumentOutOfRangeException:
1130         '     digits is less than 0 or greater than 15.
1131         '
1132         '   T:System.ArgumentException:
1133         '     mode is not a valid value of System.MidpointRounding.
1134         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1135         Public Function Round(value As Double, digits As Integer, mode As MidpointRounding) As Double
1136             Return sys.Round(value, digits, mode)
1137         End Function
1138         '
1139         ' Summary:
1140         '     Returns the absolute value of a 16-bit signed integer.
1141         '
1142         ' Parameters:
1143         '   value:
1144         '     A number that is greater than System.Int16.MinValue, but less than or equal to
1145         '     System.Int16.MaxValue.
1146         '
1147         Returns:
1148         '     A 16-bit signed integer, x, such that 0 ≤ x ≤System.Int16.MaxValue.
1149         '
1150         ' Exceptions:
1151         '   T:System.OverflowException:
1152         '     value equals System.Int16.MinValue.
1153         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1154         Public Function Abs(value As ShortAs Short
1155             If value < 0 Then
1156                 Return -value
1157             Else
1158                 Return value
1159             End If
1160         End Function
1161         '
1162         ' Summary:
1163         '     Returns the absolute value of an 8-bit signed integer.
1164         '
1165         ' Parameters:
1166         '   value:
1167         '     A number that is greater than System.SByte.MinValue, but less than or equal to
1168         '     System.SByte.MaxValue.
1169         '
1170         Returns:
1171         '     An 8-bit signed integer, x, such that 0 ≤ x ≤System.SByte.MaxValue.
1172         '
1173         ' Exceptions:
1174         '   T:System.OverflowException:
1175         '     value equals System.SByte.MinValue.
1176         <CLSCompliant(False)>
1177         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1178         Public Function Abs(value As SByteAs SByte
1179             If value < 0 Then
1180                 Return -value
1181             Else
1182                 Return value
1183             End If
1184         End Function
1185         '
1186         ' Summary:
1187         '     Returns the remainder resulting from the division of a specified number by another
1188         '     specified number.
1189         '
1190         ' Parameters:
1191         '   x:
1192         '     A dividend.
1193         '
1194         '   y:
1195         '     A divisor.
1196         '
1197         Returns:
1198         '     A number equal to x - (y Q), where Q is the quotient of x / y rounded to the
1199         '     nearest integer (if x / y falls halfway between two integers, the even integer
1200         '     is returned).If x - (y Q) is zero, the value +0 is returned if x is positive,
1201         '     or -0 if x is negative.If y = 0, System.Double.NaN is returned.
1202         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1203         Public Function IEEERemainder(x As Double, y As DoubleAs Double
1204             Return sys.IEEERemainder(x, y)
1205         End Function
1206
1207         ''' <summary>
1208         ''' Returns a specified number raised to the specified power.
1209         ''' </summary>
1210         ''' <param name="x">A double-precision floating-point number to be raised to a power.</param>
1211         ''' <param name="y">A double-precision floating-point number that specifies a power.</param>
1212         ''' <returns>The number x raised to the power y.</returns>
1213         <SecuritySafeCritical>
1214         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1215         Public Function Pow(x As Double, y As DoubleAs Double
1216             Return x ^ y
1217         End Function
1218
1219         ''' <summary>
1220         ''' Returns e raised to the specified power.
1221         ''' </summary>
1222         ''' <param name="d">A number specifying a power.</param>
1223         ''' <returns>The number e raised to the power d. If d equals System.Double.NaN or System.Double.PositiveInfinity,
1224         ''' that value is returned. If d equals System.Double.NegativeInfinity, 0 is returned.</returns>
1225         <SecuritySafeCritical>
1226         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1227         Public Function Exp(d As DoubleAs Double
1228             Return sys.Exp(d)
1229         End Function
1230         '
1231         ' Summary:
1232         '     Returns the base 10 logarithm of a specified number.
1233         '
1234         ' Parameters:
1235         '   d:
1236         '     A number whose logarithm is to be found.
1237         '
1238         Returns:
1239         '     One of the values in the following table. d parameter Return value Positive The
1240         '     base 10 log of d; that is, log 10d. Zero System.Double.NegativeInfinityNegative
1241         '     System.Double.NaNEqual to System.Double.NaNSystem.Double.NaNEqual to System.Double.PositiveInfinitySystem.Double.PositiveInfinity
1242         <SecuritySafeCritical>
1243         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1244         Public Function Log10(d As DoubleAs Double
1245             Return sys.Log10(d)
1246         End Function
1247         '
1248         ' Summary:
1249         '     Rounds a double-precision floating-point value to the nearest integer. A parameter
1250         '     specifies how to round the value if it is midway between two numbers.
1251         '
1252         ' Parameters:
1253         '   value:
1254         '     A double-precision floating-point number to be rounded.
1255         '
1256         '   mode:
1257         '     Specification for how to round value if it is midway between two other numbers.
1258         '
1259         Returns:
1260         '     The integer nearest value. If value is halfway between two integers, one of which
1261         '     is even and the other odd, then mode determines which of the two is returned.
1262         '
1263         ' Exceptions:
1264         '   T:System.ArgumentException:
1265         '     mode is not a valid value of System.MidpointRounding.
1266         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1267         Public Function Round(value As Double, mode As MidpointRounding) As Double
1268             Return sys.Round(value, mode)
1269         End Function
1270         '
1271         ' Summary:
1272         '     Returns the natural (base e) logarithm of a specified number.
1273         '
1274         ' Parameters:
1275         '   d:
1276         '     The number whose logarithm is to be found.
1277         '
1278         Returns:
1279         '     One of the values in the following table. d parameterReturn value Positive The
1280         '     natural logarithm of d; that is, ln d, or log edZero System.Double.NegativeInfinityNegative
1281         '     System.Double.NaNEqual to System.Double.NaNSystem.Double.NaNEqual to System.Double.PositiveInfinitySystem.Double.PositiveInfinity
1282         <SecuritySafeCritical>
1283         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1284         Public Function Log(d As DoubleAs Double
1285             Return sys.Log(d)
1286         End Function
1287
1288         ''' <summary>
1289         ''' Calculates the integral part of a specified double-precision floating-point number.
1290         ''' </summary>
1291         ''' <param name="d">A number to truncate.</param>
1292         ''' <returns>The integral part of d; that is, the number that remains after any fractional
1293         ''' digits have been discarded, or one of the values listed in the following table.
1294         ''' |<paramref name="d"/>          |Return value                  |
1295         ''' |------------------------------|------------------------------|
1296         ''' |System.Double.NaN             |System.Double.NaN             |
1297         ''' |System.Double.NegativeInfinity|System.Double.NegativeInfinity|
1298         ''' |System.Double.PositiveInfinity|System.Double.PositiveInfinity|
1299         ''' </returns>
1300         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1301         Public Function Truncate(d As DoubleAs Double
1302             Return sys.Truncate(d)
1303         End Function
1304         '
1305         ' Summary:
1306         '     Calculates the integral part of a specified decimal number.
1307         '
1308         ' Parameters:
1309         '   d:
1310         '     A number to truncate.
1311         '
1312         Returns:
1313         '     The integral part of d; that is, the number that remains after any fractional
1314         '     digits have been discarded.
1315         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1316         Public Function Truncate(d As DecimalAs Decimal
1317             Return sys.Truncate(d)
1318         End Function
1319         '
1320         ' Summary:
1321         '     Rounds a decimal value to a specified number of fractional digits. A parameter
1322         '     specifies how to round the value if it is midway between two numbers.
1323         '
1324         ' Parameters:
1325         '   d:
1326         '     A decimal number to be rounded.
1327         '
1328         '   decimals:
1329         '     The number of decimal places in the return value.
1330         '
1331         '   mode:
1332         '     Specification for how to round d if it is midway between two other numbers.
1333         '
1334         Returns:
1335         '     The number nearest to d that contains a number of fractional digits equal to
1336         '     decimals. If d has fewer fractional digits than decimals, d is returned unchanged.
1337         '
1338         ' Exceptions:
1339         '   T:System.ArgumentOutOfRangeException:
1340         '     decimals is less than 0 or greater than 28.
1341         '
1342         '   T:System.ArgumentException:
1343         '     mode is not a valid value of System.MidpointRounding.
1344         '
1345         '   T:System.OverflowException:
1346         '     The result is outside the range of a System.Decimal.
1347         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1348         Public Function Round(d As Decimal, decimals As Integer, mode As MidpointRounding) As Decimal
1349             Return sys.Round(d, decimals, mode)
1350         End Function
1351         '
1352         ' Summary:
1353         '     Rounds a decimal value to the nearest integer. A parameter specifies how to round
1354         '     the value if it is midway between two numbers.
1355         '
1356         ' Parameters:
1357         '   d:
1358         '     A decimal number to be rounded.
1359         '
1360         '   mode:
1361         '     Specification for how to round d if it is midway between two other numbers.
1362         '
1363         Returns:
1364         '     The integer nearest d. If d is halfway between two numbers, one of which is even
1365         '     and the other odd, then mode determines which of the two is returned.
1366         '
1367         ' Exceptions:
1368         '   T:System.ArgumentException:
1369         '     mode is not a valid value of System.MidpointRounding.
1370         '
1371         '   T:System.OverflowException:
1372         '     The result is outside the range of a System.Decimal.
1373         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1374         Public Function Round(d As Decimal, mode As MidpointRounding) As Decimal
1375             Return sys.Round(d, mode)
1376         End Function
1377         '
1378         ' Summary:
1379         '     Rounds a decimal value to a specified number of fractional digits.
1380         '
1381         ' Parameters:
1382         '   d:
1383         '     A decimal number to be rounded.
1384         '
1385         '   decimals:
1386         '     The number of decimal places in the return value.
1387         '
1388         Returns:
1389         '     The number nearest to d that contains a number of fractional digits equal to
1390         '     decimals.
1391         '
1392         ' Exceptions:
1393         '   T:System.ArgumentOutOfRangeException:
1394         '     decimals is less than 0 or greater than 28.
1395         '
1396         '   T:System.OverflowException:
1397         '     The result is outside the range of a System.Decimal.
1398         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1399         Public Function Round(d As Decimal, decimals As IntegerAs Decimal
1400             Return sys.Round(d, decimals)
1401         End Function
1402         '
1403         ' Summary:
1404         '     Rounds a decimal value to the nearest integral value.
1405         '
1406         ' Parameters:
1407         '   d:
1408         '     A decimal number to be rounded.
1409         '
1410         Returns:
1411         '     The integer nearest parameter d. If the fractional component of d is halfway
1412         '     between two integers, one of which is even and the other odd, the even number
1413         '     is returned. Note that this method returns a System.Decimal instead of an integral
1414         '     type.
1415         '
1416         ' Exceptions:
1417         '   T:System.OverflowException:
1418         '     The result is outside the range of a System.Decimal.
1419         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1420         Public Function Round(d As DecimalAs Decimal
1421             Return sys.Round(d)
1422         End Function
1423
1424         ''' <summary>
1425         ''' Returns the square root of a specified number.
1426         ''' </summary>
1427         ''' <param name="d">The number whose square root is to be found.</param>
1428         ''' <returns>One of the values in the following table. d parameter Return value Zero or positive
1429         ''' The positive square root of d. Negative System.Double.NaNEquals System.Double.NaNSystem.Double.NaNEquals
1430         ''' System.Double.PositiveInfinitySystem.Double.PositiveInfinity</returns>
1431         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1432         <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)> <SecuritySafeCritical>
1433         Public Function Sqrt(d As DoubleAs Double
1434             Return sys.Sqrt(d)
1435         End Function
1436         '
1437         ' Summary:
1438         '     Calculates the quotient of two 64-bit signed integers and also returns the remainder
1439         '     in an output parameter.
1440         '
1441         ' Parameters:
1442         '   a:
1443         '     The dividend.
1444         '
1445         '   b:
1446         '     The divisor.
1447         '
1448         '   result:
1449         '     The remainder.
1450         '
1451         Returns:
1452         '     The quotient of the specified numbers.
1453         '
1454         ' Exceptions:
1455         '   T:System.DivideByZeroException:
1456         '     b is zero.
1457         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1458         Public Function DivRem(a As Long, b As LongByRef result As LongAs Long
1459             Return sys.DivRem(a, b, result)
1460         End Function
1461 #End Region
1462
1463         ''' <summary>
1464         ''' 阶乘
1465         ''' </summary>
1466         ''' <param name="a"></param>
1467         ''' <returns></returns>
1468         Public Function Factorial(a As IntegerAs Double
1469             If a <= 1 Then
1470                 Return 1
1471             Else
1472                 Dim n As Double = a
1473
1474                 For i As Integer = a - 1 To 1 Step -1
1475                     n *= i
1476                 Next
1477
1478                 Return n
1479             End If
1480         End Function
1481
1482         Public Iterator Function FactorialSequence(a As IntegerAs IEnumerable(Of Integer)
1483             If a <= 1 Then
1484                 Yield 1
1485             Else
1486                 For i As Integer = a To 1 Step -1
1487                     Yield i
1488                 Next
1489             End If
1490         End Function
1491
1492         ''' <summary>
1493         ''' Returns the covariance of two data vectors. </summary>
1494         ''' <param name="a"> double[] of data </param>
1495         ''' <param name="b"> double[] of data
1496         ''' @return the covariance of a and b, cov(a,b) </param>
1497         Public Function Covariance(a As Double(), b As Double()) As Double
1498             If a.Length <> b.Length Then
1499                 Throw New ArgumentException("Cannot take covariance of different dimension vectors.")
1500             End If
1501
1502             Dim divisor As Double = a.Length - 1
1503             Dim sum As Double = 0
1504             Dim aMean As Double = a.Average
1505             Dim bMean As Double = b.Average
1506
1507             For i As Integer = 0 To a.Length - 1
1508                 sum += (a(i) - aMean) * (b(i) - bMean)
1509             Next
1510
1511             Return sum / divisor
1512         End Function
1513
1514         ''' <summary>
1515         ''' 请注意,<paramref name="data"/>的元素数量必须要和<paramref name="weights"/>的长度相等
1516         ''' </summary>
1517         ''' <param name="data"></param>
1518         ''' <param name="weights">这个数组里面的值的和必须要等于1</param>
1519         ''' <returns></returns>
1520         <Extension>
1521         Public Function WeighedAverage(data As IEnumerable(Of Double), ParamArray weights As Double()) As Double
1522             Dim avg#
1523
1524             For Each x As SeqValue(Of DoubleIn data.SeqIterator
1525                 avg += (x.value * weights(x))
1526             Next
1527
1528             Return avg
1529         End Function
1530
1531         ''' <summary>
1532         ''' [Sequence Generation] Generate regular sequences. seq is a standard generic with a default method.
1533         ''' </summary>
1534         ''' <param name="From">
1535         ''' the starting and (maximal) end values of the sequence. Of length 1 unless just from is supplied as an unnamed argument.
1536         ''' </param>
1537         ''' <param name="To">
1538         ''' the starting and (maximal) end values of the sequence. Of length 1 unless just from is supplied as an unnamed argument.
1539         ''' </param>
1540         ''' <param name="By">number: increment of the sequence</param>
1541         ''' <returns></returns>
1542         ''' <remarks></remarks>
1543         ''' 
1544         <Extension>
1545         Public Iterator Function seq([from] As Value(Of Double), [to] As DoubleOptional by As Double = 0.1) As IEnumerable(Of Double)
1546             Yield from
1547
1548             Do While (from = from.Value + by) <= [to]
1549                 Yield from
1550             Loop
1551         End Function
1552
1553         <Extension>
1554         Public Iterator Function seq(range As DoubleRange, Optional steps# = 0.1) As IEnumerable(Of Double)
1555             For Each x# In seq(range.Min, range.Max, steps)
1556                 Yield x#
1557             Next
1558         End Function
1559
1560         ''' <summary>
1561         ''' 以 N 为底的对数 ``LogN(X) = Log(X) / Log(N)`` 
1562         ''' </summary>
1563         ''' <param name="x"></param>
1564         ''' <param name="N"></param>
1565         ''' <returns></returns>
1566         ''' 
1567         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1568         Public Function LogN(x As Double, N As DoubleAs Double
1569             Return sys.Log(x) / sys.Log(N)
1570         End Function
1571
1572         ''' <summary>
1573         ''' return the maximum of a, b and c </summary>
1574         ''' <param name="a"> </param>
1575         ''' <param name="b"> </param>
1576         ''' <param name="c">
1577         ''' @return </param>
1578         ''' 
1579         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1580         Public Function Max(a As Integer, b As Integer, c As IntegerAs Integer
1581             Return sys.Max(a, sys.Max(b, c))
1582         End Function
1583
1584         ''' <summary>
1585         '''  sqrt(a^2 + b^2) without under/overflow.
1586         ''' </summary>
1587         ''' <param name="a"></param>
1588         ''' <param name="b"></param>
1589         ''' <returns></returns>
1590
1591         Public Function Hypot(a As Double, b As DoubleAs Double
1592             Dim r As Double
1593
1594             If sys.Abs(a) > sys.Abs(b) Then
1595                 r = b / a
1596                 r = sys.Abs(a) * sys.Sqrt(1 + r * r)
1597             ElseIf b <> 0 Then
1598                 r = a / b
1599                 r = sys.Abs(b) * sys.Sqrt(1 + r * r)
1600             Else
1601                 r = 0.0
1602             End If
1603
1604             Return r
1605         End Function
1606
1607         ''' <summary>
1608         ''' Calculates power of 2.
1609         ''' </summary>
1610         ''' 
1611         ''' <param name="power">Power to raise in.</param>
1612         ''' 
1613         ''' <returns>Returns specified power of 2 in the case if power is in the range of
1614         ''' [0, 30]. Otherwise returns 0.</returns>
1615         ''' 
1616         Public Function Pow2(power As IntegerAs Integer
1617             Return If(((power >= 0) AndAlso (power <= 30)), (1 << power), 0)
1618         End Function
1619
1620         ''' <summary>
1621         ''' Get base of binary logarithm.
1622         ''' </summary>
1623         ''' 
1624         ''' <param name="x">Source integer number.</param>
1625         ''' 
1626         ''' <returns>Power of the number (base of binary logarithm).</returns>
1627         ''' 
1628         Public Function Log2(x As IntegerAs Integer
1629             If x <= 65536 Then
1630                 If x <= 256 Then
1631                     If x <= 16 Then
1632                         If x <= 4 Then
1633                             If x <= 2 Then
1634                                 If x <= 1 Then
1635                                     Return 0
1636                                 End If
1637                                 Return 1
1638                             End If
1639                             Return 2
1640                         End If
1641                         If x <= 8 Then
1642                             Return 3
1643                         End If
1644                         Return 4
1645                     End If
1646                     If x <= 64 Then
1647                         If x <= 32 Then
1648                             Return 5
1649                         End If
1650                         Return 6
1651                     End If
1652                     If x <= 128 Then
1653                         Return 7
1654                     End If
1655                     Return 8
1656                 End If
1657                 If x <= 4096 Then
1658                     If x <= 1024 Then
1659                         If x <= 512 Then
1660                             Return 9
1661                         End If
1662                         Return 10
1663                     End If
1664                     If x <= 2048 Then
1665                         Return 11
1666                     End If
1667                     Return 12
1668                 End If
1669                 If x <= 16384 Then
1670                     If x <= 8192 Then
1671                         Return 13
1672                     End If
1673                     Return 14
1674                 End If
1675                 If x <= 32768 Then
1676                     Return 15
1677                 End If
1678                 Return 16
1679             End If
1680
1681             If x <= 16777216 Then
1682                 If x <= 1048576 Then
1683                     If x <= 262144 Then
1684                         If x <= 131072 Then
1685                             Return 17
1686                         End If
1687                         Return 18
1688                     End If
1689                     If x <= 524288 Then
1690                         Return 19
1691                     End If
1692                     Return 20
1693                 End If
1694                 If x <= 4194304 Then
1695                     If x <= 2097152 Then
1696                         Return 21
1697                     End If
1698                     Return 22
1699                 End If
1700                 If x <= 8388608 Then
1701                     Return 23
1702                 End If
1703                 Return 24
1704             End If
1705             If x <= 268435456 Then
1706                 If x <= 67108864 Then
1707                     If x <= 33554432 Then
1708                         Return 25
1709                     End If
1710                     Return 26
1711                 End If
1712                 If x <= 134217728 Then
1713                     Return 27
1714                 End If
1715                 Return 28
1716             End If
1717             If x <= 1073741824 Then
1718                 If x <= 536870912 Then
1719                     Return 29
1720                 End If
1721                 Return 30
1722             End If
1723             Return 31
1724         End Function
1725
1726         ''' <summary>
1727         ''' Checks if the specified integer is power of 2.
1728         ''' </summary>
1729         ''' 
1730         ''' <param name="x">Integer number to check.</param>
1731         ''' 
1732         ''' <returns>Returns <b>true</b> if the specified number is power of 2.
1733         ''' Otherwise returns <b>false</b>.</returns>
1734         ''' 
1735         <Extension>
1736         Public Function IsPowerOf2(x As IntegerAs Boolean
1737             Return If((x > 0), ((x And (x - 1)) = 0), False)
1738         End Function
1739
1740         ''' <summary>
1741         ''' Logical true values are regarded as one, false values as zero. For historical reasons, NULL is accepted and treated as if it were integer(0).
1742         ''' </summary>
1743         ''' <param name="bc"></param>
1744         ''' <returns></returns>
1745         ''' <remarks></remarks>
1746         ''' 
1747         <ExportAPI("Sum")>
1748         <Extension> Public Function Sum(bc As IEnumerable(Of Boolean)) As Double
1749             If bc Is Nothing Then
1750                 Return 0
1751             Else
1752                 Return bc _
1753                     .Select(Function(b) If(True = b, 1.0R, 0R)) _
1754                     .Sum
1755             End If
1756         End Function
1757
1758         ''' <summary>
1759         ''' 计算出所有的数的乘积
1760         ''' </summary>
1761         ''' <param name="[in]"></param>
1762         ''' <returns></returns>
1763         <Extension>
1764         Public Function ProductALL([in] As IEnumerable(Of Double)) As Double
1765             Dim product# = 1
1766
1767             For Each x As Double In [in]
1768                 product *= x
1769             Next
1770
1771             Return product
1772         End Function
1773
1774         ''' <summary>
1775         ''' 计算出所有的数的乘积
1776         ''' </summary>
1777         ''' <param name="[in]"></param>
1778         ''' <returns></returns>
1779         ''' 
1780         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1781         <Extension>
1782         Public Function ProductALL([in] As IEnumerable(Of Integer)) As Double
1783             Return [in].Select(Function(x) CDbl(x)).ProductALL
1784         End Function
1785
1786         ''' <summary>
1787         ''' ## Standard Deviation
1788         ''' 
1789         ''' In statistics, the standard deviation (SD, also represented by the Greek letter sigma σ or the Latin letter s) 
1790         ''' is a measure that is used to quantify the amount of variation or dispersion of a set of data values. A low 
1791         ''' standard deviation indicates that the data points tend to be close to the mean (also called the expected value) 
1792         ''' of the set, while a high standard deviation indicates that the data points are spread out over a wider range of 
1793         ''' values.
1794         ''' 
1795         ''' > https://en.wikipedia.org/wiki/Standard_deviation
1796         ''' </summary>
1797         ''' <returns></returns>
1798         ''' <remarks></remarks>
1799         ''' 
1800         <ExportAPI("STD"Info:="Standard Deviation")>
1801         <Extension> Public Function SD(values As IEnumerable(Of Double)) As Double
1802             Dim data#() = values.ToArray
1803             Dim avg# = data.Average
1804             Dim sumValue# = Aggregate n As Double In data Into Sum((n - avg) ^ 2)
1805             Return sys.Sqrt(sumValue / data.Length)
1806         End Function
1807
1808         ''' <summary>
1809         ''' Standard Deviation
1810         ''' </summary>
1811         ''' <returns></returns>
1812         ''' <remarks></remarks>
1813         ''' 
1814         <ExportAPI("STD"Info:="Standard Deviation")>
1815         <Extension> Public Function SD(values As IEnumerable(Of Integer)) As Double
1816             Return values.Select(Function(x) CDbl(x)).SD
1817         End Function
1818
1819         ''' <summary>
1820         ''' Standard Deviation
1821         ''' </summary>
1822         ''' <returns></returns>
1823         ''' <remarks></remarks>
1824         ''' 
1825         <ExportAPI("STD"Info:="Standard Deviation")>
1826         <Extension> Public Function SD(values As IEnumerable(Of Long)) As Double
1827             Return values.Select(Function(x) CDbl(x)).SD
1828         End Function
1829
1830         ''' <summary>
1831         ''' Standard Deviation
1832         ''' </summary>
1833         ''' <returns></returns>
1834         ''' <remarks></remarks>
1835         ''' 
1836         <ExportAPI("STD"Info:="Standard Deviation")>
1837         <Extension> Public Function SD(values As IEnumerable(Of Single)) As Double
1838             Return values.Select(Function(x) CDbl(x)).SD
1839         End Function
1840
1841         ''' <summary>
1842         ''' 多位坐标的欧几里得距离,与坐标点0进行比较
1843         ''' </summary>
1844         ''' <param name="vector"></param>
1845         ''' <returns></returns>
1846         ''' <remarks></remarks>
1847         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1848         <ExportAPI("Euclidean"Info:="Euclidean Distance")>
1849         <Extension> Public Function EuclideanDistance(vector As IEnumerable(Of Double)) As Double
1850             ' 由于是和令进行比较,减零仍然为原来的数,所以这里直接使用n^2了
1851             Return sys.Sqrt((From n In vector Select n ^ 2).Sum)
1852         End Function
1853
1854         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1855         <ExportAPI("Euclidean"Info:="Euclidean Distance")>
1856         <Extension> Public Function EuclideanDistance(Vector As IEnumerable(Of Integer)) As Double
1857             Return sys.Sqrt((From n In Vector Select n ^ 2).Sum)
1858         End Function
1859
1860         <ExportAPI("Euclidean"Info:="Euclidean Distance")>
1861         <Extension> Public Function EuclideanDistance(a As IEnumerable(Of Integer), b As IEnumerable(Of Integer)) As Double
1862             If a.Count <> b.Count Then
1863                 Return -1
1864             Else
1865                 Return sys.Sqrt((From i As Integer In a.Sequence Select (a(i) - b(i)) ^ 2).Sum)
1866             End If
1867         End Function
1868
1869         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1870         <ExportAPI("Euclidean"Info:="Euclidean Distance")>
1871         <Extension> Public Function EuclideanDistance(a As IEnumerable(Of Double), b As IEnumerable(Of Double)) As Double
1872             Return EuclideanDistance(a.ToArray, b.ToArray)
1873         End Function
1874
1875         ''' <summary>
1876         ''' 
1877         ''' </summary>
1878         ''' <param name="a">Point A</param>
1879         ''' <param name="b">Point B</param>
1880         ''' <returns></returns>
1881         <ExportAPI("Euclidean"Info:="Euclidean Distance")>
1882         <Extension> Public Function EuclideanDistance(a As Byte(), b As Byte()) As Double
1883             If a.Length <> b.Length Then
1884                 Return -1.0R
1885             Else
1886                 Return sys.Sqrt((From i As Integer In a.Sequence Select (CInt(a(i)) - CInt(b(i))) ^ 2).Sum)
1887             End If
1888         End Function
1889
1890         ''' <summary>
1891         ''' 计算两个向量之间的欧氏距离,请注意,这两个向量的长度必须要相等
1892         ''' </summary>
1893         ''' <param name="a">Point A</param>
1894         ''' <param name="b">Point B</param>
1895         ''' <returns></returns>
1896         <ExportAPI("Euclidean"Info:="Euclidean Distance")>
1897         <Extension> Public Function EuclideanDistance(a As Double(), b As Double()) As Double
1898             If a.Length <> b.Length Then
1899                 Return -1.0R
1900             Else
1901                 Return sys.Sqrt((From i As Integer In a.Sequence Select (a(i) - b(i)) ^ 2).Sum)
1902             End If
1903         End Function
1904
1905         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1906         <Extension>
1907         Public Function Distance(pt As (X#, Y#), x#, y#) As Double
1908             Return {pt.X, pt.Y}.EuclideanDistance({x, y})
1909         End Function
1910
1911         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1912         <ExportAPI("RangesAt")>
1913         <Extension> Public Function RangesAt(n As Double, LowerBound As Double, UpBound As DoubleAs Boolean
1914             Return n <= UpBound AndAlso n > LowerBound
1915         End Function
1916
1917         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1918         <ExportAPI("RangesAt")>
1919         <Extension> Public Function RangesAt(n As Integer, LowerBound As Double, UpBound As DoubleAs Boolean
1920             Return n <= UpBound AndAlso n > LowerBound
1921         End Function
1922
1923         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1924         <ExportAPI("RangesAt")>
1925         <Extension> Public Function RangesAt(n As Long, LowerBound As Double, UpBound As DoubleAs Boolean
1926             Return n <= UpBound AndAlso n > LowerBound
1927         End Function
1928
1929         ''' <summary>
1930         ''' Root mean square.(均方根)
1931         ''' </summary>
1932         ''' <returns></returns>
1933         ''' 
1934         <ExportAPI("RMS"Info:="Root mean square")>
1935         <Extension> Public Function RMS(data As IEnumerable(Of Double)) As Double
1936             With (From n In data Select n ^ 2).ToArray
1937                 Return sys.Sqrt(.Sum / .Length)
1938             End With
1939         End Function
1940
1941         ''' <summary>
1942         ''' ``相对标准偏差(RSD)= 标准偏差(SD)/ 计算结果的算术平均值(X)* 100%``
1943         ''' </summary>
1944         ''' <param name="data"></param>
1945         ''' <returns></returns>
1946         <Extension>
1947         Public Function RSD(data As IEnumerable(Of Double)) As Double
1948             Return data.SD / data.Average
1949         End Function
1950
1951         ''' <summary>
1952         ''' Returns the PDF value at x for the specified Poisson distribution.
1953         ''' </summary>
1954         ''' 
1955         <ExportAPI("Poisson.PDF"Info:="Returns the PDF value at x for the specified Poisson distribution.")>
1956         Public Function PoissonPDF(x As Integer, lambda As DoubleAs Double
1957             Dim result As Double = sys.Exp(-lambda)
1958             Dim k As Integer = x
1959
1960             While k >= 1
1961                 result *= lambda / k
1962                 k -= 1
1963             End While
1964
1965             Return result
1966         End Function
1967
1968         <MethodImpl(MethodImplOptions.AggressiveInlining)>
1969         <Extension>
1970         Public Function FormatNumeric(v As IEnumerable(Of Double), Optional digitals% = 2) As String()
1971             Return v.Select(Function(x) x.ToString("F" & digitals)).ToArray
1972         End Function
1973     End Module
1974 End Namespace