/// <inheritdoc />
public override IEnumerable <PipelineWorkUnit <IntrospectiveMethodInfo> > GenerateImplementation(PipelineWorkUnit <IntrospectiveMethodInfo> workUnit)
{
var permutations = new List <IntrospectiveMethodInfo>();
var definition = workUnit.Definition;
// Generate permutation definitions
var parameterPermutations = _permutationGenerator.Generate(definition);
for (int i = 0; i < parameterPermutations.Count; ++i)
{
var permutation = parameterPermutations[i];
var method = TargetType.DefineMethod
(
$"{workUnit.GetUniqueBaseMemberName()}_permutation_{i}",
Public | Final | Virtual | HideBySig | NewSlot,
CallingConventions.Standard,
definition.ReturnType,
permutation.ToArray()
);
var methodInfo = new IntrospectiveMethodInfo(method, definition.ReturnType, permutation, definition);
permutations.Add(methodInfo);
}
GenerateTopLevelMethodImplementation(definition, permutations);
// Pass the permutations on for further processing
foreach (var permutation in permutations)
{
yield return(new PipelineWorkUnit <IntrospectiveMethodInfo>(permutation, workUnit));
}
}
public string LargestTimeFromDigits(int[] arr)
{
int?max_hm = null;
PermutationGenerator.Generate(arr, a => {
int h = a[0] * 10 + a[1];
int m = a[2] * 10 + a[3];
if (h <= 23 && m <= 59)
{
int hm = h * 100 + m;
if (max_hm.HasValue)
{
if (hm > max_hm)
{
max_hm = hm;
}
}
else
{
max_hm = hm;
}
}
});
if (max_hm.HasValue)
{
return(String.Format("{0:00}:{1:00}", max_hm / 100, max_hm % 100));
}
else
{
return(String.Empty);
}
}
public IList <int> DiffWaysToCompute(string input)
{
List <int> results = new List <int>();
Token[] tokenized = Tokenize(input);
PermutationGenerator.Generate(tokenized, tokens => {
for (int i = 0; i < tokens.Length; i++)
{
Token token = tokens[i];
token.EvaluatedValue = null;
}
for (int i = 0; i < tokens.Length; i++)
{
Token token = tokens[i];
Token prev = token.Prev;
int l_value = prev?.EvaluatedValue ?? token.LValue;
Token next = token.Next;
int r_value = next?.EvaluatedValue ?? token.RValue;
token.EvaluatedValue = token.Op(l_value, r_value);
while (prev != null && prev.EvaluatedValue != null)
{
prev.EvaluatedValue = token.EvaluatedValue;
prev = prev.Prev;
}
while (next != null && next.EvaluatedValue != null)
{
next.EvaluatedValue = token.EvaluatedValue;
next = next.Next;
}
Console.Write(token);
if (i == tokens.Length - 1)
{
results.Add(token.EvaluatedValue.Value);
Console.Write(" = ");
Console.Write(token.EvaluatedValue.Value);
}
else
{
Console.Write(" -> ");
}
}
Console.WriteLine();
});
results.Sort();
return(results);
}
/// <inheritdoc />
protected override void GenerateImplementation(IntrospectiveMethodInfo member, string symbolName, string uniqueMemberIdentifier)
{
var generatedMethods = new List <IntrospectiveMethodInfo>();
// Generate permutation definitions
var permutations = _permutationGenerator.Generate(member);
for (int i = 0; i < permutations.Count; ++i)
{
var permutation = permutations[i];
var method = TargetType.DefineMethod
(
$"{uniqueMemberIdentifier}_{i}",
Public | Final | Virtual | HideBySig | NewSlot,
CallingConventions.Standard,
member.ReturnType,
permutation.ToArray()
);
var methodInfo = new IntrospectiveMethodInfo(method, member.ReturnType, permutation, member);
generatedMethods.Add(methodInfo);
}
// Generate native implementations for the permutations
foreach (var permutation in generatedMethods)
{
var uniqueIdentifier = Guid.NewGuid().ToString().Replace("-", "_");
var memberIdentifier = $"{member.Name}_{uniqueIdentifier}";
uniqueMemberIdentifier = memberIdentifier;
if (permutation.RequiresLowering())
{
_loweredMethodGenerator.GenerateImplementationForDefinition(permutation, symbolName, uniqueMemberIdentifier);
}
else
{
_methodGenerator.GenerateImplementationForDefinition(permutation, symbolName, uniqueMemberIdentifier);
}
}
// Generate a definition for the top-level method
var topLevelMethod = TargetType.DefineMethod
(
symbolName,
Public | Final | Virtual | HideBySig | NewSlot,
member.ReturnType,
member.ParameterTypes.ToArray()
);
GenerateTopLevelMethodImplementation(member, topLevelMethod, permutations, generatedMethods);
TargetType.DefineMethodOverride(topLevelMethod, member.GetWrappedMember());
}
public IList <int[]> GeneratePermutations(int[] values)
{
var permutationGenerator = new PermutationGenerator(values);
return(permutationGenerator.Generate());
}
