public async Task <bool> DeleteMangelAsync(Mangel mangel)
{
try
{
var client = new HttpClient();
var result = await client.DeleteAsync(_fjernMangelURL + mangel.id);
if (result.IsSuccessStatusCode)
{
Mangler.Remove(mangel);
RefreshMangelList();
GetLokaler();
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
Debug.WriteLine("Slet error! : " + ex);
return(false);
}
}
public void Encode(System.Text.StringBuilder result)
{
// output function or operator name
result.Append('$');
result.Append(Mangler.EncodeNamePart(this.Identifier));
// output parameter types
result.Append('$');
foreach (Expression argument in _arguments)
{
switch (argument.Type.Kind)
{
case TypeKind.Boolean: result.Append('b'); break;
case TypeKind.Integer: result.Append('i'); break;
case TypeKind.String: result.Append('s'); break;
default:
throw new BerylError("Unknown type kind '" + argument.Type.Kind.ToString() + "' encountered");
}
}
// output terminating dollar sign ($)
result.Append('$');
}
public async Task <bool> GetManglerAsync()
{
try
{
var client = new HttpClient();
var jsonMangler = await client.GetStringAsync(_getManglerURL);
var _mangler = JsonConvert.DeserializeObject <List <Mangel> >(jsonMangler);
// Just so we don't keep appending the same items. :)
if (Mangler != null)
{
Mangler.Clear();
}
foreach (var _fejl in _mangler)
{
Mangler.Add(_fejl);
}
// opdater lokale listen med de nye mangler/fejl.
GetLokaler();
return(true);
}
catch (Exception ex)
{
Debug.WriteLine("Json error! : " + ex);
return(false);
}
}
static readonly double FitnessNoise = 0.01; // E.g. 0.01
/// <summary>
/// Optimize the given problem and output result-statistics.
/// </summary>
static void Optimize(Problem problem)
{
if (UseMangler)
{
// Wrap problem-object in search-space mangler.
problem = new Mangler(problem, Diffusion, Displacement, Spillover, FitnessNoise);
}
// Create a fitness trace for tracing the progress of optimization re. mean.
int NumMeanIntervals = 3000;
FitnessTrace fitnessTraceMean = new FitnessTraceMean(NumIterations, NumMeanIntervals);
// Create a fitness trace for tracing the progress of optimization re. quartiles.
// Note that fitnessTraceMean is chained to this object by passing it to the
// constructor, this causes both fitness traces to be used.
int NumQuartileIntervals = 10;
FitnessTrace fitnessTraceQuartiles = new FitnessTraceQuartiles(NumRuns, NumIterations, NumQuartileIntervals, fitnessTraceMean);
// Create a feasibility trace for tracing the progress of optimization re. feasibility.
FeasibleTrace feasibleTrace = new FeasibleTrace(NumIterations, NumMeanIntervals, fitnessTraceQuartiles);
// Assign the problem etc. to the optimizer.
Optimizer.Problem = problem;
Optimizer.FitnessTrace = feasibleTrace;
// Wrap the optimizer in a logger of result-statistics.
bool StatisticsOnlyFeasible = true;
Statistics Statistics = new Statistics(Optimizer, StatisticsOnlyFeasible);
// Wrap it again in a repeater.
Repeat Repeat = new RepeatSum(Statistics, NumRuns);
// Perform the optimization runs.
double fitness = Repeat.Fitness(Parameters);
// Compute result-statistics.
Statistics.Compute();
// Output result-statistics
string msg = "{0} = {1} - {2} = {3} = {4} = {5} = {6} = {7} = {8} \r\n";
Console.WriteFormatted(msg, Color.OrangeRed, Color.Green,
problem.Name,
Tools.FormatNumber(Statistics.FitnessMean),
Tools.FormatNumber(Statistics.FitnessStdDev),
Tools.FormatNumber(Statistics.FitnessQuartiles.Min),
Tools.FormatNumber(Statistics.FitnessQuartiles.Q1),
Tools.FormatNumber(Statistics.FitnessQuartiles.Median),
Tools.FormatNumber(Statistics.FitnessQuartiles.Q3),
Tools.FormatNumber(Statistics.FitnessQuartiles.Max),
Tools.FormatPercent(Statistics.FeasibleFraction));
// Output fitness and feasible traces.
fitnessTraceMean.WriteToFile(Optimizer.Name + "-FitnessTraceMean-" + problem.Name + ".txt");
fitnessTraceQuartiles.WriteToFile(Optimizer.Name + "-FitnessTraceQuartiles-" + problem.Name + ".txt");
feasibleTrace.WriteToFile(Optimizer.Name + "-FeasibleTrace-" + problem.Name + ".txt");
}
public static void RunMangler()
{
Mangler m;
foreach (var item in LocalData.BlazorFilesList.Where(x => !x.IsPrimary))
{
m = new Mangler(item);
}
m = new Mangler(LocalData.BlazorFilesList.Single(x => x.IsPrimary));
}
private LLVMValueRef DeclareLocal(IMethod method)
{
var funType = GetFunctionPrototype(method);
var result = LLVM.AddFunction(Module, Mangler.Mangle(method, true), funType);
result.SetLinkage(GetLinkageForLocal(method));
if (!method.IsStatic)
{
LLVM.AddAttributeAtIndex(result, (LLVMAttributeIndex)1, CreateEnumAttribute("nonnull"));
}
return(result);
}
public override void Encode(System.Text.StringBuilder result)
{
if (this.Name[0] == '$')
{
throw new BerylError("Symbol already mangled: " + this.Name);
}
// output function or operator name
result.Append('$');
result.Append(Mangler.EncodeNamePart(this.Name));
// output parameter types
result.Append('$');
foreach (ParameterDeclaration parameter in _parameters)
{
parameter.Encode(result);
}
// output terminating dollar sign ($)
result.Append('$');
}
public LLVMValueRef DefineStaticField(IField field)
{
LLVMValueRef result;
if (fieldDecls.TryGetValue(field, out result))
{
return(result);
}
if (!field.IsStatic)
{
throw new InvalidOperationException($"Cannot define non-static field '{field.FullName}' as a global.");
}
var type = ImportType(field.FieldType);
var name = Mangler.Mangle(field, true);
result = LLVM.AddGlobal(Module, type, name);
result.SetInitializer(LLVM.ConstNull(type));
result.SetLinkage(GetLinkageForLocal(field));
fieldDecls[field] = result;
return(result);
}
private LLVMTypeRef ImportTypeImpl(IType type)
{
var intSpec = type.GetIntegerSpecOrNull();
if (intSpec != null)
{
return(LLVM.IntTypeInContext(Context, (uint)intSpec.Size));
}
else if (type == TypeSystem.Float32)
{
return(LLVM.FloatTypeInContext(Context));
}
else if (type == TypeSystem.Float64)
{
return(LLVM.DoubleTypeInContext(Context));
}
else if (type == TypeSystem.NaturalInt || type == TypeSystem.NaturalUInt)
{
return(LLVM.PointerType(LLVM.Int8TypeInContext(Context), 0));
}
else if (type is PointerType)
{
var elemType = ((PointerType)type).ElementType;
if (elemType == TypeSystem.Void)
{
return(LLVM.PointerType(LLVM.Int8TypeInContext(Context), 0));
}
else
{
return(LLVM.PointerType(ImportType(elemType), 0));
}
}
else if (type == TypeSystem.Void)
{
return(LLVM.VoidTypeInContext(Context));
}
else
{
var result = LLVM.StructCreateNamed(Context, Mangler.Mangle(type, true));
importCache[type] = result;
var fieldTypes = new List <LLVMTypeRef>();
var fieldNumbering = new Dictionary <IField, int>();
var baseNumbering = new Dictionary <IType, int>();
foreach (var baseType in type.BaseTypes)
{
var importedBase = ImportType(baseType);
if (importedBase.TypeKind != LLVMTypeKind.LLVMStructTypeKind ||
importedBase.CountStructElementTypes() > 0)
{
// Do not include empty base types.
baseNumbering[baseType] = fieldTypes.Count;
fieldTypes.Add(importedBase);
}
}
foreach (var field in type.Fields.Where(f => !f.IsStatic))
{
fieldNumbering[field] = fieldTypes.Count;
fieldTypes.Add(ImportType(field.FieldType));
}
fieldIndices[type] = fieldNumbering;
baseIndices[type] = baseNumbering;
LLVM.StructSetBody(result, fieldTypes.ToArray(), false);
return(result);
}
}
public TestCase(Expression root, LanguageWordGenerator inLanguage, Mangler mangler)
{
Root = root;
InLanguage = inLanguage;
Mangler = mangler;
}
