Ejemplo n.º 1
0
        public void Generate(IGeneratorSettings generatorSettings)
        {
            if (String.IsNullOrWhiteSpace(this.txtPassword.Text))
            {
                MessageBox.Show(base.ParentForm,
                                "Provide a source password to be processed.", "Warning",
                                MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            IEntropyCalculator  entropyCalculator  = CalculatorFactory.Create <IEntropyCalculator>();
            IStrengthCalculator strengthCalculator = CalculatorFactory.Create <IStrengthCalculator>();
            ISecurityCalculator securityCalculator = CalculatorFactory.Create <ISecurityCalculator>();

            String   password = this.txtPassword.Text;
            Double   entropy  = entropyCalculator.Calculate(password);
            Strength strength = strengthCalculator.Calculate(entropy);
            Scenario scenario = this.cmbScenario.SelectedValue as Scenario;

            // Don't change this order.
            this.cntEntropy.Strength = strength;
            this.cntEntropy.Entropy  = entropy;
            this.cntEntropy.Percent  = strengthCalculator.ToPercent(entropy);
            this.cntEntropy.Summary  = strengthCalculator.ToSummary(strength);

            if (entropy > 0d)
            {
                Duration duration = securityCalculator.Calculate(scenario, entropy);
                this.cntDuration.SetDuration(duration);
            }
        }
Ejemplo n.º 2
0
            public C(A pA, B pB, CalculatorFactory pCalcFactory)
            {
                _pA           = pA;
                _pB           = pB;
                _pCalcFactory = pCalcFactory;

                var calculator = _pCalcFactory.Create();
            }
Ejemplo n.º 3
0
        private static void Run(bool useProxy)
        {
            ICalculate theCalculator = CalculatorFactory.Create(useProxy);

            for (int i = 0; i < 1000; i++)
            {
                int        x = _generator.Next(0, Coordinate.XMax) + 1;
                int        y = _generator.Next(0, Coordinate.YMax) + 1;
                Coordinate c = new Coordinate(x, y);
                Console.WriteLine($"Result of calculation #{i:000}, using ({x},{y}) : {theCalculator.Calculate(c)} {CacheReport(useProxy)}");
            }
        }
Ejemplo n.º 4
0
        static void Main(string[] args)
        {
            var factory    = new CalculatorFactory();
            var calculator = factory.Create(Algorithm.Arctan2);

            // http://www.findlatitudeandlongitude.com/
            var origin      = new Coordinate(43.089325, -87.87406);
            var destination = new Coordinate(43.060109, -87.883759);

            var distance1 = calculator.Calculate(origin, destination);

            calculator = factory.Create(Algorithm.Haversine);
            var distance2 = calculator.Calculate(origin, destination);

            calculator = factory.Create(Algorithm.LawOfCosines);
            var distance3 = calculator.Calculate(origin, destination);

            System.Console.WriteLine("arctan2:\t{0}", distance1.Meters);
            System.Console.WriteLine("haversine:\t{0}", distance2.Meters);
            System.Console.WriteLine("law of cosines:\t{0}", distance3.Meters);

            System.Console.ReadLine();
        }
        protected override async Task FinalizeJob(ScheduledJob job)
        {
            foreach (var indicator in _indicators)
            {
                var indicatorResults = await GetIntermediateResults(job.JobId, indicator.IndicatorId);

                var calculator = _calculatorFactory.Create(indicator);
                indicatorResults = calculator.Combine(indicatorResults);

                await _globalIndicatorService.Save(new GlobalIndicator
                {
                    SectorId             = 0,
                    IndicatorId          = indicator.IndicatorId,
                    Values               = indicatorResults,
                    StartDate            = indicatorResults.Last().Date,
                    EndDate              = indicatorResults.First().Date,
                    CalculatedSuccessful = true,
                    CompanyCount         = Total,
                    LastCalculated       = DateTime.UtcNow
                });

                await ClearIntermediateResults(job.JobId, indicator.IndicatorId);
            }
        }
Ejemplo n.º 6
0
        public ExtendedGeneratorControl()
            : base()
        {
            this.InitializeComponent();
            this.lstPasswords.Items.Clear();

            this.entropyCalculator  = CalculatorFactory.Create <IEntropyCalculator>();
            this.strengthCalculator = CalculatorFactory.Create <IStrengthCalculator>();

            StandardContextMenu contextMenu = StandardContextMenu.Create(this.OnContextMenuItemClick);

            contextMenu.Opening += this.OnContextMenuOpening;

            this.numLength.ContextMenuStrip    = contextMenu;
            this.numAmount.ContextMenuStrip    = contextMenu;
            this.lstPasswords.ContextMenuStrip = contextMenu;
        }
Ejemplo n.º 7
0
        private void CalculateDestructionPercent(string happeningId, string personId)
        {
            var happening = QueryModelRepository.Dashboard.Happenings[happeningId];
            var attendee  = happening.Attendees.First(MatchAttendee(personId));
            var person    = attendee.Person;

            if (person.HappeningsQuit.Contains(happeningId))
            {
                attendee.DestructionPercent = 100;
                return;
            }

            if (person.HappeningsCompleted.Contains(happeningId))
            {
                attendee.DestructionPercent = 0;
                return;
            }

            var currentDistance =
                happening.Checkpoints.SelectMany(
                    m => m.Visits.Where(MatchVisit(personId)),
                    (checkpoint, visit) => checkpoint.DistanceFromStart).DefaultIfEmpty(0).Max();


            var speed = this.calculator.Calculate(happening.Checkpoints.OrderBy(a => 1), personId);

            var destructionCalculator =
                CalculatorFactory.Create(
                    new PersonData
            {
                DestructedInPrevious = person.QuitLastTime,
                Attended             = person.HappeningsAttended.Count,
                Destructed           = person.HappeningsQuit.Count
            });

            attendee.DestructionPercent =
                destructionCalculator.Calculate(
                    new WalkingData
            {
                LastAverageSpeedChange = (decimal)speed.LastAverageSpeedChangePercent,
                CurrentDistance        = currentDistance
            });
        }
Ejemplo n.º 8
0
        private static void CalculateRentTest()
        {
            Write("Podaj imię: ");
            string firstName = ReadLine();

            Write("Podaj nazwisko: ");
            string lastName = ReadLine();

            var rentee = new Man();

            rentee.FirstName = firstName;
            rentee.LastName  = lastName;

            Product item = new CrossCountrySki
            {
                Id           = 1,
                PricePerHour = 50,
                Name         = "Fisher",
                Size         = 150,
            };

            var rent = new Rent(rentee, item)
            {
                Id = 1,
            };

            // zwrot

            Thread.Sleep(TimeSpan.FromSeconds(1));

            rent.Return();

            ICalculatorFactory calculatorFactory = new CalculatorFactory();

            ICostCalculator calculator = calculatorFactory.Create(rent);

            rent.Cost = calculator.Calculate(rent);
        }
        public void Start()
        {
            var log = new Logger();

            try
            {
                var indicators = _indicatorService.GetGlobalIndicators();


                var findRequest = new FindCompaniesForJobRequest()
                {
                    JobId          = Guid.NewGuid().ToString(),
                    MaxRecordCount = 10,
                    SectorId       = 0
                };

                var companies    = _companyService.FindCompaniesForJob(findRequest);
                var sectorResult = new GlobalIndicatorResults(0);

                while (companies != null && companies.Any())
                {
                    foreach (var company in companies)
                    {
                        foreach (var indicator in indicators)
                        {
                            var result = CalculateIndicators(company, indicator);

                            sectorResult.Add(result, indicator, company.Ticker);
                        }

                        log.Info($"Processed {company.Ticker}");
                    }

                    _companyService.CompleteJob(new CompleteJobRequest
                    {
                        JobId   = findRequest.JobId,
                        Tickers = companies.Select(c => c.Ticker).ToList()
                    });

                    companies = null; // _companyService.FindCompaniesForJob(findRequest);
                }

                var indicatorResults = sectorResult.IndicatorResults.Select(i => i.Value).ToList();
                if (indicatorResults.Any())
                {
                    var tickers = indicatorResults.First().Select(r => r.Ticker).ToList();

                    foreach (var indicatorResult in indicatorResults)
                    {
                        var calculator = _processorFactory.Create(indicatorResult.Indicator);
                        var result     = calculator.Merge(indicatorResult);


                        _globalIndicatorService.Save(new GlobalIndicator
                        {
                            SectorId             = 0, //sector.SectorId,
                            IndicatorId          = indicatorResult.Indicator.IndicatorId,
                            Values               = result,
                            StartDate            = result.Last().Date,
                            EndDate              = result.First().Date,
                            CalculatedSuccessful = true,
                            CompanyCount         = tickers.Count,
                            LastCalculated       = DateTime.UtcNow
                        }).GetAwaiter().GetResult();
                    }
                }
            }

            catch (Exception ex)
            {
                log.Error("FindCompaniesForJob", ex);
            }
        }
Ejemplo n.º 10
0
 public CalculatorProxy()
 {
     _cache      = new Cache();
     _calculator = CalculatorFactory.Create(false);
 }
 public void Create_TypeOfIDisposable_ThrowsNotSupportedException()
 {
     Assert.That(() => CalculatorFactory.Create <IDisposable>(), Throws.InstanceOf <NotSupportedException>());
 }
        public void Create_TypeOfISecurityCalculator_ResultIsInstanceOfSecurityCalculator()
        {
            Object actual = CalculatorFactory.Create <ISecurityCalculator>();

            Assert.That(actual, Is.InstanceOf <SecurityCalculator>());
        }
        public void Create_TypeOfIEntropyCalculator_ResultIsInstanceOfEntropyCalculator()
        {
            Object actual = CalculatorFactory.Create <IEntropyCalculator>();

            Assert.That(actual, Is.InstanceOf <EntropyCalculator>());
        }