public void Execute(string[] args)
{
try
{
if (IntExtensions.TryParseEx(args[0], out int address))
{
if (IntExtensions.TryParseEx(args[1], out int value))
{
m_Proc.WriteMemory(address, value);
m_Terminal.PrintString("\t" + args[0] + " = " + args[1] + '\n');
}
else if (FloatExtensions.TryParseEx(args[1], out float fVal))
{
m_Proc.WriteFloatToMemory(address, fVal);
m_Terminal.PrintString("\t" + args[0] + " = " + args[1] + '\n');
}
else
{
m_Terminal.PrintString(args[1] + " was not a valid 32 bit value.\n");
}
}
else
{
m_Terminal.PrintString(args[0] + " was not a valid 32 bit integer.\n");
}
}
catch (Exception ex)
{
m_Terminal.PrintString(ex.Message + '\n');
}
}
private void SampleAvailable(object?sender, float[][] samples)
{
foreach (var channel in samples)
{
_fftCalculator.Calculate(channel);
}
var portions = samples.Select(c => FloatExtensions.AveragedPortions(c, _portions));
var colors = portions.Select(c => _history.AddSample(c)?.Select(FloatExtensions.NormalizedFloatToFullRangeByte).ToArray())
.WhereNotNull()
.Select(RGBColor.FromByteArray)
.ToArray();
for (var i = 0; i < colors.Length; i++)
{
foreach (var colorProcessor in _colorProcessors)
{
colors[i] = colorProcessor.Process(colors[i]);
}
}
if (colors.Length > 0)
{
foreach (var device in _colorSetters)
{
if (!device.TrySetColors(colors))
{
_logger.LogWarning("Color missed");
}
}
}
}
/// <summary>
/// Rounds the value specific to the wanted <see cref="RoundingType"/>.
/// </summary>
/// <param name="value">The value to round.</param>
/// <param name="result">The rounded result value.</param>
/// <param name="howToRound">How to round the value?</param>
/// <param name="checkedCalculation">If true all possible exceptions are enabled.</param>
/// <returns>The rounded value.</returns>
/// <exception cref="ArgumentOutOfRangeException">The value to round is <see cref="double.NaN"/>!</exception>
/// <exception cref="ArgumentOutOfRangeException">The value is not in the range of a <see cref="int"/>!</exception>
/// <exception cref="ArgumentOutOfRangeException">The given <see cref="RoundingType"/> is not a valid <see cref="RoundingType"/>!</exception>
public static void RoundSpecific(double value, out int result, RoundingType howToRound = RoundingType.Truncate, bool checkedCalculation = false)
{
if (checkedCalculation)
{
if (double.IsNaN(value))
{
throw new ArgumentOutOfRangeException("The value to round is Not a Number!");
}
if (value < int.MinValue || value > int.MaxValue)
{
throw new ArgumentOutOfRangeException("The value is not in the range of a byte!");
}
}
double tempResult = FloatExtensions.RoundSpecific(value, howToRound);
if (double.IsNaN(tempResult) || tempResult > int.MaxValue)
{
result = int.MaxValue;
}
else if (tempResult < int.MinValue)
{
result = int.MinValue;
}
else
{
result = (int)tempResult;
}
}
public void updateValue()
{
float value = slider.value * 1000; //in millis
if (value < 30)
{
warningText.SetActive(true);
}
else
{
warningText.SetActive(false);
}
float truncatedValue = Mathf.Round(value);
if (isSnapToTenMs)
{
int newVal = (int)FloatExtensions.ToNearestMultiple(truncatedValue, 10);
millisTextSlider.text = newVal + " ms";
VibrationToBeApplied = newVal;
}
else //isSnap is off
{
millisTextSlider.text = truncatedValue + " ms";
VibrationToBeApplied = truncatedValue;
}
updateButtonRunAmp((int)VibrationToBeApplied);
}
private IEnumerator Tick()
{
while (_time > 0)
{
var prevTime = _time;
_time -= Time.deltaTime;
if (_time <= 0)
{
_time = 0;
timerEndedEvent.Invoke();
}
if (!FloatExtensions.Equals(_time, prevTime, _floatComparisonThreshold))
{
_timerUpdateEvent.Invoke(_time);
}
//TODO Optimize by making it an ordered list
_timeBetweenValuesEvents.ForEach(x => x.TryInvoke(_time));
_timeLargerThanEventEmitter.ForEach(x => x.TryInvoke(_time));
_timeSmallerThanEventEmitter.ForEach(x => x.TryInvoke(_time));
yield return(new WaitForEndOfFrame());
}
timerEndedEvent.Invoke();
}
public void UpdateValue(float value)
{
try
{
//TODO: need conditions to handle bools/int/etc here. Just floats supported atm.
if (m_AssignmentType == "Property")
{
float newValue = FloatExtensions.Scale(value, 0f, 1.0f, m_MinValue, m_MaxValue);
m_PropertyInfo.SetValue(m_TargetObject, newValue, null);
}
else if (m_AssignmentType == "Method")
{
if (m_MaxValue == m_MinValue && m_MinValue == -1.0f)
{
m_MethodInfo.Invoke(m_TargetObject, null);
}
else
{
m_MethodInfo.Invoke(m_TargetObject, new object[1] {
(int)m_MaxValue
});
}
}
}
catch
{ }
}
public void SmallDiffs()
{
using (new AssertionScope())
{
FloatExtensions.NearlyEqual(0.3f, 0.30000003f).Should().BeTrue();
FloatExtensions.NearlyEqual(-0.3f, -0.30000003f).Should().BeTrue();
}
}
public void Mid()
{
using (new AssertionScope())
{
FloatExtensions.NearlyEqual(1.0000001f, 1.0000002f).Should().BeTrue();
FloatExtensions.NearlyEqual(1.0000002f, 1.0000001f).Should().BeTrue();
FloatExtensions.NearlyEqual(1.0002f, 1.0001f).Should().BeFalse();
FloatExtensions.NearlyEqual(1.0001f, 1.0002f).Should().BeFalse();
}
}
public void SmallNeg()
{
using (new AssertionScope())
{
FloatExtensions.NearlyEqual(-0.000000001000001f, -0.000000001000002f).Should().BeTrue();
FloatExtensions.NearlyEqual(-0.000000001000002f, -0.000000001000001f).Should().BeTrue();
FloatExtensions.NearlyEqual(-0.000000000001002f, -0.000000000001001f).Should().BeFalse();
FloatExtensions.NearlyEqual(-0.000000000001001f, -0.000000000001002f).Should().BeFalse();
}
}
public void BigNeg()
{
using (new AssertionScope())
{
FloatExtensions.NearlyEqual(-1000000f, -1000001f).Should().BeTrue();
FloatExtensions.NearlyEqual(-1000001f, -1000000f).Should().BeTrue();
FloatExtensions.NearlyEqual(-10000f, -10001f).Should().BeFalse();
FloatExtensions.NearlyEqual(-10001f, -10000f).Should().BeFalse();
}
}
public void Infinities()
{
using (new AssertionScope())
{
FloatExtensions.NearlyEqual(float.PositiveInfinity, float.PositiveInfinity).Should().BeTrue();
FloatExtensions.NearlyEqual(float.NegativeInfinity, float.NegativeInfinity).Should().BeTrue();
FloatExtensions.NearlyEqual(float.NegativeInfinity, float.PositiveInfinity).Should().BeFalse();
FloatExtensions.NearlyEqual(float.PositiveInfinity, float.MaxValue).Should().BeFalse();
FloatExtensions.NearlyEqual(float.NegativeInfinity, -float.MaxValue).Should().BeFalse();
}
}
public void ExtremeMax()
{
using (new AssertionScope())
{
FloatExtensions.NearlyEqual(float.MaxValue, float.MaxValue).Should().BeTrue();
FloatExtensions.NearlyEqual(float.MaxValue, -float.MaxValue).Should().BeFalse();
FloatExtensions.NearlyEqual(-float.MaxValue, float.MaxValue).Should().BeFalse();
FloatExtensions.NearlyEqual(float.MaxValue, float.MaxValue / 2).Should().BeTrue();
FloatExtensions.NearlyEqual(float.MaxValue, -float.MaxValue / 2).Should().BeFalse();
FloatExtensions.NearlyEqual(-float.MaxValue, float.MaxValue / 2).Should().BeFalse();
}
}
public void Opposite()
{
using (new AssertionScope())
{
FloatExtensions.NearlyEqual(1.000000001f, -1.0f).Should().BeFalse();
FloatExtensions.NearlyEqual(-1.0f, 1.000000001f).Should().BeFalse();
FloatExtensions.NearlyEqual(-1.000000001f, 1.0f).Should().BeFalse();
FloatExtensions.NearlyEqual(1.0f, -1.000000001f).Should().BeFalse();
FloatExtensions.NearlyEqual(10 * float.MinValue, 10 * -float.MinValue).Should().BeFalse();
FloatExtensions.NearlyEqual(10000 * float.MinValue, 10000 * -float.MinValue).Should().BeFalse();
}
}
public void Worked(float amount)
{
if (subtaskWork > -1)
{
FloatExtensions.AtomicAdd(ref completedSubtaskWork, amount);
}
if (totalWork > -1)
{
FloatExtensions.AtomicAdd(ref completedWork, amount);
}
dirty = true;
}
public void FixedUpdate()
{
if (_unityReferenceMaster.IsPaused)
{
return;
}
_timeSinceLastSecond += Time.deltaTime;
if (_timeSinceLastSecond >= 1f)
{
_timeSinceLastSecond = 0;
}
foreach (var loop in _loops)
{
if (loop.Location != null)
{
_particleSystems[loop.EffectName].transform.position = loop.Location.position + loop.Offset;
}
else
{
_particleSystems[loop.EffectName].transform.position = loop.Offset;
}
_particleSystems[loop.EffectName].startColor = loop.Tint;
var emitCount = _particleSystems[loop.EffectName].emissionRate * loop.EmitModifier;
var emitCountPerFixedDeltaTime = emitCount * Time.fixedDeltaTime;
// if the pool emits more than 1 particle per fixed update loop
// it will do so - it will NOT consider decimals though :/ but whatever
if (emitCountPerFixedDeltaTime > 1)
{
_particleSystems[loop.EffectName].Emit((int)emitCountPerFixedDeltaTime);
}
// if the pool emits less than 1 particle per fixed update loop
// it will only do so every so oft
else
{
var closestBackFrame = FloatExtensions.Round(_timeSinceLastSecond, 1 / emitCount);
if (_timeSinceLastSecond <= closestBackFrame && _timeSinceLastSecond + Time.fixedDeltaTime > closestBackFrame)
{
_particleSystems[loop.EffectName].Emit(1);
}
}
}
}
public float FindSnapPosition(float pos, float scale, float refPos)
{
if (scale.IsOdd())
{
//print (scale * gridFactor);
pos -= pos % .5f;
if ((Mathf.Abs(pos - .5f) % 1 == .5f))
{
pos += FloatExtensions.Sign(refPos) * .5f;
}
}
else if ((scale * gridFactor).IsEven())
{
//print("its even");
pos = Mathf.Round(pos * gridFactor) / gridFactor;
}
return(pos);
}
public void Ulp()
{
using (new AssertionScope())
{
FloatExtensions.NearlyEqual(float.MinValue, float.MinValue).Should().BeTrue();
FloatExtensions.NearlyEqual(-float.MinValue, float.MinValue).Should().BeFalse();
FloatExtensions.NearlyEqual(float.MinValue, -float.MinValue).Should().BeFalse();
FloatExtensions.NearlyEqual(float.MinValue, 0.0f).Should().BeFalse();
FloatExtensions.NearlyEqual(0.0f, float.MinValue).Should().BeFalse();
FloatExtensions.NearlyEqual(-float.MinValue, 0.0f).Should().BeFalse();
FloatExtensions.NearlyEqual(0.0f, -float.MinValue).Should().BeFalse();
FloatExtensions.NearlyEqual(0.000000001f, -float.MinValue).Should().BeFalse();
FloatExtensions.NearlyEqual(0.000000001f, float.MinValue).Should().BeFalse();
FloatExtensions.NearlyEqual(float.MinValue, 0.000000001f).Should().BeFalse();
FloatExtensions.NearlyEqual(-float.MinValue, 0.000000001f).Should().BeFalse();
}
}
public void Execute(string[] args)
{
try
{
string regName = args[0];
if (IntExtensions.TryParseEx(args[1], out int iValue))
{
if (RegisterMap.IsNamedIntegerRegister(regName))
{
int regIdx = RegisterMap.GetNumericRegisterValue(regName);
m_Registers.UserIntRegisters[regIdx].Value = iValue;
m_Terminal.PrintString("\t" + regName + " = " + iValue + '\n');
}
else
{
throw new ParseException(regName + " was not a valid register name.");
}
}
else if (FloatExtensions.TryParseEx(args[1], out float fValue))
{
if (RegisterMap.IsNamedFloatingPointRegister(regName))
{
int regIdx = RegisterMap.GetNumericFloatingPointRegisterValue(regName);
m_Registers.UserFloatingPointRegisters[regIdx].Value = fValue;
m_Terminal.PrintString("\t" + regName + " = " + fValue + '\n');
}
else
{
throw new ParseException(regName + " was not a valid register name.");
}
}
else
{
throw new ParseException(args[1] + " was not a valid 32-bit value");
}
}
catch (Exception ex)
{
m_Terminal.PrintString(ex.Message + '\n');
}
}
public void Zero()
{
using (new AssertionScope())
{
FloatExtensions.NearlyEqual(0.0f, 0.0f).Should().BeTrue();
FloatExtensions.NearlyEqual(0.0f, -0.0f).Should().BeTrue();
FloatExtensions.NearlyEqual(-0.0f, -0.0f).Should().BeTrue();
FloatExtensions.NearlyEqual(0.00000001f, 0.0f).Should().BeFalse();
FloatExtensions.NearlyEqual(0.0f, 0.00000001f).Should().BeFalse();
FloatExtensions.NearlyEqual(-0.00000001f, 0.0f).Should().BeFalse();
FloatExtensions.NearlyEqual(0.0f, -0.00000001f).Should().BeFalse();
FloatExtensions.NearlyEqual(0.0f, 1e-40f, 0.01f).Should().BeTrue();
FloatExtensions.NearlyEqual(1e-40f, 0.0f, 0.01f).Should().BeTrue();
FloatExtensions.NearlyEqual(1e-40f, 0.0f, 0.000001f).Should().BeFalse();
FloatExtensions.NearlyEqual(0.0f, 1e-40f, 0.000001f).Should().BeFalse();
FloatExtensions.NearlyEqual(0.0f, -1e-40f, 0.1f).Should().BeTrue();
FloatExtensions.NearlyEqual(-1e-40f, 0.0f, 0.1f).Should().BeTrue();
FloatExtensions.NearlyEqual(-1e-40f, 0.0f, 0.00000001f).Should().BeFalse();
FloatExtensions.NearlyEqual(0.0f, -1e-40f, 0.00000001f).Should().BeFalse();
}
}
public void NaN()
{
using (new AssertionScope())
{
FloatExtensions.NearlyEqual(float.NaN, float.NaN).Should().BeTrue();
FloatExtensions.NearlyEqual(float.NaN, 0.0f).Should().BeFalse();
FloatExtensions.NearlyEqual(-0.0f, float.NaN).Should().BeFalse();
FloatExtensions.NearlyEqual(float.NaN, -0.0f).Should().BeFalse();
FloatExtensions.NearlyEqual(0.0f, float.NaN).Should().BeFalse();
FloatExtensions.NearlyEqual(float.NaN, float.PositiveInfinity).Should().BeFalse();
FloatExtensions.NearlyEqual(float.PositiveInfinity, float.NaN).Should().BeFalse();
FloatExtensions.NearlyEqual(float.NaN, float.NegativeInfinity).Should().BeFalse();
FloatExtensions.NearlyEqual(float.NegativeInfinity, float.NaN).Should().BeFalse();
FloatExtensions.NearlyEqual(float.NaN, float.MaxValue).Should().BeFalse();
FloatExtensions.NearlyEqual(float.MaxValue, float.NaN).Should().BeFalse();
FloatExtensions.NearlyEqual(float.NaN, -float.MaxValue).Should().BeFalse();
FloatExtensions.NearlyEqual(-float.MaxValue, float.NaN).Should().BeFalse();
FloatExtensions.NearlyEqual(float.NaN, float.MinValue).Should().BeFalse();
FloatExtensions.NearlyEqual(float.MinValue, float.NaN).Should().BeFalse();
FloatExtensions.NearlyEqual(float.NaN, -float.MinValue).Should().BeFalse();
FloatExtensions.NearlyEqual(-float.MinValue, float.NaN).Should().BeFalse();
}
}
/// <summary>
/// Rounds the value specific to the wanted <see cref="RoundingType"/>.
/// </summary>
/// <param name="value">The value to round.</param>
/// <param name="result">The rounded result value.</param>
/// <param name="howToRound">How to round the value?</param>
/// <param name="checkedCalculation">If true all possible exceptions are enabled.</param>
/// <returns>The rounded value.</returns>
/// <exception cref="ArgumentOutOfRangeException">The value is not in the range of a <see cref="byte"/>!</exception>
/// <exception cref="ArgumentOutOfRangeException">The given <see cref="RoundingType"/> is not a valid <see cref="RoundingType"/>!</exception>
public static void RoundSpecific(decimal value, out byte result, RoundingType howToRound = RoundingType.Truncate, bool checkedCalculation = false)
{
if (checkedCalculation)
{
if (value < byte.MinValue || value > byte.MaxValue)
{
throw new ArgumentOutOfRangeException("The value is not in the range of a byte!");
}
}
decimal tempResult = FloatExtensions.RoundSpecific(value, howToRound);
if (tempResult > byte.MaxValue)
{
result = byte.MaxValue;
}
else if (tempResult < byte.MinValue)
{
result = byte.MinValue;
}
else
{
result = (byte)tempResult;
}
}
