如何在c#中获得多dim数组的最小值和最大值(指定一个dim)

本文关键字：dim 最大值 一个 最小值 数组 | 更新日期: 2023-09-27 18:17:47

我有一个多维数组在c#定义如下:

 double[,,] myArray=new double[10000,10000,3];

我发现这个数组的最大值，当最后一个dim是例如为0。例如:

 double m1=myArray[?,?,0].Max();

我如何使用Linq或其他方法计算它?

如何在c#中获得多dim数组的最小值和最大值(指定一个dim)

如果你想获得数组子集的最大值，你可以这样做:

double m1 = 
    (from x in Enumerable.Range(0, myArray.GetLength(0))
     from y in Enumerable.Range(0, myArray.GetLength(1))
     select myArray[x, y, 0])
    .Max();

如果你想获得数组中所有元素的最大值你可以这样做

double m1 = myArray.Cast<double>().Max();
但是，您可以通过实现自己的扩展方法获得显著的性能提升，如下所示: 
public static IEnumerable<T> Flatten<T>(this T[,,] arry) {
    foreach(T x in arry) yield return item;
}
myArray.Flatten().Max();

EDIT 2

注意，这个扩展同样适用于一个丑陋但有效的非零数组

var nonZeroBasedArray = Array.CreateInstance(
    typeof(double),
    new[] { 4, 4, 3 },
    new[] { -2, -2, 0 });

请注意，前两个维度的范围从-2到1(包括)。这个测试代码说明Flatten扩展仍然有效。

var count = 0;
foreach (var element in nonZeroBasedArray.Flatten<double>(null, null, 0))
{
    Console.Write(string.Join(", ", element.Key));
    Console.WriteLine(": {0}", element.Value);
}
Console.WriteLine("Count: {0}", count);
Console.ReadKey();

编辑

因此，使用下面定义的扩展名，您可以执行 
var myArray = new double[10000,10000,3];
var ordered = myArray.Flatten<double>(null, null, 0).OrderBy(p => p.Value);
var maxZ0 = ordered.First();
var minZ0 = ordered.Last();

元素类型是KeyValuePair<IEnumerable<int>, T>，因此Key允许您反向引用原始数组。

好的，这是一个通用的扩展，最初的灵感来自p.s.w.g的答案

如果您从Eric Lippert的鼓舞人心的CartesianProduct<T>扩展开始，

public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(
        this IEnumerable<IEnumerable<T>> sequences)
{
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
    return sequences.Aggregate(
        emptyProduct,
        (accumulator, sequence) =>
            from accseq in accumulator
            from item in sequence
            select accseq.Concat(new[]
                {
                    item
                }));
}

然后编写一个函数来生成多维数组的绑定集，该函数允许您为某些维度指定固定值。

private static IEnumerable<IEnumerable<int>> GetBoundSequences(
        Array array,
        int?[] definedBounds)
{
    for (var rank = 0; rank < array.Rank; rank++)
    {
        var defined = definedBounds.ElementAtorDefault(rank);
        if (defined.HasValue)
        {
            yield return new[] { defined.Value };
        }
        else
        {
            var min = array.GetLowerBound(rank);
            yield return Enumerable.Range(
                min, 
                (array.GetUpperBound(rank) - min) + 1);
        }
    }
}

您可以使用两者来创建灵活的Flatten<T>扩展，该扩展适用于任何秩的数组。

public static IEnumerable<KeyValuePair<IEnumerable<int>, T>> Flatten<T>(
        this Array array,
        params int?[] definedBounds)
{
    var coordSets = GetBoundSequences(array, definedBounds).CartesianProduct();
    foreach (var coordSet in coordSets)
    {
        var coords = coordSet.ToArray();
        var value = (T)array.GetValue(coords);
        yield return new KeyValuePair<IEnumerable<int>, T>(
            coords,
            value);
    }
}

一旦你有了这个，你可以做一些像

var myArray = new double[10000,10000,3];
var maxZ0 = myArray.Flatten<double>(null, null, 0).Max(p => p.Value);

这很好，因为它只迭代和转换指定的元素。

试试这个

double[,,] myArray = new double[10000, 10000, 3];
double max = myArray.Cast<double>().Max();
相关文章：