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