/// <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); }