public BlockPuller(OnBlockDownloadedCallback callback, IChainState chainState, ProtocolVersion protocolVersion, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory)
{
this.reassignedJobsQueue = new Queue <DownloadJob>();
this.downloadJobsQueue = new Queue <DownloadJob>();
this.assignedDownloadsByHash = new Dictionary <uint256, AssignedDownload>();
this.assignedDownloadsSorted = new LinkedList <AssignedDownload>();
this.assignedHeadersByPeerId = new Dictionary <int, List <ChainedHeader> >();
this.averageBlockSizeBytes = new AverageCalculator(AverageBlockSizeSamplesCount);
this.pullerBehaviorsByPeerId = new Dictionary <int, IBlockPullerBehavior>();
this.processQueuesSignal = new AsyncManualResetEvent(false);
this.queueLock = new object();
this.peerLock = new object();
this.assignedLock = new object();
this.nextJobId = 0;
this.networkPeerRequirement = new NetworkPeerRequirement
{
MinVersion = protocolVersion,
RequiredServices = NetworkPeerServices.Network
};
this.cancellationSource = new CancellationTokenSource();
this.random = new Random();
this.maxBlocksBeingDownloaded = MinimalCountOfBlocksBeingDownloaded;
this.onDownloadedCallback = callback;
this.chainState = chainState;
this.dateTimeProvider = dateTimeProvider;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
}
public void GivenAStudenHasGradesThenTheCalculatorShouldCalculateAverageCorrectly()
{
var student1 = new Student()
{
Naam = "Bozo"
};
var student2 = new Student()
{
Naam = "Victor"
};
float expectedAverageStudent1 = (5f + 10f) / 2;
float expectedAverageStudent2 = (8f + 5f) / 2;
var gradeCollection = new GradeCollection();
gradeCollection.AddGrade(CreateGrade(student1, 5f));
gradeCollection.AddGrade(CreateGrade(student1, 10f));
gradeCollection.AddGrade(CreateGrade(student2, 8f));
gradeCollection.AddGrade(CreateGrade(student2, 5f));
var actualAverageStudent1 = AverageCalculator.CalculateMeanAverage(gradeCollection.GetGradesForStudent(student1));
var actualAverageStudent2 = AverageCalculator.CalculateMeanAverage(gradeCollection.GetGradesForStudent(student2));
Assert.AreEqual(expectedAverageStudent1, actualAverageStudent1, 0.001f);
Assert.AreEqual(expectedAverageStudent2, actualAverageStudent2, 0.002f);
}
public void Test_AverageByMedian()
{
calculator = new MedianCalculator();
double expected = 8.0;
double actual = calculator.CalculateAverage(values);
Assert.AreEqual(expected, actual, 0.000001);
Func <IEnumerable <double>, double> method = delegate
{
var sortedValues = values.OrderBy(x => x).ToList();
int n = sortedValues.Count;
if (n % 2 == 1)
{
return(sortedValues[(n - 1) / 2]);
}
return((sortedValues[(sortedValues.Count / 2) - 1] + sortedValues[n / 2]) / 2);
};
Assert.AreEqual(expected, AverageCalculator.CalculateAverage(values, method), 0.000001);
Assert.AreEqual(expected, AverageCalculator.CalculateAverage(values, calculator), 0.000001);
}
public AddressIndexer(StoreSettings storeSettings, DataFolder dataFolder, ILoggerFactory loggerFactory, Network network, INodeStats nodeStats,
IConsensusManager consensusManager, IAsyncProvider asyncProvider, ChainIndexer chainIndexer, IDateTimeProvider dateTimeProvider, IUtxoIndexer utxoIndexer)
{
this.storeSettings = storeSettings;
this.network = network;
this.nodeStats = nodeStats;
this.dataFolder = dataFolder;
this.consensusManager = consensusManager;
this.asyncProvider = asyncProvider;
this.dateTimeProvider = dateTimeProvider;
this.utxoIndexer = utxoIndexer;
this.loggerFactory = loggerFactory;
this.scriptAddressReader = new ScriptAddressReader();
this.lockObject = new object();
this.flushChangesInterval = TimeSpan.FromMinutes(2);
this.lastFlushTime = this.dateTimeProvider.GetUtcNow();
this.cancellation = new CancellationTokenSource();
this.chainIndexer = chainIndexer;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.averageTimePerBlock = new AverageCalculator(200);
int maxReorgLength = GetMaxReorgOrFallbackMaxReorg(this.network);
this.compactionTriggerDistance = maxReorgLength * 2 + SyncBuffer + 1000;
}
public void CalculateTest(double firstValue, double secondValue, double expected)
{
var calculator = new AverageCalculator();
var actual = calculator.Calculate(firstValue, secondValue);
Assert.AreEqual(expected, actual, 0.001);
}
public void CalculateAverages()
{
AveragePricePerLiter = AverageCalculator.CalculateAveragePricePerLiter(AllEntrysForSelectedCar);
TotalFuelAmount = AverageCalculator.CalculateTotalFuelAmount(AllEntrysForSelectedCar);
TotalRefuelCosts = AverageCalculator.CalculateTotalRefuelCosts(AllEntrysForSelectedCar);
TotalDrivenDistance = AverageCalculator.CalculateTotalDrivenDistance(AllEntrysForSelectedCar);
AverageConsumption = AverageCalculator.CalculateTotalAverageConsumption(AllEntrysForSelectedCar);
AverageCostsOfHundredKilometer = AverageCalculator.CalculateTotalAverageCostsOfHundredKilometer(AllEntrysForSelectedCar);
}
public void CalculateLarge()
{
var averageCalculator = new AverageCalculator();
var suit = new List <double> {
3, 5, 6, 7, 9, 12, 23, 86, 1, 23, 2, 5, 6, 9, 11, 21, 42, 24, 80, 93
};
double expectedValue = 23.4;
Assert.AreEqual(expectedValue, averageCalculator.Calculate(suit));
}
public void CanCalculateAverageAfterCapacityExceeded()
{
var calculator = new AverageCalculator(3);
foreach (int sample in this.samples)
{
calculator.AddSample(sample);
}
Assert.True(this.DoubleEqual(25, calculator.Average));
}
private void Button_Click(object sender, RoutedEventArgs e)
{
//You can use a double array or enter each of the numbers yourself
//double[] numbers = { 10, 10, 10, 10, 10 };
//double average = AverageCalculator.GetAverage(numbers);
double average = AverageCalculator.GetAverage(1, 2, 3);
Debug.WriteLine(average);
}
public void CanCalculateAverageWhenCapacityIsNotExceeded()
{
var calculator = new AverageCalculator(this.samples.Length);
foreach (int sample in this.samples)
{
calculator.AddSample(sample);
}
Assert.True(this.DoubleEqual(this.samples.Average(), calculator.Average));
}
public void CalculateSimple()
{
var averageCalculator = new AverageCalculator();
var suit = new List <double> {
6, 2, 3, 1
};
double expectedValue = 3;
Assert.AreEqual(expectedValue, averageCalculator.Calculate(suit));
}
public void LoadCars()
{
AvailableCars = new ObservableCollection <CarModel>(SqLiteDataAccessCarRefuelTrackerModule.LoadCars(SelectedYear));
foreach (CarModel car in AvailableCars)
{
car.CarName = $"{car.Brand.BrandName} {car.ModelType.ModelName}";
car.AveragePricePerLiter = AverageCalculator.CalculateAveragePricePerLiter(car.Entries);
car.TotalFuelAmount = AverageCalculator.CalculateTotalFuelAmount(car.Entries);
car.TotalRefuelCosts = AverageCalculator.CalculateTotalRefuelCosts(car.Entries);
car.TotalDrivenDistance = AverageCalculator.CalculateTotalDrivenDistance(car.Entries);
car.AverageConsumption = AverageCalculator.CalculateTotalAverageConsumption(car.Entries);
car.AverageCostsOfHundredKilometer = AverageCalculator.CalculateTotalAverageCostsOfHundredKilometer(car.Entries);
}
}
public async Task <IEnumerable <RecipesListByCategory> > GetAllRecipesByCategoryId(int categoryId)
{
try
{
_logger.Information("Fetching Recipes By Category {CategoryId}", categoryId);
var key = CacheKeys.RecipesByCatId + "_" + categoryId;
if (_memoryCache.TryGetValue(key, out IEnumerable <RecipesListByCategory> data))
{
if (data != null || !data.Any())
{
return(data);
}
_memoryCache.Remove(key);
}
using var factory = await _dbFactory.Create();
using var _dbContext = factory.FactoryFor <ApnaBawarchiKhanaDbContext>();
var result = await _dbContext.Recipes.Include(i => i.RecipeCategories).Include(r => r.RecipeRatings)
.Include(i => i.RecipeImages)
.ThenInclude(i => i.UploadedImage)
.AsNoTracking().OrderByDescending(o => o.CreatedAt).Where(w => w.RecipeCategories.Any(a => a.CategoryId == categoryId))
.Select(
r => new RecipesListByCategory
{
RecipeId = r.Id,
Description = r.Description,
Title = r.Title,
Thumbnail = r.RecipeImages.Any() ? r.RecipeImages.First().UploadedImage.ImageData : null,
Ratings = AverageCalculator.GetAverageRating(r.RecipeRatings.Select(s => s.Rating).ToList())
}).ToListAsync();
if (result == null)
{
return(null);
}
_memoryCache.Set(key, result, DateTimeOffset.UtcNow.AddHours(1));
return(result);
}
catch (Exception e)
{
_logger.Error(e, "Failed to get recipes by category id {CategoryId} ", categoryId);
throw;
}
}
public void Test_AverageByMean()
{
calculator = new MeanCalculator();
double expected = 8.3636363;
double actual = calculator.CalculateAverage(values);
Assert.AreEqual(expected, actual, 0.000001);
Assert.AreEqual(expected, AverageCalculator.CalculateAverage(values, vls => vls.Sum() / vls.Count()), 0.000001);
Assert.AreEqual(expected, AverageCalculator.CalculateAverage(values, calculator), 0.000001);
}
private static async Task PreencherHistoricoMedias(
string symbol,
AverageCalculator mediaCurta,
AverageCalculator mediaLonga)
{
var client = new BinanceOrderClient();
var klinesResponse = await client.Klines(symbol, "1m", 25);
foreach (var kline in klinesResponse.Values)
{
mediaCurta.AddSample(kline.Close);
mediaLonga.AddSample(kline.Close);
}
}
public void OrderAfterResizeIsPreserved()
{
var calculator = new AverageCalculator(this.samples.Length + 10);
foreach (int sample in this.samples)
{
calculator.AddSample(sample);
}
List <int> lastFive = this.samples.Skip(this.samples.Length - 5).ToList();
calculator.SetMaxSamples(5);
Assert.Equal(5, calculator.GetMaxSamples());
Assert.True(this.DoubleEqual(lastFive.Average(), calculator.Average));
}
public void CanResizeCapacityWithRemovingSamples()
{
// Initialize with limit of 200.
var calculator = new AverageCalculator(200);
foreach (int sample in this.samples)
{
calculator.AddSample(sample);
}
// After that only last 5 samples should be used.
calculator.SetMaxSamples(5);
Assert.Equal(5, calculator.GetMaxSamples());
Assert.True(this.DoubleEqual(this.samples.Reverse().Take(5).Average(), calculator.Average));
}
public BlockPullerBehavior(IBlockPuller blockPuller, IInitialBlockDownloadState ibdState, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory)
{
this.ibdState = ibdState;
this.dateTimeProvider = dateTimeProvider;
this.QualityScore = SamplelessQualityScore;
this.averageSizeBytes = new AverageCalculator(IbdSamplesCount);
this.averageDelaySeconds = new AverageCalculator(IbdSamplesCount);
this.SpeedBytesPerSecond = 0;
this.lastDeliveryTime = null;
this.blockPuller = blockPuller;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.loggerFactory = loggerFactory;
}
public BlockPullerBehavior(IBlockPuller blockPuller, IInitialBlockDownloadState ibdState, ILoggerFactory loggerFactory)
{
this.ibdState = ibdState;
this.QualityScore = SamplelessQualityScore;
int samplesCount = ibdState.IsInitialBlockDownload() ? IbdSamplesCount : NormalSamplesCount;
this.averageSizeBytes = new AverageCalculator(samplesCount);
this.averageDelaySeconds = new AverageCalculator(samplesCount);
this.SpeedBytesPerSecond = 0;
this.blockPuller = blockPuller;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName, $"[{this.GetHashCode():x}] ");
this.loggerFactory = loggerFactory;
}
public void CanResizeCapacityWithoutRemovingSamples()
{
// Initialize with limit of 200.
var calculator = new AverageCalculator(200);
Assert.Equal(200, calculator.GetMaxSamples());
foreach (int sample in this.samples)
{
calculator.AddSample(sample);
}
calculator.SetMaxSamples(this.samples.Length);
Assert.Equal(this.samples.Length, calculator.GetMaxSamples());
Assert.True(this.DoubleEqual(this.samples.Average(), calculator.Average));
}
/// <summary>
/// Calculate the level average
/// </summary>
/// <param name="levelId"> level id</param>
private void CalculateLevelAverage(long levelId)
{
if (levelId == _levelDto.Id && _levelDto.Modules != null)
{
var average = 0.0;
double creditTotal = _levelDto.Modules.Sum(item => item.Credit);
for (int i = 0; i < _levelDto.Modules.Count; i++)
{
var module = _levelDto.Modules[i];
module.ModuleAverage = AverageCalculator.CalculateModuleAverage(module);
average += module.ModuleAverage * module.Credit / creditTotal;
}
LevelAverage = Double.Parse(average.ToString("n2"));
_levelDto.Average = Double.Parse(average.ToString("n2"));
_eventAggregator.GetEvent <SummaryCalculateEvent>().Publish();
}
}
public AddressIndexer(StoreSettings storeSettings, DataFolder dataFolder, ILoggerFactory loggerFactory, Network network, INodeStats nodeStats, IConsensusManager consensusManager, IAsyncProvider asyncProvider)
{
this.storeSettings = storeSettings;
this.network = network;
this.nodeStats = nodeStats;
this.dataFolder = dataFolder;
this.consensusManager = consensusManager;
this.asyncProvider = asyncProvider;
this.loggerFactory = loggerFactory;
this.scriptAddressReader = new ScriptAddressReader();
this.lockObject = new object();
this.flushChangesInterval = TimeSpan.FromMinutes(10);
this.lastFlushTime = DateTime.Now;
this.cancellation = new CancellationTokenSource();
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.averageTimePerBlock = new AverageCalculator(200);
}
public string GetSummary(User user, Subject subject)
{
if (subject == null)
{
return(null);
}
var grades = database.Grades
.Include(g => g.Student)
.Where(g => g.Student.Id == user.Id && g.Subject.Id == subject.Id)
.AsEnumerable()
.GroupBy(g => g.Semester);
string result = "";
foreach (var semester in grades)
{
result += $"Semester {semester.Key}: " +
$"{string.Join(", ", semester.Select(s => s.Value))}, " +
$"Average: {AverageCalculator.GetAverageForSubject(subject, semester.Key, semester.ToList()):F2}; "; // TODO localize
}
return(result.Trim(' ', ';'));
}
public void GivenACorrectCollectionIsProvidedThenTheCalculatorReturnsACorrectAverage()
{
var input = new List <ValueProviderMock>
{
new ValueProviderMock()
{
Value = 10
},
new ValueProviderMock()
{
Value = 6
},
new ValueProviderMock()
{
Value = 7
}
};
var expected = (10f + 6f + 7f) / 3;
float result = AverageCalculator.CalculateMeanAverage(input);
Assert.AreEqual(expected, result, 0.001f);
}
public bool TryToBeatPawn(PawnAdapter origin, PawnAdapter destination, List <PawnAdapter> bluePawns, List <PawnAdapter> redPawns)
{
int movedRows = MoveCalculator.CalculateMovedRows(origin, destination);
int movedColumns = MoveCalculator.CalculateMovedColumns(origin, destination);
if (RuleConfig.moveTwoRows == movedRows && RuleConfig.moveTwoColumns == Math.Abs(movedColumns))
{
AverageCalculator averageCalculator = new AverageCalculator();
int skippedColumn = averageCalculator.CalculateAverage(destination.Column(), origin.Column());
int skippedRow = averageCalculator.CalculateAverage(destination.Row(), origin.Row());
List <PawnAdapter> oppositeSide = origin.Player() == PlayerEnum.Red ? bluePawns : redPawns;
foreach (PawnAdapter oppositePawnAdapter in oppositeSide)
{
if (oppositePawnAdapter.Row() == skippedRow && oppositePawnAdapter.Column() == skippedColumn)
{
oppositePawnAdapter.Hide();
return(true);
}
}
}
return(false);
}
public void ResizeToSmallerSamplesCountKeepsTheRightSamples()
{
// Initialize with limit of 200.
var calculator = new AverageCalculator(200);
Assert.Equal(200, calculator.GetMaxSamples());
// Add 10,20,30
for (int i = 0; i < 3; i++)
{
calculator.AddSample(this.samples[i]);
}
// After that only 20,30 should be there
calculator.SetMaxSamples(2);
calculator.AddSample(40);
// There are 2 samples: 30 and 40
Assert.Equal(2, calculator.GetMaxSamples());
Assert.True(this.DoubleEqual(35, calculator.Average));
}
public BlockPuller(IChainState chainState, NodeSettings nodeSettings, IDateTimeProvider dateTimeProvider, INodeStats nodeStats, ILoggerFactory loggerFactory)
{
this.reassignedJobsQueue = new Queue <DownloadJob>();
this.downloadJobsQueue = new Queue <DownloadJob>();
this.assignedDownloadsByHash = new Dictionary <uint256, AssignedDownload>();
this.assignedDownloadsSorted = new LinkedList <AssignedDownload>();
this.assignedHeadersByPeerId = new Dictionary <int, List <ChainedHeader> >();
this.averageBlockSizeBytes = new AverageCalculator(AverageBlockSizeSamplesCount);
this.pullerBehaviorsByPeerId = new Dictionary <int, IBlockPullerBehavior>();
this.processQueuesSignal = new AsyncManualResetEvent(false);
this.queueLock = new object();
this.peerLock = new object();
this.assignedLock = new object();
this.nextJobId = 0;
this.networkPeerRequirement = new NetworkPeerRequirement
{
MinVersion = nodeSettings.MinProtocolVersion ?? nodeSettings.ProtocolVersion,
RequiredServices = NetworkPeerServices.Network
};
this.cancellationSource = new CancellationTokenSource();
this.random = new Random();
this.maxBlocksBeingDownloaded = MinimalCountOfBlocksBeingDownloaded;
this.chainState = chainState;
this.dateTimeProvider = dateTimeProvider;
this.logger = loggerFactory.CreateLogger("Impleum.Bitcoin.Fullnode");
nodeStats.RegisterStats(this.AddComponentStats, StatsType.Component);
}
public JumpMoveValidator()
{
AverageCalculator = new AverageCalculator();
MoveCalculator = new MoveCalculator();
}
public void Setup()
{
_numbers = new [] { 34, 21 };
_averageCalculator = new AverageCalculator(_numbers);
}
public StockAverageController(AverageCalculator averageCalculator)
{
_averageCalculator = averageCalculator;
}
