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);