Min Max Span C#

2025-04-02 18:34 UTC o3-mini-high Open in ChatGPT ↗

A straightforward approach is to iterate through the span once and update both the minimum and maximum values as you go. For example:

public static (float min, float max) GetMinMax(ReadOnlySpan<float> span)
{
    if (span.IsEmpty)
        throw new ArgumentException("Span is empty.", nameof(span));

    float min = span[0];
    float max = span[0];

    for (int i = 1; i < span.Length; i++)
    {
        float value = span[i];
        if (value < min)
            min = value;
        if (value > max)
            max = value;
    }
    return (min, max);
}

This method only loops through the span once, so it’s very efficient.

For large spans and on platforms that support SIMD, you can further optimize by leveraging vectorization via System.Numerics.Vector<float>. This approach processes multiple elements at once:

using System;
using System.Numerics;

public static (float min, float max) GetMinMaxVectorized(ReadOnlySpan<float> span)
{
    if (span.IsEmpty)
        throw new ArgumentException("Span is empty.", nameof(span));

    int vectorSize = Vector<float>.Count;
    int i = 0;

    Vector<float> minVector = new Vector<float>(float.MaxValue);
    Vector<float> maxVector = new Vector<float>(float.MinValue);

    // Process blocks of elements using vectorization
    for (; i <= span.Length - vectorSize; i += vectorSize)
    {
        var vector = new Vector<float>(span.Slice(i, vectorSize));
        minVector = Vector.Min(minVector, vector);
        maxVector = Vector.Max(maxVector, vector);
    }

    // Reduce the vectorized results to scalar values
    float min = float.MaxValue;
    float max = float.MinValue;
    for (int j = 0; j < vectorSize; j++)
    {
        min = Math.Min(min, minVector[j]);
        max = Math.Max(max, maxVector[j]);
    }

    // Process any remaining elements
    for (; i < span.Length; i++)
    {
        float value = span[i];
        min = Math.Min(min, value);
        max = Math.Max(max, value);
    }

    return (min, max);
}

Summary

Single-pass loop: Simple and very efficient for most cases.
Vectorized version: May yield performance benefits on large spans and when SIMD is available, though it introduces a bit more complexity.

Both approaches avoid multiple passes (like using separate LINQ methods for Min and Max), which is key for efficiency.

Pin the array, get a pointer turn into a native array withotu allocations, and execute the loop in a parallel job

        if (_ptsInternal == null || _ptsInternal.Length != currentData.Length)
        {
            _ptsInternal = new PolylinePoint[data.Length];
        }

        for (var i = 0; i < _ptsInternal.Length; i++)
        {
            var d = data[i];
            var t = math.remap(0,   _ptsInternal.Length, 0f,     1f,              i);
            var x = math.remap(0f,  1f,                  left,   left   + width,  t);
            var y = math.remap(min, max,                 bottom, bottom + height, d);

            _ptsInternal[i] = new PolylinePoint(point: new Vector2(x, y),
                                                color: t    < T ? beforeColor : afterColor,
                                                thickness: t < T ? 0.75f : 1.5f);
        }

Below is one way to do it in Unity using unsafe code and Unity’s Job System. In this example, we “pin” the managed array, create a NativeArray view over it (without allocating new memory), and then schedule a parallel job to update each element. Note that this requires enabling unsafe code and carefully managing lifetimes.

Example Code

using System;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;

// Make sure PolylinePoint and Vector2 are defined appropriately in your project.
public struct PolylinePoint
{
    public Vector2 point;
    public Color color;
    public float thickness;

    public PolylinePoint(Vector2 point, Color color, float thickness)
    {
        this.point = point;
        this.color = color;
        this.thickness = thickness;
    }
}

[BurstCompile] // Optional: for further speedups
public struct UpdatePolylinePointsJob : IJobParallelFor
{
    [ReadOnly] public NativeArray<float> data;

    // Marked with NativeDisableUnsafePtrRestriction to allow passing unsafe NativeArray
    [NativeDisableUnsafePtrRestriction]
    public NativeArray<PolylinePoint> ptsInternal;

    public float left;
    public float width;
    public float min;
    public float max;
    public float bottom;
    public float height;
    public float T;
    public Color beforeColor;
    public Color afterColor;

    public void Execute(int i)
    {
        float d = data[i];
        float t = math.remap(0, ptsInternal.Length, 0f, 1f, i);
        float x = math.remap(0f, 1f, left, left + width, t);
        float y = math.remap(min, max, bottom, bottom + height, d);

        ptsInternal[i] = new PolylinePoint(
            new Vector2(x, y),
            t < T ? beforeColor : afterColor,
            t < T ? 0.75f : 1.5f
        );
    }
}

public class PolylineUpdater : MonoBehaviour
{
    // Managed array that will be “pinned”
    private PolylinePoint[] _ptsInternal;

    // Example data array
    [SerializeField] private float[] data;

    // These values need to be set according to your context
    public float left = 0f, width = 10f, min = 0f, max = 1f;
    public float bottom = 0f, height = 5f, T = 0.5f;
    public Color beforeColor = Color.green, afterColor = Color.red;

    public void UpdatePoints()
    {
        // Ensure our managed array is allocated with the correct length.
        if (_ptsInternal == null || _ptsInternal.Length != data.Length)
        {
            _ptsInternal = new PolylinePoint[data.Length];
        }

        // Pin the managed array and create a NativeArray view without extra allocations.
        unsafe
        {
            fixed (PolylinePoint* ptsPtr = _ptsInternal)
            {
                // Create a NativeArray view over the pinned memory.
                var nativePts = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray<PolylinePoint>(
                    ptsPtr,
                    _ptsInternal.Length,
                    Allocator.None
                );

#if ENABLE_UNITY_COLLECTIONS_CHECKS
                // When safety checks are enabled, assign an atomic safety handle.
                NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref nativePts, AtomicSafetyHandle.Create());
#endif

                // For the input data, you can create a temporary NativeArray.
                // If data is large or updated frequently, consider using a persistent native container.
                var nativeData = new NativeArray<float>(data, Allocator.TempJob);

                // Set up the parallel job.
                var job = new UpdatePolylinePointsJob
                {
                    data = nativeData,
                    ptsInternal = nativePts,
                    left = left,
                    width = width,
                    min = min,
                    max = max,
                    bottom = bottom,
                    height = height,
                    T = T,
                    beforeColor = beforeColor,
                    afterColor = afterColor
                };

                // Schedule the job with a batch size (e.g., 64) and wait for its completion.
                JobHandle handle = job.Schedule(_ptsInternal.Length, 64);
                handle.Complete();

                // Dispose the temporary nativeData array.
                nativeData.Dispose();
            }
        }

        // At this point, _ptsInternal has been updated by the job.
        // You can now use _ptsInternal as needed.
    }
}

Explanation

Pinning the Managed Array:
The fixed statement pins the _ptsInternal array so that its memory location doesn’t change during the job execution.
Creating a NativeArray View:
We call NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray<PolylinePoint> to wrap the pinned memory in a NativeArray without extra allocations. (When running with safety checks enabled, you should assign an atomic safety handle.)
Setting Up the Parallel Job:
The job, which implements IJobParallelFor, processes each element of the array in parallel. We also create a temporary NativeArray<float> from the managed data array.
Scheduling and Completing the Job:
The job is scheduled with a given batch size (here 64), then completed, ensuring that _ptsInternal is updated safely.

This approach minimizes allocations and leverages parallel processing, making it suitable for performance-critical scenarios. Use with care, as unsafe code requires you to ensure that the managed array is not reallocated while the job is running.

You can wrap an existing span in a NativeArray without extra allocations by pinning the span’s memory and using the unsafe conversion API. For example:

using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;

public static unsafe NativeArray<float> SpanToNativeArray(ReadOnlySpan<float> span)
{
    fixed (float* ptr = span)
    {
        var nativeArray = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray<float>(
            ptr,
            span.Length,
            Allocator.None);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
        NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref nativeArray, AtomicSafetyHandle.Create());
#endif
        return nativeArray;
    }
}

Explanation

Pinning the Span:
The fixed statement pins the memory underlying the span. This prevents the garbage collector from moving the data while you use it.
Conversion without Allocation:
NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray wraps the pinned memory in a NativeArray without performing an allocation.
Use Allocator.None since you’re not allocating new memory.
Safety Checks:
When Unity’s safety checks are enabled, you need to assign an atomic safety handle to the NativeArray. This is optional in release builds but important during development.

This way, you convert a ReadOnlySpan<float> to a NativeArray<float> without allocating new memory.