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