コード例 #1
0
        public static MetaNum Min(this IList <MetaNum> self)
        {
            if (self.Count == 0)
            {
                return(TypeTrait <MetaNum> .GetNaNOrRaiseException("No elements"));
            }

            var i = 0;

            while (TypeTrait <MetaNum> .IsNaN(self[0]) && i < self.Count - 1)
            {
                ++i;
            }

            MetaNum min = self[i];

            for (++i; i < self.Count; ++i)
            {
                if (self[i] < min)
                {
                    min = self[i];
                }
            }

            return(min);
        }
コード例 #2
0
        public static MetaFloat Correlation(this IList <MetaNum> self, IList <MetaNum> other, bool skipNaN = true)
        {
            if (self.Count != other.Count)
            {
                return(MetaFloat.NaN);
            }

            if (skipNaN)
            {
                var s1 = new List <MetaNum>(self.Count);
                var s2 = new List <MetaNum>(self.Count);

                for (var i = 0; i < self.Count; ++i)
                {
                    if (TypeTrait <MetaNum> .IsNaN(self[i]) || TypeTrait <MetaNum> .IsNaN(other[i]))
                    {
                        continue;
                    }

                    s1.Add(self[i]);
                    s2.Add(other[i]);
                }
                return(Covariance(s1, s2) / s1.StandardDeviation() / s2.StandardDeviation());
            }

            return(Covariance(self, other) / self.StandardDeviation() / other.StandardDeviation());
        }
コード例 #3
0
ファイル: JoinKeyMap.cs プロジェクト: horker/Horker.MXNet
        private Dictionary <Tuple <T1, T2>, int> CollectKeys2 <T1, T2>()
        {
            Debug.Assert(_keyColumns.Length == 2);

            var column1  = _dataMap[_keyColumns[0]].UnderlyingList;
            var column2  = _dataMap[_keyColumns[1]].UnderlyingList;
            var rowCount = _dataMap.MaxRowCount;
            var result   = new Dictionary <Tuple <T1, T2>, int>(rowCount);

            for (var i = 0; i < rowCount; ++i)
            {
                T1 k1 = i >= column1.Count ? TypeTrait <T1> .GetNaN() : (T1)column1[i];

                T2 k2 = i >= column2.Count ? TypeTrait <T2> .GetNaN() : (T2)column2[i];

                var key = Tuple.Create(k1, k2);
                try
                {
                    result.Add(key, i);
                }
                catch (ArgumentException ex)
                {
                    throw new ArgumentException($"Duplicate key values: {key}", ex);
                }
            }

            return(result);
        }
コード例 #4
0
        public static int ArgMin(this IList <MetaNum> self)
        {
            if (self.Count == 0)
            {
                throw new InvalidCastException("No elements");
            }

            var i = 0;

            while (TypeTrait <MetaNum> .IsNaN(self[0]) && i < self.Count)
            {
                ++i;
            }

            if (i == self.Count)
            {
                throw new InvalidCastException("No elements");
            }

            MetaNum min    = self[i];
            int     argmin = i;

            for (++i; i < self.Count; ++i)
            {
                if (self[i] < min)
                {
                    min    = self[i];
                    argmin = i;
                }
            }

            return(argmin);
        }
コード例 #5
0
ファイル: TypeTraitTest.cs プロジェクト: horker/Horker.MXNet
 public void TestStringIsNaN()
 {
     Assert.False(TypeTrait <string> .IsNaN(" xxx "));
     Assert.True(TypeTrait <string> .IsNaN(null));
     Assert.True(TypeTrait <string> .IsNaN(string.Empty));
     Assert.True(TypeTrait <string> .IsNaN(""));
     Assert.True(TypeTrait <string> .IsNaN("\t "));
 }
コード例 #6
0
 public static void FillNaNFill(this IList <MetaNum> self, MetaNum fillValue)
 {
     for (var i = 0; i < self.Count; ++i)
     {
         if (TypeTrait <MetaNum> .IsNaN(self[i]))
         {
             self[i] = fillValue;
         }
     }
 }
コード例 #7
0
 public static void FillNaNFill <T>(this IList <T> self, T fillValue)
 {
     for (var i = 0; i < self.Count; ++i)
     {
         if (TypeTrait <T> .IsNaN(self[i]))
         {
             self[i] = fillValue;
         }
     }
 }
コード例 #8
0
        public static IList <bool> IsNaN <T>(this IList <T> self)
        {
            var result = new List <bool>(self.Count);

            foreach (var item in self)
            {
                result.Add(TypeTrait <T> .IsNaN(item));
            }

            return(result);
        }
コード例 #9
0
        public static DataMap FromJagged <T>(T[][] source, string[] columnNames = null, bool transpose = false, IEqualityComparer <string> keyComparaer = null)
        {
            var result = new DataMap(keyComparaer);

            if (!transpose)
            {
                if (columnNames == null)
                {
                    var c = source[0].Length;
                    columnNames = new string[c];
                    for (var i = 0; i < c; ++i)
                    {
                        columnNames[i] = "Column" + i;
                    }
                }

                for (var i = 0; i < columnNames.Length; ++i)
                {
                    var data = new List <T>(source.Length);
                    result.Add(columnNames[i], data);
                    for (var j = 0; j < source.Length; ++j)
                    {
                        var row = source[j];
                        if (i < row.Length)
                        {
                            data.Add(row[i]);
                        }
                        else
                        {
                            data.Add(TypeTrait <T> .GetNaN());
                        }
                    }
                }
            }
            else
            {
                if (columnNames == null)
                {
                    var c = source.Length;
                    columnNames = new string[c];
                    for (var i = 0; i < c; ++i)
                    {
                        columnNames[i] = "Column" + i;
                    }
                }

                for (var i = 0; i < columnNames.Length; ++i)
                {
                    result.Add(columnNames[i], source[i]);
                }
            }

            return(result);
        }
コード例 #10
0
        public static int CountNaN(this IList <MetaNum> self)
        {
            int count = 0;

            foreach (var value in self)
            {
                if (TypeTrait <MetaNum> .IsNaN(value))
                {
                    ++count;
                }
            }

            return(count);
        }
コード例 #11
0
        public static List <MetaNum> RemoveNaN(this IList <MetaNum> self)
        {
            var result = new List <MetaNum>(self.Count);

            foreach (var value in self)
            {
                if (!TypeTrait <MetaNum> .IsNaN(value))
                {
                    result.Add(value);
                }
            }

            return(result);
        }
コード例 #12
0
        public static MetaNum Mode(this IList <MetaNum> self, bool skipNaN = true)
        {
            if (self.Count == 0)
            {
                return(TypeTrait <MetaNum> .GetNaNOrRaiseException("No elements"));
            }

            var values = self.ToArray();

            Array.Sort(values);

            MetaNum currentValue = values[0];
            MetaNum bestValue    = currentValue;
            var     currentCount = 1;
            var     bestCount    = 1;

            int i = 1;

            if (skipNaN)
            {
                // After sort, NaNs should be collected to the first location of the sequence.
                while (TypeTrait <MetaNum> .IsNaN(values[i]))
                {
                    ++i;
                }
            }

            for (; i < values.Length; ++i)
            {
                if (currentValue == values[i])
                {
                    currentCount += 1;
                }
                else
                {
                    currentValue = values[i];
                    currentCount = 1;
                }

                if (currentCount > bestCount)
                {
                    bestCount = currentCount;
                    bestValue = currentValue;
                }
            }

            return(bestValue);
        }
コード例 #13
0
        public double getRadiusRulesInsideCircleZodiac(TypeTrait typeTrait)
        {
            double divTrait = 0.0;

            switch (typeTrait)
            {
            case TypeTrait.Petit:
                divTrait = 1.0 + DIVTRAITPETIT;
                break;

            case TypeTrait.Grand:
                divTrait = 1.0 + DIVTRAITGRAND;
                break;
            }
            return((getRadiusTotal() * (((CIRCLE1 - CIRCLE0) / divTrait) + CIRCLE0)) / 100); // - CIRCLE1
        }
コード例 #14
0
        public static MetaFloat Covariance(this IList <MetaNum> self, IList <MetaNum> other, bool unbiased = true, bool skipNaN = true)
        {
            if (self.Count != other.Count)
            {
                return(MetaFloat.NaN);
            }

            var mean0 = self.Mean(skipNaN);
            var mean1 = other.Mean(skipNaN);

            if (MetaFloat.IsNaN(mean0) || MetaFloat.IsNaN(mean1))
            {
                return(MetaFloat.NaN);
            }

            int actualCount = self.Count;

            MetaFloat c = (MetaFloat)0.0;

            for (int i = 0; i < self.Count; ++i)
            {
                if (TypeTrait <MetaNum> .IsNaN(self[i]) || TypeTrait <MetaNum> .IsNaN(other[i]))
                {
                    if (skipNaN)
                    {
                        --actualCount;
                        continue;
                    }
                    else
                    {
                        return(MetaFloat.NaN);
                    }
                }
                var a = (MetaFloat)self[i] - mean0;
                var b = (MetaFloat)other[i] - mean1;
                c += a * b;
            }

            if (unbiased)
            {
                return(c / (actualCount - 1));
            }
            else
            {
                return(c / actualCount);
            }
        }
コード例 #15
0
        public static MetaFloat Variance(this IList <MetaNum> self, bool unbiased = true, bool skipNaN = true)
        {
            if (self.Count == 0)
            {
                return(MetaFloat.NaN);
            }

            MetaFloat mean = Mean(self, skipNaN);

            if (MetaFloat.IsNaN(mean))
            {
                return(MetaFloat.NaN);
            }

            MetaFloat variance    = (MetaFloat)0.0;
            int       actualCount = self.Count;

            foreach (var value in self)
            {
                MetaFloat v = (MetaFloat)value;
                if (TypeTrait <MetaFloat> .IsNaN(v))
                {
                    if (skipNaN)
                    {
                        --actualCount;
                        continue;
                    }
                    else
                    {
                        return(MetaFloat.NaN);
                    }
                }

                MetaFloat x = v - mean;
                variance += x * x;
            }

            if (unbiased)
            {
                return(variance / (actualCount - 1));
            }
            else
            {
                return(variance / actualCount);
            }
        }
コード例 #16
0
ファイル: JoinKeyMap.cs プロジェクト: horker/Horker.MXNet
        private Dictionary <T1, int> CollectKeys1 <T1>()
        {
            Debug.Assert(_keyColumns.Length == 1);

            var column1  = _dataMap[_keyColumns[0]].UnderlyingList;
            var rowCount = _dataMap.MaxRowCount;
            var result   = new Dictionary <T1, int>(rowCount);

            for (var i = 0; i < rowCount; ++i)
            {
                T1 k1 = i >= column1.Count ? TypeTrait <T1> .GetNaN() : (T1)column1[i];

                result.Add(k1, i);
            }

            return(result);
        }
コード例 #17
0
        public static List <MetaNum> FillNaN(this IList <MetaNum> self, MetaNum fillValue)
        {
            var result = new List <MetaNum>(self.Count);

            foreach (var value in self)
            {
                if (TypeTrait <MetaNum> .IsNaN(value))
                {
                    result.Add(fillValue);
                }
                else
                {
                    result.Add(value);
                }
            }

            return(result);
        }
コード例 #18
0
        // Histogram

        private static Tuple <int[], int> CollectHistogram(IList <MetaNum> data, HistogramInterval intervals)
        {
            var result = new int[intervals.BinCount];
            var total  = 0;

            foreach (var value in data)
            {
                if (TypeTrait <MetaNum> .IsNaN(value))
                {
                    continue;
                }

                var bin = (int)Math.Floor(((double)value - intervals.AdjustedLower) / intervals.BinWidth);
                ++result[bin];
                ++total;
            }

            return(Tuple.Create(result, total));
        }
コード例 #19
0
ファイル: JoinKeyMap.cs プロジェクト: horker/Horker.MXNet
        private Dictionary <Tuple <T1, T2, T3, T4, T5, T6>, int> CollectKeys6 <T1, T2, T3, T4, T5, T6>()
        {
            Debug.Assert(_keyColumns.Length == 6);

            var column1  = _dataMap[_keyColumns[0]].UnderlyingList;
            var column2  = _dataMap[_keyColumns[1]].UnderlyingList;
            var column3  = _dataMap[_keyColumns[2]].UnderlyingList;
            var column4  = _dataMap[_keyColumns[3]].UnderlyingList;
            var column5  = _dataMap[_keyColumns[4]].UnderlyingList;
            var column6  = _dataMap[_keyColumns[5]].UnderlyingList;
            var rowCount = _dataMap.MaxRowCount;
            var result   = new Dictionary <Tuple <T1, T2, T3, T4, T5, T6>, int>(rowCount);

            for (var i = 0; i < rowCount; ++i)
            {
                T1 k1 = i >= column1.Count ? TypeTrait <T1> .GetNaN() : (T1)column1[i];

                T2 k2 = i >= column2.Count ? TypeTrait <T2> .GetNaN() : (T2)column2[i];

                T3 k3 = i >= column3.Count ? TypeTrait <T3> .GetNaN() : (T3)column3[i];

                T4 k4 = i >= column4.Count ? TypeTrait <T4> .GetNaN() : (T4)column4[i];

                T5 k5 = i >= column5.Count ? TypeTrait <T5> .GetNaN() : (T5)column5[i];

                T6 k6 = i >= column6.Count ? TypeTrait <T6> .GetNaN() : (T6)column6[i];

                var key = Tuple.Create(k1, k2, k3, k4, k5, k6);
                try
                {
                    result.Add(key, i);
                }
                catch (ArgumentException ex)
                {
                    throw new ArgumentException($"Duplicate key values: {key}", ex);
                }
            }

            return(result);
        }
コード例 #20
0
        public static MetaNum Sum(this IList <MetaNum> self, bool skipNaN = true, int minCount = 0)
        {
            MetaNum sum   = (MetaNum)0.0;
            int     count = 0;

            foreach (var value in self)
            {
                if (skipNaN && TypeTrait <MetaNum> .IsNaN(value))
                {
                    continue;
                }
                sum += value;
                ++count;
            }

            if (count < minCount)
            {
                return(TypeTrait <MetaNum> .GetNaN());
            }

            return(sum);
        }
コード例 #21
0
        public static MetaNum Product(this IList <MetaNum> self, bool skipNaN = true, int minCount = 0)
        {
            MetaNum product = (MetaNum)1;
            int     count   = 0;

            foreach (var value in self)
            {
                if (skipNaN && TypeTrait <MetaNum> .IsNaN(value))
                {
                    continue;
                }
                product *= value;
                ++count;
            }

            if (count < minCount)
            {
                return(TypeTrait <MetaNum> .GetNaN());
            }

            return(product);
        }
コード例 #22
0
        public override DataMap TransformToDataMap(SeriesBase data)
        {
            var listMap = new Dictionary <string, T[]>();
            var size    = data.Count;

            string firstKey = null;

            foreach (DictionaryEntry entry in _encoding)
            {
                if (firstKey == null && _oneHotType != OneHotType.OneHot)
                {
                    firstKey = entry.Key as string;
                    continue;
                }

                listMap[entry.Key as string] = new T[size];
            }

            int i = 0;

            switch (_oneHotType)
            {
            case OneHotType.OneHot:
                foreach (var e in data)
                {
                    var name = e.ToString();
                    if (listMap.TryGetValue(name, out var list))
                    {
                        list[i] = TypeTrait <T> .GetOne();
                    }
                    ++i;
                }
                break;

            case OneHotType.DropFirst:
                foreach (var e in data)
                {
                    var name = e.ToString();
                    if (name != firstKey && listMap.TryGetValue(name, out var list))
                    {
                        list[i] = TypeTrait <T> .GetOne();
                    }
                    ++i;
                }
                break;

            case OneHotType.EffectCoding:
                foreach (var e in data)
                {
                    var name = e.ToString();
                    if (name != firstKey)
                    {
                        if (listMap.TryGetValue(name, out var list))
                        {
                            list[i] = TypeTrait <T> .GetOne();
                        }
                    }
                    else
                    {
                        foreach (var entry in listMap)
                        {
                            entry.Value[i] = TypeTrait <T> .GetOne();
                        }
                    }
                    ++i;
                }
                break;
            }

            var result = new DataMap();
            var keys   = listMap.Keys.ToArray();

            Array.Sort(keys);
            foreach (var k in keys)
            {
                var columnName = string.Format(_columnNameFormat, k);
                result[columnName] = listMap[k];
            }

            return(result);
        }
コード例 #23
0
ファイル: TypeTraitTest.cs プロジェクト: horker/Horker.MXNet
 public void TestDoubleIsNaN()
 {
     Assert.True(TypeTrait <double> .IsNaN(double.NaN));
     Assert.False(TypeTrait <double> .IsNaN(10.2));
 }
コード例 #24
0
ファイル: TypeTraitTest.cs プロジェクト: horker/Horker.MXNet
 public void TestDateTimeIsNaN()
 {
     Assert.False(TypeTrait <DateTime> .IsNaN(DateTime.Now));
 }