PointF []数组中的最大值和最小值

Question

I have an array of PointF's that I want to use it for drawing a curve with Graphics.DrawCurve method.

For doing this, I need to now max and min of both X and Y so I can scale my bitmap imagebox correctly.

How is it possible to find the max and min for X & Y in an array of PointF's ?

I came up with this idea but I am not sure if this is the best way!

    //Find the max value on X axis (Time) and Y axis (Current)
    float xMax = 0;
    float yMax = 0;

    foreach (PointF point in points)
    {
        if (point.X > xMax)
        {
            xMax = point.X;
        }

        if (point.Y > yMax)
        {
            yMax = point.Y;
        }
    }

Answer 1

You need to iterate over all the elements in the array and test each one against a bounding box, increasing the bounding box when the current item is outside it. Like this:

Point 
  min = first item in array, 
  max = first item in array;

foreach (item in array of points)
{
  min.x = Math.Min (min.x, item.x)
  min.y = Math.Min (min.y, item.y)
  max.x = Math.Max (max.x, item.x)
  max.y = Math.Max (max.y, item.y)
}


(min,max) are now the opposite corners of an axis aligned bounding box

EDIT: You've got the right idea, but there is a .Net framework API to do the min/max test: Math.Min and Math.Max. Unless there's some other information about the array of points that can be used to reduce the number of tests, you are going to have to test every point in the array. No short cuts there unfortunately. I wonder if the JIT compiler is smart enough to use SIMD for this?

Also, initialising with the value 0 could cause an error if all the points in the array are less than zero.

Answer 2

If you find the minumum (top left point) and maximum (bottom right point) you can calculate the size of the graph.

First you need a way to compare Point values - if the Point class (struct?) implements IComparable you're already good to go, otherwise you might need to write a custom IComparer class.

Next you can write a simple extension method on IEnumerable to get the minimum or maximum values out of a collection:

static class ExtensionsClass
{
    /// <summary>
    /// Returns the mimimum value within the collection.
    /// </summary>
    static public T Min(this IEnumerable<T> values) where T : IComparable<T>
    {
        T min = values.First();

        foreach(T item in values)
        {
            if (item.CompareTo(min) < 0)
                min = item;
        }

        return min;
    }

    /// <summary>
    /// Returns the maximum value within the collection.
    /// </summary>
    static public T Max(this IEnumerable<T> values) where T : IComparable<T>
    {
        T max= values.First();

        foreach(T item in values)
        {
            if (item.CompareTo(min) > 0)
                max= item;
        }

        return max;
    }
}

Using these extension methods it would be much easier to find the minimum/maximum points and therefore and size of the graph.

var minX = points.Min().x;
var minY = points.Min().y;
var maxX = points.Max().x;
var maxY = points.Max().y;

Answer 3

Using RyuJIT and SIMD , these operations can be massively accelerated.

  void MinMax(int[] a, out int minimum, out int maximum) {
  int simdLength = Vector<int>.Length;
  Vector<int> vmin = new Vector<int>(int.MaxValue);
  Vector<int> vmax = new Vector<int>(int.MinValue);
  for (int i = 0; i < a.Length; i += simdLength) {
      Vector<int> va = new Vector<int>(a, i);
      Vector<int> vLessThan = Vector.LessThan(va, vmin);
      vmin = Vector.ConditionalSelect(vLessThan, va, vmin);
      Vector<int> vGreaterThan = Vector.GreaterThan(va, vmax);
      vmax = Vector.ConditionalSelect(vGreaterThan, va, vmax);
  }
  int min = int.MaxValue, max = int.MinValue;
  for (int i = 0; i < simdLength; ++i) {
      min = Math.Min(min, vmin[i]);
      max = Math.Max(max, vmax[i]);
  }
  minimum = min;
  maximum = max;
}

Obviously replace the int array with the PointF array. Essentially what goes on here is that SIMD is able to process the Min and Max values 4-8 items per loop iteration. This would theoretically provide a 4-8x speedup depending on your CPU. Using CPUs that support AVX2 provides the fastest performance boost.

Source: http://blogs.microsoft.co.il/sasha/2014/04/22/c-vectorization-microsoft-bcl-simd/

Answer 4

Your code isn't good. If you have points (2, 4) and (3, 1), then xMax will be 3, and yMax will be 4, which isn't one point.