public Part(double trackPosition, double playTime, RangeDictionary <double, Note> note, RangeDictionary <double, double> pitchBend)
{
TrackPosition = trackPosition;
PlayTime = playTime;
Note = note;
PitchBend = pitchBend;
}
private WaveLineCache(int sampleCount, int sampleRate, string hash, RangeDictionary <double, WaveLine> lines)
{
SampleCount = sampleCount;
SampleRate = sampleRate;
Hash = hash;
WaveLines = lines;
}
public Vibrato(int vibratoType, double vibratoLength, RangeDictionary <double, int> vibratoDepth, RangeDictionary <double, int> vibratoRate)
{
VibratoType = vibratoType;
VibratoLength = vibratoLength;
VibratoDepth = vibratoDepth;
VibratoRate = vibratoRate;
}
internal void SetRangesDictionary(string[,] rangeValues)
{
int classOrdinal = 1;
string limitType = "rampStart";
string compound = string.Empty;
RangeDictionary.Clear();
foreach (string value in rangeValues)
{
if (value == null)
{
break;
}
compound = limitType + string.Format("{0:D2}", classOrdinal);
RangeDictionary.Add(compound, value);
if (limitType == "rampStart")
{
limitType = "rampEnd";
}
else
{
limitType = "rampStart";
classOrdinal++;
}
}
}
RangeDictionary <double, int> GetValue(VprValue[] values, int pos, RangeDictionary <int, Tempo> tempo)
{
return(values.ToRangeDictionary(
p => tempo[pos + p.Pos].TickToTime(pos + p.Pos),
p => p.Value,
IntervalMode.OpenInterval
));
}
Vibrato GetVibratoInfo(IVSNote note, int partTick, double noteLength, RangeDictionary <int, Tempo> tempo)
{
var vibDepth = GetNoteStyle(note, "vibDep", partTick, tempo);
var vibRate = GetNoteStyle(note, "vibRate", partTick, tempo);
var vibLength = note.NStyle.Attrs.FirstOrDefault((st) => st.ID == "vibLen")?.Value ?? 0;
var vibType = note.NStyle.Attrs.FirstOrDefault((st) => st.ID == "vibType")?.Value ?? 0;
return(new Vibrato(vibType, vibLength * 0.01 * noteLength, vibDepth, vibRate));
}
public string GetAt(string key)
{
if (RangeDictionary.ContainsKey(key) == false)
{
RangeDictionary.Add(key, "");
}
return(RangeDictionary[key]);
}
public IEnumerable <StringField> RangeGetField(SubjectGroup subjectGroup)
{
var subjectId = subjectGroup.Id.ToInt();
return(RangeDictionary.ContainsKey(subjectId)
? RangeDictionary[subjectId]
.Select(x => new StringField(Labels.Range.ToString(), x.ToString(), Field.Store.YES))
: new List <StringField>());
}
public void Add(string key, string value)
{
if (RangeDictionary.ContainsKey(key))
{
RangeDictionary[key] = value;
}
else
{
RangeDictionary.Add(key, value);
}
}
public string GetAt(int pos)
{
if (RangeDictionary.ContainsKey(ChoroplethConstants.legendTextControlPrefix + pos))
{
return(RangeDictionary[ChoroplethConstants.legendTextControlPrefix + pos]);
}
else
{
return("");
}
}
public static WaveLineCache CreateCache(double[] wave, int sampleRate, string hash)
{
var center = DefaultPathHeight * 0.5;
var lines = new RangeDictionary <double, WaveLine>(IntervalMode.OpenInterval);
lines.Add(0.0, new WaveLine(wave.Select((w) => new float[] { (float)(w * center + center) }).ToArray(), WaveLineType.PolyLine));
foreach (var r in ReductionCounts)
{
lines.Add(r, new WaveLine(CreateReductedWaveLine(wave, r), WaveLineType.Bar));
}
return(new WaveLineCache(wave.Length, sampleRate, hash, lines));
}
public void Range_소팅테스트_Int()
{
// Arrange
RangeDictionary <int, string> rangeDictionary = new RangeDictionary <int, string>();
for (int i = 0; i < 10; i += 2)
{
Assert.IsTrue(rangeDictionary.Add(i, i + 1, $"{i}~{i + 1}"));
}
// Act && Assert
Assert.AreEqual(rangeDictionary.Keys.Min().Min, 0);
Assert.AreEqual(rangeDictionary.Keys.Max().Max, 9);
}
public void RangeDictionary_Dont_Add_OverlapRange()
{
// Arrange
RangeDictionary <int, string> rangeDictionary = new RangeDictionary <int, string>();
// Act && Assert
Assert.IsTrue(rangeDictionary.Add(1, 10, "1~10"));
Assert.IsFalse(rangeDictionary.Add(5, 10, "5~10")); // Fail
Assert.IsTrue(rangeDictionary.Add(11, 20, "11~20"));
Assert.IsTrue(rangeDictionary.Remove(1, 10));
Assert.IsTrue(rangeDictionary.Add(5, 10, "5~10")); // 위에선 실패했으나 이제 성공
}
public void Range_소팅테스트_DateTime()
{
// Arrange
DateTime sDateTimeNow = DateTime.Now;
RangeDictionary <DateTime, string> rangeDictionary = new RangeDictionary <DateTime, string>();
for (int i = 0; i < 10; i += 2)
{
Assert.IsTrue(rangeDictionary.Add(sDateTimeNow.AddSeconds(i), sDateTimeNow.AddSeconds(i + 1), $"{sDateTimeNow}~{sDateTimeNow}"));
}
// Act && Assert
Assert.AreEqual(rangeDictionary.Keys.Min().Min, sDateTimeNow);
Assert.AreEqual(rangeDictionary.Keys.Max().Max, sDateTimeNow.AddSeconds(9));
}
internal int GetClassLevelWithKey(string name)
{
int result = -1;
if (RangeDictionary.ContainsKey(name) == false)
{
return(result);
}
string parse = name.Replace("rampStart", "").Replace("rampEnd", "");
int.TryParse(parse, out result);
return(result - 1);
}
internal ClassLimitType GetLimitTypeWithKey(string name)
{
ClassLimitType limitType = ClassLimitType.Indeterminate;
if (RangeDictionary.ContainsKey(name) == false)
{
return(limitType);
}
if (name.Contains("Start"))
{
return(ClassLimitType.Start);
}
else
{
return(ClassLimitType.End);
}
}
public static RangeDictionary <TKey, TValue> ToRangeDictionary <TSource, TKey, TValue>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TValue> valueSelector, IntervalMode intervalMode) where TKey : IComparable <TKey>
{
var result = new RangeDictionary <TKey, TValue>(intervalMode);
foreach (var v in source)
{
var key = keySelector(v);
if (!result.ContainsKey(key))
{
result.Add(keySelector(v), valueSelector(v));
}
else
{
result[key] = valueSelector(v);
}
}
return(result);
}
public void RangeDictionary_Is_Working()
{
// Arrange
RangeDictionary <int, string> rangeDictionary = new RangeDictionary <int, string>();
// Act
Assert.IsTrue(rangeDictionary.Add(-10, 0, "-10~0"));
Assert.IsTrue(rangeDictionary.Add(1, 10, "1~10"));
Assert.IsTrue(rangeDictionary.Add(11, 20, "11~20"));
// Assert
// True Case
for (int i = -10; i <= 0; i++)
{
Assert.AreEqual(rangeDictionary.GetValue(i), "-10~0");
}
for (int i = 1; i <= 10; i++)
{
Assert.AreEqual(rangeDictionary.GetValue(i), "1~10");
}
for (int i = 11; i <= 20; i++)
{
Assert.AreEqual(rangeDictionary.GetValue(i), "11~20");
}
// False Case
for (int i = 0; i < 10; i++)
{
Assert.AreNotEqual(rangeDictionary.GetValue(UnityEngine.Random.Range(11, 100000)), "1~10");
}
// Null Case
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(rangeDictionary.GetValue(UnityEngine.Random.Range(21, 100000)), null);
}
}
public void 레인지딕셔너리는_IDictionary를_상속받습니다()
{
RangeDictionary <int, string> rangeDictionary = new RangeDictionary <int, string>();
Assert.IsTrue(rangeDictionary.Add(1, 10, "1~10"));
Assert.IsTrue(rangeDictionary.Add(11, 20, "11~20"));
Dictionary <Range <int>, string> dictionary_Readonly = new Dictionary <Range <int>, string>(rangeDictionary, new Range <int> .Comparer());
int iValue = 1;
Assert.IsTrue(rangeDictionary.ContainsKey(iValue));
// Todo 차후 해야함
// Assert.IsTrue(dictionary_Readonly.ContainsKey(iValue));
// Assert.AreEqual(rangeDictionary[iValue], dictionary_Readonly[new Range<int>(iValue)]);
// Assert.AreEqual(rangeDictionary[iValue], dictionary_Readonly[iValue]);
}
Vibrato GetVibratoInfo(VprNote note, int partTick, RangeDictionary <int, Tempo> tempo)
{
var vibrato = note.Vibrato;
if (vibrato.Depths == null || vibrato.Rates == null)
{
return(new Vibrato(0, 0.0, new RangeDictionary <double, int>(IntervalMode.OpenInterval, new Dictionary <double, int> {
{ 0.0, 0 }
}), new RangeDictionary <double, int>(IntervalMode.OpenInterval, new Dictionary <double, int> {
{ 0.0, 0 }
})));
}
else
{
var notePos = partTick + note.Pos;
var offset = note.Duration - vibrato.Duration;
var duration = tempo[notePos + note.Duration].TickToTime(notePos + note.Duration) - tempo[notePos + offset].TickToTime(notePos + offset);
var depth = GetValue(vibrato.Depths, notePos, tempo);
var rates = GetValue(vibrato.Rates, notePos, tempo);
return(new Vibrato(vibrato.Type, duration, depth, rates));
}
}
public Track(string name, RangeDictionary <double, Part> parts)
{
Name = name;
Parts = parts;
}
public static Dfa <TLetter> Build(INonFiniteAutomaton <TLetter> nfa, TLetter?eof = null, bool matchEmptyEof = false, Id <DfaState <TLetter> > firstId = default(Id <DfaState <TLetter> >))
{
var dfaStates = new Dictionary <string, DfaStateBuilder <TLetter> >(StringComparer.Ordinal);
var result = new List <DfaState <TLetter> >();
// Step 1: compute the epsilon closure information for all NFA nodes
var closures = nfa.States.ToDictionary(s => s.Id, state => state.EpsilonClosure().ToArray());
// Step 2: simulate transitions
var pending = new Queue <DfaStateBuilder <TLetter> >();
DfaStateBuilder <TLetter> startDfaState;
if (!GetStateBuilder(dfaStates, firstId, closures[nfa.StartState.Id], out startDfaState))
{
throw new InvalidOperationException("A new DFA state builder was expected");
}
DfaStateBuilder <TLetter> acceptDfaState;
GetStateBuilder(dfaStates, firstId, new NfaState <TLetter> [0], out acceptDfaState);
pending.Enqueue(startDfaState);
do
{
var currentDfaState = pending.Dequeue();
var allNfaTransitions = new RangeDictionary <TLetter, IEnumerable <NfaState <TLetter> > >();
foreach (var right in currentDfaState.NfaStates.Select(s => s.MatchTransitions))
{
var left = allNfaTransitions;
allNfaTransitions = new RangeDictionary <TLetter, IEnumerable <NfaState <TLetter> > >(RangeOperations <TLetter> .EnumerateRanges(left.Keys, right.Keys, (rng, leftIndex, rightIndex) => {
var rangeStates = leftIndex.HasValue ? left.Values[leftIndex.Value] : Enumerable.Empty <NfaState <TLetter> >();
if (rightIndex.HasValue)
{
rangeStates = rangeStates.Append(right.Values[rightIndex.Value]);
}
return(new KeyValuePair <Range <TLetter>, IEnumerable <NfaState <TLetter> > >(rng, rangeStates));
}));
}
var groupedNfaTransitions = new RangeDictionary <TLetter, HashSet <NfaState <TLetter> > >(
allNfaTransitions.Select(p => new KeyValuePair <Range <TLetter>, HashSet <NfaState <TLetter> > >(p.Key, new HashSet <NfaState <TLetter> >(p.Value))),
SetEqualityComparer <NfaState <TLetter> > .Default);
foreach (var matchTarget in groupedNfaTransitions)
{
DfaStateBuilder <TLetter> targetDfaState;
if (GetStateBuilder(dfaStates, firstId, matchTarget.Value.SelectMany(t => closures[t.Id]), out targetDfaState))
{
pending.Enqueue(targetDfaState);
}
currentDfaState.SetTransition(matchTarget.Key, targetDfaState);
}
} while (pending.Count > 0);
// Step 3: identify and remove identical (same transitions) states
while (true)
{
var dupes = dfaStates
.Values
.GroupBy(s => s)
.Select(g => new KeyValuePair <DfaStateBuilder <TLetter>, ICollection <DfaStateBuilder <TLetter> > >(g.Key, g.Where(s => !ReferenceEquals(s, g.Key)).ToList()))
.Where(p => p.Value.Count > 1)
.ToDictionary();
if (dupes.Count == 0)
{
break;
}
foreach (var dupe in dupes)
{
foreach (var builder in dfaStates.Values)
{
var dupeIds = new HashSet <int>(dupe.Value.Select(s => s.Id));
builder.ReplaceTransition(b => dupeIds.Contains(b.Id), dupe.Key);
}
}
foreach (var builder in dupes.SelectMany(d => d.Value))
{
dfaStates.Remove(builder.Key);
}
}
// Step 4: make the DFA states; the first is the start state
var states = new Dictionary <DfaStateBuilder <TLetter>, DfaState <TLetter> >();
var symbolStates = new Dictionary <Id <DfaState <TLetter> >, SymbolId>();
pending.Enqueue(startDfaState);
do
{
var builder = pending.Dequeue();
if (!states.ContainsKey(builder))
{
var state = ((Func <Id <DfaState <TLetter> >, DfaState <TLetter> >)(id => new DfaState <TLetter>(id)))(new Id <DfaState <TLetter> >(result.Count));
result.Add(state);
states.Add(builder, state);
foreach (var transition in builder.GetTransitions())
{
pending.Enqueue(transition.Value);
}
var acceptSymbolIds = builder
.NfaStates
.Where(s => s.AcceptId.HasValue)
// ReSharper disable once PossibleInvalidOperationException
.GroupBy(a => a.Precedence, a => a.AcceptId.Value)
.OrderByDescending(g => g.Key)
.Take(1)
.SelectMany(g => g)
.Distinct()
.ToList();
switch (acceptSymbolIds.Count)
{
case 0:
break;
case 1:
symbolStates.Add(state.Id, acceptSymbolIds[0]);
if (eof.HasValue)
{
state.SetTransition(Range <TLetter> .Create(eof.Value), Dfa <TLetter> .Accept);
}
break;
default:
throw new InvalidOperationException("The state " + state.Id + " has multiple same-precedence accept states " + string.Join(",", acceptSymbolIds));
}
}
} while (pending.Count > 0);
if (matchEmptyEof && eof.HasValue && states[startDfaState].GetTransition(eof.Value) == Dfa <TLetter> .Reject)
{
states[startDfaState].SetTransition(Range <TLetter> .Create(eof.Value), Dfa <TLetter> .Accept);
}
// Step 5: apply transitions
foreach (var pair in states)
{
foreach (var transition in pair.Key.GetTransitions())
{
var range = transition.Key;
var target = transition.Value;
pair.Value.SetTransition(range, states[target].Id);
}
}
return(new Dfa <TLetter>(eof, result, symbolStates));
}
public void 레인지딕셔너리는_현재키와같지않고_보다_작거나_큰키의데이터를_얻을수있습니다()
{
// Arrange
RangeDictionary <DateTime, string> rangeDictionary = new RangeDictionary <DateTime, string>();
DateTime sDateTimeCurrent = DateTime.Now;
Assert.IsTrue(rangeDictionary.Add(sDateTimeCurrent.AddDays(0), sDateTimeCurrent.AddDays(10), "0~10"));
Assert.IsTrue(rangeDictionary.Add(sDateTimeCurrent.AddDays(11), sDateTimeCurrent.AddDays(20), "11~20"));
Assert.IsTrue(rangeDictionary.Add(sDateTimeCurrent.AddDays(21), sDateTimeCurrent.AddDays(30), "21~30"));
for (int i = 10; i >= 0; i--)
{
Assert.AreEqual(rangeDictionary.GetValue(sDateTimeCurrent.AddDays(i)), "0~10");
}
for (int i = 20; i >= 11; i--)
{
Assert.AreEqual(rangeDictionary.GetValue(sDateTimeCurrent.AddDays(i)), "11~20");
}
for (int i = 30; i >= 21; i--)
{
Assert.AreEqual(rangeDictionary.GetValue(sDateTimeCurrent.AddDays(i)), "21~30");
}
// 키보다 작은 케이스
{
// Act && Assert
for (int i = 11; i < 20; i++)
{
try
{
Assert.IsTrue(rangeDictionary.TryGetValue_LesserThenKey(sDateTimeCurrent.AddDays(i), out string strValue));
Assert.AreEqual(strValue, "0~10");
}
catch (Exception e)
{
Assert.IsTrue(rangeDictionary.TryGetValue_LesserThenKey(sDateTimeCurrent.AddDays(i), out string strValue));
Assert.AreEqual(strValue, "0~10");
}
}
for (int i = 20; i >= 11; i--)
{
Assert.IsTrue(rangeDictionary.TryGetValue_LesserThenKey(sDateTimeCurrent.AddDays(i), out string strValue));
Assert.AreEqual(strValue, "0~10");
}
for (int i = 30; i >= 21; i--)
{
Assert.IsTrue(rangeDictionary.TryGetValue_LesserThenKey(sDateTimeCurrent.AddDays(i), out string strValue));
Assert.AreEqual(strValue, "11~20");
}
}
// 키보다 큰 케이스
{
// Act && Assert
for (int i = 10; i >= 0; i--)
{
try
{
Assert.IsTrue(rangeDictionary.TryGetValue_GreaterThenKey(sDateTimeCurrent.AddDays(i), out string strValue));
Assert.AreEqual(strValue, "11~20");
}
catch
{
Assert.IsTrue(rangeDictionary.TryGetValue_GreaterThenKey(sDateTimeCurrent.AddDays(i), out string strValue));
Assert.AreEqual(strValue, "11~20");
}
}
// Act && Assert
for (int i = 20; i >= 11; i--)
{
Assert.IsTrue(rangeDictionary.TryGetValue_GreaterThenKey(sDateTimeCurrent.AddDays(i), out string strValue));
Assert.AreEqual(strValue, "21~30");
}
}
}
public void Index()
{
var indexConfig = LuceneIndexDefaults.CreateStandardIndexWriterConfig();
long readCount = 0;
// Read All lines in the file (IEnumerable, yield)
// And group them by QCode.
var subjectGroups = FileHelper.GetInputLines(InputFilename).GroupBySubject();
using var luceneDirectory = FSDirectory.Open(EntitiesIndexPath);
using var luceneDirectoryReader = DirectoryReader.Open(luceneDirectory);
var docCount = luceneDirectoryReader.MaxDoc;
for (var i = 0; i < docCount; i++)
{
var doc = luceneDirectoryReader.Document(i);
var entity = doc.MapEntity();
var reverseProperties = entity.ReverseProperties.Select(x => x.Id.ToInt()).ToList();
var properties = entity.Properties.Select(x => x.Id.ToInt()).ToList();
//TODO: Use constant:
var otherProperties = properties.Where(x => !x.Equals(31)).ToList();
var types = entity.ParentTypes.Select(x => x.ToInt()).ToList();
var isType = entity.IsType;
//Range
//TODO: Use constant:
//if (isType)
RangeDictionary.AddSafe(31, types);
foreach (var reversePropertyId in reverseProperties)
{
RangeDictionary.AddSafe(reversePropertyId, types);
}
//Domain
DomainDictionary.AddSafe(31, types);
foreach (var propertyId in otherProperties)
{
DomainDictionary.AddSafe(propertyId, types);
}
//Frequency
foreach (var propertyIntId in properties)
{
if (!FrequencyHashTable.ContainsKey(propertyIntId))
{
FrequencyHashTable.Add(propertyIntId, 0);
}
FrequencyHashTable[propertyIntId] = (int)FrequencyHashTable[propertyIntId] + 1;
}
LogMessage(readCount++, "Frequency, Domain, Range", false);
}
LogMessage(readCount, "Frequency, Domain, Range");
readCount = 0;
using (var indexDirectory = FSDirectory.Open(OutputDirectory.GetOrCreateDirectory()))
{
using var writer = new IndexWriter(indexDirectory, indexConfig);
foreach (var subjectGroup in subjectGroups.Where(FilterGroups))
{
var document = new Document();
foreach (var field in FrequencyGetField(subjectGroup))
{
document.Add(field);
}
foreach (var field in DomainGetField(subjectGroup))
{
document.Add(field);
}
foreach (var field in RangeGetField(subjectGroup))
{
document.Add(field);
}
var boostField = document.Fields.FirstOrDefault(x => x.Name.Equals(Labels.Rank.ToString()));
var boost = 0.0;
if (boostField != null)
{
boost = (double)boostField.GetDoubleValue();
}
foreach (var fieldIndexer in FieldIndexers)
{
fieldIndexer.Boost = boost;
}
foreach (var fieldIndexer in FieldIndexers)
{
foreach (var field in fieldIndexer.GetField(subjectGroup))
{
document.Add(field);
}
}
LogProgress(readCount++);
writer.AddDocument(document);
}
}
LogProgress(readCount, true);
}
public static ReadOnlyRangeDictionary <TKey, TValue> AsReadOnly <TKey, TValue>([NotNull] this RangeDictionary <TKey, TValue> thisValue)
where TKey : IComparable
{
return(new ReadOnlyRangeDictionary <TKey, TValue>(thisValue));
}
RangeDictionary <double, double> GetControlChange(VprPart part, string name, double defaultValue, int partTick, RangeDictionary <int, Tempo> tempo)
{
var partStartTime = tempo[partTick].TickToTime(partTick);
var result = Optional <VprController[]> .FromNull(part.Controllers)
.SelectMany(cc => cc.Where(c => c.Name == name).SelectMany(c => c.Events))
.TakeWhile(e => e.Pos < part.Duration)
.ToRangeDictionary(e => tempo[partTick + e.Pos].TickToTime(partTick + e.Pos) - partStartTime, e => (double)e.Value, IntervalMode.OpenInterval);
if (result.Count < 1 || !result.ContainsKey(0.0))
{
result.Add(0.0, defaultValue);
}
return(result);
}
RangeDictionary <double, int> GetNoteStyle(IVSNote note, string styleName, int partTick, RangeDictionary <int, Tempo> tempo)
{
var partStartTime = tempo[partTick].TickToTime(partTick);
var styleTickRate = note.Duration / (double)(1 << 16);
return(note.NStyle.Sequence?
.FirstOrDefault((s) => s.ID == styleName)?.CC
.Select((c) => new { Tick = partTick + (int)(c.Position * styleTickRate), Value = c.Value })
.ToRangeDictionary((c) => tempo[c.Tick].TickToTime(c.Tick) - partStartTime, (c) => c.Value, IntervalMode.OpenInterval)
?? new RangeDictionary <double, int>(IntervalMode.OpenInterval, new Dictionary <double, int>()
{
[0.0] = 0
}));
}
public TrapEffectFactory()
{
trapEffectTable = new RangeDictionary<int, ISpecificTrapFactory>();
}
RangeDictionary <double, double> GetControlChange(IVSPart part, string id, double defaultValue, int partTick, RangeDictionary <int, Tempo> tempo)
{
var partStartTime = tempo[partTick].TickToTime(partTick);
var result = (part.CC ?? new IVSControlChange[0])
.TakeWhile((c) => c.Tick < part.PlayTime)
.Where((c) => c.Attr.ID == id)
.ToRangeDictionary((c) => tempo[partTick + c.Tick].TickToTime(partTick + c.Tick) - partStartTime, (c) => (double)c.Attr.Value, IntervalMode.OpenInterval);
if (result.Count < 1 || !result.ContainsKey(0.0))
{
result.Add(0.0, defaultValue);
}
return(result);
}
public TrapEffectFactory()
{
trapEffectTable = new RangeDictionary <int, ISpecificTrapFactory>();
}
