public async Task <int> RateMovieAsync(int movieId, int userId, int rating)
{
if (rating < 1 || rating > 5)
{
throw new InvalidRatingException(rating);
}
var movieGetter = movieRepository.Get(movieId);
var userGetter = userRepository.Get(userId);
if (await movieGetter == null)
{
throw new MovieNotFoundException(movieId);
}
if (await userGetter == null)
{
throw new UserNotFoundException(userId);
}
var ratingSavedResult = await movieRatingRepository.UpsertAsync(new MovieRating
{
MovieId = movieId,
UserId = userId,
Rating = rating
});
var ratings = await movieRatingRepository.GetByMovieId(movieId);
var roundedAverageRating = Rounder.Round(ratings.Average(x => x.Rating));
return(await movieRepository.UpdateAverageRating(movieId, roundedAverageRating));
}
public void Normalise64bit()
{
int oldBitLen = _significand.BitLength();
int sc = oldBitLen - C_64;
if (sc == 0)
{
return;
}
if (sc < 0)
{
throw new InvalidOperationException("Not enough precision");
}
_binaryExponent += sc;
if (sc > 32)
{
int highShift = (sc - 1) & 0xFFFFE0;
_significand = _significand >> (highShift);
sc -= highShift;
oldBitLen -= highShift;
}
if (sc < 1)
{
throw new InvalidOperationException();
}
_significand = Rounder.Round(_significand, sc);
if (_significand.BitLength() > oldBitLen)
{
sc++;
_binaryExponent++;
}
_significand = _significand >> (sc);
}
public void Round(double num, int expected)
{
var rounder = new Rounder();
var result = Rounder.Round(num);
Assert.Equal(expected, result);
}
public void RoundNumbers()
{
var rounder = new Rounder();
rounder.RoundUp(1.64).ShouldBe(2.00);
rounder.RoundDown(1.64).ShouldBe(1.00);
rounder.Round(1.64).ShouldBe(2.00);
}
public void Rounding_Test_Four_Round_up()
{
var result = Rounder.Round(1.251M);
Assert.AreEqual(1.30M, result);
}
public void Rounding_Test_Three_Should_Not_Round()
{
var result = Rounder.Round(1.25M);
Assert.AreEqual(1.25M, result);
}
public void Rounding_Test_Two_Round_up()
{
var result = Rounder.Round(1.221M);
Assert.AreEqual(1.25M, result);
}
public void When_Passed_Zero_Should_Return_Zero()
{
var result = Rounder.Round(0M);
Assert.AreEqual(0M, result);
}
public int DivideAndRound(int x, int y)
{
return(rounder.Round(x / y));
}
private void When_UsingARoundingAlgorithmCore(double value, RoundingAlgorithm roundingAlgorithm, double expected)
{
var rounded = Rounder.Round(value, 1, roundingAlgorithm);
Assert.AreEqual(expected, rounded);
}
public void When_UsingRoundMethod(double value, int digits, double expected)
{
var rounded = Rounder.Round(value, digits, RoundingAlgorithm.RoundHalfAwayFromZero);
Assert.AreEqual(expected, rounded);
}
public void GenerateStepsV2(float BPM, float Offset, int difficulty, bool RoundBeats)
{
BeatsPerMinute = BPM;
msTilStart = Offset * -1000;
List <float> Timings = new List <float>();
float Sensitivity = (100 - difficulty) / 100.0f;
float Max = Onsets.Max();
for (int i = 0; i < Onsets.Count; i += 1)
{
if (Onsets[i] > Max * Sensitivity)
{
Timings.Add(TimePerSample * i * 1000);
}
}
float MinutesPerBeat = 1 / BPM;
float MillisecondsPerMinute = 60000;
Measures = new List <Measure>();
float DistanceBetweenBeats = MinutesPerBeat * MillisecondsPerMinute;
var NotesInMeasure = Timings.Select(z => (int)(((Math.Round((z - msTilStart) / DistanceBetweenBeats * Measure.Resolution) / (float)BeatsPerMeasure)) + 1) % Measure.Resolution).ToList();
//var MeasureToPlace = Timings.Select(z => (int)((z - msTilStart) / DistanceBetweenBeats / BeatsPerMeasure)).ToList();
var MeasureToPlace = Timings.Select(z => (int)(((Math.Round((z - msTilStart) / DistanceBetweenBeats * Measure.Resolution) / (float)BeatsPerMeasure)) + 1) / Measure.Resolution).ToList();
//StepPattern pattern = StepPattern.StartsOnRight.GetRandom();
//int j = 0;
bool[,] lookup = new bool[Measure.Resolution, MeasureToPlace.Max() + 1];
Rounder rounder = new Rounder(0, 3, 4, 6, 8, 9, 12, 15, 16, 18, 20, 21, 24, 27, 28, 30, 32, 33, 36, 39, 40, 42, 44, 45);
//for (int i = 0; i < Timings.Count; i += 1)
//{
// int r = NotesInMeasure[i];
// if (RoundBeats)
// {
// r = rounder.Round(NotesInMeasure[i]);
// }
// if (r < 0 || MeasureToPlace[i] < 0) continue;
// if (lookup[r, MeasureToPlace[i]]) continue;
// while (MeasureToPlace[i] >= Measures.Count)
// {
// Measures.Add(new Measure());
// }
// if (j >= pattern.Steps.Count)
// {
// pattern = pattern.GetNextViablePattern();
// j = 0;
// }
// Measures[MeasureToPlace[i]].Steps[r] = pattern.Steps[j++];
// lookup[r, MeasureToPlace[i]] = true;
//}
int x = 0;
foreach (var step in StepPattern.StepStream(true))
{
restart:
if (x >= Timings.Count)
{
break;
}
int r = NotesInMeasure[x];
if (RoundBeats)
{
r = rounder.Round(NotesInMeasure[x]);
}
if (r < 0 || MeasureToPlace[x] < 0 || lookup[r, MeasureToPlace[x]])
{
x += 1;
goto restart;
}
while (MeasureToPlace[x] >= Measures.Count)
{
Measures.Add(new Measure());
}
Measures[MeasureToPlace[x]].Steps[r] = step;
lookup[r, MeasureToPlace[x]] = true;
}
}
public void Test_rounding(double input, double expected)
{
var actual = Rounder.Round(input);
actual.Should().Be(expected);
}