/// <summary>Generate the training features from the CoNLL input file.</summary> /// <returns>Dataset of feature vectors</returns> /// <exception cref="System.Exception"/> private static GeneralDataset <string, string> GenerateFeatureVectors(Properties props) { GeneralDataset <string, string> dataset = new Dataset <string, string>(); Dictionaries dict = new Dictionaries(props); DocumentMaker docMaker = new DocumentMaker(props, dict); Document document; while ((document = docMaker.NextDoc()) != null) { SetTokenIndices(document); IDictionary <int, CorefCluster> entities = document.goldCorefClusters; // Generate features for coreferent mentions with class label 1 foreach (CorefCluster entity in entities.Values) { foreach (Mention mention in entity.GetCorefMentions()) { // Ignore verbal mentions if (mention.headWord.Tag().StartsWith("V")) { continue; } IndexedWord head = mention.enhancedDependency.GetNodeByIndexSafe(mention.headWord.Index()); if (head == null) { continue; } List <string> feats = mention.GetSingletonFeatures(dict); dataset.Add(new BasicDatum <string, string>(feats, "1")); } } // Generate features for singletons with class label 0 List <CoreLabel> gold_heads = new List <CoreLabel>(); foreach (Mention gold_men in document.goldMentionsByID.Values) { gold_heads.Add(gold_men.headWord); } foreach (Mention predicted_men in document.predictedMentionsByID.Values) { SemanticGraph dep = predicted_men.enhancedDependency; IndexedWord head = dep.GetNodeByIndexSafe(predicted_men.headWord.Index()); if (head == null || !dep.VertexSet().Contains(head)) { continue; } // Ignore verbal mentions if (predicted_men.headWord.Tag().StartsWith("V")) { continue; } // If the mention is in the gold set, it is not a singleton and thus ignore if (gold_heads.Contains(predicted_men.headWord)) { continue; } dataset.Add(new BasicDatum <string, string>(predicted_men.GetSingletonFeatures(dict), "0")); } } dataset.SummaryStatistics(); return(dataset); }
public void Remove_UnknownName() { Dataset dataset = new Dataset(); dataset.Add(fooExtension); dataset.Add(barExtension); Assert.IsNull(dataset.Remove("Unknown Plug-In")); }
public void IDataset_Indexer() { Dataset dataset = new Dataset(); dataset.Add(fooExtension); dataset.Add(barExtension); Landis.PlugIns.IDataset coreDataset = dataset; AssertAreEqual(fooExtension.CoreInfo, coreDataset[fooExtension.Name]); AssertAreEqual(barExtension.CoreInfo, coreDataset[barExtension.Name]); }
public void AddNameTwice() { Dataset dataset = new Dataset(); Assert.AreEqual(0, dataset.Count); dataset.Add(fooExtension); Assert.AreEqual(1, dataset.Count); Assert.AreEqual(fooExtension, dataset[0]); Assert.AreEqual(fooExtension, dataset[fooExtension.Name]); dataset.Add(fooExtension); }
private async Task ExecuteLoadDataCommand() { if (IsBusy) { return; } IsBusy = true; try { Dataset.Clear(); var dataset = await DataStore.GetAllAsync_Score(true); //Order the scores by descending order dataset = dataset .OrderByDescending(a => a.ScoreTotal) .ToList(); foreach (var data in dataset) { Dataset.Add(data); } } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }
public async Task <bool> AddAsync(Character data) { Dataset.Add(data); var myReturn = await DataStore.AddAsync_Character(data); return(myReturn); }
async Task ExecuteLoadDataCommand() { if (IsBusy) { return; } IsBusy = true; try { Dataset.Clear(); var dataset = await DataStore.GetAllAsync_Creature(true); foreach (var data in dataset) { if (data.Type == 0)// just Characters { Dataset.Add(data); } } } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }
public async Task <bool> AddAsync(Score data) { Dataset.Add(data); var myReturn = await DataStore.AddAsync_Score(data); return(myReturn); }
public async Task <bool> AddAsync(Item data) { Dataset.Add(data); var myReturn = await DataStore.AddAsync_Item(data); return(myReturn); }
/// <summary> /// Command to load the data /// </summary> /// <returns></returns> // [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "<Pending>")] private async Task ExecuteLoadDataCommand() { if (IsBusy) { return; } IsBusy = true; try { Dataset.Clear(); var dataset = await DataStore.IndexAsync(); dataset = SortDataSet(dataset); foreach (var data in dataset) { Dataset.Add(data); } } catch (Exception e) { Debug.WriteLine(e); } finally { IsBusy = false; } }
async Task ExecuteLoadItemsCommand() { if (IsBusy) { return; } IsBusy = true; try { Dataset.Clear(); var items = await DataStore.GetAllAsync_Item(true); foreach (var item in items) { Dataset.Add(item); } } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; SetNeedsRefresh(false); } }
/// <summary> /// API to add the Data /// </summary> /// <param name="data"></param> /// <returns></returns> public async Task <bool> Add(ItemModel data) { Dataset.Add(data); var result = await DataStore.CreateAsync(data); return(true); }
public void LoadData() { Dataset.Clear(); if (CharactersViewModel.Instance.Dataset.Count == 0) { CharactersViewModel.Instance.LoadDataCommand.Execute(null); } else if (CharactersViewModel.Instance.NeedsRefresh()) { CharactersViewModel.Instance.LoadDataCommand.Execute(null); } var dataset = CharactersViewModel.Instance.GetAllCreatures(); int teamCount = 0; foreach (var data in dataset) { if ((data.Type == 0) && (teamCount < 6))//&& data.OnTeam)//the creature is a character, the team is not full, and it is on the current team { teamCount++; Creature newOne = new Creature(); newOne.Update(data); newOne.Id = Guid.NewGuid().ToString(); Dataset.Add(newOne); } } }
// Command that Loads the Data private async Task ExecuteLoadDataCommand() { if (IsBusy) { return; } IsBusy = true; try { Dataset.Clear(); var dataset = await DataStore.IndexAsync(true); // Example of how to sort the database output using a linq query. // Sort the list dataset = dataset .OrderBy(a => a.Name) .ThenBy(a => a.Description) .ToList(); foreach (var data in dataset) { Dataset.Add(data); } } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }
public async Task <bool> AddAsync(Monster data) { Dataset.Add(data); var ret = await DataStore.AddAsync_Monster(data); return(ret); }
// Command to load data into collection private async Task ExecuteLoadDataCommand() { if (IsBusy) { return; } IsBusy = true; try { Dataset.Clear(); var dataset = await DataStore.GetAllAsync_Score(true); // Load the data structure foreach (var data in dataset) { Dataset.Add(data); } SetNeedsRefresh(false); } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }
// Call to database operation for add public async Task <bool> AddAsync(Score data) { Dataset.Add(data); await DataStore.AddAsync_Score(data); return(true); }
private async Task ExecuteLoadDataCommand() { if (IsBusy) { return; } IsBusy = true; try { Dataset.Clear(); var dataset = await DataStore.GetAllAsync_Item(true); foreach (var data in dataset) { Dataset.Add(data); } } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }
private async Task ExecuteLoadDataCommand() { if (IsBusy) { return; } IsBusy = true; try { Dataset.Clear(); var dataset = await DataStore.IndexAsync(); // Example of how to sort the database output using a linq query. // Sort the list dataset = SortDataset(dataset); foreach (var data in dataset) { // Make a Copy of the Item Model to add to the List Dataset.Add(data); } } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }
/// <summary> /// Method to call before performing the actual saving. /// </summary> protected override void OnSave() { if (RootDirectoryRecord == null) { throw new InvalidOperationException("No DICOM files added, cannot save DICOM directory"); } _directoryRecordSequence.Items.Clear(); var calculator = new DicomWriteLengthCalculator(FileMetaInfo.TransferSyntax, DicomWriteOptions.Default); // ensure write length calculator does not include end of sequence item //Dataset.Remove(DicomTag.DirectoryRecordSequence); //_fileOffset = 128 + calculator.Calculate(FileMetaInfo) + calculator.Calculate(Dataset); //Add the offset for the Directory Record sequence tag itself //_fileOffset += 4;//sequence element tag if (FileMetaInfo.TransferSyntax.IsExplicitVR) { _fileOffset = 128 + calculator.Calculate(FileMetaInfo) + calculator.Calculate(Dataset); _fileOffset += 2; // vr _fileOffset += 2; // padding _fileOffset += 4; // length } else { _fileOffset = 128 + 4 + calculator.Calculate(FileMetaInfo) + calculator.Calculate(Dataset); _fileOffset += 4; //sequence element tag _fileOffset += 4; //length } AddDirectoryRecordsToSequenceItem(RootDirectoryRecord); if (RootDirectoryRecord != null) { CalculateOffsets(calculator); SetOffsets(RootDirectoryRecord); Dataset.Add <uint>( DicomTag.OffsetOfTheFirstDirectoryRecordOfTheRootDirectoryEntity, RootDirectoryRecord.Offset); var lastRoot = RootDirectoryRecord; while (lastRoot.NextDirectoryRecord != null) { lastRoot = lastRoot.NextDirectoryRecord; } Dataset.Add <uint>(DicomTag.OffsetOfTheLastDirectoryRecordOfTheRootDirectoryEntity, lastRoot.Offset); } else { Dataset.Add <uint>(DicomTag.OffsetOfTheFirstDirectoryRecordOfTheRootDirectoryEntity, 0); Dataset.Add <uint>(DicomTag.OffsetOfTheLastDirectoryRecordOfTheRootDirectoryEntity, 0); } }
public void Remove() { Dataset dataset = new Dataset(); dataset.Add(fooExtension); dataset.Add(barExtension); ExtensionInfo removedExtension = dataset.Remove(fooExtension.Name); AssertAreEqual(fooExtension, removedExtension); Assert.AreEqual(1, dataset.Count); AssertAreEqual(barExtension, dataset[0]); removedExtension = dataset.Remove(barExtension.Name); AssertAreEqual(barExtension, removedExtension); Assert.AreEqual(0, dataset.Count); }
public virtual void AddValue(WinLossKind winLossKind, bool?scoreless) { Dataset.Add(new SetElement { Value = winLossKind, Scoreless = scoreless }); }
// Add characters playing the game from the list of players in battle. public void InitializeCharacterCollection(List <Character> characters) { Dataset.Clear(); foreach (var charNew in characters) { Dataset.Add(charNew); } }
/// <summary> /// API to add the Data /// </summary> /// <param name="data"></param> /// <returns></returns> public async Task <bool> CreateAsync(ItemModel data) { Dataset.Add(data); var result = await DataStore.CreateAsync(data); SetNeedsRefresh(true); return(result); }
public void setMonsters() { Dataset.Clear(); //LoadDataCommand = new Command(async () => await ExecuteLoadDataCommand()); if (MonstersViewModel.Instance.Dataset.Count == 0) { MonstersViewModel.Instance.LoadDataCommand.Execute(null); } else if (MonstersViewModel.Instance.NeedsRefresh()) { MonstersViewModel.Instance.LoadDataCommand.Execute(null); } var dataset = MonstersViewModel.Instance.GetAllCreatures(); var tempDataset = new List <Creature>(); int dateSeed = DateTime.Now.Millisecond; Random rand = new Random(dateSeed); foreach (var data in dataset) { if (data.Type == 1)// just Monsters { Creature newOne = new Creature(); newOne.Update(data); tempDataset.Add(newOne); } } for (int i = 0; i < 6; i++) { int index = rand.Next(tempDataset.Count); if (GameGlobals.DisableRandomNumbers) { index = 0; } Creature monster = new Creature(); monster.Update(tempDataset[index]); //get a random monster type monster.Id = "monster" + i.ToString(); //Guid.NewGuid().ToString(); monster.Alive = true; monster.Level = round; monster.XP = lp[round].XP; monster.Attack = lp[round].Attack; monster.Defense = lp[round].Defense; monster.Speed = lp[round].Speed; int healthRand = rand.Next(11); if (GameGlobals.DisableRandomNumbers) { healthRand = 1; } monster.MaxHealth = healthRand * round; monster.CurrHealth = monster.MaxHealth; monster.RHandItemID = "bow";// ***temp for demo*** monster.BodyItemID = "helmet"; monster.FeetItemID = "boots"; Dataset.Add(monster); } }
public void SaveAs() { Dataset dataset = new Dataset(); dataset.Add(fooExtension); dataset.Add(barExtension); eventDataset = null; string path = Data.MakeOutputPath("SaveAs_Test.xml"); dataset.SaveAs(path); Assert.AreEqual(path, dataset.Path); Assert.AreSame(dataset, eventDataset); Dataset loadedDataset = new Dataset(path); Assert.IsNotNull(loadedDataset); AssertAreEqual(dataset, loadedDataset); }
/// <summary> /// This method is for the game engine to call to add an item to the item list /// It is not async, so it can be called from the game engine on it's thread /// It sets the needs refresh flag /// Items added to the list this way, are not saved to the DB, they are temporary during the game. /// Refactor for the future would be to create a separate item list for the game to add to, and work with. /// </summary> /// <param name="data"></param> /// <returns></returns> public bool Create_Sync(T data) { if (data == null) { return(false); } Dataset.Add(data); SetNeedsRefresh(true); return(true); }
public void clean() { List <Item> clean = Dataset.ToList(); Dataset.Clear(); foreach (var data in clean.Where(x => x != null)) { Dataset.Add(data); } }
//--------------------------------------------------------------------- /// <summary> /// Executes the command. /// </summary> public void Execute() { #if ENABLE_OLD_CODE // TODO: This code is from the old AddCommand, so it needs to be // updated eventually. Dataset dataset = Dataset.LoadOrCreate(Dataset.DefaultPath); EditableExtensionInfo.Dataset = dataset; ExtensionParser parser = new ExtensionParser(); ExtensionInfo extension = Data.Load <ExtensionInfo>(extensionInfoPath, parser); List <string> missingLibs = new List <string>(); foreach (string library in extension.ReferencedAssemblies) { if (!dataset.ReferencedByEntries(library)) { missingLibs.Add(library); } } List <string> libsToBeInstalled = new List <string>(); foreach (string libPath in extension.LibraryPaths) { libsToBeInstalled.Add(Path.GetFileNameWithoutExtension(libPath)); } foreach (string libToBeInstalled in libsToBeInstalled) { missingLibs.Remove(libToBeInstalled); } if (missingLibs.Count > 0) { MultiLineText message = new MultiLineText(); message.Add("Error: The extension requires the following libraries which are not"); message.Add(" currently installed and are not listed in the extension info file:"); foreach (string lib in missingLibs) { message.Add(" " + lib); } throw new MultiLineException(message); } Console.WriteLine("Installation directory: {0}", installDir); Console.WriteLine("Copying files to installation directory ..."); CopyFileToInstallDir(extension.AssemblyPath); foreach (string libPath in extension.LibraryPaths) { CopyFileToInstallDir(libPath); } dataset.Add(extension); dataset.Save(); Console.WriteLine("Extension {0} installed", extension.Name); #endif }
private async Task ExecuteLoadDataCommand() { if (IsBusy) { return; } IsBusy = true; try { Dataset.Clear(); DatasetParty.Clear(); var dataset = await DataStore.GetAllAsync_Character(true); dataset = dataset .OrderBy(a => a.Level) .ThenBy(a => a.Name) .ThenBy(a => a.Speed) .ThenByDescending(a => a.MaximumHealth) .ToList(); // var datasett = await DataStore.GetPartyAsync_Character(true); foreach (var data in dataset) { Dataset.Add(data); } Dataset = new ObservableCollection <Character>(Dataset.OrderBy(a => a.Level) .ThenBy(a => a.Name) .ThenBy(a => a.Speed) .ThenByDescending(a => a.MaximumHealth) .ToList()); foreach (var data in dataset) { if (PartyList.Contains(data.Id)) { DatasetParty.Add(data); } //DatasetParty = new ObservableCollection<Character>(DatasetParty.OrderBy(a => a.Level) //.ThenBy(a => a.Name) //.ThenBy(a => a.Speed) //.ThenByDescending(a => a.MaximumHealth) //.ToList()); } } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }