public void Check_IsInLiveVacancyOptions(FilteringOptions filteringOptions, bool expectedOutput)
{
filteringOptions.IsInLiveVacancyOptions().Should().Be(expectedOutput);
}
/// <summary>
///
/// </summary>
/// <param name="input"></param>
/// <param name="filteringOptions"></param>
/// <returns></returns>
public float[] Process(float[] input, FilteringOptions filteringOptions = FilteringOptions.Auto)
{
throw new NotImplementedException();
}
public static bool IsInLiveVacancyOptions(this FilteringOptions enumValue)
{
return(enumValue == FilteringOptions.ClosingSoon ||
enumValue == FilteringOptions.ClosingSoonWithNoApplications);
}
/// <summary>
/// Phase Vocoder algorithm
/// </summary>
/// <param name="signal"></param>
/// <param name="filteringOptions"></param>
/// <returns></returns>
public DiscreteSignal ApplyTo(DiscreteSignal signal,
FilteringOptions filteringOptions = FilteringOptions.Auto)
{
var stretch = (float)_hopSynthesis / _hopAnalysis;
var input = signal.Samples;
var output = new float[(int)(input.Length * stretch) + _fftSize];
var fft = new Fft(_fftSize);
var hannWindow = Window.OfType(WindowTypes.Hann, _fftSize);
var ratio = _fftSize / (2.0f * _hopAnalysis);
var norm = 4.0f / (_fftSize * ratio);
var omega = Enumerable.Range(0, _fftSize / 2 + 1)
.Select(f => 2 * Math.PI * f / _fftSize)
.ToArray();
var re = new float[_fftSize];
var im = new float[_fftSize];
var zeroblock = new float[_fftSize];
var prevPhase = new double[_fftSize / 2 + 1];
var phaseTotal = new double[_fftSize / 2 + 1];
var posSynthesis = 0;
for (var posAnalysis = 0; posAnalysis + _fftSize < input.Length; posAnalysis += _hopAnalysis)
{
input.FastCopyTo(re, _fftSize, posAnalysis);
zeroblock.FastCopyTo(im, _fftSize);
re.ApplyWindow(hannWindow);
fft.Direct(re, im);
for (var j = 0; j < _fftSize / 2 + 1; j++)
{
var mag = Math.Sqrt(re[j] * re[j] + im[j] * im[j]);
var phase = Math.Atan2(im[j], re[j]);
var delta = phase - prevPhase[j];
var deltaUnwrapped = delta - _hopAnalysis * omega[j];
var deltaWrapped = MathUtils.Mod(deltaUnwrapped + Math.PI, 2 * Math.PI) - Math.PI;
var freq = omega[j] + deltaWrapped / _hopAnalysis;
phaseTotal[j] += _hopSynthesis * freq;
prevPhase[j] = phase;
re[j] = (float)(mag * Math.Cos(phaseTotal[j]));
im[j] = (float)(mag * Math.Sin(phaseTotal[j]));
}
for (var j = _fftSize / 2 + 1; j < _fftSize; j++)
{
re[j] = im[j] = 0.0f;
}
fft.Inverse(re, im);
for (var j = 0; j < re.Length; j++)
{
output[posSynthesis + j] += re[j] * hannWindow[j] * norm;
}
posSynthesis += _hopSynthesis;
}
return(new DiscreteSignal(signal.SamplingRate, output));
}
/// <summary>
/// WSOLA algorithm
/// </summary>
/// <param name="signal"></param>
/// <param name="filteringOptions"></param>
/// <returns></returns>
public DiscreteSignal ApplyTo(DiscreteSignal signal,
FilteringOptions filteringOptions = FilteringOptions.Auto)
{
throw new NotImplementedException();
}
private List <VacancySummary> GetFilteredVacancies(List <VacancySummary> vacancies, FilteringOptions filterStatus, string searchTerm)
{
IEnumerable <VacancySummary> filteredVacancies = new List <VacancySummary>();
switch (filterStatus)
{
case FilteringOptions.Live:
case FilteringOptions.Closed:
case FilteringOptions.Draft:
case FilteringOptions.Review:
case FilteringOptions.Submitted:
filteredVacancies = vacancies.Where(v =>
v.Status.ToString() == filterStatus.ToString());
break;
case FilteringOptions.All:
filteredVacancies = vacancies;
break;
case FilteringOptions.NewApplications:
filteredVacancies = vacancies.Where(v => v.NoOfNewApplications > 0);
break;
case FilteringOptions.AllApplications:
filteredVacancies = vacancies.Where(v => v.NoOfApplications > 0);
break;
case FilteringOptions.ClosingSoon:
filteredVacancies = vacancies.Where(v =>
v.ClosingDate <= _timeProvider.Today.AddDays(ClosingSoonDays) &&
v.Status == VacancyStatus.Live);
break;
case FilteringOptions.ClosingSoonWithNoApplications:
filteredVacancies = vacancies.Where(v =>
v.ClosingDate <= _timeProvider.Today.AddDays(ClosingSoonDays) &&
v.Status == VacancyStatus.Live &&
v.ApplicationMethod == ApplicationMethod.ThroughFindAnApprenticeship &&
v.NoOfApplications == 0);
break;
case FilteringOptions.Referred:
filteredVacancies = vacancies.Where(v =>
v.Status.ToString() == VacancyStatus.Referred.ToString() ||
v.Status.ToString() == VacancyStatus.Rejected.ToString());
break;
}
return(filteredVacancies
.Where(v => string.IsNullOrWhiteSpace(searchTerm) ||
(v.Title.Contains(searchTerm, StringComparison.OrdinalIgnoreCase)) ||
(string.IsNullOrWhiteSpace(v.LegalEntityName) == false && v.LegalEntityName.Contains(searchTerm, StringComparison.OrdinalIgnoreCase)) ||
(v.VacancyReference.HasValue && $"VAC{v.VacancyReference}".Contains(searchTerm, StringComparison.OrdinalIgnoreCase)))
.OrderByDescending(v => v.CreatedDate)
.ToList());
}
/// <summary>
/// Method implements online filtering (sample-by-sample, buffer-by-buffer)
/// </summary>
/// <param name="filter">Some filter</param>
/// <param name="input">Input signal</param>
/// <param name="filteringOptions">General filtering strategy</param>
/// <returns>Filtered signal</returns>
public static DiscreteSignal Process(this IFilter filter,
DiscreteSignal input,
FilteringOptions filteringOptions = FilteringOptions.Auto)
{
return(new DiscreteSignal(input.SamplingRate, filter.Process(input.Samples, filteringOptions)));
}
public void GetFilterHeading_ShouldBeExpected(string vacancyTerm, int totalVacancies, FilteringOptions filteringOption, string searchTerm, string expectedResult)
{
var actualResult = VacancyFilterHeadingHelper.GetFilterHeading(vacancyTerm, totalVacancies, filteringOption, searchTerm);
actualResult.Should().Be(expectedResult);
}
public static string GetFilterHeading(string vacancyTerm, int totalVacancies, FilteringOptions filteringOption, string searchTerm, UserType?userType = null)
{
var vacancyWord = vacancyTerm.ToQuantity(totalVacancies, ShowQuantityAs.None);
var words = new List <string>();
words.Add(totalVacancies.ToString());
switch (filteringOption)
{
case FilteringOptions.All:
words.Add(vacancyWord);
break;
case FilteringOptions.Closed:
case FilteringOptions.Draft:
case FilteringOptions.Live:
case FilteringOptions.Referred:
words.Add(filteringOption.GetDisplayName(userType).ToLowerInvariant());
words.Add(vacancyWord);
break;
default:
words.Add(vacancyWord);
words.Add(filteringOption.GetDisplayName(userType).ToLowerInvariant());
break;
}
if (!string.IsNullOrWhiteSpace(searchTerm))
{
words.Add($"with '{searchTerm}'");
}
return(string.Join(" ", words));
}
/// <summary>
/// Online processing (buffer-by-buffer)
/// </summary>
/// <param name="input"></param>
/// <param name="filteringOptions"></param>
/// <returns></returns>
public float[] Process(float[] input, FilteringOptions filteringOptions = FilteringOptions.Auto)
{
return(ApplyTo(new DiscreteSignal(1, input)).Samples);
}
/// <summary>
/// Method implements simple tremolo effect
/// </summary>
/// <param name="signal"></param>
/// <param name="filteringOptions"></param>
/// <returns></returns>
public DiscreteSignal ApplyTo(DiscreteSignal signal,
FilteringOptions filteringOptions = FilteringOptions.Auto)
{
return(Modulate.Amplitude(signal, Frequency, TremoloIndex));
}
/// <summary>
/// The online filtering algorithm should be implemented by particular subclass
/// </summary>
/// <param name="input">Input block of samples</param>
/// <param name="filteringOptions">General filtering strategy</param>
/// <returns>Filtered block</returns>
public abstract float[] Process(float[] input,
FilteringOptions filteringOptions = FilteringOptions.Auto);
/// <summary>
/// The filtering algorithm that should be implemented by particular subclass
/// </summary>
/// <param name="signal">Signal for filtering</param>
/// <param name="filteringOptions">General filtering strategy</param>
/// <returns>Filtered signal</returns>
public abstract DiscreteSignal ApplyTo(DiscreteSignal signal,
FilteringOptions filteringOptions = FilteringOptions.Auto);
