public void TestMinimumDistance()
{
double[] input = { 1, 2, 2.1, 3, 4, 10 };
Assert.AreEqual(Dsp.MinimumDistance(input), .1, 1e-14);
Assert.Throws <ArgumentNullException>(() => Dsp.MinimumDistance(null));
}
public void TestInterpolateComplex()
{
double[] x = { 1, 2, 3, 4 };
Complex[] y =
{
Complex.FromPolarCoordinates(1, 1),
Complex.FromPolarCoordinates(2, 2),
Complex.FromPolarCoordinates(3, 3),
Complex.FromPolarCoordinates(4, 4)
};
double[] x2 = { 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5 };
var result = Dsp.InterpolateComplex(x, y, x2).ToReadOnlyList();
Assert.That(result.Count == x2.Length);
FilterAssert.ListIsMonotonouslyRising(result.Select(c => c.Magnitude));
Assert.GreaterOrEqual(result[0].Magnitude, 0);
Assert.GreaterOrEqual(result[result.Count - 1].Magnitude, 4);
Assert.LessOrEqual(result[0].Magnitude, 1);
Assert.LessOrEqual(result[result.Count - 1].Magnitude, 5);
Assert.Throws <ArgumentNullException>(() => Dsp.InterpolateComplex(null, y, x2).ToReadOnlyList());
Assert.Throws <ArgumentNullException>(() => Dsp.InterpolateComplex(x, null, x2).ToReadOnlyList());
Assert.Throws <ArgumentNullException>(() => Dsp.InterpolateComplex(x, y, null).ToReadOnlyList());
Assert.Catch <Exception>(() => Dsp.InterpolateComplex(x2, y, x2).ToReadOnlyList());
}
public override void ApplyToDsp(Dsp effect, time_t qnDur, float alpha = 0)
{
base.ApplyToDsp(effect, qnDur, alpha);
if (effect is Phaser p)
{
}
}
public void TestModBessel0()
{
double[] input = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
double[] target =
{
1,
1.26606587775201e+000,
2.27958530233607e+000,
4.88079258586502e+000,
11.3019219521363e+000,
27.2398718236044e+000,
67.2344069764780e+000,
168.593908510290e+000,
427.564115721805e+000,
1.09358835451137e+003,
2.81571662846625e+003
};
var result = input.Select(Dsp.ModBessel0).ToReadOnlyList();
FilterAssert.ListsAreReasonablyClose(target, result, 1e-13);
Assert.Catch <ArgumentOutOfRangeException>(() => Dsp.ModBessel0(-1));
}
/// <summary>
/// Initializes a new instance of the <see cref="Sinc" /> Class.
/// </summary>
/// <param name="from">The start frequency.</param>
/// <param name="to">The stop frequency.</param>
/// <param name="length">The length in seconds.</param>
/// <param name="samplerate">The samplerate.</param>
public LogSweep(double from, double to, double length, double samplerate)
: base(Dsp.LogSweep(from, to, length, samplerate).ToReadOnlyList(), samplerate)
{
this.From = @from;
this.To = to;
this.DisplayName = "logarithmic sweep";
}
private void AddParameterControl(ref Dsp dsp, int index)
{
var info = dsp.GetParameterInfo(index);
switch (info.Type)
{
case DspParameterType.Float:
AddFloatControl(dsp, ref info, index);
break;
case DspParameterType.Int:
AddIntControl(dsp, ref info, index);
break;
case DspParameterType.Bool:
AddBoolControl(dsp, ref info, index);
break;
case DspParameterType.Data:
AddDataControl(dsp, ref info, index);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
IDisposable onChanged(object sender, string name, NotifyCollectionChangedEventArgs e, bool delay)
{
IDisposable blocker;
Dsp dsp;
if (Block(name, out blocker)) //ブロックできた場合
{
if (delay)
{
dsp = new Dsp(() => {
Raise(sender, name, e);
blocker.Dispose();
});
}
else
{
Raise(sender, name, e);
dsp = new Dsp(() => {
blocker.Dispose();
});
}
}
else
{
dsp = new Dsp(null);
}
return(dsp);
}
/// <summary>
/// Applies a circular shift to the provided vector.
/// </summary>
/// <param name="series">The vector.</param>
/// <param name="amount">The shift amount.</param>
/// <returns></returns>
public static IEnumerable <double> CircularShift(this IEnumerable <double> series, int amount)
{
var list = series.ToReadOnlyList();
amount = Dsp.Mod(amount, list.Count);
return(list.Skip(amount).Concat(list.Take(amount)));
}
public override ISignal CreateSignal()
{
var fi = new FileInfo(this.FileName);
if (!fi.Exists)
{
return(null);
}
var file = File.ReadLines(this.FileName);
var frequencies = new List <double>();
var values = new List <Complex>();
double frequency;
double mag;
double phase;
foreach (var line in file)
{
var fields = line.Split(',');
if (fields.Length < 2)
{
continue;
}
if (!double.TryParse(fields[0], NumberStyles.Any, CultureInfo.InvariantCulture, out frequency))
{
continue;
}
if (!double.TryParse(fields[1], NumberStyles.Any, CultureInfo.InvariantCulture, out mag))
{
continue;
}
if (fields.Length == 2)
{
frequencies.Add(frequency);
values.Add(mag);
}
else if (fields.Length == 3)
{
if (!double.TryParse(fields[1], NumberStyles.Any, CultureInfo.InvariantCulture, out phase))
{
continue;
}
frequencies.Add(frequency);
values.Add(Complex.FromPolarCoordinates(mag, phase));
}
}
var series = new FftSeries(this.SampleRate, this.SignalLength);
var ret = Dsp.AdaptiveInterpolation(frequencies, values, series.Values.ToReadOnlyList(), false).ToReadOnlyList();
return(new FiniteSignal(new FftSpectrum(series, ret), this.TimeOffset));
}
public override void ApplyToDsp(Dsp effect, time_t qnDur, float alpha = 0)
{
base.ApplyToDsp(effect, qnDur, alpha);
if (effect is TapeStop ts)
{
ts.Duration = Duration.Sample(alpha);
}
}
public void TestLinSeries()
{
double[] target = { 1, 2, 3, 4, 5 };
var result = Dsp.LinSeries(1, 5, 5).ToReadOnlyList();
FilterAssert.ListsAreReasonablyClose(target, result);
Assert.Catch <ArgumentOutOfRangeException>(() => Dsp.LinSeries(1, 5, 1));
}
/// <summary>
/// Initializes a new instance of the <see cref="WhiteNoise" /> class.
/// </summary>
/// <param name="sampleRate">The sample rate.</param>
/// <param name="mean">The mean.</param>
/// <param name="variance">The variance.</param>
public WhiteNoise(double sampleRate, double mean = 0, double variance = 1) : base(sampleRate)
{
this.Mean = mean;
this.Sigma = Math.Sqrt(variance);
this.Variance = variance;
this.NoiseSource = Dsp.WhiteNoise().GetEnumerator();
this.DisplayName = "white noise, µ = " + mean + ",σ² = " + variance;
}
public override void ApplyToDsp(Dsp effect, time_t qnDur, float alpha = 0)
{
base.ApplyToDsp(effect, qnDur, alpha);
if (effect is Wobble wobble)
{
wobble.SetPeriod(Period.Sample(alpha) * qnDur.Seconds * 4);
}
}
public override void ApplyToDsp(Dsp effect, time_t qnDur, float alpha = 0)
{
base.ApplyToDsp(effect, qnDur, alpha);
if (effect is BitCrusher bitCrusher)
{
bitCrusher.Reduction = Reduction.Sample(alpha);
}
}
public Dsp.Dsp CreateDspByType(Dsp.Type type)
{
IntPtr DspHandle = IntPtr.Zero;
Error.Code ReturnCode = CreateDspByType (this.DangerousGetHandle (), type, ref DspHandle);
Error.Errors.ThrowError (ReturnCode);
return new Dsp.Dsp (DspHandle);
}
public Dsp.Dsp CreateDSP(ref Dsp.Description description)
{
IntPtr DspHandle = IntPtr.Zero;
Error.Code ReturnCode = CreateDSP (this.DangerousGetHandle (), ref description, ref DspHandle);
Error.Errors.ThrowError (ReturnCode);
return new Dsp.Dsp (DspHandle);
}
public override void ApplyToDsp(Dsp effect, time_t qnDur, float alpha = 0)
{
base.ApplyToDsp(effect, qnDur, alpha);
if (effect is SideChain sc)
{
sc.Amount = Amount.Sample(alpha);
sc.Duration = Duration.Sample(alpha) * qnDur.Seconds * 4;
}
}
public Dsp.Connection AddDsp(Dsp.Dsp dsp)
{
IntPtr ConnectionHandle = IntPtr.Zero;
Error.Code ReturnCode = AddDSP (this.DangerousGetHandle (), dsp.DangerousGetHandle (), ref ConnectionHandle);
Error.Errors.ThrowError (ReturnCode);
return new Dsp.Connection (ConnectionHandle);
}
public void TestWhiteNoise()
{
var noise = Dsp.WhiteNoise().Take(1000000).ToReadOnlyList();
var noise1 = Dsp.WhiteNoise().Take(1).ToReadOnlyList();
Assert.That(noise1[0] != noise[0]);
Assert.AreEqual(noise.Average(), 0, 1e-2);
Assert.AreEqual(noise.Variance(), 1, 1e-2);
}
public override void ApplyToDsp(Dsp effect, time_t qnDur, float alpha = 0)
{
base.ApplyToDsp(effect, qnDur, alpha);
if (effect is Flanger flanger)
{
flanger.SetDelay(Delay.Sample(alpha));
flanger.SetDelayRange(Offset.Sample(alpha), Depth.Sample(alpha));
}
}
public override void ApplyToDsp(Dsp effect, time_t qnDur, float alpha = 0)
{
base.ApplyToDsp(effect, qnDur, alpha);
if (effect is Gate gate)
{
gate.SetGating(Gating.Sample(alpha));
gate.SetGateDuration(GateDuration.Sample(alpha) * qnDur.Seconds * 4);
}
}
public override void Initialize()
{
base.Initialize();
System.Init(32);
dsp = System.CreateDSPByType(DSPType.Oscillator);
dsp.SetParameterFloat(1, 440.0f);
}
private void AddBoolControl(Dsp dsp, ref DspParameterDesc info, int index)
{
var boolPanel = new IntParameterPanel();
boolPanel.ComboBox.Items.AddRange(new object[] { "False", "True" });
boolPanel.Description = info.Description;
boolPanel.Anchor = AnchorStyles.Left | AnchorStyles.Right;
boolPanel.ValueChanged += (s, e) => dsp.SetParameterBool(index, boolPanel.Value == 1);
flowPanel.Controls.Add(boolPanel, 0, index);
}
public void Remove()
{
if (_dspEq != null)
{
var result = _fChannel?.RemoveDsp(_dspEq);
result = _dspEq.Release();
_dspEq = null;
}
IsActive = false;
}
public override void ApplyToDsp(Dsp effect, time_t qnDur, float alpha = 0)
{
base.ApplyToDsp(effect, qnDur, alpha);
if (effect is Retrigger retrigger)
{
retrigger.Mix = Mix.Sample(alpha);
retrigger.Gating = Gating.Sample(alpha);
retrigger.Duration = GateDuration.Sample(alpha) * qnDur.Seconds * 4;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="UniformSeries" /> class.
/// </summary>
/// <param name="from">The first value of the series.</param>
/// <param name="to">The last value of the series.</param>
/// <param name="length">Determines how many values (including first and last) the series should contain.</param>
/// <param name="logarithmic">Determines whether the series should be on a linear or a logarithmic scale.</param>
public UniformSeries(double from, double to, int length, bool logarithmic = false) :
base(logarithmic
? Dsp.LogSeries(from, to, length)
: Dsp.LinSeries(from, to, length),
logarithmic)
{
this.From = from;
this.To = to;
this.Length = length;
}
/// <summary>ブロックできたら解除Keyを返す</summary>
private bool Block(string name, out IDisposable dispose)
{
if (blockingName.Add(name))
{
dispose = new Dsp(() => blockingName.Remove(name));
return(true);
}
dispose = new Dsp(null);
return(false);
}
public void TestDegToRad()
{
var input = new[] { 0.0, -90, 180, 270 };
var target = new[] { 0, -Math.PI * 0.5, Math.PI, 1.5 * Math.PI };
var result = Dsp.DegToRad(input).ToReadOnlyList();
FilterAssert.ListsAreReasonablyClose(target, result);
Assert.That(Dsp.DegToRad(Enumerable.Empty <double>()).ToReadOnlyList().Count == 0);
Assert.Throws <ArgumentNullException>(() => Dsp.DegToRad(null).ToReadOnlyList());
}
public void TestLinearToDb()
{
var input = new[] { 1.0, 10, 2, 0 };
var target = new[] { 0, 20, 6.020599913279624, -100 };
var result = Dsp.LinearToDb(input, -100).ToReadOnlyList();
FilterAssert.ListsAreReasonablyClose(target, result);
Assert.That(Dsp.LinearToDb(Enumerable.Empty <double>()).ToReadOnlyList().Count == 0);
Assert.Throws <ArgumentNullException>(() => Dsp.LinearToDb(null).ToReadOnlyList());
}
/// <summary>
/// Convolves the specified finite signal with an enumerable signal.
/// </summary>
/// <param name="s1">The finite signal.</param>
/// <param name="s2">The enumerable signal.</param>
/// <returns></returns>
/// <exception cref="SamplerateMismatchException"></exception>
public static IEnumerableSignal Convolve(this IFiniteSignal s1, IEnumerableSignal s2)
{
if (s1.SampleRate != s2.SampleRate)
{
throw new SamplerateMismatchException();
}
return(new EnumerableSignal(Dsp.Convolve(s2.Signal, s1.Signal), s1.SampleRate, s1.Start + s2.Start)
{
DisplayName = "convolution result"
});
}
/// <summary>
/// Computes the cross-correlation of a finite and a enumerable signal.
/// </summary>
/// <param name="s1">The finite signal.</param>
/// <param name="s2">The enumerable signal.</param>
/// <returns></returns>
/// <exception cref="SamplerateMismatchException"></exception>
public static IEnumerableSignal CrossCorrelate(this IFiniteSignal s1, IEnumerableSignal s2)
{
if (s1.SampleRate != s2.SampleRate)
{
throw new SamplerateMismatchException();
}
return(new EnumerableSignal(Dsp.CrossCorrelate(s2.Signal, s1.Signal), s1.SampleRate, s1.Start - s2.Start)
{
DisplayName = "cross correlation"
});
}
public void TestAmplitudeToComplex()
{
var input = new[] { 1.0, 2, 3 };
var output = Dsp.AmplitudeToComplex(input).ToReadOnlyList();
Complex[] target = { Complex.One, 2, 3 };
FilterAssert.ListsAreEqual(output, target);
Assert.That(Dsp.AmplitudeToComplex(new List <double>()).ToReadOnlyList().Count == 0);
Assert.Throws <ArgumentNullException>(() => Dsp.AmplitudeToComplex(null));
}
private void AddIntControl(Dsp dsp, ref DspParameterDesc info, int index)
{
var intPanel = new IntParameterPanel();
// ReSharper disable once CoVariantArrayConversion
intPanel.ComboBox.Items.AddRange(info.IntDescription.ValueNames);
intPanel.Description = info.Description;
intPanel.Anchor = AnchorStyles.Left | AnchorStyles.Right;
intPanel.Value = dsp.GetParameterInt(index);
intPanel.ValueChanged += (s, e) => dsp.SetParameterInt(index, intPanel.Value);
flowPanel.Controls.Add(intPanel, 0, index);
}
public Channel.Channel PlayDsp(Dsp.Dsp dsp, bool paused)
{
IntPtr ChannelHandle = IntPtr.Zero;
Error.Code ReturnCode = PlayDsp (this.DangerousGetHandle (), Channel.Index.Free, dsp.DangerousGetHandle (), paused, ref ChannelHandle);
Error.Errors.ThrowError (ReturnCode);
return new Channel.Channel (ChannelHandle);
}
public Channel.Channel PlayDsp(Dsp.Dsp dsp)
{
return PlayDsp (dsp, false);
}
private static extern Error.Code CreateDspByType(IntPtr system, Dsp.Type type, ref IntPtr dsp);
private static extern Error.Code CreateDSP(IntPtr system, ref Dsp.Description description, ref IntPtr dsp);
private static extern Error.Code GetSpectrum(IntPtr channel, [MarshalAs(UnmanagedType.LPArray)] float[] spectrumarray, int numvalues, int channeloffset, Dsp.FFTWindow windowtype);
public void GetSpectrum(float[] spectrumarray, int numvalues, int channeloffset, Dsp.FFTWindow windowtype)
{
GetSpectrum(this.DangerousGetHandle(), spectrumarray, numvalues, channeloffset, windowtype);
}
public float[] GetSpectrum(int numvalues, int channeloffset, Dsp.FFTWindow windowtype)
{
float[] SpectrumArray = new float[numvalues];
this.GetSpectrum (SpectrumArray, numvalues, channeloffset, windowtype);
return SpectrumArray;
}
public void PlayDsp(Dsp.Dsp dsp, bool paused, Channel.Channel chn)
{
IntPtr channel = chn.DangerousGetHandle ();
Error.Code ReturnCode = PlayDsp (this.DangerousGetHandle (), Channel.Index.Reuse, dsp.DangerousGetHandle (), paused, ref channel);
Error.Errors.ThrowError (ReturnCode);
//This can't really happend.
//Check just in case...
if(chn.DangerousGetHandle () != channel)
throw new Exception("Channel handle got changed by Fmod.");
}
