/// <summary>
/// Generates the integers and stores them in a text file
/// </summary>
/// <param name="options">The parsed command line options</param>
/// <param name="updateIntegerGenerationStatus">A callback method that will be called to update
/// the status of integer generation</param>
static void GenerateIntegers(CommandLineOptions options, Action <int> updateIntegerGenerationStatus)
{
//Get an instance of the integer file creator
IIntegerFileCreator integerFileCreator = serviceProvider.GetService <IIntegerFileCreator>();
//Get an instance of the random integer generator
IRandomIntegerGenerator randomIntegerGenerator = serviceProvider.GetService <IRandomIntegerGenerator>();
//Create the random integers. The IEnumerable is actually a generator, so it generates them one at a time as
//it is enumerated rather than a whole bunch at once
IEnumerable <int> randomIntegers = randomIntegerGenerator.CreateIntegerGenerator(options.LowerBound,
options.UpperBound, (int)options.Count);
int integersGenerated = 0;
//When an integer is enumerated, update the integer generation status
randomIntegers = randomIntegers.Select(integer =>
{
integersGenerated++;
updateIntegerGenerationStatus(integersGenerated);
return(integer);
});
//Create the integer file with the randomly-generated integers
integerFileCreator.CreateIntegerTextFile(randomIntegers, options.FilePath);
}
public QuestionGenerator(IRandomIntegerGenerator randomIntegerGenerator, TParameters parameters)
{
this.randomIntegerGenerator = randomIntegerGenerator;
this.parameters = parameters;
ConstructorForQuestion = ComputeContructorForQuestion();
ContructorForParameters = ComputeContructorForParameters();
}
/// <summary>
/// Initialises a new instance of the MoreComplexDataStructures.UniqueRandomGenerator class.
/// </summary>
/// <param name="rangeStart">The inclusive start of the range to generate random numbers from.</param>
/// <param name="rangeEnd">The inclusive end of the range to generate random numbers from.</param>
/// <exception cref="System.ArgumentException">Parameter 'rangeEnd' is less than parameter 'rangeStart'.</exception>
/// <exception cref="System.ArgumentException">The total inclusive range exceeds Int64.MaxValue.</exception>
public UniqueRandomGenerator(Int64 rangeStart, Int64 rangeEnd)
{
if (rangeEnd < rangeStart)
{
throw new ArgumentException($"Parameter '{nameof(rangeEnd)}' must be greater than or equal to parameter '{nameof(rangeStart)}'.", nameof(rangeEnd));
}
if (rangeStart < 1)
{
if (rangeStart + Int64.MaxValue <= rangeEnd)
{
throw new ArgumentException("The total inclusive range cannot exceed Int64.MaxValue.", nameof(rangeEnd));
}
}
else if (rangeEnd > -2)
{
if (rangeEnd - Int64.MaxValue >= rangeStart)
{
throw new ArgumentException("The total inclusive range cannot exceed Int64.MaxValue.", nameof(rangeEnd));
}
}
rangeTree = new RangeTree();
var baseRange = new LongIntegerRange(rangeStart, rangeEnd - rangeStart + 1);
var baseRangeAndCounts = new RangeAndSubtreeCounts(baseRange, 0, 0);
rangeTree.Add(baseRangeAndCounts);
this.rangeStart = rangeStart;
this.rangeEnd = rangeEnd;
numbersGeneratedCount = 0;
randomGenerator = new DefaultRandomGenerator();
}
public QuestionController(IRandomIntegerGenerator randomIntegerGenerator, Func <IRandomIntegerGenerator,
TQuestionGenerator> questionGeneratorConstructor, ILogger logger)
{
this.randomIntegerGenerator = randomIntegerGenerator;
this.questionGeneratorConstructor = questionGeneratorConstructor;
this.logger = logger;
}
/// <summary>
/// Initialises a new instance of the MoreComplexDataStructures.WeightedRandomGenerator class.
/// </summary>
public WeightedRandomGenerator()
{
randomGenerator = new DefaultRandomGenerator();
weightingRangesAndItems = new WeightBalancedTree <ItemAndWeighting <T> >();
itemToWeightingMap = new Dictionary <T, LongIntegerRange>();
weightingsTotal = 0;
weightingStartOffset = 0;
}
public PdfBuilderController(IRandomIntegerGenerator randomIntegerGenerator, IMailSender mailSender,
QuestionGeneratorContext context, ILogger logger)
{
this.randomIntegerGenerator = randomIntegerGenerator;
this.mailSender = mailSender;
this.context = context;
queries = new DatabaseQueries(context);
this.logger = logger;
}
public QuadraticEquationController(IRandomIntegerGenerator randomIntegerGenerator, ILogger <QuadraticEquationController> logger)
{
this.randomIntegerGenerator = randomIntegerGenerator;
this.logger = logger;
}
public PolynomialEquationGenerator(IRandomIntegerGenerator randomIntegerGenerator, PolynomialEquationGeneratorParameters parameters)
: base(randomIntegerGenerator, parameters)
{
}
public LinearSimultaneousEquationsGenerator(IRandomIntegerGenerator randomIntegerGenerator, LinearSimultaneousEquationsGeneratorParameters parameters)
: base(randomIntegerGenerator, parameters)
{
}
public QuadraticEquationGenerator(IRandomIntegerGenerator randomIntegerGenerator, QuadraticEquationGeneratorParameters parameters)
: base(randomIntegerGenerator, parameters)
{
}
public CramMd5MechanismProcessor(IConnection connection, IRandomIntegerGenerator random, ICurrentDateTimeProvider dateTimeProvider) : base(connection)
{
_random = random;
_dateTimeProvider = dateTimeProvider;
}
public CramMd5MechanismProcessor(IConnection connection, IRandomIntegerGenerator random, ICurrentDateTimeProvider dateTimeProvider)
{
Connection = connection;
_random = random;
_dateTimeProvider = dateTimeProvider;
}
public void RemoveWeighting()
{
IRandomIntegerGenerator mockRandomIntegerGenerator = mockery.NewMock <IRandomIntegerGenerator>();
testWeightedRandomGenerator = new WeightedRandomGenerator <Char>(mockRandomIntegerGenerator);
// Add the test weightings
// Initial weighting ranges can be visualised as follows...
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
// | | | | | |
// a b c d e f
testWeightedRandomGenerator.SetWeightings(new List <Tuple <Char, Int64> >()
{
new Tuple <Char, Int64>('a', 3),
new Tuple <Char, Int64>('b', 1),
new Tuple <Char, Int64>('c', 3),
new Tuple <Char, Int64>('d', 2),
new Tuple <Char, Int64>('e', 4),
new Tuple <Char, Int64>('f', 5)
});
// Test shuffling up the values of all the ranges lower than the one removed
// Weighting ranges after removing 'c' can be visualised as follows...
// 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
// | | | | |
// a b d e f
testWeightedRandomGenerator.RemoveWeighting('c');
Dictionary <Int64, Int64> treeContents = GetAllWeightingRanges(testWeightedRandomGenerator);
Assert.AreEqual(5, treeContents.Count);
Assert.AreEqual(3, treeContents[3]);
Assert.AreEqual(1, treeContents[6]);
Assert.AreEqual(2, treeContents[7]);
Assert.AreEqual(4, treeContents[9]);
Assert.AreEqual(5, treeContents[13]);
// Test that the Generate() method still works correctly
mockery.ClearExpectation(mockRandomIntegerGenerator);
using (mockery.Ordered)
{
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(15L).Will(Return.Value(14L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(15L).Will(Return.Value(10L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(15L).Will(Return.Value(9L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(15L).Will(Return.Value(6L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(15L).Will(Return.Value(5L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(15L).Will(Return.Value(4L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(15L).Will(Return.Value(3L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(15L).Will(Return.Value(2L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(15L).Will(Return.Value(0L));
}
Char result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('f', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('f', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('e', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('e', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('d', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('d', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('b', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('a', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('a', result);
mockery.VerifyAllExpectationsHaveBeenMet();
// Test shuffling down the values of all the ranges higher than the one removed
// Weighting ranges after removing 'd' can be visualised as follows...
// 3 4 5 6 7 8 9 10 11 12 13 14 15 16
// | | | |
// a b e f
testWeightedRandomGenerator.RemoveWeighting('d');
treeContents = GetAllWeightingRanges(testWeightedRandomGenerator);
Assert.AreEqual(4, treeContents.Count);
Assert.AreEqual(3, treeContents[3]);
Assert.AreEqual(1, treeContents[6]);
Assert.AreEqual(4, treeContents[7]);
Assert.AreEqual(5, treeContents[11]);
// Test that the Generate() method still works correctly
mockery.ClearExpectation(mockRandomIntegerGenerator);
using (mockery.Ordered)
{
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(13L).Will(Return.Value(12L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(13L).Will(Return.Value(8L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(13L).Will(Return.Value(7L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(13L).Will(Return.Value(4L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(13L).Will(Return.Value(3L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(13L).Will(Return.Value(2L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(13L).Will(Return.Value(0L));
}
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('f', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('f', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('e', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('e', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('b', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('a', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('a', result);
mockery.VerifyAllExpectationsHaveBeenMet();
// Test removing the lowest range
// Weighting ranges after removing 'a' can be visualised as follows...
// 6 7 8 9 10 11 12 13 14 15 16
// | | |
// b e f
testWeightedRandomGenerator.RemoveWeighting('a');
treeContents = GetAllWeightingRanges(testWeightedRandomGenerator);
Assert.AreEqual(3, treeContents.Count);
Assert.AreEqual(1, treeContents[6]);
Assert.AreEqual(4, treeContents[7]);
Assert.AreEqual(5, treeContents[11]);
// Test that the Generate() method still works correctly
mockery.ClearExpectation(mockRandomIntegerGenerator);
using (mockery.Ordered)
{
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(10L).Will(Return.Value(9L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(10L).Will(Return.Value(5L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(10L).Will(Return.Value(4L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(10L).Will(Return.Value(1L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(10L).Will(Return.Value(0L));
}
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('f', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('f', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('e', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('e', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('b', result);
mockery.VerifyAllExpectationsHaveBeenMet();
// Test removing the highest range
// Weighting ranges after removing 'f' can be visualised as follows...
// 6 7 8 9 10 11
// | |
// b e
testWeightedRandomGenerator.RemoveWeighting('f');
treeContents = GetAllWeightingRanges(testWeightedRandomGenerator);
Assert.AreEqual(2, treeContents.Count);
Assert.AreEqual(1, treeContents[6]);
Assert.AreEqual(4, treeContents[7]);
// Test that the Generate() method still works correctly
mockery.ClearExpectation(mockRandomIntegerGenerator);
using (mockery.Ordered)
{
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(5L).Will(Return.Value(4L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(5L).Will(Return.Value(1L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(5L).Will(Return.Value(0L));
}
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('e', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('e', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('b', result);
mockery.VerifyAllExpectationsHaveBeenMet();
// Remove all remaining, and then set the weights again to ensure that field 'weightingStartOffset' is reset to 0
testWeightedRandomGenerator.RemoveWeighting('b');
testWeightedRandomGenerator.RemoveWeighting('e');
testWeightedRandomGenerator.SetWeightings(new List <Tuple <Char, Int64> >()
{
new Tuple <Char, Int64>('g', 5)
});
treeContents = GetAllWeightingRanges(testWeightedRandomGenerator);
Assert.AreEqual(1, treeContents.Count);
Assert.AreEqual(5, treeContents[0]);
// Test that the Generate() method still works correctly
mockery.ClearExpectation(mockRandomIntegerGenerator);
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(5L).Will(Return.Value(4L));
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('g', result);
}
public void Generate()
{
IRandomIntegerGenerator mockRandomIntegerGenerator = mockery.NewMock <IRandomIntegerGenerator>();
testWeightedRandomGenerator = new WeightedRandomGenerator <Char>(mockRandomIntegerGenerator);
// Test with a single weighting of 1
using (mockery.Ordered)
{
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(1L).Will(Return.Value(0L));
}
testWeightedRandomGenerator.SetWeightings(new List <Tuple <Char, Int64> >()
{
new Tuple <Char, Int64>('a', 1)
});
Char result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('a', result);
mockery.VerifyAllExpectationsHaveBeenMet();
// Test with 2 weightings, first a single value of 1, and the second the entire remaining space in the (Int64.MaxValue - 1) range
mockery.ClearExpectation(mockRandomIntegerGenerator);
List <Tuple <Char, Int64> > weightings = new List <Tuple <Char, Int64> >
{
new Tuple <Char, Int64>('a', 1),
new Tuple <Char, Int64>('b', Int64.MaxValue - 1)
};
using (mockery.Ordered)
{
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(Int64.MaxValue).Will(Return.Value(0L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(Int64.MaxValue).Will(Return.Value(1L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(Int64.MaxValue).Will(Return.Value(Int64.MaxValue - 1));
}
testWeightedRandomGenerator.SetWeightings(weightings);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('a', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('b', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('b', result);
mockery.VerifyAllExpectationsHaveBeenMet();
// Test with 2 weightings, first with (Int64.MaxValue - 1) range, and the second with 1
mockery.ClearExpectation(mockRandomIntegerGenerator);
weightings = new List <Tuple <Char, Int64> >
{
new Tuple <Char, Int64>('a', Int64.MaxValue - 1),
new Tuple <Char, Int64>('b', 1)
};
using (mockery.Ordered)
{
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(Int64.MaxValue).Will(Return.Value(0L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(Int64.MaxValue).Will(Return.Value(Int64.MaxValue - 2));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(Int64.MaxValue).Will(Return.Value(Int64.MaxValue - 1));
}
testWeightedRandomGenerator.SetWeightings(weightings);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('a', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('a', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('b', result);
mockery.VerifyAllExpectationsHaveBeenMet();
// Test with more standard weightings
mockery.ClearExpectation(mockRandomIntegerGenerator);
weightings = new List <Tuple <Char, Int64> >
{
new Tuple <Char, Int64>('a', 1),
new Tuple <Char, Int64>('b', 2),
new Tuple <Char, Int64>('c', 4)
};
using (mockery.Ordered)
{
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(7L).Will(Return.Value(0L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(7L).Will(Return.Value(1L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(7L).Will(Return.Value(2L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(7L).Will(Return.Value(3L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(7L).Will(Return.Value(4L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(7L).Will(Return.Value(5L));
Expect.Once.On(mockRandomIntegerGenerator).Method("Next").With(7L).Will(Return.Value(6L));
}
testWeightedRandomGenerator.SetWeightings(weightings);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('a', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('b', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('b', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('c', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('c', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('c', result);
result = testWeightedRandomGenerator.Generate();
Assert.AreEqual('c', result);
mockery.VerifyAllExpectationsHaveBeenMet();
}
public LinearSimultaneousEquationsController(IRandomIntegerGenerator randomIntegerGenerator, ILogger logger)
{
this.randomIntegerGenerator = randomIntegerGenerator;
this.logger = logger;
}
/// <summary>
/// Initialises a new instance of the MoreComplexDataStructures.UniqueRandomGenerator class.
/// </summary>
/// <param name="rangeStart">The inclusive start of the range to generate random numbers from.</param>
/// <param name="rangeEnd">The inclusive end of the range to generate random numbers from.</param>
/// <param name="randomIntegerGenerator">An implementation of interface IRandomIntegerGenerator to use for selecting random items.</param>
/// <exception cref="System.ArgumentException">Parameter 'rangeEnd' is less than parameter 'rangeStart'.</exception>
/// <exception cref="System.ArgumentException">The total inclusive range exceeds Int64.MaxValue.</exception>
public UniqueRandomGenerator(Int64 rangeStart, Int64 rangeEnd, IRandomIntegerGenerator randomIntegerGenerator)
: this(rangeStart, rangeEnd)
{
randomGenerator = randomIntegerGenerator;
}
/// <summary>
/// Initialises a new instance of the MoreComplexDataStructures.ListRandomizer class.
/// </summary>
/// <param name="randomIntegerGenerator">An implementation of interface IRandomIntegerGenerator to use for selecting random items.</param>
public WeightedRandomGenerator(IRandomIntegerGenerator randomIntegerGenerator)
: this()
{
randomGenerator = randomIntegerGenerator;
}
/// <summary>
/// Initialises a new instance of the MoreComplexDataStructures.ListRandomizer class.
/// </summary>
public ListRandomizer()
{
randomGenerator = new DefaultRandomGenerator();
}
public PolynomialEquationController(IRandomIntegerGenerator randomIntegerGenerator, ILogger logger)
{
this.randomIntegerGenerator = randomIntegerGenerator;
this.logger = logger;
}
public QuadraticEquationGenerator(IRandomIntegerGenerator randomIntegerGenerator) : base(randomIntegerGenerator)
{
}
public CramMd5MechanismProcessor(IConnection connection, IRandomIntegerGenerator random, ICurrentDateTimeProvider dateTimeProvider, string challenge)
: this(connection, random, dateTimeProvider)
{
_challenge = challenge;
}
public PolynomialEquationGenerator(IRandomIntegerGenerator randomIntegerGenerator) : base(randomIntegerGenerator)
{
}
/// <summary>
/// Initialises a new instance of the MoreComplexDataStructures.ListRandomizer class.
/// </summary>
/// <param name="randomIntegerGenerator">An implementation of interface IRandomIntegerGenerator to use for selecting indices from the source collection.</param>
public ListRandomizer(IRandomIntegerGenerator randomIntegerGenerator)
: this()
{
randomGenerator = randomIntegerGenerator;
}
public LinearSimultaneousEquationsGenerator(IRandomIntegerGenerator randomIntegerGenerator) : base(randomIntegerGenerator)
{
}
