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

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

3 个答案: