+ Added FastMix

MonoAudio.Core/SystemExtensions/Memory/SpanExtensions.cs

@@ -143,5 +143,41 @@ public static void FastScalarMultiply(this Span<float> span, float scale = defau
                 }
             }
         }
+
+        /// <summary>
+        /// Mixes the <paramref name="samplesToMix"/> to <paramref name="buffer"/>.
+        /// </summary>
+        /// <param name="samplesToMix">The samples to add.</param>
+        /// <param name="buffer">The buffer.</param>
+        /// <param name="scale">The scale to scale <paramref name="samplesToMix"/>.</param>
+        /// <exception cref="ArgumentException">samplesToMix</exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void FastMix(ReadOnlySpan<float> samplesToMix, Span<float> buffer, float scale)
+        {
+            if (samplesToMix.Length > buffer.Length) throw new ArgumentException("", nameof(samplesToMix));
+            unsafe
+            {
+                (int newLength, int remainder) = MathI.FloorStepRem(samplesToMix.Length, Vector<float>.Count);
+                if (newLength != 0)
+                {
+                    var scaleV = new Vector<float>(scale);
+                    var src = MemoryMarshal.Cast<float, Vector<float>>(samplesToMix);
+                    var dst = MemoryMarshal.Cast<float, Vector<float>>(buffer);
+                    for (int i = 0; i < src.Length; i++)
+                    {
+                        dst[i] += src[i] * scaleV;
+                    }
+                }
+                if (remainder != 0)
+                {
+                    var srcRem = samplesToMix.Slice(newLength);
+                    var dstRem = buffer.Slice(newLength);
+                    for (int i = 0; i < srcRem.Length; i++)
+                    {
+                        dstRem[i] += srcRem[i] * scale;
+                    }
+                }
+            }
+        }
     }
 }

Tests/MonoAudio.Core.Tests.CoreFx/SpanExtensionsTest.cs

@@ -173,5 +173,69 @@ public void FastScalarMultiplyFasterThanUnsafe(int length)
             Console.WriteLine($"{nameof(SpanExtensions.FastScalarMultiply)} seems to be {(double)cntFast / cntStandard} times faster than unsafe loop.");
             Assert.Greater(cntFast, cntStandard);
         }
+
+        [Test]
+        public void FastMixMixesCorrectly()
+        {
+            Span<float> source = stackalloc float[32];
+            Span<float> destination = stackalloc float[48];
+            const int Value = 1;
+            source.FastFill(Value);
+            destination.FastFill(-1);
+
+            SpanExtensions.FastMix(source, destination, 2);
+            for (int i = 0; i < source.Length; i++)
+            {
+                if (destination[i] != 1) Assert.Fail("The FastMix doesn't mix correctly!");
+            }
+            Assert.Pass();
+        }
+
+        [TestCase(2459)]    //Prime number
+        [TestCase(2048)]    //2^11
+        public void FastMixFasterThanUnsafeMix(int length)
+        {
+            var sw = new Stopwatch();
+            Span<float> source = stackalloc float[length];
+            Span<float> destination = stackalloc float[length + 1024];
+            source.FastFill(1);
+            destination.FastFill(0);
+            long cntFast = 0;
+            long cntStandard = 0;
+            Thread.Sleep(50);
+            sw.Start();
+            do
+            {
+                SpanExtensions.FastMix(source, destination, 1.0f / cntFast);
+                cntFast++;
+            } while (sw.ElapsedMilliseconds < length);
+            sw.Stop();
+            Console.WriteLine(cntFast);
+            sw.Reset();
+            Thread.Sleep(50);
+            sw.Start();
+            do
+            {
+                var u = 1.0f / cntStandard;
+                unsafe
+                {
+                    fixed (float* srcFx = source)
+                    fixed (float* dstFx = destination)
+                    {
+                        var src = srcFx;
+                        var dst = dstFx;
+                        do
+                        {
+                            *dst++ += (*src++) * u;
+                        } while (src < srcFx + source.Length);
+                    }
+                }
+                cntStandard++;
+            } while (sw.ElapsedMilliseconds < length);
+            sw.Stop();
+            Console.WriteLine(cntStandard);
+            Console.WriteLine($"{nameof(SpanExtensions.FastAdd)} seems to be {(double)cntFast / cntStandard} times faster than unsafe loop.");
+            Assert.Greater(cntFast, cntStandard);
+        }
     }
 }