Example #1
0
 public TableRenderer(string title, Tuple<string, int>[] headers)
 {
     _title = title;
     _headers = headers;
     _totalWidth = _headers.Sum(h => h.Item2) + (_headers.Count() - 1) * 3;
     _rowTemplate = "| " + String.Join(" | ", _headers.Select((h, i) => "{" + i + ",-" + h.Item2 + "}").ToArray()) + " |";
 }
Example #2
0
 public void ShortSumOnTwoTuple()
 {
     var sut = new Tuple<short, short>(1, 2);
       short expected = sut.AsEnumerable().Cast<short>().Sum();
       short actual = sut.Sum(x => (short) x);
       Assert.AreEqual(expected, actual);
 }
Example #3
0
 public void DoubleSumOnTwoTuple()
 {
     var sut = new Tuple<double, double>(1, 2);
       double expected = sut.AsEnumerable().Cast<double>().Sum();
       double actual = sut.Sum(x => (double) x);
       Assert.AreEqual(expected, actual);
 }
Example #4
0
 public void IntegerSumOnTwoTuple()
 {
     var sut = new Tuple<int, int>(1, 2);
       int expected = sut.AsEnumerable().Cast<int>().Sum();
       int actual = sut.Sum(x => (int) x);
       Assert.AreEqual(expected, actual);
 }
Example #5
0
 public void LongSumOnTwoTuple()
 {
     var sut = new Tuple<long, long>(1, 2);
       long expected = sut.AsEnumerable().Cast<long>().Sum();
       long actual = sut.Sum(x => (long) x);
       Assert.AreEqual(expected, actual);
 }
Example #6
0
 public void DecimalSumOnTwoTuple()
 {
     var sut = new Tuple<decimal, decimal>(1, 2);
       decimal expected = sut.AsEnumerable().Cast<decimal>().Sum();
       decimal actual = sut.Sum(x => (decimal) x);
       Assert.AreEqual(expected, actual);
 }
        private int InsertGuids(Tuple<Position, int>[] selections)
        {
            var sumChanges = selections.Sum(x =>
            {
                scintilla.DeleteRange(x.Item1, x.Item2);
                scintilla.InsertText(x.Item1, Guid.NewGuid().ToString());

                return GuidHelperConstants.Regexlength - x.Item2;
            });
            return sumChanges;
        }
Example #8
0
            /// <summary>
            /// This tacks on from-to percent
            /// </summary>
            private static Tuple<FlagColorCategory[], int, double, double>[] BuildMaxPerFlag(Tuple<FlagColorCategory[], int>[] groups)
            {
                double sumEnumValues = groups.Sum(o => o.Item1.Length);

                double sumPercent = 0;
                var retVal = new Tuple<FlagColorCategory[], int, double, double>[groups.Length];
                for (int cntr = 0; cntr < retVal.Length; cntr++)
                {
                    double percent = groups[cntr].Item1.Length / sumEnumValues;

                    retVal[cntr] = Tuple.Create(groups[cntr].Item1, groups[cntr].Item2, sumPercent, sumPercent + percent);

                    sumPercent += percent;
                }

                return retVal;
            }
Example #9
0
        public static double Avg(Tuple<double, double>[] weightedValues)
        {
            if (weightedValues == null || weightedValues.Length == 0)
            {
                return 0;
            }

            double totalWeight = weightedValues.Sum(o => o.Item2);
            if (Math1D.IsNearZero(totalWeight))
            {
                return weightedValues.Average(o => o.Item1);
            }

            double sum = weightedValues.Sum(o => o.Item1 * o.Item2);

            return sum / totalWeight;
        }