1 // Licensed to the .NET Foundation under one or more agreements.
2 // The .NET Foundation licenses this file to you under the MIT license.
3 // See the LICENSE file in the project root for more information.
4 
5 using System.Linq;
6 
7 namespace System.Numerics.Tests
8 {
9     public static class Util
10     {
11         private static Random s_random = new Random();
SetRandomSeed(int seed)12         public static void SetRandomSeed(int seed)
13         {
14             s_random = new Random(seed);
15         }
16 
17         /// <summary>
18         /// Generates random floats between 0 and 100.
19         /// </summary>
20         /// <param name="numValues">The number of values to generate</param>
21         /// <returns>An array containing the random floats</returns>
GenerateRandomFloats(int numValues)22         public static float[] GenerateRandomFloats(int numValues)
23         {
24             float[] values = new float[numValues];
25             for (int g = 0; g < numValues; g++)
26             {
27                 values[g] = (float)(s_random.NextDouble() * 99 + 1);
28             }
29             return values;
30         }
31 
32         /// <summary>
33         /// Generates random ints between 0 and 99, inclusive.
34         /// </summary>
35         /// <param name="numValues">The number of values to generate</param>
36         /// <returns>An array containing the random ints</returns>
GenerateRandomInts(int numValues)37         public static int[] GenerateRandomInts(int numValues)
38         {
39             int[] values = new int[numValues];
40             for (int g = 0; g < numValues; g++)
41             {
42                 values[g] = s_random.Next(1, 100);
43             }
44             return values;
45         }
46 
47         /// <summary>
48         /// Generates random doubles between 0 and 100.
49         /// </summary>
50         /// <param name="numValues">The number of values to generate</param>
51         /// <returns>An array containing the random doubles</returns>
GenerateRandomDoubles(int numValues)52         public static double[] GenerateRandomDoubles(int numValues)
53         {
54             double[] values = new double[numValues];
55             for (int g = 0; g < numValues; g++)
56             {
57                 values[g] = s_random.NextDouble() * 99 + 1;
58             }
59             return values;
60         }
61 
62         /// <summary>
63         /// Generates random doubles between 1 and 100.
64         /// </summary>
65         /// <param name="numValues">The number of values to generate</param>
66         /// <returns>An array containing the random doubles</returns>
GenerateRandomLongs(int numValues)67         public static long[] GenerateRandomLongs(int numValues)
68         {
69             long[] values = new long[numValues];
70             for (int g = 0; g < numValues; g++)
71             {
72                 values[g] = s_random.Next(1, 100) * (long.MaxValue / int.MaxValue);
73             }
74             return values;
75         }
76 
77         public static T[] GenerateRandomValues<T>(int numValues, int min = 1, int max = 100) where T : struct
78         {
79             T[] values = new T[numValues];
80             for (int g = 0; g < numValues; g++)
81             {
82                 values[g] = GenerateSingleValue<T>(min, max);
83             }
84 
85             return values;
86         }
87 
88         public static T GenerateSingleValue<T>(int min = 1, int max = 100) where T : struct
89         {
90             var randomRange = s_random.Next(min, max);
91             T value = unchecked((T)(dynamic)randomRange);
92             return value;
93         }
94 
95         public static T Abs<T>(T value) where T : struct
96         {
97             Type[] unsignedTypes = new[] { typeof(Byte), typeof(UInt16), typeof(UInt32), typeof(UInt64) };
98             if (unsignedTypes.Contains(typeof(T)))
99             {
100                 return value;
101             }
102 
103             dynamic dyn = (dynamic)value;
104             var abs = Math.Abs(dyn);
105             T ret = (T)abs;
106             return ret;
107         }
108 
109         public static T Sqrt<T>(T value) where T : struct
110         {
111             return unchecked((T)(dynamic)(Math.Sqrt((dynamic)value)));
112         }
113 
114         public static T Multiply<T>(T left, T right) where T : struct
115         {
116             return unchecked((T)((dynamic)left * right));
117         }
118 
119         public static T Divide<T>(T left, T right) where T : struct
120         {
121             return (T)((dynamic)left / right);
122         }
123 
124         public static T Add<T>(T left, T right) where T : struct
125         {
126             return unchecked((T)((dynamic)left + right));
127         }
128 
129         public static T Subtract<T>(T left, T right) where T : struct
130         {
131             return unchecked((T)((dynamic)left - right));
132         }
133 
134         public static T Xor<T>(T left, T right) where T : struct
135         {
136             return (T)((dynamic)left ^ right);
137         }
138 
139         public static T AndNot<T>(T left, T right) where T : struct
140         {
141             return (T)((dynamic)left & ~(dynamic)right);
142         }
143 
144         public static T OnesComplement<T>(T left) where T : struct
145         {
146             return unchecked((T)(~(dynamic)left));
147         }
Clamp(float value, float min, float max)148         public static float Clamp(float value, float min, float max)
149         {
150             return value > max ? max : value < min ? min : value;
151         }
152 
153         public static T Zero<T>() where T : struct
154         {
155             return (T)(dynamic)0;
156         }
157 
158         public static T One<T>() where T : struct
159         {
160             return (T)(dynamic)1;
161         }
162 
163         public static bool GreaterThan<T>(T left, T right) where T : struct
164         {
165             var result = (dynamic)left > right;
166             return (bool)result;
167         }
168 
169         public static bool GreaterThanOrEqual<T>(T left, T right) where T : struct
170         {
171             var result = (dynamic)left >= right;
172             return (bool)result;
173         }
174 
175         public static bool LessThan<T>(T left, T right) where T : struct
176         {
177             var result = (dynamic)left < right;
178             return (bool)result;
179         }
180 
181         public static bool LessThanOrEqual<T>(T left, T right) where T : struct
182         {
183             var result = (dynamic)left <= right;
184             return (bool)result;
185         }
186 
187         public static bool AnyEqual<T>(T[] left, T[] right) where T : struct
188         {
189             for (int g = 0; g < left.Length; g++)
190             {
191                 if (((IEquatable<T>)left[g]).Equals(right[g]))
192                 {
193                     return true;
194                 }
195             }
196             return false;
197         }
198 
199         public static bool AllEqual<T>(T[] left, T[] right) where T : struct
200         {
201             for (int g = 0; g < left.Length; g++)
202             {
203                 if (!((IEquatable<T>)left[g]).Equals(right[g]))
204                 {
205                     return false;
206                 }
207             }
208             return true;
209         }
210     }
211 }
212