// BackupProcessor constructor: /// <summary>Initializes a new <c>BackupProcessor</c> object to use the given configuration and user interface object.</summary> /// <param name="configuration">A <c>Configuration</c> object containing all the settings for this backup run.</param> /// <param name="userInterface">A <c>ConsoleOutput</c> object which can be used for output to the user.</param> public BackupProcessor(Configuration configuration, ConsoleOutput userInterface) { // Get and store the current operating system. systemType = Configuration.getSystemType(); // Each OS has a different means of creating hard links. Set the hardLinker object to whichever type of linker is appropriate. if (systemType == Configuration.SystemType.Windows) { hardLinker = new WindowsLinker(); } else if (systemType == Configuration.SystemType.Linux) { hardLinker = new LinuxLinker(); } else { throw new NotImplementedException("Unsupported operating system."); } // Get and store the limits on use of old physical copies for creating new hard links. maxHardLinksPerFile = configuration.MaxHardLinksPerFile; maxDaysBeforeNewFullFileCopy = configuration.MaxDaysBeforeNewFullFileCopy; // Get and store the source and destination info for the backup. sourcePaths = configuration.BackupSourcePaths; backupsDestinationRootPath = configuration.BackupDestinationPath; // Set up an empty list to contain any warnings generated during the backup process. backupProcessWarnings = new List <string>(); // Store the user output object. this.userInterface = userInterface; } // end BackupProcessor constructor
internal static double evaluateLinker(QuestionDialogDatasetReader dataset, ILinker linker) { var totalDialogCount = 0; var correctLinkCount = 0; foreach (var dialog in dataset.Dialogs) { if (!dialog.HasCorrectAnswer) { continue; } totalDialogCount += 1; var linkedQuestion = linker.LinkUtterance(dialog.Question); var contextEntities = linkedQuestion.Parts.SelectMany(p => p.Entities.Take(1)).ToArray(); var answerPhrase = getAnswerPhrase(dialog); var linkedAnswer = linker.LinkUtterance(answerPhrase, contextEntities); var answerPhraseEntities = linkedAnswer == null ? new EntityInfo[0] : linkedAnswer.Entities; var isLinkingCorrect = answerPhraseEntities.Select(e => e.Mid).Contains(dialog.AnswerMid); if (isLinkingCorrect) { ++correctLinkCount; } } return(1.0 * correctLinkCount / totalDialogCount); }
internal GraphNavigationManager(NavigationData data, IEnumerable <string> entityPhrases, ILinker linker) { _data = data; _linker = linker; _entityPhrases = entityPhrases.ToArray(); _edges = new string[] { "/location/country/form_of_government", "/biology/organism_classification/higher_classification", "/people/person/profession", "/education/field_of_study/students_majoring", "/sports/school_sports_team/school", "/music/genre/albums", "/medicine/disease/causes", "/tv/tv_program/regular_cast", "/people/person/nationality", "/film/film_genre/films_in_this_genre", "/music/artist/genre", "/business/business_operation/industry", "/common/topic/notable_types", "/location/location/contains", }; sampleEdgeRepresentants(20); }
internal GraphNavigationWebConsole(string databasePath, IEnumerable <string> phrases, NavigationData data, ILinker linker) { _databasePath = databasePath; _phrases = phrases; _data = data; _linker = linker; }
private static void exportAugmentedLinkedAnswerHints(ILinker linker, string filePath, IEnumerable <QuestionDialog> dialogs) { var file = new StreamWriter(filePath); foreach (var dialog in dialogs) { var answerEntity = new EntityInfo(dialog.AnswerMid, null, 0, 0); var linkedQuestion = linker.LinkUtterance(dialog.Question); //inject answer entities to question - forcing correct linking var questionEntities = linkedQuestion.Parts.SelectMany(p => p.Entities).Concat(new[] { answerEntity }).ToArray(); var answerTurn = dialog.AnswerTurns.Last(); var answerHint = answerTurn.InputChat; var linkedAnswerHint = linker.LinkUtterance(answerHint, questionEntities); if (linkedAnswerHint == null) { continue; } var featureText = linkedQuestion.GetEntityBasedRepresentation() + " ## " + linkedAnswerHint.GetEntityBasedRepresentation(); if (featureText.Contains("|")) { throw new NotImplementedException("escape feature text"); } file.WriteLine("{0}|{1}|{2}", dialog.Id, featureText, dialog.AnswerMid); } file.Close(); }
/// <summary>Generates.</summary> /// <param name="desc">The description.</param> /// <param name="examples">The examples.</param> /// <param name="linker">The linker.</param> /// <returns>A Cluster.</returns> public Cluster Generate(Descriptor desc, IEnumerable<object> examples, ILinker linker) { // Load data var exampleArray = examples.ToArray(); Descriptor = desc; Matrix X = Descriptor.Convert(examples).ToMatrix(); return GenerateClustering(X, linker, exampleArray); }
public FlowGraphBuilder(ILinker linker) { _layersList = new List <BaseLayer>(); _firstLayers = null; _finalLayers = null; _linker = linker; }
public CommandExecutor(IConsole console, IConfigHandler configHandler, IFileSystem fileSystem, IConfig defaultConfig, IArgumentParser argumentHandler, ILinker linker, IPathResolver pathResolver) { this.console = console; this.configHandler = configHandler; this.fileSystem = fileSystem; this.defaultConfig = defaultConfig; this.argumentHandler = argumentHandler; this.linker = linker; this.pathResolver = pathResolver; }
/// <summary>Generates.</summary> /// <param name="desc">The description.</param> /// <param name="examples">The examples.</param> /// <param name="linker">The linker.</param> /// <returns>A Cluster.</returns> public Cluster Generate(Descriptor desc, IEnumerable <object> examples, ILinker linker) { // Load data var exampleArray = examples.ToArray(); this.Descriptor = desc; var X = this.Descriptor.Convert(examples).ToMatrix(); return(this.GenerateClustering(X, linker, exampleArray)); }
private static void extractAnswer(string utterance, ILinker linker, LinkBasedExtractor extractor, QuestionDialogDatasetReader dataset) { var utteranceWords = getCleanWords(utterance).Distinct(); QuestionDialog dialogToAnswer = null; foreach (var dialog in dataset.Dialogs) { if (!dialog.HasCorrectAnswer) { continue; } var questionWords = getCleanWords(dialog.Question); if (utteranceWords.Except(questionWords).Count() == 0) { dialogToAnswer = dialog; } foreach (var turn in dialog.AnswerTurns) { var words = getCleanWords(turn.InputChat); if (utteranceWords.Except(words).Count() == 0) { dialogToAnswer = dialog; break; } } if (dialogToAnswer != null) { break; } } Console.WriteLine(dialogToAnswer.Question); var answerPhrase = getAnswerPhrase(dialogToAnswer); var linkedQuestion = linker.LinkUtterance(dialogToAnswer.Question); Console.WriteLine(linkedQuestion); var contextEntities = linkedQuestion.Parts.SelectMany(p => p.Entities).ToArray(); var result = linker.LinkUtterance(answerPhrase, contextEntities); Console.WriteLine(result); var answers = extractor.ExtractAnswerEntity(dialogToAnswer); foreach (var answer in answers) { Console.WriteLine(answer); } }
void OnConnect(bool success) { if (!success) { this._linker = null; } if (this._onConnect != null) { this._onConnect(success); } }
/// <summary> /// Compiles the specified type system. /// </summary> /// <param name="typeSystem">The type system.</param> /// <param name="typeLayout">The type layout.</param> /// <param name="internalTrace">The internal trace.</param> /// <param name="enabledSSA">if set to <c>true</c> [enabled ssa].</param> /// <param name="architecture">The architecture.</param> /// <param name="simAdapter">The sim adapter.</param> /// <param name="linker">The linker.</param> /// <returns></returns> public static SimCompiler Compile(TypeSystem typeSystem, MosaTypeLayout typeLayout, IInternalTrace internalTrace, bool enabledSSA, BaseArchitecture architecture, ISimAdapter simAdapter, ILinker linker) { CompilerOptions compilerOptions = new CompilerOptions(); compilerOptions.EnableSSA = enabledSSA; compilerOptions.EnableSSAOptimizations = enabledSSA; SimCompiler compiler = new SimCompiler(architecture, typeSystem, typeLayout, linker, compilerOptions, internalTrace, simAdapter); compiler.Compile(); return compiler; }
public OOPEmulator(ICompilation compilation, IMetadataImporter metadataImporter, IRuntimeLibrary runtimeLibrary, INamer namer, ILinker linker, IAttributeStore attributeStore, IErrorReporter errorReporter) { _compilation = compilation; _systemScript = new JsTypeReferenceExpression(compilation.FindType(new FullTypeName("System.Script")).GetDefinition()); _systemObject = new JsTypeReferenceExpression(compilation.FindType(KnownTypeCode.Object).GetDefinition()); _metadataImporter = metadataImporter; _runtimeLibrary = runtimeLibrary; _namer = namer; _linker = linker; _attributeStore = attributeStore; _errorReporter = errorReporter; _defaultReflectionRuntimeContext = new ReflectionRuntimeContext(false, _systemObject, _namer); _genericSpecializationReflectionRuntimeContext = new ReflectionRuntimeContext(true, _systemObject, _namer); }
/// <summary> /// Prevents a default instance of the <see cref="SimCompiler" /> class from being created. /// </summary> /// <param name="architecture">The compiler target architecture.</param> /// <param name="typeSystem">The type system.</param> /// <param name="typeLayout">The type layout.</param> /// <param name="linker">The linker.</param> /// <param name="compilerOptions">The compiler options.</param> /// <param name="internalTrace">The internal trace.</param> /// <param name="simAdapter">The sim adapter.</param> public SimCompiler(BaseArchitecture architecture, TypeSystem typeSystem, MosaTypeLayout typeLayout, ILinker linker, CompilerOptions compilerOptions, IInternalTrace internalTrace, ISimAdapter simAdapter) : base(architecture, typeSystem, typeLayout, new CompilationScheduler(typeSystem, true), internalTrace, linker, compilerOptions) { this.simAdapter = simAdapter; // Build the assembly compiler pipeline Pipeline.Add(new ICompilerStage[] { new PlugStage(), new MethodCompilerSchedulerStage(), new TypeInitializerSchedulerStage(), new SimPowerUpStage(), new TypeLayoutStage(), new MetadataStage(), new LinkerFinalizationStage(), }); architecture.ExtendCompilerPipeline(Pipeline); }
/// <summary> /// 连接到对应主机 /// </summary> /// <param name="host"></param> /// <param name="port"></param> /// <param name="sendBufferSize"></param> /// <param name="receiveBufferSize"></param> /// <param name="useAsyncSocket">true: 使用异步发送和接受, false:另开线程同步发送</param> public void Connect(string host, int port, int sendBufferSize, int receiveBufferSize, Action <bool> onConnect, bool useAsyncSocket = false) { if (this._linker != null) { return; } if (useAsyncSocket) { this._linker = new AsyncLinker(host, port, sendBufferSize, receiveBufferSize, this.ExceptionProcess); } else { this._linker = new ThdLinker(host, port, sendBufferSize, receiveBufferSize, this.ExceptionProcess); } this._onConnect = onConnect; this._linker.OnConnect += OnConnect; this._linker.Connect(); }
/// <summary> /// Initializes a new compiler instance. /// </summary> /// <param name="architecture">The compiler target architecture.</param> /// <param name="typeSystem">The type system.</param> /// <param name="typeLayout">The type layout.</param> /// <param name="compilationScheduler">The compilation scheduler.</param> /// <param name="internalTrace">The internal trace.</param> /// <param name="compilerOptions">The compiler options.</param> protected BaseCompiler(BaseArchitecture architecture, TypeSystem typeSystem, MosaTypeLayout typeLayout, ICompilationScheduler compilationScheduler, IInternalTrace internalTrace, ILinker linker, CompilerOptions compilerOptions) { if (architecture == null) throw new ArgumentNullException(@"Architecture"); Pipeline = new CompilerPipeline(); Architecture = architecture; TypeSystem = typeSystem; TypeLayout = typeLayout; InternalTrace = internalTrace; CompilerOptions = compilerOptions; Counters = new Counters(); CompilationScheduler = compilationScheduler; PlugSystem = new PlugSystem(); Linker = linker; if (Linker == null) { Linker = compilerOptions.LinkerFactory(); Linker.Initialize(compilerOptions.OutputFile, architecture.Endianness, architecture.ElfMachineType); } }
private void CreateLink(object control, object context, string controlName, object view) { if (control == null) { return; } IReadOnlyList <LinkRule> linkRules = RuleProvider.GetLinkRulesForType(control.GetType()); if (linkRules.Count <= 0) { return; } ILinker linker = LinkerManager.GetLinkerForType(control.GetType()); if (linker == null) { return; } Link(control, context, linkRules, linker, controlName, view); }
public GraphNavigationExperiment(string experimentsRoot, string experimentId, int taskCount, QuestionDialogDatasetReader seedDialogs) : base(experimentsRoot, experimentId) { _db = Configuration.Db; var phrases = LoadPhrases(seedDialogs, _db); _phrases = phrases.ToArray(); var navigationDataPath = Path.Combine(ExperimentRootPath, "navigation_data.nvd"); _data = new NavigationData(navigationDataPath); _linker = createLinker(_phrases); var writer = new CrowdFlowerCodeWriter(ExperimentRootPath, experimentId); //generate all tasks for (var taskIndex = 0; taskIndex < taskCount; ++taskIndex) { add(taskIndex, writer); } writer.Close(); }
public void RemoveLinker(ILinker linker) { m_Linkers.Remove(linker); }
public void AddLinker(ILinker linker) { m_Linkers.Add(linker); }
internal static AnswerExtractionResult evaluateExtractor(QuestionDialogDatasetReader dataset, ILinker linker, Func <QuestionDialog, IEnumerable <EntityInfo> > extractor, int n = 1) { var totalDialogCount = 0; var correctLinkCount = 0; var correctExtractionCount = 0; foreach (var dialog in dataset.Dialogs) { if (!dialog.HasCorrectAnswer) { continue; } totalDialogCount += 1; var linkedQuestion = linker.LinkUtterance(dialog.Question); //Console.WriteLine(linkedQuestion); var contextEntities = linkedQuestion.Parts.SelectMany(p => p.Entities).ToArray(); var answerPhrase = getAnswerPhrase(dialog); var linkedAnswer = linker.LinkUtterance(answerPhrase, contextEntities); var answerPhraseEntities = linkedAnswer == null ? new EntityInfo[0] : linkedAnswer.Entities; var utteranceEntities = linkedAnswer.Parts.SelectMany(p => p.Entities).ToArray(); var isLinkingCorrect = utteranceEntities.Select(e => e.Mid).Contains(dialog.AnswerMid); if (!isLinkingCorrect) { continue; } ++correctLinkCount; var denotations = extractor(dialog).Take(n).ToArray(); var isExtractionCorrect = denotations.Any(d => d.Mid == dialog.AnswerMid); if (isExtractionCorrect) { ++correctExtractionCount; } } return(new AnswerExtractionResult(1.0 * correctExtractionCount / totalDialogCount, 1.0 * correctExtractionCount / correctLinkCount)); }
public HCluster Generate(IEnumerable <T> examples, ILinker linker) { // Initialize Linker = linker; var clusters = new List <HCluster>(); var distances = new Dictionary <Tuple <int, int>, double>(); // Load data if (Description == null) { Description = Converter.GetDescription(typeof(T)).BuildDictionaries <T>(examples); } Matrix X = Converter.Convert <T>(examples, Description.Features); // Create a new cluster for each data point for (int i = 0; i < X.Rows; i++) { clusters.Add(new HCluster { Id = i, Points = new Vector[] { X[i, VectorType.Row] } }); } // Set the current closest distance/pair to the first pair of clusters var key = new Tuple <int, int>(0, 0); var distance = 0.0; var clusterId = -1; while (clusters.Count > 1) { var closestClusters = new Tuple <int, int>(0, 1); var smallestDistance = Linker.Distance(clusters[0].Points, clusters[1].Points); // Loop through each of the clusters looking for the two closest for (int i = 0; i < clusters.Count; i++) { for (int j = i + 1; j < clusters.Count; j++) { key = new Tuple <int, int>(clusters[i].Id, clusters[j].Id); // Cache the distance if it hasn't been calculated yet if (!distances.ContainsKey(key)) { distances.Add(key, Linker.Distance(clusters[i].Points, clusters[j].Points)); } // Update closest clusters and distance if necessary distance = distances[key]; if (distance < smallestDistance) { smallestDistance = distance; closestClusters = new Tuple <int, int>(i, j); } } } var min = System.Math.Min(closestClusters.Item1, closestClusters.Item2); var max = System.Math.Max(closestClusters.Item1, closestClusters.Item2); var newCluster = new HCluster(clusterId, clusters[min], clusters[max]); // Remove the merged clusters clusters.RemoveAt(min); clusters.RemoveAt(max - 1); // Add new cluster clusters.Add(newCluster); clusterId += 1; } return(clusters.Single()); }
internal LinkBasedExtractor(ILinker linker, FreebaseDbProvider db) { Db = db; Linker = linker; }
public void StartSimulator(string platform) { if (TypeSystem == null) return; Status = "Compiling..."; Architecture = GetArchitecture(platform); var simAdapter = GetSimAdaptor(platform); Linker = new SimLinker(simAdapter); compileStartTime = DateTime.Now; SimCompiler.Compile(TypeSystem, TypeLayout, InternalTrace, true, Architecture, simAdapter, Linker); SimCPU = simAdapter.SimCPU; SimCPU.Monitor.BreakAtTick = 1; SimCPU.Monitor.BreakOnException = true; SimCPU.Monitor.OnStateUpdate = UpdateSimState; SimCPU.Reset(); Display32 = SimCPU.GetState().NativeRegisterSize == 32; SimCPU.Monitor.OnExecutionStepCompleted(true); Status = "Compiled."; symbolView.CreateEntries(); }
void ICompilerStage.Setup(BaseCompiler compiler) { base.Setup(compiler); linker = RetrieveLinkerFromCompiler(); }
/// <summary> /// Initializes a new compiler instance. /// </summary> /// <param name="architecture">The compiler target architecture.</param> /// <param name="typeSystem">The type system.</param> /// <param name="typeLayout">The type layout.</param> /// <param name="compilationScheduler">The compilation scheduler.</param> /// <param name="internalTrace">The internal trace.</param> /// <param name="compilerOptions">The compiler options.</param> protected BaseCompiler(IArchitecture architecture, ITypeSystem typeSystem, ITypeLayout typeLayout, ICompilationScheduler compilationScheduler, IInternalTrace internalTrace, CompilerOptions compilerOptions) { if (architecture == null) throw new ArgumentNullException(@"architecture"); this.pipeline = new CompilerPipeline(); this.architecture = architecture; this.typeSystem = typeSystem; this.typeLayout = typeLayout; this.internalTrace = internalTrace; this.compilerOptions = compilerOptions; this.genericTypePatcher = new GenericTypePatcher(typeSystem); this.counters = new Counters(); this.compilationScheduler = compilationScheduler; this.linker = compilerOptions.Linker; this.plugSystem = new PlugSystem(); }
/// <summary> /// Initializes a new instance of <see cref="BaseCodeEmitter" />. /// </summary> /// <param name="methodName">Name of the method.</param> /// <param name="linker">The linker.</param> /// <param name="codeStream">The stream the machine code is written to.</param> /// <param name="typeSystem">The type system.</param> public void Initialize(string methodName, ILinker linker, Stream codeStream, TypeSystem typeSystem) { Debug.Assert(codeStream != null); Debug.Assert(linker != null); this.MethodName = methodName; this.linker = linker; this.codeStream = codeStream; this.codeStreamBasePosition = codeStream.Position; this.TypeSystem = typeSystem; }
/// <summary> /// Default constructor /// </summary> public MermaidResolver(ILinker linker) { m_linker = linker; }
/// <summary>Generates a clustering.</summary> /// <param name="X">The Matrix to process.</param> /// <param name="linker">The linker.</param> /// <param name="data">(Optional) the data.</param> /// <returns>The clustering.</returns> private Cluster GenerateClustering(Matrix X, ILinker linker, object[] data = null) { // Initialize this.Linker = linker; var clusters = new List <Cluster>(); var distances = new Dictionary <Tuple <int, int>, double>(); // Create a new cluster for each data point for (var i = 0; i < X.Rows; i++) { clusters.Add( new Cluster { Id = i, Points = new[] { (Vector)X.Row(i) }, Members = data != null ? new[] { data[i] } : new object[] { X.Row(i) } }); } // Set the current closest distance/pair to the first pair of clusters var key = new Tuple <int, int>(0, 0); var distance = 0.0; var clusterId = X.Rows; while (clusters.Count > 1) { var closestClusters = new Tuple <int, int>(0, 1); var smallestDistance = this.Linker.Distance(clusters[0].Points, clusters[1].Points); // this needs to be parallelized.... // Loop through each of the clusters looking for the two closest for (var i = 0; i < clusters.Count; i++) { for (var j = i + 1; j < clusters.Count; j++) { key = new Tuple <int, int>(clusters[i].Id, clusters[j].Id); // Cache the distance if it hasn't been calculated yet if (!distances.ContainsKey(key)) { distances.Add(key, this.Linker.Distance(clusters[i].Points, clusters[j].Points)); } // Update closest clusters and distance if necessary distance = distances[key]; if (distance < smallestDistance) { smallestDistance = distance; closestClusters = new Tuple <int, int>(i, j); } } } // order clusters by distance var min = Math.Min(closestClusters.Item1, closestClusters.Item2); var max = Math.Max(closestClusters.Item1, closestClusters.Item2); var newCluster = new Cluster(clusterId, clusters[min], clusters[max]); // Remove the merged clusters clusters.RemoveAt(min); clusters.RemoveAt(max - 1); // Add new cluster clusters.Add(newCluster); clusterId++; } return(clusters.Single()); }
/// <summary> /// Initializes a new instance of <see cref="BaseCodeEmitter"/>. /// </summary> /// <param name="compiler">The compiler.</param> /// <param name="codeStream">The stream the machine code is written to.</param> void ICodeEmitter.Initialize(BaseMethodCompiler compiler, Stream codeStream) { Debug.Assert(null != compiler, @"MachineCodeEmitter needs a method compiler."); if (compiler == null) throw new ArgumentNullException(@"compiler"); Debug.Assert(null != codeStream, @"MachineCodeEmitter needs a code stream."); if (codeStream == null) throw new ArgumentNullException(@"codeStream"); this.compiler = compiler; this.codeStream = codeStream; this.codeStreamBasePosition = codeStream.Position; this.linker = compiler.Linker; }
public void Process(ILinker linker, object args) { }
/// <summary> /// Default constructor /// </summary> /// <param name="composer">Injected composer</param> /// <param name="linker">Injected linker</param> /// <param name="processLogger">Process logger instance</param> public PrinterMarkdown(ITypeComposer composer, ILinker linker, IIndefiniteProcess processLogger) { m_linker = linker; m_processLogger = processLogger; m_composer = composer; }
/// <summary>Generates a clustering.</summary> /// <param name="X">The Matrix to process.</param> /// <param name="linker">The linker.</param> /// <param name="data">(Optional) the data.</param> /// <returns>The clustering.</returns> private Cluster GenerateClustering(Matrix X, ILinker linker, object[] data = null) { // Initialize Linker = linker; var clusters = new List<Cluster>(); var distances = new Dictionary<Tuple<int, int>, double>(); // Create a new cluster for each data point for (int i = 0; i < X.Rows; i++) clusters.Add(new Cluster { Id = i, Points = new Vector[] { (Vector)X.Row(i) }, Members = data != null ? new object[] { data[i] } : new object[] { X.Row(i) } }); // Set the current closest distance/pair to the first pair of clusters var key = new Tuple<int, int>(0, 0); var distance = 0.0; var clusterId = X.Rows; while (clusters.Count > 1) { var closestClusters = new Tuple<int, int>(0, 1); var smallestDistance = Linker.Distance(clusters[0].Points, clusters[1].Points); // this needs to be parallelized.... // Loop through each of the clusters looking for the two closest for (int i = 0; i < clusters.Count; i++) { for (int j = i + 1; j < clusters.Count; j++) { key = new Tuple<int, int>(clusters[i].Id, clusters[j].Id); // Cache the distance if it hasn't been calculated yet if (!distances.ContainsKey(key)) distances.Add(key, Linker.Distance(clusters[i].Points, clusters[j].Points)); // Update closest clusters and distance if necessary distance = distances[key]; if (distance < smallestDistance) { smallestDistance = distance; closestClusters = new Tuple<int, int>(i, j); } } } // order clusters by distance var min = System.Math.Min(closestClusters.Item1, closestClusters.Item2); var max = System.Math.Max(closestClusters.Item1, closestClusters.Item2); var newCluster = new Cluster(clusterId, clusters[min], clusters[max]); // Remove the merged clusters clusters.RemoveAt(min); clusters.RemoveAt(max - 1); // Add new cluster clusters.Add(newCluster); clusterId++; } return clusters.Single(); }
public HomeController(ILogger <HomeController> logger, ILinker linker) { _logger = logger; _linker = linker; }
void ExceptionProcess(ILinker linker, NetExceptionType excType, Exception exc) { }
/// <summary>Generates.</summary> /// <param name="x">The Matrix to process.</param> /// <param name="linker">The linker.</param> /// <returns>A Cluster.</returns> public Cluster Generate(Matrix x, ILinker linker) { return(this.GenerateClustering(x, linker)); }
private void Link(object control, object context, IEnumerable <LinkRule> linkRules, ILinker linker, string controlName, object view) { Type contextType = context?.GetType(); List <LinkData> linkData = new List <LinkData>(); foreach (LinkRule rule in linkRules) { LinkData data = CreateLinkData(controlName, rule, context.GetType(), context, rule.InfoName, null, view); if (data != null) { linkData.Add(data); } } //if no data found to link then return and don't call / add the linker if (linkData.Count == 0) { return; } _linkers.Add(linker); linker.Link(control, linkData, CreateLink); }
/// <summary> /// Initializes a new instance of the <see cref="AotCompiler"/> class. /// </summary> /// <param name="architecture">The architecture.</param> /// <param name="linker">The linker.</param> /// <param name="typeSystem">The type system.</param> /// <param name="typeLayout">The type layout.</param> /// <param name="internalTrace">The internal trace.</param> /// <param name="compilerOptions">The compiler options.</param> public AotCompiler(IArchitecture architecture, ILinker linker, ITypeSystem typeSystem, ITypeLayout typeLayout, IInternalTrace internalTrace, CompilerOptions compilerOptions) : base(architecture, typeSystem, typeLayout, new CompilationScheduler(typeSystem, true), internalTrace, compilerOptions) { }
void ICompilerStage.Setup(BaseCompiler compiler) { base.Setup(compiler); linker = RetrieveLinkerFromCompiler(); if (compiler.CompilerOptions.Multiboot.VideoDepth.HasValue) this.VideoDepth = compiler.CompilerOptions.Multiboot.VideoDepth.Value; if (compiler.CompilerOptions.Multiboot.VideoHeight.HasValue) this.VideoHeight = compiler.CompilerOptions.Multiboot.VideoHeight.Value; if (compiler.CompilerOptions.Multiboot.VideoMode.HasValue) this.VideoMode = compiler.CompilerOptions.Multiboot.VideoMode.Value; if (compiler.CompilerOptions.Multiboot.VideoWidth.HasValue) this.VideoWidth = compiler.CompilerOptions.Multiboot.VideoWidth.Value; }
/// <summary>Generates.</summary> /// <param name="x">The Matrix to process.</param> /// <param name="linker">The linker.</param> /// <returns>A Cluster.</returns> public Cluster Generate(Matrix x, ILinker linker) { return GenerateClustering(x, linker); }
/// <summary> /// Initializes a new instance of the <see cref="BaseMethodCompiler"/> class. /// </summary> /// <param name="compiler">The assembly compiler.</param> /// <param name="method">The method to compile by this instance.</param> /// <param name="instructionSet">The instruction set.</param> protected BaseMethodCompiler(BaseCompiler compiler, RuntimeMethod method, InstructionSet instructionSet) { this.compiler = compiler; this.method = method; this.type = method.DeclaringType; this.compilationScheduler = compiler.Scheduler; this.moduleTypeSystem = method.Module; this.architecture = compiler.Architecture; this.typeSystem = compiler.TypeSystem; this.typeLayout = Compiler.TypeLayout; this.internalTrace = Compiler.InternalTrace; this.linker = compiler.Linker; this.basicBlocks = new BasicBlocks(); this.instructionSet = instructionSet ?? new InstructionSet(256); this.pipeline = new CompilerPipeline(); this.stackLayout = new StackLayout(architecture, method.Parameters.Count + (method.Signature.HasThis || method.Signature.HasExplicitThis ? 1 : 0)); this.virtualRegisterLayout = new VirtualRegisterLayout(architecture, stackLayout); EvaluateParameterOperands(); this.stopMethodCompiler = false; }
public void Process(ILinker linker, object args) { throw new NotImplementedException(); }
internal void Execute(IConsole console, IConfigHandler configHandler, IFileSystem fileSystem, ILinker linker, IPathResolver pathResolver) { if (!configHandler.DoesConfigExist(path)) { console.WriteLine($"Config '{ path }' does not exist. Type 'help config' in order to see how you create a config file.", IConsole.ContentType.Negative); return; } IConfig config = configHandler.LoadConfig(path); console.WriteLine("\nCreating links based on config..."); int successes = 0; // Allow linkers verbose output if flag is set for this command linker.verbose = verbose; foreach (ConfigLink configLink in config.LinkList) { string resolvedSourcePath = pathResolver.GetAbsoluteResolvedPath(configLink.sourcePath, config.Variables); string resolvedTargetPath = pathResolver.GetAbsoluteResolvedPath(configLink.targetPath, config.Variables); CreateSubDirectories(console, fileSystem, pathResolver, config, resolvedTargetPath); if (fileSystem.Directory.Exists(resolvedTargetPath) || fileSystem.File.Exists(resolvedTargetPath)) { console.Write($"Path '{configLink.targetPath}' already exists", IConsole.ContentType.Negative); if (verbose) { console.Write($" (resolved to '{resolvedTargetPath}')", IConsole.ContentType.Negative); } console.WriteLine(); } else if (linker.CreateLink(resolvedSourcePath, resolvedTargetPath, configLink.linkType)) { successes++; } } console.WriteLine("\n### Finished! Created {0} / {1} links ###", successes, config.LinkList.Count); }