public void SourceConverter_RiseAndFall()
{
var nextFrame = new VisualizationDataFrame(
testFrame.Time.Value.Add(testFrame.Duration),
testFrame.Duration,
ScalarData.Create(Enumerable.Repeat <float>(1.0f, (int)expectedChannelCount).ToArray()),
ScalarData.Create(Enumerable.Repeat <float>(2.0f, (int)expectedChannelCount).ToArray()),
SpectrumData.Create(
Enumerable.Repeat <float>(1.0f, (int)(expectedChannelCount * expectedFrequencyCount)).ToArray(), expectedChannelCount, ScaleType.Linear, ScaleType.Linear, expectedMinFrequency, expectedMaxFrequency)
);
sut.SpectrumRiseTime = TimeSpan.FromMilliseconds(100);
sut.SpectrumFallTime = TimeSpan.FromMilliseconds(50);
sut.RmsRiseTime = TimeSpan.FromMilliseconds(80);
sut.RmsFallTime = TimeSpan.FromMilliseconds(40);
sut.PeakRiseTime = TimeSpan.FromMilliseconds(20);
sut.PeakFallTime = TimeSpan.FromMilliseconds(200);
var data = sut.GetData();
testSource.Frame = nextFrame;
data = sut.GetData();
Assert.IsNotNull(data.RMS);
Assert.IsNotNull(data.Peak);
Assert.IsNotNull(data.Spectrum);
}
public void ScalarData_CombineChannels()
{
var data = ScalarData.Create(new float[] { 1, 2, 3 });
var result = data.CombineChannels(new float[] { 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f });
Assert.AreEqual(2, result.Count);
float[] expectedResult = { 1.4f, 3.2f };
AssertFloatCollectionsAreEqual(expectedResult, result.ToArray(), 0.0001f, "Calculation incorrect");
}
public void ScalarData_RiseAndFall_WithDifferentSizeArgThrows()
{
Assert.ThrowsException <ArgumentException>(
() =>
{
ScalarData.CreateEmpty(2).ApplyRiseAndFall(ScalarData.CreateEmpty(1), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1));
}
);
}
public void ScalarData_RiseAndFallToEmpty_WithPreviousNullThrows()
{
Assert.ThrowsException <ArgumentException>(
() =>
{
var result = ScalarData.ApplyRiseAndFallToEmpty(null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(4));
}
);
}
public void ScalarData_CombineChannelsWithNullMapThrows()
{
Assert.ThrowsException <NullReferenceException>(
() =>
{
ScalarData.CreateEmpty(2).CombineChannels(null);
}
);
}
public void ScalarData_CombineChannelsWithMapSizeLTChannelsThrows()
{
Assert.ThrowsException <ArgumentException>(
() =>
{
ScalarData.CreateEmpty(2).CombineChannels(new float[] { 0.5f });
}
);
}
public void ScalarData_CreateEmpty()
{
var data = ScalarData.CreateEmpty(2);
Assert.AreEqual(ScaleType.Linear, data.AmplitudeScale);
Assert.AreEqual(0.0f, data[0]);
Assert.AreEqual(0.0f, data[1]);
CollectionAssert.AreEqual(new float[] { 0.0f, 0.0f }, data.AsEnumerable().ToArray());
}
public RobustDesignVariable(ScalarData data, double lowerBound, double upperBound, double probability, IRoustOptimizationDistribution distribution)
: base(data)
{
(double lower, double upper) = distribution.GetBoundExtensions(probability);
LowerBound = lowerBound + lower;
UpperBound = upperBound + upper;
Probability = probability;
Distribution = distribution;
}
public void ScalarData_RiseAndFall_WithLogScaleArgThrows()
{
Assert.ThrowsException <ArgumentException>(
() =>
{
ScalarData.CreateEmpty(2).ConvertToDecibels(-100, 20).ApplyRiseAndFall(null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1));
}
);
}
public void ScalarData_ConvertToDecibels()
{
float[] testValues = new float [] { 0.0f, 0.1f, 1.0f, 1e-6f, 1e6f, -1 };
var data = ScalarData.Create(testValues);
var logData = data.ConvertToDecibels(-100, 0);
CollectionAssert.AreEqual(new float[] { -100.0f, -20.0f, 0.0f, -100.0f, 0.0f, -100.0f }, logData.ToArray());
Assert.ThrowsException <Exception>(() => { var d2 = logData.ConvertToDecibels(-100, 0); });
Assert.ThrowsException <ArgumentException>(() => { var d3 = data.ConvertToDecibels(0, 0); });
}
public void ScalarData_CombineChannelsWithLogScaleThrows()
{
#if DEBUG
Assert.ThrowsException <COMException>(
#else
Assert.ThrowsException <Exception>(
#endif
() =>
{
ScalarData.CreateEmpty(2).ConvertToDecibels(-100, 0).CombineChannels(new float[] { 0.5f, 0.5f });
}
);
}
public void ScalarData_CreateWithValues()
{
var initData = new float[] { 0.0f, 0.1f, 0.2f, 0.3f, 0.4f };
var data = ScalarData.Create(initData);
Assert.AreEqual(5, data.Count());
Assert.AreEqual(5, data.Count);
Assert.AreEqual(ScaleType.Linear, data.AmplitudeScale);
for (int i = 0; i < 5; i++)
{
Assert.AreEqual(initData[i], data[i]);
}
}
public void VisualizationDataFrame_ctor()
{
var rms = ScalarData.CreateEmpty(2);
var peak = ScalarData.CreateEmpty(2);
var spectrum = SpectrumData.CreateEmpty(2, 100, ScaleType.Linear, ScaleType.Linear, 0, 20000.0f);
var frame = new VisualizationDataFrame(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1.0 / 60.0), rms, peak, spectrum);
Assert.IsNotNull(frame);
Assert.AreEqual(TimeSpan.FromSeconds(1), frame.Time);
Assert.AreEqual(TimeSpan.FromSeconds(1.0 / 60.0), frame.Duration);
Assert.AreSame(rms, frame.RMS);
Assert.AreSame(peak, frame.Peak);
Assert.AreSame(spectrum, frame.Spectrum);
}
public void ScalarData_RiseAndFall_WithZeroRiseAndFallTime()
{
var previous = ScalarData.Create(new float[] { 2.0f, 1.0f, 1.5f });
var data = ScalarData.Create(new float[] { 1.0f, 2.0f, 1.5f }); // First falling, second rising, 3rd same
var result1 = data.ApplyRiseAndFall(previous,
TimeSpan.Zero,
TimeSpan.Zero,
TimeSpan.FromMilliseconds(400)
);
AssertFloatCollectionsAreEqual(
data.ToArray(),
result1.ToArray(), 0.001f, "Calculation results incorrect"
);
}
public void ScalarData_RiseAndFallToEmpty()
{
var data = ScalarData.Create(new float[] { 1.0f, 0.0f, -1.0f });
var result = ScalarData.ApplyRiseAndFallToEmpty(data, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(4));
var expectedResult = new float[] {
RiseFallTime(0, data[0], 0.25f, 0.5f),
RiseFallTime(0, data[1], 0.25f, 0.5f),
RiseFallTime(0, data[2], 0.25f, 0.5f)
};
AssertFloatCollectionsAreEqual(
expectedResult,
result.ToArray(), 0.001f, "Calculation results incorrect"
);
}
public void TestInit()
{
sut = new SourceConverter();
testSource = new FakeVisualizationSource();
testSource.ExpectedChannels = expectedChannelCount;
sut.Source = testSource;
testFrame = new VisualizationDataFrame(
TimeSpan.Zero,
TimeSpan.FromMilliseconds(16.7),
ScalarData.CreateEmpty(expectedChannelCount),
ScalarData.CreateEmpty(expectedChannelCount),
SpectrumData.CreateEmpty(expectedChannelCount, 10, ScaleType.Linear, ScaleType.Linear, 0, 10000));
testSource.Frame = testFrame;
}
public void ScalarData_RiseAndFall_WithPreviousNullArg()
{
var data = ScalarData.Create(new float[] { 1.0f, -1.0f, 0.0f }); // First falling, second rising, 3rd same
var result = data.ApplyRiseAndFall(null,
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(200),
TimeSpan.FromMilliseconds(400));
var expectedResult = new float[] {
RiseFallTime(data[0], 0, 0.25f, 0.5f),
RiseFallTime(data[1], 0, 0.25f, 0.5f),
RiseFallTime(data[2], 0, 0.25f, 0.5f)
};
AssertFloatCollectionsAreEqual(
expectedResult,
result.ToArray(), 0.001f, "Calculation results incorrect"
);
}
public void ScalarData_RiseAndFall_WithZeroTimeDelta()
{
var previous = ScalarData.Create(new float[] { 2.0f, 1.0f, 1.5f });
var data = ScalarData.Create(new float[] { 1.0f, 2.0f, 1.5f }); // First falling, second rising, 3rd same
var result1 = data.ApplyRiseAndFall(previous,
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(200),
TimeSpan.Zero
);
var expectedResult1 = new float[] {
RiseFallTime(data[0], previous[0], 0.25f, 0.5f),
RiseFallTime(data[1], previous[1], 0.25f, 0.5f),
RiseFallTime(data[2], previous[2], 0.25f, 0.5f)
};
AssertFloatCollectionsAreEqual(
previous.ToArray(),
result1.ToArray(), 0.001f, "Calculation results incorrect"
);
}
public void ScalarData_RiseAndFall()
{
var data = ScalarData.Create(new float[] { 1.0f, 2.0f, 1.5f }); // First falling, second rising, 3rd same
var previous = ScalarData.Create(new float[] { 2.0f, 1.0f, 1.5f });
var result = data.ApplyRiseAndFall(previous,
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(200),
TimeSpan.FromMilliseconds(400)
);
CollectionAssert.AreEqual(
new float[] { 1.135336f, 1.98168433f, 1.5f }, result.ToArray());
var result2 = data.ApplyRiseAndFall(null,
TimeSpan.FromMilliseconds(100),
TimeSpan.FromMilliseconds(200),
TimeSpan.FromMilliseconds(400));
CollectionAssert.AreEqual(
new float[] { 0.9816843f, 1.96336865f, 1.47252655f }, result2.ToArray());
Assert.ThrowsException <ArgumentException>(
() => {
data.ConvertToDecibels(-100, 20).ApplyRiseAndFall(previous, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1));
}
);
Assert.ThrowsException <ArgumentException>(
() => {
data.ApplyRiseAndFall(previous, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), TimeSpan.Zero);
}
);
var data2 = ScalarData.CreateEmpty(2); // Different size
Assert.ThrowsException <ArgumentException>(
() =>
{
data2.ApplyRiseAndFall(previous, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1));
}
);
}
public void TestInit()
{
sut = new SourceConverter();
testSource = new FakeVisualizationSource();
sut.Source = testSource;
testFrame = new VisualizationDataFrame(
expectedTime,
expectedDuration,
ScalarData.CreateEmpty(expectedChannelCount),
ScalarData.CreateEmpty(expectedChannelCount),
SpectrumData.CreateEmpty(expectedChannelCount, expectedFrequencyCount, ScaleType.Linear, ScaleType.Linear, expectedMinFrequency, expectedMaxFrequency)
);
otherFrame = new VisualizationDataFrame(
expectedTime.Add(expectedDuration),
expectedDuration,
ScalarData.CreateEmpty(expectedChannelCount),
ScalarData.CreateEmpty(expectedChannelCount),
SpectrumData.CreateEmpty(expectedChannelCount, expectedFrequencyCount, ScaleType.Linear, ScaleType.Linear, expectedMinFrequency, expectedMaxFrequency)
);
testSource.Frame = testFrame;
}
public void Sql_Scalar_InsertDeleteTest()
{
ArrayList list = _sql.SelectAll(typeof(ScalarData));
Hashtable tbl = new Hashtable();
foreach (ScalarData d in list)
{
tbl[d.ID] = d;
}
ScalarData data = (ScalarData)TypeAccessor.CreateInstance(typeof(ScalarData));
_sql.Insert(data);
list = _sql.SelectAll(typeof(ScalarData));
foreach (ScalarData d in list)
{
if (tbl.ContainsKey(d.ID) == false)
{
_sql.Delete(d);
}
}
}
public abstract void Insert([Direction.Output("@DataTypeID")] ScalarData data);
public void SourceConverter_CombineChannels_WithMap(uint inputChannels, uint outChannels, float [] map, float[] expectedRms)
{
float[] input = new float[inputChannels];
float value = 1.0f;
for (int index = 0; index < inputChannels; index++, value *= 2.0f)
{
input[index] = value;
}
var inputFrame = new VisualizationDataFrame(TimeSpan.Zero, TimeSpan.FromMilliseconds(16), ScalarData.Create(input), null, null);
testSource.ExpectedChannels = inputChannels;
testSource.Frame = inputFrame;
sut.ChannelCount = outChannels;
sut.ChannelMapping = map;
var outFrame = sut.GetData();
CollectionAssert.AreEqual(expectedRms, outFrame.RMS.ToArray());
}
public void TestInit()
{
sut = ScalarData.CreateEmpty(2);
}
