/// <summary>
/// Produces a copy of this list in which the item order has been randomized.
/// </summary>
/// <returns>List containing items in random order.</returns>
public PFKeyValueList <K, V> Randomize()
{
PFKeyValueList <K, V> randomizedList = new PFKeyValueList <K, V>();
PFKeyValueListSorted <int, stKeyValuePair <K, V> > sortList = new PFKeyValueListSorted <int, stKeyValuePair <K, V> >();
RandomNumber rnd = new RandomNumber();
int min = 0;
int max = 200000000;
for (int i = 0; i < this.Count; i++)
{
stKeyValuePair <K, V> item = this[i];
int key = rnd.GenerateRandomNumber(min, max);
sortList.Add(key, item);
}
IEnumerator <KeyValuePair <int, stKeyValuePair <K, V> > > enumerator = sortList.GetEnumerator();
while (enumerator.MoveNext())
{
// Get current key value pair
stKeyValuePair <int, stKeyValuePair <K, V> > keyValuePair = new stKeyValuePair <int, stKeyValuePair <K, V> >(enumerator.Current.Key, enumerator.Current.Value);
randomizedList.Add(keyValuePair.Value);
}
return(randomizedList);
}
public bool SendVerificationCodeSms(User user)
{
MobileVerificationCode vCode = new MobileVerificationCode
{
MobileNumber = user.MobileNumber,
IsVerified = false,
CreationDateTime = DateTime.Now,
CreatedByUserId = user.Id
};
RandomNumber myrand = new RandomNumber();
vCode.Code = myrand.GenerateRandomNumber(4);
_UnitOfWork.MobileVerificationCodeRepository.Add(vCode);
int count = _UnitOfWork.Complete();
if (count == 1)
{
SmsService sms = new SmsService();
var smsSent = true; // sms.SendVerificationCode(user.MobileNumber, vCode.Code);
if (smsSent)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public void SpawnEnemies()
{
if (RandomNumber.GenerateRandomNumber(0, 20000) < 2 && enemyCount < maxEnemyCount)
{
Instantiate(enemy, this.transform.position, new Quaternion(0, 0, 0, 0));
enemyCount++;
}
}
// Update is called once per frame
void Update()
{
if (RandomNumber.GenerateRandomNumber(0, 100000) < 5 && trashCount < maxTrashCount)
{
Instantiate(trash, this.transform.position, new Quaternion(0, 0, 0, 0));
trashCount++;
}
}
public Flight(string flightno, string flighttime, int totalseats, string origin, string destination)
{
FlightNo = flightno;
FlightTime = flighttime;
TotalSeats = totalseats;
Origin = origin;
Destination = destination;
AvailableSeats = RandomNumber.GenerateRandomNumber(3, 7);
}
private enNameLanguage GetLanguage(enCountry country)
{
enNameLanguage language = enNameLanguage.NotSpecified;
double percentCanadaEnglish = 80.0;
double minValue = 1.0;
double maxValue = 100.0;
if (country == enCountry.UnitedStates)
{
language = enNameLanguage.US;
}
else if (country == enCountry.Mexico)
{
language = enNameLanguage.Spanish;
}
else
{
Double randNum = _rn.GenerateRandomNumber(minValue, maxValue);
language = randNum <= percentCanadaEnglish ? enNameLanguage.English : enNameLanguage.French;
}
return(language);
}
/// <summary>
/// Creates a set of true/false values expressed as numbers.
/// </summary>
/// <param name="numRows">Number of random values to generate.</param>
/// <param name="percentOutputValuesAsTrue">Percentage of output values to be true.</param>
/// <param name="percentOutputValuesAsFalse">Percentage of output values to be false.</param>
/// <param name="numType">Use enRandomNumberType enum to specify type of numbers to generate.</param>
/// <param name="trueValue">The numeric value for True booleans (e.g. 1).</param>
/// <param name="falseValue">The numeric value for False booleans (e.g. 0)</param>
/// <returns>ADO.NET DataTable containing the set of random values.</returns>
/// <remarks>If percentOutputValuesAsTrue and percentOutputValuesAsFalse do not add up to 100, you will get unexpected results.</remarks>
public DataTable CreateNumericDataTable(int numRows, string percentOutputValuesAsTrue, string percentOutputValuesAsFalse, enRandomNumberType numType, string trueValue, string falseValue)
{
DataTable dt = new DataTable();
RandomNumber rn = new RandomNumber();
try
{
Double percentTrueValues = Convert.ToDouble(percentOutputValuesAsTrue);
Double percentFalseValues = Convert.ToDouble(percentOutputValuesAsFalse);
double minValue = 1.0;
double maxValue = 100.0;
DataColumn dc = new DataColumn("RandomValue");
dc.DataType = numberType[(int)numType];
dt.Columns.Add(dc);
for (int i = 0; i < numRows; i++)
{
DataRow dr = dt.NewRow();
Double randNum = rn.GenerateRandomNumber(minValue, maxValue);
if (randNum <= percentTrueValues)
{
dr[0] = Convert.ChangeType(trueValue, numberType[(int)numType]);
}
else
{
//randNum > percentTrueValues //is false
dr[0] = Convert.ChangeType(falseValue, numberType[(int)numType]);
}
dt.Rows.Add(dr);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateNumericDataTable routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
/// <summary>
/// Creates a set of true/false values expressed as strings.
/// </summary>
/// <param name="numRows">Number of random values to generate.</param>
/// <param name="percentOutputValuesAsTrue">Percentage of output values to be true.</param>
/// <param name="percentOutputValuesAsFalse">Percentage of output values to be false.</param>
/// <param name="trueValue">The string value for True booleans (e.g. "true").</param>
/// <param name="falseValue">The string value for False booleans (e.g. "false")</param>
/// <returns>ADO.NET DataTable containing the set of random values.</returns>
/// <remarks>If percentOutputValuesAsTrue and percentOutputValuesAsFalse do not add up to 100, you will get unexpected results.</remarks>
public DataTable CreateStringDataTable(int numRows, string percentOutputValuesAsTrue, string percentOutputValuesAsFalse, string trueValue, string falseValue)
{
DataTable dt = new DataTable();
RandomNumber rn = new RandomNumber();
try
{
Double percentTrueValues = Convert.ToDouble(percentOutputValuesAsTrue);
Double percentFalseValues = Convert.ToDouble(percentOutputValuesAsFalse);
double minValue = 1.0;
double maxValue = 100.0;
DataColumn dc = new DataColumn("RandomValue");
dc.DataType = Type.GetType("System.String");
dt.Columns.Add(dc);
for (int i = 0; i < numRows; i++)
{
DataRow dr = dt.NewRow();
Double randNum = rn.GenerateRandomNumber(minValue, maxValue);
string randString = randNum <= percentTrueValues ? trueValue : falseValue;
dr[0] = randString;
dt.Rows.Add(dr);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateStringDataTable routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
// Use this for initialization
void Start()
{
random1 = RandomNumber.GenerateRandomNumber(0, 20);
if (random1 < 5)
{
moveUp = true;
}
if (random1 >= 5 && random1 <= 10)
{
moveDown = true;
}
if (random1 >= 10 && random1 <= 15)
{
moveRight = true;
}
if (random1 >= 15 && random1 <= 20)
{
moveLeft = true;
}
}
/// <summary>
/// Creates set of random numbers that fall within a pre-defined range of numbers.
/// </summary>
/// <param name="numType">Type of number to generate (e.g. Int32, Int64, etc.)</param>
/// <param name="numRows">Number of random numbers to generate.</param>
/// <param name="fromNumber">Minimum value of defined number range.</param>
/// <param name="toNumber">Maximum value of defined number range.</param>
/// <returns>ADO.NET DataTable containing the set of random values.</returns>
public DataTable CreateRangeDataTable(enRandomNumberType numType, int numRows, string fromNumber, string toNumber)
{
DataTable dt = new DataTable();
RandomNumber rn = new RandomNumber();
try
{
Double fromNum = Convert.ToDouble(fromNumber);
Double toNum = Convert.ToDouble(toNumber);
DataColumn dc = new DataColumn("RandomValue");
dc.DataType = numberType[(int)numType];
dt.Columns.Add(dc);
for (int i = 0; i < numRows; i++)
{
DataRow dr = dt.NewRow();
Double randNum = rn.GenerateRandomNumber(fromNum, toNum);
dr[0] = Convert.ChangeType(randNum, numberType[(int)numType]);
dt.Rows.Add(dr);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateRangeDataTable routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
public static byte[] GenerateSalt()
{
const int saltLength = 32;
return(RandomNumber.GenerateRandomNumber(saltLength));
}
void ChangeDirections()
{
if (checkDown && moveDown)
{
random2 = RandomNumber.GenerateRandomNumber(0, 15);
if (random2 <= 5)
{
moveUp = true;
moveLeft = false;
moveDown = false;
moveRight = false;
}
else if (random2 > 5 && random2 <= 10)
{
moveLeft = true;
moveUp = false;
moveDown = false;
moveRight = false;
}
else
{
moveRight = true;
moveLeft = false;
moveDown = false;
moveUp = false;
}
}
if (checkUp && moveUp)
{
random2 = RandomNumber.GenerateRandomNumber(0, 15);
if (random2 <= 5)
{
moveDown = true;
moveLeft = false;
moveUp = false;
moveRight = false;
}
else if (random2 > 5 && random2 <= 10)
{
moveLeft = true;
moveUp = false;
moveDown = false;
moveRight = false;
}
else
{
moveRight = true;
moveLeft = false;
moveDown = false;
moveUp = false;
}
}
if ((checkRight && moveRight))
{
random2 = RandomNumber.GenerateRandomNumber(0, 15);
if (random2 <= 5)
{
moveUp = true;
moveLeft = false;
moveDown = false;
moveRight = false;
}
else if (random2 > 5 && random2 <= 10)
{
moveLeft = true;
moveUp = false;
moveDown = false;
moveRight = false;
}
else
{
moveDown = true;
moveLeft = false;
moveUp = false;
moveRight = false;
}
}
if ((checkLeft && moveLeft) || (checkForRecyclingPlant && moveLeft))
{
random2 = RandomNumber.GenerateRandomNumber(0, 15);
if (random2 <= 5)
{
moveUp = true;
moveLeft = false;
moveDown = false;
moveRight = false;
}
else if (random2 > 5 && random2 <= 10)
{
moveDown = true;
moveLeft = false;
moveUp = false;
moveRight = false;
}
else
{
moveRight = true;
moveLeft = false;
moveDown = false;
moveUp = false;
}
}
}
/// <summary>
/// Creates set of random DateTime values that fall within a defined range.
/// </summary>
/// <param name="numRows">Number of random DataTime values to generate. </param>
/// <param name="fromDate">Minimum date to generate.</param>
/// <param name="toDate">Maximum date to generate.</param>
/// <param name="generateRandomTime">Set to true to generate a time value as part of the DateTime value being generated.</param>
/// <param name="fromTime">Minimum time to generate.</param>
/// <param name="toTime">Maximum time to generate.</param>
/// <param name="dateConversionType">Determines whether or not to convert the DateTime value to an integer. Useful for data warehousing scenarios.</param>
/// <returns>ADO.NET DataTable containing the set of random values.</returns>
public DataTable CreateRangeDataTable(int numRows, string fromDate, string toDate, bool generateRandomTime, string fromTime, string toTime, enDateConversionType dateConversionType)
{
DataTable dt = new DataTable();
try
{
TimeSpan fromDateTs = Convert.ToDateTime(fromDate).Subtract(DateTime.MinValue);
TimeSpan toDateTs = Convert.ToDateTime(toDate).Subtract(DateTime.MinValue);
double fromDays = fromDateTs.TotalDays;
double toDays = toDateTs.TotalDays;
TimeSpan fromTimeTs = Convert.ToDateTime(fromTime).TimeOfDay;
TimeSpan toTimeTs = Convert.ToDateTime(toTime).TimeOfDay;
double fromSeconds = fromTimeTs.TotalSeconds;
double toSeconds = toTimeTs.TotalSeconds;
DataColumn dc = new DataColumn("RandomValue");
switch (dateConversionType)
{
case enDateConversionType.DoNotConvert:
dc.DataType = Type.GetType("System.DateTime");
break;
case enDateConversionType.ConvertDateTo32bitInt:
dc.DataType = Type.GetType("System.Int32");
break;
case enDateConversionType.ConvertTimeTo32bitInt:
dc.DataType = Type.GetType("System.Int32");
break;
case enDateConversionType.ConvertDateTimeTo64bitInt:
dc.DataType = Type.GetType("System.Int64");
break;
default:
dc.DataType = Type.GetType("System.DateTime");
break;
}
dt.Columns.Add(dc);
for (int i = 0; i < numRows; i++)
{
DataRow dr = dt.NewRow();
Double randNum = _rn.GenerateRandomNumber(fromDays, toDays);
TimeSpan ts = new TimeSpan((int)randNum, 0, 0, 0, 0);
DateTime dtm = DateTime.MinValue.Add(ts);
if (generateRandomTime)
{
randNum = _rn.GenerateRandomNumber(fromSeconds, toSeconds);
TimeSpan ts2 = new TimeSpan(0, 0, 0, (int)randNum, 0);
dtm = dtm.AddSeconds(ts2.TotalSeconds);
}
//dr[0] = dtm;
switch (dateConversionType)
{
case enDateConversionType.DoNotConvert:
dr[0] = dtm;
break;
case enDateConversionType.ConvertDateTo32bitInt:
dr[0] = Convert.ToInt32(dtm.ToString("yyyyMMdd"));
break;
case enDateConversionType.ConvertTimeTo32bitInt:
dr[0] = Convert.ToInt32(dtm.ToString("HHmmss"));
break;
case enDateConversionType.ConvertDateTimeTo64bitInt:
dr[0] = Convert.ToInt64(dtm.ToString("yyyyMMddHHmmss"));
break;
default:
dr[0] = dtm;
break;
}
dt.Rows.Add(dr);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateRangeDataTable routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
/// <summary>
/// Creates a set of offset values that can be used to decrease or increase existing values by the calling program. This routine also allows display of results on a form in a grid. Random offset, base value and adjuted base value can be displayed in the grid.
/// </summary>
/// <param name="numType">Type of offset number to generate (e.g. Int32, Int64, etc.)</param>
/// <param name="numRows">Number of random offset numbers to generate.</param>
/// <param name="minPercent">Minimum offset percent for offset.</param>
/// <param name="maxPercent">Maximum offset percent for offset.</param>
/// <returns>ADO.NET DataTable containing the set of random values.</returns>
/// <remarks>Any negative percent values will decrease a value. Positive percent values 100 will increase a value.
/// For example, min -50 percent max +50 percent means offsets will range from 50 percent less to 50 percent more.</remarks>
/// <remarks>Offset will be expressed in terms of the following base values: 10000 for short integers, 10 for byte sized integers, 1000000 for all other numeric types.
/// For example, min to max definition of -50 percent to +50 percent for int32 numbers, will return values ranging from -500000 to +500000. You can use these offsets to calculate a percentage to use in modifying an existing value.
/// For example, if current value for an Int32 in a table is 100 and offset is -500000, modified value = currentvalue * (-500000/ 1000000) or currentvalue = currentvalue * (offset / basevalue) </remarks>
public DataTable CreateOffsetDataTablePreview(enRandomNumberType numType, int numRows, string minPercent, string maxPercent)
{
DataTable dt = new DataTable();
RandomNumber rn = new RandomNumber();
try
{
Double minPct = Convert.ToDouble(minPercent) / 100.0;
Double maxPct = Convert.ToDouble(maxPercent) / 100.0;
Double currValue = 1000.0;
Double currValueMin = 1000.0;
Double currValueIncrement = 500.0;
Double currValueMax = 5000.0;
if (numType == enRandomNumberType.enByte || numType == enRandomNumberType.enSByte)
{
currValue = 10.0;
currValueMin = 10.0;
currValueIncrement = 5.0;
currValueMax = 50.0;
}
DataColumn dc = new DataColumn("RandomValue");
dc.DataType = numberType[(int)numType];
dt.Columns.Add(dc);
DataColumn dc2 = new DataColumn("CurrentValue");
dc2.DataType = numberType[(int)numType];
dt.Columns.Add(dc2);
DataColumn dc3 = new DataColumn("OffsetValue");
dc3.DataType = numberType[(int)numType];
dt.Columns.Add(dc3);
for (int i = 0; i < numRows; i++)
{
if (currValue > currValueMax)
{
currValue = currValueMin;
}
Double minNum = currValue + (currValue * minPct) + 1.0;
Double maxNum = currValue + (currValue * maxPct) + 1.0;
DataRow dr = dt.NewRow();
Double randNum = rn.GenerateRandomNumber(minNum, maxNum);
Double randOffset = randNum - currValue;
if (randNum < numberTypeMinMaxVals[(int)numType].minVal)
{
dr[0] = Convert.ChangeType(numberTypeMinMaxVals[(int)numType].minVal + 1, numberType[(int)numType]);
}
else if (randNum > numberTypeMinMaxVals[(int)numType].maxVal)
{
dr[0] = Convert.ChangeType(numberTypeMinMaxVals[(int)numType].maxVal - 1, numberType[(int)numType]);
}
else
{
dr[0] = Convert.ChangeType(randNum, numberType[(int)numType]);
}
dr[1] = Convert.ChangeType(currValue, numberType[(int)numType]);
dr[2] = Convert.ChangeType(randOffset, numberType[(int)numType]);
dt.Rows.Add(dr);
currValue += currValueIncrement;
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateIntNumberRangeDataTable routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
/// <summary>
/// Creates a set of offset values that can be used to decrease or increase existing values by the calling program.
/// </summary>
/// <param name="numType">Type of offset number to generate (e.g. Int32, Int64, etc.)</param>
/// <param name="numRows">Number of random offset numbers to generate.</param>
/// <param name="minPercent">Minimum offset percent for offset.</param>
/// <param name="maxPercent">Maximum offset percent for offset.</param>
/// <returns>ADO.NET DataTable containing the set of random values.</returns>
/// <remarks>Any negative percent values will decrease a value. Positive percent values 100 will increase a value.
/// For example, min -50 percent max +50 percent means offsets will range from 50 percent less to 50 percent more.</remarks>
/// <remarks>Offset will be expressed in terms of the following base values: 10000 for short integers, 10 for byte sized integers, 1000000 for all other numeric types.
/// For example, min to max definition of -50 percent to +50 percent for int32 numbers, will return values ranging from -500000 to +500000. You can use these offsets to calculate a percentage to use in modifying an existing value.
/// Example, if current value for an Int32 in a table is 100 and offset is -500000, modified value = currentvalue * (-500000/ 1000000) or currentvalue = currentvalue * (offset / basevalue).</remarks>
public DataTable CreateOffsetDataTable(enRandomNumberType numType, int numRows, string minPercent, string maxPercent)
{
DataTable dt = new DataTable();
RandomNumber rn = new RandomNumber();
try
{
Double minPct = Convert.ToDouble(minPercent) / 100.0;
Double maxPct = Convert.ToDouble(maxPercent) / 100.0;
Double baseValue = 1000.0;
if (numType == enRandomNumberType.enShort || numType == enRandomNumberType.enUShort)
{
baseValue = 10000;
}
else if (numType == enRandomNumberType.enByte || numType == enRandomNumberType.enSByte)
{
baseValue = 10.0;
}
else if (numType == enRandomNumberType.enInt || numType == enRandomNumberType.enUInt ||
numType == enRandomNumberType.enLong || numType == enRandomNumberType.enULong ||
numType == enRandomNumberType.enDouble || numType == enRandomNumberType.enFloat)
{
baseValue = 1000000;
}
else
{
//is a float number (.NET Single)
baseValue = 100000;
}
DataColumn dc = new DataColumn("RandomValue");
dc.DataType = Type.GetType("System.Double");
dt.Columns.Add(dc);
DataColumn dc2 = new DataColumn("BaseValue");
dc2.DataType = Type.GetType("System.Double");
dt.Columns.Add(dc2);
DataColumn dc3 = new DataColumn("NewValueAfterOffset");
dc3.DataType = numberType[(int)numType];
dt.Columns.Add(dc3);
for (int i = 0; i < numRows; i++)
{
Double minNum = baseValue + (baseValue * minPct) + 1.0;
Double maxNum = baseValue + (baseValue * maxPct) + 1.0;
DataRow dr = dt.NewRow();
Double randNum = rn.GenerateRandomNumber(minNum, maxNum);
Double randOffset = randNum - baseValue;
if (randNum < numberTypeMinMaxVals[(int)numType].minVal)
{
dr[0] = numberTypeMinMaxVals[(int)numType].minVal + 1; //Convert.ChangeType(numberTypeMinMaxVals[(int)numType].minVal + 1, numberType[(int)numType]);
}
else if (randNum > numberTypeMinMaxVals[(int)numType].maxVal)
{
dr[0] = numberTypeMinMaxVals[(int)numType].maxVal - 1; //Convert.ChangeType(numberTypeMinMaxVals[(int)numType].maxVal - 1, numberType[(int)numType]);
}
else
{
dr[0] = randOffset; // Convert.ChangeType(randNum, numberType[(int)numType]);
}
dr[1] = baseValue;
Double newValueAfterOffset = baseValue + (double)dr[0];
dr[2] = Convert.ChangeType(newValueAfterOffset, numberType[(int)numType]);
dt.Rows.Add(dr);
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Error in CreateIntNumberRangeDataTable routine.\r\n");
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
;
}
return(dt);
}
