Максимални и минимални стойности в масив PointF[].

Трябва да обходите всички елементи в масива и да тествате всеки един спрямо ограничаваща кутия, като увеличавате ограничаващата рамка, когато текущият елемент е извън нея. Като този:

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

РЕДАКТИРАНЕ: Имате правилната идея, но има .Net framework API за извършване на теста за мин./макс.: Math.Min и Math.Max. Освен ако няма друга информация за масива от точки, която може да се използва за намаляване на броя на тестовете, ще трябва да тествате всяка точка в масива. За съжаление там няма преки пътища. Чудя се дали JIT компилаторът е достатъчно умен, за да използва SIMD за това?

Освен това инициализирането със стойност 0 може да причини грешка, ако всички точки в масива са по-малки от нула.

Ако намерите минимума (горната лява точка) и максимума (долната дясна точка), можете да изчислите размера на графиката.

Първо се нуждаете от начин да сравнявате стойностите на Point - ако класът Point (struct?) внедрява IComparable, вече сте готови, в противен случай може да се наложи да напишете персонализиран клас IComparer.

След това можете да напишете прост метод за разширение на IEnumerable, за да получите минималните или максималните стойности от колекция:

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

Използвайки тези методи за разширение, ще бъде много по-лесно да намерите минималните/максималните точки и следователно и размера на графиката.

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

Кодът ви не е добър. Ако имате точки (2, 4) и (3, 1), тогава xMax ще бъде 3, а yMax ще бъде 4, което не е една точка.

Използване на RyuJIT и SIMD, тези операции могат да бъдат значително ускорени.

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

Очевидно заменете масива int с масива PointF. По същество това, което се случва тук, е, че SIMD е в състояние да обработва минималните и максималните стойности 4-8 елемента на итерация на цикъл. Това теоретично би осигурило 4-8x ускорение в зависимост от вашия процесор. Използването на процесори, които поддържат AVX2, осигурява най-бързото повишаване на производителността.

Източник: http://blogs.microsoft.co.il/sasha/2014/04/22/c-vectorization-microsoft-bcl-simd/