Exemplo n.º 1
0
 /// <summary>
 /// Notifies this barrier that there will be additional participants.
 /// </summary>
 /// <param name="participantCount">The number of additional participants to add to the barrier.</param>
 /// <returns>The phase number of the barrier in which the new participants will first participate.</returns>
 /// <exception cref="ArgumentOutOfRangeException"><paramref name="participantCount"/> is less than 0.</exception>
 /// <exception cref="ObjectDisposedException">The current instance has already been disposed.</exception>
 public long AddParticipants(long participantCount)
 {
     ThrowIfDisposed();
     countdown.TryAddCount(participantCount, true);  // always returns true if autoReset==true
     participants.Add(participantCount);
     return(currentPhase);
 }
Exemplo n.º 2
0
            public RandomNumberRequestInformation GetRandomNumberRequestInformation()
            {
                var lastMinedMinerInformation = _currentRound.RealTimeMinersInformation.Values.OrderBy(i => i.Order)
                                                .LastOrDefault(i => i.OutValue != null);
                var minedMinersCount = lastMinedMinerInformation?.Order ?? 0;
                var leftMinersCount  = _minersCount.Sub(minedMinersCount);

                if (leftMinersCount >= _minimumRequestMinersCount)
                {
                    // It's possible for user to get random number in current round.
                    return(new RandomNumberRequestInformation
                    {
                        TargetRoundNumber = _currentRound.RoundNumber,
                        ExpectedBlockHeight =
                            _currentHeight.Add(
                                _minimumRequestMinersCount.Mul(AEDPoSContractConstants.MaximumTinyBlocksCount)),
                        Order = minedMinersCount
                    });
                }

                var leftTinyBlocks = lastMinedMinerInformation == null
                    ? 0
                    : AEDPoSContractConstants.MaximumTinyBlocksCount.Sub(lastMinedMinerInformation.ActualMiningTimes
                                                                         .Count);
                var leftBlocksCount = _currentHeight
                                      .Add(leftMinersCount.Mul(AEDPoSContractConstants.MaximumTinyBlocksCount))
                                      .Add(leftTinyBlocks);

                return(new RandomNumberRequestInformation
                {
                    TargetRoundNumber = _currentRound.RoundNumber.Add(1),
                    ExpectedBlockHeight = _currentHeight.Add(leftBlocksCount),
                    Order = minedMinersCount
                });
            }
Exemplo n.º 3
0
        public static void Solve()
        {
            var(A, B, Q) = Scanner.Scan <int, int, int>();
            var        S   = new long[A].Select(_ => Scanner.Scan <long>()).ToList();
            var        T   = new long[B].Select(_ => Scanner.Scan <long>()).ToList();
            var        X   = new long[Q].Select(_ => Scanner.Scan <long>()).ToArray();
            const long inf = (long)1e18;

            S.Add(-inf); S.Add(inf);
            T.Add(-inf); T.Add(inf);
            S.Sort(); T.Sort();
            foreach (var x in X)
            {
                var slb    = ~S.BinarySearch(x);
                var tlb    = ~T.BinarySearch(x);
                var answer = inf;
                foreach (var s in new[] { S[slb - 1], S[slb] })
                {
                    foreach (var t in new[] { T[tlb - 1], T[tlb] })
                    {
                        answer = Math.Min(answer, Math.Abs(s - x) + Math.Abs(t - s));
                        answer = Math.Min(answer, Math.Abs(t - x) + Math.Abs(s - t));
                    }
                }
                Console.WriteLine(answer);
            }
        }
            public void Deconstruct(out BlockchainMiningStatus status)
            {
                status = BlockchainMiningStatus.Normal;

                if (_libRoundNumber.Add(AbnormalThresholdRoundsCount) < _currentRoundNumber &&
                    _currentRoundNumber < _libRoundNumber.Add(SevereStatusRoundsThreshold))
                {
                    status = BlockchainMiningStatus.Abnormal;
                }

                if (_currentRoundNumber >= _libRoundNumber.Add(SevereStatusRoundsThreshold))
                {
                    status = BlockchainMiningStatus.Severe;
                }
            }
Exemplo n.º 5
0
        public void Int64_And_UInt64_Test()
        {
            ulong number1 = 6;
            long  number2 = 6;

            number1.Mul(6).ShouldBe(36UL);
            number2.Mul(6).ShouldBe(36L);
            Should.Throw <DivideByZeroException>(() => { number1.Div(0); });
            Should.Throw <DivideByZeroException>(() => { number2.Div(0); });

            number1.Div(2).ShouldBe(3UL);
            number2.Div(-2).ShouldBe(-3L);
            Should.Throw <DivideByZeroException>(() => { 5.Div(0); });
            Should.Throw <DivideByZeroException>(() => { (-5).Div(0); });

            number1.Sub(5).ShouldBe(1UL);
            number2.Sub(5).ShouldBe(1L);
            Should.Throw <OverflowException>(() => { long.MaxValue.Sub(-5); });
            Should.Throw <OverflowException>(() => { ulong.MinValue.Sub(5); });

            number1.Add(5).ShouldBe(11UL);
            number2.Add(5).ShouldBe(11L);
            Should.Throw <OverflowException>(() => { long.MaxValue.Add(8); });
            Should.Throw <OverflowException>(() => { ulong.MaxValue.Add(8); });
        }
        /// <summary>
        /// This method for now is able to handle the situation of a miner keeping offline so many rounds,
        /// by using missedRoundsCount.
        /// </summary>
        /// <param name="miningInterval"></param>
        /// <param name="missedRoundsCount"></param>
        /// <returns></returns>
        private Timestamp CalculateFutureRoundStartTime(long missedRoundsCount = 0, int miningInterval = 0)
        {
            if (miningInterval == 0)
            {
                miningInterval = GetMiningInterval();
            }

            var totalMilliseconds = TotalMilliseconds(miningInterval);

            return(GetRoundStartTime().AddMilliseconds(missedRoundsCount.Add(1).Mul(totalMilliseconds)));
        }
Exemplo n.º 7
0
        private void addPoint(Polygon polygon, Vector3 point)
        {
            List <Vector3> points = null;

            if (!this.currentPoints.TryGetValue(polygon, out points))
            {
                points = new List <Vector3>();
                this.currentPoints[polygon] = points;
                this.polygonQueue.Enqueue(polygon);
                buildings++;
            }

            points.Add(point);
            polygon.ContainsPoints = true;
        }
Exemplo n.º 8
0
        /// <summary>
        /// Signals that a participant has reached the barrier and waits
        /// for all other participants to reach the barrier as well.
        /// </summary>
        /// <param name="timeout">The time to wait for phase completion.</param>
        /// <param name="token">The token that can be used to cancel the waiting operation.</param>
        /// <returns><see langword="true"/> if all other participants reached the barrier; otherwise, <see langword="false"/>.</returns>
        /// <exception cref="ObjectDisposedException">The current instance has already been disposed.</exception>
        public async Task <bool> SignalAndWaitAsync(TimeSpan timeout, CancellationToken token = default)
        {
            if (ParticipantCount == 0L)
            {
                throw new InvalidOperationException();
            }

            if (countdown.Signal(1L, true))
            {
                await PostPhase(currentPhase.Add(1L)).ConfigureAwait(false);

                return(true);
            }

            return(await WaitAsync(timeout, token).ConfigureAwait(false));
        }
Exemplo n.º 9
0
        /// <summary>
        /// Just burn balance in general ledger.
        /// </summary>
        /// <param name="period"></param>
        /// <param name="profitsMap"></param>
        /// <param name="scheme"></param>
        /// <param name="profitsReceivingVirtualAddress"></param>
        /// <returns></returns>
        private Empty BurnProfits(long period, Dictionary <string, long> profitsMap, Scheme scheme,
                                  Address profitsReceivingVirtualAddress)
        {
            Context.LogDebug(() => "going to Burn Profits.");
            scheme.CurrentPeriod = period.Add(1);

            var distributedProfitsInfo = new DistributedProfitsInfo
            {
                IsReleased = true
            };

            foreach (var profits in profitsMap)
            {
                var symbol = profits.Key;
                var amount = profits.Value;
                if (amount > 0)
                {
                    var balanceOfToken = State.TokenContract.GetBalance.Call(new GetBalanceInput
                    {
                        Owner  = scheme.VirtualAddress,
                        Symbol = symbol
                    });
                    if (balanceOfToken.Balance < amount)
                    {
                        continue;
                    }
                    State.TokenContract.TransferFrom.Send(new TransferFromInput
                    {
                        From   = scheme.VirtualAddress,
                        To     = Context.Self,
                        Amount = amount,
                        Symbol = symbol
                    });
                    State.TokenContract.Burn.Send(new BurnInput
                    {
                        Amount = amount,
                        Symbol = symbol
                    });
                    distributedProfitsInfo.AmountsMap.Add(symbol, -amount);
                }
            }

            State.SchemeInfos[scheme.SchemeId] = scheme;
            State.DistributedProfitsMap[profitsReceivingVirtualAddress] = distributedProfitsInfo;
            return(new Empty());
        }
Exemplo n.º 10
0
        public long FindFirstDuplicateFrequency(string frequencyChangesString)
        {
            var summedChanges = new long[] { 0 }.ToList();

            while (true)
            {
                foreach (var frequencyChange in ParseFrequencyChanges(frequencyChangesString))
                {
                    var lastSum = summedChanges.LastOrDefault();
                    var newSum  = lastSum + frequencyChange;
                    if (summedChanges.Contains(newSum))
                    {
                        return(newSum);
                    }

                    summedChanges.Add(newSum);
                }
            }
        }
Exemplo n.º 11
0
        private void UpdateTreasurySubItemsShares(long termNumber)
        {
            var endPeriod = termNumber.Add(1);

            if (State.ElectionContract.Value == null)
            {
                State.ElectionContract.Value =
                    Context.GetContractAddressByName(SmartContractConstants.ElectionContractSystemName);
            }

            var victories = State.ElectionContract.GetVictories.Call(new Empty()).Value.Select(bs => bs.ToHex())
                            .ToList();

            var previousMiners       = State.AEDPoSContract.GetPreviousMinerList.Call(new Empty()).Pubkeys.ToList();
            var previousMinerAddress = previousMiners.Select(k => Address.FromPublicKey(k.ToByteArray())).ToList();

            UpdateBasicMinerRewardWeights(endPeriod, victories, previousMinerAddress);

            UpdateReElectionRewardWeights(endPeriod, previousMiners.Select(m => m.ToHex()).ToList(),
                                          previousMinerAddress, victories);

            UpdateVotesWeightRewardWeights(endPeriod, victories, previousMinerAddress);
        }
Exemplo n.º 12
0
        internal Round GenerateFirstRoundOfNewTerm(int miningInterval,
                                                   Timestamp currentBlockTime, long currentRoundNumber = 0, long currentTermNumber = 0)
        {
            var sortedMiners =
                (from obj in Pubkeys
                 .ToDictionary <ByteString, string, int>(miner => miner.ToHex(), miner => miner[0])
                 orderby obj.Value descending
                 select obj.Key).ToList();

            var round = new Round();

            for (var i = 0; i < sortedMiners.Count; i++)
            {
                var minerInRound = new MinerInRound();

                // The first miner will be the extra block producer of first round of each term.
                if (i == 0)
                {
                    minerInRound.IsExtraBlockProducer = true;
                }

                minerInRound.Pubkey             = sortedMiners[i];
                minerInRound.Order              = i + 1;
                minerInRound.ExpectedMiningTime =
                    currentBlockTime.AddMilliseconds(i.Mul(miningInterval).Add(miningInterval));
                // Should be careful during validation.
                minerInRound.PreviousInValue = Hash.Empty;

                round.RealTimeMinersInformation.Add(sortedMiners[i], minerInRound);
            }

            round.RoundNumber            = currentRoundNumber.Add(1);
            round.TermNumber             = currentTermNumber.Add(1);
            round.IsMinerListJustChanged = true;

            return(round);
        }
Exemplo n.º 13
0
 public static long Inc(this long i)
 {
     return(i.Add(1));
 }
Exemplo n.º 14
0
 /// <summary>Adds the specified percentage to the stream size.</summary>
 /// <param name="p">
 /// The percentage to add.
 /// </param>
 public StreamSize Add(Percentage p)
 {
     return(m_Value.Add(p));
 }
Exemplo n.º 15
0
 /// <summary>
 /// Добавление тиков и инкремент счетчика тиков
 /// </summary>
 /// <param name="item"></param>
 public void Add(TimeSpan item)
 {
     _count.Increment();
     _ticks.Add(item.Ticks);
 }
Exemplo n.º 16
0
 public static IArray <long> Add(this long self, IArray <long> vector)
 {
     return(vector.Select(x => self.Add(x)));
 }