/// <summary>
/// Creates Real-Time FFT analyzer.
/// </summary>
/// <param name="source">Specified audio provider.</param>
/// <param name="fftLength">Length of FFT.</param>
public LiveFftAnalyzer(IAudioProvider source, int fftLength = 16384, bool real = true)
{
_real = real;
FftLength = fftLength;
_channels = source.ChannelCount();
if (!IsPowerOfTwo(fftLength))
{
throw new ArgumentException("FFT Length must be a power of two");
}
_m = (int)Math.Log(fftLength, 2.0);
_fftLength = fftLength;
FftPlan(_fftLength);
_fftBuffer = new Complex[fftLength];
_fftArgs = new FftEventArgs(_fftBuffer);
_source = source;
_source.DataChunkRecieved += DataChunkRecieved;
if (_source is IFloatProvider)
{
(_source as IFloatProvider).FloatChunkRecieved += FloatChunkRecieved;
}
WaveFormat = new WaveFormat(_source.SamplingRate(), _source.Bits(), _source.ChannelCount());
_converter = new FloatConverter(_source.SamplingRate(), _source.Bits(), _source.ChannelCount());
_step = _channels * _converter.Step();
}
public void ConvertToCsvItemTest()
{
var c = new FloatConverter();
Assert.AreEqual("1000.1", c.ConvertToCsvItem(CreateConvertToCsvItemContext(1000.1f)));
Assert.AreEqual("1,000.1", c.ConvertToCsvItem(CreateConvertToCsvItemContext(1000.1f, "FormattedValue")));
}
private float?ConvertToObjectItem(string csvItem)
{
var c = new FloatConverter();
Assert.IsTrue(c.TryConvertToObjectItem(CreateConvertToObjectItemContext(csvItem), out object?result, out string _));
return((float?)result);
}
private static string floatArrayToString(float[] array, int num)
{
StringBuilder stringBuilder = new StringBuilder().append(array.Length);
int num2 = array.Length;
for (int i = 0; i < num2; i++)
{
float num3 = array[i];
if (num == 3)
{
stringBuilder.append(' ').append(DataUtil.formatDouble((double)num3, 10, 5));
}
else if (num == 1)
{
FloatConverter floatConverter = new FloatConverter();
int num4 = FloatConverter.ToInt(num3, ref floatConverter);
stringBuilder.append(" 0x").append(Integer.toHexString(num4));
}
else if (num == 2)
{
stringBuilder.append(' ').append(Utilities.doubleToScientificString((double)num3, 8));
}
}
return(stringBuilder.toString());
}
internal override void CalculateReturnValue()
{
if (FloatConverter == null)
{
throw new NullReferenceException();
}
else
{
if (modbusValueData.Values.Count > 1)
{
int indexno = 0;
ushort[] values = new ushort[2];
foreach (var item in base.modbusValueData.Values)
{
values[indexno] = item;
indexno++;
if (indexno == 2)
{
break;
}
}
InnerValue = FloatConverter.ConvertToFloat(values[0], values[1]);
}
else
{
throw new IndexOutOfRangeException();
}
}
}
public void TestFloatConverter()
{
FloatConverter floatConverter = new FloatConverter();
Assert.True(floatConverter.CanConvertTo(typeof(float)));
Assert.True(floatConverter.CanConvertTo(typeof(double)));
Assert.True(floatConverter.CanConvertTo(typeof(decimal)));
Assert.False(floatConverter.CanConvertTo(typeof(string)));
Assert.False(floatConverter.CanConvertTo(typeof(int)));
Assert.False(floatConverter.CanConvertTo(typeof(Enum)));
Assert.True(floatConverter.CanConvertFrom(" 10 "));
Assert.True(floatConverter.CanConvertFrom("1.0"));
Assert.True(floatConverter.CanConvertFrom(" .2"));
Assert.True(floatConverter.CanConvertFrom(" 0 "));
Assert.True(floatConverter.CanConvertFrom(" 1,000,000"));
Assert.True(floatConverter.CanConvertFrom(" 123.456 "));
Assert.True(floatConverter.CanConvertFrom(".123"));
Assert.True(floatConverter.CanConvertFrom(" 1,234,567.89 "));
Assert.True(floatConverter.CanConvertFrom("1e2"));
Assert.True(floatConverter.CanConvertFrom("12E-3"));
Assert.True(floatConverter.CanConvertFrom("1.2E4"));
Assert.False(floatConverter.CanConvertFrom("abc"));
Assert.False(floatConverter.CanConvertFrom(""));
Assert.False(floatConverter.CanConvertFrom(" "));
Assert.False(floatConverter.CanConvertFrom("."));
Assert.False(floatConverter.CanConvertFrom("abc123"));
Assert.False(floatConverter.CanConvertFrom("1 2 3"));
Assert.False(floatConverter.CanConvertFrom("123e"));
Assert.False(floatConverter.CanConvertFrom("e123"));
Assert.Equal(1.0f, floatConverter.Convert(typeof(float), "1"));
Assert.Equal(0.123d, floatConverter.Convert(typeof(double), " .123"));
Assert.Equal(1234567m, floatConverter.Convert(typeof(decimal), "1,234,567 "));
Assert.Equal(123.0m, floatConverter.Convert(typeof(object), " 123"));
Assert.Equal(12.3f, floatConverter.Convert(typeof(float), " 1,2.3"));
Assert.Equal(123.456d, floatConverter.Convert(typeof(double), "123.456 "));
Assert.Equal(1.00001m, floatConverter.Convert(typeof(decimal), "00001.00001"));
Assert.Equal(0.123m, floatConverter.Convert(typeof(object), ".123 "));
Assert.Equal(1234567.89f, floatConverter.Convert(typeof(float), "1,234,567.89 "));
Assert.Equal(123456789.0d, floatConverter.Convert(typeof(double), " 1,2,3,4,5,6,7,8,9"));
Assert.Equal(0.0m, floatConverter.Convert(typeof(decimal), " 00000 "));
Assert.Equal(1234.0m, floatConverter.Convert(typeof(object), "1,234"));
Assert.Equal(12000.0f, floatConverter.Convert(typeof(float), "12e3"));
Assert.Equal(0.01d, floatConverter.Convert(typeof(double), "10e-3"));
Assert.Equal(10000000000000000.0m, floatConverter.Convert(typeof(decimal), " 10E+15 "));
Assert.Equal(0.00035m, floatConverter.Convert(typeof(object), "3.5E-4"));
Assert.Throws <InvalidOperationException>(() => floatConverter.Convert(typeof(float), "."));
Assert.Throws <InvalidOperationException>(() => floatConverter.Convert(typeof(double), "122abc"));
Assert.Throws <InvalidOperationException>(() => floatConverter.Convert(typeof(decimal), " 1 2 3 4 "));
Assert.Throws <InvalidOperationException>(() => floatConverter.Convert(typeof(object), "123..123"));
Assert.Throws <InvalidOperationException>(() => floatConverter.Convert(typeof(float), "e"));
Assert.Throws <InvalidOperationException>(() => floatConverter.Convert(typeof(double), "1E"));
Assert.Throws <InvalidOperationException>(() => floatConverter.Convert(typeof(decimal), " 3E"));
Assert.Throws <InvalidOperationException>(() => floatConverter.Convert(typeof(object), " 3e4E-1 "));
}
public FloatRatingConverter(FloatConverter innerConverter, TimeSpan period) :
base(innerConverter)
{
Period = period;
tokenSource = new CancellationTokenSource();
reportTask = ReportAsync();
}
public ushort[] GetWriteValue()
{
if (FloatConverter == null)
{
throw new NullReferenceException();
}
return(FloatConverter.ConvertToUshort(WriteValue));
}
public void TryConvertToObjectItemFailureTest()
{
var c = new FloatConverter();
var context = CreateConvertToObjectItemContext("x");
Assert.IsFalse(c.TryConvertToObjectItem(context, out object?_, out string message));
Assert.AreEqual(CsvConfig.Current.ValidationMessage.GetNumericConvertError(context), message);
}
public void ToQuotedString_FloatConverter_not_throw_Exception()
{
var floatConverter = new FloatConverter();
floatConverter.ToQuotedString(typeof(decimal), 89.123456789);
floatConverter.ToQuotedString(typeof(float), 89.123456789);
floatConverter.ToQuotedString(typeof(double), 89.123456789);
}
public void TryConvertToObjectItemRequireTest()
{
var c = new FloatConverter();
var context = CreateConvertToObjectItemContext(string.Empty);
Assert.IsFalse(c.TryConvertToObjectItem(context, out object?_, out string message));
Assert.AreEqual(CsvConfig.Current.ValidationMessage.GetRequiredError(context), message);
}
public Mixer(FloatConverter innerConverter, TimeSpan period, int frameSize)
: base(innerConverter)
{
Period = period;
data = new float[frameSize];
watch = Stopwatch.StartNew();
var ignore = SynchonizeAsync();
}
public G3XDdcDdc1FloatProvider(Ddc1 ddc1, bool seperateIq = false, int bufferSize = 131072)
{
_floatBuffer = new float[bufferSize];
_ddc1 = ddc1;
SeperateIq = seperateIq;
_converter = new FloatConverter(SamplingRate(), Bits(), ChannelCount());
_step = _converter.Step() * ChannelCount();
}
public void CanSerializeAndDeserialize()
{
float value = float.MaxValue;
FloatConverter converter = new FloatConverter();
byte[] bytes = converter.Serialize(value);
float valueFromBytes = converter.Deserialize(bytes);
Assert.Equal(valueFromBytes, value);
}
/// <summary>
/// This is a approximate yet fast inverse square-root.
/// </summary>
/// <param name="x">The x.</param>
/// <returns></returns>
public static float InvSqrt(float x)
{
FloatConverter convert = new FloatConverter();
convert.x = x;
float xhalf = 0.5f * x;
convert.i = 0x5f3759df - (convert.i >> 1);
x = convert.x;
x = x * (1.5f - xhalf * x * x);
return x;
}
public static Half SingleToHalf(float single)
{
uint value = new FloatConverter()
{
Float = single
}.Integer;
ushort result = (ushort)(baseTable[(value >> 23) & 0x1ff] + ((value & 0x007fffff) >> shiftTable[value >> 23]));
return(Half.ToHalf(result));
}
/// <summary>
/// This is a approximate yet fast inverse square-root.
/// </summary>
/// <param name="x">The x.</param>
/// <returns></returns>
public static float InvSqrt(float x)
{
FloatConverter convert = new FloatConverter {
X = x
};
float xhalf = 0.5f * x;
convert.I = 0x5f3759df - (convert.I >> 1);
x = convert.X;
x = x * (1.5f - xhalf * x * x);
return(x);
}
private void Ddc2_AudioDataRecieved(object sender, AudioCallbackArgs e)
{
if (DataChunkRecieved == null)
{
return;
}
var data = UseFilteredDate
? FloatConverter.Float32ToPcm16BufferReady(e.FilteredData)
: FloatConverter.Float32ToPcm16BufferReady(e.Data);
DataChunkRecieved(this, new ChunkArgs(data, e.SamplingRate));
}
public void FloatConverter_CorrectConversionTest()
{
Array[] data = new float[][]
{
new float[] { 0f, 1f },
new float[] { 0.4f, 0.6f },
};
var converter = new FloatConverter();
var sut = converter.Convert(data, 2, 2);
var expectation = new ushort[] { 0, ushort.MaxValue, 26214, 39321 };
sut.Should().BeEquivalentTo(expectation);
}
private void ProvideRawData(Ddc2CallbackArgs e)
{
if (!RawProvider || DataChunkRecieved == null)
{
return;
}
var iqRate = e.SamplingRate;
iqRate = SeperateIq ? iqRate : iqRate * 2;
var data = FloatConverter.Float32ToPcm16BufferReady(e.Data);
DataChunkRecieved(this, new ChunkArgs(data, iqRate));
}
public void ShouldFailToConvertToCSharpValue()
{
//Arrange
object value0;
object value1;
object value2;
var converter = new FloatConverter();
//Act
bool success0 = converter.TryConvertToCSharpValue("9E10D", out value0);
bool success1 = converter.TryConvertToCSharpValue("N/A", out value1);
bool success2 = converter.TryConvertToCSharpValue("10000E", out value2);
//Assert
Assert.IsFalse(success0);
Assert.IsFalse(success1);
Assert.IsFalse(success2);
}
public virtual float readFloat(DataInputStream dis)
{
int num;
if (this.swap)
{
num = Utilities.readLittleEndianInt(dis);
}
else
{
num = dis.readInt();
}
this.calculatedCheckSum = ((this.calculatedCheckSum << 20 | this.calculatedCheckSum >> 12) + (long)num & unchecked ((long)(unchecked ((ulong)-1))));
FloatConverter floatConverter = new FloatConverter();
return(FloatConverter.ToFloat(num, ref floatConverter));
}
public override void Execute()
{
GameConstants.Directories.Root = Application.dataPath + @"/../";
var overlayCanvas = GameObject.Find("OverlayCanvas");
injectionBinder.Bind <GameObject>().ToValue(overlayCanvas).ToName(GameContextKeys.OverlayCanvas);
var worldSpaceCanvas = GameObject.Find("WorldSpaceCanvas");
injectionBinder.Bind <GameObject>().ToValue(worldSpaceCanvas).ToName(GameContextKeys.WorldSpaceCanvas);
var floatConverter = new FloatConverter();
var stringConverter = new StringConverter();
var vector2Converter = new Vector2Converter();
LoadDispatcher.Dispatch();
}
public void t1()
{
// 一次累计流量 1027
//
byte[] bs = new byte[]{0x03, 0x04, 0x00, 0x00};
Int32Converter c = new Int32Converter();
int i = (int)c.ConvertToObject(bs);
FloatConverter f = new FloatConverter();
float fv = (float)f.ConvertToObject(bs);
fv = (float)Math.Round(fv, 2);
//Assert.AreEqual(i, fv);
f.IsLittleEndian = false;
bs = f.ConvertToBytes(10.01F);
float f2 = (float)f.ConvertToObject(bs);
Assert.AreEqual(10.01F, f2);
}
public void ShouldConvertToCellValue()
{
//Arrange
string value0;
string value1;
string value2;
var converter = new FloatConverter();
//Act
bool success0 = converter.TryConvertToCellValue(0.123f, out value0);
bool success1 = converter.TryConvertToCellValue(1000000000f, out value1);
bool success2 = converter.TryConvertToCellValue(-12.85f, out value2);
//Assert
Assert.IsTrue(success0);
Assert.IsTrue(success1);
Assert.IsTrue(success2);
Assert.AreEqual("0.123", value0);
Assert.AreEqual("1E+09", value1);
Assert.AreEqual("-12.85", value2);
}
public void ShouldConvertToCSharpValue()
{
//Arrange
object value0;
object value1;
object value2;
var converter = new FloatConverter();
//Act
bool success0 = converter.TryConvertToCSharpValue("0.123", out value0);
bool success1 = converter.TryConvertToCSharpValue("9E10", out value1);
bool success2 = converter.TryConvertToCSharpValue("-12.84848715", out value2);
//Assert
Assert.IsTrue(success0);
Assert.IsTrue(success1);
Assert.IsTrue(success2);
Assert.AreEqual(0.123f, value0);
Assert.AreEqual(9E10f, value1);
Assert.AreEqual(-12.84848715f, value2);
}
public void t1()
{
// 一次累计流量 1027
//
byte[] bs = new byte[] { 0x03, 0x04, 0x00, 0x00 };
Int32Converter c = new Int32Converter();
int i = (int)c.ConvertToObject(bs);
FloatConverter f = new FloatConverter();
float fv = (float)f.ConvertToObject(bs);
fv = (float)Math.Round(fv, 2);
//Assert.AreEqual(i, fv);
f.IsLittleEndian = false;
bs = f.ConvertToBytes(10.01F);
float f2 = (float)f.ConvertToObject(bs);
Assert.AreEqual(10.01F, f2);
}
public static int ToInt(float value, ref FloatConverter converter)
{
converter._f = value;
return converter._i;
}
public static float ToFloat(int value, ref FloatConverter converter)
{
converter._i = value;
return converter._f;
}
public static float IntBitsToFloat(int value)
{
FloatConverter converter = new FloatConverter();
return FloatConverter.ToFloat(value, ref converter);
}
public static int FloatToRawIntBits(float f)
{
FloatConverter converter = new FloatConverter();
return FloatConverter.ToInt(f, ref converter);
}
public static float IntBitsToFloat(int value)
{
FloatConverter converter = new FloatConverter();
return(FloatConverter.ToFloat(value, ref converter));
}
public void ShouldFailToConvertToCellValue()
{
//Arrange
string value0;
string value1;
string value2;
var converter = new FloatConverter();
//Act
bool success0 = converter.TryConvertToCellValue(0.18D, out value0);
bool success1 = converter.TryConvertToCellValue("-1", out value1);
bool success2 = converter.TryConvertToCellValue("NaN", out value2);
//Assert
Assert.IsFalse(success0);
Assert.IsFalse(success1);
Assert.IsFalse(success2);
}
public static int ToInt(float value, ref FloatConverter converter)
{
converter._f = value;
return(converter._i);
}
public static int FloatToRawIntBits(float f)
{
FloatConverter converter = new FloatConverter();
return(FloatConverter.ToInt(f, ref converter));
}
public ScalingConverter(FloatConverter innerConverter, float ratio)
: base(innerConverter)
{
Ratio = ratio;
}
/// <summary>
/// Converts array element into a float or returns default value if conversion is not possible.
/// </summary>
/// <param name="index">an index of element to get.</param>
/// <param name="defaultValue">the default value</param>
/// <returns>float value of element or default value if conversion is not supported.</returns>
/// See <see cref="FloatConverter.ToFloatWithDefault(object, float)"/>
public float GetAsFloatWithDefault(int index, float defaultValue)
{
return(FloatConverter.ToFloatWithDefault(this[index], defaultValue));
}
/// <summary>
/// Converts array element into a float or returns null if conversion is not possible.
/// </summary>
/// <param name="index">an index of element to get.</param>
/// <returns>float value of element or null if conversion is not supported.</returns>
/// See <see cref="FloatConverter.ToNullableFloat(object)"/>
public float?GetAsNullableFloat(int index)
{
return(FloatConverter.ToNullableFloat(this[index]));
}
public static float ToFloat(int value, ref FloatConverter converter)
{
converter._i = value;
return(converter._f);
}
public FloatSimplifier(FloatConverter innerConverter, int ratio, int frameSize)
: base(innerConverter)
{
Ratio = ratio;
FrameSize = frameSize;
}
