public NNResultsVisual(double width, double height, Tuple<Point, double, bool>[] values, bool shouldOutlineNonMatches) { #region Min/Max Value, Colors bool hasNegative = values.Any(o => o.Item2 < 0); double maxValue = Math.Max(Math.Abs(values.Min(o => o.Item2)), Math.Abs(values.Max(o => o.Item2))); if (maxValue < 1d) // should never be greater, but leave alone if it is { maxValue = 1d; } Color positiveColor = hasNegative ? Colors.Blue : Colors.Black; Color negativeColor = Colors.Red; #endregion #region XY Scale double radius = ((width + height) / 2) / 100; bool hasNegativePosition = values.Any(o => o.Item1.X < 0 || o.Item1.Y < 0); double maxX = Math.Max(Math.Abs(values.Min(o => o.Item1.X)), Math.Abs(values.Max(o => o.Item1.X))); double maxY = Math.Max(Math.Abs(values.Min(o => o.Item1.Y)), Math.Abs(values.Max(o => o.Item1.Y))); // If they are somewhat near 1, then cap at 1 if (maxX > .5 && maxX < 1) maxX = 1; if (maxY > .5 && maxY < 1) maxY = 1; double offsetX = hasNegativePosition ? (width / 2) : 0; double offsetY = hasNegativePosition ? (height / 2) : 0; double scaleX = maxX > 0d ? (width - offsetX) / maxX : 1; double scaleY = maxY > 0d ? (height - offsetY) / maxY : 1; #endregion Pen matchPen = new Pen(Brushes.Lime, radius * .32); Pen otherPen = shouldOutlineNonMatches ? new Pen(new SolidColorBrush(Color.FromArgb(192, 192, 192, 192)), radius * .18) : null; _visual = new DrawingVisual(); using (DrawingContext dc = _visual.RenderOpen()) { foreach (var value in values) { Color color = value.Item2 < 0 ? negativeColor : positiveColor; double alpha = Math.Abs(value.Item2) / maxValue; Color finalColor = Color.FromArgb(Convert.ToByte(alpha * 255), color.R, color.G, color.B); Point point = new Point(offsetX + (value.Item1.X * scaleX), offsetY + (value.Item1.Y * scaleY)); Pen pen = value.Item3 ? matchPen : otherPen; dc.DrawEllipse(new SolidColorBrush(finalColor), pen, point, radius, radius); } } }
public void ShortMinOnTwoTuple() { var sut = new Tuple<short, short>(1, 2); short expected = sut.AsEnumerable().Cast<short>().Min(); short actual = sut.Min(x => (short) x); Assert.AreEqual(expected, actual); }
public void IntegerMinOnTwoTuple() { var sut = new Tuple<int, int>(1, 2); int expected = sut.AsEnumerable().Cast<int>().Min(); int actual = sut.Min(x => (int) x); Assert.AreEqual(expected, actual); }
public void DecimalMinOnTwoTuple() { var sut = new Tuple<decimal, decimal>(1, 2); decimal expected = sut.AsEnumerable().Cast<decimal>().Min(); decimal actual = sut.Min(x => (decimal) x); Assert.AreEqual(expected, actual); }
public void DoubleMinOnTwoTuple() { var sut = new Tuple<double, double>(1, 2); double expected = sut.AsEnumerable().Cast<double>().Min(); double actual = sut.Min(x => (double) x); Assert.AreEqual(expected, actual); }
public void LongMinOnTwoTuple() { var sut = new Tuple<long, long>(1, 2); long expected = sut.AsEnumerable().Cast<long>().Min(); long actual = sut.Min(x => (long) x); Assert.AreEqual(expected, actual); }
public void ShortMinOnOneTuple() { var sut = new Tuple <short>(1); short expected = sut.AsEnumerable().Cast <short>().Min(); short actual = sut.Min(x => (short)x); Assert.AreEqual(expected, actual); }
public void IntegerMinOnOneTuple() { var sut = new Tuple <int>(1); int expected = sut.AsEnumerable().Cast <int>().Min(); int actual = sut.Min(x => (int)x); Assert.AreEqual(expected, actual); }
public void DoubleMinOnOneTuple() { var sut = new Tuple <double>(1); double expected = sut.AsEnumerable().Cast <double>().Min(); double actual = sut.Min(x => (double)x); Assert.AreEqual(expected, actual); }
public void LongMinOnOneTuple() { var sut = new Tuple <long>(1); long expected = sut.AsEnumerable().Cast <long>().Min(); long actual = sut.Min(x => (long)x); Assert.AreEqual(expected, actual); }
public void DecimalMinOnOneTuple() { var sut = new Tuple <decimal>(1); decimal expected = sut.AsEnumerable().Cast <decimal>().Min(); decimal actual = sut.Min(x => (decimal)x); Assert.AreEqual(expected, actual); }
static long Solve() { int n = int.Parse(Console.ReadLine()); Tuple <long, long>[] cost = new Tuple <long, long>[] { new Tuple <long, long>(-1, 0), new Tuple <long, long>(-1, 0), new Tuple <long, long>(-1, 0) }; for (int i = 0; i < n; i++) { var ab = Console.ReadLine().Split().Select(int.Parse).ToArray(); Tuple <long, long>[] newcost = new Tuple <long, long> [3]; for (int j = 0; j < 3; j++) { newcost[j] = new Tuple <long, long>(ab[0] + j, cost.Where(x => x.Item1 != ab[0] + j).Min(x => x.Item2) + ab[1] * j); } cost = newcost; } return(cost.Min(x => x.Item2)); }
internal static void Run() { if (string.IsNullOrEmpty(Endpoints)) { throw new ArgumentException("FhirEndpoints value is empty"); } endpoints = Endpoints.Split(";", StringSplitOptions.RemoveEmptyEntries).ToList(); var globalPrefix = $"RequestedBlobRange=[{NumberOfBlobsToSkip + 1}-{MaxBlobIndexForImport}]"; Console.WriteLine($"{globalPrefix}: Starting..."); var blobContainerClient = GetContainer(ConnectionString, ContainerName); var blobs = blobContainerClient.GetBlobs().OrderBy(_ => _.Name).Where(_ => _.Name.EndsWith(".ndjson", StringComparison.OrdinalIgnoreCase)).ToList(); Console.WriteLine($"Found ndjson blobs={blobs.Count} in {ContainerName}."); var take = MaxBlobIndexForImport == 0 ? blobs.Count : MaxBlobIndexForImport - NumberOfBlobsToSkip; blobs = blobs.Skip(NumberOfBlobsToSkip).Take(take).ToList(); var swWrites = Stopwatch.StartNew(); var swReport = Stopwatch.StartNew(); var currentBlobRanges = new Tuple <int, int> [ReadThreads]; BatchExtensions.ExecuteInParallelBatches(blobs, ReadThreads, BlobRangeSize, (reader, blobRangeInt) => { var localSw = Stopwatch.StartNew(); var writes = 0L; var blobRangeIndex = blobRangeInt.Item1; var blobsInt = blobRangeInt.Item2; var firstBlob = NumberOfBlobsToSkip + (blobRangeIndex * BlobRangeSize) + 1; var lastBlob = NumberOfBlobsToSkip + (blobRangeIndex * BlobRangeSize) + blobsInt.Count; currentBlobRanges[reader] = Tuple.Create(firstBlob, lastBlob); var prefix = $"Reader={reader}.BlobRange=[{firstBlob}-{lastBlob}]"; var incrementor = new IndexIncrementor(endpoints.Count); Console.WriteLine($"{prefix}: Starting..."); // 100 below is a compromise between processing with maximum available threads (value 1) and inefficiency in wrapping single resource in a list. BatchExtensions.ExecuteInParallelBatches(GetLinesInBlobRange(blobsInt, prefix), WriteThreads / ReadThreads, 100, (thread, lineBatch) => { Interlocked.Increment(ref writers); foreach (var line in lineBatch.Item2) { Interlocked.Increment(ref totalWrites); Interlocked.Increment(ref writes); PutResource(line, incrementor); if (swReport.Elapsed.TotalSeconds > ReportingPeriodSec) { lock (swReport) { if (swReport.Elapsed.TotalSeconds > ReportingPeriodSec) { var currWrites = Interlocked.Read(ref totalWrites); var currReads = Interlocked.Read(ref totalReads); var minBlob = currentBlobRanges.Min(_ => _.Item1); var maxBlob = currentBlobRanges.Max(_ => _.Item2); Console.WriteLine($"{globalPrefix}.WorkingBlobRange=[{minBlob}-{maxBlob}].Readers=[{Interlocked.Read(ref readers)}/{ReadThreads}].Writers=[{Interlocked.Read(ref writers)}].EndPointCalls=[{Interlocked.Read(ref epCalls)}].Waits=[{Interlocked.Read(ref waits)}]: reads={currReads} writes={currWrites} secs={(int)swWrites.Elapsed.TotalSeconds} read-speed={(int)(currReads / swReads.Elapsed.TotalSeconds)} lines/sec write-speed={(int)(currWrites / swWrites.Elapsed.TotalSeconds)} res/sec"); swReport.Restart(); } } } } Interlocked.Decrement(ref writers); }); Console.WriteLine($"{prefix}: Completed writes. Total={writes} secs={(int)localSw.Elapsed.TotalSeconds} speed={(int)(writes / localSw.Elapsed.TotalSeconds)} res/sec"); }); Console.WriteLine($"{globalPrefix}.Readers=[{readers}/{ReadThreads}].Writers=[{writers}].EndPointCalls=[{epCalls}].Waits=[{waits}]: total reads={totalReads} total writes={totalWrites} secs={(int)swWrites.Elapsed.TotalSeconds} read-speed={(int)(totalReads / swReads.Elapsed.TotalSeconds)} lines/sec write-speed={(int)(totalWrites / swWrites.Elapsed.TotalSeconds)} res/sec"); }