如何在c＃中获得多暗调阵列的最小值和最大值（指定了一个暗淡）

Question

我有一个多维数组，C＃定义如下：

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

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

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

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

Answer 1

如果你想在阵列的某个子集中获得最大值，你可以这样做：

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();

Answer 2

编辑2

请注意，此扩展同样适用于基于非零的数组的可怕但有效的情况

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

请注意，前两个维度的范围从-2到1（yikes）。此测试代码说明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's answer

的启发

如果您从Eric Lippert's inspirational CartesianProduct<T> extension开始，

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

这很好，因为它懒惰地迭代并只转换指定的元素。

Answer 3

试试这个

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

double max = myArray.Cast<double>().Max();