public void exportVariety(string varietyName, int agreement, DateTime startingDate, DateTime endingDate)
{
XSSFWorkbook workbook = new XSSFWorkbook();
XSSFSheet sheet = (XSSFSheet)workbook.CreateSheet("Sheet1");
setColumnWidth(sheet);
initStyle(workbook);
//第一行，品种、起止时间
XSSFRow row0 = (XSSFRow)sheet.CreateRow(0);
setRowHeight(row0);
XSSFCell cell = (XSSFCell)row0.CreateCell(0);
cell.CellStyle = headerStyle;
cell.SetCellValue(varietyName + Variety.getAgreementName(agreement));
sheet.AddMergedRegion(new NPOI.SS.Util.CellRangeAddress(0, 0, 1, 2));
cell = (XSSFCell)row0.CreateCell(2);
cell.CellStyle = headerStyle;
cell = (XSSFCell)row0.CreateCell(1);
cell.CellStyle = headerStyle;
cell.SetCellValue(Utils.formatDate(startingDate) + "-" + Utils.formatDate(endingDate));
excelFilePath = Utils.getExportDir() + varietyName + "_" + Variety.getAgreementName(agreement) + "_" + Utils.getDate() + "_回测" + "_" + Utils.getTimeMillisecond() + ".xlsx";
FileStream file = new FileStream(excelFilePath, FileMode.Create);
workbook.Write(file);
file.Close();
}
public async Task <IActionResult> Edit(int id, [Bind("VarietyId,CropId,Name")] Variety variety)
{
if (id != variety.VarietyId)
{
ModelState.AddModelError("", "The variety is for a different variety ID than your asked for.");
}
if (ModelState.IsValid)
{
try
{
_context.Update(variety);
await _context.SaveChangesAsync();
TempData["message"] = $"Variety updated: {variety.Name}";
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
while (ex.InnerException != null)
{
ex = ex.InnerException;
}
ModelState.AddModelError("", $"exception updating album: {ex.Message}");
}
}
Create();
return(View(variety));
}
public void VarietyEqualsOne()
{
var actors = new List <Actor>
{
new Actor(1, "a1"),
new Actor(2, "a2")
};
var network = new Network
{
Actors = actors,
Layers = new List <Layer>
{
new Layer
{
Edges = new List <Edge>
{
new Edge(actors[0], actors[1])
}
},
new Layer
{
Edges = new List <Edge>
{
new Edge(actors[0], actors[1])
}
}
}
};
var community = new Community(actors);
Assert.Equal(1, Variety.Compute(community, network));
}
public Variety Get(Guid id)
{
Variety variety = null;
SqlCommand cmd = _unitOfWork.CreateCommand();
cmd.CommandText = "Select VarietyId, Name, CreateDate, LastModifiedDate From dbo.Varieties Where VarietyId = @VarietyId";
cmd.Parameters.AddWithValue("@VarietyId", id);
using (SqlDataReader infoReader = cmd.ExecuteReader())
{
if (infoReader.Read())
{
int idxVarietyId = infoReader.GetOrdinal("VarietyId");
int idxName = infoReader.GetOrdinal("Name");
int idxCreateDate = infoReader.GetOrdinal("CreateDate");
int idxLastModifiedDate = infoReader.GetOrdinal("LastModifiedDate");
variety = new Variety(
EntityId.ForExistingEntity(infoReader.GetGuid(idxVarietyId)),
new TimeStamp(infoReader.GetDateTimeOffset(idxCreateDate).DateTime,
infoReader.GetSafeDateTimeOffset(idxLastModifiedDate)),
infoReader.GetString(idxName));
}
}
return(variety);
}
public async Task <IActionResult> Edit(int id, [Bind("VarietyId,CropId,Name")] Variety variety)
{
if (id != variety.VarietyId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(variety);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VarietyExists(variety.VarietyId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CropId"] = new SelectList(_context.Crop, "CropId", "CropId", variety.CropId);
return(View(variety));
}
public void Save(Variety variety)
{
SqlCommand cmd = _unitOfWork.CreateCommand();
if (variety.IsNew)
{
cmd.CommandText = "insert into dbo.Varieties(VarietyId, Name, CreateDate) values(@VarietyId, @Name, @CreateDate)";
cmd.Parameters.AddWithValue("@VarietyId", variety.Id);
cmd.Parameters.AddWithValue("@Name", variety.Name);
cmd.Parameters.AddWithValue("@CreateDate", DateTime.UtcNow);
}
else
{
cmd.CommandText = "update dbo.Varieties Set Name = @Name, LastModifiedDate = @LastModifiedDate Where VarietyId = @VarietyId";
cmd.Parameters.AddWithValue("@VarietyId", variety.Id);
cmd.Parameters.AddWithValue("@Name", variety.Name);
variety.UpdateTimeStamp();
cmd.Parameters.AddWithValue("@LastModifiedDate", variety.TimeStamp.LastModifiedDate);
}
cmd.ExecuteNonQuery();
variety.AcceptChanges();
}
public EditVarietyViewModel(IKeyedCollection <string, Variety> varieties, Variety variety)
{
_title = "Rename Variety";
_varieties = varieties;
_variety = variety;
_name = variety.Name;
}
public EditRegionViewModel(IEnumerable <Variety> varieties, Variety variety, GeographicRegion region)
{
_title = "Edit Region";
_varieties = new ReadOnlyList <VarietyViewModel>(varieties.Select(v => new VarietyViewModel(v)).OrderBy(vm => vm.Name).ToArray());
_selectedVariety = _varieties.First(vm => vm.DomainVariety == variety);
_description = region.Description;
}
public void Segment(Variety variety)
{
_busyService.ShowBusyIndicatorUntilFinishDrawing();
var pipeline = new Pipeline <Variety>(GetSegmentProcessors());
pipeline.Process(variety.ToEnumerable());
}
public SegmentsVarietyViewModel(SegmentsViewModel segmentsViewModel, Variety variety)
: base(variety)
{
_segments = new MirroredBindableList <Segment, VarietySegmentViewModel>(segmentsViewModel.DomainSegments,
segment => new VarietySegmentViewModel(this, segment, segmentsViewModel.DomainSyllablePosition), viewModel => viewModel.DomainSegment);
_switchToVarietyCommand = new RelayCommand(() => Messenger.Default.Send(new SwitchViewMessage(typeof(VarietiesViewModel), DomainVariety)));
}
public void CreateNewVarietyThatIsNotYetPersisted()
{
Variety variety = new Variety("Greens");
Assert.True(variety.IsNew);
Assert.Equal("Greens", variety.Name);
}
public void Process(VarietyPair varietyPair)
{
int num = 0;
IProcessor <VarietyPair>[] processors = _processorIDs.Select(id => _project.VarietyPairProcessors[id]).ToArray();
for (int n = 0; n < _iterationCount; n++)
{
var randVariety2 = new Variety(varietyPair.Variety2.Name + "-rand" + n);
randVariety2.Words.AddRange(varietyPair.Variety2.Words.Meanings.OrderBy(gloss => Guid.NewGuid())
.Zip(varietyPair.Variety2.Words.Meanings.Select(meaning => varietyPair.Variety2.Words[meaning].FirstOrDefault()).Where(word => word != null),
(meaning, word) => new Word(word.StrRep, word.StemIndex, word.StemLength, meaning)
{
Shape = word.Shape
}));
var randVarietyPair = new VarietyPair(varietyPair.Variety1, randVariety2);
foreach (IProcessor <VarietyPair> processor in processors)
{
processor.Process(randVarietyPair);
}
if (randVarietyPair.LexicalSimilarityScore >= varietyPair.LexicalSimilarityScore)
{
num++;
}
}
varietyPair.Significance = (double)num / _iterationCount;
}
public void VarietyEqualsZero()
{
var actors = new List <Actor>
{
new Actor(1, "a1"),
new Actor(2, "a2"),
new Actor(3, "a3"),
new Actor(4, "a4")
};
var network = new Network
{
Actors = actors,
Layers = new List <Layer>
{
new Layer
{
Edges = new List <Edge>
{
new Edge(actors[0], actors[1])
}
},
new Layer
{
Edges = new List <Edge>
{
new Edge(actors[2], actors[3])
}
}
}
};
var community = new Community(actors.GetRange(0, 2));
Assert.Equal(0, Variety.Compute(community, network));
}
public async Task <bool> UpdateVariety(string cropId, Variety variety)
{
var filter = Builders <Crop> .Filter.Where(m => m.CropId == cropId && m.Varieties.Any(f => f.VarietyId == variety.VarietyId));
var update = Builders <Crop> .Update.Set(x => x.Varieties[-1], variety);
return(await base.Update(filter, update));
}
public async Task <bool> AddVariety(string cropId, Variety variety)
{
var filter = Builders <Crop> .Filter.Where(m => m.CropId == cropId);
var update = Builders <Crop> .Update.Push(x => x.Varieties, variety);
return(await base.Update(filter, update));
}
public void SavingVarietyResetsIsNewFlag()
{
Variety newVariety = new Variety("plum tomatoes");
repo.Save(newVariety);
Assert.False(newVariety.IsNew);
}
public SimilarityMatrixVarietyPairViewModel(SimilarityMetric similarityMetric, Variety thisVariety, VarietyPair varietyPair)
{
_varietyPair = varietyPair;
_thisVariety = thisVariety;
_otherVariety = _varietyPair.GetOtherVariety(_thisVariety);
_switchToVarietyPairCommand = new RelayCommand(SwitchToVarietyPair);
_similarityMetric = similarityMetric;
}
public ActionResult DeleteConfirmed(int id)
{
Variety variety = db.Varieties.Find(id);
db.Varieties.Remove(variety);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void DirectSeedingCropCreatesSinglePlanting()
{
Variety corn = new Variety("corn");
CropPlan cropPlan = CropPlan.DirectSeed(corn).StartOn(new DateTime(2017, 4, 5));
Assert.Equal(1, cropPlan.Plantings.Count);
Assert.Equal(new DateTime(2017, 4, 5), cropPlan.Plantings[0].PlanDate);
}
public void GetVarietyAfterSaving()
{
Variety newVariety = new Variety("plum tomatoes");
repo.Save(newVariety);
Variety savedVariety = repo.Get(newVariety.Id);
Assert.NotNull(savedVariety);
Assert.Equal("plum tomatoes", savedVariety.Name);
}
private CogProject CreateProject()
{
var project = new CogProject();
var variety1 = new Variety("variety1");
project.Varieties.Add(variety1);
var variety2 = new Variety("variety2");
project.Varieties.Add(variety2);
var variety3 = new Variety("variety3");
project.Varieties.Add(variety3);
var meaning1 = new Meaning("meaning1", null);
project.Meanings.Add(meaning1);
var meaning2 = new Meaning("meaning2", null);
project.Meanings.Add(meaning2);
var meaning3 = new Meaning("meaning3", null);
project.Meanings.Add(meaning3);
variety1.Words.Add(new Word("word1", meaning1));
variety1.Words.Add(new Word("word2", meaning2));
variety1.Words.Add(new Word("word3", meaning3));
variety2.Words.Add(new Word("word4", meaning1));
variety2.Words.Add(new Word("word5", meaning2));
variety2.Words.Add(new Word("word6", meaning3));
variety3.Words.Add(new Word("word7", meaning1));
variety3.Words.Add(new Word("word8", meaning2));
variety3.Words.Add(new Word("word9", meaning3));
var vpGenerator = new VarietyPairGenerator();
vpGenerator.Process(project);
double score = 1.0;
foreach (VarietyPair vp in project.VarietyPairs)
{
foreach (Meaning meaning in project.Meanings)
{
Word w1 = vp.Variety1.Words[meaning].First();
Word w2 = vp.Variety2.Words[meaning].First();
WordPair wp = vp.WordPairs.Add(w1, w2);
wp.PredictedCognacyScore = score;
wp.PredictedCognacy = true;
score -= 0.1;
}
}
return(project);
}
internal async void AddVariety(string name, string notes, int plantId, string plantName, int varietyId)
{
if (varietyId == 0)
{
var variety = new Variety {
Name = name, PlantId = plantId
};
await _varietyRepository.Insert(variety);
if (!string.IsNullOrEmpty(notes))
{
await _noteRepository.Insert(
new Note
{
Type = (int)NoteType.Variety,
TypeId = variety.ID,
Notes = notes,
Meta = string.Format("{0}{1} [{2}]", (int)NoteType.Variety, plantName, name)
});
}
}
else
{
var variety = await _varietyRepository.Get(varietyId);
variety.Name = name;
await _varietyRepository.Update(variety);
var note = await _noteRepository.Get(predicate : x => x.Type == (int)NoteType.Variety && x.TypeId == varietyId);
if (note == null)
{
if (!string.IsNullOrEmpty(notes))
{
await _noteRepository.Insert(
new Note
{
Type = (int)NoteType.Variety,
TypeId = varietyId,
Notes = notes,
Meta = string.Format("{0}{1} [{2}]", (int)NoteType.Variety, plantName, name)
});
}
}
else
{
note.Type = (int)NoteType.Variety;
note.TypeId = varietyId;
note.Notes = notes;
note.Meta = string.Format("{0}{1} [{2}]", (int)NoteType.Variety, plantName, name);
await _noteRepository.Update(note);
}
}
}
public async Task <IActionResult> Create([Bind("Id,Name")] Variety variety)
{
if (ModelState.IsValid)
{
_context.Add(variety);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(variety));
}
public void Import(object importSettingsViewModel, Stream stream, CogProject project)
{
var reader = new CsvReader(new StreamReader(stream), ',');
if (!SkipRows(reader, 5))
{
project.Meanings.Clear();
project.Varieties.Clear();
return;
}
var varieties = new List <Variety>();
var meanings = new Dictionary <string, Meaning>();
IList <string> varietyRow;
while (reader.ReadRow(out varietyRow))
{
if (string.IsNullOrEmpty(varietyRow[0]))
{
break;
}
var variety = new Variety(varietyRow[0].Trim());
if (!SkipRows(reader, 2))
{
throw new ImportException("Metadata for a variety is incomplete.");
}
Meaning curMeaning = null;
IList <string> glossRow;
while (reader.ReadRow(out glossRow) && glossRow.Any(s => !string.IsNullOrEmpty(s)))
{
if (!string.IsNullOrEmpty(glossRow[0]))
{
string gloss = glossRow[0].Trim();
curMeaning = meanings.GetValue(gloss, () => new Meaning(gloss, null));
}
if (curMeaning == null)
{
throw new ImportException("A gloss is missing.");
}
string wordStr = glossRow[1].Trim();
if (!string.IsNullOrEmpty(wordStr))
{
variety.Words.Add(new Word(wordStr, curMeaning));
}
}
varieties.Add(variety);
}
project.Meanings.ReplaceAll(meanings.Values);
project.Varieties.ReplaceAll(varieties);
}
public async Task <IActionResult> Create([Bind("CropId,Name")] Variety variety)
{
if (ModelState.IsValid)
{
_context.Add(variety);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
//ViewData["CropId"] = new SelectList(_context.Crop, "CropId", "CropId", variety.CropId);
return(View(variety));
}
public async Task <IActionResult> Create([Bind("VarietyId,CropId,Name")] Variety variety)
{
if (ModelState.IsValid)
{
_context.Add(variety);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["CropId"] = HttpContext.Session.GetString("cropidSession");
return(View(variety));
}
private void AddNewVariety()
{
var vm = new EditVarietyViewModel(_projectService.Project.Varieties);
if (_dialogService.ShowModalDialog(this, vm) == true)
{
var variety = new Variety(vm.Name);
_projectService.Project.Varieties.Add(variety);
_analysisService.Segment(variety);
Messenger.Default.Send(new DomainModelChangedMessage(true));
}
}
public ActionResult Edit([Bind(Include = "Id,ProductId,SizeId,ColorId,Quantity")] Variety variety)
{
if (ModelState.IsValid)
{
db.Entry(variety).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ColorId = new SelectList(db.Colors, "Id", "Label", variety.ColorId);
ViewBag.ProductId = new SelectList(db.Products, "Id", "Name", variety.ProductId);
ViewBag.SizeId = new SelectList(db.Sizes, "Id", "Label", variety.SizeId);
return(View(variety));
}
public async Task <IActionResult> Create([Bind("VarietyId,CropId,Name")] Variety variety)
{
if (ModelState.IsValid)
{
variety.CropId = Convert.ToInt32(Request.Cookies["cropId_Variety"]);
_context.Add(variety);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["CropId"] = new SelectList(_context.Crop, "CropId", "CropId", variety.CropId);
return(View(variety));
}
public void Stem(StemmingMethod method, Variety variety)
{
_busyService.ShowBusyIndicatorUntilFinishDrawing();
if (method == StemmingMethod.Automatic)
{
variety.Affixes.Clear();
}
var pipeline = new Pipeline <Variety>(GetStemProcessors(method));
pipeline.Process(variety.ToEnumerable());
Messenger.Default.Send(new DomainModelChangedMessage(true));
}
public override void Process(Variety data)
{
var initialOnsets = new HashSet<string>();
foreach (Word word in data.Words.Where(w => w.IsValid))
{
string prefixOnset = GetInitialOnset(word.Prefix);
if (prefixOnset != null)
initialOnsets.Add(prefixOnset);
string stemOnset = GetInitialOnset(word.Stem);
if (stemOnset != null)
initialOnsets.Add(stemOnset);
}
_initialOnsets.Value = initialOnsets;
base.Process(data);
_initialOnsets.Value = null;
}
public void SetUp()
{
_featSys = new FeatureSystem
{
new SymbolicFeature("place",
new FeatureSymbol("bilabial"),
new FeatureSymbol("labiodental"),
new FeatureSymbol("dental"),
new FeatureSymbol("alveolar"),
new FeatureSymbol("retroflex"),
new FeatureSymbol("palato-alveolar"),
new FeatureSymbol("palatal"),
new FeatureSymbol("velar"),
new FeatureSymbol("uvular"),
new FeatureSymbol("pharyngeal"),
new FeatureSymbol("glottal")),
new SymbolicFeature("manner",
new FeatureSymbol("stop"),
new FeatureSymbol("affricate"),
new FeatureSymbol("fricative"),
new FeatureSymbol("approximant"),
new FeatureSymbol("trill"),
new FeatureSymbol("flap"),
new FeatureSymbol("close-vowel"),
new FeatureSymbol("mid-vowel"),
new FeatureSymbol("open-vowel")),
new SymbolicFeature("voice",
new FeatureSymbol("voice+"),
new FeatureSymbol("voice-")),
new SymbolicFeature("height",
new FeatureSymbol("close"),
new FeatureSymbol("near-close"),
new FeatureSymbol("close-mid"),
new FeatureSymbol("mid"),
new FeatureSymbol("open-mid"),
new FeatureSymbol("near-open"),
new FeatureSymbol("open")),
new SymbolicFeature("backness",
new FeatureSymbol("front"),
new FeatureSymbol("near-front"),
new FeatureSymbol("central"),
new FeatureSymbol("near-back"),
new FeatureSymbol("back")),
new SymbolicFeature("round",
new FeatureSymbol("round+"),
new FeatureSymbol("round-"))
};
_segmentPool = new SegmentPool();
_segmenter = new Segmenter(_spanFactory)
{
Consonants =
{
{"c", FeatureStruct.New(_featSys).Symbol("palatal").Symbol("stop").Symbol("voice-").Value},
{"b", FeatureStruct.New(_featSys).Symbol("bilabial").Symbol("stop").Symbol("voice+").Value},
{"r", FeatureStruct.New(_featSys).Symbol("alveolar").Symbol("trill").Symbol("voice+").Value}
},
Vowels =
{
{"a", FeatureStruct.New(_featSys).Symbol("open").Symbol("front").Symbol("round-").Symbol("open-vowel").Symbol("voice+").Value}
},
Boundaries = {"-"},
Modifiers = {"\u0303", "\u0308"},
Joiners = {"\u0361"}
};
var syllabifier = new SimpleSyllabifier(false, false);
var meaning = new Meaning("test", null);
var v1 = new Variety("variety1");
_word1 = new Word("car", meaning);
_segmenter.Segment(_word1);
v1.Words.Add(_word1);
syllabifier.Process(v1);
var v2 = new Variety("variety2");
_word2 = new Word("bar", meaning);
_segmenter.Segment(_word2);
v2.Words.Add(_word2);
syllabifier.Process(v2);
var vp = new VarietyPair(v1, v2);
vp.SoundChangeFrequencyDistribution = new ConditionalFrequencyDistribution<SoundContext, Ngram<Segment>>();
vp.SoundChangeFrequencyDistribution[_word1.Shape.First.ToSoundContext(_segmentPool, Enumerable.Empty<SoundClass>())].Increment(_segmentPool.Get(_word2.Shape.First));
vp.SoundChangeProbabilityDistribution = new ConditionalProbabilityDistribution<SoundContext, Ngram<Segment>>(vp.SoundChangeFrequencyDistribution,
(sc, fd) => new MaxLikelihoodProbabilityDistribution<Ngram<Segment>>(fd));
v1.VarietyPairs.VarietyPairAdded(vp);
v2.VarietyPairs.VarietyPairAdded(vp);
}
public Palette(float hue, float degree, Variety variation)
{
this.genes = new DNA();
this.hue = hue;
this.hueLeft = hue - degree;
this.hueRight = hue + degree;
this.degree = degree;
this.variation = variation;
this.DefineColourPrimes();
}
