阵列数据标准化 [英] Array data normalization

问题描述

我有重新present强度（黑到白）值（-1.0到1.0之间）的数组。我需要一种方法来通过1.0至255和背部-1.0双值映射到0。

更广义的，我有一个数据数组，我需要从最小和数据的最大值映射到所提供的最小值和最大值。基本结构应该是这样的：

 私有静态诠释[] NormalizeData（双[]的数据，INT分钟，INT最大值）
{
    VAR分类= data.OrderBy（D = GT; D）;
    双DATAMAX = sorted.First（）;
    双dataMin = sorted.Last（）;
    INT [] = RET新INT [data.Length]    的for（int i = 0; I＆LT; data.Length;我++）
    {
        RET [I] =（int）的数据[I] //这里归
    }    返回RET;
}
 

解决方案

这个作品：

 私有静态诠释[] NormalizeData（IEnumerable的＆LT;双＆GT;的数据，诠释分钟，诠释最大值）
{
    双DATAMAX = data.Max（）;
    双dataMin = data.Min（）;
    双范围=的Datamax  -  dataMin;    返回数据
        。选择（D =＆GT;（四 -  dataMin）/范围）
        。选择（N =＆GT;（INT）（（1  -  N）*分+ N * MAX））
        .ToArray（）;
}
 

第一选择标准化的输入是从0到1（0为最小，1为最大值）。所述第二选择采用该规格化数，并将其映射到新的最小和最大

注意，使用LINQ MIN（）和 MAX（）函数比排序输入更大更快数据集：为O（n）与O（N * LG电子（N））

。

另外，如果你想要去的其他方式，那么你会希望它双打返回，而不是整数。

I have an array of values (between -1.0 and 1.0) that represent intensity (Black to White). I need a way to map the double values from -1.0 through 1.0 to 0 through 255 and back.

More generalized, I have an array of data and I need to map from the min and max value of the data to a supplied min and max. Basic structure should be like:

private static int[] NormalizeData(double[] data, int min, int max)
{
    var sorted = data.OrderBy(d => d);
    double dataMax = sorted.First();
    double dataMin = sorted.Last();
    int[] ret = new int[data.Length];

    for (int i = 0; i < data.Length; i++)
    {
        ret[i] = (int)data[i];  // Normalization here
    }

    return ret;
}

解决方案

This works:

private static int[] NormalizeData(IEnumerable<double> data, int min, int max)
{
    double dataMax = data.Max();
    double dataMin = data.Min();
    double range = dataMax - dataMin;

    return data
        .Select(d => (d - dataMin) / range)
        .Select(n => (int)((1 - n) * min + n * max))
        .ToArray();
}

The first select normalizes the input to be from 0 to 1 (0 being minimum, 1 being the maximum). The second select takes that normalized number, and maps it to the new minimum and maximum.

Note that using the LINQ Min() and Max() functions are faster than sorting the input for larger datasets: O(n) vs. O(n * lg(n)).

Also, if you want to go the other way, then you'll want it to return doubles instead of ints.

这篇关于阵列数据标准化的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！