public static (List <(Vector <double>[], Vector <double>[])>, List <(Vector <double>[], Vector <double>[])>) GetNTestGroups(IEnumerable <Vector <double> > input, IEnumerable <Vector <double> > output, int testSize, int N)
{
var inputGroups = new List <(Vector <double>[], Vector <double>[])>();
var outputGroups = new List <(Vector <double>[], Vector <double>[])>();
if (testSize == 0)
{
inputGroups.Add((input.ToArray(), new Vector <double> [0]));
outputGroups.Add((output.ToArray(), new Vector <double> [0]));
}
else
{
for (int i = 0; i < N; i++)
{
int[] rand = Combinatorics.GeneratePermutation(input.Count());
var testInput = rand.Take(testSize).Select(input.ElementAt);
var trainInput = rand.Skip(testSize).Select(input.ElementAt);
var testOutput = rand.Take(testSize).Select(output.ElementAt);
var trainOutput = rand.Skip(testSize).Select(output.ElementAt);
inputGroups.Add((testInput.ToArray(), trainInput.ToArray()));
outputGroups.Add((testOutput.ToArray(), trainOutput.ToArray()));
}
}
return(inputGroups, outputGroups);
}
public IObservable <byte[]> Process <TSource>(IObservable <TSource> source, IObservable <Random> randomSource)
{
var distributionSource = randomSource.Select(random => new DiscreteUniform(0, 1, random));
return(source.CombineLatest(
distributionSource,
(input, distribution) =>
{
var result = new byte[Rows * Columns];
for (int i = 0; i < result.Length; i++)
{
if (i < ActiveQuads)
{
result[i] = (byte)(distribution.Sample() * byte.MaxValue);
}
else
{
result[i] = 128;
}
}
Combinatorics.SelectPermutationInplace(result, distribution.RandomSource);
return result;
}));
}
/// <summary>
/// Projects an input point into feature space.
/// </summary>
///
/// <param name="input">The input point to be projected into feature space.</param>
/// <param name="constant">The <see cref="Constant"/> parameter of the kernel.</param>
/// <param name="degree">The <see cref="Degree"/> parameter of the kernel.</param>
///
/// <returns>
/// The feature space representation of the given <paramref name="input"/> point.
/// </returns>
///
public static double[] Transform(double[] input, int degree, double constant)
{
if (constant != 0)
{
throw new NotSupportedException(
"The explicit feature-space projection function for degrees "
+ " higher than two is only available for homogeneous kernels"
+ " (i.e. kernel functions with the constant term set to zero).");
}
int n = input.Length;
int m = (int)Math.Pow(n, degree);
double[] features = new double[m];
int index = 0;
foreach (int[] s in Combinatorics.Sequences(input.Length, degree))
{
double prod = 1;
for (int i = 0; i < s.Length; i++)
{
prod *= input[s[i]];
}
features[index++] = prod;
}
return(features);
}
public void Combinatorics_GetPermutations_OneString_ShouldNotContainsDuplicates()
{
ICombinatorics combinator = new Combinatorics();
var combinations = combinator.GetPermutation("albero");
var duplicateItems = combinations.GroupBy(x => x).Where(grouped => grouped.Count() > 1).Select(grouped => grouped.Key);
Assert.IsTrue(!duplicateItems.Any());
}
public IObservable <TElement> Process <TElement>(IObservable <TElement> source)
{
return(source
.ToArray()
.Do(elements => Combinatorics.SelectPermutationInplace(elements))
.SelectMany(elements => elements));
}
private static List <Tuple <uint, uint> > CreatePairs2(List <uint> aPlayers, ref List <Tuple <uint, uint> > aPreviousPairs, int aTotalPlayers)
{
if (aPlayers.Count % 2 > 0)
{
throw new Exception("Not even count");
}
var lPlayers = aPlayers.ToList();
var lReturn = new List <Tuple <uint, uint> >();
var lAssertCounter = 0;
for (int i = 0; i < aPlayers.Count / 2; i++)
{
uint[] lGenerated;
do
{
lGenerated = lPlayers.SelectCombination(2, mRandom).ToArray();
SwapIfNeeded(lGenerated);
lAssertCounter++;
if (lAssertCounter > 100000)
{
return(CreatePairs2(aPlayers, ref aPreviousPairs, aTotalPlayers));
}
} while (PairDuplicated(aPreviousPairs, lGenerated[0], lGenerated[1]) &&
Combinatorics.Combinations(aTotalPlayers, 2) > aPreviousPairs.Count * 2);
lPlayers.Remove(lGenerated[0]);
lPlayers.Remove(lGenerated[1]);
lReturn.Add(new Tuple <uint, uint>(lGenerated[0], lGenerated[1]));
}
return(lReturn);
}
public void combinations_of_size_k()
{
// Let's say we would like to compute all the
// combinations of size 2 the elements (1,2,3):
//
int[] elements = new[] { 1, 2, 3 };
// The number of possible subsets might be too large
// to fit on memory. For this reason, we can compute
// values on-the-fly using foreach:
foreach (int[] combination in Combinatorics.Combinations(elements, k: 2))
{
// ...
}
// Or we could try to compute them all and store in an array:
int[][] combinations = Combinatorics.Combinations(elements, k: 2).ToArray();
// In either case, the result will be:
int[][] expected =
{
new [] { 1, 2 },
new [] { 1, 3 },
new [] { 2, 3 },
};
string str = combinations.Apply(x => x.ToArray()).ToCSharp();
for (int i = 0; i < combinations.Length; i++)
{
CollectionAssert.AreEqual(combinations[i], expected[i]);
}
}
/// <inheritdoc />
public double Evaluate(ClusterSet <TInstance> clusterSet, IDictionary <TInstance, TClass> instanceClasses)
{
// counts the positives for each cluster
var truePositives = 0L;
var positives = 0L;
foreach (var cluster in clusterSet)
{
// gets class counts
var clusterClassCounts = new Dictionary <TClass, int>();
foreach (var instance in cluster)
{
var instanceClass = instanceClasses[instance];
if (clusterClassCounts.ContainsKey(instanceClass))
{
clusterClassCounts[instanceClass]++;
}
else
{
clusterClassCounts[instanceClass] = 1;
}
}
// updates positives
positives += Combinatorics.GetCombinations(cluster.Count, 2);
// updates true positives (pairs of same class within cluster)
truePositives += clusterClassCounts.Values
.Where(count => count > 1)
.Sum(count => Combinatorics.GetCombinations(count, 2));
}
// returns precision
return((double)truePositives / positives);
}
public void CanCountVariationsWithRepetition([Values(0, 1, 10, 10, 10, 10, 10, 10, 10)] int n, [Values(0, 0, 0, 2, 4, 6, 9, 10, 11)] int k, [Values(1, 1, 1, 100, 10000, 1000000, 1000000000, 10000000000, 100000000000)] long expected)
{
Assert.AreEqual(
expected,
Combinatorics.VariationsWithRepetition(n, k),
"Count the number of variations with repetition");
}
public void OutOfRangeVariationsWithRepetitionCountToZero([Values(0, 0, 1, -1, -1)] int n, [Values(1, -1, -1, 0, 1)] int k)
{
Assert.AreEqual(
0,
Combinatorics.VariationsWithRepetition(n, k),
"The number of variations with repetition but out of the range must be 0.");
}
public void CanCountPermutations([Values(0, 1, 2, 8, 15)] int n, [Values(1, 1, 2, 40320, 1307674368000)] long expected)
{
Assert.AreEqual(
expected,
Combinatorics.Permutations(n),
"Count the number of permutations");
}
public void CanCountVariations([Values(0, 1, 10, 10, 10, 10, 10, 10)] int n, [Values(0, 0, 0, 2, 4, 6, 9, 10)] int k, [Values(1, 1, 1, 90, 5040, 151200, 3628800, 3628800)] long expected)
{
Assert.AreEqual(
expected,
Combinatorics.Variations(n, k),
"Count the number of variations without repetition");
}
public void CanCountCombinationsWithRepetition([Values(0, 1, 10, 10, 10, 10, 10, 10, 10)] int n, [Values(0, 0, 0, 2, 4, 6, 9, 10, 11)] int k, [Values(1, 1, 1, 55, 715, 5005, 48620, 92378, 167960)] long expected)
{
Assert.AreEqual(
expected,
Combinatorics.CombinationsWithRepetition(n, k),
"Count the number of combinations with repetition");
}
public void OutOfRangeCombinationsCountToZero([Values(0, 10, 0, 1, -1, -1)] int n, [Values(1, 11, -1, -1, 0, 1)] int k)
{
Assert.AreEqual(
0,
Combinatorics.Combinations(n, k),
"The number of combinations without repetition but out of the range must be 0.");
}
public void CanCountCombinations([Values(0, 1, 10, 10, 10, 10, 10, 10)] int n, [Values(0, 0, 0, 2, 4, 6, 9, 10)] int k, [Values(1, 1, 1, 45, 210, 210, 10, 1)] long expected)
{
Assert.AreEqual(
expected,
Combinatorics.Combinations(n, k),
"Count the number of combinations without repetition");
}
public void GetAllPartitions()
{
var partitions = Combinatorics.GetAllPartitions(new[] { 1, 2, 3, 4 }).ToArray();
int[][][] sets =
{
new int[][] { new int[] { 1, 2, 3, 4 } },
new int[][] { new int[] { 1, 3,4 }, new int[] { 2 } },
new int[][] { new int[] { 1, 2,4 }, new int[] { 3 } },
new int[][] { new int[] { 1,4 }, new int[] { 2, 3 } },
new int[][] { new int[] { 1,4 }, new int[] { 2 }, new int[] { 3 } },
new int[][] { new int[] { 1, 2,3 }, new int[] { 4 } },
new int[][] { new int[] { 1,3 }, new int[] { 2, 4 } },
new int[][] { new int[] { 1,3 }, new int[] { 2 }, new int[] { 4 } },
new int[][] { new int[] { 1,2 }, new int[] { 3, 4 } },
new int[][] { new int[] { 1,2 }, new int[] { 3 }, new int[] { 4 } },
new int[][] { new int[] {1 }, new int[] { 2, 3, 4 } },
new int[][] { new int[] {1 }, new int[] { 2, 4 }, new int[] { 3 } },
new int[][] { new int[] {1 }, new int[] { 2, 3 }, new int[] { 4 } },
new int[][] { new int[] {1 }, new int[] { 2 }, new int[] { 3, 4 } },
new int[][] { new int[] {1 }, new int[] { 2 }, new int[] { 3 }, new int[] { 4 } }
};
Assert.AreEqual(sets.Length, partitions.Length);
for (int i = 0; i < sets.Length; i++)
{
Assert.AreEqual(sets[i].Length, partitions[i].Length);
for (int j = 0; j < sets[i].Length; j++)
{
Assert.IsTrue(sets[i][j].SequenceEqual(partitions[i][j]));
}
}
}
public void KOfNTest()
{
void AllKOfN(int n, int k, bool exactlyK)
{
Out.WriteLine($"{k} of {n} {(exactlyK ? "(exactly)" : "")}:");
var allKofN = Combinatorics.KOfN(n, k, exactlyK);
foreach (var subset in allKofN)
{
Out.WriteLine(" " + subset.ToDelimitedString());
}
if (exactlyK)
{
var expected = (int)Combinatorics.Cnk(n, k);
Assert.Equal(expected, allKofN.Count());
}
}
AllKOfN(5, 5, false);
AllKOfN(5, 4, true);
AllKOfN(5, 4, false);
AllKOfN(5, 3, true);
AllKOfN(5, 3, false);
AllKOfN(5, 2, true);
AllKOfN(5, 2, false);
}
public void CanCountVariationsWithRepetition(int n, int k, long expected)
{
Assert.AreEqual(
expected,
Combinatorics.VariationsWithRepetition(n, k),
"Count the number of variations with repetition");
}
unsafe static void Main(string[] args)
{
init();
// load mnist
var imagesTrain = LoadImages(args[0]);
var labelsTrain = LoadLabels(args[1]);
var imagesTest = LoadImages(args[2]);
var labelsTest = LoadLabels(args[3]);
var imagesShuffled = new float[imagesTrain.GetLength(0), 28 * 28];
var labelsShuffled = new long[labelsTrain.GetLength(0)];
for (int epoch = 0; epoch < 10; ++epoch)
{
// shuffle
var idxs = Combinatorics.GeneratePermutation(imagesTrain.GetLength(0));
int i = 0;
foreach (int idx in idxs)
{
Array.Copy(imagesTrain, idx * 28 * 28, imagesShuffled, i * 28 * 28, 28 * 28);
labelsShuffled[i] = labelsTrain[idx];
++i;
}
fixed(float *pImagesTrain = &imagesShuffled[0, 0])
fixed(long *pLabelsTrain = &labelsShuffled[0])
fixed(float *pImagesTest = &imagesTest[0, 0])
fixed(long *pLabelsTest = &labelsTest[0])
{
train(pImagesTrain, pLabelsTrain, imagesTrain.GetLength(0));
test(pImagesTest, pLabelsTest, imagesTest.GetLength(0));
}
}
}
public void CanCountPermutations(int n, long expected)
{
Assert.AreEqual(
expected,
Combinatorics.Permutations(n),
"Count the number of permutations");
}
public void OutOfRangeVariationsCountToZero(int n, int k)
{
Assert.AreEqual(
0,
Combinatorics.Variations(n, k),
"The number of variations without repetition but out of the range must be 0.");
}
public void CanCountCombinations(int n, int k, long expected)
{
Assert.AreEqual(
expected,
Combinatorics.Combinations(n, k),
"Count the number of combinations without repetition");
}
public void OutOfRangeCombinationsWithRepetitionCountToZero(int n, int k)
{
Assert.AreEqual(
0,
Combinatorics.CombinationsWithRepetition(n, k),
"The number of combinations with repetition but out of the range must be 0.");
}
/// <summary>
/// Creates a new Wilcoxon's W+ distribution.
/// </summary>
///
/// <param name="ranks">The rank statistics for the samples.</param>
/// <param name="forceExact">True to compute the exact test. May requires
/// a significant amount of processing power for large samples (n > 12).</param>
///
public WilcoxonDistribution(double[] ranks, bool forceExact)
{
// Remove zero elements
int[] idx = ranks.Find(x => x != 0);
this.Ranks = ranks.Submatrix(idx);
this.Samples = idx.Length;
if (forceExact || Samples < 12)
{
// For a small sample (i.e. n < 12)
// the distribution will be exact.
// Generate all possible combinations in advance
int[][] combinations = Combinatorics.TruthTable(Samples);
// Transform binary into sign combinations
for (int i = 0; i < combinations.Length; i++)
{
for (int j = 0; j < combinations[i].Length; j++)
{
combinations[i][j] = Math.Sign(combinations[i][j] * 2 - 1);
}
}
// Compute all possible values for W+ considering those signs
this.table = new double[combinations.Length];
for (int i = 0; i < combinations.Length; i++)
{
table[i] = WPositive(combinations[i], ranks);
}
Array.Sort(table);
}
}
public void TruthTableTest2()
{
// Suppose we would like to generate a truth table (i.e. all possible
// combinations of a set of discrete symbols) for variables that contain
// different numbers symbols. Let's say, for example, that the first
// variable may contain symbols 0 and 1, the second could contain either
// 0, 1, or 2, and the last one again could contain only 0 and 1. Thus
// we can generate the truth table in the following way:
int[] symbols = { 2, 3, 2 };
int[][] actual = Combinatorics.TruthTable(symbols);
int[][] expected =
{
new int[] { 0, 0, 0 },
new int[] { 0, 0, 1 },
new int[] { 0, 1, 0 },
new int[] { 0, 1, 1 },
new int[] { 0, 2, 0 },
new int[] { 0, 2, 1 },
new int[] { 1, 0, 0 },
new int[] { 1, 0, 1 },
new int[] { 1, 1, 0 },
new int[] { 1, 1, 1 },
new int[] { 1, 2, 0 },
new int[] { 1, 2, 1 },
};
Assert.IsTrue(expected.IsEqual(actual));
}
public void CombinationsTest()
{
Assert.IsTrue(Combinatorics.CombinationsCount(8, 5) == 792);
Assert.IsTrue(Combinatorics.CombinationsCount(8, 2) == 36);
Assert.IsTrue(Combinatorics.CombinationsCount(18, 5) == 26334);
Assert.IsTrue(Combinatorics.CombinationsCount(17, 6) == 74613);
int[,] expected = new int[, ] {
{ 0, 0, 0 }, { 0, 0, 1 }, { 0, 0, 2 }, { 0, 0, 3 }, { 0, 0, 4 }, { 0, 0, 5 }, { 0, 1, 1 }, { 0, 1, 2 },
{ 0, 1, 3 }, { 0, 1, 4 }, { 0, 1, 5 }, { 0, 2, 2 }, { 0, 2, 3 }, { 0, 2, 4 }, { 0, 2, 5 }, { 0, 3, 3 },
{ 0, 3, 4 }, { 0, 3, 5 }, { 0, 4, 4 }, { 0, 4, 5 }, { 0, 5, 5 }, { 1, 1, 1 }, { 1, 1, 2 }, { 1, 1, 3 },
{ 1, 1, 4 }, { 1, 1, 5 }, { 1, 2, 2 }, { 1, 2, 3 }, { 1, 2, 4 }, { 1, 2, 5 }, { 1, 3, 3 }, { 1, 3, 4 },
{ 1, 3, 5 }, { 1, 4, 4 }, { 1, 4, 5 }, { 1, 5, 5 }, { 2, 2, 2 }, { 2, 2, 3 }, { 2, 2, 4 }, { 2, 2, 5 },
{ 2, 3, 3 }, { 2, 3, 4 }, { 2, 3, 5 }, { 2, 4, 4 }, { 2, 4, 5 }, { 2, 5, 5 }, { 3, 3, 3 }, { 3, 3, 4 },
{ 3, 3, 5 }, { 3, 4, 4 }, { 3, 4, 5 }, { 3, 5, 5 }, { 4, 4, 4 }, { 4, 4, 5 }, { 4, 5, 5 }, { 5, 5, 5 }
};
int[] arr = Enumerable.Range(0, 6).ToArray();
Assert.IsTrue(Combinatorics.CombinationsCount(arr, 3) == 56);
int[,] x = arr.Combinations(3).Select(X => X.ToArray()).ToArray().FromJagged();
Assert.IsTrue(expected.ArrayEquals(x));
int[,] x1 = arr.Combinations(3, true).Select(X => X.ToArray()).ToArray().FromJagged();
Assert.IsTrue(expected.ArrayEquals(x1));
}
public void UniquePermutationsTest()
{
Assert.IsTrue(Combinatorics.UniquePermutationsCount(8, 5) == 6720);
Assert.IsTrue(Combinatorics.UniquePermutationsCount(8, 2) == 56);
Assert.IsTrue(Combinatorics.UniquePermutationsCount(18, 5) == 1028160);
Assert.IsTrue(Combinatorics.UniquePermutationsCount(17, 6) == 8910720);
int[,] expected = new int[, ] {
{ 0, 1, 2 }, { 0, 1, 3 }, { 0, 1, 4 }, { 0, 1, 5 }, { 0, 2, 1 }, { 0, 2, 3 }, { 0, 2, 4 }, { 0, 2, 5 },
{ 0, 3, 1 }, { 0, 3, 2 }, { 0, 3, 4 }, { 0, 3, 5 }, { 0, 4, 1 }, { 0, 4, 2 }, { 0, 4, 3 }, { 0, 4, 5 },
{ 0, 5, 1 }, { 0, 5, 2 }, { 0, 5, 3 }, { 0, 5, 4 }, { 1, 0, 2 }, { 1, 0, 3 }, { 1, 0, 4 }, { 1, 0, 5 },
{ 1, 2, 0 }, { 1, 2, 3 }, { 1, 2, 4 }, { 1, 2, 5 }, { 1, 3, 0 }, { 1, 3, 2 }, { 1, 3, 4 }, { 1, 3, 5 },
{ 1, 4, 0 }, { 1, 4, 2 }, { 1, 4, 3 }, { 1, 4, 5 }, { 1, 5, 0 }, { 1, 5, 2 }, { 1, 5, 3 }, { 1, 5, 4 },
{ 2, 0, 1 }, { 2, 0, 3 }, { 2, 0, 4 }, { 2, 0, 5 }, { 2, 1, 0 }, { 2, 1, 3 }, { 2, 1, 4 }, { 2, 1, 5 },
{ 2, 3, 0 }, { 2, 3, 1 }, { 2, 3, 4 }, { 2, 3, 5 }, { 2, 4, 0 }, { 2, 4, 1 }, { 2, 4, 3 }, { 2, 4, 5 },
{ 2, 5, 0 }, { 2, 5, 1 }, { 2, 5, 3 }, { 2, 5, 4 }, { 3, 0, 1 }, { 3, 0, 2 }, { 3, 0, 4 }, { 3, 0, 5 },
{ 3, 1, 0 }, { 3, 1, 2 }, { 3, 1, 4 }, { 3, 1, 5 }, { 3, 2, 0 }, { 3, 2, 1 }, { 3, 2, 4 }, { 3, 2, 5 },
{ 3, 4, 0 }, { 3, 4, 1 }, { 3, 4, 2 }, { 3, 4, 5 }, { 3, 5, 0 }, { 3, 5, 1 }, { 3, 5, 2 }, { 3, 5, 4 },
{ 4, 0, 1 }, { 4, 0, 2 }, { 4, 0, 3 }, { 4, 0, 5 }, { 4, 1, 0 }, { 4, 1, 2 }, { 4, 1, 3 }, { 4, 1, 5 },
{ 4, 2, 0 }, { 4, 2, 1 }, { 4, 2, 3 }, { 4, 2, 5 }, { 4, 3, 0 }, { 4, 3, 1 }, { 4, 3, 2 }, { 4, 3, 5 },
{ 4, 5, 0 }, { 4, 5, 1 }, { 4, 5, 2 }, { 4, 5, 3 }, { 5, 0, 1 }, { 5, 0, 2 }, { 5, 0, 3 }, { 5, 0, 4 },
{ 5, 1, 0 }, { 5, 1, 2 }, { 5, 1, 3 }, { 5, 1, 4 }, { 5, 2, 0 }, { 5, 2, 1 }, { 5, 2, 3 }, { 5, 2, 4 },
{ 5, 3, 0 }, { 5, 3, 1 }, { 5, 3, 2 }, { 5, 3, 4 }, { 5, 4, 0 }, { 5, 4, 1 }, { 5, 4, 2 }, { 5, 4, 3 }
};
int[] arr = Enumerable.Range(0, 6).ToArray();
Assert.IsTrue(Combinatorics.UniquePermutationsCount(arr, 3) == 120);
int[,] x = arr.UniquePermutations(3).Select(X => X.ToArray()).ToArray().FromJagged();
Assert.IsTrue(expected.ArrayEquals(x));
int[,] x1 = arr.Permutations(3, false).Select(X => X.ToArray()).ToArray().FromJagged();
Assert.IsTrue(expected.ArrayEquals(x1));
}
public void UniqueCombinationsTest()
{
Assert.IsTrue(Combinatorics.UniqueCombinationsCount(8, 5) == 56);
Assert.IsTrue(Combinatorics.UniqueCombinationsCount(8, 2) == 28);
Assert.IsTrue(Combinatorics.UniqueCombinationsCount(18, 5) == 8568);
Assert.IsTrue(Combinatorics.UniqueCombinationsCount(17, 6) == 12376);
int[,] expected = new int[, ] {
{ 0, 1, 2 }, { 0, 1, 3 }, { 0, 1, 4 }, { 0, 1, 5 },
{ 0, 2, 3 }, { 0, 2, 4 }, { 0, 2, 5 }, { 0, 3, 4 },
{ 0, 3, 5 }, { 0, 4, 5 }, { 1, 2, 3 }, { 1, 2, 4 },
{ 1, 2, 5 }, { 1, 3, 4 }, { 1, 3, 5 }, { 1, 4, 5 },
{ 2, 3, 4 }, { 2, 3, 5 }, { 2, 4, 5 }, { 3, 4, 5 }
};
int[] arr = Enumerable.Range(0, 6).ToArray();
Assert.IsTrue(Combinatorics.UniqueCombinationsCount(arr, 3) == 20);
int[,] x = arr.UniqueCombinations(3).Select(X => X.ToArray()).ToArray().FromJagged();
Assert.IsTrue(expected.ArrayEquals(x));
int[,] x1 = arr.Combinations(3, false).Select(X => X.ToArray()).ToArray().FromJagged();
Assert.IsTrue(expected.ArrayEquals(x1));
}
public Anagram.Models.AnagramDataModel GetFormattedAnagrams(String phrase)
{
String [] resultsArray = GetAnagrams(phrase).ToArray();
var phraseLetterValues = new LetterValues(phrase);
if (resultsArray.Length >= 2)
{
var watch = Stopwatch.StartNew();
Parallel.ForEach(Combinatorics.Combinations <String>(resultsArray, 2, false), (combination) =>
{
if (CheckIfStringsHaveTheSameFrequency(combination, phrase))
{
AnagramsFormattedResults.Add(ComposeAnagramsStrings(combination));
}
});
watch.Stop();
return(new Models.AnagramDataModel(AnagramsFormattedResults, watch.ElapsedMilliseconds));
}
return(new Models.AnagramDataModel(new List <string>(), 0));
}
/// <summary>
/// Constructs a Mann-Whitney's U-statistic distribution.
/// </summary>
///
/// <param name="ranks">The rank statistics.</param>
/// <param name="n1">The number of observations in the first sample.</param>
/// <param name="n2">The number of observations in the second sample.</param>
///
public MannWhitneyDistribution(double[] ranks, int n1, int n2)
{
this.Ranks = ranks;
this.Samples1 = n1;
this.Samples2 = n2;
int nt = n1 + n2;
this.smallSample = (n1 <= 30 && n2 <= 30);
if (smallSample)
{
// For a small sample (< 30) the distribution is exact.
int nc = (int)Special.Binomial(nt, n1);
table = new double[nc];
int i = 0; // Consider all possible combinations of samples
foreach (double[] combination in Combinatorics.Combinations(Ranks, n1))
{
table[i++] = USample1(combination, Samples2);
}
Array.Sort(table);
}
}
/// <summary>
/// Gets the marginal distribution of a given variable evaluated at a given value.
/// </summary>
///
/// <param name="index">The variable index.</param>
/// <param name="value">The variable value.</param>
///
public double MarginalDistributionFunction(int index, int value)
{
double num = 0;
double den = 0;
int[] symbols = Support.Apply(x => x.Length);
int[] probe = new int[Dimension];
foreach (int[] input in Combinatorics.Sequences(symbols, inPlace: true))
{
for (int i = 0; i < probe.Length; i++)
{
probe[i] = input[i] + Support[i].Min;
}
double p = ProbabilityMassFunction(probe);
for (int k = 0; k < probe.Length; k++)
{
if (k == index)
{
continue;
}
if (probe[k] == Support[k].Min + value)
{
num += p;
}
}
den += p;
}
return(num == 0 ? 0 : num / den);
}
public void Combinatorics_GetPermutations_OneCharString_ShouldReturn_SameString()
{
ICombinatorics combinator = new Combinatorics();
var combinations = combinator.GetPermutation("a");
Assert.IsTrue(combinations.FirstOrDefault() == "a");
}
public void Combinatorics_GetPermutations_Null_ShouldReturn_EmptyStringList()
{
ICombinatorics combinator = new Combinatorics();
var combinations = combinator.GetPermutation(null);
Assert.IsTrue(!combinations.Any());
}
public void Combinatorics_GetPermutations_OneString_ShouldReturn_Combinatorics()
{
ICombinatorics combinator = new Combinatorics();
var combinations = combinator.GetPermutation("pippo");
Assert.IsTrue(combinations.Any());
}
