Пример #1
0
        public void Report(IEnumerable<SuiteRunResult> executed)
        {
            var totalPasses = executed.Sum(x => x.Passes);
            var totalFailures = executed.Sum(x => x.Failures);
            var total = totalPasses + totalFailures;

            _output.WriteLine("Loaded: {0}".FormatWith(executed.Select(s => s.Name).Join(", ")));
            _output.WriteLine("  {0} {1} loaded.".FormatWith(
                total,
                "test".Pluralize(total)));
            _output.WriteLine("  {0}/{1} {2} passed ({3} {4}).".FormatWith(
                totalPasses,
                total,
                "test".Pluralize(total),
                totalFailures,
                "failure".Pluralize(totalFailures)));

            if (totalFailures > 0)
                _output.WriteLine("Failures: ");
            executed.Each(suiteResult => suiteResult
                .Results
                .Where(containerResult => containerResult.Results.Any(r => !r.Pass))
                .Each(f =>
                {
                    _output.WriteLine("  {0}.{1} contained {2} failures.".FormatWith(suiteResult.Name, f.Name, f.Failures));
                    f.Results.Where(r => !r.Pass).Each(r => _output.WriteLine("    {0} failed. [{1}]".FormatWith(r.Name, r.Message)));
                }));

            _output.Flush();
        }
Пример #2
0
 public Run(IEnumerable<Assembly> assemblies) : base(assemblies.Cast<SpecificationContainer>())
 {
   _assemblies = assemblies;
   _totalAssemblies = assemblies.Count();
   _totalConcerns = assemblies.Sum(x => x.TotalConcerns);
   _totalContexts = assemblies.Sum(x => x.TotalContexts);
 }
 protected SpecificationContainer(IEnumerable<SpecificationContainer> specificationContainers)
 {
   _totalSpecifications = specificationContainers.Sum(x => x.TotalSpecifications);
   _passingSpecifications = specificationContainers.Sum(x => x.PassingSpecifications);
   _failingSpecifications = specificationContainers.Sum(x => x.FailingSpecifications);
   _notImplementedSpecifications = specificationContainers.Sum(x => x.NotImplementedSpecifications);
 }
Пример #4
0
        public static double Pearson(IEnumerable<long> v1, IEnumerable<long> v2)
        {
            var sum1 = v1.Sum();
            var sum2 = v2.Sum();

            // Sum of the squares
            var sum1Sq = v1.Sum(v => m.Pow(v, 2));
            var sum2Sq = v2.Sum(v => m.Pow(v, 2));

            // Sum of the products
            var l1 = v1.ToArray();
            var l2 = v2.ToArray();

            if (l1.Length != l2.Length)
                throw new ApplicationException("Input data should contain the equal number of items");

            long pSum = Enumerable.Range(0, l1.Length)
                .Select(i => l1[i] * l2[i])
                .Sum();

            // Calculate r (Pearson score)
            var num = pSum - (sum1 * sum2 / l1.Length);
            var den =
                m.Sqrt((sum1Sq - m.Pow(sum1, 2)/l1.Length)*(sum2Sq - m.Pow(sum2, 2)/l2.Length));

            if (den == 0)
                return 0;

            return 1.0 - num /den;
        }
Пример #5
0
 public RiskResult(IEnumerable<StationPath> path, double radius)
 {
     Radius = radius;
     Path = path;
     TotalRisk = path.Sum(x => x.Risk);
     TotalDistance = path.Sum(x => x.Distance);
     TotalDistanceRatio = TotalDistance / (Math.PI * radius);
 }
Пример #6
0
 public Run(IEnumerable<Assembly> assemblies) : base(assemblies.Cast<SpecificationContainer>())
 {
   Meta = new Meta { GeneratedAt = DateTime.Now };
   _assemblies = assemblies.OrderBy(x => x.Name);
   _totalAssemblies = assemblies.Count();
   _totalConcerns = assemblies.Sum(x => x.TotalConcerns);
   _totalContexts = assemblies.Sum(x => x.TotalContexts);
 }
Пример #7
0
        private static CieLabColor getAverageColor(IEnumerable<CieLabColor> colors)
        {
            double colorCount = colors.Count();
            double l = colors.Sum(color => color.L) / colorCount;
            double a = colors.Sum(color => color.A) / colorCount;
            double b = colors.Sum(color => color.B) / colorCount;

            return new CieLabColor((float)l, (float)a, (float)b);
        }
Пример #8
0
        public double WeightingDensity(IEnumerable<MaterialDensityCalculationItem> items)
        {
            //错误输入验证代码后续

            double[] tmpValue = new double[items.Count()];
            double sum = items.Sum(i => i.MoleWeight * i.At);
            double weightingDensity = items.Sum(i => i.At * i.MoleWeight / sum * i.Density);

            return weightingDensity;
        }
Пример #9
0
        /// <summary>
        /// Gets the slope for a set of points using the formula:
        /// m = SUM(x-AVG(x)(y-AVG(y)) / SUM(x-AVG(x))^2
        /// </summary>
        /// <param name="points">Points to calculate the Slope from</param>
        /// <returns>SlopeOfPoints</returns>
        private static float SlopeOfPoints(IEnumerable<PointF> points)
        {
            float avgX = points.Average(p => p.X);
            float avgY = points.Average(p => p.Y);

            float dividend = points.Sum(p => (p.X - avgX) * (p.Y - avgY));
            float divisor = (float)points.Sum(p => Math.Pow(p.X - avgX, 2));

            return dividend / divisor;
        }
Пример #10
0
        public BenchmarkResultList(IEnumerable<BenchmarkResult> results)
        {
            _results = results.ToArray();

            var totalTicks = _results.Sum(r => r.Time.Ticks);
            _totalTime = TimeSpan.FromTicks(totalTicks);
            _totalIterations = _results.Sum(r => r.Iterations);

            if (_totalIterations > 0)
                _average = TimeSpan.FromTicks(totalTicks/_totalIterations);
        }
Пример #11
0
        public Order(IEnumerable<Outcome> outcomes, List<OrderLine> orderLines)
            : this()
        {
            Lines = orderLines;
            orderLines.ForEach(ol => ol.Order = this);

            Summ = outcomes.Sum(o => o.Summ);
            SummWithDiscount = outcomes.Sum(o => o.SummWithDiscount);
            Profit = outcomes.Sum(o => o.Profit);
            DiscountSumm = outcomes.Sum(o => o.DiscountSumm);
        }
        public CardStatsByRarity(string rarity, IEnumerable<CardInCollection> cards)
        {
            Rarity = rarity;
            TotalAmount = cards.Select(c => c.MaxAmountInCollection)
                .Sum();
            PlayerHas = cards.Sum(c => c.AmountNonGolden);
            PlayerHasGolden = cards.Sum(c => c.AmountGolden);

            OpenGoldenOdds = CalculateOpeningOdds(cards, card => card.MaxAmountInCollection - card.AmountGolden, GoldenCardProbabilities);
            OpenNonGoldenOdds = CalculateOpeningOdds(cards, card => card.MaxAmountInCollection - card.AmountNonGolden, CardProbabilities);
        }
Пример #13
0
        static void DownloadArtwork(IEnumerable<Series> series)
        {
            var start = DateTime.Now;
            Total = series.Sum(e => e.ArtWorks.Count);
            Console.WriteLine("{0}: Downloading {1} Artwork files.", DateTime.Now, Total);

            var downloader = new FileDownloader();
            downloader.DownloadProgressNotification += DownloaderOnDownloadProgressNotification;

            foreach (var s in series)
            {
                foreach (var artwork in s.ArtWorks)
                {
                    var localPath = Path.Combine(s.SeriesId.ToString(), Path.GetFileName(artwork.Url.ToString()));
                    downloader.AddDownload(artwork.Url, new FileInfo(Path.Combine(Path.GetDirectoryName(localPath), artwork.Id.ToString() + Path.GetExtension(localPath))), artwork.Id);
                }
            }

            while (!downloader.IsIdle)
            {
                Thread.Sleep(1000);
            }

            Console.WriteLine("{0}: Finished. Took: {1} seconds.", DateTime.Now, Math.Round((DateTime.Now - start).TotalSeconds, 0));
        }
Пример #14
0
        public void SutEvaluatesAsSumOfInputs(IEnumerable<double> inputs, DoubleSumFunction sut)
        {
            var result = sut.Evaluate(inputs);

            var expected = inputs.Sum();
            Assert.Equal<double>(expected, result);
        }
Пример #15
0
 public static double GetComboDamage(
     this AIHeroClient source,
     Obj_AI_Base target,
     IEnumerable<Tuple<SpellSlot, int>> spellCombo)
 {
     return spellCombo.Sum(spell => source.GetSpellDamage(target, spell.Item1));
 }
        public static double CalculateSRM(IEnumerable<RecipeFermentable> fermentables, double batchSize)
        {
            //Morey SRM approximation
            var maltColorUnits = fermentables.Sum(f => (double)(f.Base.DegreesLovibond*f.Amount)) / batchSize;

            return 1.4922 * Math.Pow(maltColorUnits, 0.6859);
        }
Пример #17
0
        public Decimal CalculatePrice(IEnumerable<PotterBook> products)
        {
            Decimal summaryPrice;
            var bookCount = products.Count();
            summaryPrice = products.Sum(x => x.Price);
            switch (bookCount)
            {
                case 2:
                    summaryPrice = summaryPrice * 0.95m;
                    break;
                case 3:
                    summaryPrice = summaryPrice * 0.9m;
                    break;
                case 4:
                    summaryPrice = summaryPrice * 0.8m;
                    break;
                case 5:
                    summaryPrice = summaryPrice * 0.75m;
                    break;
                case 1:
                default:
                    break;
            }

            return summaryPrice;
        }
Пример #18
0
        public async Task Synchronize(IEnumerable<FileInfoCopyCommand> filesToSynchronize, Repository source, Repository target)
        {
            if (target.Accessor.IsReadOnly)
                throw new InvalidOperationException("Target repository is read only.");

            long totalSize = filesToSynchronize.Sum(f => f.Source.Size);
            long copiedSize = 0;

            foreach (var item in filesToSynchronize)
            {
                ts.TraceInformation("[{0}%]Updating {1} ({2}) #{3}...", 
                    100 * copiedSize / totalSize,
                    System.IO.Path.GetFileName(item.Source.FileName),
                    FileHelper.ResolveFriendlySize(item.Source.Size),
                    item.Source.Hash.ToString().Substring(0, 6)
                    );

                copiedSize += item.Source.Size;

                var targets = item.Targets.ToArray();
                using (var stream = await source.Accessor.ReadFileAsStream(item.Source))
                {
                    await target.Accessor.WriteFromStream(stream, targets);
                }
            }

            // synchronize properties
            target.Files = source.Files;
            target.UrlName = source.UrlName;
            target.Settings = source.Settings;

            ts.TraceInformation("[100%] Completed!");
        }
Пример #19
0
 public static CompareSummary Map(IEnumerable<CommonGames> games, string label)
 {
     var total = games.Count();
     var wins = games.Count(a => a.Player1.currentgs > a.Player2.currentgs);
     var ties = games.Count(a => a.Player1.currentgs == a.Player2.currentgs);
     var loses = total - wins - ties;
     return new CompareSummary
     {
         Label = label,
         Wins = wins,
         Ties = ties,
         Loses = loses,
         Tag1Score = games.Sum(a => a.Player1.currentgs),
         Tag2Score = games.Sum(a => a.Player2.currentgs)
     };
 }
Пример #20
0
 public Assembly(string name, IEnumerable<Concern> concerns) : base(concerns.Cast<SpecificationContainer>())
 {
   _name = name;
   _concerns = concerns.OrderBy(x => x.Name).ToList();
   _totalConerns = concerns.Count();
   _totalContexts = concerns.Sum(x => x.TotalContexts);
 }
Пример #21
0
 public InterfaceDefinitionsGenerator(IEnumerable<TypeScriptModule> modules, GeneratorOptions options)
 {
     _modules = modules;
       _sb = new IndentedStringBuilder(modules.Sum(m => m.ModuleMembers.Count) * 256, options.CodeGenerationOptions.IndentationCharacter, options.CodeGenerationOptions.IndentationIncrementAmount);
       _options = options;
       _propertyCommenter = new PropertyCommenter(options);
 }
Пример #22
0
        public void BindToStats(IEnumerable<WarcraftRaceRecord> raceRecords)
        {
            foreach (var record in raceRecords)
            {
                Row row = rowMap[record.Race];
                row.Win.Text = record.Wins.ToString(CultureInfo.CurrentCulture);
                row.Loss.Text = record.Losses.ToString(CultureInfo.CurrentCulture);
                double percent = record.Wins * 100.0 / (double)(record.Wins + record.Losses);
                row.Percent.Text = string.Format(CultureInfo.CurrentCulture, "{0:F}%", percent);
            }

            totalsRow.Win.Text = raceRecords.Sum(r => r.Wins).ToString(CultureInfo.CurrentCulture);
            totalsRow.Loss.Text = raceRecords.Sum(r => r.Losses).ToString(CultureInfo.CurrentCulture);
            totalsRow.Percent.Text = string.Format(CultureInfo.CurrentCulture, "{0:F}%",
                (double)raceRecords.Sum(r => r.Wins * 100.0) / (double)(raceRecords.Sum(r => r.Wins + r.Losses)));
        }
        /// <summary>
        /// Calculates the harmonic mean of the given numbers.
        /// The harmonic mean is defined as zero if at least one of the numbers is zero.
        /// </summary>
        /// <param name="numbers">The numbers whose harmonic mean is to be calculated.</param>
        /// <returns>The harmonic mean of the given numbers.</returns>
        /// <exception cref="System.InvalidOperationException">
        /// The specified collection must not contain negative numbers and must not be empty.
        /// </exception>
        /// <exception cref="System.ArgumentNullException">
        /// The specified collection must not be null.
        /// </exception>
        public static double HarmonicMean(IEnumerable<double> numbers)
        {
            if (numbers == null)
            {
                throw ArgumentNullException;
            }

            if (!numbers.Any())
            {
                throw EmptyNumbersCollectionException;
            }

            if (numbers.Any(number => number < 0))
            {
                throw CollectionContainingNegativeNumbersException;
            }

            if (numbers.Contains(0))
            {
                // If one of the values strives against zero the limiting value of the harmonic mean does, too.
                // Therefore, it is sensible to define the harmonic mean as being zero if at least one of the values is zero.
                return 0;
            }

            double sumOfReciprocalValues = numbers.Sum(number => 1.0 / number);
            double harmonicMean = numbers.Count() / sumOfReciprocalValues;

            return harmonicMean;
        }
Пример #24
0
        public void Initialize(Microsoft.Xna.Framework.Game game, Color color, IEnumerable<IEnumerable<Vector3>> verticeLists, IEnumerable<IEnumerable<Triangle<byte>>> triangleLists)
        {
            int listCount = verticeLists.Count();
            var vertCount = verticeLists.Sum(l => l.Count());
            var triCount = triangleLists.Sum(l => l.Count());
            var verts = new Vector3[vertCount];
            var tris = new Triangle<uint>[triCount];
            int c = 0;
            int tc = 0;
            for (int i = 0; i < listCount; i++)
            {
                var vertList = verticeLists.ElementAt(i);
                var triList = triangleLists.ElementAt(i);
                var vertOffset = (uint)c;

                foreach (var vert in vertList)
                    verts[c++] = vert;

                foreach (var tri in triList)
                {
                    tris[tc++] = new Triangle<uint>(tri.Type, tri.V0 + vertOffset, tri.V1 + vertOffset, tri.V2 + vertOffset);
                }
            }
            Initialize(game, color, verts, tris);
        }
Пример #25
0
        public ImagesUploadViewModel(FileContext context, string path, IEnumerable<FileInfo> files, Action finished)
        {
            _context = context;

            _path = path;

            _finished = finished;

            _items = new ObservableCollection<ImageUploadModel>(files.Select(file => new ImageUploadModel(file)));

            _totalSize = files.Sum(file => file.Length);

            _removeCommand = new DelegateCommand<ImageUploadModel>(Remove);

            _window = new ImagesUploadWindow();

            _window.DataContext = this;

            _window.Loaded += ImagesUploadWindow_Loaded;

            _window.Closed += Window_Closed;

            _window.Closing += Window_Closing;

            _window.Show();
        }
Пример #26
0
        /// <summary>
        /// Creates a new instance of ArrangementComparer.
        /// </summary>
        public ArrangementComparer(IEnumerable<int> concealedTiles, int meldCount)
        {
            Validate.InRange(meldCount, 0, 4, nameof(meldCount));

              // All melds count as 3 tiles for determining worse arrangements.
              _tileCount = concealedTiles.Sum() + meldCount * 3;
        }
        private static double CalculateTotalPrice(IEnumerable<HarryPotter> books)
        {
            var total = (double)books.Sum(x => x.Price);
            switch (books.Count())
            {
                case 1:
                    total *= 1;
                    break;
                case 2:
                    total *= 0.95;
                    break;
                case 3:
                    total *= 0.9;
                    break;
                case 4:
                    total *= 0.8;
                    break;
                case 5:
                    total *= 0.75;
                    break;
                default:
                    throw new NotImplementedException();
            }

            return total;
        }
Пример #28
0
        public override SqlQuery Combine(IEnumerable<SqlQuery> sqlQueries)
        {
            if (sqlQueries == null)
            {
                throw new ArgumentNullException("sqlQueries");
            }

            int argumentsCount = 0;
            var sqlBuilder = new StringBuilder(sqlQueries.Sum(s => s.CommandText.Length));

            foreach (var sqlQuery in sqlQueries)
            {
                argumentsCount += sqlQuery.Arguments.Count;

                if (sqlBuilder.Length == 0)
                {
                    sqlBuilder.Append(sqlQuery.CommandText).AppendLine(this.StatementSeparator);
                }
                else
                {
                    var commandText = sqlQuery.CommandText.StartsWith("EXEC", StringComparison.OrdinalIgnoreCase)
                        ? sqlQuery.CommandText
                        : SqlUtility.RenumberParameters(sqlQuery.CommandText, argumentsCount);

                    sqlBuilder.Append(commandText).AppendLine(this.StatementSeparator);
                }
            }

            var combinedQuery = new SqlQuery(sqlBuilder.ToString(0, sqlBuilder.Length - 3), sqlQueries.SelectMany(s => s.Arguments).ToArray());
            combinedQuery.Timeout = sqlQueries.Max(s => s.Timeout);

            return combinedQuery;
        }
Пример #29
0
        public double GetAverage(IEnumerable<XElement> set)
        {
            double sum = set.Sum(item => Convert.ToDouble(item.Value));
            double avg = sum / Enumerable.Count(set);

            return avg;
        }
        private decimal FinishDistribution(decimal total, IEnumerable<decimal> distributed)
        {
            decimal rounded = Round(total - distributed.Sum());
            decimal sum = distributed.Sum();

            if (PreventOverflow == false || sum + rounded <= total)
                return rounded;
            else
            {
                decimal step = FinishStep;

                decimal difference = rounded + sum - total;
                decimal overLimit = Math.Ceiling(difference / step) * step;
                return rounded - overLimit;
            }
        }
Пример #31
0
        public decimal CalculatePrice(Currency currency, IEnumerable <Equipment> equipments = null, Rims rims = null, Varnish varnish = null, int?enginePower = null)
        {
            var equipmentPrice    = equipments?.Sum(_ => currency == Currency.Euro ? _.PriceEuro : _.PricePound) ?? decimal.Zero;
            var rimsesPrice       = (currency == Currency.Euro ? rims?.PriceEuro : rims?.PricePound) ?? decimal.Zero;
            var varnishesPrice    = (currency == Currency.Euro ? varnish?.PriceEuro : varnish?.PricePound) ?? decimal.Zero;
            var engingePowerPrice = (enginePower ?? 0) * (currency == Currency.Euro ? 5 : 4);

            return(equipmentPrice + rimsesPrice + varnishesPrice + engingePowerPrice);
        }
Пример #32
0
        private static decimal?GetCalculationsTotalRecursive(Calculation calculation)
        {
            IEnumerable <Calculation> cashCalculations = calculation.Calculations?
                                                         .Where(subCalculation => subCalculation.Type == CalculationType.Cash);

            decimal?calculationSum = cashCalculations?.Sum(GetCalculationsTotalRecursive);

            return(calculation.Value.AddValueIfNotNull(calculationSum));
        }
Пример #33
0
        private async Task CreateAssignCalculationJobForFundingStream(string fundingStreamId,
                                                                      string fundingPeriodId,
                                                                      SpecificationVersion specificationVersion,
                                                                      Reference user,
                                                                      string correlationId,
                                                                      string parentJobId)
        {
            string templateVersion = specificationVersion.TemplateIds.ContainsKey(fundingStreamId) ? specificationVersion.TemplateIds[fundingStreamId] : string.Empty;

            if (string.IsNullOrEmpty(templateVersion))
            {
                return;
            }

            ApiResponse <TemplateMetadataContents> templateContents = await _policyResiliencePolicy.ExecuteAsync(
                () => _policies.GetFundingTemplateContents(fundingStreamId, fundingPeriodId,
                                                           templateVersion));

            IEnumerable <FundingLine> flattenedFundingLines = templateContents?.Content?.RootFundingLines.Flatten(_ => _.FundingLines)
                                                              ?? new FundingLine[0];

            IEnumerable <Calculation> flattenedCalculations = flattenedFundingLines.SelectMany(_ => _.Calculations.Flatten(cal => cal.Calculations)) ?? new Calculation[0];

            IEnumerable <Calculation> uniqueflattenedCalculations = flattenedCalculations.GroupBy(x => x.TemplateCalculationId).Select(x => x.FirstOrDefault());

            int itemCount = uniqueflattenedCalculations?.Count() + uniqueflattenedCalculations?.Sum(
                cal => (cal.ReferenceData?.Count())
                .GetValueOrDefault()) ?? 0;

            if (itemCount == 0)
            {
                _logger.Warning("Did not locate any calculations on to queue assignment job for");

                return;
            }

            Job assignCalculationsJob = await CreateJob($"Failed to queue assign template calculations job for {fundingStreamId}/{templateVersion}",
                                                        NewJobCreateModel(specificationVersion.SpecificationId,
                                                                          "Assigning Template Calculations for Specification",
                                                                          JobConstants.DefinitionNames.AssignTemplateCalculationsJob,
                                                                          correlationId,
                                                                          user,
                                                                          new Dictionary <string, string>
            {
                { "specification-id", specificationVersion.SpecificationId },
                { "fundingstream-id", fundingStreamId },
                { "fundingperiod-id", fundingPeriodId },
                { "template-version", templateVersion }
            },
                                                                          parentJobId,
                                                                          itemCount));

            GuardAgainstNullJob(assignCalculationsJob, $"Failed to queue assign template calculations job for {fundingStreamId}/{templateVersion}");
        }
Пример #34
0
        DtoVotoDetalleLista ObtenerInformacionLista(Pe05_Lista lista, IEnumerable <Mv01_Voto> votos, int numeroEscanios)
        {
            var detalleLista = new DtoVotoDetalleLista()
            {
                CantidadVotos = (votos?.Sum(x => (x.Opciones.Where(y => y.Candidato.ListaId == lista.Id)?.Count() ?? 0) * (1 /*ObtenerCargoPonderacion(x.Cargo.Ponderacion)*/))) ?? 0,
                ListaId       = lista?.Id ?? 0,
            };

            detalleLista.Coeficintes = CalcularCoeficientes(detalleLista.CantidadVotos, numeroEscanios, lista.Id);
            return(detalleLista);
        }
        private static Procedure_InclusaoReservaFiltersType CreateReservaFilterType(string key, string password, Reserva entity, IEnumerable <IMes> months, Programa program, Estrutura structure, Fonte source, Regional regional)
        {
            var inQuotaReserva_1 = Convert.ToString(months?.Where(x => B1.Contains(x.Descricao)).Sum(y => y.ValorMes));
            var inQuotaReserva_2 = Convert.ToString(months?.Where(x => B2.Contains(x.Descricao)).Sum(y => y.ValorMes));
            var inQuotaReserva_3 = Convert.ToString(months?.Where(x => B3.Contains(x.Descricao)).Sum(y => y.ValorMes));
            var inQuotaReserva_4 = Convert.ToString(months?.Where(x => B4.Contains(x.Descricao)).Sum(y => y.ValorMes));
            var inTotalReserva   = months?.Sum(x => x.ValorMes).ToString();

            return(new Procedure_InclusaoReservaFiltersType
            {
                inOperador = key,
                inChave = password,
                inAnoRefRes = entity?.AnoExercicio.ToString().Substring(2, 2),
                inAnoExercicio = DateTime.Now.Month <= 2 ? entity?.AnoExercicio.ToString().Substring(2, 2) : default(string),
                inCFPRes_1 = program?.Cfp?.Substring(0, 2),
                inCFPRes_2 = program?.Cfp?.Substring(2, 3),
                inCFPRes_3 = program?.Cfp?.Substring(5, 4),
                inCFPRes_4 = program?.Cfp?.Substring(9, 4),
                inCFPRes_5 = entity?.OrigemRecurso?.Substring(1, 2) + "00" ?? default(string),
                inCEDRes_1 = structure?.Natureza?.Substring(0, 1),
                inCEDRes_2 = structure?.Natureza?.Substring(1, 1),
                inCEDRes_3 = structure?.Natureza?.Substring(2, 1),
                inCEDRes_4 = structure?.Natureza?.Substring(3, 1),
                inCEDRes_5 = structure?.Natureza?.Substring(4, 2),
                inOrgao = regional?.Descricao?.Substring(2, 2),
                inCodAplicacaoRes = entity?.Obra?.ToString(),
                inOrigemRecursoRes = entity?.OrigemRecurso?.Substring(1, 2),
                inDestinoRecursoRes = entity?.DestinoRecurso,
                inNumProcessoRes = entity?.Processo,
                inAutoProcFolhasRes = entity?.AutorizadoSupraFolha,
                inCodEspecDespesaRes = entity?.EspecificacaoDespesa,
                inEspecifDespesaRes = entity?.DescEspecificacaoDespesa.Replace(";", string.Empty),
                inAutoPorAssRes = entity?.AutorizadoAssinatura,
                inAutoPorGrupoRes = entity?.AutorizadoGrupo,
                inAutoPorOrgaoRes = entity?.AutorizadoOrgao,
                inExamPorAssRes = entity?.ExaminadoAssinatura,
                inExamPorGrupoRes = entity?.ExaminadoGrupo,
                inExamPorOrgaoRes = entity?.ExaminadoOrgao,
                inRespEmissaoAssRes = entity?.ResponsavelAssinatura,
                inRespEmissGrupoRes = entity?.ResponsavelGrupo,
                inRespEmissOrgaoRes = entity?.ResponsavelOrgao,
                inIdentContratoANORes = entity?.Contrato?.Substring(0, 2),
                inIdentContratoORGAORes = entity?.Contrato?.Substring(2, 2),
                inIdentContratoNUMRes = entity?.Contrato?.Substring(4, 5),
                inIdentContratoDCRes = entity?.Contrato?.Substring(9, 1),
                inQuotaReserva_1 = inQuotaReserva_1?.Length < 3 ? "0" + inQuotaReserva_1 : inQuotaReserva_1,
                inQuotaReserva_2 = inQuotaReserva_2?.Length < 3 ? "0" + inQuotaReserva_2 : inQuotaReserva_2,
                inQuotaReserva_3 = inQuotaReserva_3?.Length < 3 ? "0" + inQuotaReserva_3 : inQuotaReserva_3,
                inQuotaReserva_4 = inQuotaReserva_4?.Length < 3 ? "0" + inQuotaReserva_4 : inQuotaReserva_4,
                inTotalReserva = inTotalReserva?.Length < 3 ? "0" + inTotalReserva : inTotalReserva,
            });
        }
        private static Procedure_AnulacaoEmpenhoFiltersType CreateAnulacaoFilterType(string key, string password, EmpenhoCancelamento entity, IEnumerable <IMes> months, Fonte source)
        {
            var descriptions = new List <string>(entity.DescricaoEspecificacaoDespesa?.Split(';') ?? new string[] { });

            return(new Procedure_AnulacaoEmpenhoFiltersType
            {
                //  inImpressora =
                inOperador = key,
                inChave = password,

                inNumProcesso = entity?.NumeroProcesso,
                inOrigemRecurso = source.Codigo.Substring(1, 2),
                inDestinoRecurso = entity.DestinoId,

                inEmpenho = entity?.CodigoEmpenho,
                inQuota1 = months?.Where(x => B1.Contains(x.Descricao)).Sum(y => y.ValorMes).ToString(),
                inQuota2 = months?.Where(x => B2.Contains(x.Descricao)).Sum(y => y.ValorMes).ToString(),
                inQuota3 = months?.Where(x => B3.Contains(x.Descricao)).Sum(y => y.ValorMes).ToString(),
                inQuota4 = months?.Where(x => B4.Contains(x.Descricao)).Sum(y => y.ValorMes).ToString(),

                inTotal = months?.Sum(x => x.ValorMes).ToString(),

                inAutFLS = entity?.DescricaoAutorizadoSupraFolha,
                inCodEspecificaDesp = entity.CodigoEspecificacaoDespesa,
                inEspecificaDesp_01 = descriptions.Count > 0 ? descriptions[0] : null,
                inEspecificaDesp_02 = descriptions.Count > 1 ? descriptions[1] : null,
                inEspecificaDesp_03 = descriptions.Count > 2 ? descriptions[2] : null,
                inEspecificaDesp_04 = descriptions.Count > 3 ? descriptions[3] : null,
                inEspecificaDesp_05 = descriptions.Count > 4 ? descriptions[4] : null,
                inEspecificaDesp_06 = descriptions.Count > 5 ? descriptions[5] : null,
                inEspecificaDesp_07 = descriptions.Count > 6 ? descriptions[6] : null,
                inEspecificaDesp_08 = descriptions.Count > 7 ? descriptions[7] : null,
                inEspecificaDesp_09 = descriptions.Count > 8 ? descriptions[8] : null,

                inCodAssinAutorizacao = entity?.CodigoAutorizadoAssinatura.ToString(),
                inGrupoAssinAutorizacao = entity?.CodigoAutorizadoGrupo.ToString(),
                inOrgaoAssinAutorizacao = entity?.CodigoAutorizadoOrgao,

                inCodAssinExaminado = entity?.CodigoExaminadoAssinatura.ToString(),
                inGrupoAssinExaminado = entity?.CodigoExaminadoGrupo.ToString(),
                inOrgaoAssinExaminado = entity?.CodigoExaminadoOrgao,

                inCodAssinRespons = entity?.CodigoResponsavelAssinatura.ToString(),
                inGrupoAssinRespons = entity?.CodigoResponsavelGrupo.ToString(),
                InOrgaoAssinRespons = entity?.CodigoResponsavelOrgao,
                inImprimir = "A"
            });
        }
Пример #37
0
        protected string BuildNameArray(IEnumerable <NameGroup> nameGroups, string arrayName, int indentationLevels, string sequentialName)
        {
            string content = string.Empty;

            if (string.IsNullOrWhiteSpace(sequentialName) && nameGroups.All(x => x.Values.Count == 0))
            {
                return(content);
            }

            content += $"{GetIndentation(indentationLevels)}{arrayName} = {{{Environment.NewLine}";


            if (nameGroups?.Sum(x => x.Values.Count) > 0)
            {
                if (!string.IsNullOrWhiteSpace(sequentialName))
                {
                    content           += $"{GetIndentation(indentationLevels + 1)}random_names = {{{Environment.NewLine}";
                    indentationLevels += 1;
                }

                content += GetFormattedNameCollection(nameGroups, indentationLevels + 1);

                if (!string.IsNullOrWhiteSpace(sequentialName))
                {
                    content           += $"{GetIndentation(indentationLevels)}}}{Environment.NewLine}";
                    indentationLevels -= 1;
                }
            }

            if (!string.IsNullOrWhiteSpace(sequentialName))
            {
                content += $"{GetIndentation(indentationLevels + 1)}sequential_name = \"{sequentialName}\"{Environment.NewLine}";
            }

            content += $"{GetIndentation(indentationLevels)}}}{Environment.NewLine}";

            return(content);
        }
Пример #38
0
 public virtual int InsertOrReplace(IEnumerable <T> entities) =>
 entities?.Sum(entity => InsertOrReplace(entity)) ?? 0;
Пример #39
0
 public virtual int Delete(IEnumerable <T> entities) =>
 entities?.Sum(entity => Delete(entity)) ?? 0;
Пример #40
0
        public float Sum(IEnumerable <float> sourceCollection)
        {
            var num = 0f;

            return(sourceCollection?.Sum() ?? num);
        }
Пример #41
0
 public virtual int UpdateOrInsert(IEnumerable <T> entities) =>
 entities?.Sum(entity => UpdateOrInsert(entity)) ?? 0;
Пример #42
0
 private static int MyInstanceSum(IEnumerable <int> enumerable)
 {
     return(enumerable.Sum());
 }
Пример #43
0
 public static decimal TotalPrices(this IEnumerable <Product> products)
 {
     return(products?.Sum(x => x?.Price ?? 0) ?? 0);
 }
Пример #44
0
        public double Sum(IEnumerable <double> sourceCollection)
        {
            var num = 0.0;

            return(sourceCollection?.Sum() ?? num);
        }
Пример #45
0
 private static int MyStaticSum(IEnumerable <int> enumerable)
 {
     return(enumerable.Sum());
 }
Пример #46
0
 public double Sum(IEnumerable <double> numbers)
 => numbers?.Sum() ?? throw new ArgumentNullException(nameof(numbers));
Пример #47
0
 public int GetHashCode(IEnumerable <MultiItems> obj)
 => obj?.Sum(x => x.GetHashCode()) ?? 0;
 private decimal CalcularSubTotal(IEnumerable <Cobertura> coberturas) => coberturas?.Sum(c => c.Premio) ?? 0m;
Пример #49
0
 public double CalculateSumTime(IEnumerable <BoardOrderItem> items, int boardsQuantity)
 {
     return(Math.Round(items?.Sum(item => item.WorkdaysModifier * boardsQuantity) ?? 0));
 }
Пример #50
0
 public double CalculateSumCost(IEnumerable <BoardOrderItem> items, int boardsQuantity)
 {
     return(items?.Sum(item => item.CostModifier * boardsQuantity) ?? 0);
 }
Пример #51
0
 public long Sum(IEnumerable <long> sourceCollection)
 {
     return(sourceCollection?.Sum() ?? 0L);
 }
 private static double GetMaxAssessment()
 {
     return(_analyzers?.Sum(x => x.MultiplicationFactor * 2.0) ?? 0.0);
 }
Пример #53
0
    public async Task <CoinJoinResult> StartCoinJoinAsync(IEnumerable <SmartCoin> coinCandidates, CancellationToken cancellationToken)
    {
        var tryLimit = 6;

        RoundState?currentRoundState;
        uint256    excludeRound = uint256.Zero;
        ImmutableList <SmartCoin> coins;

        do
        {
            currentRoundState = await WaitForRoundAsync(excludeRound, cancellationToken).ConfigureAwait(false);

            RoundParameters roundParameteers = currentRoundState.CoinjoinState.Parameters;
            coins = SelectCoinsForRound(coinCandidates, roundParameteers, ConsolidationMode, AnonScoreTarget, SecureRandom);

            if (roundParameteers.MaxSuggestedAmount != default && coins.Any(c => c.Amount > roundParameteers.MaxSuggestedAmount))
            {
                excludeRound = currentRoundState.Id;
                currentRoundState.LogInfo($"Skipping the round for more optimal mixing. Max suggested amount is '{roundParameteers.MaxSuggestedAmount}' BTC, biggest coin amount is: '{coins.Select(c => c.Amount).Max()}' BTC.");

                continue;
            }

            break;
        }while (!cancellationToken.IsCancellationRequested);

        if (coins.IsEmpty)
        {
            throw new NoCoinsToMixException($"No coin was selected from '{coinCandidates.Count()}' number of coins. Probably it was not economical, total amount of coins were: {Money.Satoshis(coinCandidates.Sum(c => c.Amount))} BTC.");
        }

        for (var tries = 0; tries < tryLimit; tries++)
        {
            CoinJoinResult result = await StartRoundAsync(coins, currentRoundState, cancellationToken).ConfigureAwait(false);

            if (!result.GoForBlameRound)
            {
                return(result);
            }

            // Only use successfully registered coins in the blame round.
            coins = result.RegisteredCoins;

            currentRoundState.LogInfo("Waiting for the blame round.");
            currentRoundState = await WaitForBlameRoundAsync(currentRoundState.Id, cancellationToken).ConfigureAwait(false);
        }

        throw new InvalidOperationException("Blame rounds were not successful.");
    }
 internal static StructurePermitDetail Map(
     BldgpermitApplicationMaster bldg,
     BldgapplicationConditions apcnConditionRecord,
     BldgapplicationInspections apinConditionRecord,
     BldgstructureBuildingPermitDetail strd,
     BldgfireDistrictCodes fdst,
     IEnumerable <BldgapplicationValues> appv)
 => new StructurePermitDetail(strd?.OfficeProjectDescription, strd?.ResAgCommOther, strd?.NumberOfBedrooms, strd?.NumberOfBathrooms, strd?.NumberOfUnits,
                              strd?.Heated, strd?.HeatSourceDescription, strd?.PrescriptiveReviewDone, strd?.WattsunRunReviewDone, strd?.Nrecreceived, strd?.PlansAnalystReviewDone,
                              strd?.PlansAnalystReviewDescription, strd?.SprinklerSystemRequired, strd?.SprinklerSystemDescription, strd?.AlarmSystemRequired, strd?.AlarmSystemDescription,
                              strd?.SpecialInspectionRequired, strd?.SpecialInspectionDescription, strd?.PermitIncludePlumbing, strd?.PermitIncludeMechanical, strd?.FireDistrictCode,
                              fdst?.LongFireDistrictName, strd?.FireFlowAlreadyProvided, strd?.AdditionalFireFlowRequired, strd?.AmountOfFireFlowRequired, strd?.BldgDeptSetback,
                              strd?.FireMarshalSetback, apcnConditionRecord == null, apinConditionRecord == null, appv?.Sum(t => t.ExtendedValue),
                              new PermitApprovedInfo(strd?.BldgDeptApprovedBy, strd?.BldgDepDateApproved, strd?.BldgDeptApprovedUserId, strd?.BldgDeptApprovedChangeDate),
                              new PermitApprovedInfo(strd?.FireMarshalApprovedBy, strd?.FireMarshalDateApproved, strd?.FireMarshalApprovedUserId, strd?.FireMarshalApprovedChangeDate));
Пример #55
0
 public static int GetPickupCount(this Inventory inv, IEnumerable <PickupIndex> pickupIndices)
 {
     return(pickupIndices?.Sum(inv.GetPickupCount) ?? 0);
 }
Пример #56
0
        public int Sum(IEnumerable <int> sourceCollection)
        {
            var num = 0;

            return(sourceCollection?.Sum() ?? num);
        }
 private decimal GetPeriodValueSum(IEnumerable <SupplementaryDataModel> data)
 {
     return(data?.Sum(v => (decimal)(v.GetType().GetProperty("Value")?.GetValue(v) ?? 0M)) ?? 0);
 }
Пример #58
0
 static Tuple <int, int> Total(IEnumerable <int> wordCounts)
 {
     return(new Tuple <int, int>(wordCounts.Count(), wordCounts.Sum()));
 }
Пример #59
0
 public static int CountRatings(IEnumerable <RatingsPredictionSchedule> schedules)
 {
     return(schedules?.Sum(x => x.Ratings?.Count ?? 0) ?? 0);
 }
Пример #60
0
 public static double Calculate(IEnumerable <double> shares)
 {
     return(shares?.Sum(p => Math.Pow(p, 2)) ?? 0);
 }